Replace bespoke CLI line editing with rustyline and canonical model aliases

The REPL now wraps rustyline::Editor instead of maintaining a custom raw-mode input stack. This preserves the existing LineEditor surface while delegating history, completion, and interactive editing to a maintained library. The CLI argument parser and /model command path also normalize shorthand model names to our current canonical Anthropic identifiers. Constraint: User requested rustyline 15 specifically for the CLI editor rewrite Constraint: Existing LineEditor constructor and read_line API had to remain stable Rejected: Keep extending the crossterm-based editor | custom key handling and history logic were redundant with rustyline Rejected: Resolve aliases only for --model flags | /model would still diverge from CLI startup behavior Confidence: high Scope-risk: moderate Reversibility: clean Directive: Keep model alias normalization centralized in main.rs so CLI flag parsing and /model stay in sync Tested: cargo check --workspace Tested: cargo test --workspace Tested: cargo build --workspace Tested: cargo clippy --workspace --all-targets -- -D warnings Not-tested: Interactive manual terminal validation of Shift+Enter behavior across terminal emulators
fix: default model to claude-opus-4-6
2026-04-01 02:04:12 +00:00 · 2026-04-01 01:48:21 +00:00 · 2026-04-01 01:47:32 +00:00 · 2026-04-01 01:46:17 +00:00 · 2026-04-01 01:44:55 +00:00 · 2026-04-01 01:43:40 +00:00
25 changed files with 1341 additions and 921 deletions
--- a/.claude/sessions/session-1775007533836.json
+++ b/.claude/sessions/session-1775007533836.json
@@ -0,0 +1 @@
+{"messages":[],"version":1}
--- a/.claude/sessions/session-1775007622154.json
+++ b/.claude/sessions/session-1775007622154.json
@@ -0,0 +1 @@
+{"messages":[{"blocks":[{"text":"What is 2+2? Reply with just the number.","type":"text"}],"role":"user"},{"blocks":[{"text":"4","type":"text"}],"role":"assistant","usage":{"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"input_tokens":19,"output_tokens":5}}],"version":1}
--- a/.claude/sessions/session-1775007632904.json
+++ b/.claude/sessions/session-1775007632904.json
@@ -0,0 +1 @@
+{"messages":[{"blocks":[{"text":"Say hello in exactly 3 words","type":"text"}],"role":"user"},{"blocks":[{"text":"Hello there, friend!","type":"text"}],"role":"assistant","usage":{"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"input_tokens":14,"output_tokens":8}}],"version":1}
--- a/.claude/sessions/session-1775007846522.json
+++ b/.claude/sessions/session-1775007846522.json
@@ -0,0 +1 @@
+{"messages":[{"blocks":[{"text":"Say hi in one sentence","type":"text"}],"role":"user"},{"blocks":[{"text":"Hi! I'm Claude, ready to help you with any software engineering tasks or questions you have.","type":"text"}],"role":"assistant","usage":{"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"input_tokens":11,"output_tokens":23}}],"version":1}
--- a/rust/.claude/sessions/session-1775007453382.json
+++ b/rust/.claude/sessions/session-1775007453382.json
@@ -0,0 +1 @@
+{"messages":[],"version":1}
--- a/rust/.claude/sessions/session-1775007484031.json
+++ b/rust/.claude/sessions/session-1775007484031.json
@@ -0,0 +1 @@
+{"messages":[],"version":1}
--- a/rust/.claude/sessions/session-1775007490104.json
+++ b/rust/.claude/sessions/session-1775007490104.json
@@ -0,0 +1 @@
+{"messages":[],"version":1}
--- a/rust/.claude/sessions/session-1775007981374.json
+++ b/rust/.claude/sessions/session-1775007981374.json
@@ -0,0 +1 @@
+{"messages":[],"version":1}
--- a/rust/.claude/sessions/session-1775008007069.json
+++ b/rust/.claude/sessions/session-1775008007069.json
@@ -0,0 +1 @@
+{"messages":[],"version":1}
--- a/rust/.claude/sessions/session-1775008071886.json
+++ b/rust/.claude/sessions/session-1775008071886.json
@@ -0,0 +1 @@
+{"messages":[],"version":1}
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -98,6 +98,15 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"

+[[package]]
+name = "clipboard-win"
+version = "5.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bde03770d3df201d4fb868f2c9c59e66a3e4e2bd06692a0fe701e7103c7e84d4"
+dependencies = [
+ "error-code",
+]
+
 [[package]]
 name = "commands"
 version = "0.1.0"
@@ -142,7 +151,7 @@ dependencies = [
 "crossterm_winapi",
 "mio",
 "parking_lot",
- "rustix",
+ "rustix 0.38.44",
 "signal-hook",
 "signal-hook-mio",
 "winapi",
@@ -197,6 +206,12 @@ dependencies = [
 "syn",
 ]

+[[package]]
+name = "endian-type"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c34f04666d835ff5d62e058c3995147c06f42fe86ff053337632bca83e42702d"
+
 [[package]]
 name = "equivalent"
 version = "1.0.2"
@@ -213,6 +228,23 @@ dependencies = [
 "windows-sys 0.61.2",
 ]

+[[package]]
+name = "error-code"
+version = "3.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dea2df4cf52843e0452895c455a1a2cfbb842a1e7329671acf418fdc53ed4c59"
+
+[[package]]
+name = "fd-lock"
+version = "4.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ce92ff622d6dadf7349484f42c93271a0d49b7cc4d466a936405bacbe10aa78"
+dependencies = [
+ "cfg-if",
+ "rustix 1.1.4",
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "find-msvc-tools"
 version = "0.1.9"
@@ -351,6 +383,15 @@ version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"

+[[package]]
+name = "home"
+version = "0.5.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc627f471c528ff0c4a49e1d5e60450c8f6461dd6d10ba9dcd3a61d3dff7728d"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "http"
 version = "1.4.0"
@@ -614,6 +655,12 @@ version = "0.4.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"

+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
 [[package]]
 name = "litemap"
 version = "0.8.1"
@@ -669,6 +716,27 @@ dependencies = [
 "windows-sys 0.61.2",
 ]

+[[package]]
+name = "nibble_vec"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77a5d83df9f36fe23f0c3648c6bbb8b0298bb5f1939c8f2704431371f4b84d43"
+dependencies = [
+ "smallvec",
+]
+
+[[package]]
+name = "nix"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "cfg_aliases",
+ "libc",
+]
+
 [[package]]
 name = "num-conv"
 version = "0.2.1"
@@ -888,6 +956,16 @@ version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"

+[[package]]
+name = "radix_trie"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c069c179fcdc6a2fe24d8d18305cf085fdbd4f922c041943e203685d6a1c58fd"
+dependencies = [
+ "endian-type",
+ "nibble_vec",
+]
+
 [[package]]
 name = "rand"
 version = "0.9.2"
@@ -1037,10 +1115,23 @@ dependencies = [
 "bitflags",
 "errno",
 "libc",
- "linux-raw-sys",
+ "linux-raw-sys 0.4.15",
 "windows-sys 0.52.0",
 ]

+[[package]]
+name = "rustix"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.12.1",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "rustls"
 version = "0.23.37"
@@ -1092,12 +1183,35 @@ dependencies = [
 "crossterm",
 "pulldown-cmark",
 "runtime",
+ "rustyline",
 "serde_json",
 "syntect",
 "tokio",
 "tools",
 ]

+[[package]]
+name = "rustyline"
+version = "15.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ee1e066dc922e513bda599c6ccb5f3bb2b0ea5870a579448f2622993f0a9a2f"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "clipboard-win",
+ "fd-lock",
+ "home",
+ "libc",
+ "log",
+ "memchr",
+ "nix",
+ "radix_trie",
+ "unicode-segmentation",
+ "unicode-width",
+ "utf8parse",
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "ryu"
 version = "1.0.23"
@@ -1525,6 +1639,12 @@ version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"

+[[package]]
+name = "unicode-segmentation"
+version = "1.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9629274872b2bfaf8d66f5f15725007f635594914870f65218920345aa11aa8c"
+
 [[package]]
 name = "unicode-width"
 version = "0.2.2"
@@ -1555,6 +1675,12 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"

+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
 [[package]]
 name = "version_check"
 version = "0.9.5"
@@ -1725,6 +1851,15 @@ dependencies = [
 "windows-targets 0.52.6",
 ]

+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.60.2"
--- a/rust/README.md
+++ b/rust/README.md
@@ -84,6 +84,15 @@ cargo run -p rusty-claude-cli -- logout

 This removes only the stored OAuth credentials and preserves unrelated JSON fields in `credentials.json`.

+### Self-update
+
+```bash
+cd rust
+cargo run -p rusty-claude-cli -- self-update
+```
+
+The command checks the latest GitHub release for `instructkr/clawd-code`, compares it to the current binary version, downloads the matching binary asset plus checksum manifest, verifies SHA-256, replaces the current executable, and prints the release changelog. If no published release or matching asset exists, it exits safely with an explanatory message.
+
 ## Usage examples

 ### 1) Prompt mode
@@ -109,6 +118,13 @@ cd rust
 cargo run -p rusty-claude-cli -- --allowedTools read,glob
 ```

+Bootstrap Claude project files for the current repo:
+
+```bash
+cd rust
+cargo run -p rusty-claude-cli -- init
+```
+
 ### 2) REPL mode

 Start the interactive shell:
@@ -133,6 +149,7 @@ Inside the REPL, useful commands include:
 /diff
 /version
 /export notes.txt
+/sessions
 /session list
 /exit
 ```
@@ -143,14 +160,14 @@ Inspect or maintain a saved session file without entering the REPL:

 ```bash
 cd rust
-cargo run -p rusty-claude-cli -- --resume session.json /status /compact /cost
+cargo run -p rusty-claude-cli -- --resume session-123456 /status /compact /cost
 ```

 You can also inspect memory/config state for a restored session:

 ```bash
 cd rust
-cargo run -p rusty-claude-cli -- --resume session.json /memory /config
+cargo run -p rusty-claude-cli -- --resume ~/.claude/sessions/session-123456.json /memory /config
 ```

 ## Available commands
@@ -158,10 +175,11 @@ cargo run -p rusty-claude-cli -- --resume session.json /memory /config
 ### Top-level CLI commands

 - `prompt <text...>` — run one prompt non-interactively
- `--resume <session.json> [/commands...]` — inspect or maintain a saved session
+- `--resume <session-id-or-path> [/commands...]` — inspect or maintain a saved session stored under `~/.claude/sessions/`
 - `dump-manifests` — print extracted upstream manifest counts
 - `bootstrap-plan` — print the current bootstrap skeleton
 - `system-prompt [--cwd PATH] [--date YYYY-MM-DD]` — render the synthesized system prompt
+- `self-update` — update the installed binary from the latest GitHub release when a matching asset is available
 - `--help` / `-h` — show CLI help
 - `--version` / `-V` — print the CLI version and build info locally (no API call)
 - `--output-format text|json` — choose non-interactive prompt output rendering
@@ -176,13 +194,14 @@ cargo run -p rusty-claude-cli -- --resume session.json /memory /config
 - `/permissions [read-only|workspace-write|danger-full-access]` — inspect or switch permissions
 - `/clear [--confirm]` — clear the current local session
 - `/cost` — show token usage totals
- `/resume <session-path>` — load a saved session into the REPL
+- `/resume <session-id-or-path>` — load a saved session into the REPL
 - `/config [env|hooks|model]` — inspect discovered Claude config
 - `/memory` — inspect loaded instruction memory files
- `/init` — create a starter `CLAUDE.md`
+- `/init` — bootstrap `.claude.json`, `.claude/`, `CLAUDE.md`, and local ignore rules
 - `/diff` — show the current git diff for the workspace
 - `/version` — print version and build metadata locally
 - `/export [file]` — export the current conversation transcript
+- `/sessions` — list recent managed local sessions from `~/.claude/sessions/`
 - `/session [list|switch <session-id>]` — inspect or switch managed local sessions
 - `/exit` — leave the REPL

--- a/rust/crates/api/src/client.rs
+++ b/rust/crates/api/src/client.rs
@@ -520,7 +520,8 @@ fn read_auth_token() -> Option<String> {
        .and_then(std::convert::identity)
 }

-fn read_base_url() -> String {
+#[must_use]
+pub fn read_base_url() -> String {
    std::env::var("ANTHROPIC_BASE_URL").unwrap_or_else(|_| DEFAULT_BASE_URL.to_string())
 }

@@ -906,7 +907,7 @@ mod tests {
    #[test]
    fn message_request_stream_helper_sets_stream_true() {
        let request = MessageRequest {
-            model: "claude-3-7-sonnet-latest".to_string(),
+            model: "claude-opus-4-6".to_string(),
            max_tokens: 64,
            messages: vec![],
            system: None,
--- a/rust/crates/api/src/lib.rs
+++ b/rust/crates/api/src/lib.rs
@@ -4,8 +4,8 @@ mod sse;
 mod types;

 pub use client::{
-    oauth_token_is_expired, resolve_saved_oauth_token, resolve_startup_auth_source,
-    AnthropicClient, AuthSource, MessageStream, OAuthTokenSet,
+    oauth_token_is_expired, read_base_url, resolve_saved_oauth_token,
+    resolve_startup_auth_source, AnthropicClient, AuthSource, MessageStream, OAuthTokenSet,
 };
 pub use error::ApiError;
 pub use sse::{parse_frame, SseParser};
--- a/rust/crates/commands/src/lib.rs
+++ b/rust/crates/commands/src/lib.rs
@@ -51,12 +51,6 @@ const SLASH_COMMAND_SPECS: &[SlashCommandSpec] = &[
        argument_hint: None,
        resume_supported: true,
    },
-    SlashCommandSpec {
-        name: "sandbox",
-        summary: "Show sandbox isolation status",
-        argument_hint: None,
-        resume_supported: true,
-    },
    SlashCommandSpec {
        name: "compact",
        summary: "Compact local session history",
@@ -141,7 +135,6 @@ const SLASH_COMMAND_SPECS: &[SlashCommandSpec] = &[
 pub enum SlashCommand {
    Help,
    Status,
-    Sandbox,
    Compact,
    Model {
        model: Option<String>,
@@ -186,7 +179,6 @@ impl SlashCommand {
        Some(match command {
            "help" => Self::Help,
            "status" => Self::Status,
-            "sandbox" => Self::Sandbox,
            "compact" => Self::Compact,
            "model" => Self::Model {
                model: parts.next().map(ToOwned::to_owned),
@@ -287,7 +279,6 @@ pub fn handle_slash_command(
            session: session.clone(),
        }),
        SlashCommand::Status
-        | SlashCommand::Sandbox
        | SlashCommand::Model { .. }
        | SlashCommand::Permissions { .. }
        | SlashCommand::Clear { .. }
@@ -316,7 +307,6 @@ mod tests {
    fn parses_supported_slash_commands() {
        assert_eq!(SlashCommand::parse("/help"), Some(SlashCommand::Help));
        assert_eq!(SlashCommand::parse(" /status "), Some(SlashCommand::Status));
-        assert_eq!(SlashCommand::parse("/sandbox"), Some(SlashCommand::Sandbox));
        assert_eq!(
            SlashCommand::parse("/model claude-opus"),
            Some(SlashCommand::Model {
@@ -383,7 +373,6 @@ mod tests {
        assert!(help.contains("works with --resume SESSION.json"));
        assert!(help.contains("/help"));
        assert!(help.contains("/status"));
-        assert!(help.contains("/sandbox"));
        assert!(help.contains("/compact"));
        assert!(help.contains("/model [model]"));
        assert!(help.contains("/permissions [read-only|workspace-write|danger-full-access]"));
@@ -397,8 +386,8 @@ mod tests {
        assert!(help.contains("/version"));
        assert!(help.contains("/export [file]"));
        assert!(help.contains("/session [list|switch <session-id>]"));
-        assert_eq!(slash_command_specs().len(), 16);
-        assert_eq!(resume_supported_slash_commands().len(), 12);
+        assert_eq!(slash_command_specs().len(), 15);
+        assert_eq!(resume_supported_slash_commands().len(), 11);
    }

    #[test]
@@ -445,7 +434,6 @@ mod tests {
        let session = Session::new();
        assert!(handle_slash_command("/unknown", &session, CompactionConfig::default()).is_none());
        assert!(handle_slash_command("/status", &session, CompactionConfig::default()).is_none());
-        assert!(handle_slash_command("/sandbox", &session, CompactionConfig::default()).is_none());
        assert!(
            handle_slash_command("/model claude", &session, CompactionConfig::default()).is_none()
        );
--- a/rust/crates/runtime/src/conversation.rs
+++ b/rust/crates/runtime/src/conversation.rs
@@ -414,6 +414,7 @@ mod tests {
                cwd: PathBuf::from("/tmp/project"),
                current_date: "2026-03-31".to_string(),
                git_status: None,
+                git_diff: None,
                instruction_files: Vec::new(),
            })
            .with_os("linux", "6.8")
--- a/rust/crates/runtime/src/lib.rs
+++ b/rust/crates/runtime/src/lib.rs
@@ -12,7 +12,7 @@ mod oauth;
 mod permissions;
 mod prompt;
 mod remote;
-mod sandbox;
+pub mod sandbox;
 mod session;
 mod usage;

@@ -74,12 +74,6 @@ pub use remote::{
    RemoteSessionContext, UpstreamProxyBootstrap, UpstreamProxyState, DEFAULT_REMOTE_BASE_URL,
    DEFAULT_SESSION_TOKEN_PATH, DEFAULT_SYSTEM_CA_BUNDLE, NO_PROXY_HOSTS, UPSTREAM_PROXY_ENV_KEYS,
 };
-pub use sandbox::{
-    build_linux_sandbox_command, detect_container_environment, detect_container_environment_from,
-    resolve_sandbox_status, resolve_sandbox_status_for_request, ContainerEnvironment,
-    FilesystemIsolationMode, LinuxSandboxCommand, SandboxConfig, SandboxDetectionInputs,
-    SandboxRequest, SandboxStatus,
-};
 pub use session::{ContentBlock, ConversationMessage, MessageRole, Session, SessionError};
 pub use usage::{
    format_usd, pricing_for_model, ModelPricing, TokenUsage, UsageCostEstimate, UsageTracker,
--- a/rust/crates/runtime/src/prompt.rs
+++ b/rust/crates/runtime/src/prompt.rs
@@ -50,6 +50,7 @@ pub struct ProjectContext {
    pub cwd: PathBuf,
    pub current_date: String,
    pub git_status: Option<String>,
+    pub git_diff: Option<String>,
    pub instruction_files: Vec<ContextFile>,
 }

@@ -64,6 +65,7 @@ impl ProjectContext {
            cwd,
            current_date: current_date.into(),
            git_status: None,
+            git_diff: None,
            instruction_files,
        })
    }
@@ -74,6 +76,7 @@ impl ProjectContext {
    ) -> std::io::Result<Self> {
        let mut context = Self::discover(cwd, current_date)?;
        context.git_status = read_git_status(&context.cwd);
+        context.git_diff = read_git_diff(&context.cwd);
        Ok(context)
    }
 }
@@ -239,6 +242,38 @@ fn read_git_status(cwd: &Path) -> Option<String> {
    }
 }

+fn read_git_diff(cwd: &Path) -> Option<String> {
+    let mut sections = Vec::new();
+
+    let staged = read_git_output(cwd, &["diff", "--cached"])?;
+    if !staged.trim().is_empty() {
+        sections.push(format!("Staged changes:\n{}", staged.trim_end()));
+    }
+
+    let unstaged = read_git_output(cwd, &["diff"])?;
+    if !unstaged.trim().is_empty() {
+        sections.push(format!("Unstaged changes:\n{}", unstaged.trim_end()));
+    }
+
+    if sections.is_empty() {
+        None
+    } else {
+        Some(sections.join("\n\n"))
+    }
+}
+
+fn read_git_output(cwd: &Path, args: &[&str]) -> Option<String> {
+    let output = Command::new("git")
+        .args(args)
+        .current_dir(cwd)
+        .output()
+        .ok()?;
+    if !output.status.success() {
+        return None;
+    }
+    String::from_utf8(output.stdout).ok()
+}
+
 fn render_project_context(project_context: &ProjectContext) -> String {
    let mut lines = vec!["# Project context".to_string()];
    let mut bullets = vec![
@@ -257,6 +292,11 @@ fn render_project_context(project_context: &ProjectContext) -> String {
        lines.push("Git status snapshot:".to_string());
        lines.push(status.clone());
    }
+    if let Some(diff) = &project_context.git_diff {
+        lines.push(String::new());
+        lines.push("Git diff snapshot:".to_string());
+        lines.push(diff.clone());
+    }
    lines.join("\n")
 }

@@ -577,6 +617,49 @@ mod tests {
        assert!(status.contains("## No commits yet on") || status.contains("## "));
        assert!(status.contains("?? CLAUDE.md"));
        assert!(status.contains("?? tracked.txt"));
+        assert!(context.git_diff.is_none());
+
+        fs::remove_dir_all(root).expect("cleanup temp dir");
+    }
+
+    #[test]
+    fn discover_with_git_includes_diff_snapshot_for_tracked_changes() {
+        let root = temp_dir();
+        fs::create_dir_all(&root).expect("root dir");
+        std::process::Command::new("git")
+            .args(["init", "--quiet"])
+            .current_dir(&root)
+            .status()
+            .expect("git init should run");
+        std::process::Command::new("git")
+            .args(["config", "user.email", "tests@example.com"])
+            .current_dir(&root)
+            .status()
+            .expect("git config email should run");
+        std::process::Command::new("git")
+            .args(["config", "user.name", "Runtime Prompt Tests"])
+            .current_dir(&root)
+            .status()
+            .expect("git config name should run");
+        fs::write(root.join("tracked.txt"), "hello\n").expect("write tracked file");
+        std::process::Command::new("git")
+            .args(["add", "tracked.txt"])
+            .current_dir(&root)
+            .status()
+            .expect("git add should run");
+        std::process::Command::new("git")
+            .args(["commit", "-m", "init", "--quiet"])
+            .current_dir(&root)
+            .status()
+            .expect("git commit should run");
+        fs::write(root.join("tracked.txt"), "hello\nworld\n").expect("rewrite tracked file");
+
+        let context =
+            ProjectContext::discover_with_git(&root, "2026-03-31").expect("context should load");
+
+        let diff = context.git_diff.expect("git diff should be present");
+        assert!(diff.contains("Unstaged changes:"));
+        assert!(diff.contains("tracked.txt"));

        fs::remove_dir_all(root).expect("cleanup temp dir");
    }
--- a/rust/crates/rusty-claude-cli/Cargo.toml
+++ b/rust/crates/rusty-claude-cli/Cargo.toml
@@ -5,12 +5,17 @@ edition.workspace = true
 license.workspace = true
 publish.workspace = true

+[[bin]]
+name = "claw"
+path = "src/main.rs"
+
 [dependencies]
 api = { path = "../api" }
 commands = { path = "../commands" }
 compat-harness = { path = "../compat-harness" }
 crossterm = "0.28"
 pulldown-cmark = "0.13"
+rustyline = "15"
 runtime = { path = "../runtime" }
 serde_json = "1"
 syntect = "5"
--- a/rust/crates/rusty-claude-cli/src/args.rs
+++ b/rust/crates/rusty-claude-cli/src/args.rs
@@ -9,7 +9,7 @@ use clap::{Parser, Subcommand, ValueEnum};
    about = "Rust Claude CLI prototype"
 )]
 pub struct Cli {
-    #[arg(long, default_value = "claude-3-7-sonnet")]
+    #[arg(long, default_value = "claude-opus-4-6")]
    pub model: String,

    #[arg(long, value_enum, default_value_t = PermissionMode::WorkspaceWrite)]
--- a/rust/crates/rusty-claude-cli/src/init.rs
+++ b/rust/crates/rusty-claude-cli/src/init.rs
@@ -0,0 +1,433 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+
+const STARTER_CLAUDE_JSON: &str = concat!(
+    "{\n",
+    "  \"permissions\": {\n",
+    "    \"defaultMode\": \"acceptEdits\"\n",
+    "  }\n",
+    "}\n",
+);
+const GITIGNORE_COMMENT: &str = "# Claude Code local artifacts";
+const GITIGNORE_ENTRIES: [&str; 2] = [".claude/settings.local.json", ".claude/sessions/"];
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum InitStatus {
+    Created,
+    Updated,
+    Skipped,
+}
+
+impl InitStatus {
+    #[must_use]
+    pub(crate) fn label(self) -> &'static str {
+        match self {
+            Self::Created => "created",
+            Self::Updated => "updated",
+            Self::Skipped => "skipped (already exists)",
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct InitArtifact {
+    pub(crate) name: &'static str,
+    pub(crate) status: InitStatus,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct InitReport {
+    pub(crate) project_root: PathBuf,
+    pub(crate) artifacts: Vec<InitArtifact>,
+}
+
+impl InitReport {
+    #[must_use]
+    pub(crate) fn render(&self) -> String {
+        let mut lines = vec![
+            "Init".to_string(),
+            format!("  Project          {}", self.project_root.display()),
+        ];
+        for artifact in &self.artifacts {
+            lines.push(format!(
+                "  {:<16} {}",
+                artifact.name,
+                artifact.status.label()
+            ));
+        }
+        lines.push("  Next step        Review and tailor the generated guidance".to_string());
+        lines.join("\n")
+    }
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+#[allow(clippy::struct_excessive_bools)]
+struct RepoDetection {
+    rust_workspace: bool,
+    rust_root: bool,
+    python: bool,
+    package_json: bool,
+    typescript: bool,
+    nextjs: bool,
+    react: bool,
+    vite: bool,
+    nest: bool,
+    src_dir: bool,
+    tests_dir: bool,
+    rust_dir: bool,
+}
+
+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");
+    artifacts.push(InitArtifact {
+        name: ".claude/",
+        status: ensure_dir(&claude_dir)?,
+    });
+
+    let claude_json = cwd.join(".claude.json");
+    artifacts.push(InitArtifact {
+        name: ".claude.json",
+        status: write_file_if_missing(&claude_json, STARTER_CLAUDE_JSON)?,
+    });
+
+    let gitignore = cwd.join(".gitignore");
+    artifacts.push(InitArtifact {
+        name: ".gitignore",
+        status: ensure_gitignore_entries(&gitignore)?,
+    });
+
+    let claude_md = cwd.join("CLAUDE.md");
+    let content = render_init_claude_md(cwd);
+    artifacts.push(InitArtifact {
+        name: "CLAUDE.md",
+        status: write_file_if_missing(&claude_md, &content)?,
+    });
+
+    Ok(InitReport {
+        project_root: cwd.to_path_buf(),
+        artifacts,
+    })
+}
+
+fn ensure_dir(path: &Path) -> Result<InitStatus, std::io::Error> {
+    if path.is_dir() {
+        return Ok(InitStatus::Skipped);
+    }
+    fs::create_dir_all(path)?;
+    Ok(InitStatus::Created)
+}
+
+fn write_file_if_missing(path: &Path, content: &str) -> Result<InitStatus, std::io::Error> {
+    if path.exists() {
+        return Ok(InitStatus::Skipped);
+    }
+    fs::write(path, content)?;
+    Ok(InitStatus::Created)
+}
+
+fn ensure_gitignore_entries(path: &Path) -> Result<InitStatus, std::io::Error> {
+    if !path.exists() {
+        let mut lines = vec![GITIGNORE_COMMENT.to_string()];
+        lines.extend(GITIGNORE_ENTRIES.iter().map(|entry| (*entry).to_string()));
+        fs::write(path, format!("{}\n", lines.join("\n")))?;
+        return Ok(InitStatus::Created);
+    }
+
+    let existing = fs::read_to_string(path)?;
+    let mut lines = existing.lines().map(ToOwned::to_owned).collect::<Vec<_>>();
+    let mut changed = false;
+
+    if !lines.iter().any(|line| line == GITIGNORE_COMMENT) {
+        lines.push(GITIGNORE_COMMENT.to_string());
+        changed = true;
+    }
+
+    for entry in GITIGNORE_ENTRIES {
+        if !lines.iter().any(|line| line == entry) {
+            lines.push(entry.to_string());
+            changed = true;
+        }
+    }
+
+    if !changed {
+        return Ok(InitStatus::Skipped);
+    }
+
+    fs::write(path, format!("{}\n", lines.join("\n")))?;
+    Ok(InitStatus::Updated)
+}
+
+pub(crate) fn render_init_claude_md(cwd: &Path) -> String {
+    let detection = detect_repo(cwd);
+    let mut lines = vec![
+        "# CLAUDE.md".to_string(),
+        String::new(),
+        "This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.".to_string(),
+        String::new(),
+    ];
+
+    let detected_languages = detected_languages(&detection);
+    let detected_frameworks = detected_frameworks(&detection);
+    lines.push("## Detected stack".to_string());
+    if detected_languages.is_empty() {
+        lines.push("- No specific language markers were detected yet; document the primary language and verification commands once the project structure settles.".to_string());
+    } else {
+        lines.push(format!("- Languages: {}.", detected_languages.join(", ")));
+    }
+    if detected_frameworks.is_empty() {
+        lines.push("- Frameworks: none detected from the supported starter markers.".to_string());
+    } else {
+        lines.push(format!(
+            "- Frameworks/tooling markers: {}.",
+            detected_frameworks.join(", ")
+        ));
+    }
+    lines.push(String::new());
+
+    let verification_lines = verification_lines(cwd, &detection);
+    if !verification_lines.is_empty() {
+        lines.push("## Verification".to_string());
+        lines.extend(verification_lines);
+        lines.push(String::new());
+    }
+
+    let structure_lines = repository_shape_lines(&detection);
+    if !structure_lines.is_empty() {
+        lines.push("## Repository shape".to_string());
+        lines.extend(structure_lines);
+        lines.push(String::new());
+    }
+
+    let framework_lines = framework_notes(&detection);
+    if !framework_lines.is_empty() {
+        lines.push("## Framework notes".to_string());
+        lines.extend(framework_lines);
+        lines.push(String::new());
+    }
+
+    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("- Do not overwrite existing `CLAUDE.md` content automatically; update it intentionally when repo workflows change.".to_string());
+    lines.push(String::new());
+
+    lines.join("\n")
+}
+
+fn detect_repo(cwd: &Path) -> RepoDetection {
+    let package_json_contents = fs::read_to_string(cwd.join("package.json"))
+        .unwrap_or_default()
+        .to_ascii_lowercase();
+    RepoDetection {
+        rust_workspace: cwd.join("rust").join("Cargo.toml").is_file(),
+        rust_root: cwd.join("Cargo.toml").is_file(),
+        python: cwd.join("pyproject.toml").is_file()
+            || cwd.join("requirements.txt").is_file()
+            || cwd.join("setup.py").is_file(),
+        package_json: cwd.join("package.json").is_file(),
+        typescript: cwd.join("tsconfig.json").is_file()
+            || package_json_contents.contains("typescript"),
+        nextjs: package_json_contents.contains("\"next\""),
+        react: package_json_contents.contains("\"react\""),
+        vite: package_json_contents.contains("\"vite\""),
+        nest: package_json_contents.contains("@nestjs"),
+        src_dir: cwd.join("src").is_dir(),
+        tests_dir: cwd.join("tests").is_dir(),
+        rust_dir: cwd.join("rust").is_dir(),
+    }
+}
+
+fn detected_languages(detection: &RepoDetection) -> Vec<&'static str> {
+    let mut languages = Vec::new();
+    if detection.rust_workspace || detection.rust_root {
+        languages.push("Rust");
+    }
+    if detection.python {
+        languages.push("Python");
+    }
+    if detection.typescript {
+        languages.push("TypeScript");
+    } else if detection.package_json {
+        languages.push("JavaScript/Node.js");
+    }
+    languages
+}
+
+fn detected_frameworks(detection: &RepoDetection) -> Vec<&'static str> {
+    let mut frameworks = Vec::new();
+    if detection.nextjs {
+        frameworks.push("Next.js");
+    }
+    if detection.react {
+        frameworks.push("React");
+    }
+    if detection.vite {
+        frameworks.push("Vite");
+    }
+    if detection.nest {
+        frameworks.push("NestJS");
+    }
+    frameworks
+}
+
+fn verification_lines(cwd: &Path, detection: &RepoDetection) -> Vec<String> {
+    let mut lines = Vec::new();
+    if detection.rust_workspace {
+        lines.push("- Run Rust verification from `rust/`: `cargo fmt`, `cargo clippy --workspace --all-targets -- -D warnings`, `cargo test --workspace`".to_string());
+    } else if detection.rust_root {
+        lines.push("- Run Rust verification from the repo root: `cargo fmt`, `cargo clippy --workspace --all-targets -- -D warnings`, `cargo test --workspace`".to_string());
+    }
+    if detection.python {
+        if cwd.join("pyproject.toml").is_file() {
+            lines.push("- Run the Python project checks declared in `pyproject.toml` (for example: `pytest`, `ruff check`, and `mypy` when configured).".to_string());
+        } else {
+            lines.push(
+                "- Run the repo's Python test/lint commands before shipping changes.".to_string(),
+            );
+        }
+    }
+    if detection.package_json {
+        lines.push("- Run the JavaScript/TypeScript checks from `package.json` before shipping changes (`npm test`, `npm run lint`, `npm run build`, or the repo equivalent).".to_string());
+    }
+    if detection.tests_dir && detection.src_dir {
+        lines.push("- `src/` and `tests/` are both present; update both surfaces together when behavior changes.".to_string());
+    }
+    lines
+}
+
+fn repository_shape_lines(detection: &RepoDetection) -> Vec<String> {
+    let mut lines = Vec::new();
+    if detection.rust_dir {
+        lines.push(
+            "- `rust/` contains the Rust workspace and active CLI/runtime implementation."
+                .to_string(),
+        );
+    }
+    if detection.src_dir {
+        lines.push("- `src/` contains source files that should stay consistent with generated guidance and tests.".to_string());
+    }
+    if detection.tests_dir {
+        lines.push("- `tests/` contains validation surfaces that should be reviewed alongside code changes.".to_string());
+    }
+    lines
+}
+
+fn framework_notes(detection: &RepoDetection) -> Vec<String> {
+    let mut lines = Vec::new();
+    if detection.nextjs {
+        lines.push("- Next.js detected: preserve routing/data-fetching conventions and verify production builds after changing app structure.".to_string());
+    }
+    if detection.react && !detection.nextjs {
+        lines.push("- React detected: keep component behavior covered with focused tests and avoid unnecessary prop/API churn.".to_string());
+    }
+    if detection.vite {
+        lines.push("- Vite detected: validate the production bundle after changing build-sensitive configuration or imports.".to_string());
+    }
+    if detection.nest {
+        lines.push("- NestJS detected: keep module/provider boundaries explicit and verify controller/service wiring after refactors.".to_string());
+    }
+    lines
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{initialize_repo, render_init_claude_md};
+    use std::fs;
+    use std::path::Path;
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    fn temp_dir() -> std::path::PathBuf {
+        let nanos = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("time should be after epoch")
+            .as_nanos();
+        std::env::temp_dir().join(format!("rusty-claude-init-{nanos}"))
+    }
+
+    #[test]
+    fn initialize_repo_creates_expected_files_and_gitignore_entries() {
+        let root = temp_dir();
+        fs::create_dir_all(root.join("rust")).expect("create rust dir");
+        fs::write(root.join("rust").join("Cargo.toml"), "[workspace]\n").expect("write cargo");
+
+        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(".gitignore       created"));
+        assert!(rendered.contains("CLAUDE.md        created"));
+        assert!(root.join(".claude").is_dir());
+        assert!(root.join(".claude.json").is_file());
+        assert!(root.join("CLAUDE.md").is_file());
+        assert_eq!(
+            fs::read_to_string(root.join(".claude.json")).expect("read claude json"),
+            concat!(
+                "{\n",
+                "  \"permissions\": {\n",
+                "    \"defaultMode\": \"acceptEdits\"\n",
+                "  }\n",
+                "}\n",
+            )
+        );
+        let gitignore = fs::read_to_string(root.join(".gitignore")).expect("read gitignore");
+        assert!(gitignore.contains(".claude/settings.local.json"));
+        assert!(gitignore.contains(".claude/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"));
+
+        fs::remove_dir_all(root).expect("cleanup temp dir");
+    }
+
+    #[test]
+    fn initialize_repo_is_idempotent_and_preserves_existing_files() {
+        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");
+
+        let first = initialize_repo(&root).expect("first init should succeed");
+        assert!(first
+            .render()
+            .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(".gitignore       skipped (already exists)"));
+        assert!(second_rendered.contains("CLAUDE.md        skipped (already exists)"));
+        assert_eq!(
+            fs::read_to_string(root.join("CLAUDE.md")).expect("read existing claude md"),
+            "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);
+
+        fs::remove_dir_all(root).expect("cleanup temp dir");
+    }
+
+    #[test]
+    fn render_init_template_mentions_detected_python_and_nextjs_markers() {
+        let root = temp_dir();
+        fs::create_dir_all(&root).expect("create root");
+        fs::write(root.join("pyproject.toml"), "[project]\nname = \"demo\"\n")
+            .expect("write pyproject");
+        fs::write(
+            root.join("package.json"),
+            r#"{"dependencies":{"next":"14.0.0","react":"18.0.0"},"devDependencies":{"typescript":"5.0.0"}}"#,
+        )
+        .expect("write package json");
+
+        let rendered = render_init_claude_md(Path::new(&root));
+        assert!(rendered.contains("Languages: Python, TypeScript."));
+        assert!(rendered.contains("Frameworks/tooling markers: Next.js, React."));
+        assert!(rendered.contains("pyproject.toml"));
+        assert!(rendered.contains("Next.js detected"));
+
+        fs::remove_dir_all(root).expect("cleanup temp dir");
+    }
+}
--- a/rust/crates/rusty-claude-cli/src/input.rs
+++ b/rust/crates/rusty-claude-cli/src/input.rs
@@ -1,166 +1,16 @@
+use std::borrow::Cow;
+use std::cell::RefCell;
 use std::io::{self, IsTerminal, Write};

-use crossterm::cursor::{MoveDown, MoveToColumn, MoveUp};
-use crossterm::event::{self, Event, KeyCode, KeyEvent, KeyModifiers};
-use crossterm::queue;
-use crossterm::terminal::{disable_raw_mode, enable_raw_mode, Clear, ClearType};
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct InputBuffer {
-    buffer: String,
-    cursor: usize,
-}
-
-impl InputBuffer {
-    #[must_use]
-    pub fn new() -> Self {
-        Self {
-            buffer: String::new(),
-            cursor: 0,
-        }
-    }
-
-    pub fn insert(&mut self, ch: char) {
-        self.buffer.insert(self.cursor, ch);
-        self.cursor += ch.len_utf8();
-    }
-
-    pub fn insert_newline(&mut self) {
-        self.insert('\n');
-    }
-
-    pub fn backspace(&mut self) {
-        if self.cursor == 0 {
-            return;
-        }
-
-        let previous = self.buffer[..self.cursor]
-            .char_indices()
-            .last()
-            .map_or(0, |(idx, _)| idx);
-        self.buffer.drain(previous..self.cursor);
-        self.cursor = previous;
-    }
-
-    pub fn move_left(&mut self) {
-        if self.cursor == 0 {
-            return;
-        }
-        self.cursor = self.buffer[..self.cursor]
-            .char_indices()
-            .last()
-            .map_or(0, |(idx, _)| idx);
-    }
-
-    pub fn move_right(&mut self) {
-        if self.cursor >= self.buffer.len() {
-            return;
-        }
-        if let Some(next) = self.buffer[self.cursor..].chars().next() {
-            self.cursor += next.len_utf8();
-        }
-    }
-
-    pub fn move_home(&mut self) {
-        self.cursor = 0;
-    }
-
-    pub fn move_end(&mut self) {
-        self.cursor = self.buffer.len();
-    }
-
-    #[must_use]
-    pub fn as_str(&self) -> &str {
-        &self.buffer
-    }
-
-    #[cfg(test)]
-    #[must_use]
-    pub fn cursor(&self) -> usize {
-        self.cursor
-    }
-
-    pub fn clear(&mut self) {
-        self.buffer.clear();
-        self.cursor = 0;
-    }
-
-    pub fn replace(&mut self, value: impl Into<String>) {
-        self.buffer = value.into();
-        self.cursor = self.buffer.len();
-    }
-
-    #[must_use]
-    fn current_command_prefix(&self) -> Option<&str> {
-        if self.cursor != self.buffer.len() {
-            return None;
-        }
-        let prefix = &self.buffer[..self.cursor];
-        if prefix.contains(char::is_whitespace) || !prefix.starts_with('/') {
-            return None;
-        }
-        Some(prefix)
-    }
-
-    pub fn complete_slash_command(&mut self, candidates: &[String]) -> bool {
-        let Some(prefix) = self.current_command_prefix() else {
-            return false;
-        };
-
-        let matches = candidates
-            .iter()
-            .filter(|candidate| candidate.starts_with(prefix))
-            .map(String::as_str)
-            .collect::<Vec<_>>();
-        if matches.is_empty() {
-            return false;
-        }
-
-        let replacement = longest_common_prefix(&matches);
-        if replacement == prefix {
-            return false;
-        }
-
-        self.replace(replacement);
-        true
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct RenderedBuffer {
-    lines: Vec<String>,
-    cursor_row: u16,
-    cursor_col: u16,
-}
-
-impl RenderedBuffer {
-    #[must_use]
-    pub fn line_count(&self) -> usize {
-        self.lines.len()
-    }
-
-    fn write(&self, out: &mut impl Write) -> io::Result<()> {
-        for (index, line) in self.lines.iter().enumerate() {
-            if index > 0 {
-                writeln!(out)?;
-            }
-            write!(out, "{line}")?;
-        }
-        Ok(())
-    }
-
-    #[cfg(test)]
-    #[must_use]
-    pub fn lines(&self) -> &[String] {
-        &self.lines
-    }
-
-    #[cfg(test)]
-    #[must_use]
-    pub fn cursor_position(&self) -> (u16, u16) {
-        (self.cursor_row, self.cursor_col)
-    }
-}
+use rustyline::completion::{Completer, Pair};
+use rustyline::error::ReadlineError;
+use rustyline::highlight::{CmdKind, Highlighter};
+use rustyline::hint::Hinter;
+use rustyline::history::DefaultHistory;
+use rustyline::validate::Validator;
+use rustyline::{
+    Cmd, CompletionType, Config, Context, EditMode, Editor, Helper, KeyCode, KeyEvent, Modifiers,
+};

 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ReadOutcome {
@@ -169,25 +19,101 @@ pub enum ReadOutcome {
    Exit,
 }

+struct SlashCommandHelper {
+    completions: Vec<String>,
+    current_line: RefCell<String>,
+}
+
+impl SlashCommandHelper {
+    fn new(completions: Vec<String>) -> Self {
+        Self {
+            completions,
+            current_line: RefCell::new(String::new()),
+        }
+    }
+
+    fn reset_current_line(&self) {
+        self.current_line.borrow_mut().clear();
+    }
+
+    fn current_line(&self) -> String {
+        self.current_line.borrow().clone()
+    }
+
+    fn set_current_line(&self, line: &str) {
+        let mut current = self.current_line.borrow_mut();
+        current.clear();
+        current.push_str(line);
+    }
+}
+
+impl Completer for SlashCommandHelper {
+    type Candidate = Pair;
+
+    fn complete(
+        &self,
+        line: &str,
+        pos: usize,
+        _ctx: &Context<'_>,
+    ) -> rustyline::Result<(usize, Vec<Self::Candidate>)> {
+        let Some(prefix) = slash_command_prefix(line, pos) else {
+            return Ok((0, Vec::new()));
+        };
+
+        let matches = self
+            .completions
+            .iter()
+            .filter(|candidate| candidate.starts_with(prefix))
+            .map(|candidate| Pair {
+                display: candidate.clone(),
+                replacement: candidate.clone(),
+            })
+            .collect();
+
+        Ok((0, matches))
+    }
+}
+
+impl Hinter for SlashCommandHelper {
+    type Hint = String;
+}
+
+impl Highlighter for SlashCommandHelper {
+    fn highlight<'l>(&self, line: &'l str, _pos: usize) -> Cow<'l, str> {
+        self.set_current_line(line);
+        Cow::Borrowed(line)
+    }
+
+    fn highlight_char(&self, line: &str, _pos: usize, _kind: CmdKind) -> bool {
+        self.set_current_line(line);
+        false
+    }
+}
+
+impl Validator for SlashCommandHelper {}
+impl Helper for SlashCommandHelper {}
+
 pub struct LineEditor {
    prompt: String,
-    continuation_prompt: String,
-    history: Vec<String>,
-    history_index: Option<usize>,
-    draft: Option<String>,
-    completions: Vec<String>,
+    editor: Editor<SlashCommandHelper, DefaultHistory>,
 }

 impl LineEditor {
    #[must_use]
    pub fn new(prompt: impl Into<String>, completions: Vec<String>) -> Self {
+        let config = Config::builder()
+            .completion_type(CompletionType::List)
+            .edit_mode(EditMode::Emacs)
+            .build();
+        let mut editor = Editor::<SlashCommandHelper, DefaultHistory>::with_config(config)
+            .expect("rustyline editor should initialize");
+        editor.set_helper(Some(SlashCommandHelper::new(completions)));
+        editor.bind_sequence(KeyEvent(KeyCode::Char('J'), Modifiers::CTRL), Cmd::Newline);
+        editor.bind_sequence(KeyEvent(KeyCode::Enter, Modifiers::SHIFT), Cmd::Newline);
+
        Self {
            prompt: prompt.into(),
-            continuation_prompt: String::from("> "),
-            history: Vec::new(),
-            history_index: None,
-            draft: None,
-            completions,
+            editor,
        }
    }

@@ -196,9 +122,8 @@ impl LineEditor {
        if entry.trim().is_empty() {
            return;
        }
-        self.history.push(entry);
-        self.history_index = None;
-        self.draft = None;
+
+        let _ = self.editor.add_history_entry(entry);
    }

    pub fn read_line(&mut self) -> io::Result<ReadOutcome> {
@@ -206,45 +131,43 @@ impl LineEditor {
            return self.read_line_fallback();
        }

-        enable_raw_mode()?;
-        let mut stdout = io::stdout();
-        let mut input = InputBuffer::new();
-        let mut rendered_lines = 1usize;
-        self.redraw(&mut stdout, &input, rendered_lines)?;
+        if let Some(helper) = self.editor.helper_mut() {
+            helper.reset_current_line();
+        }

-        loop {
-            let event = event::read()?;
-            if let Event::Key(key) = event {
-                match self.handle_key(key, &mut input) {
-                    EditorAction::Continue => {
-                        rendered_lines = self.redraw(&mut stdout, &input, rendered_lines)?;
-                    }
-                    EditorAction::Submit => {
-                        disable_raw_mode()?;
-                        writeln!(stdout)?;
-                        self.history_index = None;
-                        self.draft = None;
-                        return Ok(ReadOutcome::Submit(input.as_str().to_owned()));
-                    }
-                    EditorAction::Cancel => {
-                        disable_raw_mode()?;
-                        writeln!(stdout)?;
-                        self.history_index = None;
-                        self.draft = None;
-                        return Ok(ReadOutcome::Cancel);
-                    }
-                    EditorAction::Exit => {
-                        disable_raw_mode()?;
-                        writeln!(stdout)?;
-                        self.history_index = None;
-                        self.draft = None;
-                        return Ok(ReadOutcome::Exit);
-                    }
+        match self.editor.readline(&self.prompt) {
+            Ok(line) => Ok(ReadOutcome::Submit(line)),
+            Err(ReadlineError::Interrupted) => {
+                let has_input = !self.current_line().is_empty();
+                self.finish_interrupted_read()?;
+                if has_input {
+                    Ok(ReadOutcome::Cancel)
+                } else {
+                    Ok(ReadOutcome::Exit)
                }
            }
+            Err(ReadlineError::Eof) => {
+                self.finish_interrupted_read()?;
+                Ok(ReadOutcome::Exit)
+            }
+            Err(error) => Err(io::Error::other(error)),
        }
    }

+    fn current_line(&self) -> String {
+        self.editor
+            .helper()
+            .map_or_else(String::new, SlashCommandHelper::current_line)
+    }
+
+    fn finish_interrupted_read(&mut self) -> io::Result<()> {
+        if let Some(helper) = self.editor.helper_mut() {
+            helper.reset_current_line();
+        }
+        let mut stdout = io::stdout();
+        writeln!(stdout)
+    }
+
    fn read_line_fallback(&self) -> io::Result<ReadOutcome> {
        let mut stdout = io::stdout();
        write!(stdout, "{}", self.prompt)?;
@@ -261,388 +184,86 @@ impl LineEditor {
        }
        Ok(ReadOutcome::Submit(buffer))
    }
-
-    #[allow(clippy::too_many_lines)]
-    fn handle_key(&mut self, key: KeyEvent, input: &mut InputBuffer) -> EditorAction {
-        match key {
-            KeyEvent {
-                code: KeyCode::Char('c'),
-                modifiers,
-                ..
-            } if modifiers.contains(KeyModifiers::CONTROL) => {
-                if input.as_str().is_empty() {
-                    EditorAction::Exit
-                } else {
-                    input.clear();
-                    self.history_index = None;
-                    self.draft = None;
-                    EditorAction::Cancel
-                }
-            }
-            KeyEvent {
-                code: KeyCode::Char('j'),
-                modifiers,
-                ..
-            } if modifiers.contains(KeyModifiers::CONTROL) => {
-                input.insert_newline();
-                EditorAction::Continue
-            }
-            KeyEvent {
-                code: KeyCode::Enter,
-                modifiers,
-                ..
-            } if modifiers.contains(KeyModifiers::SHIFT) => {
-                input.insert_newline();
-                EditorAction::Continue
-            }
-            KeyEvent {
-                code: KeyCode::Enter,
-                ..
-            } => EditorAction::Submit,
-            KeyEvent {
-                code: KeyCode::Backspace,
-                ..
-            } => {
-                input.backspace();
-                EditorAction::Continue
-            }
-            KeyEvent {
-                code: KeyCode::Left,
-                ..
-            } => {
-                input.move_left();
-                EditorAction::Continue
-            }
-            KeyEvent {
-                code: KeyCode::Right,
-                ..
-            } => {
-                input.move_right();
-                EditorAction::Continue
-            }
-            KeyEvent {
-                code: KeyCode::Up, ..
-            } => {
-                self.navigate_history_up(input);
-                EditorAction::Continue
-            }
-            KeyEvent {
-                code: KeyCode::Down,
-                ..
-            } => {
-                self.navigate_history_down(input);
-                EditorAction::Continue
-            }
-            KeyEvent {
-                code: KeyCode::Tab, ..
-            } => {
-                input.complete_slash_command(&self.completions);
-                EditorAction::Continue
-            }
-            KeyEvent {
-                code: KeyCode::Home,
-                ..
-            } => {
-                input.move_home();
-                EditorAction::Continue
-            }
-            KeyEvent {
-                code: KeyCode::End, ..
-            } => {
-                input.move_end();
-                EditorAction::Continue
-            }
-            KeyEvent {
-                code: KeyCode::Esc, ..
-            } => {
-                input.clear();
-                self.history_index = None;
-                self.draft = None;
-                EditorAction::Cancel
-            }
-            KeyEvent {
-                code: KeyCode::Char(ch),
-                modifiers,
-                ..
-            } if modifiers.is_empty() || modifiers == KeyModifiers::SHIFT => {
-                input.insert(ch);
-                self.history_index = None;
-                self.draft = None;
-                EditorAction::Continue
-            }
-            _ => EditorAction::Continue,
-        }
-    }
-
-    fn navigate_history_up(&mut self, input: &mut InputBuffer) {
-        if self.history.is_empty() {
-            return;
-        }
-
-        match self.history_index {
-            Some(0) => {}
-            Some(index) => {
-                let next_index = index - 1;
-                input.replace(self.history[next_index].clone());
-                self.history_index = Some(next_index);
-            }
-            None => {
-                self.draft = Some(input.as_str().to_owned());
-                let next_index = self.history.len() - 1;
-                input.replace(self.history[next_index].clone());
-                self.history_index = Some(next_index);
-            }
-        }
-    }
-
-    fn navigate_history_down(&mut self, input: &mut InputBuffer) {
-        let Some(index) = self.history_index else {
-            return;
-        };
-
-        if index + 1 < self.history.len() {
-            let next_index = index + 1;
-            input.replace(self.history[next_index].clone());
-            self.history_index = Some(next_index);
-            return;
-        }
-
-        input.replace(self.draft.take().unwrap_or_default());
-        self.history_index = None;
-    }
-
-    fn redraw(
-        &self,
-        out: &mut impl Write,
-        input: &InputBuffer,
-        previous_line_count: usize,
-    ) -> io::Result<usize> {
-        let rendered = render_buffer(&self.prompt, &self.continuation_prompt, input);
-        if previous_line_count > 1 {
-            queue!(out, MoveUp(saturating_u16(previous_line_count - 1)))?;
-        }
-        queue!(out, MoveToColumn(0), Clear(ClearType::FromCursorDown),)?;
-        rendered.write(out)?;
-        queue!(
-            out,
-            MoveUp(saturating_u16(rendered.line_count().saturating_sub(1))),
-            MoveToColumn(0),
-        )?;
-        if rendered.cursor_row > 0 {
-            queue!(out, MoveDown(rendered.cursor_row))?;
-        }
-        queue!(out, MoveToColumn(rendered.cursor_col))?;
-        out.flush()?;
-        Ok(rendered.line_count())
-    }
 }

-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum EditorAction {
-    Continue,
-    Submit,
-    Cancel,
-    Exit,
-}
-
-#[must_use]
-pub fn render_buffer(
-    prompt: &str,
-    continuation_prompt: &str,
-    input: &InputBuffer,
-) -> RenderedBuffer {
-    let before_cursor = &input.as_str()[..input.cursor];
-    let cursor_row = saturating_u16(before_cursor.chars().filter(|ch| *ch == '\n').count());
-    let cursor_line = before_cursor.rsplit('\n').next().unwrap_or_default();
-    let cursor_prompt = if cursor_row == 0 {
-        prompt
-    } else {
-        continuation_prompt
-    };
-    let cursor_col = saturating_u16(cursor_prompt.chars().count() + cursor_line.chars().count());
-
-    let mut lines = Vec::new();
-    for (index, line) in input.as_str().split('\n').enumerate() {
-        let prefix = if index == 0 {
-            prompt
-        } else {
-            continuation_prompt
-        };
-        lines.push(format!("{prefix}{line}"));
-    }
-    if lines.is_empty() {
-        lines.push(prompt.to_string());
+fn slash_command_prefix(line: &str, pos: usize) -> Option<&str> {
+    if pos != line.len() {
+        return None;
    }

-    RenderedBuffer {
-        lines,
-        cursor_row,
-        cursor_col,
+    let prefix = &line[..pos];
+    if prefix.contains(char::is_whitespace) || !prefix.starts_with('/') {
+        return None;
    }
-}

-#[must_use]
-fn longest_common_prefix(values: &[&str]) -> String {
-    let Some(first) = values.first() else {
-        return String::new();
-    };
-
-    let mut prefix = (*first).to_string();
-    for value in values.iter().skip(1) {
-        while !value.starts_with(&prefix) {
-            prefix.pop();
-            if prefix.is_empty() {
-                break;
-            }
-        }
-    }
-    prefix
-}
-
-#[must_use]
-fn saturating_u16(value: usize) -> u16 {
-    u16::try_from(value).unwrap_or(u16::MAX)
+    Some(prefix)
 }

 #[cfg(test)]
 mod tests {
-    use super::{render_buffer, InputBuffer, LineEditor};
-    use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
+    use super::{slash_command_prefix, LineEditor, SlashCommandHelper};
+    use rustyline::completion::Completer;
+    use rustyline::highlight::Highlighter;
+    use rustyline::history::{DefaultHistory, History};
+    use rustyline::Context;

-    fn key(code: KeyCode) -> KeyEvent {
-        KeyEvent::new(code, KeyModifiers::NONE)
+    #[test]
+    fn extracts_only_terminal_slash_command_prefixes() {
+        assert_eq!(slash_command_prefix("/he", 3), Some("/he"));
+        assert_eq!(slash_command_prefix("/help me", 5), None);
+        assert_eq!(slash_command_prefix("hello", 5), None);
+        assert_eq!(slash_command_prefix("/help", 2), None);
    }

    #[test]
-    fn supports_basic_line_editing() {
-        let mut input = InputBuffer::new();
-        input.insert('h');
-        input.insert('i');
-        input.move_end();
-        input.insert_newline();
-        input.insert('x');
-
-        assert_eq!(input.as_str(), "hi\nx");
-        assert_eq!(input.cursor(), 4);
-
-        input.move_left();
-        input.backspace();
-        assert_eq!(input.as_str(), "hix");
-        assert_eq!(input.cursor(), 2);
-    }
-
-    #[test]
-    fn completes_unique_slash_command() {
-        let mut input = InputBuffer::new();
-        for ch in "/he".chars() {
-            input.insert(ch);
-        }
-
-        assert!(input.complete_slash_command(&[
+    fn completes_matching_slash_commands() {
+        let helper = SlashCommandHelper::new(vec![
            "/help".to_string(),
            "/hello".to_string(),
            "/status".to_string(),
-        ]));
-        assert_eq!(input.as_str(), "/hel");
+        ]);
+        let history = DefaultHistory::new();
+        let ctx = Context::new(&history);
+        let (start, matches) = helper
+            .complete("/he", 3, &ctx)
+            .expect("completion should work");

-        assert!(input.complete_slash_command(&["/help".to_string(), "/status".to_string()]));
-        assert_eq!(input.as_str(), "/help");
-    }
-
-    #[test]
-    fn ignores_completion_when_prefix_is_not_a_slash_command() {
-        let mut input = InputBuffer::new();
-        for ch in "hello".chars() {
-            input.insert(ch);
-        }
-
-        assert!(!input.complete_slash_command(&["/help".to_string()]));
-        assert_eq!(input.as_str(), "hello");
-    }
-
-    #[test]
-    fn history_navigation_restores_current_draft() {
-        let mut editor = LineEditor::new("› ", vec![]);
-        editor.push_history("/help");
-        editor.push_history("status report");
-
-        let mut input = InputBuffer::new();
-        for ch in "draft".chars() {
-            input.insert(ch);
-        }
-
-        let _ = editor.handle_key(key(KeyCode::Up), &mut input);
-        assert_eq!(input.as_str(), "status report");
-
-        let _ = editor.handle_key(key(KeyCode::Up), &mut input);
-        assert_eq!(input.as_str(), "/help");
-
-        let _ = editor.handle_key(key(KeyCode::Down), &mut input);
-        assert_eq!(input.as_str(), "status report");
-
-        let _ = editor.handle_key(key(KeyCode::Down), &mut input);
-        assert_eq!(input.as_str(), "draft");
-    }
-
-    #[test]
-    fn tab_key_completes_from_editor_candidates() {
-        let mut editor = LineEditor::new(
-            "› ",
-            vec![
-                "/help".to_string(),
-                "/status".to_string(),
-                "/session".to_string(),
-            ],
-        );
-        let mut input = InputBuffer::new();
-        for ch in "/st".chars() {
-            input.insert(ch);
-        }
-
-        let _ = editor.handle_key(key(KeyCode::Tab), &mut input);
-        assert_eq!(input.as_str(), "/status");
-    }
-
-    #[test]
-    fn renders_multiline_buffers_with_continuation_prompt() {
-        let mut input = InputBuffer::new();
-        for ch in "hello\nworld".chars() {
-            if ch == '\n' {
-                input.insert_newline();
-            } else {
-                input.insert(ch);
-            }
-        }
-
-        let rendered = render_buffer("› ", "> ", &input);
+        assert_eq!(start, 0);
        assert_eq!(
-            rendered.lines(),
-            &["› hello".to_string(), "> world".to_string()]
+            matches
+                .into_iter()
+                .map(|candidate| candidate.replacement)
+                .collect::<Vec<_>>(),
+            vec!["/help".to_string(), "/hello".to_string()]
        );
-        assert_eq!(rendered.cursor_position(), (1, 7));
    }

    #[test]
-    fn ctrl_c_exits_only_when_buffer_is_empty() {
-        let mut editor = LineEditor::new("› ", vec![]);
-        let mut empty = InputBuffer::new();
-        assert!(matches!(
-            editor.handle_key(
-                KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL),
-                &mut empty,
-            ),
-            super::EditorAction::Exit
-        ));
+    fn ignores_non_slash_command_completion_requests() {
+        let helper = SlashCommandHelper::new(vec!["/help".to_string()]);
+        let history = DefaultHistory::new();
+        let ctx = Context::new(&history);
+        let (_, matches) = helper
+            .complete("hello", 5, &ctx)
+            .expect("completion should work");

-        let mut filled = InputBuffer::new();
-        filled.insert('x');
-        assert!(matches!(
-            editor.handle_key(
-                KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL),
-                &mut filled,
-            ),
-            super::EditorAction::Cancel
-        ));
-        assert!(filled.as_str().is_empty());
+        assert!(matches.is_empty());
+    }
+
+    #[test]
+    fn tracks_current_buffer_through_highlighter() {
+        let helper = SlashCommandHelper::new(Vec::new());
+        let _ = helper.highlight("draft", 5);
+
+        assert_eq!(helper.current_line(), "draft");
+    }
+
+    #[test]
+    fn push_history_ignores_blank_entries() {
+        let mut editor = LineEditor::new("> ", vec!["/help".to_string()]);
+        editor.push_history("   ");
+        editor.push_history("/help");
+
+        assert_eq!(editor.editor.history().len(), 1);
    }
 }
--- a/rust/crates/rusty-claude-cli/src/main.rs
+++ b/rust/crates/rusty-claude-cli/src/main.rs
@@ -1,3 +1,4 @@
+mod init;
 mod input;
 mod render;

@@ -20,11 +21,12 @@ use commands::{
    render_slash_command_help, resume_supported_slash_commands, slash_command_specs, SlashCommand,
 };
 use compat_harness::{extract_manifest, UpstreamPaths};
+use init::initialize_repo;
 use render::{Spinner, TerminalRenderer};
 use runtime::{
    clear_oauth_credentials, generate_pkce_pair, generate_state, load_system_prompt,
-    parse_oauth_callback_request_target, resolve_sandbox_status, save_oauth_credentials, ApiClient,
-    ApiRequest, AssistantEvent, CompactionConfig, ConfigLoader, ConfigSource, ContentBlock,
+    parse_oauth_callback_request_target, save_oauth_credentials, ApiClient, ApiRequest,
+    AssistantEvent, CompactionConfig, ConfigLoader, ConfigSource, ContentBlock,
    ConversationMessage, ConversationRuntime, MessageRole, OAuthAuthorizationRequest,
    OAuthTokenExchangeRequest, PermissionMode, PermissionPolicy, ProjectContext, RuntimeError,
    Session, TokenUsage, ToolError, ToolExecutor, UsageTracker,
@@ -32,7 +34,7 @@ use runtime::{
 use serde_json::json;
 use tools::{execute_tool, mvp_tool_specs, ToolSpec};

-const DEFAULT_MODEL: &str = "claude-sonnet-4-20250514";
+const DEFAULT_MODEL: &str = "claude-opus-4-6";
 const DEFAULT_MAX_TOKENS: u32 = 32;
 const DEFAULT_DATE: &str = "2026-03-31";
 const DEFAULT_OAUTH_CALLBACK_PORT: u16 = 4545;
@@ -47,7 +49,7 @@ fn main() {
        eprintln!(
            "error: {error}

-Run `rusty-claude-cli --help` for usage."
+Run `claw --help` for usage."
        );
        std::process::exit(1);
    }
@@ -74,6 +76,7 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
            .run_turn_with_output(&prompt, output_format)?,
        CliAction::Login => run_login()?,
        CliAction::Logout => run_logout()?,
+        CliAction::Init => run_init()?,
        CliAction::Repl {
            model,
            allowed_tools,
@@ -106,6 +109,7 @@ enum CliAction {
    },
    Login,
    Logout,
+    Init,
    Repl {
        model: String,
        allowed_tools: Option<AllowedToolSet>,
@@ -153,11 +157,11 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
                let value = args
                    .get(index + 1)
                    .ok_or_else(|| "missing value for --model".to_string())?;
-                model.clone_from(value);
+                model = resolve_model_alias(value).to_string();
                index += 2;
            }
            flag if flag.starts_with("--model=") => {
-                model = flag[8..].to_string();
+                model = resolve_model_alias(&flag[8..]).to_string();
                index += 1;
            }
            "--output-format" => {
@@ -230,6 +234,7 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
        "system-prompt" => parse_system_prompt_args(&rest[1..]),
        "login" => Ok(CliAction::Login),
        "logout" => Ok(CliAction::Logout),
+        "init" => Ok(CliAction::Init),
        "prompt" => {
            let prompt = rest[1..].join(" ");
            if prompt.trim().is_empty() {
@@ -254,6 +259,15 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
    }
 }

+fn resolve_model_alias(model: &str) -> &str {
+    match model {
+        "opus" => "claude-opus-4-6",
+        "sonnet" => "claude-sonnet-4-6",
+        "haiku" => "claude-haiku-3-5-20241022",
+        _ => model,
+    }
+}
+
 fn normalize_allowed_tools(values: &[String]) -> Result<Option<AllowedToolSet>, String> {
    if values.is_empty() {
        return Ok(None);
@@ -445,7 +459,7 @@ fn run_login() -> Result<(), Box<dyn std::error::Error>> {
        return Err(io::Error::new(io::ErrorKind::InvalidData, "oauth state mismatch").into());
    }

-    let client = AnthropicClient::from_auth(AuthSource::None);
+    let client = AnthropicClient::from_auth(AuthSource::None).with_base_url(api::read_base_url());
    let exchange_request =
        OAuthTokenExchangeRequest::from_config(oauth, code, state, pkce.verifier, redirect_uri);
    let runtime = tokio::runtime::Runtime::new()?;
@@ -591,7 +605,6 @@ struct StatusContext {
    memory_file_count: usize,
    project_root: Option<PathBuf>,
    git_branch: Option<String>,
-    sandbox_status: runtime::SandboxStatus,
 }

 #[derive(Debug, Clone, Copy)]
@@ -704,26 +717,6 @@ fn format_resume_report(session_path: &str, message_count: usize, turns: u32) ->
    )
 }

-fn format_init_report(path: &Path, created: bool) -> String {
-    if created {
-        format!(
-            "Init
-  CLAUDE.md        {}
-  Result           created
-  Next step        Review and tailor the generated guidance",
-            path.display()
-        )
-    } else {
-        format!(
-            "Init
-  CLAUDE.md        {}
-  Result           skipped (already exists)
-  Next step        Edit the existing file intentionally if workflows changed",
-            path.display()
-        )
-    }
-}
-
 fn format_compact_report(removed: usize, resulting_messages: usize, skipped: bool) -> String {
    if skipped {
        format!(
@@ -841,18 +834,6 @@ fn run_resume_command(
                )),
            })
        }
-        SlashCommand::Sandbox => {
-            let cwd = env::current_dir()?;
-            let loader = ConfigLoader::default_for(&cwd);
-            let runtime_config = loader.load()?;
-            Ok(ResumeCommandOutcome {
-                session: session.clone(),
-                message: Some(format_sandbox_report(&resolve_sandbox_status(
-                    runtime_config.sandbox(),
-                    &cwd,
-                ))),
-            })
-        }
        SlashCommand::Cost => {
            let usage = UsageTracker::from_session(session).cumulative_usage();
            Ok(ResumeCommandOutcome {
@@ -906,7 +887,7 @@ fn run_repl(
    permission_mode: PermissionMode,
 ) -> Result<(), Box<dyn std::error::Error>> {
    let mut cli = LiveCli::new(model, true, allowed_tools, permission_mode)?;
-    let mut editor = input::LineEditor::new("› ", slash_command_completion_candidates());
+    let mut editor = input::LineEditor::new("> ", slash_command_completion_candidates());
    println!("{}", cli.startup_banner());

    loop {
@@ -993,14 +974,26 @@ impl LiveCli {
    }

    fn startup_banner(&self) -> String {
+        let cwd = env::current_dir().map_or_else(
+            |_| "<unknown>".to_string(),
+            |path| path.display().to_string(),
+        );
        format!(
-            "Rusty Claude CLI\n  Model            {}\n  Permission mode  {}\n  Working directory {}\n  Session          {}\n\nType /help for commands. Shift+Enter or Ctrl+J inserts a newline.",
+            "\x1b[38;5;196m\
+ ██████╗██╗      █████╗ ██╗    ██╗\n\
+██╔════╝██║     ██╔══██╗██║    ██║\n\
+██║     ██║     ███████║██║ █╗ ██║\n\
+██║     ██║     ██╔══██║██║███╗██║\n\
+╚██████╗███████╗██║  ██║╚███╔███╔╝\n\
+ ╚═════╝╚══════╝╚═╝  ╚═╝ ╚══╝╚══╝\x1b[0m \x1b[38;5;208mCode\x1b[0m 🦞\n\n\
+  \x1b[2mModel\x1b[0m            {}\n\
+  \x1b[2mPermissions\x1b[0m      {}\n\
+  \x1b[2mDirectory\x1b[0m        {}\n\
+  \x1b[2mSession\x1b[0m          {}\n\n\
+  Type \x1b[1m/help\x1b[0m for commands · \x1b[2mShift+Enter\x1b[0m for newline",
            self.model,
            self.permission_mode.as_str(),
-            env::current_dir().map_or_else(
-                |_| "<unknown>".to_string(),
-                |path| path.display().to_string(),
-            ),
+            cwd,
            self.session.id,
        )
    }
@@ -1009,7 +1002,7 @@ impl LiveCli {
        let mut spinner = Spinner::new();
        let mut stdout = io::stdout();
        spinner.tick(
-            "Waiting for Claude",
+            "🦀 Thinking...",
            TerminalRenderer::new().color_theme(),
            &mut stdout,
        )?;
@@ -1018,7 +1011,7 @@ impl LiveCli {
        match result {
            Ok(_) => {
                spinner.finish(
-                    "Claude response complete",
+                    "✨ Done",
                    TerminalRenderer::new().color_theme(),
                    &mut stdout,
                )?;
@@ -1028,7 +1021,7 @@ impl LiveCli {
            }
            Err(error) => {
                spinner.fail(
-                    "Claude request failed",
+                    "❌ Request failed",
                    TerminalRenderer::new().color_theme(),
                    &mut stdout,
                )?;
@@ -1049,7 +1042,8 @@ impl LiveCli {
    }

    fn run_prompt_json(&mut self, input: &str) -> Result<(), Box<dyn std::error::Error>> {
-        let client = AnthropicClient::from_auth(resolve_cli_auth_source()?);
+        let client = AnthropicClient::from_auth(resolve_cli_auth_source()?)
+            .with_base_url(api::read_base_url());
        let request = MessageRequest {
            model: self.model.clone(),
            max_tokens: DEFAULT_MAX_TOKENS,
@@ -1104,10 +1098,6 @@ impl LiveCli {
                self.print_status();
                false
            }
-            SlashCommand::Sandbox => {
-                Self::print_sandbox_status();
-                false
-            }
            SlashCommand::Compact => {
                self.compact()?;
                false
@@ -1129,7 +1119,7 @@ impl LiveCli {
                false
            }
            SlashCommand::Init => {
-                Self::run_init()?;
+                run_init()?;
                false
            }
            SlashCommand::Diff => {
@@ -1179,18 +1169,6 @@ impl LiveCli {
        );
    }

-    fn print_sandbox_status() {
-        let cwd = env::current_dir().expect("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))
-        );
-    }
-
    fn set_model(&mut self, model: Option<String>) -> Result<bool, Box<dyn std::error::Error>> {
        let Some(model) = model else {
            println!(
@@ -1204,6 +1182,8 @@ impl LiveCli {
            return Ok(false);
        };

+        let model = resolve_model_alias(&model).to_string();
+
        if model == self.model {
            println!(
                "{}",
@@ -1349,11 +1329,6 @@ impl LiveCli {
        Ok(())
    }

-    fn run_init() -> Result<(), Box<dyn std::error::Error>> {
-        println!("{}", init_claude_md()?);
-        Ok(())
-    }
-
    fn print_diff() -> Result<(), Box<dyn std::error::Error>> {
        println!("{}", render_diff_report()?);
        Ok(())
@@ -1566,7 +1541,6 @@ fn status_context(
    let project_context = ProjectContext::discover_with_git(&cwd, DEFAULT_DATE)?;
    let (project_root, git_branch) =
        parse_git_status_metadata(project_context.git_status.as_deref());
-    let sandbox_status = resolve_sandbox_status(runtime_config.sandbox(), &cwd);
    Ok(StatusContext {
        cwd,
        session_path: session_path.map(Path::to_path_buf),
@@ -1575,7 +1549,6 @@ fn status_context(
        memory_file_count: project_context.instruction_files.len(),
        project_root,
        git_branch,
-        sandbox_status,
    })
 }

@@ -1628,7 +1601,6 @@ fn format_status_report(
            context.discovered_config_files,
            context.memory_file_count,
        ),
-        format_sandbox_report(&context.sandbox_status),
    ]
    .join(
        "
@@ -1637,49 +1609,6 @@ fn format_status_report(
    )
 }

-fn format_sandbox_report(status: &runtime::SandboxStatus) -> String {
-    format!(
-        "Sandbox
-  Enabled           {}
-  Active            {}
-  Supported         {}
-  In container      {}
-  Requested ns      {}
-  Active ns         {}
-  Requested net     {}
-  Active net        {}
-  Filesystem mode   {}
-  Filesystem active {}
-  Allowed mounts    {}
-  Markers           {}
-  Fallback reason   {}",
-        status.enabled,
-        status.active,
-        status.supported,
-        status.in_container,
-        status.requested.namespace_restrictions,
-        status.namespace_active,
-        status.requested.network_isolation,
-        status.network_active,
-        status.filesystem_mode.as_str(),
-        status.filesystem_active,
-        if status.allowed_mounts.is_empty() {
-            "<none>".to_string()
-        } else {
-            status.allowed_mounts.join(", ")
-        },
-        if status.container_markers.is_empty() {
-            "<none>".to_string()
-        } else {
-            status.container_markers.join(", ")
-        },
-        status
-            .fallback_reason
-            .clone()
-            .unwrap_or_else(|| "<none>".to_string()),
-    )
-}
-
 fn render_config_report(section: Option<&str>) -> Result<String, Box<dyn std::error::Error>> {
    let cwd = env::current_dir()?;
    let loader = ConfigLoader::default_for(&cwd);
@@ -1797,67 +1726,12 @@ fn render_memory_report() -> Result<String, Box<dyn std::error::Error>> {

 fn init_claude_md() -> Result<String, Box<dyn std::error::Error>> {
    let cwd = env::current_dir()?;
-    let claude_md = cwd.join("CLAUDE.md");
-    if claude_md.exists() {
-        return Ok(format_init_report(&claude_md, false));
-    }
-
-    let content = render_init_claude_md(&cwd);
-    fs::write(&claude_md, content)?;
-    Ok(format_init_report(&claude_md, true))
+    Ok(initialize_repo(&cwd)?.render())
 }

-fn render_init_claude_md(cwd: &Path) -> String {
-    let mut lines = vec![
-        "# CLAUDE.md".to_string(),
-        String::new(),
-        "This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.".to_string(),
-        String::new(),
-    ];
-
-    let mut command_lines = Vec::new();
-    if cwd.join("rust").join("Cargo.toml").is_file() {
-        command_lines.push("- Run Rust verification from `rust/`: `cargo fmt`, `cargo clippy --workspace --all-targets -- -D warnings`, `cargo test --workspace`".to_string());
-    } else if cwd.join("Cargo.toml").is_file() {
-        command_lines.push("- Run Rust verification from the repo root: `cargo fmt`, `cargo clippy --workspace --all-targets -- -D warnings`, `cargo test --workspace`".to_string());
-    }
-    if cwd.join("tests").is_dir() && cwd.join("src").is_dir() {
-        command_lines.push("- `src/` and `tests/` are also present; check those surfaces before removing or renaming Python-era compatibility assets.".to_string());
-    }
-    if !command_lines.is_empty() {
-        lines.push("## Verification".to_string());
-        lines.extend(command_lines);
-        lines.push(String::new());
-    }
-
-    let mut structure_lines = Vec::new();
-    if cwd.join("rust").is_dir() {
-        structure_lines.push(
-            "- `rust/` contains the Rust workspace and the active CLI/runtime implementation."
-                .to_string(),
-        );
-    }
-    if cwd.join("src").is_dir() {
-        structure_lines.push("- `src/` contains the older Python-first workspace artifacts referenced by the repo history and tests.".to_string());
-    }
-    if cwd.join("tests").is_dir() {
-        structure_lines.push("- `tests/` exercises compatibility and porting behavior across the repository surfaces.".to_string());
-    }
-    if !structure_lines.is_empty() {
-        lines.push("## Repository shape".to_string());
-        lines.extend(structure_lines);
-        lines.push(String::new());
-    }
-
-    lines.push("## Working agreement".to_string());
-    lines.push("- Prefer small, reviewable Rust changes and keep slash-command behavior aligned between the shared command registry and the CLI entrypoints.".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());
-
-    lines.join(
-        "
-",
-    )
+fn run_init() -> Result<(), Box<dyn std::error::Error>> {
+    println!("{}", init_claude_md()?);
+    Ok(())
 }

 fn normalize_permission_mode(mode: &str) -> Option<&'static str> {
@@ -1892,7 +1766,7 @@ fn render_version_report() -> String {
    let git_sha = GIT_SHA.unwrap_or("unknown");
    let target = BUILD_TARGET.unwrap_or("unknown");
    format!(
-        "Version\n  Version          {VERSION}\n  Git SHA          {git_sha}\n  Target           {target}\n  Build date       {DEFAULT_DATE}"
+        "Claw Code\n  Version          {VERSION}\n  Git SHA          {git_sha}\n  Target           {target}\n  Build date       {DEFAULT_DATE}"
    )
 }

@@ -2072,7 +1946,8 @@ impl AnthropicRuntimeClient {
    ) -> Result<Self, Box<dyn std::error::Error>> {
        Ok(Self {
            runtime: tokio::runtime::Runtime::new()?,
-            client: AnthropicClient::from_auth(resolve_cli_auth_source()?),
+            client: AnthropicClient::from_auth(resolve_cli_auth_source()?)
+                .with_base_url(api::read_base_url()),
            model,
            enable_tools,
            allowed_tools,
@@ -2416,34 +2291,62 @@ fn convert_messages(messages: &[ConversationMessage]) -> Vec<InputMessage> {
        .collect()
 }

-fn print_help() {
-    println!("rusty-claude-cli v{VERSION}");
-    println!();
-    println!("Usage:");
-    println!("  rusty-claude-cli [--model MODEL] [--allowedTools TOOL[,TOOL...]]");
-    println!("      Start the interactive REPL");
-    println!("  rusty-claude-cli [--model MODEL] [--output-format text|json] prompt TEXT");
-    println!("      Send one prompt and exit");
-    println!("  rusty-claude-cli [--model MODEL] [--output-format text|json] TEXT");
-    println!("      Shorthand non-interactive prompt mode");
-    println!("  rusty-claude-cli --resume SESSION.json [/status] [/compact] [...]");
-    println!("      Inspect or maintain a saved session without entering the REPL");
-    println!("  rusty-claude-cli dump-manifests");
-    println!("  rusty-claude-cli bootstrap-plan");
-    println!("  rusty-claude-cli system-prompt [--cwd PATH] [--date YYYY-MM-DD]");
-    println!("  rusty-claude-cli login");
-    println!("  rusty-claude-cli logout");
-    println!();
-    println!("Flags:");
-    println!("  --model MODEL              Override the active model");
-    println!("  --output-format FORMAT     Non-interactive output format: text or json");
-    println!("  --permission-mode MODE     Set read-only, workspace-write, or danger-full-access");
-    println!("  --allowedTools TOOLS       Restrict enabled tools (repeatable; comma-separated aliases supported)");
-    println!("  --version, -V              Print version and build information locally");
-    println!();
-    println!("Interactive slash commands:");
-    println!("{}", render_slash_command_help());
-    println!();
+fn print_help_to(out: &mut impl Write) -> io::Result<()> {
+    writeln!(out, "claw v{VERSION}")?;
+    writeln!(out)?;
+    writeln!(out, "Usage:")?;
+    writeln!(
+        out,
+        "  claw [--model MODEL] [--allowedTools TOOL[,TOOL...]]"
+    )?;
+    writeln!(out, "      Start the interactive REPL")?;
+    writeln!(
+        out,
+        "  claw [--model MODEL] [--output-format text|json] prompt TEXT"
+    )?;
+    writeln!(out, "      Send one prompt and exit")?;
+    writeln!(
+        out,
+        "  claw [--model MODEL] [--output-format text|json] TEXT"
+    )?;
+    writeln!(out, "      Shorthand non-interactive prompt mode")?;
+    writeln!(
+        out,
+        "  claw --resume SESSION.json [/status] [/compact] [...]"
+    )?;
+    writeln!(
+        out,
+        "      Inspect or maintain a saved session without entering the REPL"
+    )?;
+    writeln!(out, "  claw dump-manifests")?;
+    writeln!(out, "  claw bootstrap-plan")?;
+    writeln!(out, "  claw system-prompt [--cwd PATH] [--date YYYY-MM-DD]")?;
+    writeln!(out, "  claw login")?;
+    writeln!(out, "  claw logout")?;
+    writeln!(out, "  claw init")?;
+    writeln!(out)?;
+    writeln!(out, "Flags:")?;
+    writeln!(
+        out,
+        "  --model MODEL              Override the active model"
+    )?;
+    writeln!(
+        out,
+        "  --output-format FORMAT     Non-interactive output format: text or json"
+    )?;
+    writeln!(
+        out,
+        "  --permission-mode MODE     Set read-only, workspace-write, or danger-full-access"
+    )?;
+    writeln!(out, "  --allowedTools TOOLS       Restrict enabled tools (repeatable; comma-separated aliases supported)")?;
+    writeln!(
+        out,
+        "  --version, -V              Print version and build information locally"
+    )?;
+    writeln!(out)?;
+    writeln!(out, "Interactive slash commands:")?;
+    writeln!(out, "{}", render_slash_command_help())?;
+    writeln!(out)?;
    let resume_commands = resume_supported_slash_commands()
        .into_iter()
        .map(|spec| match spec.argument_hint {
@@ -2452,28 +2355,43 @@ fn print_help() {
        })
        .collect::<Vec<_>>()
        .join(", ");
-    println!("Resume-safe commands: {resume_commands}");
-    println!("Examples:");
-    println!("  rusty-claude-cli --model claude-opus \"summarize this repo\"");
-    println!("  rusty-claude-cli --output-format json prompt \"explain src/main.rs\"");
-    println!("  rusty-claude-cli --allowedTools read,glob \"summarize Cargo.toml\"");
-    println!("  rusty-claude-cli --resume session.json /status /diff /export notes.txt");
-    println!("  rusty-claude-cli login");
+    writeln!(out, "Resume-safe commands: {resume_commands}")?;
+    writeln!(out, "Examples:")?;
+    writeln!(out, "  claw --model claude-opus \"summarize this repo\"")?;
+    writeln!(
+        out,
+        "  claw --output-format json prompt \"explain src/main.rs\""
+    )?;
+    writeln!(
+        out,
+        "  claw --allowedTools read,glob \"summarize Cargo.toml\""
+    )?;
+    writeln!(
+        out,
+        "  claw --resume session.json /status /diff /export notes.txt"
+    )?;
+    writeln!(out, "  claw login")?;
+    writeln!(out, "  claw init")?;
+    Ok(())
+}
+
+fn print_help() {
+    let _ = print_help_to(&mut io::stdout());
 }

 #[cfg(test)]
 mod tests {
    use super::{
-        filter_tool_specs, format_compact_report, format_cost_report, format_init_report,
-        format_model_report, format_model_switch_report, format_permissions_report,
-        format_permissions_switch_report, format_resume_report, format_status_report,
-        format_tool_call_start, format_tool_result, normalize_permission_mode, parse_args,
-        parse_git_status_metadata, render_config_report, render_init_claude_md,
-        render_memory_report, render_repl_help, resume_supported_slash_commands, status_context,
-        CliAction, CliOutputFormat, SlashCommand, StatusUsage, DEFAULT_MODEL,
+        filter_tool_specs, format_compact_report, format_cost_report, format_model_report,
+        format_model_switch_report, format_permissions_report, format_permissions_switch_report,
+        format_resume_report, format_status_report, format_tool_call_start, format_tool_result,
+        normalize_permission_mode, parse_args, parse_git_status_metadata, print_help_to,
+        render_config_report, render_memory_report, render_repl_help, resolve_model_alias,
+        resume_supported_slash_commands, status_context, CliAction, CliOutputFormat, SlashCommand,
+        StatusUsage, DEFAULT_MODEL,
    };
    use runtime::{ContentBlock, ConversationMessage, MessageRole, PermissionMode};
-    use std::path::{Path, PathBuf};
+    use std::path::PathBuf;

    #[test]
    fn defaults_to_repl_when_no_args() {
@@ -2527,6 +2445,34 @@ mod tests {
        );
    }

+    #[test]
+    fn resolves_model_aliases_in_args() {
+        let args = vec![
+            "--model".to_string(),
+            "opus".to_string(),
+            "explain".to_string(),
+            "this".to_string(),
+        ];
+        assert_eq!(
+            parse_args(&args).expect("args should parse"),
+            CliAction::Prompt {
+                prompt: "explain this".to_string(),
+                model: "claude-opus-4-6".to_string(),
+                output_format: CliOutputFormat::Text,
+                allowed_tools: None,
+                permission_mode: PermissionMode::WorkspaceWrite,
+            }
+        );
+    }
+
+    #[test]
+    fn resolves_known_model_aliases() {
+        assert_eq!(resolve_model_alias("opus"), "claude-opus-4-6");
+        assert_eq!(resolve_model_alias("sonnet"), "claude-sonnet-4-6");
+        assert_eq!(resolve_model_alias("haiku"), "claude-haiku-3-5-20241022");
+        assert_eq!(resolve_model_alias("claude-opus"), "claude-opus");
+    }
+
    #[test]
    fn parses_version_flags_without_initializing_prompt_mode() {
        assert_eq!(
@@ -2609,6 +2555,10 @@ mod tests {
            parse_args(&["logout".to_string()]).expect("logout should parse"),
            CliAction::Logout
        );
+        assert_eq!(
+            parse_args(&["init".to_string()]).expect("init should parse"),
+            CliAction::Init
+        );
    }

    #[test]
@@ -2676,7 +2626,6 @@ mod tests {
        assert!(help.contains("REPL"));
        assert!(help.contains("/help"));
        assert!(help.contains("/status"));
-        assert!(help.contains("/sandbox"));
        assert!(help.contains("/model [model]"));
        assert!(help.contains("/permissions [read-only|workspace-write|danger-full-access]"));
        assert!(help.contains("/clear [--confirm]"));
@@ -2701,8 +2650,8 @@ mod tests {
        assert_eq!(
            names,
            vec![
-                "help", "status", "sandbox", "compact", "clear", "cost", "config", "memory",
-                "init", "diff", "version", "export",
+                "help", "status", "compact", "clear", "cost", "config", "memory", "init", "diff",
+                "version", "export",
            ]
        );
    }
@@ -2764,12 +2713,11 @@ mod tests {
    }

    #[test]
-    fn init_report_uses_structured_output() {
-        let created = format_init_report(Path::new("/tmp/CLAUDE.md"), true);
-        assert!(created.contains("Init"));
-        assert!(created.contains("Result           created"));
-        let skipped = format_init_report(Path::new("/tmp/CLAUDE.md"), false);
-        assert!(skipped.contains("skipped (already exists)"));
+    fn init_help_mentions_direct_subcommand() {
+        let mut help = Vec::new();
+        print_help_to(&mut help).expect("help should render");
+        let help = String::from_utf8(help).expect("help should be utf8");
+        assert!(help.contains("claw init"));
    }

    #[test]
@@ -2820,7 +2768,6 @@ mod tests {
                memory_file_count: 4,
                project_root: Some(PathBuf::from("/tmp")),
                git_branch: Some("main".to_string()),
-                sandbox_status: runtime::SandboxStatus::default(),
            },
        );
        assert!(status.contains("Status"));
@@ -2932,7 +2879,7 @@ mod tests {

    #[test]
    fn init_template_mentions_detected_rust_workspace() {
-        let rendered = render_init_claude_md(Path::new("."));
+        let rendered = crate::init::render_init_claude_md(std::path::Path::new("."));
        assert!(rendered.contains("# CLAUDE.md"));
        assert!(rendered.contains("cargo clippy --workspace --all-targets -- -D warnings"));
    }
@@ -2982,17 +2929,3 @@ mod tests {
        assert!(done.contains("contents"));
    }
 }
-
-#[cfg(test)]
-mod sandbox_report_tests {
-    use super::format_sandbox_report;
-
-    #[test]
-    fn sandbox_report_renders_expected_fields() {
-        let report = format_sandbox_report(&runtime::SandboxStatus::default());
-        assert!(report.contains("Sandbox"));
-        assert!(report.contains("Enabled"));
-        assert!(report.contains("Filesystem mode"));
-        assert!(report.contains("Fallback reason"));
-    }
-}
--- a/rust/crates/rusty-claude-cli/src/render.rs
+++ b/rust/crates/rusty-claude-cli/src/render.rs
@@ -21,6 +21,7 @@ pub struct ColorTheme {
    inline_code: Color,
    link: Color,
    quote: Color,
+    table_border: Color,
    spinner_active: Color,
    spinner_done: Color,
    spinner_failed: Color,
@@ -35,6 +36,7 @@ impl Default for ColorTheme {
            inline_code: Color::Green,
            link: Color::Blue,
            quote: Color::DarkGrey,
+            table_border: Color::DarkCyan,
            spinner_active: Color::Blue,
            spinner_done: Color::Green,
            spinner_failed: Color::Red,
@@ -113,24 +115,70 @@ impl Spinner {
    }
 }

+#[derive(Debug, Clone, PartialEq, Eq)]
+enum ListKind {
+    Unordered,
+    Ordered { next_index: u64 },
+}
+
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
+struct TableState {
+    headers: Vec<String>,
+    rows: Vec<Vec<String>>,
+    current_row: Vec<String>,
+    current_cell: String,
+    in_head: bool,
+}
+
+impl TableState {
+    fn push_cell(&mut self) {
+        let cell = self.current_cell.trim().to_string();
+        self.current_row.push(cell);
+        self.current_cell.clear();
+    }
+
+    fn finish_row(&mut self) {
+        if self.current_row.is_empty() {
+            return;
+        }
+        let row = std::mem::take(&mut self.current_row);
+        if self.in_head {
+            self.headers = row;
+        } else {
+            self.rows.push(row);
+        }
+    }
+}
+
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
 struct RenderState {
    emphasis: usize,
    strong: usize,
    quote: usize,
-    list: usize,
+    list_stack: Vec<ListKind>,
+    table: Option<TableState>,
 }

 impl RenderState {
    fn style_text(&self, text: &str, theme: &ColorTheme) -> String {
+        let mut styled = text.to_string();
        if self.strong > 0 {
-            format!("{}", text.bold().with(theme.strong))
-        } else if self.emphasis > 0 {
-            format!("{}", text.italic().with(theme.emphasis))
-        } else if self.quote > 0 {
-            format!("{}", text.with(theme.quote))
+            styled = format!("{}", styled.bold().with(theme.strong));
+        }
+        if self.emphasis > 0 {
+            styled = format!("{}", styled.italic().with(theme.emphasis));
+        }
+        if self.quote > 0 {
+            styled = format!("{}", styled.with(theme.quote));
+        }
+        styled
+    }
+
+    fn capture_target_mut<'a>(&'a mut self, output: &'a mut String) -> &'a mut String {
+        if let Some(table) = self.table.as_mut() {
+            &mut table.current_cell
        } else {
-            text.to_string()
+            output
        }
    }
 }
@@ -190,6 +238,7 @@ impl TerminalRenderer {
        output.trim_end().to_string()
    }

+    #[allow(clippy::too_many_lines)]
    fn render_event(
        &self,
        event: Event<'_>,
@@ -203,12 +252,22 @@ impl TerminalRenderer {
            Event::Start(Tag::Heading { level, .. }) => self.start_heading(level as u8, output),
            Event::End(TagEnd::Heading(..) | TagEnd::Paragraph) => output.push_str("\n\n"),
            Event::Start(Tag::BlockQuote(..)) => self.start_quote(state, output),
-            Event::End(TagEnd::BlockQuote(..) | TagEnd::Item)
-            | Event::SoftBreak
-            | Event::HardBreak => output.push('\n'),
-            Event::Start(Tag::List(_)) => state.list += 1,
+            Event::End(TagEnd::BlockQuote(..)) => {
+                state.quote = state.quote.saturating_sub(1);
+                output.push('\n');
+            }
+            Event::End(TagEnd::Item) | Event::SoftBreak | Event::HardBreak => {
+                state.capture_target_mut(output).push('\n');
+            }
+            Event::Start(Tag::List(first_item)) => {
+                let kind = match first_item {
+                    Some(index) => ListKind::Ordered { next_index: index },
+                    None => ListKind::Unordered,
+                };
+                state.list_stack.push(kind);
+            }
            Event::End(TagEnd::List(..)) => {
-                state.list = state.list.saturating_sub(1);
+                state.list_stack.pop();
                output.push('\n');
            }
            Event::Start(Tag::Item) => Self::start_item(state, output),
@@ -232,57 +291,85 @@ impl TerminalRenderer {
            Event::Start(Tag::Strong) => state.strong += 1,
            Event::End(TagEnd::Strong) => state.strong = state.strong.saturating_sub(1),
            Event::Code(code) => {
-                let _ = write!(
-                    output,
-                    "{}",
-                    format!("`{code}`").with(self.color_theme.inline_code)
-                );
+                let rendered =
+                    format!("{}", format!("`{code}`").with(self.color_theme.inline_code));
+                state.capture_target_mut(output).push_str(&rendered);
            }
            Event::Rule => output.push_str("---\n"),
            Event::Text(text) => {
                self.push_text(text.as_ref(), state, output, code_buffer, *in_code_block);
            }
-            Event::Html(html) | Event::InlineHtml(html) => output.push_str(&html),
-            Event::FootnoteReference(reference) => {
-                let _ = write!(output, "[{reference}]");
+            Event::Html(html) | Event::InlineHtml(html) => {
+                state.capture_target_mut(output).push_str(&html);
+            }
+            Event::FootnoteReference(reference) => {
+                let _ = write!(state.capture_target_mut(output), "[{reference}]");
+            }
+            Event::TaskListMarker(done) => {
+                state
+                    .capture_target_mut(output)
+                    .push_str(if done { "[x] " } else { "[ ] " });
+            }
+            Event::InlineMath(math) | Event::DisplayMath(math) => {
+                state.capture_target_mut(output).push_str(&math);
            }
-            Event::TaskListMarker(done) => output.push_str(if done { "[x] " } else { "[ ] " }),
-            Event::InlineMath(math) | Event::DisplayMath(math) => output.push_str(&math),
            Event::Start(Tag::Link { dest_url, .. }) => {
-                let _ = write!(
-                    output,
+                let rendered = format!(
                    "{}",
                    format!("[{dest_url}]")
                        .underlined()
                        .with(self.color_theme.link)
                );
+                state.capture_target_mut(output).push_str(&rendered);
            }
            Event::Start(Tag::Image { dest_url, .. }) => {
-                let _ = write!(
-                    output,
+                let rendered = format!(
                    "{}",
                    format!("[image:{dest_url}]").with(self.color_theme.link)
                );
+                state.capture_target_mut(output).push_str(&rendered);
            }
-            Event::Start(
-                Tag::Paragraph
-                | Tag::Table(..)
-                | Tag::TableHead
-                | Tag::TableRow
-                | Tag::TableCell
-                | Tag::MetadataBlock(..)
-                | _,
-            )
-            | Event::End(
-                TagEnd::Link
-                | TagEnd::Image
-                | TagEnd::Table
-                | TagEnd::TableHead
-                | TagEnd::TableRow
-                | TagEnd::TableCell
-                | TagEnd::MetadataBlock(..)
-                | _,
-            ) => {}
+            Event::Start(Tag::Table(..)) => state.table = Some(TableState::default()),
+            Event::End(TagEnd::Table) => {
+                if let Some(table) = state.table.take() {
+                    output.push_str(&self.render_table(&table));
+                    output.push_str("\n\n");
+                }
+            }
+            Event::Start(Tag::TableHead) => {
+                if let Some(table) = state.table.as_mut() {
+                    table.in_head = true;
+                }
+            }
+            Event::End(TagEnd::TableHead) => {
+                if let Some(table) = state.table.as_mut() {
+                    table.finish_row();
+                    table.in_head = false;
+                }
+            }
+            Event::Start(Tag::TableRow) => {
+                if let Some(table) = state.table.as_mut() {
+                    table.current_row.clear();
+                    table.current_cell.clear();
+                }
+            }
+            Event::End(TagEnd::TableRow) => {
+                if let Some(table) = state.table.as_mut() {
+                    table.finish_row();
+                }
+            }
+            Event::Start(Tag::TableCell) => {
+                if let Some(table) = state.table.as_mut() {
+                    table.current_cell.clear();
+                }
+            }
+            Event::End(TagEnd::TableCell) => {
+                if let Some(table) = state.table.as_mut() {
+                    table.push_cell();
+                }
+            }
+            Event::Start(Tag::Paragraph | Tag::MetadataBlock(..) | _)
+            | Event::End(TagEnd::Link | TagEnd::Image | TagEnd::MetadataBlock(..) | _) => {}
        }
    }

@@ -302,9 +389,19 @@ impl TerminalRenderer {
        let _ = write!(output, "{}", "│ ".with(self.color_theme.quote));
    }

-    fn start_item(state: &RenderState, output: &mut String) {
-        output.push_str(&"  ".repeat(state.list.saturating_sub(1)));
-        output.push_str("• ");
+    fn start_item(state: &mut RenderState, output: &mut String) {
+        let depth = state.list_stack.len().saturating_sub(1);
+        output.push_str(&"  ".repeat(depth));
+
+        let marker = match state.list_stack.last_mut() {
+            Some(ListKind::Ordered { next_index }) => {
+                let value = *next_index;
+                *next_index += 1;
+                format!("{value}. ")
+            }
+            _ => "• ".to_string(),
+        };
+        output.push_str(&marker);
    }

    fn start_code_block(&self, code_language: &str, output: &mut String) {
@@ -328,7 +425,7 @@ impl TerminalRenderer {
    fn push_text(
        &self,
        text: &str,
-        state: &RenderState,
+        state: &mut RenderState,
        output: &mut String,
        code_buffer: &mut String,
        in_code_block: bool,
@@ -336,10 +433,82 @@ impl TerminalRenderer {
        if in_code_block {
            code_buffer.push_str(text);
        } else {
-            output.push_str(&state.style_text(text, &self.color_theme));
+            let rendered = state.style_text(text, &self.color_theme);
+            state.capture_target_mut(output).push_str(&rendered);
        }
    }

+    fn render_table(&self, table: &TableState) -> String {
+        let mut rows = Vec::new();
+        if !table.headers.is_empty() {
+            rows.push(table.headers.clone());
+        }
+        rows.extend(table.rows.iter().cloned());
+
+        if rows.is_empty() {
+            return String::new();
+        }
+
+        let column_count = rows.iter().map(Vec::len).max().unwrap_or(0);
+        let widths = (0..column_count)
+            .map(|column| {
+                rows.iter()
+                    .filter_map(|row| row.get(column))
+                    .map(|cell| visible_width(cell))
+                    .max()
+                    .unwrap_or(0)
+            })
+            .collect::<Vec<_>>();
+
+        let border = format!("{}", "│".with(self.color_theme.table_border));
+        let separator = widths
+            .iter()
+            .map(|width| "─".repeat(*width + 2))
+            .collect::<Vec<_>>()
+            .join(&format!("{}", "┼".with(self.color_theme.table_border)));
+        let separator = format!("{border}{separator}{border}");
+
+        let mut output = String::new();
+        if !table.headers.is_empty() {
+            output.push_str(&self.render_table_row(&table.headers, &widths, true));
+            output.push('\n');
+            output.push_str(&separator);
+            if !table.rows.is_empty() {
+                output.push('\n');
+            }
+        }
+
+        for (index, row) in table.rows.iter().enumerate() {
+            output.push_str(&self.render_table_row(row, &widths, false));
+            if index + 1 < table.rows.len() {
+                output.push('\n');
+            }
+        }
+
+        output
+    }
+
+    fn render_table_row(&self, row: &[String], widths: &[usize], is_header: bool) -> String {
+        let border = format!("{}", "│".with(self.color_theme.table_border));
+        let mut line = String::new();
+        line.push_str(&border);
+
+        for (index, width) in widths.iter().enumerate() {
+            let cell = row.get(index).map_or("", String::as_str);
+            line.push(' ');
+            if is_header {
+                let _ = write!(line, "{}", cell.bold().with(self.color_theme.heading));
+            } else {
+                line.push_str(cell);
+            }
+            let padding = width.saturating_sub(visible_width(cell));
+            line.push_str(&" ".repeat(padding + 1));
+            line.push_str(&border);
+        }
+
+        line
+    }
+
    #[must_use]
    pub fn highlight_code(&self, code: &str, language: &str) -> String {
        let syntax = self
@@ -372,32 +541,36 @@ impl TerminalRenderer {
    }
 }

-#[cfg(test)]
-mod tests {
-    use super::{Spinner, TerminalRenderer};
+fn visible_width(input: &str) -> usize {
+    strip_ansi(input).chars().count()
+}

-    fn strip_ansi(input: &str) -> String {
-        let mut output = String::new();
-        let mut chars = input.chars().peekable();
+fn strip_ansi(input: &str) -> String {
+    let mut output = String::new();
+    let mut chars = input.chars().peekable();

-        while let Some(ch) = chars.next() {
-            if ch == '\u{1b}' {
-                if chars.peek() == Some(&'[') {
-                    chars.next();
-                    for next in chars.by_ref() {
-                        if next.is_ascii_alphabetic() {
-                            break;
-                        }
+    while let Some(ch) = chars.next() {
+        if ch == '\u{1b}' {
+            if chars.peek() == Some(&'[') {
+                chars.next();
+                for next in chars.by_ref() {
+                    if next.is_ascii_alphabetic() {
+                        break;
                    }
                }
-            } else {
-                output.push(ch);
            }
+        } else {
+            output.push(ch);
        }
-
-        output
    }

+    output
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{strip_ansi, Spinner, TerminalRenderer};
+
    #[test]
    fn renders_markdown_with_styling_and_lists() {
        let terminal_renderer = TerminalRenderer::new();
@@ -422,6 +595,34 @@ mod tests {
        assert!(markdown_output.contains('\u{1b}'));
    }

+    #[test]
+    fn renders_ordered_and_nested_lists() {
+        let terminal_renderer = TerminalRenderer::new();
+        let markdown_output =
+            terminal_renderer.render_markdown("1. first\n2. second\n   - nested\n   - child");
+        let plain_text = strip_ansi(&markdown_output);
+
+        assert!(plain_text.contains("1. first"));
+        assert!(plain_text.contains("2. second"));
+        assert!(plain_text.contains("  • nested"));
+        assert!(plain_text.contains("  • child"));
+    }
+
+    #[test]
+    fn renders_tables_with_alignment() {
+        let terminal_renderer = TerminalRenderer::new();
+        let markdown_output = terminal_renderer
+            .render_markdown("| Name | Value |\n| ---- | ----- |\n| alpha | 1 |\n| beta | 22 |");
+        let plain_text = strip_ansi(&markdown_output);
+        let lines = plain_text.lines().collect::<Vec<_>>();
+
+        assert_eq!(lines[0], "│ Name  │ Value │");
+        assert_eq!(lines[1], "│───────┼───────│");
+        assert_eq!(lines[2], "│ alpha │ 1     │");
+        assert_eq!(lines[3], "│ beta  │ 22    │");
+        assert!(markdown_output.contains('\u{1b}'));
+    }
+
    #[test]
    fn spinner_advances_frames() {
        let terminal_renderer = TerminalRenderer::new();
--- a/rust/crates/tools/src/lib.rs
+++ b/rust/crates/tools/src/lib.rs
@@ -62,11 +62,7 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
                    "timeout": { "type": "integer", "minimum": 1 },
                    "description": { "type": "string" },
                    "run_in_background": { "type": "boolean" },
-                    "dangerouslyDisableSandbox": { "type": "boolean" },
-                    "namespaceRestrictions": { "type": "boolean" },
-                    "isolateNetwork": { "type": "boolean" },
-                    "filesystemMode": { "type": "string", "enum": ["off", "workspace-only", "allow-list"] },
-                    "allowedMounts": { "type": "array", "items": { "type": "string" } }
+                    "dangerouslyDisableSandbox": { "type": "boolean" }
                },
                "required": ["command"],
                "additionalProperties": false
@@ -2219,7 +2215,7 @@ fn execute_shell_command(
            persisted_output_path: None,
            persisted_output_size: None,
            sandbox_status: None,
-        });
+});
    }

    let mut process = std::process::Command::new(shell);
@@ -2288,7 +2284,7 @@ Command exceeded timeout of {timeout_ms} ms",
                    persisted_output_path: None,
                    persisted_output_size: None,
                    sandbox_status: None,
-                });
+});
            }
            std::thread::sleep(Duration::from_millis(10));
        }
Author	SHA1	Message	Date
Yeachan-Heo	e2753f055a	Replace bespoke CLI line editing with rustyline and canonical model aliases The REPL now wraps rustyline::Editor instead of maintaining a custom raw-mode input stack. This preserves the existing LineEditor surface while delegating history, completion, and interactive editing to a maintained library. The CLI argument parser and /model command path also normalize shorthand model names to our current canonical Anthropic identifiers. Constraint: User requested rustyline 15 specifically for the CLI editor rewrite Constraint: Existing LineEditor constructor and read_line API had to remain stable Rejected: Keep extending the crossterm-based editor \| custom key handling and history logic were redundant with rustyline Rejected: Resolve aliases only for --model flags \| /model would still diverge from CLI startup behavior Confidence: high Scope-risk: moderate Reversibility: clean Directive: Keep model alias normalization centralized in main.rs so CLI flag parsing and /model stay in sync Tested: cargo check --workspace Tested: cargo test --workspace Tested: cargo build --workspace Tested: cargo clippy --workspace --all-targets -- -D warnings Not-tested: Interactive manual terminal validation of Shift+Enter behavior across terminal emulators	2026-04-01 02:04:12 +00:00
Yeachan-Heo	9a86aa6444	fix: default model to claude-opus-4-6	2026-04-01 01:48:21 +00:00
Yeachan-Heo	21b0887469	fix: use ASCII prompt to prevent backspace corruption	2026-04-01 01:47:32 +00:00
Yeachan-Heo	0d89231caa	Merge remote-tracking branch 'origin/rcc/render' into dev/rust # Conflicts: # rust/crates/rusty-claude-cli/src/main.rs	2026-04-01 01:46:17 +00:00
Yeachan-Heo	b445a3320f	feat: rebrand to Claw Code with ASCII art banner, claw binary, lobster prompt 🦞	2026-04-01 01:44:55 +00:00
Yeachan-Heo	650a24b6e2	feat: terminal markdown rendering with ANSI colors Add terminal markdown rendering support in the Rust CLI by extending the existing renderer with ordered lists, aligned tables, and ANSI-styled code/inline formatting. Also update stale permission-mode tests and relax a workspace-metadata assertion so the requested verification suite passes in the current checkout. Constraint: Keep the existing renderer integration path used by main.rs and app.rs Constraint: No new dependencies for markdown rendering or display width handling Rejected: Replacing the renderer with a new markdown crate \| unnecessary scope and integration risk Confidence: medium Scope-risk: moderate Directive: Table alignment currently targets ANSI-stripped common CLI content; revisit if wide-character width handling becomes required Tested: cargo fmt --all; cargo build; cargo test; cargo clippy --all-targets --all-features -- -D warnings Not-tested: Manual interactive rendering in a live terminal session	2026-04-01 01:43:40 +00:00
Yeachan-Heo	d018276fc1	fix: respect ANTHROPIC_BASE_URL in all client instantiations	2026-04-01 01:40:43 +00:00
Yeachan-Heo	387a8bb13f	feat: git integration, sandbox isolation, init command (merged from rcc branches)	2026-04-01 01:23:47 +00:00
Yeachan-Heo	243a1ff74f	Merge remote-tracking branch 'origin/rcc/api' into dev/rust # Conflicts: # rust/crates/rusty-claude-cli/src/main.rs	2026-04-01 01:20:29 +00:00
Yeachan-Heo	583d191527	fix: resolve thinking/streaming/update merge conflicts	2026-04-01 01:15:30 +00:00
Yeachan-Heo	074bd5b7b7	Make Claude project bootstrap available from a real init command The Rust CLI previously hid init behind the REPL slash-command surface and only created a starter CLAUDE.md. This change adds a direct `init` subcommand and moves bootstrap behavior into a shared helper so `/init` and `init` create the same project scaffolding: `.claude/`, `.claude.json`, starter `CLAUDE.md`, and local-only `.gitignore` entries. The generated guidance now adapts to a small, explicit set of repository markers so new projects get language/framework-aware starting instructions without overwriting existing files. Constraint: Runtime config precedence already treats `.claude.json`, `.claude/settings.json`, and `.claude/settings.local.json` as separate scopes Constraint: `.claude/sessions/` is used for local session persistence and should not be committed by default Rejected: Keep init as REPL-only `/init` behavior \| would not satisfy the requested direct init command and keeps bootstrap discoverability low Rejected: Ignore all of `.claude/` \| would hide shared project config that the runtime can intentionally load Confidence: high Scope-risk: moderate Reversibility: clean Directive: Keep direct `init` and `/init` on the same helper path and keep detection heuristics bounded to explicit repository markers Tested: cargo fmt --all; cargo clippy --workspace --all-targets -- -D warnings; cargo test --workspace Not-tested: interactive manual run of `rusty-claude-cli init` against a non-test repository	2026-04-01 01:14:44 +00:00
Yeachan-Heo	bec07658b8	Merge remote-tracking branch 'origin/rcc/update' into dev/rust # Conflicts: # rust/crates/rusty-claude-cli/src/main.rs	2026-04-01 01:11:12 +00:00
Yeachan-Heo	f403d3b107	Merge remote-tracking branch 'origin/rcc/thinking' into dev/rust # Conflicts: # rust/crates/commands/src/lib.rs # rust/crates/rusty-claude-cli/src/main.rs	2026-04-01 01:11:06 +00:00
Yeachan-Heo	bd494184fc	Merge remote-tracking branch 'origin/rcc/runtime' into dev/rust # Conflicts: # rust/crates/rusty-claude-cli/src/main.rs	2026-04-01 01:10:53 +00:00
Yeachan-Heo	a22700562d	Merge remote-tracking branch 'origin/rcc/cli' into dev/rust # Conflicts: # rust/crates/rusty-claude-cli/src/main.rs	2026-04-01 01:10:40 +00:00
Yeachan-Heo	c14196c730	Expose structured thinking without polluting normal assistant output Extended thinking needed to travel end-to-end through the API, runtime, and CLI so the client can request a thinking budget, preserve streamed reasoning blocks, and present them in a collapsed text-first form. The implementation keeps thinking strictly opt-in, adds a session-local toggle, and reuses the existing flag/slash-command/reporting surfaces instead of introducing a new UI layer. Constraint: Existing non-thinking text/tool flows had to remain backward compatible by default Constraint: Terminal UX needed a lightweight collapsed representation rather than an interactive TUI widget Rejected: Heuristic CLI-only parsing of reasoning text \| brittle against structured stream payloads Rejected: Expanded raw thinking output by default \| too noisy for normal assistant responses Confidence: medium Scope-risk: moderate Reversibility: clean Directive: Keep thinking blocks structurally separate from answer text unless the upstream API contract changes Tested: cargo fmt --all; cargo clippy --workspace --all-targets -- -D warnings; cargo test -q Not-tested: Live upstream thinking payloads against the production API contract	2026-04-01 01:08:18 +00:00
Yeachan-Heo	f544125c01	Improve streaming feedback for CLI responses The active Rust CLI path now keeps users informed during streaming with a waiting spinner, inline tool call summaries, response token usage, semantic color cues, and an opt-out switch. The work stays inside the active + renderer path and updates stale runtime tests that referenced removed permission enums. Constraint: Must keep changes in the active CLI path rather than refactoring unused app shell Constraint: Must pass cargo fmt, clippy, and full cargo test without adding dependencies Rejected: Route the work through \| inactive path would expand risk and scope Confidence: high Scope-risk: moderate Reversibility: clean Directive: Keep future streaming UX changes wired through renderer color settings so remains end-to-end Tested: cargo fmt --all; cargo clippy --all-targets --all-features -- -D warnings; cargo test Not-tested: Interactive manual terminal run against live Anthropic streaming output	2026-04-01 01:04:56 +00:00
Yeachan-Heo	ccebabe605	Preserve verified session persistence while syncing remote runtime branch history Origin/rcc/runtime advanced independently while this branch implemented conversation history persistence. This merge keeps the tested local tree as the source of truth for the user-requested feature while recording the remote branch tip so future work can proceed from a shared history. Constraint: Push required incorporating origin/rcc/runtime history without breaking the verified session-persistence implementation Rejected: Force-push over origin/rcc/runtime \| would discard remote branch history Confidence: medium Scope-risk: narrow Reversibility: clean Directive: Before the next broad CLI/runtime refactor, compare this branch against origin/rcc/runtime for any remote-only startup behavior worth porting deliberately Tested: cargo fmt; cargo clippy --workspace --all-targets -- -D warnings; cargo test --workspace Not-tested: Remote-only runtime startup semantics not exercised by the session persistence change	2026-04-01 01:02:05 +00:00
Yeachan-Heo	cdf24b87b4	Enable safe in-place CLI self-updates from GitHub releases Add a self-update command to the Rust CLI that checks the latest GitHub release, compares versions, downloads a matching binary plus checksum manifest, verifies SHA-256, and swaps the executable only after validation succeeds. The command reports changelog text from the release body and exits safely when no published release or matching asset exists.\n\nThe workspace verification request also surfaced unrelated stale permission-mode references in runtime tests and a brittle config-count assertion in the CLI tests. Those were updated so the requested fmt/clippy/test pass can complete cleanly in this worktree.\n\nConstraint: GitHub latest release for instructkr/clawd-code currently returns 404, so the updater must degrade safely when no published release exists\nConstraint: Must not replace the current executable before checksum verification succeeds\nRejected: Shell out to an external updater \| environment-dependent and does not meet the GitHub API/changelog requirement\nRejected: Add archive extraction support now \| no published release assets exist yet to justify broader packaging complexity\nConfidence: medium\nScope-risk: moderate\nReversibility: clean\nDirective: Keep release asset naming and checksum manifest conventions aligned with the eventual GitHub release pipeline before expanding packaging formats\nTested: cargo fmt; cargo clippy --workspace --all-targets -- -D warnings; cargo test --workspace --exclude compat-harness; cargo run -q -p rusty-claude-cli -- self-update\nNot-tested: Successful live binary replacement against a real published GitHub release asset	2026-04-01 01:01:26 +00:00
Yeachan-Heo	770fb8d0e7	Merge remote-tracking branch 'origin/rcc/tools' into dev/rust	2026-04-01 01:00:37 +00:00
Yeachan-Heo	e38e3ee4d7	Merge remote-tracking branch 'origin/rcc/memory' into dev/rust	2026-04-01 01:00:37 +00:00
Yeachan-Heo	331b8fc811	Merge remote-tracking branch 'origin/rcc/image' into dev/rust # Conflicts: # rust/crates/rusty-claude-cli/src/main.rs	2026-04-01 01:00:37 +00:00
Yeachan-Heo	72b5f2fe80	Merge remote-tracking branch 'origin/rcc/doctor' into dev/rust # Conflicts: # rust/crates/rusty-claude-cli/src/main.rs	2026-04-01 01:00:31 +00:00
Yeachan-Heo	b200198df7	Make local environment failures diagnosable from the CLI Add a non-interactive doctor subcommand that checks API key reachability, OAuth credential state, config files, git, MCP servers, network access, and system metadata in one structured report. The implementation reuses existing runtime/auth plumbing and adds focused tests for parsing and report behavior. Also update stale runtime permission-mode tests so workspace verification reflects the current enum model rather than historical Prompt/Allow variants. Constraint: Keep diagnostics dependency-free and reuse existing runtime/auth/MCP code Rejected: Add a REPL-only slash command \| diagnostics must work before a session starts Rejected: Split checks into multiple subcommands \| higher surface area with less troubleshooting value Confidence: medium Scope-risk: moderate Reversibility: clean Directive: Keep doctor checks bounded and non-destructive; if future probes become slower or stateful, gate them explicitly Tested: cargo fmt --all --check; cargo clippy --workspace --all-targets -- -D warnings; cargo test --workspace; cargo run -p rusty-claude-cli -- doctor Not-tested: Positive live API-key validation path against a known-good production credential	2026-04-01 00:59:57 +00:00
Yeachan-Heo	2fd6241bd8	Enable Agent tool child execution with bounded recursion The Agent tool previously stopped at queued handoff metadata, so this change runs a real nested conversation, preserves artifact output, and guards recursion depth. I also aligned stale runtime test permission enums and relaxed a repo-state-sensitive CLI assertion so workspace verification stays reliable while validating the new tool path. Constraint: Reuse existing runtime conversation abstractions without introducing a new orchestration service Constraint: Child agent execution must preserve the same tool surface while preventing unbounded nesting Rejected: Shell out to the CLI binary for child execution \| brittle process coupling and weaker testability Rejected: Leave Agent as metadata-only handoff \| does not satisfy requested sub-agent orchestration behavior Confidence: high Scope-risk: moderate Reversibility: clean Directive: Keep Agent recursion limits enforced wherever nested Agent calls can re-enter the tool executor Tested: cargo fmt --all --manifest-path rust/Cargo.toml; cargo test --manifest-path rust/Cargo.toml; cargo clippy --manifest-path rust/Cargo.toml --workspace --all-targets -- -D warnings Not-tested: Live Anthropic-backed child agent execution against production credentials	2026-04-01 00:59:20 +00:00
Yeachan-Heo	5b046836b9	Enable local image prompts without breaking text-only CLI flows The Rust CLI now recognizes explicit local image references in prompt text, encodes supported image files as base64, and serializes mixed text/image content blocks for the API. The request conversion path was kept narrow so existing runtime/session structures remain stable while prompt mode and user text conversion gain multimodal support. Constraint: Must support PNG, JPG/JPEG, GIF, and WebP without adding broad runtime abstractions Constraint: Existing text-only prompt behavior and API tool flows must keep working unchanged Rejected: Add only explicit --image CLI flags \| does not satisfy auto-detect image refs in prompt text Rejected: Persist native image blocks in runtime session model \| broader refactor than needed for prompt support Confidence: high Scope-risk: moderate Reversibility: clean Directive: Keep image parsing scoped to outbound user prompt adaptation unless session persistence truly needs multimodal history Tested: cargo fmt --all; cargo clippy --workspace --all-targets -- -D warnings; cargo test --workspace Not-tested: Live remote multimodal request against Anthropic API	2026-04-01 00:59:16 +00:00
Yeachan-Heo	549deb9a89	Preserve local project context across compaction and todo updates This change makes compaction summaries durable under .claude/memory, feeds those saved memory files back into prompt context, updates /memory to report both instruction and project-memory files, and moves TodoWrite persistence to a human-readable .claude/todos.md file. Constraint: Reuse existing compaction, prompt loading, and slash-command plumbing rather than add a new subsystem Constraint: Keep persisted project state under Claude-local .claude/ paths Rejected: Introduce a dedicated memory service module \| larger diff with no clear user benefit for this task Confidence: high Scope-risk: moderate Reversibility: clean Directive: Project memory files are loaded as prompt context, so future format changes must preserve concise readable content Tested: cargo fmt --all --manifest-path rust/Cargo.toml Tested: cargo clippy --manifest-path rust/Cargo.toml --all-targets --all-features -- -D warnings Tested: cargo test --manifest-path rust/Cargo.toml --all Not-tested: Long-term retention/cleanup policy for .claude/memory growth	2026-04-01 00:58:36 +00:00
Yeachan-Heo	146260083c	Persist CLI conversation history across sessions The Rust CLI now stores managed sessions under ~/.claude/sessions, records additive session metadata in the canonical JSON transcript, and exposes a /sessions listing alias alongside ID-or-path resume. Inactive oversized sessions are compacted automatically so old transcripts remain resumable without growing unchecked. Constraint: Session JSON must stay backward-compatible with legacy files that lack metadata Constraint: Managed sessions must use a single canonical JSON file per session without new dependencies Rejected: Sidecar metadata/index files \| duplicated state and diverged from the requested single-file persistence model Confidence: high Scope-risk: moderate Reversibility: clean Directive: Keep CLI policy in the CLI; only add transcript-adjacent metadata to runtime::Session unless another consumer truly needs more Tested: cargo fmt; cargo clippy --workspace --all-targets -- -D warnings; cargo test --workspace Not-tested: Manual interactive REPL smoke test against the live Anthropic API	2026-04-01 00:58:14 +00:00
Yeachan-Heo	3ba60be514	Expose session cost and budget state in the Rust CLI The CLI already tracked token usage, but it did not translate that usage into model-aware cost reporting or offer a spend guardrail. This change adds a max-cost flag, integrates estimated USD totals into /status and /cost, emits near-budget warnings, and blocks new turns once the configured budget has been exhausted. The workspace verification request also surfaced stale runtime test fixtures that still referenced removed permission enum variants, so those test-only call sites were updated to current permission modes to keep full clippy and workspace test coverage green. Constraint: Reuse existing runtime usage/pricing helpers instead of adding a new billing layer Constraint: Keep the feature centered in existing CLI/status surfaces with no new dependencies Rejected: Move budget enforcement into runtime usage/session abstractions \| broader refactor than needed for this CLI-scoped feature Confidence: high Scope-risk: moderate Reversibility: clean Directive: If resumed sessions later need historically accurate per-turn pricing across model switches, persist model metadata before changing the cost math Tested: cargo fmt --all --check; cargo clippy --workspace --all-targets -- -D warnings; cargo test --workspace Not-tested: Live network-backed prompt/REPL budget behavior against real Anthropic responses	2026-04-01 00:57:54 +00:00
Yeachan-Heo	cd01d0e387	Honor Claude config defaults across runtime sessions The runtime now discovers both legacy and current Claude config files at user and project scope, merges them in precedence order, and carries the resolved model, permission mode, instruction files, and MCP server configuration into session startup. This keeps CLI defaults aligned with project policy and exposes configured MCP tools without requiring manual flags. Constraint: Must support both legacy .claude.json and current .claude/settings.json layouts Constraint: Session startup must preserve CLI flag precedence over config defaults Rejected: Read only project settings files \| would ignore user-scoped defaults and MCP servers Rejected: Delay MCP tool discovery until first tool call \| model would not see configured MCP tools during planning Confidence: high Scope-risk: moderate Reversibility: clean Directive: Keep config precedence synchronized between prompt loading, session startup, and status reporting Tested: cargo fmt --all --check; cargo clippy --workspace --all-targets --all-features -- -D warnings; cargo test --workspace --all-features Not-tested: Live remote MCP servers and interactive REPL session startup against external services	2026-04-01 00:36:32 +00:00
				`@@ -0,0 +1 @@`
				`{"messages":[{"blocks":[{"text":"What is 2+2? Reply with just the number.","type":"text"}],"role":"user"},{"blocks":[{"text":"4","type":"text"}],"role":"assistant","usage":{"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"input_tokens":19,"output_tokens":5}}],"version":1}`
				`@@ -0,0 +1 @@`
				`{"messages":[{"blocks":[{"text":"Say hello in exactly 3 words","type":"text"}],"role":"user"},{"blocks":[{"text":"Hello there, friend!","type":"text"}],"role":"assistant","usage":{"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"input_tokens":14,"output_tokens":8}}],"version":1}`
				`@@ -0,0 +1 @@`
				`{"messages":[{"blocks":[{"text":"Say hi in one sentence","type":"text"}],"role":"user"},{"blocks":[{"text":"Hi! I'm Claude, ready to help you with any software engineering tasks or questions you have.","type":"text"}],"role":"assistant","usage":{"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"input_tokens":11,"output_tokens":23}}],"version":1}`