Make .claw the only user-facing config namespace

Agents, skills, and init output were still surfacing .codex/.claude paths even though the runtime already treats .claw as the canonical config home. This updates help text, reports, skill install defaults, and repo bootstrap output to present a single .claw namespace while keeping legacy discovery fallbacks in place for existing setups. Constraint: Existing .codex/.claude agent and skill directories still need to load for compatibility Rejected: Remove legacy discovery entirely | would break existing user setups instead of just cleaning up surfaced output Confidence: high Scope-risk: moderate Reversibility: clean Directive: Keep future user-facing config, agent, and skill path copy aligned to .claw and even when legacy fallbacks remain supported internally Tested: cargo fmt --all --check; cargo test --workspace --exclude compat-harness Not-tested: cargo clippy --workspace --all-targets -- -D warnings | fails in pre-existing unrelated runtime files (for example mcp_lifecycle_hardened.rs, mcp_tool_bridge.rs, lsp_client.rs, permission_enforcer.rs, recovery_recipes.rs, stale_branch.rs, task_registry.rs, team_cron_registry.rs, worker_boot.rs)
style: cargo fmt
2026-04-06 08:04:50 +08:00 · 2026-04-05 17:27:46 +00:00 · 2026-04-05 16:56:48 +00:00 · 2026-04-05 16:54:59 +00:00 · 2026-04-05 16:54:45 +00:00 · 2026-04-05 16:54:38 +00:00
29 changed files with 1233 additions and 324 deletions
--- a/PHILOSOPHY.md
+++ b/PHILOSOPHY.md
@@ -0,0 +1,114 @@
+# Claw Code Philosophy
+
+## Stop Staring at the Files
+
+If you only look at the generated files in this repository, you are looking at the wrong layer.
+
+The Python rewrite was a byproduct. The Rust rewrite was also a byproduct. The real thing worth studying is the **system that produced them**: a clawhip-based coordination loop where humans give direction and autonomous claws execute the work.
+
+Claw Code is not just a codebase. It is a public demonstration of what happens when:
+
+- a human provides clear direction,
+- multiple coding agents coordinate in parallel,
+- notification routing is pushed out of the agent context window,
+- planning, execution, review, and retry loops are automated,
+- and the human does **not** sit in a terminal micromanaging every step.
+
+## The Human Interface Is Discord
+
+The important interface here is not tmux, Vim, SSH, or a terminal multiplexer.
+
+The real human interface is a Discord channel.
+
+A person can type a sentence from a phone, walk away, sleep, or do something else. The claws read the directive, break it into tasks, assign roles, write code, run tests, argue over failures, recover, and push when the work passes.
+
+That is the philosophy: **humans set direction; claws perform the labor.**
+
+## The Three-Part System
+
+### 1. OmX (`oh-my-codex`)
+[oh-my-codex](https://github.com/Yeachan-Heo/oh-my-codex) provides the workflow layer.
+
+It turns short directives into structured execution:
+- planning keywords
+- execution modes
+- persistent verification loops
+- parallel multi-agent workflows
+
+This is the layer that converts a sentence into a repeatable work protocol.
+
+### 2. clawhip
+[clawhip](https://github.com/Yeachan-Heo/clawhip) is the event and notification router.
+
+It watches:
+- git commits
+- tmux sessions
+- GitHub issues and PRs
+- agent lifecycle events
+- channel delivery
+
+Its job is to keep monitoring and delivery **outside** the coding agent's context window so the agents can stay focused on implementation instead of status formatting and notification routing.
+
+### 3. OmO (`oh-my-openagent`)
+[oh-my-openagent](https://github.com/code-yeongyu/oh-my-openagent) handles multi-agent coordination.
+
+This is where planning, handoffs, disagreement resolution, and verification loops happen across agents.
+
+When Architect, Executor, and Reviewer disagree, OmO provides the structure for that loop to converge instead of collapse.
+
+## The Real Bottleneck Changed
+
+The bottleneck is no longer typing speed.
+
+When agent systems can rebuild a codebase in hours, the scarce resource becomes:
+- architectural clarity
+- task decomposition
+- judgment
+- taste
+- conviction about what is worth building
+- knowing which parts can be parallelized and which parts must stay constrained
+
+A fast agent team does not remove the need for thinking. It makes clear thinking even more valuable.
+
+## What Claw Code Demonstrates
+
+Claw Code demonstrates that a repository can be:
+
+- **autonomously built in public**
+- coordinated by claws/lobsters rather than human pair-programming alone
+- operated through a chat interface
+- continuously improved by structured planning/execution/review loops
+- maintained as a showcase of the coordination layer, not just the output files
+
+The code is evidence.
+The coordination system is the product lesson.
+
+## What Still Matters
+
+As coding intelligence gets cheaper and more available, the durable differentiators are not raw coding output.
+
+What still matters:
+- product taste
+- direction
+- system design
+- human trust
+- operational stability
+- judgment about what to build next
+
+In that world, the job of the human is not to out-type the machine.
+The job of the human is to decide what deserves to exist.
+
+## Short Version
+
+**Claw Code is a demo of autonomous software development.**
+
+Humans provide direction.
+Claws coordinate, build, test, recover, and push.
+The repository is the artifact.
+The philosophy is the system behind it.
+
+## Related explanation
+
+For the longer public explanation behind this philosophy, see:
+
+- https://x.com/realsigridjin/status/2039472968624185713
--- a/README.md
+++ b/README.md
@@ -5,11 +5,11 @@
 </p>

 <p align="center">
-  <a href="https://star-history.com/#instructkr/claw-code&Date">
+  <a href="https://star-history.com/#ultraworkers/claw-code&Date">
    <picture>
-      <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=instructkr/claw-code&type=Date&theme=dark" />
-      <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=instructkr/claw-code&type=Date" />
-      <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=instructkr/claw-code&type=Date" width="600" />
+      <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=ultraworkers/claw-code&type=Date&theme=dark" />
+      <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=ultraworkers/claw-code&type=Date" />
+      <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=ultraworkers/claw-code&type=Date" width="600" />
    </picture>
  </a>
 </p>
@@ -19,48 +19,42 @@
 </p>

 <p align="center">
-  <strong>Better Harness Tools, not merely storing the archive of leaked Claude Code</strong>
+  <strong>Autonomously maintained by lobsters/claws — not by human hands</strong>
 </p>

 <p align="center">
-  <a href="https://github.com/sponsors/instructkr"><img src="https://img.shields.io/badge/Sponsor-%E2%9D%A4-pink?logo=github&style=for-the-badge" alt="Sponsor on GitHub" /></a>
+  <a href="https://github.com/Yeachan-Heo/clawhip">clawhip</a> ·
+  <a href="https://github.com/code-yeongyu/oh-my-openagent">oh-my-openagent</a> ·
+  <a href="https://github.com/Yeachan-Heo/oh-my-claudecode">oh-my-claudecode</a> ·
+  <a href="https://github.com/Yeachan-Heo/oh-my-codex">oh-my-codex</a> ·
+  <a href="https://discord.gg/6ztZB9jvWq">UltraWorkers Discord</a>
 </p>

 > [!IMPORTANT]
 > The active Rust workspace now lives in [`rust/`](./rust). Start with [`USAGE.md`](./USAGE.md) for build, auth, CLI, session, and parity-harness workflows, then use [`rust/README.md`](./rust/README.md) for crate-level details.

-> If you find this work useful, consider [sponsoring @instructkr on GitHub](https://github.com/sponsors/instructkr) to support continued open-source harness engineering research.
+> Want the bigger idea behind this repo? Read [`PHILOSOPHY.md`](./PHILOSOPHY.md) and Sigrid Jin's public explanation: https://x.com/realsigridjin/status/2039472968624185713
+
+> Shout-out to the UltraWorkers ecosystem powering this repo: [clawhip](https://github.com/Yeachan-Heo/clawhip), [oh-my-openagent](https://github.com/code-yeongyu/oh-my-openagent), [oh-my-claudecode](https://github.com/Yeachan-Heo/oh-my-claudecode), [oh-my-codex](https://github.com/Yeachan-Heo/oh-my-codex), and the [UltraWorkers Discord](https://discord.gg/6ztZB9jvWq).

 ---

 ## Backstory

-At 4 AM on March 31, 2026, I woke up to my phone blowing up with notifications. The Claude Code source had been exposed, and the entire dev community was in a frenzy. My girlfriend in Korea was genuinely worried I might face legal action from Anthropic just for having the code on my machine — so I did what any engineer would do under pressure: I sat down, ported the core features to Python from scratch, and pushed it before the sun came up.
+This repo is maintained by **lobsters/claws**, not by a conventional human-only dev team.

-The whole thing was orchestrated end-to-end using [oh-my-codex (OmX)](https://github.com/Yeachan-Heo/oh-my-codex) by [@bellman_ych](https://x.com/bellman_ych) — a workflow layer built on top of OpenAI's Codex ([@OpenAIDevs](https://x.com/OpenAIDevs)). I used `$team` mode for parallel code review and `$ralph` mode for persistent execution loops with architect-level verification. The entire porting session — from reading the original harness structure to producing a working Python tree with tests — was driven through OmX orchestration.
+The people behind the system are [Bellman / Yeachan Heo](https://github.com/Yeachan-Heo) and friends like [Yeongyu](https://github.com/code-yeongyu), but the repo itself is being pushed forward by autonomous claw workflows: parallel coding sessions, event-driven orchestration, recovery loops, and machine-readable lane state.

-The result is a clean-room Python rewrite that captures the architectural patterns of Claude Code's agent harness without copying any proprietary source. I'm now actively collaborating with [@bellman_ych](https://x.com/bellman_ych) — the creator of OmX himself — to push this further. The basic Python foundation is already in place and functional, but we're just getting started. **Stay tuned — a much more capable version is on the way.**
+In practice, that means this project is not just *about* coding agents — it is being **actively built by them**. Features, tests, telemetry, docs, and workflow hardening are landed through claw-driven loops using [clawhip](https://github.com/Yeachan-Heo/clawhip), [oh-my-openagent](https://github.com/code-yeongyu/oh-my-openagent), [oh-my-claudecode](https://github.com/Yeachan-Heo/oh-my-claudecode), and [oh-my-codex](https://github.com/Yeachan-Heo/oh-my-codex).

-https://github.com/instructkr/claw-code
+This repository exists to prove that an open coding harness can be built **autonomously, in public, and at high velocity** — with humans setting direction and claws doing the grinding.
+
+See the public build story here:
+
+https://x.com/realsigridjin/status/2039472968624185713

 ![Tweet screenshot](assets/tweet-screenshot.png)

-## The Creators Featured in Wall Street Journal For Avid Claude Code Fans
-
-I've been deeply interested in **harness engineering** — studying how agent systems wire tools, orchestrate tasks, and manage runtime context. This isn't a sudden thing. The Wall Street Journal featured my work earlier this month, documenting how I've been one of the most active power users exploring these systems:
-
-> AI startup worker Sigrid Jin, who attended the Seoul dinner, single-handedly used 25 billion of Claude Code tokens last year. At the time, usage limits were looser, allowing early enthusiasts to reach tens of billions of tokens at a very low cost.
->
-> Despite his countless hours with Claude Code, Jin isn't faithful to any one AI lab. The tools available have different strengths and weaknesses, he said. Codex is better at reasoning, while Claude Code generates cleaner, more shareable code.
->
-> Jin flew to San Francisco in February for Claude Code's first birthday party, where attendees waited in line to compare notes with Cherny. The crowd included a practicing cardiologist from Belgium who had built an app to help patients navigate care, and a California lawyer who made a tool for automating building permit approvals using Claude Code.
->
-> "It was basically like a sharing party," Jin said. "There were lawyers, there were doctors, there were dentists. They did not have software engineering backgrounds."
->
-> — *The Wall Street Journal*, March 21, 2026, [*"The Trillion Dollar Race to Automate Our Entire Lives"*](https://lnkd.in/gs9td3qd)
-
-![WSJ Feature](assets/wsj-feature.png)
-
 ---

 ## Porting Status
@@ -174,12 +168,12 @@ The restructuring and documentation work on this repository was AI-assisted and
 ## Community

 <p align="center">
-  <a href="https://instruct.kr/"><img src="assets/instructkr.png" alt="instructkr" width="400" /></a>
+  <a href="https://discord.gg/6ztZB9jvWq"><img src="https://img.shields.io/badge/UltraWorkers-Discord-5865F2?logo=discord&style=for-the-badge" alt="UltraWorkers Discord" /></a>
 </p>

-Join the [**instructkr Discord**](https://instruct.kr/) — the best Korean language model community. Come chat about LLMs, harness engineering, agent workflows, and everything in between.
+Join the [**UltraWorkers Discord**](https://discord.gg/6ztZB9jvWq) — the community around clawhip, oh-my-openagent, oh-my-claudecode, oh-my-codex, and claw-code. Come chat about LLMs, harness engineering, agent workflows, and autonomous software development.

-[![Discord](https://img.shields.io/badge/Join%20Discord-instruct.kr-5865F2?logo=discord&style=for-the-badge)](https://instruct.kr/)
+[![Discord](https://img.shields.io/badge/Join%20Discord-UltraWorkers-5865F2?logo=discord&style=for-the-badge)](https://discord.gg/6ztZB9jvWq)

 ## Star History

--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -272,6 +272,18 @@ Priority order: P0 = blocks CI/green state, P1 = blocks integration wiring, P2 =

 **P0 — Fix first (CI reliability)**
 1. Isolate `render_diff_report` tests into tmpdir — flaky under `cargo test --workspace`; reads real working-tree state; breaks CI during active worktree ops
+2. Expand GitHub CI from single-crate coverage to workspace-grade verification — current `rust-ci.yml` runs `cargo fmt` and `cargo test -p rusty-claude-cli`, but misses broader `cargo test --workspace` coverage that already passes locally
+3. Add release-grade binary workflow — repo has a Rust CLI and release intent, but no GitHub Actions path that builds tagged artifacts / checks release packaging before a publish step
+4. Add container-first test/run docs — runtime detects Docker/Podman/container state, but docs do not show a canonical container workflow for `cargo test --workspace`, binary execution, or bind-mounted repo usage
+5. Surface `doctor` / preflight diagnostics in onboarding docs and help — the CLI already has setup-diagnosis commands and branch preflight machinery, but they are not prominent enough in README/USAGE, so new users still ask manual setup questions instead of running a built-in health check first
+6. Add branding/source-of-truth residue checks for docs — after repo migration, old org names can survive in badges, star-history URLs, and copied snippets; docs need a consistency pass or CI lint to catch stale branding automatically
+7. Reconcile README product narrative with current repo reality — top-level docs now say the active workspace is Rust, but later sections still describe the repo as Python-first; users should not have to infer which implementation is canonical
+8. Eliminate warning spam from first-run help/build path — `cargo run -p rusty-claude-cli -- --help` currently prints a wall of compile warnings before the actual help text, which pollutes the first-touch UX and hides the product surface behind unrelated noise
+9. Promote `doctor` from slash-only to top-level CLI entrypoint — users naturally try `claw doctor`, but today it errors and tells them to enter a REPL or resume path first; healthcheck flows should be callable directly from the shell
+10. Make machine-readable status commands actually machine-readable — `status` and `sandbox` accept the global `--output-format json` flag path, but currently still render prose tables, which breaks shell automation and agent-friendly health polling
+11. Unify legacy config/skill namespaces in user-facing output — `skills` currently surfaces mixed project roots like `.codex` and `.claude`, which leaks historical layers into the current product and makes it unclear which config namespace is canonical
+12. Honor JSON output on inventory commands like `skills` and `mcp` — these are exactly the commands agents and shell scripts want to inspect programmatically, but `--output-format json` still yields prose, forcing text scraping where structured inventory should exist
+13. Audit `--output-format` contract across the whole CLI surface — current behavior is inconsistent by subcommand, so agents cannot trust the global flag without command-by-command probing; the format contract itself needs to become deterministic

 **P1 — Next (integration wiring, unblocks verification)**
 2. Add cross-module integration tests — **done**: 12 integration tests covering worker→recovery→policy, stale_branch→policy, green_contract→policy, reconciliation flows
@@ -291,8 +303,14 @@ Priority order: P0 = blocks CI/green state, P1 = blocks integration wiring, P2 =
 14. **Config merge validation gap** — **done**: `config.rs` hook validation before deep-merge (+56 lines), malformed entries fail with source-path context instead of merged parse errors
 15. **MCP manager discovery flaky test** — `manager_discovery_report_keeps_healthy_servers_when_one_server_fails` has intermittent timing issues in CI; temporarily ignored, needs root cause fix

+16. **Commit provenance / worktree-aware push events** — clawhip build stream shows duplicate-looking commit messages and worktree-originated pushes without clear supersession indicators; add worktree/branch metadata to push events and de-dup superseded commits in build stream display
+17. **Orphaned module integration audit** — `session_control` is `pub mod` exported from `runtime` but has zero consumers across the entire workspace (no import, no call site outside its own file). `trust_resolver` types are re-exported from `lib.rs` but never instantiated outside unit tests. These modules implement core clawability contracts (session management, trust resolution) that are structurally dead — built but not wired into the CLI or tools crate. **Action:** audit all `pub mod` / `pub use` exports from `runtime` for actual call sites; either wire orphaned modules into the real execution path or demote to `pub(crate)` / `cfg(test)` to prevent false clawability surface.
+18. **Context-window preflight gap** — claw-code auto-compacts only after cumulative input crosses a static `100_000`-token threshold, while provider requests derive `max_tokens` from a naive model-name heuristic (`opus` => 32k, else 64k) and do not appear to preflight `estimated_prompt_tokens + requested_output_tokens` against the selected model’s actual context window. Result: giant sessions can be sent upstream and fail hard with provider-side `input_exceeds_context_by_*` errors instead of local preflight compaction/rejection. **Action:** add a model-context registry + request-size preflight before provider call; if projected request exceeds context, emit a structured `context_window_blocked` event and auto-compact or force `/compact` before retry.
+19. **Subcommand help falls through into runtime/API path** — direct dogfood shows `./target/debug/claw doctor --help` and `./target/debug/claw status --help` do not render local subcommand help. Instead they enter the request path, show `🦀 Thinking...`, then fail with `api returned 500 ... auth_unavailable: no auth available`. Help/usage surfaces must be pure local parsing and never require auth or provider reachability. **Action:** fix argv dispatch so `<subcommand> --help` is intercepted before runtime startup/API client initialization; add regression tests for `doctor --help`, `status --help`, and similar local-info commands.
+
 **P3 — Swarm efficiency**
 13. Swarm branch-lock protocol — detect same-module/same-branch collision before parallel workers drift into duplicate implementation
+14. Commit provenance / worktree-aware push events — emit branch, worktree, superseded-by, and canonical commit lineage so parallel sessions stop producing duplicate-looking push summaries

 ## Suggested Session Split

--- a/assets/sigrid-photo.png
+++ b/assets/sigrid-photo.png
--- a/rust/.claw/sessions/session-1775386832313-0.jsonl
+++ b/rust/.claw/sessions/session-1775386832313-0.jsonl
@@ -0,0 +1,2 @@
+{"created_at_ms":1775386832313,"session_id":"session-1775386832313-0","type":"session_meta","updated_at_ms":1775386832313,"version":1}
+{"message":{"blocks":[{"text":"status --help","type":"text"}],"role":"user"},"type":"message"}
--- a/rust/.claw/sessions/session-1775386842352-0.jsonl
+++ b/rust/.claw/sessions/session-1775386842352-0.jsonl
@@ -0,0 +1,2 @@
+{"created_at_ms":1775386842352,"session_id":"session-1775386842352-0","type":"session_meta","updated_at_ms":1775386842352,"version":1}
+{"message":{"blocks":[{"text":"doctor --help","type":"text"}],"role":"user"},"type":"message"}
--- a/rust/.claw/sessions/session-1775386852257-0.jsonl
+++ b/rust/.claw/sessions/session-1775386852257-0.jsonl
@@ -0,0 +1,2 @@
+{"created_at_ms":1775386852257,"session_id":"session-1775386852257-0","type":"session_meta","updated_at_ms":1775386852257,"version":1}
+{"message":{"blocks":[{"text":"doctor --help","type":"text"}],"role":"user"},"type":"message"}
--- a/rust/.claw/sessions/session-1775386853666-0.jsonl
+++ b/rust/.claw/sessions/session-1775386853666-0.jsonl
@@ -0,0 +1,2 @@
+{"created_at_ms":1775386853666,"session_id":"session-1775386853666-0","type":"session_meta","updated_at_ms":1775386853666,"version":1}
+{"message":{"blocks":[{"text":"status --help","type":"text"}],"role":"user"},"type":"message"}
--- a/rust/crates/api/src/error.rs
+++ b/rust/crates/api/src/error.rs
@@ -8,6 +8,13 @@ pub enum ApiError {
        provider: &'static str,
        env_vars: &'static [&'static str],
    },
+    ContextWindowExceeded {
+        model: String,
+        estimated_input_tokens: u32,
+        requested_output_tokens: u32,
+        estimated_total_tokens: u32,
+        context_window_tokens: u32,
+    },
    ExpiredOAuthToken,
    Auth(String),
    InvalidApiKeyEnv(VarError),
@@ -48,6 +55,7 @@ impl ApiError {
            Self::Api { retryable, .. } => *retryable,
            Self::RetriesExhausted { last_error, .. } => last_error.is_retryable(),
            Self::MissingCredentials { .. }
+            | Self::ContextWindowExceeded { .. }
            | Self::ExpiredOAuthToken
            | Self::Auth(_)
            | Self::InvalidApiKeyEnv(_)
@@ -67,6 +75,16 @@ impl Display for ApiError {
                "missing {provider} credentials; export {} before calling the {provider} API",
                env_vars.join(" or ")
            ),
+            Self::ContextWindowExceeded {
+                model,
+                estimated_input_tokens,
+                requested_output_tokens,
+                estimated_total_tokens,
+                context_window_tokens,
+            } => write!(
+                f,
+                "context_window_blocked for {model}: estimated input {estimated_input_tokens} + requested output {requested_output_tokens} = {estimated_total_tokens} tokens exceeds the {context_window_tokens}-token context window; compact the session or reduce request size before retrying"
+            ),
            Self::ExpiredOAuthToken => {
                write!(
                    f,
--- a/rust/crates/api/src/providers/anthropic.rs
+++ b/rust/crates/api/src/providers/anthropic.rs
@@ -14,7 +14,7 @@ use telemetry::{AnalyticsEvent, AnthropicRequestProfile, ClientIdentity, Session
 use crate::error::ApiError;
 use crate::prompt_cache::{PromptCache, PromptCacheRecord, PromptCacheStats};

-use super::{Provider, ProviderFuture};
+use super::{preflight_message_request, Provider, ProviderFuture};
 use crate::sse::SseParser;
 use crate::types::{MessageDeltaEvent, MessageRequest, MessageResponse, StreamEvent, Usage};

@@ -294,6 +294,8 @@ impl AnthropicClient {
            }
        }

+        preflight_message_request(&request)?;
+
        let response = self.send_with_retry(&request).await?;
        let request_id = request_id_from_headers(response.headers());
        let mut response = response
@@ -337,6 +339,7 @@ impl AnthropicClient {
        &self,
        request: &MessageRequest,
    ) -> Result<MessageStream, ApiError> {
+        preflight_message_request(request)?;
        let response = self
            .send_with_retry(&request.clone().with_streaming())
            .await?;
--- a/rust/crates/api/src/providers/mod.rs
+++ b/rust/crates/api/src/providers/mod.rs
@@ -1,14 +1,18 @@
 use std::future::Future;
 use std::pin::Pin;

+use serde::Serialize;
+
 use crate::error::ApiError;
 use crate::types::{MessageRequest, MessageResponse};

 pub mod anthropic;
 pub mod openai_compat;

+#[allow(dead_code)]
 pub type ProviderFuture<'a, T> = Pin<Box<dyn Future<Output = Result<T, ApiError>> + Send + 'a>>;

+#[allow(dead_code)]
 pub trait Provider {
    type Stream;

@@ -38,6 +42,12 @@ pub struct ProviderMetadata {
    pub default_base_url: &'static str,
 }

+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ModelTokenLimit {
+    pub max_output_tokens: u32,
+    pub context_window_tokens: u32,
+}
+
 const MODEL_REGISTRY: &[(&str, ProviderMetadata)] = &[
    (
        "opus",
@@ -180,17 +190,86 @@ pub fn detect_provider_kind(model: &str) -> ProviderKind {

 #[must_use]
 pub fn max_tokens_for_model(model: &str) -> u32 {
+    model_token_limit(model).map_or_else(
+        || {
+            let canonical = resolve_model_alias(model);
+            if canonical.contains("opus") {
+                32_000
+            } else {
+                64_000
+            }
+        },
+        |limit| limit.max_output_tokens,
+    )
+}
+
+#[must_use]
+pub fn model_token_limit(model: &str) -> Option<ModelTokenLimit> {
    let canonical = resolve_model_alias(model);
-    if canonical.contains("opus") {
-        32_000
-    } else {
-        64_000
+    match canonical.as_str() {
+        "claude-opus-4-6" => Some(ModelTokenLimit {
+            max_output_tokens: 32_000,
+            context_window_tokens: 200_000,
+        }),
+        "claude-sonnet-4-6" | "claude-haiku-4-5-20251213" => Some(ModelTokenLimit {
+            max_output_tokens: 64_000,
+            context_window_tokens: 200_000,
+        }),
+        "grok-3" | "grok-3-mini" => Some(ModelTokenLimit {
+            max_output_tokens: 64_000,
+            context_window_tokens: 131_072,
+        }),
+        _ => None,
    }
 }

+pub fn preflight_message_request(request: &MessageRequest) -> Result<(), ApiError> {
+    let Some(limit) = model_token_limit(&request.model) else {
+        return Ok(());
+    };
+
+    let estimated_input_tokens = estimate_message_request_input_tokens(request);
+    let estimated_total_tokens = estimated_input_tokens.saturating_add(request.max_tokens);
+    if estimated_total_tokens > limit.context_window_tokens {
+        return Err(ApiError::ContextWindowExceeded {
+            model: resolve_model_alias(&request.model),
+            estimated_input_tokens,
+            requested_output_tokens: request.max_tokens,
+            estimated_total_tokens,
+            context_window_tokens: limit.context_window_tokens,
+        });
+    }
+
+    Ok(())
+}
+
+fn estimate_message_request_input_tokens(request: &MessageRequest) -> u32 {
+    let mut estimate = estimate_serialized_tokens(&request.messages);
+    estimate = estimate.saturating_add(estimate_serialized_tokens(&request.system));
+    estimate = estimate.saturating_add(estimate_serialized_tokens(&request.tools));
+    estimate = estimate.saturating_add(estimate_serialized_tokens(&request.tool_choice));
+    estimate
+}
+
+fn estimate_serialized_tokens<T: Serialize>(value: &T) -> u32 {
+    serde_json::to_vec(value)
+        .ok()
+        .map_or(0, |bytes| (bytes.len() / 4 + 1) as u32)
+}
+
 #[cfg(test)]
 mod tests {
-    use super::{detect_provider_kind, max_tokens_for_model, resolve_model_alias, ProviderKind};
+    use serde_json::json;
+
+    use crate::error::ApiError;
+    use crate::types::{
+        InputContentBlock, InputMessage, MessageRequest, ToolChoice, ToolDefinition,
+    };
+
+    use super::{
+        detect_provider_kind, max_tokens_for_model, model_token_limit, preflight_message_request,
+        resolve_model_alias, ProviderKind,
+    };

    #[test]
    fn resolves_grok_aliases() {
@@ -213,4 +292,86 @@ mod tests {
        assert_eq!(max_tokens_for_model("opus"), 32_000);
        assert_eq!(max_tokens_for_model("grok-3"), 64_000);
    }
+
+    #[test]
+    fn returns_context_window_metadata_for_supported_models() {
+        assert_eq!(
+            model_token_limit("claude-sonnet-4-6")
+                .expect("claude-sonnet-4-6 should be registered")
+                .context_window_tokens,
+            200_000
+        );
+        assert_eq!(
+            model_token_limit("grok-mini")
+                .expect("grok-mini should resolve to a registered model")
+                .context_window_tokens,
+            131_072
+        );
+    }
+
+    #[test]
+    fn preflight_blocks_requests_that_exceed_the_model_context_window() {
+        let request = MessageRequest {
+            model: "claude-sonnet-4-6".to_string(),
+            max_tokens: 64_000,
+            messages: vec![InputMessage {
+                role: "user".to_string(),
+                content: vec![InputContentBlock::Text {
+                    text: "x".repeat(600_000),
+                }],
+            }],
+            system: Some("Keep the answer short.".to_string()),
+            tools: Some(vec![ToolDefinition {
+                name: "weather".to_string(),
+                description: Some("Fetches weather".to_string()),
+                input_schema: json!({
+                    "type": "object",
+                    "properties": { "city": { "type": "string" } },
+                }),
+            }]),
+            tool_choice: Some(ToolChoice::Auto),
+            stream: true,
+        };
+
+        let error = preflight_message_request(&request)
+            .expect_err("oversized request should be rejected before the provider call");
+
+        match error {
+            ApiError::ContextWindowExceeded {
+                model,
+                estimated_input_tokens,
+                requested_output_tokens,
+                estimated_total_tokens,
+                context_window_tokens,
+            } => {
+                assert_eq!(model, "claude-sonnet-4-6");
+                assert!(estimated_input_tokens > 136_000);
+                assert_eq!(requested_output_tokens, 64_000);
+                assert!(estimated_total_tokens > context_window_tokens);
+                assert_eq!(context_window_tokens, 200_000);
+            }
+            other => panic!("expected context-window preflight failure, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn preflight_skips_unknown_models() {
+        let request = MessageRequest {
+            model: "unknown-model".to_string(),
+            max_tokens: 64_000,
+            messages: vec![InputMessage {
+                role: "user".to_string(),
+                content: vec![InputContentBlock::Text {
+                    text: "x".repeat(600_000),
+                }],
+            }],
+            system: None,
+            tools: None,
+            tool_choice: None,
+            stream: false,
+        };
+
+        preflight_message_request(&request)
+            .expect("models without context metadata should skip the guarded preflight");
+    }
 }
--- a/rust/crates/api/src/providers/openai_compat.rs
+++ b/rust/crates/api/src/providers/openai_compat.rs
@@ -12,7 +12,7 @@ use crate::types::{
    ToolChoice, ToolDefinition, ToolResultContentBlock, Usage,
 };

-use super::{Provider, ProviderFuture};
+use super::{preflight_message_request, Provider, ProviderFuture};

 pub const DEFAULT_XAI_BASE_URL: &str = "https://api.x.ai/v1";
 pub const DEFAULT_OPENAI_BASE_URL: &str = "https://api.openai.com/v1";
@@ -128,6 +128,7 @@ impl OpenAiCompatClient {
            stream: false,
            ..request.clone()
        };
+        preflight_message_request(&request)?;
        let response = self.send_with_retry(&request).await?;
        let request_id = request_id_from_headers(response.headers());
        let payload = response.json::<ChatCompletionResponse>().await?;
@@ -142,6 +143,7 @@ impl OpenAiCompatClient {
        &self,
        request: &MessageRequest,
    ) -> Result<MessageStream, ApiError> {
+        preflight_message_request(request)?;
        let response = self
            .send_with_retry(&request.clone().with_streaming())
            .await?;
--- a/rust/crates/api/tests/client_integration.rs
+++ b/rust/crates/api/tests/client_integration.rs
@@ -103,6 +103,41 @@ async fn send_message_posts_json_and_parses_response() {
    );
 }

+#[tokio::test]
+async fn send_message_blocks_oversized_requests_before_the_http_call() {
+    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
+    let server = spawn_server(
+        state.clone(),
+        vec![http_response("200 OK", "application/json", "{}")],
+    )
+    .await;
+
+    let client = AnthropicClient::new("test-key").with_base_url(server.base_url());
+    let error = client
+        .send_message(&MessageRequest {
+            model: "claude-sonnet-4-6".to_string(),
+            max_tokens: 64_000,
+            messages: vec![InputMessage {
+                role: "user".to_string(),
+                content: vec![InputContentBlock::Text {
+                    text: "x".repeat(600_000),
+                }],
+            }],
+            system: Some("Keep the answer short.".to_string()),
+            tools: None,
+            tool_choice: None,
+            stream: false,
+        })
+        .await
+        .expect_err("oversized request should fail local context-window preflight");
+
+    assert!(matches!(error, ApiError::ContextWindowExceeded { .. }));
+    assert!(
+        state.lock().await.is_empty(),
+        "preflight failure should avoid any upstream HTTP request"
+    );
+}
+
 #[tokio::test]
 async fn send_message_applies_request_profile_and_records_telemetry() {
    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
--- a/rust/crates/api/tests/openai_compat_integration.rs
+++ b/rust/crates/api/tests/openai_compat_integration.rs
@@ -4,10 +4,10 @@ use std::sync::Arc;
 use std::sync::{Mutex as StdMutex, OnceLock};

 use api::{
-    ContentBlockDelta, ContentBlockDeltaEvent, ContentBlockStartEvent, ContentBlockStopEvent,
-    InputContentBlock, InputMessage, MessageDeltaEvent, MessageRequest, OpenAiCompatClient,
-    OpenAiCompatConfig, OutputContentBlock, ProviderClient, StreamEvent, ToolChoice,
-    ToolDefinition,
+    ApiError, ContentBlockDelta, ContentBlockDeltaEvent, ContentBlockStartEvent,
+    ContentBlockStopEvent, InputContentBlock, InputMessage, MessageDeltaEvent, MessageRequest,
+    OpenAiCompatClient, OpenAiCompatConfig, OutputContentBlock, ProviderClient, StreamEvent,
+    ToolChoice, ToolDefinition,
 };
 use serde_json::json;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
@@ -63,6 +63,42 @@ async fn send_message_uses_openai_compatible_endpoint_and_auth() {
    assert_eq!(body["tools"][0]["type"], json!("function"));
 }

+#[tokio::test]
+async fn send_message_blocks_oversized_xai_requests_before_the_http_call() {
+    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
+    let server = spawn_server(
+        state.clone(),
+        vec![http_response("200 OK", "application/json", "{}")],
+    )
+    .await;
+
+    let client = OpenAiCompatClient::new("xai-test-key", OpenAiCompatConfig::xai())
+        .with_base_url(server.base_url());
+    let error = client
+        .send_message(&MessageRequest {
+            model: "grok-3".to_string(),
+            max_tokens: 64_000,
+            messages: vec![InputMessage {
+                role: "user".to_string(),
+                content: vec![InputContentBlock::Text {
+                    text: "x".repeat(300_000),
+                }],
+            }],
+            system: Some("Keep the answer short.".to_string()),
+            tools: None,
+            tool_choice: None,
+            stream: false,
+        })
+        .await
+        .expect_err("oversized request should fail local context-window preflight");
+
+    assert!(matches!(error, ApiError::ContextWindowExceeded { .. }));
+    assert!(
+        state.lock().await.is_empty(),
+        "preflight failure should avoid any upstream HTTP request"
+    );
+}
+
 #[tokio::test]
 async fn send_message_accepts_full_chat_completions_endpoint_override() {
    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
--- a/rust/crates/commands/src/lib.rs
+++ b/rust/crates/commands/src/lib.rs
@@ -1954,25 +1954,49 @@ pub struct PluginsCommandResult {

 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 enum DefinitionSource {
+    ProjectClaw,
    ProjectCodex,
    ProjectClaude,
+    UserClawConfigHome,
    UserCodexHome,
+    UserClaw,
    UserCodex,
    UserClaude,
 }

-impl DefinitionSource {
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+enum DefinitionScope {
+    Project,
+    UserConfigHome,
+    UserHome,
+}
+
+impl DefinitionScope {
    fn label(self) -> &'static str {
        match self {
-            Self::ProjectCodex => "Project (.codex)",
-            Self::ProjectClaude => "Project (.claude)",
-            Self::UserCodexHome => "User ($CODEX_HOME)",
-            Self::UserCodex => "User (~/.codex)",
-            Self::UserClaude => "User (~/.claude)",
+            Self::Project => "Project (.claw)",
+            Self::UserConfigHome => "User ($CLAW_CONFIG_HOME)",
+            Self::UserHome => "User (~/.claw)",
        }
    }
 }

+impl DefinitionSource {
+    fn report_scope(self) -> DefinitionScope {
+        match self {
+            Self::ProjectClaw | Self::ProjectCodex | Self::ProjectClaude => {
+                DefinitionScope::Project
+            }
+            Self::UserClawConfigHome | Self::UserCodexHome => DefinitionScope::UserConfigHome,
+            Self::UserClaw | Self::UserCodex | Self::UserClaude => DefinitionScope::UserHome,
+        }
+    }
+
+    fn label(self) -> &'static str {
+        self.report_scope().label()
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 struct AgentSummary {
    name: String,
@@ -2142,13 +2166,22 @@ pub fn handle_plugins_slash_command(
 }

 pub fn handle_agents_slash_command(args: Option<&str>, cwd: &Path) -> std::io::Result<String> {
+    if let Some(args) = normalize_optional_args(args) {
+        if let Some(help_path) = help_path_from_args(args) {
+            return Ok(match help_path.as_slice() {
+                [] => render_agents_usage(None),
+                _ => render_agents_usage(Some(&help_path.join(" "))),
+            });
+        }
+    }
+
    match normalize_optional_args(args) {
        None | Some("list") => {
            let roots = discover_definition_roots(cwd, "agents");
            let agents = load_agents_from_roots(&roots)?;
            Ok(render_agents_report(&agents))
        }
-        Some("-h" | "--help" | "help") => Ok(render_agents_usage(None)),
+        Some(args) if is_help_arg(args) => Ok(render_agents_usage(None)),
        Some(args) => Ok(render_agents_usage(Some(args))),
    }
 }
@@ -2162,6 +2195,16 @@ pub fn handle_mcp_slash_command(
 }

 pub fn handle_skills_slash_command(args: Option<&str>, cwd: &Path) -> std::io::Result<String> {
+    if let Some(args) = normalize_optional_args(args) {
+        if let Some(help_path) = help_path_from_args(args) {
+            return Ok(match help_path.as_slice() {
+                [] => render_skills_usage(None),
+                ["install", ..] => render_skills_usage(Some("install")),
+                _ => render_skills_usage(Some(&help_path.join(" "))),
+            });
+        }
+    }
+
    match normalize_optional_args(args) {
        None | Some("list") => {
            let roots = discover_skill_roots(cwd);
@@ -2177,7 +2220,7 @@ pub fn handle_skills_slash_command(args: Option<&str>, cwd: &Path) -> std::io::R
            let install = install_skill(target, cwd)?;
            Ok(render_skill_install_report(&install))
        }
-        Some("-h" | "--help" | "help") => Ok(render_skills_usage(None)),
+        Some(args) if is_help_arg(args) => Ok(render_skills_usage(None)),
        Some(args) => Ok(render_skills_usage(Some(args))),
    }
 }
@@ -2187,6 +2230,16 @@ fn render_mcp_report_for(
    cwd: &Path,
    args: Option<&str>,
 ) -> Result<String, runtime::ConfigError> {
+    if let Some(args) = normalize_optional_args(args) {
+        if let Some(help_path) = help_path_from_args(args) {
+            return Ok(match help_path.as_slice() {
+                [] => render_mcp_usage(None),
+                ["show", ..] => render_mcp_usage(Some("show")),
+                _ => render_mcp_usage(Some(&help_path.join(" "))),
+            });
+        }
+    }
+
    match normalize_optional_args(args) {
        None | Some("list") => {
            let runtime_config = loader.load()?;
@@ -2195,7 +2248,7 @@ fn render_mcp_report_for(
                runtime_config.mcp().servers(),
            ))
        }
-        Some("-h" | "--help" | "help") => Ok(render_mcp_usage(None)),
+        Some(args) if is_help_arg(args) => Ok(render_mcp_usage(None)),
        Some("show") => Ok(render_mcp_usage(Some("show"))),
        Some(args) if args.split_whitespace().next() == Some("show") => {
            let mut parts = args.split_whitespace();
@@ -2273,6 +2326,11 @@ fn discover_definition_roots(cwd: &Path, leaf: &str) -> Vec<(DefinitionSource, P
    let mut roots = Vec::new();

    for ancestor in cwd.ancestors() {
+        push_unique_root(
+            &mut roots,
+            DefinitionSource::ProjectClaw,
+            ancestor.join(".claw").join(leaf),
+        );
        push_unique_root(
            &mut roots,
            DefinitionSource::ProjectCodex,
@@ -2285,6 +2343,14 @@ fn discover_definition_roots(cwd: &Path, leaf: &str) -> Vec<(DefinitionSource, P
        );
    }

+    if let Ok(claw_config_home) = env::var("CLAW_CONFIG_HOME") {
+        push_unique_root(
+            &mut roots,
+            DefinitionSource::UserClawConfigHome,
+            PathBuf::from(claw_config_home).join(leaf),
+        );
+    }
+
    if let Ok(codex_home) = env::var("CODEX_HOME") {
        push_unique_root(
            &mut roots,
@@ -2295,6 +2361,11 @@ fn discover_definition_roots(cwd: &Path, leaf: &str) -> Vec<(DefinitionSource, P

    if let Some(home) = env::var_os("HOME") {
        let home = PathBuf::from(home);
+        push_unique_root(
+            &mut roots,
+            DefinitionSource::UserClaw,
+            home.join(".claw").join(leaf),
+        );
        push_unique_root(
            &mut roots,
            DefinitionSource::UserCodex,
@@ -2314,6 +2385,12 @@ fn discover_skill_roots(cwd: &Path) -> Vec<SkillRoot> {
    let mut roots = Vec::new();

    for ancestor in cwd.ancestors() {
+        push_unique_skill_root(
+            &mut roots,
+            DefinitionSource::ProjectClaw,
+            ancestor.join(".claw").join("skills"),
+            SkillOrigin::SkillsDir,
+        );
        push_unique_skill_root(
            &mut roots,
            DefinitionSource::ProjectCodex,
@@ -2326,6 +2403,12 @@ fn discover_skill_roots(cwd: &Path) -> Vec<SkillRoot> {
            ancestor.join(".claude").join("skills"),
            SkillOrigin::SkillsDir,
        );
+        push_unique_skill_root(
+            &mut roots,
+            DefinitionSource::ProjectClaw,
+            ancestor.join(".claw").join("commands"),
+            SkillOrigin::LegacyCommandsDir,
+        );
        push_unique_skill_root(
            &mut roots,
            DefinitionSource::ProjectCodex,
@@ -2340,6 +2423,22 @@ fn discover_skill_roots(cwd: &Path) -> Vec<SkillRoot> {
        );
    }

+    if let Ok(claw_config_home) = env::var("CLAW_CONFIG_HOME") {
+        let claw_config_home = PathBuf::from(claw_config_home);
+        push_unique_skill_root(
+            &mut roots,
+            DefinitionSource::UserClawConfigHome,
+            claw_config_home.join("skills"),
+            SkillOrigin::SkillsDir,
+        );
+        push_unique_skill_root(
+            &mut roots,
+            DefinitionSource::UserClawConfigHome,
+            claw_config_home.join("commands"),
+            SkillOrigin::LegacyCommandsDir,
+        );
+    }
+
    if let Ok(codex_home) = env::var("CODEX_HOME") {
        let codex_home = PathBuf::from(codex_home);
        push_unique_skill_root(
@@ -2358,6 +2457,18 @@ fn discover_skill_roots(cwd: &Path) -> Vec<SkillRoot> {

    if let Some(home) = env::var_os("HOME") {
        let home = PathBuf::from(home);
+        push_unique_skill_root(
+            &mut roots,
+            DefinitionSource::UserClaw,
+            home.join(".claw").join("skills"),
+            SkillOrigin::SkillsDir,
+        );
+        push_unique_skill_root(
+            &mut roots,
+            DefinitionSource::UserClaw,
+            home.join(".claw").join("commands"),
+            SkillOrigin::LegacyCommandsDir,
+        );
        push_unique_skill_root(
            &mut roots,
            DefinitionSource::UserCodex,
@@ -2438,15 +2549,18 @@ fn install_skill_into(
 }

 fn default_skill_install_root() -> std::io::Result<PathBuf> {
+    if let Ok(claw_config_home) = env::var("CLAW_CONFIG_HOME") {
+        return Ok(PathBuf::from(claw_config_home).join("skills"));
+    }
    if let Ok(codex_home) = env::var("CODEX_HOME") {
        return Ok(PathBuf::from(codex_home).join("skills"));
    }
    if let Some(home) = env::var_os("HOME") {
-        return Ok(PathBuf::from(home).join(".codex").join("skills"));
+        return Ok(PathBuf::from(home).join(".claw").join("skills"));
    }
    Err(std::io::Error::new(
        std::io::ErrorKind::NotFound,
-        "unable to resolve a skills install root; set CODEX_HOME or HOME",
+        "unable to resolve a skills install root; set CLAW_CONFIG_HOME or HOME",
    ))
 }

@@ -2812,22 +2926,20 @@ fn render_agents_report(agents: &[AgentSummary]) -> String {
        String::new(),
    ];

-    for source in [
-        DefinitionSource::ProjectCodex,
-        DefinitionSource::ProjectClaude,
-        DefinitionSource::UserCodexHome,
-        DefinitionSource::UserCodex,
-        DefinitionSource::UserClaude,
+    for scope in [
+        DefinitionScope::Project,
+        DefinitionScope::UserConfigHome,
+        DefinitionScope::UserHome,
    ] {
        let group = agents
            .iter()
-            .filter(|agent| agent.source == source)
+            .filter(|agent| agent.source.report_scope() == scope)
            .collect::<Vec<_>>();
        if group.is_empty() {
            continue;
        }

-        lines.push(format!("{}:", source.label()));
+        lines.push(format!("{}:", scope.label()));
        for agent in group {
            let detail = agent_detail(agent);
            match agent.shadowed_by {
@@ -2870,22 +2982,20 @@ fn render_skills_report(skills: &[SkillSummary]) -> String {
        String::new(),
    ];

-    for source in [
-        DefinitionSource::ProjectCodex,
-        DefinitionSource::ProjectClaude,
-        DefinitionSource::UserCodexHome,
-        DefinitionSource::UserCodex,
-        DefinitionSource::UserClaude,
+    for scope in [
+        DefinitionScope::Project,
+        DefinitionScope::UserConfigHome,
+        DefinitionScope::UserHome,
    ] {
        let group = skills
            .iter()
-            .filter(|skill| skill.source == source)
+            .filter(|skill| skill.source.report_scope() == scope)
            .collect::<Vec<_>>();
        if group.is_empty() {
            continue;
        }

-        lines.push(format!("{}:", source.label()));
+        lines.push(format!("{}:", scope.label()));
        for skill in group {
            let mut parts = vec![skill.name.clone()];
            if let Some(description) = &skill.description {
@@ -3036,12 +3146,22 @@ fn normalize_optional_args(args: Option<&str>) -> Option<&str> {
    args.map(str::trim).filter(|value| !value.is_empty())
 }

+fn is_help_arg(arg: &str) -> bool {
+    matches!(arg, "help" | "-h" | "--help")
+}
+
+fn help_path_from_args(args: &str) -> Option<Vec<&str>> {
+    let parts = args.split_whitespace().collect::<Vec<_>>();
+    let help_index = parts.iter().position(|part| is_help_arg(part))?;
+    Some(parts[..help_index].to_vec())
+}
+
 fn render_agents_usage(unexpected: Option<&str>) -> String {
    let mut lines = vec![
        "Agents".to_string(),
        "  Usage            /agents [list|help]".to_string(),
        "  Direct CLI       claw agents".to_string(),
-        "  Sources          .codex/agents, .claude/agents, $CODEX_HOME/agents".to_string(),
+        "  Sources          .claw/agents, ~/.claw/agents, $CLAW_CONFIG_HOME/agents".to_string(),
    ];
    if let Some(args) = unexpected {
        lines.push(format!("  Unexpected       {args}"));
@@ -3054,8 +3174,8 @@ fn render_skills_usage(unexpected: Option<&str>) -> String {
        "Skills".to_string(),
        "  Usage            /skills [list|install <path>|help]".to_string(),
        "  Direct CLI       claw skills [list|install <path>|help]".to_string(),
-        "  Install root     $CODEX_HOME/skills or ~/.codex/skills".to_string(),
-        "  Sources          .codex/skills, .claude/skills, legacy /commands".to_string(),
+        "  Install root     $CLAW_CONFIG_HOME/skills or ~/.claw/skills".to_string(),
+        "  Sources          .claw/skills, ~/.claw/skills, legacy /commands".to_string(),
    ];
    if let Some(args) = unexpected {
        lines.push(format!("  Unexpected       {args}"));
@@ -3894,7 +4014,7 @@ mod tests {
        let workspace = temp_dir("agents-workspace");
        let project_agents = workspace.join(".codex").join("agents");
        let user_home = temp_dir("agents-home");
-        let user_agents = user_home.join(".codex").join("agents");
+        let user_agents = user_home.join(".claude").join("agents");

        write_agent(
            &project_agents,
@@ -3927,10 +4047,10 @@ mod tests {

        assert!(report.contains("Agents"));
        assert!(report.contains("2 active agents"));
-        assert!(report.contains("Project (.codex):"));
+        assert!(report.contains("Project (.claw):"));
        assert!(report.contains("planner · Project planner · gpt-5.4 · medium"));
-        assert!(report.contains("User (~/.codex):"));
-        assert!(report.contains("(shadowed by Project (.codex)) planner · User planner"));
+        assert!(report.contains("User (~/.claw):"));
+        assert!(report.contains("(shadowed by Project (.claw)) planner · User planner"));
        assert!(report.contains("verifier · Verification agent · gpt-5.4-mini · high"));

        let _ = fs::remove_dir_all(workspace);
@@ -3972,12 +4092,11 @@ mod tests {

        assert!(report.contains("Skills"));
        assert!(report.contains("3 available skills"));
-        assert!(report.contains("Project (.codex):"));
+        assert!(report.contains("Project (.claw):"));
        assert!(report.contains("plan · Project planning guidance"));
-        assert!(report.contains("Project (.claude):"));
        assert!(report.contains("deploy · Legacy deployment guidance · legacy /commands"));
-        assert!(report.contains("User (~/.codex):"));
-        assert!(report.contains("(shadowed by Project (.codex)) plan · User planning guidance"));
+        assert!(report.contains("User (~/.claw):"));
+        assert!(report.contains("(shadowed by Project (.claw)) plan · User planning guidance"));
        assert!(report.contains("help · Help guidance"));

        let _ = fs::remove_dir_all(workspace);
@@ -3992,6 +4111,8 @@ mod tests {
            super::handle_agents_slash_command(Some("help"), &cwd).expect("agents help");
        assert!(agents_help.contains("Usage            /agents [list|help]"));
        assert!(agents_help.contains("Direct CLI       claw agents"));
+        assert!(agents_help
+            .contains("Sources          .claw/agents, ~/.claw/agents, $CLAW_CONFIG_HOME/agents"));

        let agents_unexpected =
            super::handle_agents_slash_command(Some("show planner"), &cwd).expect("agents usage");
@@ -4000,12 +4121,22 @@ mod tests {
        let skills_help =
            super::handle_skills_slash_command(Some("--help"), &cwd).expect("skills help");
        assert!(skills_help.contains("Usage            /skills [list|install <path>|help]"));
-        assert!(skills_help.contains("Install root     $CODEX_HOME/skills or ~/.codex/skills"));
+        assert!(skills_help.contains("Install root     $CLAW_CONFIG_HOME/skills or ~/.claw/skills"));
        assert!(skills_help.contains("legacy /commands"));

        let skills_unexpected =
            super::handle_skills_slash_command(Some("show help"), &cwd).expect("skills usage");
-        assert!(skills_unexpected.contains("Unexpected       show help"));
+        assert!(skills_unexpected.contains("Unexpected       show"));
+
+        let skills_install_help = super::handle_skills_slash_command(Some("install --help"), &cwd)
+            .expect("nested skills help");
+        assert!(skills_install_help.contains("Usage            /skills [list|install <path>|help]"));
+        assert!(skills_install_help.contains("Unexpected       install"));
+
+        let skills_unknown_help =
+            super::handle_skills_slash_command(Some("show --help"), &cwd).expect("skills help");
+        assert!(skills_unknown_help.contains("Usage            /skills [list|install <path>|help]"));
+        assert!(skills_unknown_help.contains("Unexpected       show"));

        let _ = fs::remove_dir_all(cwd);
    }
@@ -4022,6 +4153,16 @@ mod tests {
            super::handle_mcp_slash_command(Some("show alpha beta"), &cwd).expect("mcp usage");
        assert!(unexpected.contains("Unexpected       show alpha beta"));

+        let nested_help =
+            super::handle_mcp_slash_command(Some("show --help"), &cwd).expect("mcp help");
+        assert!(nested_help.contains("Usage            /mcp [list|show <server>|help]"));
+        assert!(nested_help.contains("Unexpected       show"));
+
+        let unknown_help =
+            super::handle_mcp_slash_command(Some("inspect --help"), &cwd).expect("mcp usage");
+        assert!(unknown_help.contains("Usage            /mcp [list|show <server>|help]"));
+        assert!(unknown_help.contains("Unexpected       inspect"));
+
        let _ = fs::remove_dir_all(cwd);
    }

@@ -4154,7 +4295,7 @@ mod tests {
        let listed = render_skills_report(
            &load_skills_from_roots(&roots).expect("installed skills should load"),
        );
-        assert!(listed.contains("User ($CODEX_HOME):"));
+        assert!(listed.contains("User ($CLAW_CONFIG_HOME):"));
        assert!(listed.contains("help · Helpful skill"));

        let _ = fs::remove_dir_all(workspace);
--- a/rust/crates/runtime/src/file_ops.rs
+++ b/rust/crates/runtime/src/file_ops.rs
@@ -28,6 +28,7 @@ fn is_binary_file(path: &Path) -> io::Result<bool> {
 /// Validate that a resolved path stays within the given workspace root.
 /// Returns the canonical path on success, or an error if the path escapes
 /// the workspace boundary (e.g. via `../` traversal or symlink).
+#[allow(dead_code)]
 fn validate_workspace_boundary(resolved: &Path, workspace_root: &Path) -> io::Result<()> {
    if !resolved.starts_with(workspace_root) {
        return Err(io::Error::new(
@@ -557,6 +558,7 @@ fn normalize_path_allow_missing(path: &str) -> io::Result<PathBuf> {
 }

 /// Read a file with workspace boundary enforcement.
+#[allow(dead_code)]
 pub fn read_file_in_workspace(
    path: &str,
    offset: Option<usize>,
@@ -572,6 +574,7 @@ pub fn read_file_in_workspace(
 }

 /// Write a file with workspace boundary enforcement.
+#[allow(dead_code)]
 pub fn write_file_in_workspace(
    path: &str,
    content: &str,
@@ -586,6 +589,7 @@ pub fn write_file_in_workspace(
 }

 /// Edit a file with workspace boundary enforcement.
+#[allow(dead_code)]
 pub fn edit_file_in_workspace(
    path: &str,
    old_string: &str,
@@ -602,6 +606,7 @@ pub fn edit_file_in_workspace(
 }

 /// Check whether a path is a symlink that resolves outside the workspace.
+#[allow(dead_code)]
 pub fn is_symlink_escape(path: &Path, workspace_root: &Path) -> io::Result<bool> {
    let metadata = fs::symlink_metadata(path)?;
    if !metadata.is_symlink() {
--- a/rust/crates/runtime/src/lane_events.rs
+++ b/rust/crates/runtime/src/lane_events.rs
@@ -114,8 +114,12 @@ impl LaneEvent {

    #[must_use]
    pub fn finished(emitted_at: impl Into<String>, detail: Option<String>) -> Self {
-        Self::new(LaneEventName::Finished, LaneEventStatus::Completed, emitted_at)
-            .with_optional_detail(detail)
+        Self::new(
+            LaneEventName::Finished,
+            LaneEventStatus::Completed,
+            emitted_at,
+        )
+        .with_optional_detail(detail)
    }

    #[must_use]
@@ -161,19 +165,14 @@ impl LaneEvent {
 mod tests {
    use serde_json::json;

-    use super::{
-        LaneEvent, LaneEventBlocker, LaneEventName, LaneEventStatus, LaneFailureClass,
-    };
+    use super::{LaneEvent, LaneEventBlocker, LaneEventName, LaneEventStatus, LaneFailureClass};

    #[test]
    fn canonical_lane_event_names_serialize_to_expected_wire_values() {
        let cases = [
            (LaneEventName::Started, "lane.started"),
            (LaneEventName::Ready, "lane.ready"),
-            (
-                LaneEventName::PromptMisdelivery,
-                "lane.prompt_misdelivery",
-            ),
+            (LaneEventName::PromptMisdelivery, "lane.prompt_misdelivery"),
            (LaneEventName::Blocked, "lane.blocked"),
            (LaneEventName::Red, "lane.red"),
            (LaneEventName::Green, "lane.green"),
@@ -193,7 +192,10 @@ mod tests {
        ];

        for (event, expected) in cases {
-            assert_eq!(serde_json::to_value(event).expect("serialize event"), json!(expected));
+            assert_eq!(
+                serde_json::to_value(event).expect("serialize event"),
+                json!(expected)
+            );
        }
    }

--- a/rust/crates/runtime/src/mcp_lifecycle_hardened.rs
+++ b/rust/crates/runtime/src/mcp_lifecycle_hardened.rs
@@ -599,7 +599,10 @@ mod tests {
            ));

            match result {
-                McpPhaseResult::Failure { phase: failed_phase, error } => {
+                McpPhaseResult::Failure {
+                    phase: failed_phase,
+                    error,
+                } => {
                    assert_eq!(failed_phase, phase);
                    assert_eq!(error.phase, phase);
                    assert_eq!(
--- a/rust/crates/runtime/src/mcp_stdio.rs
+++ b/rust/crates/runtime/src/mcp_stdio.rs
@@ -360,8 +360,10 @@ impl McpServerManagerError {
    }

    fn recoverable(&self) -> bool {
-        !matches!(self.lifecycle_phase(), McpLifecyclePhase::InitializeHandshake)
-            && matches!(self, Self::Transport { .. } | Self::Timeout { .. })
+        !matches!(
+            self.lifecycle_phase(),
+            McpLifecyclePhase::InitializeHandshake
+        ) && matches!(self, Self::Transport { .. } | Self::Timeout { .. })
    }

    fn discovery_failure(&self, server_name: &str) -> McpDiscoveryFailure {
@@ -417,10 +419,9 @@ impl McpServerManagerError {
                ("method".to_string(), (*method).to_string()),
                ("timeout_ms".to_string(), timeout_ms.to_string()),
            ]),
-            Self::UnknownTool { qualified_name } => BTreeMap::from([(
-                "qualified_tool".to_string(),
-                qualified_name.clone(),
-            )]),
+            Self::UnknownTool { qualified_name } => {
+                BTreeMap::from([("qualified_tool".to_string(), qualified_name.clone())])
+            }
            Self::UnknownServer { server_name } => {
                BTreeMap::from([("server".to_string(), server_name.clone())])
            }
@@ -1425,11 +1426,10 @@ mod tests {
    use crate::mcp_client::McpClientBootstrap;

    use super::{
-        spawn_mcp_stdio_process, JsonRpcId, JsonRpcRequest, JsonRpcResponse,
-        McpInitializeClientInfo, McpInitializeParams, McpInitializeResult, McpInitializeServerInfo,
-        McpListToolsResult, McpReadResourceParams, McpReadResourceResult, McpServerManager,
-        McpServerManagerError, McpStdioProcess, McpTool, McpToolCallParams,
-        unsupported_server_failed_server,
+        spawn_mcp_stdio_process, unsupported_server_failed_server, JsonRpcId, JsonRpcRequest,
+        JsonRpcResponse, McpInitializeClientInfo, McpInitializeParams, McpInitializeResult,
+        McpInitializeServerInfo, McpListToolsResult, McpReadResourceParams, McpReadResourceResult,
+        McpServerManager, McpServerManagerError, McpStdioProcess, McpTool, McpToolCallParams,
    };
    use crate::McpLifecyclePhase;

@@ -2698,7 +2698,10 @@ mod tests {
            );
            assert!(!report.failed_servers[0].recoverable);
            assert_eq!(
-                report.failed_servers[0].context.get("method").map(String::as_str),
+                report.failed_servers[0]
+                    .context
+                    .get("method")
+                    .map(String::as_str),
                Some("initialize")
            );
            assert!(report.failed_servers[0].error.contains("initialize"));
--- a/rust/crates/runtime/src/session_control.rs
+++ b/rust/crates/runtime/src/session_control.rs
@@ -4,10 +4,7 @@ use std::fs;
 use std::path::{Path, PathBuf};
 use std::time::UNIX_EPOCH;

-use serde::{Deserialize, Serialize};
-
 use crate::session::{Session, SessionError};
-use crate::worker_boot::{Worker, WorkerReadySnapshot, WorkerRegistry, WorkerStatus};

 pub const PRIMARY_SESSION_EXTENSION: &str = "jsonl";
 pub const LEGACY_SESSION_EXTENSION: &str = "json";
--- a/rust/crates/runtime/src/task_packet.rs
+++ b/rust/crates/runtime/src/task_packet.rs
@@ -66,11 +66,7 @@ pub fn validate_packet(packet: TaskPacket) -> Result<ValidatedPacket, TaskPacket
        &packet.reporting_contract,
        &mut errors,
    );
-    validate_required(
-        "escalation_policy",
-        &packet.escalation_policy,
-        &mut errors,
-    );
+    validate_required("escalation_policy", &packet.escalation_policy, &mut errors);

    for (index, test) in packet.acceptance_tests.iter().enumerate() {
        if test.trim().is_empty() {
@@ -146,9 +142,9 @@ mod tests {
        assert!(error
            .errors()
            .contains(&"repo must not be empty".to_string()));
-        assert!(error.errors().contains(
-            &"acceptance_tests contains an empty value at index 1".to_string()
-        ));
+        assert!(error
+            .errors()
+            .contains(&"acceptance_tests contains an empty value at index 1".to_string()));
    }

    #[test]
--- a/rust/crates/runtime/src/task_registry.rs
+++ b/rust/crates/runtime/src/task_registry.rs
@@ -76,11 +76,7 @@ impl TaskRegistry {
    }

    pub fn create(&self, prompt: &str, description: Option<&str>) -> Task {
-        self.create_task(
-            prompt.to_owned(),
-            description.map(str::to_owned),
-            None,
-        )
+        self.create_task(prompt.to_owned(), description.map(str::to_owned), None)
    }

    pub fn create_from_packet(
--- a/rust/crates/runtime/src/worker_boot.rs
+++ b/rust/crates/runtime/src/worker_boot.rs
@@ -257,7 +257,9 @@ impl WorkerRegistry {
            let prompt_preview = prompt_preview(worker.last_prompt.as_deref().unwrap_or_default());
            let message = match observation.target {
                WorkerPromptTarget::Shell => {
-                    format!("worker prompt landed in shell instead of coding agent: {prompt_preview}")
+                    format!(
+                        "worker prompt landed in shell instead of coding agent: {prompt_preview}"
+                    )
                }
                WorkerPromptTarget::WrongTarget => format!(
                    "worker prompt landed in the wrong target instead of {}: {}",
@@ -312,7 +314,9 @@ impl WorkerRegistry {
            worker.last_error = None;
        }

-        if detect_ready_for_prompt(screen_text, &lowered) && worker.status != WorkerStatus::ReadyForPrompt {
+        if detect_ready_for_prompt(screen_text, &lowered)
+            && worker.status != WorkerStatus::ReadyForPrompt
+        {
            worker.status = WorkerStatus::ReadyForPrompt;
            worker.prompt_in_flight = false;
            if matches!(
@@ -412,7 +416,10 @@ impl WorkerRegistry {
            worker_id: worker.worker_id.clone(),
            status: worker.status,
            ready: worker.status == WorkerStatus::ReadyForPrompt,
-            blocked: matches!(worker.status, WorkerStatus::TrustRequired | WorkerStatus::Failed),
+            blocked: matches!(
+                worker.status,
+                WorkerStatus::TrustRequired | WorkerStatus::Failed
+            ),
            replay_prompt_ready: worker.replay_prompt.is_some(),
            last_error: worker.last_error.clone(),
        })
--- a/rust/crates/rusty-claude-cli/src/init.rs
+++ b/rust/crates/rusty-claude-cli/src/init.rs
@@ -1,7 +1,7 @@
 use std::fs;
 use std::path::{Path, PathBuf};

-const STARTER_CLAUDE_JSON: &str = concat!(
+const STARTER_CLAW_JSON: &str = concat!(
    "{\n",
    "  \"permissions\": {\n",
    "    \"defaultMode\": \"dontAsk\"\n",
@@ -9,7 +9,7 @@ const STARTER_CLAUDE_JSON: &str = concat!(
    "}\n",
 );
 const GITIGNORE_COMMENT: &str = "# Claw Code local artifacts";
-const GITIGNORE_ENTRIES: [&str; 2] = [".claude/settings.local.json", ".claude/sessions/"];
+const GITIGNORE_ENTRIES: [&str; 2] = [".claw/settings.local.json", ".claw/sessions/"];

 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum InitStatus {
@@ -80,16 +80,16 @@ struct RepoDetection {
 pub(crate) fn initialize_repo(cwd: &Path) -> Result<InitReport, Box<dyn std::error::Error>> {
    let mut artifacts = Vec::new();

-    let claude_dir = cwd.join(".claude");
+    let claw_dir = cwd.join(".claw");
    artifacts.push(InitArtifact {
-        name: ".claude/",
-        status: ensure_dir(&claude_dir)?,
+        name: ".claw/",
+        status: ensure_dir(&claw_dir)?,
    });

-    let claude_json = cwd.join(".claude.json");
+    let claw_json = cwd.join(".claw.json");
    artifacts.push(InitArtifact {
-        name: ".claude.json",
-        status: write_file_if_missing(&claude_json, STARTER_CLAUDE_JSON)?,
+        name: ".claw.json",
+        status: write_file_if_missing(&claw_json, STARTER_CLAW_JSON)?,
    });

    let gitignore = cwd.join(".gitignore");
@@ -209,7 +209,7 @@ pub(crate) fn render_init_claude_md(cwd: &Path) -> String {

    lines.push("## Working agreement".to_string());
    lines.push("- Prefer small, reviewable changes and keep generated bootstrap files aligned with actual repo workflows.".to_string());
-    lines.push("- Keep shared defaults in `.claude.json`; reserve `.claude/settings.local.json` for machine-local overrides.".to_string());
+    lines.push("- Keep shared defaults in `.claw.json`; reserve `.claw/settings.local.json` for machine-local overrides.".to_string());
    lines.push("- Do not overwrite existing `CLAUDE.md` content automatically; update it intentionally when repo workflows change.".to_string());
    lines.push(String::new());

@@ -354,15 +354,16 @@ mod tests {

        let report = initialize_repo(&root).expect("init should succeed");
        let rendered = report.render();
-        assert!(rendered.contains(".claude/         created"));
-        assert!(rendered.contains(".claude.json     created"));
+        assert!(rendered.contains(".claw/"));
+        assert!(rendered.contains(".claw.json"));
+        assert!(rendered.contains("created"));
        assert!(rendered.contains(".gitignore       created"));
        assert!(rendered.contains("CLAUDE.md        created"));
-        assert!(root.join(".claude").is_dir());
-        assert!(root.join(".claude.json").is_file());
+        assert!(root.join(".claw").is_dir());
+        assert!(root.join(".claw.json").is_file());
        assert!(root.join("CLAUDE.md").is_file());
        assert_eq!(
-            fs::read_to_string(root.join(".claude.json")).expect("read claude json"),
+            fs::read_to_string(root.join(".claw.json")).expect("read claw json"),
            concat!(
                "{\n",
                "  \"permissions\": {\n",
@@ -372,8 +373,8 @@ mod tests {
            )
        );
        let gitignore = fs::read_to_string(root.join(".gitignore")).expect("read gitignore");
-        assert!(gitignore.contains(".claude/settings.local.json"));
-        assert!(gitignore.contains(".claude/sessions/"));
+        assert!(gitignore.contains(".claw/settings.local.json"));
+        assert!(gitignore.contains(".claw/sessions/"));
        let claude_md = fs::read_to_string(root.join("CLAUDE.md")).expect("read claude md");
        assert!(claude_md.contains("Languages: Rust."));
        assert!(claude_md.contains("cargo clippy --workspace --all-targets -- -D warnings"));
@@ -386,8 +387,7 @@ mod tests {
        let root = temp_dir();
        fs::create_dir_all(&root).expect("create root");
        fs::write(root.join("CLAUDE.md"), "custom guidance\n").expect("write existing claude md");
-        fs::write(root.join(".gitignore"), ".claude/settings.local.json\n")
-            .expect("write gitignore");
+        fs::write(root.join(".gitignore"), ".claw/settings.local.json\n").expect("write gitignore");

        let first = initialize_repo(&root).expect("first init should succeed");
        assert!(first
@@ -395,8 +395,9 @@ mod tests {
            .contains("CLAUDE.md        skipped (already exists)"));
        let second = initialize_repo(&root).expect("second init should succeed");
        let second_rendered = second.render();
-        assert!(second_rendered.contains(".claude/         skipped (already exists)"));
-        assert!(second_rendered.contains(".claude.json     skipped (already exists)"));
+        assert!(second_rendered.contains(".claw/"));
+        assert!(second_rendered.contains(".claw.json"));
+        assert!(second_rendered.contains("skipped (already exists)"));
        assert!(second_rendered.contains(".gitignore       skipped (already exists)"));
        assert!(second_rendered.contains("CLAUDE.md        skipped (already exists)"));
        assert_eq!(
@@ -404,8 +405,8 @@ mod tests {
            "custom guidance\n"
        );
        let gitignore = fs::read_to_string(root.join(".gitignore")).expect("read gitignore");
-        assert_eq!(gitignore.matches(".claude/settings.local.json").count(), 1);
-        assert_eq!(gitignore.matches(".claude/sessions/").count(), 1);
+        assert_eq!(gitignore.matches(".claw/settings.local.json").count(), 1);
+        assert_eq!(gitignore.matches(".claw/sessions/").count(), 1);

        fs::remove_dir_all(root).expect("cleanup temp dir");
    }
--- a/rust/crates/rusty-claude-cli/src/main.rs
+++ b/rust/crates/rusty-claude-cli/src/main.rs
@@ -49,7 +49,7 @@ use runtime::{
    UsageTracker,
 };
 use serde::Deserialize;
-use serde_json::json;
+use serde_json::{json, Value};
 use tools::{GlobalToolRegistry, RuntimeToolDefinition, ToolSearchOutput};

 const DEFAULT_MODEL: &str = "claude-opus-4-6";
@@ -117,12 +117,14 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
        CliAction::ResumeSession {
            session_path,
            commands,
-        } => resume_session(&session_path, &commands),
+            output_format,
+        } => resume_session(&session_path, &commands, output_format),
        CliAction::Status {
            model,
            permission_mode,
-        } => print_status_snapshot(&model, permission_mode)?,
-        CliAction::Sandbox => print_sandbox_status_snapshot()?,
+            output_format,
+        } => print_status_snapshot(&model, permission_mode, output_format)?,
+        CliAction::Sandbox { output_format } => print_sandbox_status_snapshot(output_format)?,
        CliAction::Prompt {
            prompt,
            model,
@@ -165,12 +167,16 @@ enum CliAction {
    ResumeSession {
        session_path: PathBuf,
        commands: Vec<String>,
+        output_format: CliOutputFormat,
    },
    Status {
        model: String,
        permission_mode: PermissionMode,
+        output_format: CliOutputFormat,
+    },
+    Sandbox {
+        output_format: CliOutputFormat,
    },
-    Sandbox,
    Prompt {
        prompt: String,
        model: String,
@@ -339,9 +345,10 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
        });
    }
    if rest.first().map(String::as_str) == Some("--resume") {
-        return parse_resume_args(&rest[1..]);
+        return parse_resume_args(&rest[1..], output_format);
    }
-    if let Some(action) = parse_single_word_command_alias(&rest, &model, permission_mode_override)
+    if let Some(action) =
+        parse_single_word_command_alias(&rest, &model, permission_mode_override, output_format)
    {
        return action;
    }
@@ -392,6 +399,7 @@ fn parse_single_word_command_alias(
    rest: &[String],
    model: &str,
    permission_mode_override: Option<PermissionMode>,
+    output_format: CliOutputFormat,
 ) -> Option<Result<CliAction, String>> {
    if rest.len() != 1 {
        return None;
@@ -403,8 +411,9 @@ fn parse_single_word_command_alias(
        "status" => Some(Ok(CliAction::Status {
            model: model.to_string(),
            permission_mode: permission_mode_override.unwrap_or_else(default_permission_mode),
+            output_format,
        })),
-        "sandbox" => Some(Ok(CliAction::Sandbox)),
+        "sandbox" => Some(Ok(CliAction::Sandbox { output_format })),
        other => bare_slash_command_guidance(other).map(Err),
    }
 }
@@ -698,7 +707,7 @@ fn parse_system_prompt_args(args: &[String]) -> Result<CliAction, String> {
    Ok(CliAction::PrintSystemPrompt { cwd, date })
 }

-fn parse_resume_args(args: &[String]) -> Result<CliAction, String> {
+fn parse_resume_args(args: &[String], output_format: CliOutputFormat) -> Result<CliAction, String> {
    let (session_path, command_tokens): (PathBuf, &[String]) = match args.first() {
        None => (PathBuf::from(LATEST_SESSION_REFERENCE), &[]),
        Some(first) if looks_like_slash_command_token(first) => {
@@ -738,6 +747,7 @@ fn parse_resume_args(args: &[String]) -> Result<CliAction, String> {
    Ok(CliAction::ResumeSession {
        session_path,
        commands,
+        output_format,
    })
 }

@@ -928,7 +938,7 @@ fn print_version() {
    println!("{}", render_version_report());
 }

-fn resume_session(session_path: &Path, commands: &[String]) {
+fn resume_session(session_path: &Path, commands: &[String], output_format: CliOutputFormat) {
    let resolved_path = if session_path.exists() {
        session_path.to_path_buf()
    } else {
@@ -950,15 +960,31 @@ fn resume_session(session_path: &Path, commands: &[String]) {
    };

    if commands.is_empty() {
-        println!(
-            "Restored session from {} ({} messages).",
-            resolved_path.display(),
-            session.messages.len()
-        );
+        match output_format {
+            CliOutputFormat::Text => {
+                println!(
+                    "Restored session from {} ({} messages).",
+                    resolved_path.display(),
+                    session.messages.len()
+                );
+            }
+            CliOutputFormat::Json => {
+                println!(
+                    "{}",
+                    serialize_json_output(&json!({
+                        "kind": "resume",
+                        "session_file": resolved_path.display().to_string(),
+                        "messages": session.messages.len(),
+                    }))
+                    .unwrap_or_else(|error| format!(r#"{{"kind":"error","message":"{error}"}}"#))
+                );
+            }
+        }
        return;
    }

    let mut session = session;
+    let mut json_outputs = Vec::new();
    for raw_command in commands {
        let command = match SlashCommand::parse(raw_command) {
            Ok(Some(command)) => command,
@@ -971,14 +997,19 @@ fn resume_session(session_path: &Path, commands: &[String]) {
                std::process::exit(2);
            }
        };
-        match run_resume_command(&resolved_path, &session, &command) {
+        match run_resume_command(&resolved_path, &session, &command, output_format) {
            Ok(ResumeCommandOutcome {
                session: next_session,
                message,
            }) => {
                session = next_session;
                if let Some(message) = message {
-                    println!("{message}");
+                    match output_format {
+                        CliOutputFormat::Text => {
+                            println!("{}", render_resume_text_output(&message))
+                        }
+                        CliOutputFormat::Json => json_outputs.push(message),
+                    }
                }
            }
            Err(error) => {
@@ -987,12 +1018,27 @@ fn resume_session(session_path: &Path, commands: &[String]) {
            }
        }
    }
+
+    if matches!(output_format, CliOutputFormat::Json) {
+        let payload = if json_outputs.len() == 1 {
+            json_outputs.pop().expect("single json output")
+        } else {
+            Value::Array(json_outputs)
+        };
+        match serialize_json_output(&payload) {
+            Ok(rendered) => println!("{rendered}"),
+            Err(error) => {
+                eprintln!("failed to render json output: {error}");
+                std::process::exit(2);
+            }
+        }
+    }
 }

 #[derive(Debug, Clone)]
 struct ResumeCommandOutcome {
    session: Session,
-    message: Option<String>,
+    message: Option<Value>,
 }

 #[derive(Debug, Clone)]
@@ -1317,16 +1363,28 @@ fn parse_git_status_metadata_for(
    (project_root, branch)
 }

+fn serialize_json_output(value: &Value) -> Result<String, serde_json::Error> {
+    serde_json::to_string_pretty(value)
+}
+
+fn render_resume_text_output(value: &Value) -> String {
+    value.get("message").and_then(Value::as_str).map_or_else(
+        || serialize_json_output(value).unwrap_or_else(|_| value.to_string()),
+        ToString::to_string,
+    )
+}
+
 #[allow(clippy::too_many_lines)]
 fn run_resume_command(
    session_path: &Path,
    session: &Session,
    command: &SlashCommand,
+    output_format: CliOutputFormat,
 ) -> Result<ResumeCommandOutcome, Box<dyn std::error::Error>> {
    match command {
        SlashCommand::Help => Ok(ResumeCommandOutcome {
            session: session.clone(),
-            message: Some(render_repl_help()),
+            message: Some(json!({ "kind": "help", "message": render_repl_help() })),
        }),
        SlashCommand::Compact => {
            let result = runtime::compact_session(
@@ -1342,16 +1400,20 @@ fn run_resume_command(
            result.compacted_session.save_to_path(session_path)?;
            Ok(ResumeCommandOutcome {
                session: result.compacted_session,
-                message: Some(format_compact_report(removed, kept, skipped)),
+                message: Some(json!({
+                    "kind": "compact",
+                    "message": format_compact_report(removed, kept, skipped),
+                })),
            })
        }
        SlashCommand::Clear { confirm } => {
            if !confirm {
                return Ok(ResumeCommandOutcome {
                    session: session.clone(),
-                    message: Some(
-                        "clear: confirmation required; rerun with /clear --confirm".to_string(),
-                    ),
+                    message: Some(json!({
+                        "kind": "clear",
+                        "message": "clear: confirmation required; rerun with /clear --confirm",
+                    })),
                });
            }
            let backup_path = write_session_clear_backup(session, session_path)?;
@@ -1361,55 +1423,85 @@ fn run_resume_command(
            cleared.save_to_path(session_path)?;
            Ok(ResumeCommandOutcome {
                session: cleared,
-                message: Some(format!(
-                    "Session cleared\n  Mode             resumed session reset\n  Previous session {previous_session_id}\n  Backup           {}\n  Resume previous  claw --resume {}\n  New session      {new_session_id}\n  Session file     {}",
-                    backup_path.display(),
-                    backup_path.display(),
-                    session_path.display()
-                )),
+                message: Some(json!({
+                    "kind": "clear",
+                    "message": format!(
+                        "Session cleared\n  Mode             resumed session reset\n  Previous session {previous_session_id}\n  Backup           {}\n  Resume previous  claw --resume {}\n  New session      {new_session_id}\n  Session file     {}",
+                        backup_path.display(),
+                        backup_path.display(),
+                        session_path.display()
+                    ),
+                })),
            })
        }
        SlashCommand::Status => {
            let tracker = UsageTracker::from_session(session);
            let usage = tracker.cumulative_usage();
+            let status_usage = StatusUsage {
+                message_count: session.messages.len(),
+                turns: tracker.turns(),
+                latest: tracker.current_turn_usage(),
+                cumulative: usage,
+                estimated_tokens: 0,
+            };
+            let context = status_context(Some(session_path))?;
+            let status_json = status_report_json(
+                "restored-session",
+                status_usage,
+                default_permission_mode().as_str(),
+                &context,
+            );
            Ok(ResumeCommandOutcome {
                session: session.clone(),
-                message: Some(format_status_report(
-                    "restored-session",
-                    StatusUsage {
-                        message_count: session.messages.len(),
-                        turns: tracker.turns(),
-                        latest: tracker.current_turn_usage(),
-                        cumulative: usage,
-                        estimated_tokens: 0,
-                    },
-                    default_permission_mode().as_str(),
-                    &status_context(Some(session_path))?,
-                )),
+                message: Some(match output_format {
+                    CliOutputFormat::Text => json!({
+                        "kind": "status-text",
+                        "message": format_status_report(
+                            "restored-session",
+                            status_usage,
+                            default_permission_mode().as_str(),
+                            &context,
+                        ),
+                    }),
+                    CliOutputFormat::Json => status_json,
+                }),
            })
        }
        SlashCommand::Sandbox => {
            let cwd = env::current_dir()?;
            let loader = ConfigLoader::default_for(&cwd);
            let runtime_config = loader.load()?;
+            let sandbox_status = resolve_sandbox_status(runtime_config.sandbox(), &cwd);
            Ok(ResumeCommandOutcome {
                session: session.clone(),
-                message: Some(format_sandbox_report(&resolve_sandbox_status(
-                    runtime_config.sandbox(),
-                    &cwd,
-                ))),
+                message: Some(match output_format {
+                    CliOutputFormat::Text => json!({
+                        "kind": "sandbox-text",
+                        "message": format_sandbox_report(&sandbox_status),
+                    }),
+                    CliOutputFormat::Json => json!({
+                        "kind": "sandbox",
+                        "sandbox": sandbox_status_json(&sandbox_status),
+                    }),
+                }),
            })
        }
        SlashCommand::Cost => {
            let usage = UsageTracker::from_session(session).cumulative_usage();
            Ok(ResumeCommandOutcome {
                session: session.clone(),
-                message: Some(format_cost_report(usage)),
+                message: Some(json!({
+                    "kind": "cost",
+                    "message": format_cost_report(usage),
+                })),
            })
        }
        SlashCommand::Config { section } => Ok(ResumeCommandOutcome {
            session: session.clone(),
-            message: Some(render_config_report(section.as_deref())?),
+            message: Some(json!({
+                "kind": "config",
+                "message": render_config_report(section.as_deref())?,
+            })),
        }),
        SlashCommand::Mcp { action, target } => {
            let cwd = env::current_dir()?;
@@ -1421,51 +1513,75 @@ fn run_resume_command(
            };
            Ok(ResumeCommandOutcome {
                session: session.clone(),
-                message: Some(handle_mcp_slash_command(args.as_deref(), &cwd)?),
+                message: Some(json!({
+                    "kind": "mcp",
+                    "message": handle_mcp_slash_command(args.as_deref(), &cwd)?,
+                })),
            })
        }
        SlashCommand::Memory => Ok(ResumeCommandOutcome {
            session: session.clone(),
-            message: Some(render_memory_report()?),
+            message: Some(json!({
+                "kind": "memory",
+                "message": render_memory_report()?,
+            })),
        }),
        SlashCommand::Init => Ok(ResumeCommandOutcome {
            session: session.clone(),
-            message: Some(init_claude_md()?),
+            message: Some(json!({
+                "kind": "init",
+                "message": init_claude_md()?,
+            })),
        }),
        SlashCommand::Diff => Ok(ResumeCommandOutcome {
            session: session.clone(),
-            message: Some(render_diff_report_for(
-                session_path.parent().unwrap_or_else(|| Path::new(".")),
-            )?),
+            message: Some(json!({
+                "kind": "diff",
+                "message": render_diff_report_for(
+                    session_path.parent().unwrap_or_else(|| Path::new(".")),
+                )?,
+            })),
        }),
        SlashCommand::Version => Ok(ResumeCommandOutcome {
            session: session.clone(),
-            message: Some(render_version_report()),
+            message: Some(json!({
+                "kind": "version",
+                "message": render_version_report(),
+            })),
        }),
        SlashCommand::Export { path } => {
            let export_path = resolve_export_path(path.as_deref(), session)?;
            fs::write(&export_path, render_export_text(session))?;
            Ok(ResumeCommandOutcome {
                session: session.clone(),
-                message: Some(format!(
-                    "Export\n  Result           wrote transcript\n  File             {}\n  Messages         {}",
-                    export_path.display(),
-                    session.messages.len(),
-                )),
+                message: Some(json!({
+                    "kind": "export",
+                    "message": format!(
+                        "Export\n  Result           wrote transcript\n  File             {}\n  Messages         {}",
+                        export_path.display(),
+                        session.messages.len(),
+                    ),
+                })),
            })
        }
        SlashCommand::Agents { args } => {
            let cwd = env::current_dir()?;
            Ok(ResumeCommandOutcome {
                session: session.clone(),
-                message: Some(handle_agents_slash_command(args.as_deref(), &cwd)?),
+                message: Some(json!({
+                    "kind": "agents",
+                    "message": handle_agents_slash_command(args.as_deref(), &cwd)?,
+                })),
            })
        }
        SlashCommand::Skills { args } => {
            let cwd = env::current_dir()?;
            Ok(ResumeCommandOutcome {
                session: session.clone(),
-                message: Some(handle_skills_slash_command(args.as_deref(), &cwd)?),
+                message: Some(json!({
+                    "kind": "skills",
+                    "message": handle_skills_slash_command(args.as_deref(), &cwd)?,
+                })),
            })
        }
        SlashCommand::Unknown(name) => Err(format_unknown_slash_command(name).into()),
@@ -1751,37 +1867,38 @@ impl RuntimeMcpState {
            .into_iter()
            .filter(|server_name| !failed_server_names.contains(server_name))
            .collect::<Vec<_>>();
-        let failed_servers = discovery
-            .failed_servers
-            .iter()
-            .map(|failure| runtime::McpFailedServer {
-                server_name: failure.server_name.clone(),
-                phase: runtime::McpLifecyclePhase::ToolDiscovery,
-                error: runtime::McpErrorSurface::new(
-                    runtime::McpLifecyclePhase::ToolDiscovery,
-                    Some(failure.server_name.clone()),
-                    failure.error.clone(),
-                    std::collections::BTreeMap::new(),
-                    true,
-                ),
-            })
-            .chain(discovery.unsupported_servers.iter().map(|server| {
-                runtime::McpFailedServer {
-                    server_name: server.server_name.clone(),
-                    phase: runtime::McpLifecyclePhase::ServerRegistration,
+        let failed_servers =
+            discovery
+                .failed_servers
+                .iter()
+                .map(|failure| runtime::McpFailedServer {
+                    server_name: failure.server_name.clone(),
+                    phase: runtime::McpLifecyclePhase::ToolDiscovery,
                    error: runtime::McpErrorSurface::new(
-                        runtime::McpLifecyclePhase::ServerRegistration,
-                        Some(server.server_name.clone()),
-                        server.reason.clone(),
-                        std::collections::BTreeMap::from([(
-                            "transport".to_string(),
-                            format!("{:?}", server.transport).to_ascii_lowercase(),
-                        )]),
-                        false,
+                        runtime::McpLifecyclePhase::ToolDiscovery,
+                        Some(failure.server_name.clone()),
+                        failure.error.clone(),
+                        std::collections::BTreeMap::new(),
+                        true,
                    ),
-                }
-            }))
-            .collect::<Vec<_>>();
+                })
+                .chain(discovery.unsupported_servers.iter().map(|server| {
+                    runtime::McpFailedServer {
+                        server_name: server.server_name.clone(),
+                        phase: runtime::McpLifecyclePhase::ServerRegistration,
+                        error: runtime::McpErrorSurface::new(
+                            runtime::McpLifecyclePhase::ServerRegistration,
+                            Some(server.server_name.clone()),
+                            server.reason.clone(),
+                            std::collections::BTreeMap::from([(
+                                "transport".to_string(),
+                                format!("{:?}", server.transport).to_ascii_lowercase(),
+                            )]),
+                            false,
+                        ),
+                    }
+                }))
+                .collect::<Vec<_>>();
        let degraded_report = (!failed_servers.is_empty()).then(|| {
            runtime::McpDegradedReport::new(
                working_servers,
@@ -3179,22 +3296,31 @@ fn render_repl_help() -> String {
 fn print_status_snapshot(
    model: &str,
    permission_mode: PermissionMode,
+    output_format: CliOutputFormat,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    println!(
-        "{}",
-        format_status_report(
-            model,
-            StatusUsage {
-                message_count: 0,
-                turns: 0,
-                latest: TokenUsage::default(),
-                cumulative: TokenUsage::default(),
-                estimated_tokens: 0,
-            },
-            permission_mode.as_str(),
-            &status_context(None)?,
-        )
-    );
+    let usage = StatusUsage {
+        message_count: 0,
+        turns: 0,
+        latest: TokenUsage::default(),
+        cumulative: TokenUsage::default(),
+        estimated_tokens: 0,
+    };
+    let context = status_context(None)?;
+    match output_format {
+        CliOutputFormat::Text => println!(
+            "{}",
+            format_status_report(model, usage, permission_mode.as_str(), &context)
+        ),
+        CliOutputFormat::Json => println!(
+            "{}",
+            serialize_json_output(&status_report_json(
+                model,
+                usage,
+                permission_mode.as_str(),
+                &context,
+            ))?
+        ),
+    }
    Ok(())
 }

@@ -3292,6 +3418,61 @@ fn format_status_report(
    )
 }

+fn status_report_json(
+    model: &str,
+    usage: StatusUsage,
+    permission_mode: &str,
+    context: &StatusContext,
+) -> Value {
+    json!({
+        "kind": "status",
+        "model": model,
+        "permission_mode": permission_mode,
+        "messages": usage.message_count,
+        "turns": usage.turns,
+        "estimated_tokens": usage.estimated_tokens,
+        "usage": {
+            "latest": token_usage_json(usage.latest),
+            "cumulative": token_usage_json(usage.cumulative),
+        },
+        "workspace": {
+            "cwd": context.cwd.display().to_string(),
+            "project_root": context.project_root.as_ref().map(|path| path.display().to_string()),
+            "git_branch": context.git_branch.clone(),
+            "git_state": context.git_summary.headline(),
+            "changed_files": context.git_summary.changed_files,
+            "staged_files": context.git_summary.staged_files,
+            "unstaged_files": context.git_summary.unstaged_files,
+            "untracked_files": context.git_summary.untracked_files,
+            "session": status_session_label(context.session_path.as_deref()),
+            "config_files": {
+                "loaded": context.loaded_config_files,
+                "discovered": context.discovered_config_files,
+            },
+            "memory_files": context.memory_file_count,
+            "suggested_flow": ["/status", "/diff", "/commit"],
+        },
+        "sandbox": sandbox_status_json(&context.sandbox_status),
+    })
+}
+
+fn token_usage_json(usage: TokenUsage) -> Value {
+    json!({
+        "input_tokens": usage.input_tokens,
+        "output_tokens": usage.output_tokens,
+        "cache_creation_input_tokens": usage.cache_creation_input_tokens,
+        "cache_read_input_tokens": usage.cache_read_input_tokens,
+        "total_tokens": usage.total_tokens(),
+    })
+}
+
+fn status_session_label(session_path: Option<&Path>) -> String {
+    session_path.map_or_else(
+        || "live-repl".to_string(),
+        |path| path.display().to_string(),
+    )
+}
+
 fn format_sandbox_report(status: &runtime::SandboxStatus) -> String {
    format!(
        "Sandbox
@@ -3335,6 +3516,31 @@ fn format_sandbox_report(status: &runtime::SandboxStatus) -> String {
    )
 }

+fn sandbox_status_json(status: &runtime::SandboxStatus) -> Value {
+    json!({
+        "enabled": status.enabled,
+        "active": status.active,
+        "supported": status.supported,
+        "namespace_supported": status.namespace_supported,
+        "namespace_active": status.namespace_active,
+        "network_supported": status.network_supported,
+        "network_active": status.network_active,
+        "filesystem_mode": status.filesystem_mode.as_str(),
+        "filesystem_active": status.filesystem_active,
+        "allowed_mounts": status.allowed_mounts.clone(),
+        "in_container": status.in_container,
+        "container_markers": status.container_markers.clone(),
+        "fallback_reason": status.fallback_reason.clone(),
+        "requested": {
+            "enabled": status.requested.enabled,
+            "namespace_restrictions": status.requested.namespace_restrictions,
+            "network_isolation": status.requested.network_isolation,
+            "filesystem_mode": status.requested.filesystem_mode.as_str(),
+            "allowed_mounts": status.requested.allowed_mounts.clone(),
+        }
+    })
+}
+
 fn format_commit_preflight_report(branch: Option<&str>, summary: GitWorkspaceSummary) -> String {
    format!(
        "Commit
@@ -3358,16 +3564,25 @@ fn format_commit_skipped_report() -> String {
        .to_string()
 }

-fn print_sandbox_status_snapshot() -> Result<(), Box<dyn std::error::Error>> {
+fn print_sandbox_status_snapshot(
+    output_format: CliOutputFormat,
+) -> Result<(), Box<dyn std::error::Error>> {
    let cwd = env::current_dir()?;
    let loader = ConfigLoader::default_for(&cwd);
    let runtime_config = loader
        .load()
        .unwrap_or_else(|_| runtime::RuntimeConfig::empty());
-    println!(
-        "{}",
-        format_sandbox_report(&resolve_sandbox_status(runtime_config.sandbox(), &cwd))
-    );
+    let sandbox_status = resolve_sandbox_status(runtime_config.sandbox(), &cwd);
+    match output_format {
+        CliOutputFormat::Text => println!("{}", format_sandbox_report(&sandbox_status)),
+        CliOutputFormat::Json => println!(
+            "{}",
+            serialize_json_output(&json!({
+                "kind": "sandbox",
+                "sandbox": sandbox_status_json(&sandbox_status),
+            }))?
+        ),
+    }
    Ok(())
 }

@@ -5650,12 +5865,12 @@ mod tests {
        parse_git_status_branch, parse_git_status_metadata_for, parse_git_workspace_summary,
        permission_policy, print_help_to, push_output_block, render_config_report,
        render_diff_report, render_diff_report_for, render_memory_report, render_repl_help,
-        render_resume_usage, resolve_model_alias, resolve_session_reference, response_to_events,
-        resume_supported_slash_commands, run_resume_command,
-        slash_command_completion_candidates_with_sessions, status_context, validate_no_args,
-        write_mcp_server_fixture, CliAction, CliOutputFormat, CliToolExecutor, GitWorkspaceSummary,
-        InternalPromptProgressEvent, InternalPromptProgressState, LiveCli, SlashCommand,
-        StatusUsage, DEFAULT_MODEL,
+        render_resume_text_output, render_resume_usage, resolve_model_alias,
+        resolve_session_reference, response_to_events, resume_supported_slash_commands,
+        run_resume_command, slash_command_completion_candidates_with_sessions, status_context,
+        validate_no_args, write_mcp_server_fixture, CliAction, CliOutputFormat, CliToolExecutor,
+        GitWorkspaceSummary, InternalPromptProgressEvent, InternalPromptProgressState, LiveCli,
+        SlashCommand, StatusUsage, DEFAULT_MODEL,
    };
    use api::{MessageResponse, OutputContentBlock, Usage};
    use plugins::{
@@ -6063,11 +6278,36 @@ mod tests {
            CliAction::Status {
                model: DEFAULT_MODEL.to_string(),
                permission_mode: PermissionMode::DangerFullAccess,
+                output_format: CliOutputFormat::Text,
            }
        );
        assert_eq!(
            parse_args(&["sandbox".to_string()]).expect("sandbox should parse"),
-            CliAction::Sandbox
+            CliAction::Sandbox {
+                output_format: CliOutputFormat::Text,
+            }
+        );
+    }
+
+    #[test]
+    fn parses_json_output_for_status_and_sandbox_aliases() {
+        let _guard = env_lock();
+        std::env::remove_var("RUSTY_CLAUDE_PERMISSION_MODE");
+        assert_eq!(
+            parse_args(&["--output-format=json".to_string(), "status".to_string()])
+                .expect("json status should parse"),
+            CliAction::Status {
+                model: DEFAULT_MODEL.to_string(),
+                permission_mode: PermissionMode::DangerFullAccess,
+                output_format: CliOutputFormat::Json,
+            }
+        );
+        assert_eq!(
+            parse_args(&["--output-format=json".to_string(), "sandbox".to_string()])
+                .expect("json sandbox should parse"),
+            CliAction::Sandbox {
+                output_format: CliOutputFormat::Json,
+            }
        );
    }

@@ -6173,6 +6413,7 @@ mod tests {
            CliAction::ResumeSession {
                session_path: PathBuf::from("session.jsonl"),
                commands: vec!["/compact".to_string()],
+                output_format: CliOutputFormat::Text,
            }
        );
    }
@@ -6184,6 +6425,7 @@ mod tests {
            CliAction::ResumeSession {
                session_path: PathBuf::from("latest"),
                commands: vec![],
+                output_format: CliOutputFormat::Text,
            }
        );
        assert_eq!(
@@ -6192,6 +6434,7 @@ mod tests {
            CliAction::ResumeSession {
                session_path: PathBuf::from("latest"),
                commands: vec!["/status".to_string()],
+                output_format: CliOutputFormat::Text,
            }
        );
    }
@@ -6214,6 +6457,7 @@ mod tests {
                    "/compact".to_string(),
                    "/cost".to_string(),
                ],
+                output_format: CliOutputFormat::Text,
            }
        );
    }
@@ -6244,6 +6488,7 @@ mod tests {
                    "/export notes.txt".to_string(),
                    "/clear --confirm".to_string(),
                ],
+                output_format: CliOutputFormat::Text,
            }
        );
    }
@@ -6262,6 +6507,25 @@ mod tests {
            CliAction::ResumeSession {
                session_path: PathBuf::from("session.jsonl"),
                commands: vec!["/export /tmp/notes.txt".to_string(), "/status".to_string()],
+                output_format: CliOutputFormat::Text,
+            }
+        );
+    }
+
+    #[test]
+    fn parses_json_output_for_resumed_status_queries() {
+        let args = vec![
+            "--output-format=json".to_string(),
+            "--resume".to_string(),
+            "session.jsonl".to_string(),
+            "/status".to_string(),
+        ];
+        assert_eq!(
+            parse_args(&args).expect("json resume status should parse"),
+            CliAction::ResumeSession {
+                session_path: PathBuf::from("session.jsonl"),
+                commands: vec!["/status".to_string()],
+                output_format: CliOutputFormat::Json,
            }
        );
    }
@@ -6782,10 +7046,16 @@ UU conflicted.rs",

        let session = Session::load_from_path(&session_path).expect("session should load");
        let outcome = with_current_dir(&root, || {
-            run_resume_command(&session_path, &session, &SlashCommand::Diff)
-                .expect("resume diff should work")
+            run_resume_command(
+                &session_path,
+                &session,
+                &SlashCommand::Diff,
+                CliOutputFormat::Text,
+            )
+            .expect("resume diff should work")
        });
-        let message = outcome.message.expect("diff message should exist");
+        let message =
+            render_resume_text_output(&outcome.message.expect("diff message should exist"));
        assert!(message.contains("Unstaged changes:"));
        assert!(message.contains("tracked.txt"));

@@ -7509,8 +7779,12 @@ UU conflicted.rs",
        let runtime_config = loader.load().expect("runtime config should load");
        let state = build_runtime_plugin_state_with_loader(&workspace, &loader, &runtime_config)
            .expect("runtime plugin state should load");
-        let mut executor =
-            CliToolExecutor::new(None, false, state.tool_registry.clone(), state.mcp_state.clone());
+        let mut executor = CliToolExecutor::new(
+            None,
+            false,
+            state.tool_registry.clone(),
+            state.mcp_state.clone(),
+        );

        let search_output = executor
            .execute("ToolSearch", r#"{"query":"remote","max_results":5}"#)
--- a/rust/crates/rusty-claude-cli/tests/cli_flags_and_config_defaults.rs
+++ b/rust/crates/rusty-claude-cli/tests/cli_flags_and_config_defaults.rs
@@ -160,6 +160,42 @@ fn config_command_loads_defaults_from_standard_config_locations() {
    fs::remove_dir_all(temp_dir).expect("cleanup temp dir");
 }

+#[test]
+fn nested_help_flags_render_usage_instead_of_falling_through() {
+    let temp_dir = unique_temp_dir("nested-help");
+    fs::create_dir_all(&temp_dir).expect("temp dir should exist");
+
+    let mcp_output = command_in(&temp_dir)
+        .args(["mcp", "show", "--help"])
+        .output()
+        .expect("claw should launch");
+    assert_success(&mcp_output);
+    let mcp_stdout = String::from_utf8(mcp_output.stdout).expect("stdout should be utf8");
+    assert!(mcp_stdout.contains("Usage            /mcp [list|show <server>|help]"));
+    assert!(mcp_stdout.contains("Unexpected       show"));
+    assert!(!mcp_stdout.contains("server `--help` is not configured"));
+
+    let skills_output = command_in(&temp_dir)
+        .args(["skills", "install", "--help"])
+        .output()
+        .expect("claw should launch");
+    assert_success(&skills_output);
+    let skills_stdout = String::from_utf8(skills_output.stdout).expect("stdout should be utf8");
+    assert!(skills_stdout.contains("Usage            /skills [list|install <path>|help]"));
+    assert!(skills_stdout.contains("Unexpected       install"));
+
+    let unknown_output = command_in(&temp_dir)
+        .args(["mcp", "inspect", "--help"])
+        .output()
+        .expect("claw should launch");
+    assert_success(&unknown_output);
+    let unknown_stdout = String::from_utf8(unknown_output.stdout).expect("stdout should be utf8");
+    assert!(unknown_stdout.contains("Usage            /mcp [list|show <server>|help]"));
+    assert!(unknown_stdout.contains("Unexpected       inspect"));
+
+    fs::remove_dir_all(temp_dir).expect("cleanup temp dir");
+}
+
 fn command_in(cwd: &Path) -> Command {
    let mut command = Command::new(env!("CARGO_BIN_EXE_claw"));
    command.current_dir(cwd);
--- a/rust/crates/rusty-claude-cli/tests/resume_slash_commands.rs
+++ b/rust/crates/rusty-claude-cli/tests/resume_slash_commands.rs
@@ -7,6 +7,7 @@ use std::time::{SystemTime, UNIX_EPOCH};

 use runtime::ContentBlock;
 use runtime::Session;
+use serde_json::Value;

 static TEMP_COUNTER: AtomicU64 = AtomicU64::new(0);

@@ -221,6 +222,52 @@ fn resume_latest_restores_the_most_recent_managed_session() {
    assert!(stdout.contains(newer_path.to_str().expect("utf8 path")));
 }

+#[test]
+fn resumed_status_command_emits_structured_json_when_requested() {
+    // given
+    let temp_dir = unique_temp_dir("resume-status-json");
+    fs::create_dir_all(&temp_dir).expect("temp dir should exist");
+    let session_path = temp_dir.join("session.jsonl");
+
+    let mut session = Session::new();
+    session
+        .push_user_text("resume status json fixture")
+        .expect("session write should succeed");
+    session
+        .save_to_path(&session_path)
+        .expect("session should persist");
+
+    // when
+    let output = run_claw(
+        &temp_dir,
+        &[
+            "--output-format",
+            "json",
+            "--resume",
+            session_path.to_str().expect("utf8 path"),
+            "/status",
+        ],
+    );
+
+    // then
+    assert!(
+        output.status.success(),
+        "stdout:\n{}\n\nstderr:\n{}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    let stdout = String::from_utf8(output.stdout).expect("stdout should be utf8");
+    let parsed: Value =
+        serde_json::from_str(stdout.trim()).expect("resume status output should be json");
+    assert_eq!(parsed["kind"], "status");
+    assert_eq!(parsed["messages"], 1);
+    assert_eq!(
+        parsed["workspace"]["session"],
+        session_path.to_str().expect("utf8 path")
+    );
+}
+
 fn run_claw(current_dir: &Path, args: &[&str]) -> Output {
    run_claw_with_env(current_dir, args, &[])
 }
--- a/rust/crates/tools/src/lane_completion.rs
+++ b/rust/crates/tools/src/lane_completion.rs
@@ -16,9 +16,10 @@ use runtime::{
 use crate::AgentOutput;

 /// Detects if a lane should be automatically marked as completed.
-/// 
+///
 /// Returns `Some(LaneContext)` with `completed = true` if all conditions met,
 /// `None` if lane should remain active.
+#[allow(dead_code)]
 pub(crate) fn detect_lane_completion(
    output: &AgentOutput,
    test_green: bool,
@@ -28,29 +29,29 @@ pub(crate) fn detect_lane_completion(
    if output.error.is_some() {
        return None;
    }
-    
+
    // Must have finished status
    if !output.status.eq_ignore_ascii_case("completed")
        && !output.status.eq_ignore_ascii_case("finished")
    {
        return None;
    }
-    
+
    // Must have no current blocker
    if output.current_blocker.is_some() {
        return None;
    }
-    
+
    // Must have green tests
    if !test_green {
        return None;
    }
-    
+
    // Must have pushed code
    if !has_pushed {
        return None;
    }
-    
+
    // All conditions met — create completed context
    Some(LaneContext {
        lane_id: output.agent_id.clone(),
@@ -65,9 +66,8 @@ pub(crate) fn detect_lane_completion(
 }

 /// Evaluates policy actions for a completed lane.
-pub(crate) fn evaluate_completed_lane(
-    context: &LaneContext,
-) -> Vec<PolicyAction> {
+#[allow(dead_code)]
+pub(crate) fn evaluate_completed_lane(context: &LaneContext) -> Vec<PolicyAction> {
    let engine = PolicyEngine::new(vec![
        PolicyRule::new(
            "closeout-completed-lane",
@@ -85,7 +85,7 @@ pub(crate) fn evaluate_completed_lane(
            5,
        ),
    ]);
-    
+
    evaluate(&engine, context)
 }

@@ -112,53 +112,53 @@ mod tests {
            error: None,
        }
    }
-    
+
    #[test]
    fn detects_completion_when_all_conditions_met() {
        let output = test_output();
        let result = detect_lane_completion(&output, true, true);
-        
+
        assert!(result.is_some());
        let context = result.unwrap();
        assert!(context.completed);
        assert_eq!(context.green_level, 3);
        assert_eq!(context.blocker, LaneBlocker::None);
    }
-    
+
    #[test]
    fn no_completion_when_error_present() {
        let mut output = test_output();
        output.error = Some("Build failed".to_string());
-        
+
        let result = detect_lane_completion(&output, true, true);
        assert!(result.is_none());
    }
-    
+
    #[test]
    fn no_completion_when_not_finished() {
        let mut output = test_output();
        output.status = "Running".to_string();
-        
+
        let result = detect_lane_completion(&output, true, true);
        assert!(result.is_none());
    }
-    
+
    #[test]
    fn no_completion_when_tests_not_green() {
        let output = test_output();
-        
+
        let result = detect_lane_completion(&output, false, true);
        assert!(result.is_none());
    }
-    
+
    #[test]
    fn no_completion_when_not_pushed() {
        let output = test_output();
-        
+
        let result = detect_lane_completion(&output, true, false);
        assert!(result.is_none());
    }
-    
+
    #[test]
    fn evaluate_triggers_closeout_for_completed_lane() {
        let context = LaneContext {
@@ -171,9 +171,9 @@ mod tests {
            completed: true,
            reconciled: false,
        };
-        
+
        let actions = evaluate_completed_lane(&context);
-        
+
        assert!(actions.contains(&PolicyAction::CloseoutLane));
        assert!(actions.contains(&PolicyAction::CleanupSession));
    }
--- a/rust/crates/tools/src/lib.rs
+++ b/rust/crates/tools/src/lib.rs
@@ -17,7 +17,6 @@ use runtime::{
    permission_enforcer::{EnforcementResult, PermissionEnforcer},
    read_file,
    summary_compression::compress_summary_text,
-    TaskPacket,
    task_registry::TaskRegistry,
    team_cron_registry::{CronRegistry, TeamRegistry},
    worker_boot::{WorkerReadySnapshot, WorkerRegistry},
@@ -25,7 +24,7 @@ use runtime::{
    BranchFreshness, ContentBlock, ConversationMessage, ConversationRuntime, GrepSearchInput,
    LaneEvent, LaneEventBlocker, LaneEventName, LaneEventStatus, LaneFailureClass,
    McpDegradedReport, MessageRole, PermissionMode, PermissionPolicy, PromptCacheEvent,
-    RuntimeError, Session, ToolError, ToolExecutor,
+    RuntimeError, Session, TaskPacket, ToolError, ToolExecutor,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
@@ -1878,27 +1877,25 @@ fn branch_divergence_output(
        dangerously_disable_sandbox: None,
        return_code_interpretation: Some("preflight_blocked:branch_divergence".to_string()),
        no_output_expected: Some(false),
-        structured_content: Some(vec![
-            serde_json::to_value(
-                LaneEvent::new(
-                    LaneEventName::BranchStaleAgainstMain,
-                    LaneEventStatus::Blocked,
-                    iso8601_now(),
-                )
-                    .with_failure_class(LaneFailureClass::BranchDivergence)
-                    .with_detail(stderr.clone())
-                    .with_data(json!({
-                        "branch": branch,
-                        "mainRef": main_ref,
-                        "commitsBehind": commits_behind,
-                        "commitsAhead": commits_ahead,
-                        "missingCommits": missing_fixes,
-                        "blockedCommand": command,
-                        "recommendedAction": format!("merge or rebase {main_ref} before workspace tests")
-                    })),
+        structured_content: Some(vec![serde_json::to_value(
+            LaneEvent::new(
+                LaneEventName::BranchStaleAgainstMain,
+                LaneEventStatus::Blocked,
+                iso8601_now(),
            )
-            .expect("lane event should serialize"),
-        ]),
+            .with_failure_class(LaneFailureClass::BranchDivergence)
+            .with_detail(stderr.clone())
+            .with_data(json!({
+                "branch": branch,
+                "mainRef": main_ref,
+                "commitsBehind": commits_behind,
+                "commitsAhead": commits_ahead,
+                "missingCommits": missing_fixes,
+                "blockedCommand": command,
+                "recommendedAction": format!("merge or rebase {main_ref} before workspace tests")
+            })),
+        )
+        .expect("lane event should serialize")]),
        persisted_output_path: None,
        persisted_output_size: None,
        sandbox_status: None,
@@ -2979,15 +2976,21 @@ fn resolve_skill_path(skill: &str) -> Result<std::path::PathBuf, String> {
    }

    let mut candidates = Vec::new();
+    if let Ok(claw_config_home) = std::env::var("CLAW_CONFIG_HOME") {
+        candidates.push(std::path::PathBuf::from(claw_config_home).join("skills"));
+    }
    if let Ok(codex_home) = std::env::var("CODEX_HOME") {
        candidates.push(std::path::PathBuf::from(codex_home).join("skills"));
    }
    if let Ok(home) = std::env::var("HOME") {
        let home = std::path::PathBuf::from(home);
+        candidates.push(home.join(".claw").join("skills"));
        candidates.push(home.join(".agents").join("skills"));
        candidates.push(home.join(".config").join("opencode").join("skills"));
        candidates.push(home.join(".codex").join("skills"));
+        candidates.push(home.join(".claude").join("skills"));
    }
+    candidates.push(std::path::PathBuf::from("/home/bellman/.claw/skills"));
    candidates.push(std::path::PathBuf::from("/home/bellman/.codex/skills"));

    for root in candidates {
@@ -3297,12 +3300,12 @@ fn persist_agent_terminal_state(
    next_manifest.current_blocker = blocker.clone();
    next_manifest.error = error;
    if let Some(blocker) = blocker {
-        next_manifest.lane_events.push(
-            LaneEvent::blocked(iso8601_now(), &blocker),
-        );
-        next_manifest.lane_events.push(
-            LaneEvent::failed(iso8601_now(), &blocker),
-        );
+        next_manifest
+            .lane_events
+            .push(LaneEvent::blocked(iso8601_now(), &blocker));
+        next_manifest
+            .lane_events
+            .push(LaneEvent::failed(iso8601_now(), &blocker));
    } else {
        next_manifest.current_blocker = None;
        let compressed_detail = result
@@ -4952,8 +4955,8 @@ mod tests {
        agent_permission_policy, allowed_tools_for_subagent, classify_lane_failure,
        execute_agent_with_spawn, execute_tool, final_assistant_text, mvp_tool_specs,
        permission_mode_from_plugin, persist_agent_terminal_state, push_output_block,
-        run_task_packet, AgentInput, AgentJob, GlobalToolRegistry, LaneEventName,
-        LaneFailureClass, SubagentToolExecutor,
+        run_task_packet, AgentInput, AgentJob, GlobalToolRegistry, LaneEventName, LaneFailureClass,
+        SubagentToolExecutor,
    };
    use api::OutputContentBlock;
    use runtime::{
@@ -5977,7 +5980,10 @@ mod tests {
                "gateway routing rejected the request",
                LaneFailureClass::GatewayRouting,
            ),
-            ("tool failed: denied tool execution from hook", LaneFailureClass::ToolRuntime),
+            (
+                "tool failed: denied tool execution from hook",
+                LaneFailureClass::ToolRuntime,
+            ),
            ("thread creation failed", LaneFailureClass::Infra),
        ];

@@ -6000,11 +6006,17 @@ mod tests {
            (LaneEventName::MergeReady, "lane.merge.ready"),
            (LaneEventName::Finished, "lane.finished"),
            (LaneEventName::Failed, "lane.failed"),
-            (LaneEventName::BranchStaleAgainstMain, "branch.stale_against_main"),
+            (
+                LaneEventName::BranchStaleAgainstMain,
+                "branch.stale_against_main",
+            ),
        ];

        for (event, expected) in cases {
-            assert_eq!(serde_json::to_value(event).expect("serialize lane event"), json!(expected));
+            assert_eq!(
+                serde_json::to_value(event).expect("serialize lane event"),
+                json!(expected)
+            );
        }
    }
Author	SHA1	Message	Date
Yeachan-Heo	c65126a339	Make .claw the only user-facing config namespace Agents, skills, and init output were still surfacing .codex/.claude paths even though the runtime already treats .claw as the canonical config home. This updates help text, reports, skill install defaults, and repo bootstrap output to present a single .claw namespace while keeping legacy discovery fallbacks in place for existing setups. Constraint: Existing .codex/.claude agent and skill directories still need to load for compatibility Rejected: Remove legacy discovery entirely \| would break existing user setups instead of just cleaning up surfaced output Confidence: high Scope-risk: moderate Reversibility: clean Directive: Keep future user-facing config, agent, and skill path copy aligned to .claw and even when legacy fallbacks remain supported internally Tested: cargo fmt --all --check; cargo test --workspace --exclude compat-harness Not-tested: cargo clippy --workspace --all-targets -- -D warnings \| fails in pre-existing unrelated runtime files (for example mcp_lifecycle_hardened.rs, mcp_tool_bridge.rs, lsp_client.rs, permission_enforcer.rs, recovery_recipes.rs, stale_branch.rs, task_registry.rs, team_cron_registry.rs, worker_boot.rs)	2026-04-05 17:27:46 +00:00
Yeachan-Heo	31163be347	style: cargo fmt	2026-04-05 16:56:48 +00:00
Yeachan-Heo	eb4d3b11ee	merge fix/p2-19-subcommand-help-fallthrough	2026-04-05 16:54:59 +00:00
Yeachan-Heo	9bd7a78ca8	Merge branch 'fix/p2-18-context-window-preflight'	2026-04-05 16:54:45 +00:00
Yeachan-Heo	24d8f916c8	merge fix/p0-10-json-status	2026-04-05 16:54:38 +00:00
Yeachan-Heo	30883bddbd	Keep doctor and local help paths shell-native Promote doctor into a real top-level CLI action, reuse the same local report for resumed and REPL doctor invocations, and intercept doctor/status/sandbox help flags before prompt-mode dispatch. The parser change also closes the help fallthrough that previously wandered into runtime startup for local-info commands. Constraint: Preserve prompt shorthand for normal multi-word text input while fixing exact local subcommand help paths Rejected: Route \7[1G[2K[m⠋ 🦀 Thinking...[0m8[1G[2K[m✘ ❌ Request failed [0m through prompt/slash guidance \| still shells out through the wrong surface and keeps health checks hidden Rejected: Reuse the status report as doctor output \| status does not explain auth/config health or expose a dedicated diagnostic summary Confidence: high Scope-risk: narrow Directive: Keep doctor local-only unless an explicit network probe is intentionally added and separately tested Tested: cargo build -p rusty-claude-cli; cargo test -p rusty-claude-cli; cargo run -p rusty-claude-cli -- doctor --help; CLAW_CONFIG_HOME=/tmp/tmp.7pm9SVzOPN ANTHROPIC_API_KEY= ANTHROPIC_AUTH_TOKEN= cargo run -p rusty-claude-cli -- doctor Not-tested: direct /doctor outside the REPL remains interactive-only	2026-04-05 16:44:36 +00:00
Yeachan-Heo	1a2fa1581e	Keep status JSON machine-readable for automation The global --output-format json flag already reached prompt-mode responses, but status and sandbox still bypassed that path and printed human-readable tables. This change threads the selected output format through direct command aliases and resumed slash-command execution so status queries emit valid structured JSON instead of mixed prose. It also adds end-to-end regression coverage for direct status/sandbox JSON and resumed /status JSON so shell automation can rely on stable parsing. Constraint: Global output formatting must stay compatible with existing text-mode reports Rejected: Require callers to scrape text status tables \| fragile and breaks automation Confidence: high Scope-risk: narrow Directive: New direct commands that honor --output-format should thread the format through CliAction and resumed slash execution paths Tested: cargo build -p rusty-claude-cli Tested: cargo test -p rusty-claude-cli -- --nocapture Tested: cargo test --workspace Tested: cargo run -q -p rusty-claude-cli -- --output-format json status Tested: cargo run -q -p rusty-claude-cli -- --output-format json sandbox Not-tested: cargo clippy --workspace --all-targets -- -D warnings (fails in pre-existing runtime files unrelated to this change)	2026-04-05 16:41:02 +00:00
Yeachan-Heo	fa72cd665e	Block oversized requests before providers hard-fail The runtime already tracked rough token estimates for compaction, but provider-bound requests still relied on naive model output limits and could be sent upstream even when the selected model could not fit the estimated prompt plus requested output. This adds a small model token/context registry in the API layer, estimates request size from the serialized prompt payload, and fails locally with a dedicated context-window error before Anthropic or xAI calls are made. Focused integration coverage asserts the preflight fires before any HTTP request leaves the process. Constraint: Keep the first pass minimal and reusable across both Anthropic and OpenAI-compatible providers Rejected: Auto-compact-and-retry in the same patch \| broader control-flow change than the requested minimal preflight Confidence: medium Scope-risk: narrow Reversibility: clean Directive: Expand the model registry before enabling preflight for additional providers or aliases Tested: cargo build -p api -p tools -p rusty-claude-cli; cargo test -p api Not-tested: End-to-end CLI auto-compaction or retry behavior after a local context_window_blocked failure	2026-04-05 16:39:58 +00:00
Yeachan-Heo	1f53d961ff	Route nested CLI help requests to usage instead of operand fallthrough The direct CLI wrappers for agents, skills, and mcp treated nested help flags as ordinary operands. That made commands like `claw mcp show --help` report a missing server and `claw skills install --help` fall into filesystem install logic instead of surfacing usage. This change normalizes help-path arguments before dispatch so nested help stays on the help path. The regression tests cover both handler-level behavior and end-to-end CLI output for nested help and unknown subcommands with trailing help flags. Constraint: Keep the fix scoped to direct CLI slash-command wrappers without changing unrelated parser behavior Rejected: Rework top-level argument parsing for all subcommands \| broader risk than needed for the regression Confidence: high Scope-risk: narrow Reversibility: clean Directive: If more nested subcommands are added, extend the help-path normalization table before relying on raw operand dispatch Tested: cargo build -p commands -p rusty-claude-cli Tested: cargo test -p commands -p rusty-claude-cli Not-tested: cargo clippy -p commands -p rusty-claude-cli --all-targets --no-deps -- -D warnings (pre-existing warnings in untouched files block clean run)	2026-04-05 16:38:43 +00:00
Yeachan-Heo	b9c5cc118e	docs: add subcommand help fallthrough pinpoint	2026-04-05 14:46:02 +00:00
Yeachan-Heo	38fa2778af	docs: add context-window preflight gap pinpoint	2026-04-05 14:46:02 +00:00
Yeachan-Heo	c4d4daa41d	docs: add P2.16 orphaned module integration audit pinpoint session_control is pub exported but has zero consumers workspace-wide. trust_resolver types are re-exported but never instantiated outside unit tests. These implement core clawability contracts that are structurally dead — built but not wired into the actual execution path.	2026-04-05 14:46:02 +00:00
Yeachan-Heo	3df5dece39	fix: suppress dead_code warnings for unused file_ops functions	2026-04-05 03:23:51 +00:00
Yeachan-Heo	cd1ee43f33	fix: suppress dead_code warnings for unused provider and lane completion items	2026-04-05 03:22:32 +00:00
Yeachan-Heo	1fb3759e7c	fix: remove unused imports in session_control.rs	2026-04-05 03:21:55 +00:00
Yeachan-Heo	6b73f7f410	docs: add roadmap item for output format contract audit	2026-04-04 23:00:49 +00:00
Yeachan-Heo	f30251a9e1	docs: add roadmap item for json inventory command output	2026-04-04 22:30:46 +00:00
Yeachan-Heo	b0b655d417	docs: add roadmap item for config namespace unification	2026-04-04 22:01:03 +00:00
Yeachan-Heo	8e72aaee2e	docs: add roadmap item for json status output parity	2026-04-04 21:30:47 +00:00
Yeachan-Heo	1ceb077e40	docs: add roadmap item for top-level doctor command	2026-04-04 21:00:54 +00:00
Yeachan-Heo	58903cef75	docs: add roadmap item for warning-free first-run UX	2026-04-04 20:30:46 +00:00
Yeachan-Heo	cad1ac32a0	docs: add roadmap item for README reality reconciliation	2026-04-04 20:00:36 +00:00
Yeachan-Heo	1f52ce25fb	docs: fix stale star history branding and add docs residue check	2026-04-04 19:30:54 +00:00
Yeachan-Heo	9350e70bc5	docs: add roadmap item for doctor discoverability	2026-04-04 19:00:45 +00:00
Yeachan-Heo	25a19792aa	docs: add roadmap item for container-first docs	2026-04-04 18:30:34 +00:00
Yeachan-Heo	89a869e261	docs: add roadmap item for release-grade binary workflow	2026-04-04 18:00:37 +00:00
Yeachan-Heo	460284e7df	docs: add roadmap item for workspace-grade ci coverage	2026-04-04 17:30:35 +00:00
Yeachan-Heo	feddbdd598	docs: add roadmap item for commit provenance push events	2026-04-04 17:00:46 +00:00
Yeachan-Heo	c99ee2f65d	docs: switch community section to ultraworkers discord	2026-04-04 16:56:31 +00:00
Yeachan-Heo	78fd0216f4	docs: add philosophy document for autonomous claw development	2026-04-04 16:51:51 +00:00
Yeachan-Heo	aca03fc3f9	docs: rewrite README around autonomous claw maintenance	2026-04-04 16:50:05 +00:00
Yeachan-Heo	9a7aab5259	docs: replace instructkr sponsor callout with ultraworkers shout-out	2026-04-04 16:49:02 +00:00