feat: jsonl-session progress

wip: jsonl-session progress
2026-04-03 19:14:48 +08:00 · 2026-04-01 06:15:14 +00:00 · 2026-04-01 04:30:27 +00:00
45 changed files with 2334 additions and 10165 deletions
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -111,9 +111,7 @@ dependencies = [
 name = "commands"
 version = "0.1.0"
 dependencies = [
- "plugins",
 "runtime",
- "serde_json",
 ]

 [[package]]
@@ -827,14 +825,6 @@ dependencies = [
 "time",
 ]

-[[package]]
-name = "plugins"
-version = "0.1.0"
-dependencies = [
- "serde",
- "serde_json",
-]
-
 [[package]]
 name = "potential_utf"
 version = "0.1.4"
@@ -1102,7 +1092,6 @@ name = "runtime"
 version = "0.1.0"
 dependencies = [
 "glob",
- "plugins",
 "regex",
 "serde",
 "serde_json",
@@ -1192,7 +1181,6 @@ dependencies = [
 "commands",
 "compat-harness",
 "crossterm",
- "plugins",
 "pulldown-cmark",
 "runtime",
 "rustyline",
@@ -1558,7 +1546,6 @@ name = "tools"
 version = "0.1.0"
 dependencies = [
 "api",
- "plugins",
 "reqwest",
 "runtime",
 "serde",
--- a/rust/Cargo.toml
+++ b/rust/Cargo.toml
@@ -8,9 +8,6 @@ edition = "2021"
 license = "MIT"
 publish = false

-[workspace.dependencies]
-serde_json = "1"
-
 [workspace.lints.rust]
 unsafe_code = "forbid"

--- a/rust/README.md
+++ b/rust/README.md
@@ -1,6 +1,6 @@
 # 🦞 Claw Code — Rust Implementation

-A high-performance Rust rewrite of the Claw Code CLI agent harness. Built for speed, safety, and native tool execution.
+A high-performance Rust rewrite of the Claude Code CLI agent harness. Built for speed, safety, and native tool execution.

 ## Quick Start

--- a/rust/crates/api/Cargo.toml
+++ b/rust/crates/api/Cargo.toml
@@ -9,7 +9,7 @@ publish.workspace = true
 reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls"] }
 runtime = { path = "../runtime" }
 serde = { version = "1", features = ["derive"] }
-serde_json.workspace = true
+serde_json = "1"
 tokio = { version = "1", features = ["io-util", "macros", "net", "rt-multi-thread", "time"] }

 [lints]
--- a/rust/crates/api/src/client.rs
+++ b/rust/crates/api/src/client.rs
--- a/rust/crates/api/src/error.rs
+++ b/rust/crates/api/src/error.rs
@@ -4,10 +4,7 @@ use std::time::Duration;

 #[derive(Debug)]
 pub enum ApiError {
-    MissingCredentials {
-        provider: &'static str,
-        env_vars: &'static [&'static str],
-    },
+    MissingApiKey,
    ExpiredOAuthToken,
    Auth(String),
    InvalidApiKeyEnv(VarError),
@@ -33,21 +30,13 @@ pub enum ApiError {
 }

 impl ApiError {
-    #[must_use]
-    pub const fn missing_credentials(
-        provider: &'static str,
-        env_vars: &'static [&'static str],
-    ) -> Self {
-        Self::MissingCredentials { provider, env_vars }
-    }
-
    #[must_use]
    pub fn is_retryable(&self) -> bool {
        match self {
            Self::Http(error) => error.is_connect() || error.is_timeout() || error.is_request(),
            Self::Api { retryable, .. } => *retryable,
            Self::RetriesExhausted { last_error, .. } => last_error.is_retryable(),
-            Self::MissingCredentials { .. }
+            Self::MissingApiKey
            | Self::ExpiredOAuthToken
            | Self::Auth(_)
            | Self::InvalidApiKeyEnv(_)
@@ -62,11 +51,12 @@ impl ApiError {
 impl Display for ApiError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
-            Self::MissingCredentials { provider, env_vars } => write!(
-                f,
-                "missing {provider} credentials; export {} before calling the {provider} API",
-                env_vars.join(" or ")
-            ),
+            Self::MissingApiKey => {
+                write!(
+                    f,
+                    "ANTHROPIC_AUTH_TOKEN or ANTHROPIC_API_KEY is not set; export one before calling the Anthropic API"
+                )
+            }
            Self::ExpiredOAuthToken => {
                write!(
                    f,
@@ -75,7 +65,10 @@ impl Display for ApiError {
            }
            Self::Auth(message) => write!(f, "auth error: {message}"),
            Self::InvalidApiKeyEnv(error) => {
-                write!(f, "failed to read credential environment variable: {error}")
+                write!(
+                    f,
+                    "failed to read ANTHROPIC_AUTH_TOKEN / ANTHROPIC_API_KEY: {error}"
+                )
            }
            Self::Http(error) => write!(f, "http error: {error}"),
            Self::Io(error) => write!(f, "io error: {error}"),
@@ -88,14 +81,20 @@ impl Display for ApiError {
                ..
            } => match (error_type, message) {
                (Some(error_type), Some(message)) => {
-                    write!(f, "api returned {status} ({error_type}): {message}")
+                    write!(
+                        f,
+                        "anthropic api returned {status} ({error_type}): {message}"
+                    )
                }
-                _ => write!(f, "api returned {status}: {body}"),
+                _ => write!(f, "anthropic api returned {status}: {body}"),
            },
            Self::RetriesExhausted {
                attempts,
                last_error,
-            } => write!(f, "api failed after {attempts} attempts: {last_error}"),
+            } => write!(
+                f,
+                "anthropic api failed after {attempts} attempts: {last_error}"
+            ),
            Self::InvalidSseFrame(message) => write!(f, "invalid sse frame: {message}"),
            Self::BackoffOverflow {
                attempt,
--- a/rust/crates/api/src/lib.rs
+++ b/rust/crates/api/src/lib.rs
@@ -1,19 +1,13 @@
 mod client;
 mod error;
-mod providers;
 mod sse;
 mod types;

 pub use client::{
-    oauth_token_is_expired, read_base_url, read_xai_base_url, resolve_saved_oauth_token,
-    resolve_startup_auth_source, MessageStream, OAuthTokenSet, ProviderClient,
+    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 providers::anthropic::{AnthropicClient, AnthropicClient as ApiClient, AuthSource};
-pub use providers::openai_compat::{OpenAiCompatClient, OpenAiCompatConfig};
-pub use providers::{
-    detect_provider_kind, max_tokens_for_model, resolve_model_alias, ProviderKind,
-};
 pub use sse::{parse_frame, SseParser};
 pub use types::{
    ContentBlockDelta, ContentBlockDeltaEvent, ContentBlockStartEvent, ContentBlockStopEvent,
--- a/rust/crates/api/src/providers/anthropic.rs
+++ b/rust/crates/api/src/providers/anthropic.rs
--- a/rust/crates/api/src/providers/mod.rs
+++ b/rust/crates/api/src/providers/mod.rs
@@ -1,216 +0,0 @@
-use std::future::Future;
-use std::pin::Pin;
-
-use crate::error::ApiError;
-use crate::types::{MessageRequest, MessageResponse};
-
-pub mod anthropic;
-pub mod openai_compat;
-
-pub type ProviderFuture<'a, T> = Pin<Box<dyn Future<Output = Result<T, ApiError>> + Send + 'a>>;
-
-pub trait Provider {
-    type Stream;
-
-    fn send_message<'a>(
-        &'a self,
-        request: &'a MessageRequest,
-    ) -> ProviderFuture<'a, MessageResponse>;
-
-    fn stream_message<'a>(
-        &'a self,
-        request: &'a MessageRequest,
-    ) -> ProviderFuture<'a, Self::Stream>;
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum ProviderKind {
-    Anthropic,
-    Xai,
-    OpenAi,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct ProviderMetadata {
-    pub provider: ProviderKind,
-    pub auth_env: &'static str,
-    pub base_url_env: &'static str,
-    pub default_base_url: &'static str,
-}
-
-const MODEL_REGISTRY: &[(&str, ProviderMetadata)] = &[
-    (
-        "opus",
-        ProviderMetadata {
-            provider: ProviderKind::Anthropic,
-            auth_env: "ANTHROPIC_API_KEY",
-            base_url_env: "ANTHROPIC_BASE_URL",
-            default_base_url: anthropic::DEFAULT_BASE_URL,
-        },
-    ),
-    (
-        "sonnet",
-        ProviderMetadata {
-            provider: ProviderKind::Anthropic,
-            auth_env: "ANTHROPIC_API_KEY",
-            base_url_env: "ANTHROPIC_BASE_URL",
-            default_base_url: anthropic::DEFAULT_BASE_URL,
-        },
-    ),
-    (
-        "haiku",
-        ProviderMetadata {
-            provider: ProviderKind::Anthropic,
-            auth_env: "ANTHROPIC_API_KEY",
-            base_url_env: "ANTHROPIC_BASE_URL",
-            default_base_url: anthropic::DEFAULT_BASE_URL,
-        },
-    ),
-    (
-        "grok",
-        ProviderMetadata {
-            provider: ProviderKind::Xai,
-            auth_env: "XAI_API_KEY",
-            base_url_env: "XAI_BASE_URL",
-            default_base_url: openai_compat::DEFAULT_XAI_BASE_URL,
-        },
-    ),
-    (
-        "grok-3",
-        ProviderMetadata {
-            provider: ProviderKind::Xai,
-            auth_env: "XAI_API_KEY",
-            base_url_env: "XAI_BASE_URL",
-            default_base_url: openai_compat::DEFAULT_XAI_BASE_URL,
-        },
-    ),
-    (
-        "grok-mini",
-        ProviderMetadata {
-            provider: ProviderKind::Xai,
-            auth_env: "XAI_API_KEY",
-            base_url_env: "XAI_BASE_URL",
-            default_base_url: openai_compat::DEFAULT_XAI_BASE_URL,
-        },
-    ),
-    (
-        "grok-3-mini",
-        ProviderMetadata {
-            provider: ProviderKind::Xai,
-            auth_env: "XAI_API_KEY",
-            base_url_env: "XAI_BASE_URL",
-            default_base_url: openai_compat::DEFAULT_XAI_BASE_URL,
-        },
-    ),
-    (
-        "grok-2",
-        ProviderMetadata {
-            provider: ProviderKind::Xai,
-            auth_env: "XAI_API_KEY",
-            base_url_env: "XAI_BASE_URL",
-            default_base_url: openai_compat::DEFAULT_XAI_BASE_URL,
-        },
-    ),
-];
-
-#[must_use]
-pub fn resolve_model_alias(model: &str) -> String {
-    let trimmed = model.trim();
-    let lower = trimmed.to_ascii_lowercase();
-    MODEL_REGISTRY
-        .iter()
-        .find_map(|(alias, metadata)| {
-            (*alias == lower).then_some(match metadata.provider {
-                ProviderKind::Anthropic => match *alias {
-                    "opus" => "claude-opus-4-6",
-                    "sonnet" => "claude-sonnet-4-6",
-                    "haiku" => "claude-haiku-4-5-20251213",
-                    _ => trimmed,
-                },
-                ProviderKind::Xai => match *alias {
-                    "grok" | "grok-3" => "grok-3",
-                    "grok-mini" | "grok-3-mini" => "grok-3-mini",
-                    "grok-2" => "grok-2",
-                    _ => trimmed,
-                },
-                ProviderKind::OpenAi => trimmed,
-            })
-        })
-        .map_or_else(|| trimmed.to_string(), ToOwned::to_owned)
-}
-
-#[must_use]
-pub fn metadata_for_model(model: &str) -> Option<ProviderMetadata> {
-    let canonical = resolve_model_alias(model);
-    if canonical.starts_with("claude") {
-        return Some(ProviderMetadata {
-            provider: ProviderKind::Anthropic,
-            auth_env: "ANTHROPIC_API_KEY",
-            base_url_env: "ANTHROPIC_BASE_URL",
-            default_base_url: anthropic::DEFAULT_BASE_URL,
-        });
-    }
-    if canonical.starts_with("grok") {
-        return Some(ProviderMetadata {
-            provider: ProviderKind::Xai,
-            auth_env: "XAI_API_KEY",
-            base_url_env: "XAI_BASE_URL",
-            default_base_url: openai_compat::DEFAULT_XAI_BASE_URL,
-        });
-    }
-    None
-}
-
-#[must_use]
-pub fn detect_provider_kind(model: &str) -> ProviderKind {
-    if let Some(metadata) = metadata_for_model(model) {
-        return metadata.provider;
-    }
-    if anthropic::has_auth_from_env_or_saved().unwrap_or(false) {
-        return ProviderKind::Anthropic;
-    }
-    if openai_compat::has_api_key("OPENAI_API_KEY") {
-        return ProviderKind::OpenAi;
-    }
-    if openai_compat::has_api_key("XAI_API_KEY") {
-        return ProviderKind::Xai;
-    }
-    ProviderKind::Anthropic
-}
-
-#[must_use]
-pub fn max_tokens_for_model(model: &str) -> u32 {
-    let canonical = resolve_model_alias(model);
-    if canonical.contains("opus") {
-        32_000
-    } else {
-        64_000
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{detect_provider_kind, max_tokens_for_model, resolve_model_alias, ProviderKind};
-
-    #[test]
-    fn resolves_grok_aliases() {
-        assert_eq!(resolve_model_alias("grok"), "grok-3");
-        assert_eq!(resolve_model_alias("grok-mini"), "grok-3-mini");
-        assert_eq!(resolve_model_alias("grok-2"), "grok-2");
-    }
-
-    #[test]
-    fn detects_provider_from_model_name_first() {
-        assert_eq!(detect_provider_kind("grok"), ProviderKind::Xai);
-        assert_eq!(
-            detect_provider_kind("claude-sonnet-4-6"),
-            ProviderKind::Anthropic
-        );
-    }
-
-    #[test]
-    fn keeps_existing_max_token_heuristic() {
-        assert_eq!(max_tokens_for_model("opus"), 32_000);
-        assert_eq!(max_tokens_for_model("grok-3"), 64_000);
-    }
-}
--- a/rust/crates/api/src/providers/openai_compat.rs
+++ b/rust/crates/api/src/providers/openai_compat.rs
--- a/rust/crates/api/src/sse.rs
+++ b/rust/crates/api/src/sse.rs
@@ -216,64 +216,4 @@ mod tests {
            ))
        );
    }
-
-    #[test]
-    fn parses_thinking_content_block_start() {
-        let frame = concat!(
-            "event: content_block_start\n",
-            "data: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"thinking\",\"thinking\":\"\",\"signature\":null}}\n\n"
-        );
-
-        let event = parse_frame(frame).expect("frame should parse");
-        assert_eq!(
-            event,
-            Some(StreamEvent::ContentBlockStart(
-                crate::types::ContentBlockStartEvent {
-                    index: 0,
-                    content_block: OutputContentBlock::Thinking {
-                        thinking: String::new(),
-                        signature: None,
-                    },
-                },
-            ))
-        );
-    }
-
-    #[test]
-    fn parses_thinking_related_deltas() {
-        let thinking = concat!(
-            "event: content_block_delta\n",
-            "data: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"thinking_delta\",\"thinking\":\"step 1\"}}\n\n"
-        );
-        let signature = concat!(
-            "event: content_block_delta\n",
-            "data: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"signature_delta\",\"signature\":\"sig_123\"}}\n\n"
-        );
-
-        let thinking_event = parse_frame(thinking).expect("thinking delta should parse");
-        let signature_event = parse_frame(signature).expect("signature delta should parse");
-
-        assert_eq!(
-            thinking_event,
-            Some(StreamEvent::ContentBlockDelta(
-                crate::types::ContentBlockDeltaEvent {
-                    index: 0,
-                    delta: ContentBlockDelta::ThinkingDelta {
-                        thinking: "step 1".to_string(),
-                    },
-                }
-            ))
-        );
-        assert_eq!(
-            signature_event,
-            Some(StreamEvent::ContentBlockDelta(
-                crate::types::ContentBlockDeltaEvent {
-                    index: 0,
-                    delta: ContentBlockDelta::SignatureDelta {
-                        signature: "sig_123".to_string(),
-                    },
-                }
-            ))
-        );
-    }
 }
--- a/rust/crates/api/src/types.rs
+++ b/rust/crates/api/src/types.rs
@@ -135,15 +135,6 @@ pub enum OutputContentBlock {
        name: String,
        input: Value,
    },
-    Thinking {
-        #[serde(default)]
-        thinking: String,
-        #[serde(default, skip_serializing_if = "Option::is_none")]
-        signature: Option<String>,
-    },
-    RedactedThinking {
-        data: Value,
-    },
 }

 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
@@ -199,8 +190,6 @@ pub struct ContentBlockDeltaEvent {
 pub enum ContentBlockDelta {
    TextDelta { text: String },
    InputJsonDelta { partial_json: String },
-    ThinkingDelta { thinking: String },
-    SignatureDelta { signature: String },
 }

 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
--- a/rust/crates/api/tests/client_integration.rs
+++ b/rust/crates/api/tests/client_integration.rs
@@ -3,9 +3,9 @@ use std::sync::Arc;
 use std::time::Duration;

 use api::{
-    ApiClient, ApiError, AuthSource, ContentBlockDelta, ContentBlockDeltaEvent,
-    ContentBlockStartEvent, InputContentBlock, InputMessage, MessageDeltaEvent, MessageRequest,
-    OutputContentBlock, ProviderClient, StreamEvent, ToolChoice, ToolDefinition,
+    AnthropicClient, ApiError, ContentBlockDelta, ContentBlockDeltaEvent, ContentBlockStartEvent,
+    InputContentBlock, InputMessage, MessageDeltaEvent, MessageRequest, OutputContentBlock,
+    StreamEvent, ToolChoice, ToolDefinition,
 };
 use serde_json::json;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
@@ -34,7 +34,7 @@ async fn send_message_posts_json_and_parses_response() {
    )
    .await;

-    let client = ApiClient::new("test-key")
+    let client = AnthropicClient::new("test-key")
        .with_auth_token(Some("proxy-token".to_string()))
        .with_base_url(server.base_url());
    let response = client
@@ -104,7 +104,7 @@ async fn stream_message_parses_sse_events_with_tool_use() {
    )
    .await;

-    let client = ApiClient::new("test-key")
+    let client = AnthropicClient::new("test-key")
        .with_auth_token(Some("proxy-token".to_string()))
        .with_base_url(server.base_url());
    let mut stream = client
@@ -182,7 +182,7 @@ async fn retries_retryable_failures_before_succeeding() {
    )
    .await;

-    let client = ApiClient::new("test-key")
+    let client = AnthropicClient::new("test-key")
        .with_base_url(server.base_url())
        .with_retry_policy(2, Duration::from_millis(1), Duration::from_millis(2));

@@ -195,47 +195,6 @@ async fn retries_retryable_failures_before_succeeding() {
    assert_eq!(state.lock().await.len(), 2);
 }

-#[tokio::test]
-async fn provider_client_dispatches_anthropic_requests() {
-    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
-    let server = spawn_server(
-        state.clone(),
-        vec![http_response(
-            "200 OK",
-            "application/json",
-            "{\"id\":\"msg_provider\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"Dispatched\"}],\"model\":\"claude-3-7-sonnet-latest\",\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":3,\"output_tokens\":2}}",
-        )],
-    )
-    .await;
-
-    let client = ProviderClient::from_model_with_anthropic_auth(
-        "claude-sonnet-4-6",
-        Some(AuthSource::ApiKey("test-key".to_string())),
-    )
-    .expect("anthropic provider client should be constructed");
-    let client = match client {
-        ProviderClient::Anthropic(client) => {
-            ProviderClient::Anthropic(client.with_base_url(server.base_url()))
-        }
-        other => panic!("expected anthropic provider, got {other:?}"),
-    };
-
-    let response = client
-        .send_message(&sample_request(false))
-        .await
-        .expect("provider-dispatched request should succeed");
-
-    assert_eq!(response.total_tokens(), 5);
-
-    let captured = state.lock().await;
-    let request = captured.first().expect("server should capture request");
-    assert_eq!(request.path, "/v1/messages");
-    assert_eq!(
-        request.headers.get("x-api-key").map(String::as_str),
-        Some("test-key")
-    );
-}
-
 #[tokio::test]
 async fn surfaces_retry_exhaustion_for_persistent_retryable_errors() {
    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
@@ -256,7 +215,7 @@ async fn surfaces_retry_exhaustion_for_persistent_retryable_errors() {
    )
    .await;

-    let client = ApiClient::new("test-key")
+    let client = AnthropicClient::new("test-key")
        .with_base_url(server.base_url())
        .with_retry_policy(1, Duration::from_millis(1), Duration::from_millis(2));

@@ -287,7 +246,7 @@ async fn surfaces_retry_exhaustion_for_persistent_retryable_errors() {
 #[tokio::test]
 #[ignore = "requires ANTHROPIC_API_KEY and network access"]
 async fn live_stream_smoke_test() {
-    let client = ApiClient::from_env().expect("ANTHROPIC_API_KEY must be set");
+    let client = AnthropicClient::from_env().expect("ANTHROPIC_API_KEY must be set");
    let mut stream = client
        .stream_message(&MessageRequest {
            model: std::env::var("ANTHROPIC_MODEL")
--- a/rust/crates/api/tests/openai_compat_integration.rs
+++ b/rust/crates/api/tests/openai_compat_integration.rs
@@ -1,415 +0,0 @@
-use std::collections::HashMap;
-use std::ffi::OsString;
-use std::sync::Arc;
-use std::sync::{Mutex as StdMutex, OnceLock};
-
-use api::{
-    ContentBlockDelta, ContentBlockDeltaEvent, ContentBlockStartEvent, ContentBlockStopEvent,
-    InputContentBlock, InputMessage, MessageRequest, OpenAiCompatClient, OpenAiCompatConfig,
-    OutputContentBlock, ProviderClient, StreamEvent, ToolChoice, ToolDefinition,
-};
-use serde_json::json;
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
-use tokio::net::TcpListener;
-use tokio::sync::Mutex;
-
-#[tokio::test]
-async fn send_message_uses_openai_compatible_endpoint_and_auth() {
-    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
-    let body = concat!(
-        "{",
-        "\"id\":\"chatcmpl_test\",",
-        "\"model\":\"grok-3\",",
-        "\"choices\":[{",
-        "\"message\":{\"role\":\"assistant\",\"content\":\"Hello from Grok\",\"tool_calls\":[]},",
-        "\"finish_reason\":\"stop\"",
-        "}],",
-        "\"usage\":{\"prompt_tokens\":11,\"completion_tokens\":5}",
-        "}"
-    );
-    let server = spawn_server(
-        state.clone(),
-        vec![http_response("200 OK", "application/json", body)],
-    )
-    .await;
-
-    let client = OpenAiCompatClient::new("xai-test-key", OpenAiCompatConfig::xai())
-        .with_base_url(server.base_url());
-    let response = client
-        .send_message(&sample_request(false))
-        .await
-        .expect("request should succeed");
-
-    assert_eq!(response.model, "grok-3");
-    assert_eq!(response.total_tokens(), 16);
-    assert_eq!(
-        response.content,
-        vec![OutputContentBlock::Text {
-            text: "Hello from Grok".to_string(),
-        }]
-    );
-
-    let captured = state.lock().await;
-    let request = captured.first().expect("server should capture request");
-    assert_eq!(request.path, "/chat/completions");
-    assert_eq!(
-        request.headers.get("authorization").map(String::as_str),
-        Some("Bearer xai-test-key")
-    );
-    let body: serde_json::Value = serde_json::from_str(&request.body).expect("json body");
-    assert_eq!(body["model"], json!("grok-3"));
-    assert_eq!(body["messages"][0]["role"], json!("system"));
-    assert_eq!(body["tools"][0]["type"], json!("function"));
-}
-
-#[tokio::test]
-async fn send_message_accepts_full_chat_completions_endpoint_override() {
-    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
-    let body = concat!(
-        "{",
-        "\"id\":\"chatcmpl_full_endpoint\",",
-        "\"model\":\"grok-3\",",
-        "\"choices\":[{",
-        "\"message\":{\"role\":\"assistant\",\"content\":\"Endpoint override works\",\"tool_calls\":[]},",
-        "\"finish_reason\":\"stop\"",
-        "}],",
-        "\"usage\":{\"prompt_tokens\":7,\"completion_tokens\":3}",
-        "}"
-    );
-    let server = spawn_server(
-        state.clone(),
-        vec![http_response("200 OK", "application/json", body)],
-    )
-    .await;
-
-    let endpoint_url = format!("{}/chat/completions", server.base_url());
-    let client = OpenAiCompatClient::new("xai-test-key", OpenAiCompatConfig::xai())
-        .with_base_url(endpoint_url);
-    let response = client
-        .send_message(&sample_request(false))
-        .await
-        .expect("request should succeed");
-
-    assert_eq!(response.total_tokens(), 10);
-
-    let captured = state.lock().await;
-    let request = captured.first().expect("server should capture request");
-    assert_eq!(request.path, "/chat/completions");
-}
-
-#[tokio::test]
-async fn stream_message_normalizes_text_and_multiple_tool_calls() {
-    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
-    let sse = concat!(
-        "data: {\"id\":\"chatcmpl_stream\",\"model\":\"grok-3\",\"choices\":[{\"delta\":{\"content\":\"Hello\"}}]}\n\n",
-        "data: {\"id\":\"chatcmpl_stream\",\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"call_1\",\"function\":{\"name\":\"weather\",\"arguments\":\"{\\\"city\\\":\\\"Paris\\\"}\"}},{\"index\":1,\"id\":\"call_2\",\"function\":{\"name\":\"clock\",\"arguments\":\"{\\\"zone\\\":\\\"UTC\\\"}\"}}]}}]}\n\n",
-        "data: {\"id\":\"chatcmpl_stream\",\"choices\":[{\"delta\":{},\"finish_reason\":\"tool_calls\"}]}\n\n",
-        "data: [DONE]\n\n"
-    );
-    let server = spawn_server(
-        state.clone(),
-        vec![http_response_with_headers(
-            "200 OK",
-            "text/event-stream",
-            sse,
-            &[("x-request-id", "req_grok_stream")],
-        )],
-    )
-    .await;
-
-    let client = OpenAiCompatClient::new("xai-test-key", OpenAiCompatConfig::xai())
-        .with_base_url(server.base_url());
-    let mut stream = client
-        .stream_message(&sample_request(false))
-        .await
-        .expect("stream should start");
-
-    assert_eq!(stream.request_id(), Some("req_grok_stream"));
-
-    let mut events = Vec::new();
-    while let Some(event) = stream.next_event().await.expect("event should parse") {
-        events.push(event);
-    }
-
-    assert!(matches!(events[0], StreamEvent::MessageStart(_)));
-    assert!(matches!(
-        events[1],
-        StreamEvent::ContentBlockStart(ContentBlockStartEvent {
-            content_block: OutputContentBlock::Text { .. },
-            ..
-        })
-    ));
-    assert!(matches!(
-        events[2],
-        StreamEvent::ContentBlockDelta(ContentBlockDeltaEvent {
-            delta: ContentBlockDelta::TextDelta { .. },
-            ..
-        })
-    ));
-    assert!(matches!(
-        events[3],
-        StreamEvent::ContentBlockStart(ContentBlockStartEvent {
-            index: 1,
-            content_block: OutputContentBlock::ToolUse { .. },
-        })
-    ));
-    assert!(matches!(
-        events[4],
-        StreamEvent::ContentBlockDelta(ContentBlockDeltaEvent {
-            index: 1,
-            delta: ContentBlockDelta::InputJsonDelta { .. },
-        })
-    ));
-    assert!(matches!(
-        events[5],
-        StreamEvent::ContentBlockStart(ContentBlockStartEvent {
-            index: 2,
-            content_block: OutputContentBlock::ToolUse { .. },
-        })
-    ));
-    assert!(matches!(
-        events[6],
-        StreamEvent::ContentBlockDelta(ContentBlockDeltaEvent {
-            index: 2,
-            delta: ContentBlockDelta::InputJsonDelta { .. },
-        })
-    ));
-    assert!(matches!(
-        events[7],
-        StreamEvent::ContentBlockStop(ContentBlockStopEvent { index: 1 })
-    ));
-    assert!(matches!(
-        events[8],
-        StreamEvent::ContentBlockStop(ContentBlockStopEvent { index: 2 })
-    ));
-    assert!(matches!(
-        events[9],
-        StreamEvent::ContentBlockStop(ContentBlockStopEvent { index: 0 })
-    ));
-    assert!(matches!(events[10], StreamEvent::MessageDelta(_)));
-    assert!(matches!(events[11], StreamEvent::MessageStop(_)));
-
-    let captured = state.lock().await;
-    let request = captured.first().expect("captured request");
-    assert_eq!(request.path, "/chat/completions");
-    assert!(request.body.contains("\"stream\":true"));
-}
-
-#[tokio::test]
-async fn provider_client_dispatches_xai_requests_from_env() {
-    let _lock = env_lock();
-    let _api_key = ScopedEnvVar::set("XAI_API_KEY", "xai-test-key");
-
-    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
-    let server = spawn_server(
-        state.clone(),
-        vec![http_response(
-            "200 OK",
-            "application/json",
-            "{\"id\":\"chatcmpl_provider\",\"model\":\"grok-3\",\"choices\":[{\"message\":{\"role\":\"assistant\",\"content\":\"Through provider client\",\"tool_calls\":[]},\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":9,\"completion_tokens\":4}}",
-        )],
-    )
-    .await;
-    let _base_url = ScopedEnvVar::set("XAI_BASE_URL", server.base_url());
-
-    let client =
-        ProviderClient::from_model("grok").expect("xAI provider client should be constructed");
-    assert!(matches!(client, ProviderClient::Xai(_)));
-
-    let response = client
-        .send_message(&sample_request(false))
-        .await
-        .expect("provider-dispatched request should succeed");
-
-    assert_eq!(response.total_tokens(), 13);
-
-    let captured = state.lock().await;
-    let request = captured.first().expect("captured request");
-    assert_eq!(request.path, "/chat/completions");
-    assert_eq!(
-        request.headers.get("authorization").map(String::as_str),
-        Some("Bearer xai-test-key")
-    );
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-struct CapturedRequest {
-    path: String,
-    headers: HashMap<String, String>,
-    body: String,
-}
-
-struct TestServer {
-    base_url: String,
-    join_handle: tokio::task::JoinHandle<()>,
-}
-
-impl TestServer {
-    fn base_url(&self) -> String {
-        self.base_url.clone()
-    }
-}
-
-impl Drop for TestServer {
-    fn drop(&mut self) {
-        self.join_handle.abort();
-    }
-}
-
-async fn spawn_server(
-    state: Arc<Mutex<Vec<CapturedRequest>>>,
-    responses: Vec<String>,
-) -> TestServer {
-    let listener = TcpListener::bind("127.0.0.1:0")
-        .await
-        .expect("listener should bind");
-    let address = listener.local_addr().expect("listener addr");
-    let join_handle = tokio::spawn(async move {
-        for response in responses {
-            let (mut socket, _) = listener.accept().await.expect("accept");
-            let mut buffer = Vec::new();
-            let mut header_end = None;
-            loop {
-                let mut chunk = [0_u8; 1024];
-                let read = socket.read(&mut chunk).await.expect("read request");
-                if read == 0 {
-                    break;
-                }
-                buffer.extend_from_slice(&chunk[..read]);
-                if let Some(position) = find_header_end(&buffer) {
-                    header_end = Some(position);
-                    break;
-                }
-            }
-
-            let header_end = header_end.expect("headers should exist");
-            let (header_bytes, remaining) = buffer.split_at(header_end);
-            let header_text = String::from_utf8(header_bytes.to_vec()).expect("utf8 headers");
-            let mut lines = header_text.split("\r\n");
-            let request_line = lines.next().expect("request line");
-            let path = request_line
-                .split_whitespace()
-                .nth(1)
-                .expect("path")
-                .to_string();
-            let mut headers = HashMap::new();
-            let mut content_length = 0_usize;
-            for line in lines {
-                if line.is_empty() {
-                    continue;
-                }
-                let (name, value) = line.split_once(':').expect("header");
-                let value = value.trim().to_string();
-                if name.eq_ignore_ascii_case("content-length") {
-                    content_length = value.parse().expect("content length");
-                }
-                headers.insert(name.to_ascii_lowercase(), value);
-            }
-
-            let mut body = remaining[4..].to_vec();
-            while body.len() < content_length {
-                let mut chunk = vec![0_u8; content_length - body.len()];
-                let read = socket.read(&mut chunk).await.expect("read body");
-                if read == 0 {
-                    break;
-                }
-                body.extend_from_slice(&chunk[..read]);
-            }
-
-            state.lock().await.push(CapturedRequest {
-                path,
-                headers,
-                body: String::from_utf8(body).expect("utf8 body"),
-            });
-
-            socket
-                .write_all(response.as_bytes())
-                .await
-                .expect("write response");
-        }
-    });
-
-    TestServer {
-        base_url: format!("http://{address}"),
-        join_handle,
-    }
-}
-
-fn find_header_end(bytes: &[u8]) -> Option<usize> {
-    bytes.windows(4).position(|window| window == b"\r\n\r\n")
-}
-
-fn http_response(status: &str, content_type: &str, body: &str) -> String {
-    http_response_with_headers(status, content_type, body, &[])
-}
-
-fn http_response_with_headers(
-    status: &str,
-    content_type: &str,
-    body: &str,
-    headers: &[(&str, &str)],
-) -> String {
-    let mut extra_headers = String::new();
-    for (name, value) in headers {
-        use std::fmt::Write as _;
-        write!(&mut extra_headers, "{name}: {value}\r\n").expect("header write");
-    }
-    format!(
-        "HTTP/1.1 {status}\r\ncontent-type: {content_type}\r\n{extra_headers}content-length: {}\r\nconnection: close\r\n\r\n{body}",
-        body.len()
-    )
-}
-
-fn sample_request(stream: bool) -> MessageRequest {
-    MessageRequest {
-        model: "grok-3".to_string(),
-        max_tokens: 64,
-        messages: vec![InputMessage {
-            role: "user".to_string(),
-            content: vec![InputContentBlock::Text {
-                text: "Say hello".to_string(),
-            }],
-        }],
-        system: Some("Use tools when needed".to_string()),
-        tools: Some(vec![ToolDefinition {
-            name: "weather".to_string(),
-            description: Some("Fetches weather".to_string()),
-            input_schema: json!({
-                "type": "object",
-                "properties": {"city": {"type": "string"}},
-                "required": ["city"]
-            }),
-        }]),
-        tool_choice: Some(ToolChoice::Auto),
-        stream,
-    }
-}
-
-fn env_lock() -> std::sync::MutexGuard<'static, ()> {
-    static LOCK: OnceLock<StdMutex<()>> = OnceLock::new();
-    LOCK.get_or_init(|| StdMutex::new(()))
-        .lock()
-        .unwrap_or_else(|poisoned| poisoned.into_inner())
-}
-
-struct ScopedEnvVar {
-    key: &'static str,
-    previous: Option<OsString>,
-}
-
-impl ScopedEnvVar {
-    fn set(key: &'static str, value: impl AsRef<std::ffi::OsStr>) -> Self {
-        let previous = std::env::var_os(key);
-        std::env::set_var(key, value);
-        Self { key, previous }
-    }
-}
-
-impl Drop for ScopedEnvVar {
-    fn drop(&mut self) {
-        match &self.previous {
-            Some(value) => std::env::set_var(self.key, value),
-            None => std::env::remove_var(self.key),
-        }
-    }
-}
--- a/rust/crates/api/tests/provider_client_integration.rs
+++ b/rust/crates/api/tests/provider_client_integration.rs
@@ -1,86 +0,0 @@
-use std::ffi::OsString;
-use std::sync::{Mutex, OnceLock};
-
-use api::{read_xai_base_url, ApiError, AuthSource, ProviderClient, ProviderKind};
-
-#[test]
-fn provider_client_routes_grok_aliases_through_xai() {
-    let _lock = env_lock();
-    let _xai_api_key = EnvVarGuard::set("XAI_API_KEY", Some("xai-test-key"));
-
-    let client = ProviderClient::from_model("grok-mini").expect("grok alias should resolve");
-
-    assert_eq!(client.provider_kind(), ProviderKind::Xai);
-}
-
-#[test]
-fn provider_client_reports_missing_xai_credentials_for_grok_models() {
-    let _lock = env_lock();
-    let _xai_api_key = EnvVarGuard::set("XAI_API_KEY", None);
-
-    let error = ProviderClient::from_model("grok-3")
-        .expect_err("grok requests without XAI_API_KEY should fail fast");
-
-    match error {
-        ApiError::MissingCredentials { provider, env_vars } => {
-            assert_eq!(provider, "xAI");
-            assert_eq!(env_vars, &["XAI_API_KEY"]);
-        }
-        other => panic!("expected missing xAI credentials, got {other:?}"),
-    }
-}
-
-#[test]
-fn provider_client_uses_explicit_anthropic_auth_without_env_lookup() {
-    let _lock = env_lock();
-    let _anthropic_api_key = EnvVarGuard::set("ANTHROPIC_API_KEY", None);
-    let _anthropic_auth_token = EnvVarGuard::set("ANTHROPIC_AUTH_TOKEN", None);
-
-    let client = ProviderClient::from_model_with_anthropic_auth(
-        "claude-sonnet-4-6",
-        Some(AuthSource::ApiKey("anthropic-test-key".to_string())),
-    )
-    .expect("explicit anthropic auth should avoid env lookup");
-
-    assert_eq!(client.provider_kind(), ProviderKind::Anthropic);
-}
-
-#[test]
-fn read_xai_base_url_prefers_env_override() {
-    let _lock = env_lock();
-    let _xai_base_url = EnvVarGuard::set("XAI_BASE_URL", Some("https://example.xai.test/v1"));
-
-    assert_eq!(read_xai_base_url(), "https://example.xai.test/v1");
-}
-
-fn env_lock() -> std::sync::MutexGuard<'static, ()> {
-    static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
-    LOCK.get_or_init(|| Mutex::new(()))
-        .lock()
-        .unwrap_or_else(|poisoned| poisoned.into_inner())
-}
-
-struct EnvVarGuard {
-    key: &'static str,
-    original: Option<OsString>,
-}
-
-impl EnvVarGuard {
-    fn set(key: &'static str, value: Option<&str>) -> Self {
-        let original = std::env::var_os(key);
-        match value {
-            Some(value) => std::env::set_var(key, value),
-            None => std::env::remove_var(key),
-        }
-        Self { key, original }
-    }
-}
-
-impl Drop for EnvVarGuard {
-    fn drop(&mut self) {
-        match &self.original {
-            Some(value) => std::env::set_var(self.key, value),
-            None => std::env::remove_var(self.key),
-        }
-    }
-}
--- a/rust/crates/commands/Cargo.toml
+++ b/rust/crates/commands/Cargo.toml
@@ -9,6 +9,4 @@ publish.workspace = true
 workspace = true

 [dependencies]
-plugins = { path = "../plugins" }
 runtime = { path = "../runtime" }
-serde_json.workspace = true
--- a/rust/crates/commands/src/lib.rs
+++ b/rust/crates/commands/src/lib.rs
--- a/rust/crates/compat-harness/src/lib.rs
+++ b/rust/crates/compat-harness/src/lib.rs
@@ -70,12 +70,16 @@ fn upstream_repo_candidates(primary_repo_root: &Path) -> Vec<PathBuf> {
    }

    for ancestor in primary_repo_root.ancestors().take(4) {
-        candidates.push(ancestor.join("claw-code"));
+        candidates.push(ancestor.join("claude-code"));
        candidates.push(ancestor.join("clawd-code"));
    }

-    candidates.push(primary_repo_root.join("reference-source").join("claw-code"));
-    candidates.push(primary_repo_root.join("vendor").join("claw-code"));
+    candidates.push(
+        primary_repo_root
+            .join("reference-source")
+            .join("claude-code"),
+    );
+    candidates.push(primary_repo_root.join("vendor").join("claude-code"));

    let mut deduped = Vec::new();
    for candidate in candidates {
--- a/rust/crates/plugins/Cargo.toml
+++ b/rust/crates/plugins/Cargo.toml
@@ -1,13 +0,0 @@
-[package]
-name = "plugins"
-version.workspace = true
-edition.workspace = true
-license.workspace = true
-publish.workspace = true
-
-[dependencies]
-serde = { version = "1", features = ["derive"] }
-serde_json.workspace = true
-
-[lints]
-workspace = true
--- a/rust/crates/plugins/bundled/example-bundled/.claude-plugin/plugin.json
+++ b/rust/crates/plugins/bundled/example-bundled/.claude-plugin/plugin.json
@@ -1,10 +0,0 @@
-{
-  "name": "example-bundled",
-  "version": "0.1.0",
-  "description": "Example bundled plugin scaffold for the Rust plugin system",
-  "defaultEnabled": false,
-  "hooks": {
-    "PreToolUse": ["./hooks/pre.sh"],
-    "PostToolUse": ["./hooks/post.sh"]
-  }
-}
--- a/rust/crates/plugins/bundled/example-bundled/hooks/post.sh
+++ b/rust/crates/plugins/bundled/example-bundled/hooks/post.sh
@@ -1,2 +0,0 @@
-#!/bin/sh
-printf '%s\n' 'example bundled post hook'
--- a/rust/crates/plugins/bundled/example-bundled/hooks/pre.sh
+++ b/rust/crates/plugins/bundled/example-bundled/hooks/pre.sh
@@ -1,2 +0,0 @@
-#!/bin/sh
-printf '%s\n' 'example bundled pre hook'
--- a/rust/crates/plugins/bundled/sample-hooks/.claude-plugin/plugin.json
+++ b/rust/crates/plugins/bundled/sample-hooks/.claude-plugin/plugin.json
@@ -1,10 +0,0 @@
-{
-  "name": "sample-hooks",
-  "version": "0.1.0",
-  "description": "Bundled sample plugin scaffold for hook integration tests.",
-  "defaultEnabled": false,
-  "hooks": {
-    "PreToolUse": ["./hooks/pre.sh"],
-    "PostToolUse": ["./hooks/post.sh"]
-  }
-}
--- a/rust/crates/plugins/bundled/sample-hooks/hooks/post.sh
+++ b/rust/crates/plugins/bundled/sample-hooks/hooks/post.sh
@@ -1,2 +0,0 @@
-#!/bin/sh
-printf 'sample bundled post hook'
--- a/rust/crates/plugins/bundled/sample-hooks/hooks/pre.sh
+++ b/rust/crates/plugins/bundled/sample-hooks/hooks/pre.sh
@@ -1,2 +0,0 @@
-#!/bin/sh
-printf 'sample bundled pre hook'
--- a/rust/crates/plugins/src/hooks.rs
+++ b/rust/crates/plugins/src/hooks.rs
@@ -1,395 +0,0 @@
-use std::ffi::OsStr;
-use std::path::Path;
-use std::process::Command;
-
-use serde_json::json;
-
-use crate::{PluginError, PluginHooks, PluginRegistry};
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum HookEvent {
-    PreToolUse,
-    PostToolUse,
-}
-
-impl HookEvent {
-    fn as_str(self) -> &'static str {
-        match self {
-            Self::PreToolUse => "PreToolUse",
-            Self::PostToolUse => "PostToolUse",
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct HookRunResult {
-    denied: bool,
-    messages: Vec<String>,
-}
-
-impl HookRunResult {
-    #[must_use]
-    pub fn allow(messages: Vec<String>) -> Self {
-        Self {
-            denied: false,
-            messages,
-        }
-    }
-
-    #[must_use]
-    pub fn is_denied(&self) -> bool {
-        self.denied
-    }
-
-    #[must_use]
-    pub fn messages(&self) -> &[String] {
-        &self.messages
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub struct HookRunner {
-    hooks: PluginHooks,
-}
-
-impl HookRunner {
-    #[must_use]
-    pub fn new(hooks: PluginHooks) -> Self {
-        Self { hooks }
-    }
-
-    pub fn from_registry(plugin_registry: &PluginRegistry) -> Result<Self, PluginError> {
-        Ok(Self::new(plugin_registry.aggregated_hooks()?))
-    }
-
-    #[must_use]
-    pub fn run_pre_tool_use(&self, tool_name: &str, tool_input: &str) -> HookRunResult {
-        self.run_commands(
-            HookEvent::PreToolUse,
-            &self.hooks.pre_tool_use,
-            tool_name,
-            tool_input,
-            None,
-            false,
-        )
-    }
-
-    #[must_use]
-    pub fn run_post_tool_use(
-        &self,
-        tool_name: &str,
-        tool_input: &str,
-        tool_output: &str,
-        is_error: bool,
-    ) -> HookRunResult {
-        self.run_commands(
-            HookEvent::PostToolUse,
-            &self.hooks.post_tool_use,
-            tool_name,
-            tool_input,
-            Some(tool_output),
-            is_error,
-        )
-    }
-
-    fn run_commands(
-        &self,
-        event: HookEvent,
-        commands: &[String],
-        tool_name: &str,
-        tool_input: &str,
-        tool_output: Option<&str>,
-        is_error: bool,
-    ) -> HookRunResult {
-        if commands.is_empty() {
-            return HookRunResult::allow(Vec::new());
-        }
-
-        let payload = json!({
-            "hook_event_name": event.as_str(),
-            "tool_name": tool_name,
-            "tool_input": parse_tool_input(tool_input),
-            "tool_input_json": tool_input,
-            "tool_output": tool_output,
-            "tool_result_is_error": is_error,
-        })
-        .to_string();
-
-        let mut messages = Vec::new();
-
-        for command in commands {
-            match self.run_command(
-                command,
-                event,
-                tool_name,
-                tool_input,
-                tool_output,
-                is_error,
-                &payload,
-            ) {
-                HookCommandOutcome::Allow { message } => {
-                    if let Some(message) = message {
-                        messages.push(message);
-                    }
-                }
-                HookCommandOutcome::Deny { message } => {
-                    messages.push(message.unwrap_or_else(|| {
-                        format!("{} hook denied tool `{tool_name}`", event.as_str())
-                    }));
-                    return HookRunResult {
-                        denied: true,
-                        messages,
-                    };
-                }
-                HookCommandOutcome::Warn { message } => messages.push(message),
-            }
-        }
-
-        HookRunResult::allow(messages)
-    }
-
-    #[allow(clippy::too_many_arguments, clippy::unused_self)]
-    fn run_command(
-        &self,
-        command: &str,
-        event: HookEvent,
-        tool_name: &str,
-        tool_input: &str,
-        tool_output: Option<&str>,
-        is_error: bool,
-        payload: &str,
-    ) -> HookCommandOutcome {
-        let mut child = shell_command(command);
-        child.stdin(std::process::Stdio::piped());
-        child.stdout(std::process::Stdio::piped());
-        child.stderr(std::process::Stdio::piped());
-        child.env("HOOK_EVENT", event.as_str());
-        child.env("HOOK_TOOL_NAME", tool_name);
-        child.env("HOOK_TOOL_INPUT", tool_input);
-        child.env("HOOK_TOOL_IS_ERROR", if is_error { "1" } else { "0" });
-        if let Some(tool_output) = tool_output {
-            child.env("HOOK_TOOL_OUTPUT", tool_output);
-        }
-
-        match child.output_with_stdin(payload.as_bytes()) {
-            Ok(output) => {
-                let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
-                let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
-                let message = (!stdout.is_empty()).then_some(stdout);
-                match output.status.code() {
-                    Some(0) => HookCommandOutcome::Allow { message },
-                    Some(2) => HookCommandOutcome::Deny { message },
-                    Some(code) => HookCommandOutcome::Warn {
-                        message: format_hook_warning(
-                            command,
-                            code,
-                            message.as_deref(),
-                            stderr.as_str(),
-                        ),
-                    },
-                    None => HookCommandOutcome::Warn {
-                        message: format!(
-                            "{} hook `{command}` terminated by signal while handling `{tool_name}`",
-                            event.as_str()
-                        ),
-                    },
-                }
-            }
-            Err(error) => HookCommandOutcome::Warn {
-                message: format!(
-                    "{} hook `{command}` failed to start for `{tool_name}`: {error}",
-                    event.as_str()
-                ),
-            },
-        }
-    }
-}
-
-enum HookCommandOutcome {
-    Allow { message: Option<String> },
-    Deny { message: Option<String> },
-    Warn { message: String },
-}
-
-fn parse_tool_input(tool_input: &str) -> serde_json::Value {
-    serde_json::from_str(tool_input).unwrap_or_else(|_| json!({ "raw": tool_input }))
-}
-
-fn format_hook_warning(command: &str, code: i32, stdout: Option<&str>, stderr: &str) -> String {
-    let mut message =
-        format!("Hook `{command}` exited with status {code}; allowing tool execution to continue");
-    if let Some(stdout) = stdout.filter(|stdout| !stdout.is_empty()) {
-        message.push_str(": ");
-        message.push_str(stdout);
-    } else if !stderr.is_empty() {
-        message.push_str(": ");
-        message.push_str(stderr);
-    }
-    message
-}
-
-fn shell_command(command: &str) -> CommandWithStdin {
-    #[cfg(windows)]
-    let command_builder = {
-        let mut command_builder = Command::new("cmd");
-        command_builder.arg("/C").arg(command);
-        CommandWithStdin::new(command_builder)
-    };
-
-    #[cfg(not(windows))]
-    let command_builder = if Path::new(command).exists() {
-        let mut command_builder = Command::new("sh");
-        command_builder.arg(command);
-        CommandWithStdin::new(command_builder)
-    } else {
-        let mut command_builder = Command::new("sh");
-        command_builder.arg("-lc").arg(command);
-        CommandWithStdin::new(command_builder)
-    };
-
-    command_builder
-}
-
-struct CommandWithStdin {
-    command: Command,
-}
-
-impl CommandWithStdin {
-    fn new(command: Command) -> Self {
-        Self { command }
-    }
-
-    fn stdin(&mut self, cfg: std::process::Stdio) -> &mut Self {
-        self.command.stdin(cfg);
-        self
-    }
-
-    fn stdout(&mut self, cfg: std::process::Stdio) -> &mut Self {
-        self.command.stdout(cfg);
-        self
-    }
-
-    fn stderr(&mut self, cfg: std::process::Stdio) -> &mut Self {
-        self.command.stderr(cfg);
-        self
-    }
-
-    fn env<K, V>(&mut self, key: K, value: V) -> &mut Self
-    where
-        K: AsRef<OsStr>,
-        V: AsRef<OsStr>,
-    {
-        self.command.env(key, value);
-        self
-    }
-
-    fn output_with_stdin(&mut self, stdin: &[u8]) -> std::io::Result<std::process::Output> {
-        let mut child = self.command.spawn()?;
-        if let Some(mut child_stdin) = child.stdin.take() {
-            use std::io::Write as _;
-            child_stdin.write_all(stdin)?;
-        }
-        child.wait_with_output()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{HookRunResult, HookRunner};
-    use crate::{PluginManager, PluginManagerConfig};
-    use std::fs;
-    use std::path::{Path, PathBuf};
-    use std::time::{SystemTime, UNIX_EPOCH};
-
-    fn temp_dir(label: &str) -> PathBuf {
-        let nanos = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .expect("time should be after epoch")
-            .as_nanos();
-        std::env::temp_dir().join(format!("plugins-hook-runner-{label}-{nanos}"))
-    }
-
-    fn write_hook_plugin(root: &Path, name: &str, pre_message: &str, post_message: &str) {
-        fs::create_dir_all(root.join(".claude-plugin")).expect("manifest dir");
-        fs::create_dir_all(root.join("hooks")).expect("hooks dir");
-        fs::write(
-            root.join("hooks").join("pre.sh"),
-            format!("#!/bin/sh\nprintf '%s\\n' '{pre_message}'\n"),
-        )
-        .expect("write pre hook");
-        fs::write(
-            root.join("hooks").join("post.sh"),
-            format!("#!/bin/sh\nprintf '%s\\n' '{post_message}'\n"),
-        )
-        .expect("write post hook");
-        fs::write(
-            root.join(".claude-plugin").join("plugin.json"),
-            format!(
-                "{{\n  \"name\": \"{name}\",\n  \"version\": \"1.0.0\",\n  \"description\": \"hook plugin\",\n  \"hooks\": {{\n    \"PreToolUse\": [\"./hooks/pre.sh\"],\n    \"PostToolUse\": [\"./hooks/post.sh\"]\n  }}\n}}"
-            ),
-        )
-        .expect("write plugin manifest");
-    }
-
-    #[test]
-    fn collects_and_runs_hooks_from_enabled_plugins() {
-        let config_home = temp_dir("config");
-        let first_source_root = temp_dir("source-a");
-        let second_source_root = temp_dir("source-b");
-        write_hook_plugin(
-            &first_source_root,
-            "first",
-            "plugin pre one",
-            "plugin post one",
-        );
-        write_hook_plugin(
-            &second_source_root,
-            "second",
-            "plugin pre two",
-            "plugin post two",
-        );
-
-        let mut manager = PluginManager::new(PluginManagerConfig::new(&config_home));
-        manager
-            .install(first_source_root.to_str().expect("utf8 path"))
-            .expect("first plugin install should succeed");
-        manager
-            .install(second_source_root.to_str().expect("utf8 path"))
-            .expect("second plugin install should succeed");
-        let registry = manager.plugin_registry().expect("registry should build");
-
-        let runner = HookRunner::from_registry(&registry).expect("plugin hooks should load");
-
-        assert_eq!(
-            runner.run_pre_tool_use("Read", r#"{"path":"README.md"}"#),
-            HookRunResult::allow(vec![
-                "plugin pre one".to_string(),
-                "plugin pre two".to_string(),
-            ])
-        );
-        assert_eq!(
-            runner.run_post_tool_use("Read", r#"{"path":"README.md"}"#, "ok", false),
-            HookRunResult::allow(vec![
-                "plugin post one".to_string(),
-                "plugin post two".to_string(),
-            ])
-        );
-
-        let _ = fs::remove_dir_all(config_home);
-        let _ = fs::remove_dir_all(first_source_root);
-        let _ = fs::remove_dir_all(second_source_root);
-    }
-
-    #[test]
-    fn pre_tool_use_denies_when_plugin_hook_exits_two() {
-        let runner = HookRunner::new(crate::PluginHooks {
-            pre_tool_use: vec!["printf 'blocked by plugin'; exit 2".to_string()],
-            post_tool_use: Vec::new(),
-        });
-
-        let result = runner.run_pre_tool_use("Bash", r#"{"command":"pwd"}"#);
-
-        assert!(result.is_denied());
-        assert_eq!(result.messages(), &["blocked by plugin".to_string()]);
-    }
-}
--- a/rust/crates/plugins/src/lib.rs
+++ b/rust/crates/plugins/src/lib.rs
--- a/rust/crates/runtime/Cargo.toml
+++ b/rust/crates/runtime/Cargo.toml
@@ -8,10 +8,9 @@ publish.workspace = true
 [dependencies]
 sha2 = "0.10"
 glob = "0.3"
-plugins = { path = "../plugins" }
 regex = "1"
 serde = { version = "1", features = ["derive"] }
-serde_json.workspace = true
+serde_json = "1"
 tokio = { version = "1", features = ["io-util", "macros", "process", "rt", "rt-multi-thread", "time"] }
 walkdir = "2"

--- a/rust/crates/runtime/src/compact.rs
+++ b/rust/crates/runtime/src/compact.rs
@@ -1,10 +1,5 @@
 use crate::session::{ContentBlock, ConversationMessage, MessageRole, Session};

-const COMPACT_CONTINUATION_PREAMBLE: &str =
-    "This session is being continued from a previous conversation that ran out of context. The summary below covers the earlier portion of the conversation.\n\n";
-const COMPACT_RECENT_MESSAGES_NOTE: &str = "Recent messages are preserved verbatim.";
-const COMPACT_DIRECT_RESUME_INSTRUCTION: &str = "Continue the conversation from where it left off without asking the user any further questions. Resume directly — do not acknowledge the summary, do not recap what was happening, and do not preface with continuation text.";
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct CompactionConfig {
    pub preserve_recent_messages: usize,
@@ -35,15 +30,8 @@ pub fn estimate_session_tokens(session: &Session) -> usize {

 #[must_use]
 pub fn should_compact(session: &Session, config: CompactionConfig) -> bool {
-    let start = compacted_summary_prefix_len(session);
-    let compactable = &session.messages[start..];
-
-    compactable.len() > config.preserve_recent_messages
-        && compactable
-            .iter()
-            .map(estimate_message_tokens)
-            .sum::<usize>()
-            >= config.max_estimated_tokens
+    session.messages.len() > config.preserve_recent_messages
+        && estimate_session_tokens(session) >= config.max_estimated_tokens
 }

 #[must_use]
@@ -68,18 +56,16 @@ pub fn get_compact_continuation_message(
    recent_messages_preserved: bool,
 ) -> String {
    let mut base = format!(
-        "{COMPACT_CONTINUATION_PREAMBLE}{}",
+        "This session is being continued from a previous conversation that ran out of context. The summary below covers the earlier portion of the conversation.\n\n{}",
        format_compact_summary(summary)
    );

    if recent_messages_preserved {
-        base.push_str("\n\n");
-        base.push_str(COMPACT_RECENT_MESSAGES_NOTE);
+        base.push_str("\n\nRecent messages are preserved verbatim.");
    }

    if suppress_follow_up_questions {
-        base.push('\n');
-        base.push_str(COMPACT_DIRECT_RESUME_INSTRUCTION);
+        base.push_str("\nContinue the conversation from where it left off without asking the user any further questions. Resume directly — do not acknowledge the summary, do not recap what was happening, and do not preface with continuation text.");
    }

    base
@@ -96,19 +82,13 @@ pub fn compact_session(session: &Session, config: CompactionConfig) -> Compactio
        };
    }

-    let existing_summary = session
-        .messages
-        .first()
-        .and_then(extract_existing_compacted_summary);
-    let compacted_prefix_len = usize::from(existing_summary.is_some());
    let keep_from = session
        .messages
        .len()
        .saturating_sub(config.preserve_recent_messages);
-    let removed = &session.messages[compacted_prefix_len..keep_from];
+    let removed = &session.messages[..keep_from];
    let preserved = session.messages[keep_from..].to_vec();
-    let summary =
-        merge_compact_summaries(existing_summary.as_deref(), &summarize_messages(removed));
+    let summary = summarize_messages(removed);
    let formatted_summary = format_compact_summary(&summary);
    let continuation = get_compact_continuation_message(&summary, true, !preserved.is_empty());

@@ -119,27 +99,18 @@ pub fn compact_session(session: &Session, config: CompactionConfig) -> Compactio
    }];
    compacted_messages.extend(preserved);

+    let mut compacted_session = session.clone();
+    compacted_session.messages = compacted_messages;
+    compacted_session.record_compaction(summary.clone(), removed.len());
+
    CompactionResult {
        summary,
        formatted_summary,
-        compacted_session: Session {
-            version: session.version,
-            messages: compacted_messages,
-        },
+        compacted_session,
        removed_message_count: removed.len(),
    }
 }

-fn compacted_summary_prefix_len(session: &Session) -> usize {
-    usize::from(
-        session
-            .messages
-            .first()
-            .and_then(extract_existing_compacted_summary)
-            .is_some(),
-    )
-}
-
 fn summarize_messages(messages: &[ConversationMessage]) -> String {
    let user_messages = messages
        .iter()
@@ -227,41 +198,6 @@ fn summarize_messages(messages: &[ConversationMessage]) -> String {
    lines.join("\n")
 }

-fn merge_compact_summaries(existing_summary: Option<&str>, new_summary: &str) -> String {
-    let Some(existing_summary) = existing_summary else {
-        return new_summary.to_string();
-    };
-
-    let previous_highlights = extract_summary_highlights(existing_summary);
-    let new_formatted_summary = format_compact_summary(new_summary);
-    let new_highlights = extract_summary_highlights(&new_formatted_summary);
-    let new_timeline = extract_summary_timeline(&new_formatted_summary);
-
-    let mut lines = vec!["<summary>".to_string(), "Conversation summary:".to_string()];
-
-    if !previous_highlights.is_empty() {
-        lines.push("- Previously compacted context:".to_string());
-        lines.extend(
-            previous_highlights
-                .into_iter()
-                .map(|line| format!("  {line}")),
-        );
-    }
-
-    if !new_highlights.is_empty() {
-        lines.push("- Newly compacted context:".to_string());
-        lines.extend(new_highlights.into_iter().map(|line| format!("  {line}")));
-    }
-
-    if !new_timeline.is_empty() {
-        lines.push("- Key timeline:".to_string());
-        lines.extend(new_timeline.into_iter().map(|line| format!("  {line}")));
-    }
-
-    lines.push("</summary>".to_string());
-    lines.join("\n")
-}
-
 fn summarize_block(block: &ContentBlock) -> String {
    let raw = match block {
        ContentBlock::Text { text } => text.clone(),
@@ -439,71 +375,11 @@ fn collapse_blank_lines(content: &str) -> String {
    result
 }

-fn extract_existing_compacted_summary(message: &ConversationMessage) -> Option<String> {
-    if message.role != MessageRole::System {
-        return None;
-    }
-
-    let text = first_text_block(message)?;
-    let summary = text.strip_prefix(COMPACT_CONTINUATION_PREAMBLE)?;
-    let summary = summary
-        .split_once(&format!("\n\n{COMPACT_RECENT_MESSAGES_NOTE}"))
-        .map_or(summary, |(value, _)| value);
-    let summary = summary
-        .split_once(&format!("\n{COMPACT_DIRECT_RESUME_INSTRUCTION}"))
-        .map_or(summary, |(value, _)| value);
-    Some(summary.trim().to_string())
-}
-
-fn extract_summary_highlights(summary: &str) -> Vec<String> {
-    let mut lines = Vec::new();
-    let mut in_timeline = false;
-
-    for line in format_compact_summary(summary).lines() {
-        let trimmed = line.trim_end();
-        if trimmed.is_empty() || trimmed == "Summary:" || trimmed == "Conversation summary:" {
-            continue;
-        }
-        if trimmed == "- Key timeline:" {
-            in_timeline = true;
-            continue;
-        }
-        if in_timeline {
-            continue;
-        }
-        lines.push(trimmed.to_string());
-    }
-
-    lines
-}
-
-fn extract_summary_timeline(summary: &str) -> Vec<String> {
-    let mut lines = Vec::new();
-    let mut in_timeline = false;
-
-    for line in format_compact_summary(summary).lines() {
-        let trimmed = line.trim_end();
-        if trimmed == "- Key timeline:" {
-            in_timeline = true;
-            continue;
-        }
-        if !in_timeline {
-            continue;
-        }
-        if trimmed.is_empty() {
-            break;
-        }
-        lines.push(trimmed.to_string());
-    }
-
-    lines
-}
-
 #[cfg(test)]
 mod tests {
    use super::{
        collect_key_files, compact_session, estimate_session_tokens, format_compact_summary,
-        get_compact_continuation_message, infer_pending_work, should_compact, CompactionConfig,
+        infer_pending_work, should_compact, CompactionConfig,
    };
    use crate::session::{ContentBlock, ConversationMessage, MessageRole, Session};

@@ -515,10 +391,8 @@ mod tests {

    #[test]
    fn leaves_small_sessions_unchanged() {
-        let session = Session {
-            version: 1,
-            messages: vec![ConversationMessage::user_text("hello")],
-        };
+        let mut session = Session::new();
+        session.messages = vec![ConversationMessage::user_text("hello")];

        let result = compact_session(&session, CompactionConfig::default());
        assert_eq!(result.removed_message_count, 0);
@@ -529,23 +403,21 @@ mod tests {

    #[test]
    fn compacts_older_messages_into_a_system_summary() {
-        let session = Session {
-            version: 1,
-            messages: vec![
-                ConversationMessage::user_text("one ".repeat(200)),
-                ConversationMessage::assistant(vec![ContentBlock::Text {
-                    text: "two ".repeat(200),
-                }]),
-                ConversationMessage::tool_result("1", "bash", "ok ".repeat(200), false),
-                ConversationMessage {
-                    role: MessageRole::Assistant,
-                    blocks: vec![ContentBlock::Text {
-                        text: "recent".to_string(),
-                    }],
-                    usage: None,
-                },
-            ],
-        };
+        let mut session = Session::new();
+        session.messages = vec![
+            ConversationMessage::user_text("one ".repeat(200)),
+            ConversationMessage::assistant(vec![ContentBlock::Text {
+                text: "two ".repeat(200),
+            }]),
+            ConversationMessage::tool_result("1", "bash", "ok ".repeat(200), false),
+            ConversationMessage {
+                role: MessageRole::Assistant,
+                blocks: vec![ContentBlock::Text {
+                    text: "recent".to_string(),
+                }],
+                usage: None,
+            },
+        ];

        let result = compact_session(
            &session,
@@ -578,98 +450,6 @@ mod tests {
        );
    }

-    #[test]
-    fn keeps_previous_compacted_context_when_compacting_again() {
-        let initial_session = Session {
-            version: 1,
-            messages: vec![
-                ConversationMessage::user_text("Investigate rust/crates/runtime/src/compact.rs"),
-                ConversationMessage::assistant(vec![ContentBlock::Text {
-                    text: "I will inspect the compact flow.".to_string(),
-                }]),
-                ConversationMessage::user_text(
-                    "Also update rust/crates/runtime/src/conversation.rs",
-                ),
-                ConversationMessage::assistant(vec![ContentBlock::Text {
-                    text: "Next: preserve prior summary context during auto compact.".to_string(),
-                }]),
-            ],
-        };
-        let config = CompactionConfig {
-            preserve_recent_messages: 2,
-            max_estimated_tokens: 1,
-        };
-
-        let first = compact_session(&initial_session, config);
-        let mut follow_up_messages = first.compacted_session.messages.clone();
-        follow_up_messages.extend([
-            ConversationMessage::user_text("Please add regression tests for compaction."),
-            ConversationMessage::assistant(vec![ContentBlock::Text {
-                text: "Working on regression coverage now.".to_string(),
-            }]),
-        ]);
-
-        let second = compact_session(
-            &Session {
-                version: 1,
-                messages: follow_up_messages,
-            },
-            config,
-        );
-
-        assert!(second
-            .formatted_summary
-            .contains("Previously compacted context:"));
-        assert!(second
-            .formatted_summary
-            .contains("Scope: 2 earlier messages compacted"));
-        assert!(second
-            .formatted_summary
-            .contains("Newly compacted context:"));
-        assert!(second
-            .formatted_summary
-            .contains("Also update rust/crates/runtime/src/conversation.rs"));
-        assert!(matches!(
-            &second.compacted_session.messages[0].blocks[0],
-            ContentBlock::Text { text }
-                if text.contains("Previously compacted context:")
-                    && text.contains("Newly compacted context:")
-        ));
-        assert!(matches!(
-            &second.compacted_session.messages[1].blocks[0],
-            ContentBlock::Text { text } if text.contains("Please add regression tests for compaction.")
-        ));
-    }
-
-    #[test]
-    fn ignores_existing_compacted_summary_when_deciding_to_recompact() {
-        let summary = "<summary>Conversation summary:\n- Scope: earlier work preserved.\n- Key timeline:\n  - user: large preserved context\n</summary>";
-        let session = Session {
-            version: 1,
-            messages: vec![
-                ConversationMessage {
-                    role: MessageRole::System,
-                    blocks: vec![ContentBlock::Text {
-                        text: get_compact_continuation_message(summary, true, true),
-                    }],
-                    usage: None,
-                },
-                ConversationMessage::user_text("tiny"),
-                ConversationMessage::assistant(vec![ContentBlock::Text {
-                    text: "recent".to_string(),
-                }]),
-            ],
-        };
-
-        assert!(!should_compact(
-            &session,
-            CompactionConfig {
-                preserve_recent_messages: 2,
-                max_estimated_tokens: 1,
-            }
-        ));
-    }
-
    #[test]
    fn truncates_long_blocks_in_summary() {
        let summary = super::summarize_block(&ContentBlock::Text {
--- a/rust/crates/runtime/src/config.rs
+++ b/rust/crates/runtime/src/config.rs
@@ -6,7 +6,7 @@ use std::path::{Path, PathBuf};
 use crate::json::JsonValue;
 use crate::sandbox::{FilesystemIsolationMode, SandboxConfig};

-pub const CLAW_SETTINGS_SCHEMA_NAME: &str = "SettingsSchema";
+pub const CLAUDE_CODE_SETTINGS_SCHEMA_NAME: &str = "SettingsSchema";

 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub enum ConfigSource {
@@ -35,19 +35,9 @@ pub struct RuntimeConfig {
    feature_config: RuntimeFeatureConfig,
 }

-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub struct RuntimePluginConfig {
-    enabled_plugins: BTreeMap<String, bool>,
-    external_directories: Vec<String>,
-    install_root: Option<String>,
-    registry_path: Option<String>,
-    bundled_root: Option<String>,
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub struct RuntimeFeatureConfig {
    hooks: RuntimeHookConfig,
-    plugins: RuntimePluginConfig,
    mcp: McpConfigCollection,
    oauth: Option<OAuthConfig>,
    model: Option<String>,
@@ -79,7 +69,7 @@ pub enum McpTransport {
    Http,
    Ws,
    Sdk,
-    ManagedProxy,
+    ClaudeAiProxy,
 }

 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -89,7 +79,7 @@ pub enum McpServerConfig {
    Http(McpRemoteServerConfig),
    Ws(McpWebSocketServerConfig),
    Sdk(McpSdkServerConfig),
-    ManagedProxy(McpManagedProxyServerConfig),
+    ClaudeAiProxy(McpClaudeAiProxyServerConfig),
 }

 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -120,7 +110,7 @@ pub struct McpSdkServerConfig {
 }

 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct McpManagedProxyServerConfig {
+pub struct McpClaudeAiProxyServerConfig {
    pub url: String,
    pub id: String,
 }
@@ -184,20 +174,18 @@ impl ConfigLoader {
    #[must_use]
    pub fn default_for(cwd: impl Into<PathBuf>) -> Self {
        let cwd = cwd.into();
-        let config_home = default_config_home();
+        let config_home = std::env::var_os("CLAUDE_CONFIG_HOME")
+            .map(PathBuf::from)
+            .or_else(|| std::env::var_os("HOME").map(|home| PathBuf::from(home).join(".claude")))
+            .unwrap_or_else(|| PathBuf::from(".claude"));
        Self { cwd, config_home }
    }

-    #[must_use]
-    pub fn config_home(&self) -> &Path {
-        &self.config_home
-    }
-
    #[must_use]
    pub fn discover(&self) -> Vec<ConfigEntry> {
        let user_legacy_path = self.config_home.parent().map_or_else(
-            || PathBuf::from(".claw.json"),
-            |parent| parent.join(".claw.json"),
+            || PathBuf::from(".claude.json"),
+            |parent| parent.join(".claude.json"),
        );
        vec![
            ConfigEntry {
@@ -210,15 +198,15 @@ impl ConfigLoader {
            },
            ConfigEntry {
                source: ConfigSource::Project,
-                path: self.cwd.join(".claw.json"),
+                path: self.cwd.join(".claude.json"),
            },
            ConfigEntry {
                source: ConfigSource::Project,
-                path: self.cwd.join(".claw").join("settings.json"),
+                path: self.cwd.join(".claude").join("settings.json"),
            },
            ConfigEntry {
                source: ConfigSource::Local,
-                path: self.cwd.join(".claw").join("settings.local.json"),
+                path: self.cwd.join(".claude").join("settings.local.json"),
            },
        ]
    }
@@ -241,7 +229,6 @@ impl ConfigLoader {

        let feature_config = RuntimeFeatureConfig {
            hooks: parse_optional_hooks_config(&merged_value)?,
-            plugins: parse_optional_plugin_config(&merged_value)?,
            mcp: McpConfigCollection {
                servers: mcp_servers,
            },
@@ -304,11 +291,6 @@ impl RuntimeConfig {
        &self.feature_config.hooks
    }

-    #[must_use]
-    pub fn plugins(&self) -> &RuntimePluginConfig {
-        &self.feature_config.plugins
-    }
-
    #[must_use]
    pub fn oauth(&self) -> Option<&OAuthConfig> {
        self.feature_config.oauth.as_ref()
@@ -337,22 +319,11 @@ impl RuntimeFeatureConfig {
        self
    }

-    #[must_use]
-    pub fn with_plugins(mut self, plugins: RuntimePluginConfig) -> Self {
-        self.plugins = plugins;
-        self
-    }
-
    #[must_use]
    pub fn hooks(&self) -> &RuntimeHookConfig {
        &self.hooks
    }

-    #[must_use]
-    pub fn plugins(&self) -> &RuntimePluginConfig {
-        &self.plugins
-    }
-
    #[must_use]
    pub fn mcp(&self) -> &McpConfigCollection {
        &self.mcp
@@ -379,53 +350,6 @@ impl RuntimeFeatureConfig {
    }
 }

-impl RuntimePluginConfig {
-    #[must_use]
-    pub fn enabled_plugins(&self) -> &BTreeMap<String, bool> {
-        &self.enabled_plugins
-    }
-
-    #[must_use]
-    pub fn external_directories(&self) -> &[String] {
-        &self.external_directories
-    }
-
-    #[must_use]
-    pub fn install_root(&self) -> Option<&str> {
-        self.install_root.as_deref()
-    }
-
-    #[must_use]
-    pub fn registry_path(&self) -> Option<&str> {
-        self.registry_path.as_deref()
-    }
-
-    #[must_use]
-    pub fn bundled_root(&self) -> Option<&str> {
-        self.bundled_root.as_deref()
-    }
-
-    pub fn set_plugin_state(&mut self, plugin_id: String, enabled: bool) {
-        self.enabled_plugins.insert(plugin_id, enabled);
-    }
-
-    #[must_use]
-    pub fn state_for(&self, plugin_id: &str, default_enabled: bool) -> bool {
-        self.enabled_plugins
-            .get(plugin_id)
-            .copied()
-            .unwrap_or(default_enabled)
-    }
-}
-
-#[must_use]
-pub fn default_config_home() -> PathBuf {
-    std::env::var_os("CLAW_CONFIG_HOME")
-        .map(PathBuf::from)
-        .or_else(|| std::env::var_os("HOME").map(|home| PathBuf::from(home).join(".claw")))
-        .unwrap_or_else(|| PathBuf::from(".claw"))
-}
-
 impl RuntimeHookConfig {
    #[must_use]
    pub fn new(pre_tool_use: Vec<String>, post_tool_use: Vec<String>) -> Self {
@@ -444,18 +368,6 @@ impl RuntimeHookConfig {
    pub fn post_tool_use(&self) -> &[String] {
        &self.post_tool_use
    }
-
-    #[must_use]
-    pub fn merged(&self, other: &Self) -> Self {
-        let mut merged = self.clone();
-        merged.extend(other);
-        merged
-    }
-
-    pub fn extend(&mut self, other: &Self) {
-        extend_unique(&mut self.pre_tool_use, other.pre_tool_use());
-        extend_unique(&mut self.post_tool_use, other.post_tool_use());
-    }
 }

 impl McpConfigCollection {
@@ -486,7 +398,7 @@ impl McpServerConfig {
            Self::Http(_) => McpTransport::Http,
            Self::Ws(_) => McpTransport::Ws,
            Self::Sdk(_) => McpTransport::Sdk,
-            Self::ManagedProxy(_) => McpTransport::ManagedProxy,
+            Self::ClaudeAiProxy(_) => McpTransport::ClaudeAiProxy,
        }
    }
 }
@@ -494,7 +406,7 @@ impl McpServerConfig {
 fn read_optional_json_object(
    path: &Path,
 ) -> Result<Option<BTreeMap<String, JsonValue>>, ConfigError> {
-    let is_legacy_config = path.file_name().and_then(|name| name.to_str()) == Some(".claw.json");
+    let is_legacy_config = path.file_name().and_then(|name| name.to_str()) == Some(".claude.json");
    let contents = match fs::read_to_string(path) {
        Ok(contents) => contents,
        Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None),
@@ -572,36 +484,6 @@ fn parse_optional_hooks_config(root: &JsonValue) -> Result<RuntimeHookConfig, Co
    })
 }

-fn parse_optional_plugin_config(root: &JsonValue) -> Result<RuntimePluginConfig, ConfigError> {
-    let Some(object) = root.as_object() else {
-        return Ok(RuntimePluginConfig::default());
-    };
-
-    let mut config = RuntimePluginConfig::default();
-    if let Some(enabled_plugins) = object.get("enabledPlugins") {
-        config.enabled_plugins = parse_bool_map(enabled_plugins, "merged settings.enabledPlugins")?;
-    }
-
-    let Some(plugins_value) = object.get("plugins") else {
-        return Ok(config);
-    };
-    let plugins = expect_object(plugins_value, "merged settings.plugins")?;
-
-    if let Some(enabled_value) = plugins.get("enabled") {
-        config.enabled_plugins = parse_bool_map(enabled_value, "merged settings.plugins.enabled")?;
-    }
-    config.external_directories =
-        optional_string_array(plugins, "externalDirectories", "merged settings.plugins")?
-            .unwrap_or_default();
-    config.install_root =
-        optional_string(plugins, "installRoot", "merged settings.plugins")?.map(str::to_string);
-    config.registry_path =
-        optional_string(plugins, "registryPath", "merged settings.plugins")?.map(str::to_string);
-    config.bundled_root =
-        optional_string(plugins, "bundledRoot", "merged settings.plugins")?.map(str::to_string);
-    Ok(config)
-}
-
 fn parse_optional_permission_mode(
    root: &JsonValue,
 ) -> Result<Option<ResolvedPermissionMode>, ConfigError> {
@@ -724,10 +606,12 @@ fn parse_mcp_server_config(
        "sdk" => Ok(McpServerConfig::Sdk(McpSdkServerConfig {
            name: expect_string(object, "name", context)?.to_string(),
        })),
-        "claudeai-proxy" => Ok(McpServerConfig::ManagedProxy(McpManagedProxyServerConfig {
-            url: expect_string(object, "url", context)?.to_string(),
-            id: expect_string(object, "id", context)?.to_string(),
-        })),
+        "claudeai-proxy" => Ok(McpServerConfig::ClaudeAiProxy(
+            McpClaudeAiProxyServerConfig {
+                url: expect_string(object, "url", context)?.to_string(),
+                id: expect_string(object, "id", context)?.to_string(),
+            },
+        )),
        other => Err(ConfigError::Parse(format!(
            "{context}: unsupported MCP server type for {server_name}: {other}"
        ))),
@@ -832,24 +716,6 @@ fn optional_u16(
    }
 }

-fn parse_bool_map(value: &JsonValue, context: &str) -> Result<BTreeMap<String, bool>, ConfigError> {
-    let Some(map) = value.as_object() else {
-        return Err(ConfigError::Parse(format!(
-            "{context}: expected JSON object"
-        )));
-    };
-    map.iter()
-        .map(|(key, value)| {
-            value
-                .as_bool()
-                .map(|enabled| (key.clone(), enabled))
-                .ok_or_else(|| {
-                    ConfigError::Parse(format!("{context}: field {key} must be a boolean"))
-                })
-        })
-        .collect()
-}
-
 fn optional_string_array(
    object: &BTreeMap<String, JsonValue>,
    key: &str,
@@ -924,23 +790,11 @@ fn deep_merge_objects(
    }
 }

-fn extend_unique(target: &mut Vec<String>, values: &[String]) {
-    for value in values {
-        push_unique(target, value.clone());
-    }
-}
-
-fn push_unique(target: &mut Vec<String>, value: String) {
-    if !target.iter().any(|existing| existing == &value) {
-        target.push(value);
-    }
-}
-
 #[cfg(test)]
 mod tests {
    use super::{
        ConfigLoader, ConfigSource, McpServerConfig, McpTransport, ResolvedPermissionMode,
-        CLAW_SETTINGS_SCHEMA_NAME,
+        CLAUDE_CODE_SETTINGS_SCHEMA_NAME,
    };
    use crate::json::JsonValue;
    use crate::sandbox::FilesystemIsolationMode;
@@ -959,7 +813,7 @@ mod tests {
    fn rejects_non_object_settings_files() {
        let root = temp_dir();
        let cwd = root.join("project");
-        let home = root.join("home").join(".claw");
+        let home = root.join("home").join(".claude");
        fs::create_dir_all(&home).expect("home config dir");
        fs::create_dir_all(&cwd).expect("project dir");
        fs::write(home.join("settings.json"), "[]").expect("write bad settings");
@@ -978,12 +832,12 @@ mod tests {
    fn loads_and_merges_claude_code_config_files_by_precedence() {
        let root = temp_dir();
        let cwd = root.join("project");
-        let home = root.join("home").join(".claw");
-        fs::create_dir_all(cwd.join(".claw")).expect("project config dir");
+        let home = root.join("home").join(".claude");
+        fs::create_dir_all(cwd.join(".claude")).expect("project config dir");
        fs::create_dir_all(&home).expect("home config dir");

        fs::write(
-            home.parent().expect("home parent").join(".claw.json"),
+            home.parent().expect("home parent").join(".claude.json"),
            r#"{"model":"haiku","env":{"A":"1"},"mcpServers":{"home":{"command":"uvx","args":["home"]}}}"#,
        )
        .expect("write user compat config");
@@ -993,17 +847,17 @@ mod tests {
        )
        .expect("write user settings");
        fs::write(
-            cwd.join(".claw.json"),
+            cwd.join(".claude.json"),
            r#"{"model":"project-compat","env":{"B":"2"}}"#,
        )
        .expect("write project compat config");
        fs::write(
-            cwd.join(".claw").join("settings.json"),
+            cwd.join(".claude").join("settings.json"),
            r#"{"env":{"C":"3"},"hooks":{"PostToolUse":["project"]},"mcpServers":{"project":{"command":"uvx","args":["project"]}}}"#,
        )
        .expect("write project settings");
        fs::write(
-            cwd.join(".claw").join("settings.local.json"),
+            cwd.join(".claude").join("settings.local.json"),
            r#"{"model":"opus","permissionMode":"acceptEdits"}"#,
        )
        .expect("write local settings");
@@ -1012,7 +866,7 @@ mod tests {
            .load()
            .expect("config should load");

-        assert_eq!(CLAW_SETTINGS_SCHEMA_NAME, "SettingsSchema");
+        assert_eq!(CLAUDE_CODE_SETTINGS_SCHEMA_NAME, "SettingsSchema");
        assert_eq!(loaded.loaded_entries().len(), 5);
        assert_eq!(loaded.loaded_entries()[0].source, ConfigSource::User);
        assert_eq!(
@@ -1054,12 +908,12 @@ mod tests {
    fn parses_sandbox_config() {
        let root = temp_dir();
        let cwd = root.join("project");
-        let home = root.join("home").join(".claw");
-        fs::create_dir_all(cwd.join(".claw")).expect("project config dir");
+        let home = root.join("home").join(".claude");
+        fs::create_dir_all(cwd.join(".claude")).expect("project config dir");
        fs::create_dir_all(&home).expect("home config dir");

        fs::write(
-            cwd.join(".claw").join("settings.local.json"),
+            cwd.join(".claude").join("settings.local.json"),
            r#"{
              "sandbox": {
                "enabled": true,
@@ -1092,8 +946,8 @@ mod tests {
    fn parses_typed_mcp_and_oauth_config() {
        let root = temp_dir();
        let cwd = root.join("project");
-        let home = root.join("home").join(".claw");
-        fs::create_dir_all(cwd.join(".claw")).expect("project config dir");
+        let home = root.join("home").join(".claude");
+        fs::create_dir_all(cwd.join(".claude")).expect("project config dir");
        fs::create_dir_all(&home).expect("home config dir");

        fs::write(
@@ -1130,7 +984,7 @@ mod tests {
        )
        .expect("write user settings");
        fs::write(
-            cwd.join(".claw").join("settings.local.json"),
+            cwd.join(".claude").join("settings.local.json"),
            r#"{
              "mcpServers": {
                "remote-server": {
@@ -1179,101 +1033,11 @@ mod tests {
        fs::remove_dir_all(root).expect("cleanup temp dir");
    }

-    #[test]
-    fn parses_plugin_config_from_enabled_plugins() {
-        let root = temp_dir();
-        let cwd = root.join("project");
-        let home = root.join("home").join(".claw");
-        fs::create_dir_all(cwd.join(".claw")).expect("project config dir");
-        fs::create_dir_all(&home).expect("home config dir");
-
-        fs::write(
-            home.join("settings.json"),
-            r#"{
-              "enabledPlugins": {
-                "tool-guard@builtin": true,
-                "sample-plugin@external": false
-              }
-            }"#,
-        )
-        .expect("write user settings");
-
-        let loaded = ConfigLoader::new(&cwd, &home)
-            .load()
-            .expect("config should load");
-
-        assert_eq!(
-            loaded.plugins().enabled_plugins().get("tool-guard@builtin"),
-            Some(&true)
-        );
-        assert_eq!(
-            loaded
-                .plugins()
-                .enabled_plugins()
-                .get("sample-plugin@external"),
-            Some(&false)
-        );
-
-        fs::remove_dir_all(root).expect("cleanup temp dir");
-    }
-
-    #[test]
-    fn parses_plugin_config() {
-        let root = temp_dir();
-        let cwd = root.join("project");
-        let home = root.join("home").join(".claw");
-        fs::create_dir_all(cwd.join(".claw")).expect("project config dir");
-        fs::create_dir_all(&home).expect("home config dir");
-
-        fs::write(
-            home.join("settings.json"),
-            r#"{
-              "enabledPlugins": {
-                "core-helpers@builtin": true
-              },
-              "plugins": {
-                "externalDirectories": ["./external-plugins"],
-                "installRoot": "plugin-cache/installed",
-                "registryPath": "plugin-cache/installed.json",
-                "bundledRoot": "./bundled-plugins"
-              }
-            }"#,
-        )
-        .expect("write plugin settings");
-
-        let loaded = ConfigLoader::new(&cwd, &home)
-            .load()
-            .expect("config should load");
-
-        assert_eq!(
-            loaded
-                .plugins()
-                .enabled_plugins()
-                .get("core-helpers@builtin"),
-            Some(&true)
-        );
-        assert_eq!(
-            loaded.plugins().external_directories(),
-            &["./external-plugins".to_string()]
-        );
-        assert_eq!(
-            loaded.plugins().install_root(),
-            Some("plugin-cache/installed")
-        );
-        assert_eq!(
-            loaded.plugins().registry_path(),
-            Some("plugin-cache/installed.json")
-        );
-        assert_eq!(loaded.plugins().bundled_root(), Some("./bundled-plugins"));
-
-        fs::remove_dir_all(root).expect("cleanup temp dir");
-    }
-
    #[test]
    fn rejects_invalid_mcp_server_shapes() {
        let root = temp_dir();
        let cwd = root.join("project");
-        let home = root.join("home").join(".claw");
+        let home = root.join("home").join(".claude");
        fs::create_dir_all(&home).expect("home config dir");
        fs::create_dir_all(&cwd).expect("project dir");
        fs::write(
--- a/rust/crates/runtime/src/conversation.rs
+++ b/rust/crates/runtime/src/conversation.rs
@@ -156,8 +156,8 @@ where
        mut prompter: Option<&mut dyn PermissionPrompter>,
    ) -> Result<TurnSummary, RuntimeError> {
        self.session
-            .messages
-            .push(ConversationMessage::user_text(user_input.into()));
+            .push_user_text(user_input.into())
+            .map_err(|error| RuntimeError::new(error.to_string()))?;

        let mut assistant_messages = Vec::new();
        let mut tool_results = Vec::new();
@@ -191,7 +191,9 @@ where
                })
                .collect::<Vec<_>>();

-            self.session.messages.push(assistant_message.clone());
+            self.session
+                .push_message(assistant_message.clone())
+                .map_err(|error| RuntimeError::new(error.to_string()))?;
            assistant_messages.push(assistant_message);

            if pending_tool_uses.is_empty() {
@@ -249,7 +251,9 @@ where
                        ConversationMessage::tool_result(tool_use_id, tool_name, reason, true)
                    }
                };
-                self.session.messages.push(result_message.clone());
+                self.session
+                    .push_message(result_message.clone())
+                    .map_err(|error| RuntimeError::new(error.to_string()))?;
                tool_results.push(result_message);
            }
        }
@@ -282,6 +286,11 @@ where
        &self.session
    }

+    #[must_use]
+    pub fn fork_session(&self, branch_name: Option<String>) -> Session {
+        self.session.fork(branch_name)
+    }
+
    #[must_use]
    pub fn into_session(self) -> Session {
        self.session
@@ -408,7 +417,9 @@ mod tests {
    use crate::prompt::{ProjectContext, SystemPromptBuilder};
    use crate::session::{ContentBlock, MessageRole, Session};
    use crate::usage::TokenUsage;
+    use std::fs;
    use std::path::PathBuf;
+    use std::time::{SystemTime, UNIX_EPOCH};

    struct ScriptedApiClient {
        call_count: usize,
@@ -697,7 +708,7 @@ mod tests {
            "post hook should preserve non-error result: {output:?}"
        );
        assert!(
-            output.contains('4'),
+            output.contains("4"),
            "tool output missing value: {output:?}"
        );
        assert!(
@@ -787,6 +798,86 @@ mod tests {
            result.compacted_session.messages[0].role,
            MessageRole::System
        );
+        assert_eq!(
+            result.compacted_session.session_id,
+            runtime.session().session_id
+        );
+        assert!(result.compacted_session.compaction.is_some());
+    }
+
+    #[test]
+    fn persists_conversation_turn_messages_to_jsonl_session() {
+        struct SimpleApi;
+        impl ApiClient for SimpleApi {
+            fn stream(
+                &mut self,
+                _request: ApiRequest,
+            ) -> Result<Vec<AssistantEvent>, RuntimeError> {
+                Ok(vec![
+                    AssistantEvent::TextDelta("done".to_string()),
+                    AssistantEvent::MessageStop,
+                ])
+            }
+        }
+
+        let path = temp_session_path("persisted-turn");
+        let session = Session::new().with_persistence_path(path.clone());
+        let mut runtime = ConversationRuntime::new(
+            session,
+            SimpleApi,
+            StaticToolExecutor::new(),
+            PermissionPolicy::new(PermissionMode::DangerFullAccess),
+            vec!["system".to_string()],
+        );
+
+        runtime
+            .run_turn("persist this turn", None)
+            .expect("turn should succeed");
+
+        let restored = Session::load_from_path(&path).expect("persisted session should reload");
+        fs::remove_file(&path).expect("temp session file should be removable");
+
+        assert_eq!(restored.messages.len(), 2);
+        assert_eq!(restored.messages[0].role, MessageRole::User);
+        assert_eq!(restored.messages[1].role, MessageRole::Assistant);
+        assert_eq!(restored.session_id, runtime.session().session_id);
+    }
+
+    #[test]
+    fn forks_runtime_session_without_mutating_original() {
+        let mut session = Session::new();
+        session
+            .push_user_text("branch me")
+            .expect("message should append");
+
+        let runtime = ConversationRuntime::new(
+            session.clone(),
+            ScriptedApiClient { call_count: 0 },
+            StaticToolExecutor::new(),
+            PermissionPolicy::new(PermissionMode::DangerFullAccess),
+            vec!["system".to_string()],
+        );
+
+        let forked = runtime.fork_session(Some("alt-path".to_string()));
+
+        assert_eq!(forked.messages, session.messages);
+        assert_ne!(forked.session_id, session.session_id);
+        assert_eq!(
+            forked
+                .fork
+                .as_ref()
+                .map(|fork| (fork.parent_session_id.as_str(), fork.branch_name.as_deref())),
+            Some((session.session_id.as_str(), Some("alt-path")))
+        );
+        assert!(runtime.session().fork.is_none());
+    }
+
+    fn temp_session_path(label: &str) -> PathBuf {
+        let nanos = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("system time should be after epoch")
+            .as_nanos();
+        std::env::temp_dir().join(format!("runtime-conversation-{label}-{nanos}.json"))
    }

    #[cfg(windows)]
--- a/rust/crates/runtime/src/hooks.rs
+++ b/rust/crates/runtime/src/hooks.rs
@@ -51,16 +51,6 @@ pub struct HookRunner {
    config: RuntimeHookConfig,
 }

-#[derive(Debug, Clone, Copy)]
-struct HookCommandRequest<'a> {
-    event: HookEvent,
-    tool_name: &'a str,
-    tool_input: &'a str,
-    tool_output: Option<&'a str>,
-    is_error: bool,
-    payload: &'a str,
-}
-
 impl HookRunner {
    #[must_use]
    pub fn new(config: RuntimeHookConfig) -> Self {
@@ -128,16 +118,14 @@ impl HookRunner {
        let mut messages = Vec::new();

        for command in commands {
-            match Self::run_command(
+            match self.run_command(
                command,
-                HookCommandRequest {
-                    event,
-                    tool_name,
-                    tool_input,
-                    tool_output,
-                    is_error,
-                    payload: &payload,
-                },
+                event,
+                tool_name,
+                tool_input,
+                tool_output,
+                is_error,
+                &payload,
            ) {
                HookCommandOutcome::Allow { message } => {
                    if let Some(message) = message {
@@ -161,23 +149,29 @@ impl HookRunner {
        HookRunResult::allow(messages)
    }

-    fn run_command(command: &str, request: HookCommandRequest<'_>) -> HookCommandOutcome {
+    fn run_command(
+        &self,
+        command: &str,
+        event: HookEvent,
+        tool_name: &str,
+        tool_input: &str,
+        tool_output: Option<&str>,
+        is_error: bool,
+        payload: &str,
+    ) -> HookCommandOutcome {
        let mut child = shell_command(command);
        child.stdin(std::process::Stdio::piped());
        child.stdout(std::process::Stdio::piped());
        child.stderr(std::process::Stdio::piped());
-        child.env("HOOK_EVENT", request.event.as_str());
-        child.env("HOOK_TOOL_NAME", request.tool_name);
-        child.env("HOOK_TOOL_INPUT", request.tool_input);
-        child.env(
-            "HOOK_TOOL_IS_ERROR",
-            if request.is_error { "1" } else { "0" },
-        );
-        if let Some(tool_output) = request.tool_output {
+        child.env("HOOK_EVENT", event.as_str());
+        child.env("HOOK_TOOL_NAME", tool_name);
+        child.env("HOOK_TOOL_INPUT", tool_input);
+        child.env("HOOK_TOOL_IS_ERROR", if is_error { "1" } else { "0" });
+        if let Some(tool_output) = tool_output {
            child.env("HOOK_TOOL_OUTPUT", tool_output);
        }

-        match child.output_with_stdin(request.payload.as_bytes()) {
+        match child.output_with_stdin(payload.as_bytes()) {
            Ok(output) => {
                let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
                let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
@@ -195,18 +189,16 @@ impl HookRunner {
                    },
                    None => HookCommandOutcome::Warn {
                        message: format!(
-                            "{} hook `{command}` terminated by signal while handling `{}`",
-                            request.event.as_str(),
-                            request.tool_name
+                            "{} hook `{command}` terminated by signal while handling `{tool_name}`",
+                            event.as_str()
                        ),
                    },
                }
            }
            Err(error) => HookCommandOutcome::Warn {
                message: format!(
-                    "{} hook `{command}` failed to start for `{}`: {error}",
-                    request.event.as_str(),
-                    request.tool_name
+                    "{} hook `{command}` failed to start for `{tool_name}`: {error}",
+                    event.as_str()
                ),
            },
        }
--- a/rust/crates/runtime/src/lib.rs
+++ b/rust/crates/runtime/src/lib.rs
@@ -24,11 +24,11 @@ pub use compact::{
    get_compact_continuation_message, should_compact, CompactionConfig, CompactionResult,
 };
 pub use config::{
-    ConfigEntry, ConfigError, ConfigLoader, ConfigSource, McpManagedProxyServerConfig,
+    ConfigEntry, ConfigError, ConfigLoader, ConfigSource, McpClaudeAiProxyServerConfig,
    McpConfigCollection, McpOAuthConfig, McpRemoteServerConfig, McpSdkServerConfig,
    McpServerConfig, McpStdioServerConfig, McpTransport, McpWebSocketServerConfig, OAuthConfig,
    ResolvedPermissionMode, RuntimeConfig, RuntimeFeatureConfig, RuntimeHookConfig,
-    RuntimePluginConfig, ScopedMcpServerConfig, CLAW_SETTINGS_SCHEMA_NAME,
+    ScopedMcpServerConfig, CLAUDE_CODE_SETTINGS_SCHEMA_NAME,
 };
 pub use conversation::{
    ApiClient, ApiRequest, AssistantEvent, ConversationRuntime, RuntimeError, StaticToolExecutor,
@@ -45,7 +45,7 @@ pub use mcp::{
    scoped_mcp_config_hash, unwrap_ccr_proxy_url,
 };
 pub use mcp_client::{
-    McpManagedProxyTransport, McpClientAuth, McpClientBootstrap, McpClientTransport,
+    McpClaudeAiProxyTransport, McpClientAuth, McpClientBootstrap, McpClientTransport,
    McpRemoteTransport, McpSdkTransport, McpStdioTransport,
 };
 pub use mcp_stdio::{
@@ -76,7 +76,10 @@ 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 session::{ContentBlock, ConversationMessage, MessageRole, Session, SessionError};
+pub use session::{
+    ContentBlock, ConversationMessage, MessageRole, Session, SessionCompaction, SessionError,
+    SessionFork,
+};
 pub use usage::{
    format_usd, pricing_for_model, ModelPricing, TokenUsage, UsageCostEstimate, UsageTracker,
 };
--- a/rust/crates/runtime/src/mcp.rs
+++ b/rust/crates/runtime/src/mcp.rs
@@ -73,7 +73,7 @@ pub fn mcp_server_signature(config: &McpServerConfig) -> Option<String> {
            Some(format!("url:{}", unwrap_ccr_proxy_url(&config.url)))
        }
        McpServerConfig::Ws(config) => Some(format!("url:{}", unwrap_ccr_proxy_url(&config.url))),
-        McpServerConfig::ManagedProxy(config) => {
+        McpServerConfig::ClaudeAiProxy(config) => {
            Some(format!("url:{}", unwrap_ccr_proxy_url(&config.url)))
        }
        McpServerConfig::Sdk(_) => None,
@@ -110,7 +110,7 @@ pub fn scoped_mcp_config_hash(config: &ScopedMcpServerConfig) -> String {
            ws.headers_helper.as_deref().unwrap_or("")
        ),
        McpServerConfig::Sdk(sdk) => format!("sdk|{}", sdk.name),
-        McpServerConfig::ManagedProxy(proxy) => {
+        McpServerConfig::ClaudeAiProxy(proxy) => {
            format!("claudeai-proxy|{}|{}", proxy.url, proxy.id)
        }
    };
--- a/rust/crates/runtime/src/mcp_client.rs
+++ b/rust/crates/runtime/src/mcp_client.rs
@@ -10,7 +10,7 @@ pub enum McpClientTransport {
    Http(McpRemoteTransport),
    WebSocket(McpRemoteTransport),
    Sdk(McpSdkTransport),
-    ManagedProxy(McpManagedProxyTransport),
+    ClaudeAiProxy(McpClaudeAiProxyTransport),
 }

 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -34,7 +34,7 @@ pub struct McpSdkTransport {
 }

 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct McpManagedProxyTransport {
+pub struct McpClaudeAiProxyTransport {
    pub url: String,
    pub id: String,
 }
@@ -97,8 +97,8 @@ impl McpClientTransport {
            McpServerConfig::Sdk(config) => Self::Sdk(McpSdkTransport {
                name: config.name.clone(),
            }),
-            McpServerConfig::ManagedProxy(config) => {
-                Self::ManagedProxy(McpManagedProxyTransport {
+            McpServerConfig::ClaudeAiProxy(config) => {
+                Self::ClaudeAiProxy(McpClaudeAiProxyTransport {
                    url: config.url.clone(),
                    id: config.id.clone(),
                })
--- a/rust/crates/runtime/src/oauth.rs
+++ b/rust/crates/runtime/src/oauth.rs
@@ -324,12 +324,12 @@ fn generate_random_token(bytes: usize) -> io::Result<String> {
 }

 fn credentials_home_dir() -> io::Result<PathBuf> {
-    if let Some(path) = std::env::var_os("CLAW_CONFIG_HOME") {
+    if let Some(path) = std::env::var_os("CLAUDE_CONFIG_HOME") {
        return Ok(PathBuf::from(path));
    }
    let home = std::env::var_os("HOME")
        .ok_or_else(|| io::Error::new(io::ErrorKind::NotFound, "HOME is not set"))?;
-    Ok(PathBuf::from(home).join(".claw"))
+    Ok(PathBuf::from(home).join(".claude"))
 }

 fn read_credentials_root(path: &PathBuf) -> io::Result<Map<String, Value>> {
@@ -541,7 +541,7 @@ mod tests {
    fn oauth_credentials_round_trip_and_clear_preserves_other_fields() {
        let _guard = env_lock();
        let config_home = temp_config_home();
-        std::env::set_var("CLAW_CONFIG_HOME", &config_home);
+        std::env::set_var("CLAUDE_CONFIG_HOME", &config_home);
        let path = credentials_path().expect("credentials path");
        std::fs::create_dir_all(path.parent().expect("parent")).expect("create parent");
        std::fs::write(&path, "{\"other\":\"value\"}\n").expect("seed credentials");
@@ -567,7 +567,7 @@ mod tests {
        assert!(cleared.contains("\"other\": \"value\""));
        assert!(!cleared.contains("\"oauth\""));

-        std::env::remove_var("CLAW_CONFIG_HOME");
+        std::env::remove_var("CLAUDE_CONFIG_HOME");
        std::fs::remove_dir_all(config_home).expect("cleanup temp dir");
    }

--- a/rust/crates/runtime/src/prompt.rs
+++ b/rust/crates/runtime/src/prompt.rs
@@ -203,8 +203,8 @@ fn discover_instruction_files(cwd: &Path) -> std::io::Result<Vec<ContextFile>> {
        for candidate in [
            dir.join("CLAUDE.md"),
            dir.join("CLAUDE.local.md"),
-            dir.join(".claw").join("CLAUDE.md"),
-            dir.join(".claw").join("instructions.md"),
+            dir.join(".claude").join("CLAUDE.md"),
+            dir.join(".claude").join("instructions.md"),
        ] {
            push_context_file(&mut files, candidate)?;
        }
@@ -421,7 +421,7 @@ fn render_config_section(config: &RuntimeConfig) -> String {
    let mut lines = vec!["# Runtime config".to_string()];
    if config.loaded_entries().is_empty() {
        lines.extend(prepend_bullets(vec![
-            "No Claw Code settings files loaded.".to_string()
+            "No Claude Code settings files loaded.".to_string(),
        ]));
        return lines.join("\n");
    }
@@ -517,23 +517,23 @@ mod tests {
    fn discovers_instruction_files_from_ancestor_chain() {
        let root = temp_dir();
        let nested = root.join("apps").join("api");
-        fs::create_dir_all(nested.join(".claw")).expect("nested claw dir");
+        fs::create_dir_all(nested.join(".claude")).expect("nested claude dir");
        fs::write(root.join("CLAUDE.md"), "root instructions").expect("write root instructions");
        fs::write(root.join("CLAUDE.local.md"), "local instructions")
            .expect("write local instructions");
        fs::create_dir_all(root.join("apps")).expect("apps dir");
-        fs::create_dir_all(root.join("apps").join(".claw")).expect("apps claw dir");
+        fs::create_dir_all(root.join("apps").join(".claude")).expect("apps claude dir");
        fs::write(root.join("apps").join("CLAUDE.md"), "apps instructions")
            .expect("write apps instructions");
        fs::write(
-            root.join("apps").join(".claw").join("instructions.md"),
+            root.join("apps").join(".claude").join("instructions.md"),
            "apps dot claude instructions",
        )
        .expect("write apps dot claude instructions");
-        fs::write(nested.join(".claw").join("CLAUDE.md"), "nested rules")
+        fs::write(nested.join(".claude").join("CLAUDE.md"), "nested rules")
            .expect("write nested rules");
        fs::write(
-            nested.join(".claw").join("instructions.md"),
+            nested.join(".claude").join("instructions.md"),
            "nested instructions",
        )
        .expect("write nested instructions");
@@ -593,14 +593,13 @@ mod tests {
    #[test]
    fn displays_context_paths_compactly() {
        assert_eq!(
-            display_context_path(Path::new("/tmp/project/.claw/CLAUDE.md")),
+            display_context_path(Path::new("/tmp/project/.claude/CLAUDE.md")),
            "CLAUDE.md"
        );
    }

    #[test]
    fn discover_with_git_includes_status_snapshot() {
-        let _guard = env_lock();
        let root = temp_dir();
        fs::create_dir_all(&root).expect("root dir");
        std::process::Command::new("git")
@@ -625,7 +624,6 @@ mod tests {

    #[test]
    fn discover_with_git_includes_diff_snapshot_for_tracked_changes() {
-        let _guard = env_lock();
        let root = temp_dir();
        fs::create_dir_all(&root).expect("root dir");
        std::process::Command::new("git")
@@ -669,10 +667,10 @@ mod tests {
    #[test]
    fn load_system_prompt_reads_claude_files_and_config() {
        let root = temp_dir();
-        fs::create_dir_all(root.join(".claw")).expect("claw dir");
+        fs::create_dir_all(root.join(".claude")).expect("claude dir");
        fs::write(root.join("CLAUDE.md"), "Project rules").expect("write instructions");
        fs::write(
-            root.join(".claw").join("settings.json"),
+            root.join(".claude").join("settings.json"),
            r#"{"permissionMode":"acceptEdits"}"#,
        )
        .expect("write settings");
@@ -680,9 +678,9 @@ mod tests {
        let _guard = env_lock();
        let previous = std::env::current_dir().expect("cwd");
        let original_home = std::env::var("HOME").ok();
-        let original_claw_home = std::env::var("CLAW_CONFIG_HOME").ok();
+        let original_claude_home = std::env::var("CLAUDE_CONFIG_HOME").ok();
        std::env::set_var("HOME", &root);
-        std::env::set_var("CLAW_CONFIG_HOME", root.join("missing-home"));
+        std::env::set_var("CLAUDE_CONFIG_HOME", root.join("missing-home"));
        std::env::set_current_dir(&root).expect("change cwd");
        let prompt = super::load_system_prompt(&root, "2026-03-31", "linux", "6.8")
            .expect("system prompt should load")
@@ -697,10 +695,10 @@ mod tests {
        } else {
            std::env::remove_var("HOME");
        }
-        if let Some(value) = original_claw_home {
-            std::env::set_var("CLAW_CONFIG_HOME", value);
+        if let Some(value) = original_claude_home {
+            std::env::set_var("CLAUDE_CONFIG_HOME", value);
        } else {
-            std::env::remove_var("CLAW_CONFIG_HOME");
+            std::env::remove_var("CLAUDE_CONFIG_HOME");
        }

        assert!(prompt.contains("Project rules"));
@@ -711,10 +709,10 @@ mod tests {
    #[test]
    fn renders_claude_code_style_sections_with_project_context() {
        let root = temp_dir();
-        fs::create_dir_all(root.join(".claw")).expect("claw dir");
+        fs::create_dir_all(root.join(".claude")).expect("claude dir");
        fs::write(root.join("CLAUDE.md"), "Project rules").expect("write CLAUDE.md");
        fs::write(
-            root.join(".claw").join("settings.json"),
+            root.join(".claude").join("settings.json"),
            r#"{"permissionMode":"acceptEdits"}"#,
        )
        .expect("write settings");
@@ -753,9 +751,9 @@ mod tests {
    fn discovers_dot_claude_instructions_markdown() {
        let root = temp_dir();
        let nested = root.join("apps").join("api");
-        fs::create_dir_all(nested.join(".claw")).expect("nested claw dir");
+        fs::create_dir_all(nested.join(".claude")).expect("nested claude dir");
        fs::write(
-            nested.join(".claw").join("instructions.md"),
+            nested.join(".claude").join("instructions.md"),
            "instruction markdown",
        )
        .expect("write instructions.md");
@@ -764,7 +762,7 @@ mod tests {
        assert!(context
            .instruction_files
            .iter()
-            .any(|file| file.path.ends_with(".claw/instructions.md")));
+            .any(|file| file.path.ends_with(".claude/instructions.md")));
        assert!(
            render_instruction_files(&context.instruction_files).contains("instruction markdown")
        );
--- a/rust/crates/runtime/src/session.rs
+++ b/rust/crates/runtime/src/session.rs
@@ -1,11 +1,19 @@
 use std::collections::BTreeMap;
 use std::fmt::{Display, Formatter};
-use std::fs;
-use std::path::Path;
+use std::fs::{self, OpenOptions};
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{SystemTime, UNIX_EPOCH};

 use crate::json::{JsonError, JsonValue};
 use crate::usage::TokenUsage;

+const SESSION_VERSION: u32 = 1;
+const ROTATE_AFTER_BYTES: u64 = 256 * 1024;
+const MAX_ROTATED_FILES: usize = 3;
+static SESSION_ID_COUNTER: AtomicU64 = AtomicU64::new(0);
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum MessageRole {
    System,
@@ -40,11 +48,49 @@ pub struct ConversationMessage {
 }

 #[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SessionCompaction {
+    pub count: u32,
+    pub removed_message_count: usize,
+    pub summary: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SessionFork {
+    pub parent_session_id: String,
+    pub branch_name: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct SessionPersistence {
+    path: PathBuf,
+}
+
+#[derive(Debug, Clone)]
 pub struct Session {
    pub version: u32,
+    pub session_id: String,
+    pub created_at_ms: u64,
+    pub updated_at_ms: u64,
    pub messages: Vec<ConversationMessage>,
+    pub compaction: Option<SessionCompaction>,
+    pub fork: Option<SessionFork>,
+    persistence: Option<SessionPersistence>,
 }

+impl PartialEq for Session {
+    fn eq(&self, other: &Self) -> bool {
+        self.version == other.version
+            && self.session_id == other.session_id
+            && self.created_at_ms == other.created_at_ms
+            && self.updated_at_ms == other.updated_at_ms
+            && self.messages == other.messages
+            && self.compaction == other.compaction
+            && self.fork == other.fork
+    }
+}
+
+impl Eq for Session {}
+
 #[derive(Debug)]
 pub enum SessionError {
    Io(std::io::Error),
@@ -79,20 +125,84 @@ impl From<JsonError> for SessionError {
 impl Session {
    #[must_use]
    pub fn new() -> Self {
+        let now = current_time_millis();
        Self {
-            version: 1,
+            version: SESSION_VERSION,
+            session_id: generate_session_id(),
+            created_at_ms: now,
+            updated_at_ms: now,
            messages: Vec::new(),
+            compaction: None,
+            fork: None,
+            persistence: None,
        }
    }

+    #[must_use]
+    pub fn with_persistence_path(mut self, path: impl Into<PathBuf>) -> Self {
+        self.persistence = Some(SessionPersistence { path: path.into() });
+        self
+    }
+
+    #[must_use]
+    pub fn persistence_path(&self) -> Option<&Path> {
+        self.persistence.as_ref().map(|value| value.path.as_path())
+    }
+
    pub fn save_to_path(&self, path: impl AsRef<Path>) -> Result<(), SessionError> {
-        fs::write(path, self.to_json().render())?;
+        let path = path.as_ref();
+        rotate_session_file_if_needed(path)?;
+        write_atomic(path, &self.render_jsonl_snapshot())?;
+        cleanup_rotated_logs(path)?;
        Ok(())
    }

    pub fn load_from_path(path: impl AsRef<Path>) -> Result<Self, SessionError> {
+        let path = path.as_ref();
        let contents = fs::read_to_string(path)?;
-        Self::from_json(&JsonValue::parse(&contents)?)
+        let session = match JsonValue::parse(&contents) {
+            Ok(value) => Self::from_json(&value)?,
+            Err(_) => Self::from_jsonl(&contents)?,
+        };
+        Ok(session.with_persistence_path(path.to_path_buf()))
+    }
+
+    pub fn push_message(&mut self, message: ConversationMessage) -> Result<(), SessionError> {
+        self.touch();
+        self.messages.push(message.clone());
+        self.append_persisted_message(&message)
+    }
+
+    pub fn push_user_text(&mut self, text: impl Into<String>) -> Result<(), SessionError> {
+        self.push_message(ConversationMessage::user_text(text))
+    }
+
+    pub fn record_compaction(&mut self, summary: impl Into<String>, removed_message_count: usize) {
+        self.touch();
+        let count = self.compaction.as_ref().map_or(1, |value| value.count + 1);
+        self.compaction = Some(SessionCompaction {
+            count,
+            removed_message_count,
+            summary: summary.into(),
+        });
+    }
+
+    #[must_use]
+    pub fn fork(&self, branch_name: Option<String>) -> Self {
+        let now = current_time_millis();
+        Self {
+            version: self.version,
+            session_id: generate_session_id(),
+            created_at_ms: now,
+            updated_at_ms: now,
+            messages: self.messages.clone(),
+            compaction: self.compaction.clone(),
+            fork: Some(SessionFork {
+                parent_session_id: self.session_id.clone(),
+                branch_name: normalize_optional_string(branch_name),
+            }),
+            persistence: None,
+        }
    }

    #[must_use]
@@ -102,6 +212,18 @@ impl Session {
            "version".to_string(),
            JsonValue::Number(i64::from(self.version)),
        );
+        object.insert(
+            "session_id".to_string(),
+            JsonValue::String(self.session_id.clone()),
+        );
+        object.insert(
+            "created_at_ms".to_string(),
+            JsonValue::Number(i64_from_u64(self.created_at_ms, "created_at_ms")),
+        );
+        object.insert(
+            "updated_at_ms".to_string(),
+            JsonValue::Number(i64_from_u64(self.updated_at_ms, "updated_at_ms")),
+        );
        object.insert(
            "messages".to_string(),
            JsonValue::Array(
@@ -111,6 +233,12 @@ impl Session {
                    .collect(),
            ),
        );
+        if let Some(compaction) = &self.compaction {
+            object.insert("compaction".to_string(), compaction.to_json());
+        }
+        if let Some(fork) = &self.fork {
+            object.insert("fork".to_string(), fork.to_json());
+        }
        JsonValue::Object(object)
    }

@@ -131,7 +259,179 @@ impl Session {
            .iter()
            .map(ConversationMessage::from_json)
            .collect::<Result<Vec<_>, _>>()?;
-        Ok(Self { version, messages })
+        let now = current_time_millis();
+        let session_id = object
+            .get("session_id")
+            .and_then(JsonValue::as_str)
+            .map(ToOwned::to_owned)
+            .unwrap_or_else(generate_session_id);
+        let created_at_ms = object
+            .get("created_at_ms")
+            .map(|value| required_u64_from_value(value, "created_at_ms"))
+            .transpose()?
+            .unwrap_or(now);
+        let updated_at_ms = object
+            .get("updated_at_ms")
+            .map(|value| required_u64_from_value(value, "updated_at_ms"))
+            .transpose()?
+            .unwrap_or(created_at_ms);
+        let compaction = object
+            .get("compaction")
+            .map(SessionCompaction::from_json)
+            .transpose()?;
+        let fork = object.get("fork").map(SessionFork::from_json).transpose()?;
+        Ok(Self {
+            version,
+            session_id,
+            created_at_ms,
+            updated_at_ms,
+            messages,
+            compaction,
+            fork,
+            persistence: None,
+        })
+    }
+
+    fn from_jsonl(contents: &str) -> Result<Self, SessionError> {
+        let mut version = SESSION_VERSION;
+        let mut session_id = None;
+        let mut created_at_ms = None;
+        let mut updated_at_ms = None;
+        let mut messages = Vec::new();
+        let mut compaction = None;
+        let mut fork = None;
+
+        for (line_number, raw_line) in contents.lines().enumerate() {
+            let line = raw_line.trim();
+            if line.is_empty() {
+                continue;
+            }
+            let value = JsonValue::parse(line).map_err(|error| {
+                SessionError::Format(format!(
+                    "invalid JSONL record at line {}: {}",
+                    line_number + 1,
+                    error
+                ))
+            })?;
+            let object = value.as_object().ok_or_else(|| {
+                SessionError::Format(format!(
+                    "JSONL record at line {} must be an object",
+                    line_number + 1
+                ))
+            })?;
+            match object
+                .get("type")
+                .and_then(JsonValue::as_str)
+                .ok_or_else(|| {
+                    SessionError::Format(format!(
+                        "JSONL record at line {} missing type",
+                        line_number + 1
+                    ))
+                })? {
+                "session_meta" => {
+                    version = required_u32(object, "version")?;
+                    session_id = Some(required_string(object, "session_id")?);
+                    created_at_ms = Some(required_u64(object, "created_at_ms")?);
+                    updated_at_ms = Some(required_u64(object, "updated_at_ms")?);
+                    fork = object.get("fork").map(SessionFork::from_json).transpose()?;
+                }
+                "message" => {
+                    let message_value = object.get("message").ok_or_else(|| {
+                        SessionError::Format(format!(
+                            "JSONL record at line {} missing message",
+                            line_number + 1
+                        ))
+                    })?;
+                    messages.push(ConversationMessage::from_json(message_value)?);
+                }
+                "compaction" => {
+                    compaction = Some(SessionCompaction::from_json(&JsonValue::Object(
+                        object.clone(),
+                    ))?);
+                }
+                other => {
+                    return Err(SessionError::Format(format!(
+                        "unsupported JSONL record type at line {}: {other}",
+                        line_number + 1
+                    )))
+                }
+            }
+        }
+
+        let now = current_time_millis();
+        Ok(Self {
+            version,
+            session_id: session_id.unwrap_or_else(generate_session_id),
+            created_at_ms: created_at_ms.unwrap_or(now),
+            updated_at_ms: updated_at_ms.unwrap_or(created_at_ms.unwrap_or(now)),
+            messages,
+            compaction,
+            fork,
+            persistence: None,
+        })
+    }
+
+    fn render_jsonl_snapshot(&self) -> String {
+        let mut lines = vec![self.meta_record().render()];
+        if let Some(compaction) = &self.compaction {
+            lines.push(compaction.to_jsonl_record().render());
+        }
+        lines.extend(
+            self.messages
+                .iter()
+                .map(|message| message_record(message).render()),
+        );
+        let mut rendered = lines.join("\n");
+        rendered.push('\n');
+        rendered
+    }
+
+    fn append_persisted_message(&self, message: &ConversationMessage) -> Result<(), SessionError> {
+        let Some(path) = self.persistence_path() else {
+            return Ok(());
+        };
+
+        let needs_bootstrap = !path.exists() || fs::metadata(path)?.len() == 0;
+        if needs_bootstrap {
+            self.save_to_path(path)?;
+            return Ok(());
+        }
+
+        let mut file = OpenOptions::new().append(true).open(path)?;
+        writeln!(file, "{}", message_record(message).render())?;
+        Ok(())
+    }
+
+    fn meta_record(&self) -> JsonValue {
+        let mut object = BTreeMap::new();
+        object.insert(
+            "type".to_string(),
+            JsonValue::String("session_meta".to_string()),
+        );
+        object.insert(
+            "version".to_string(),
+            JsonValue::Number(i64::from(self.version)),
+        );
+        object.insert(
+            "session_id".to_string(),
+            JsonValue::String(self.session_id.clone()),
+        );
+        object.insert(
+            "created_at_ms".to_string(),
+            JsonValue::Number(i64_from_u64(self.created_at_ms, "created_at_ms")),
+        );
+        object.insert(
+            "updated_at_ms".to_string(),
+            JsonValue::Number(i64_from_u64(self.updated_at_ms, "updated_at_ms")),
+        );
+        if let Some(fork) = &self.fork {
+            object.insert("fork".to_string(), fork.to_json());
+        }
+        JsonValue::Object(object)
+    }
+
+    fn touch(&mut self) {
+        self.updated_at_ms = current_time_millis();
    }
 }

@@ -324,6 +624,92 @@ impl ContentBlock {
    }
 }

+impl SessionCompaction {
+    #[must_use]
+    pub fn to_json(&self) -> JsonValue {
+        let mut object = BTreeMap::new();
+        object.insert(
+            "count".to_string(),
+            JsonValue::Number(i64::from(self.count)),
+        );
+        object.insert(
+            "removed_message_count".to_string(),
+            JsonValue::Number(i64_from_usize(
+                self.removed_message_count,
+                "removed_message_count",
+            )),
+        );
+        object.insert(
+            "summary".to_string(),
+            JsonValue::String(self.summary.clone()),
+        );
+        JsonValue::Object(object)
+    }
+
+    #[must_use]
+    pub fn to_jsonl_record(&self) -> JsonValue {
+        let mut object = self
+            .to_json()
+            .as_object()
+            .cloned()
+            .expect("compaction should render to object");
+        object.insert(
+            "type".to_string(),
+            JsonValue::String("compaction".to_string()),
+        );
+        JsonValue::Object(object)
+    }
+
+    fn from_json(value: &JsonValue) -> Result<Self, SessionError> {
+        let object = value
+            .as_object()
+            .ok_or_else(|| SessionError::Format("compaction must be an object".to_string()))?;
+        Ok(Self {
+            count: required_u32(object, "count")?,
+            removed_message_count: required_usize(object, "removed_message_count")?,
+            summary: required_string(object, "summary")?,
+        })
+    }
+}
+
+impl SessionFork {
+    #[must_use]
+    pub fn to_json(&self) -> JsonValue {
+        let mut object = BTreeMap::new();
+        object.insert(
+            "parent_session_id".to_string(),
+            JsonValue::String(self.parent_session_id.clone()),
+        );
+        if let Some(branch_name) = &self.branch_name {
+            object.insert(
+                "branch_name".to_string(),
+                JsonValue::String(branch_name.clone()),
+            );
+        }
+        JsonValue::Object(object)
+    }
+
+    fn from_json(value: &JsonValue) -> Result<Self, SessionError> {
+        let object = value
+            .as_object()
+            .ok_or_else(|| SessionError::Format("fork metadata must be an object".to_string()))?;
+        Ok(Self {
+            parent_session_id: required_string(object, "parent_session_id")?,
+            branch_name: object
+                .get("branch_name")
+                .and_then(JsonValue::as_str)
+                .map(ToOwned::to_owned),
+        })
+    }
+}
+
+fn message_record(message: &ConversationMessage) -> JsonValue {
+    let mut object = BTreeMap::new();
+    object.insert("type".to_string(), JsonValue::String("message".to_string()));
+    object.insert("message".to_string(), message.to_json());
+    JsonValue::Object(object)
+}
+
 fn usage_to_json(usage: TokenUsage) -> JsonValue {
    let mut object = BTreeMap::new();
    object.insert(
@@ -376,22 +762,155 @@ fn required_u32(object: &BTreeMap<String, JsonValue>, key: &str) -> Result<u32,
    u32::try_from(value).map_err(|_| SessionError::Format(format!("{key} out of range")))
 }

+fn required_u64(object: &BTreeMap<String, JsonValue>, key: &str) -> Result<u64, SessionError> {
+    let value = object
+        .get(key)
+        .ok_or_else(|| SessionError::Format(format!("missing {key}")))?;
+    required_u64_from_value(value, key)
+}
+
+fn required_u64_from_value(value: &JsonValue, key: &str) -> Result<u64, SessionError> {
+    let value = value
+        .as_i64()
+        .ok_or_else(|| SessionError::Format(format!("missing {key}")))?;
+    u64::try_from(value).map_err(|_| SessionError::Format(format!("{key} out of range")))
+}
+
+fn required_usize(object: &BTreeMap<String, JsonValue>, key: &str) -> Result<usize, SessionError> {
+    let value = object
+        .get(key)
+        .and_then(JsonValue::as_i64)
+        .ok_or_else(|| SessionError::Format(format!("missing {key}")))?;
+    usize::try_from(value).map_err(|_| SessionError::Format(format!("{key} out of range")))
+}
+
+fn i64_from_u64(value: u64, key: &str) -> i64 {
+    i64::try_from(value).unwrap_or_else(|_| panic!("{key} out of range for JSON number"))
+}
+
+fn i64_from_usize(value: usize, key: &str) -> i64 {
+    i64::try_from(value).unwrap_or_else(|_| panic!("{key} out of range for JSON number"))
+}
+
+fn normalize_optional_string(value: Option<String>) -> Option<String> {
+    value.and_then(|value| {
+        let trimmed = value.trim();
+        if trimmed.is_empty() {
+            None
+        } else {
+            Some(trimmed.to_string())
+        }
+    })
+}
+
+fn current_time_millis() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|duration| duration.as_millis() as u64)
+        .unwrap_or_default()
+}
+
+fn generate_session_id() -> String {
+    let millis = current_time_millis();
+    let counter = SESSION_ID_COUNTER.fetch_add(1, Ordering::Relaxed);
+    format!("session-{millis}-{counter}")
+}
+
+fn write_atomic(path: &Path, contents: &str) -> Result<(), SessionError> {
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+    let temp_path = temporary_path_for(path);
+    fs::write(&temp_path, contents)?;
+    fs::rename(temp_path, path)?;
+    Ok(())
+}
+
+fn temporary_path_for(path: &Path) -> PathBuf {
+    let file_name = path
+        .file_name()
+        .and_then(|value| value.to_str())
+        .unwrap_or("session");
+    path.with_file_name(format!(
+        "{file_name}.tmp-{}-{}",
+        current_time_millis(),
+        SESSION_ID_COUNTER.fetch_add(1, Ordering::Relaxed)
+    ))
+}
+
+fn rotate_session_file_if_needed(path: &Path) -> Result<(), SessionError> {
+    let Ok(metadata) = fs::metadata(path) else {
+        return Ok(());
+    };
+    if metadata.len() < ROTATE_AFTER_BYTES {
+        return Ok(());
+    }
+    let rotated_path = rotated_log_path(path);
+    fs::rename(path, rotated_path)?;
+    Ok(())
+}
+
+fn rotated_log_path(path: &Path) -> PathBuf {
+    let stem = path
+        .file_stem()
+        .and_then(|value| value.to_str())
+        .unwrap_or("session");
+    path.with_file_name(format!("{stem}.rot-{}.jsonl", current_time_millis()))
+}
+
+fn cleanup_rotated_logs(path: &Path) -> Result<(), SessionError> {
+    let Some(parent) = path.parent() else {
+        return Ok(());
+    };
+    let stem = path
+        .file_stem()
+        .and_then(|value| value.to_str())
+        .unwrap_or("session");
+    let prefix = format!("{stem}.rot-");
+    let mut rotated_paths = fs::read_dir(parent)?
+        .filter_map(Result::ok)
+        .map(|entry| entry.path())
+        .filter(|entry_path| {
+            entry_path
+                .file_name()
+                .and_then(|value| value.to_str())
+                .is_some_and(|name| name.starts_with(&prefix) && name.ends_with(".jsonl"))
+        })
+        .collect::<Vec<_>>();
+
+    rotated_paths.sort_by_key(|entry_path| {
+        fs::metadata(entry_path)
+            .and_then(|metadata| metadata.modified())
+            .unwrap_or(UNIX_EPOCH)
+    });
+
+    let remove_count = rotated_paths.len().saturating_sub(MAX_ROTATED_FILES);
+    for stale_path in rotated_paths.into_iter().take(remove_count) {
+        fs::remove_file(stale_path)?;
+    }
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
-    use super::{ContentBlock, ConversationMessage, MessageRole, Session};
+    use super::{
+        cleanup_rotated_logs, rotate_session_file_if_needed, ContentBlock, ConversationMessage,
+        MessageRole, Session, SessionFork,
+    };
+    use crate::json::JsonValue;
    use crate::usage::TokenUsage;
    use std::fs;
+    use std::path::PathBuf;
    use std::time::{SystemTime, UNIX_EPOCH};

    #[test]
-    fn persists_and_restores_session_json() {
+    fn persists_and_restores_session_jsonl() {
        let mut session = Session::new();
        session
-            .messages
-            .push(ConversationMessage::user_text("hello"));
+            .push_user_text("hello")
+            .expect("user message should append");
        session
-            .messages
-            .push(ConversationMessage::assistant_with_usage(
+            .push_message(ConversationMessage::assistant_with_usage(
                vec![
                    ContentBlock::Text {
                        text: "thinking".to_string(),
@@ -408,16 +927,15 @@ mod tests {
                    cache_creation_input_tokens: 1,
                    cache_read_input_tokens: 2,
                }),
-            ));
-        session.messages.push(ConversationMessage::tool_result(
-            "tool-1", "bash", "hi", false,
-        ));
+            ))
+            .expect("assistant message should append");
+        session
+            .push_message(ConversationMessage::tool_result(
+                "tool-1", "bash", "hi", false,
+            ))
+            .expect("tool result should append");

-        let nanos = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .expect("system time should be after epoch")
-            .as_nanos();
-        let path = std::env::temp_dir().join(format!("runtime-session-{nanos}.json"));
+        let path = temp_session_path("jsonl");
        session.save_to_path(&path).expect("session should save");
        let restored = Session::load_from_path(&path).expect("session should load");
        fs::remove_file(&path).expect("temp file should be removable");
@@ -428,5 +946,157 @@ mod tests {
            restored.messages[1].usage.expect("usage").total_tokens(),
            17
        );
+        assert_eq!(restored.session_id, session.session_id);
+    }
+
+    #[test]
+    fn loads_legacy_session_json_object() {
+        let path = temp_session_path("legacy");
+        let legacy = JsonValue::Object(
+            [
+                ("version".to_string(), JsonValue::Number(1)),
+                (
+                    "messages".to_string(),
+                    JsonValue::Array(vec![ConversationMessage::user_text("legacy").to_json()]),
+                ),
+            ]
+            .into_iter()
+            .collect(),
+        );
+        fs::write(&path, legacy.render()).expect("legacy file should write");
+
+        let restored = Session::load_from_path(&path).expect("legacy session should load");
+        fs::remove_file(&path).expect("temp file should be removable");
+
+        assert_eq!(restored.messages.len(), 1);
+        assert_eq!(
+            restored.messages[0],
+            ConversationMessage::user_text("legacy")
+        );
+        assert!(!restored.session_id.is_empty());
+    }
+
+    #[test]
+    fn appends_messages_to_persisted_jsonl_session() {
+        let path = temp_session_path("append");
+        let mut session = Session::new().with_persistence_path(path.clone());
+        session
+            .save_to_path(&path)
+            .expect("initial save should succeed");
+        session
+            .push_user_text("hi")
+            .expect("user append should succeed");
+        session
+            .push_message(ConversationMessage::assistant(vec![ContentBlock::Text {
+                text: "hello".to_string(),
+            }]))
+            .expect("assistant append should succeed");
+
+        let restored = Session::load_from_path(&path).expect("session should replay from jsonl");
+        fs::remove_file(&path).expect("temp file should be removable");
+
+        assert_eq!(restored.messages.len(), 2);
+        assert_eq!(restored.messages[0], ConversationMessage::user_text("hi"));
+    }
+
+    #[test]
+    fn persists_compaction_metadata() {
+        let path = temp_session_path("compaction");
+        let mut session = Session::new();
+        session
+            .push_user_text("before")
+            .expect("message should append");
+        session.record_compaction("summarized earlier work", 4);
+        session.save_to_path(&path).expect("session should save");
+
+        let restored = Session::load_from_path(&path).expect("session should load");
+        fs::remove_file(&path).expect("temp file should be removable");
+
+        let compaction = restored.compaction.expect("compaction metadata");
+        assert_eq!(compaction.count, 1);
+        assert_eq!(compaction.removed_message_count, 4);
+        assert!(compaction.summary.contains("summarized"));
+    }
+
+    #[test]
+    fn forks_sessions_with_branch_metadata_and_persists_it() {
+        let path = temp_session_path("fork");
+        let mut session = Session::new();
+        session
+            .push_user_text("before fork")
+            .expect("message should append");
+
+        let forked = session
+            .fork(Some("investigation".to_string()))
+            .with_persistence_path(path.clone());
+        forked
+            .save_to_path(&path)
+            .expect("forked session should save");
+
+        let restored = Session::load_from_path(&path).expect("forked session should load");
+        fs::remove_file(&path).expect("temp file should be removable");
+
+        assert_ne!(restored.session_id, session.session_id);
+        assert_eq!(
+            restored.fork,
+            Some(SessionFork {
+                parent_session_id: session.session_id,
+                branch_name: Some("investigation".to_string()),
+            })
+        );
+        assert_eq!(restored.messages, forked.messages);
+    }
+
+    #[test]
+    fn rotates_and_cleans_up_large_session_logs() {
+        let path = temp_session_path("rotation");
+        fs::write(&path, "x".repeat((super::ROTATE_AFTER_BYTES + 10) as usize))
+            .expect("oversized file should write");
+        rotate_session_file_if_needed(&path).expect("rotation should succeed");
+        assert!(
+            !path.exists(),
+            "original path should be rotated away before rewrite"
+        );
+
+        for _ in 0..5 {
+            let rotated = super::rotated_log_path(&path);
+            fs::write(&rotated, "old").expect("rotated file should write");
+        }
+        cleanup_rotated_logs(&path).expect("cleanup should succeed");
+
+        let rotated_count = rotation_files(&path).len();
+        assert!(rotated_count <= super::MAX_ROTATED_FILES);
+        for rotated in rotation_files(&path) {
+            fs::remove_file(rotated).expect("rotated file should be removable");
+        }
+    }
+
+    fn temp_session_path(label: &str) -> PathBuf {
+        let nanos = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("system time should be after epoch")
+            .as_nanos();
+        std::env::temp_dir().join(format!("runtime-session-{label}-{nanos}.json"))
+    }
+
+    fn rotation_files(path: &PathBuf) -> Vec<PathBuf> {
+        let stem = path
+            .file_stem()
+            .and_then(|value| value.to_str())
+            .expect("temp path should have file stem")
+            .to_string();
+        fs::read_dir(path.parent().expect("temp path should have parent"))
+            .expect("temp dir should read")
+            .filter_map(Result::ok)
+            .map(|entry| entry.path())
+            .filter(|entry_path| {
+                entry_path
+                    .file_name()
+                    .and_then(|value| value.to_str())
+                    .is_some_and(|name| {
+                        name.starts_with(&format!("{stem}.rot-")) && name.ends_with(".jsonl")
+                    })
+            })
+            .collect()
    }
 }
--- a/rust/crates/runtime/src/usage.rs
+++ b/rust/crates/runtime/src/usage.rs
@@ -286,21 +286,19 @@ mod tests {

    #[test]
    fn reconstructs_usage_from_session_messages() {
-        let session = Session {
-            version: 1,
-            messages: vec![ConversationMessage {
-                role: MessageRole::Assistant,
-                blocks: vec![ContentBlock::Text {
-                    text: "done".to_string(),
-                }],
-                usage: Some(TokenUsage {
-                    input_tokens: 5,
-                    output_tokens: 2,
-                    cache_creation_input_tokens: 1,
-                    cache_read_input_tokens: 0,
-                }),
+        let mut session = Session::new();
+        session.messages = vec![ConversationMessage {
+            role: MessageRole::Assistant,
+            blocks: vec![ContentBlock::Text {
+                text: "done".to_string(),
            }],
-        };
+            usage: Some(TokenUsage {
+                input_tokens: 5,
+                output_tokens: 2,
+                cache_creation_input_tokens: 1,
+                cache_read_input_tokens: 0,
+            }),
+        }];

        let tracker = UsageTracker::from_session(&session);
        assert_eq!(tracker.turns(), 1);
--- a/rust/crates/rusty-claude-cli/Cargo.toml
+++ b/rust/crates/rusty-claude-cli/Cargo.toml
@@ -17,8 +17,7 @@ crossterm = "0.28"
 pulldown-cmark = "0.13"
 rustyline = "15"
 runtime = { path = "../runtime" }
-plugins = { path = "../plugins" }
-serde_json.workspace = true
+serde_json = "1"
 syntect = "5"
 tokio = { version = "1", features = ["rt-multi-thread", "time"] }
 tools = { path = "../tools" }
--- a/rust/crates/rusty-claude-cli/src/init.rs
+++ b/rust/crates/rusty-claude-cli/src/init.rs
@@ -8,7 +8,7 @@ const STARTER_CLAUDE_JSON: &str = concat!(
    "  }\n",
    "}\n",
 );
-const GITIGNORE_COMMENT: &str = "# Claw Code local artifacts";
+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)]
@@ -164,7 +164,7 @@ pub(crate) fn render_init_claude_md(cwd: &Path) -> String {
    let mut lines = vec![
        "# CLAUDE.md".to_string(),
        String::new(),
-        "This file provides guidance to Claw Code (clawcode.dev) when working with code in this repository.".to_string(),
+        "This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.".to_string(),
        String::new(),
    ];

--- a/rust/crates/rusty-claude-cli/src/main.rs
+++ b/rust/crates/rusty-claude-cli/src/main.rs
--- a/rust/crates/rusty-claude-cli/src/render.rs
+++ b/rust/crates/rusty-claude-cli/src/render.rs
@@ -286,7 +286,7 @@ impl TerminalRenderer {
    ) {
        match event {
            Event::Start(Tag::Heading { level, .. }) => {
-                self.start_heading(state, level as u8, output);
+                self.start_heading(state, level as u8, output)
            }
            Event::End(TagEnd::Paragraph) => output.push_str("\n\n"),
            Event::Start(Tag::BlockQuote(..)) => self.start_quote(state, output),
@@ -426,7 +426,6 @@ impl TerminalRenderer {
        }
    }

-    #[allow(clippy::unused_self)]
    fn start_heading(&self, state: &mut RenderState, level: u8, output: &mut String) {
        state.heading_level = Some(level);
        if !output.is_empty() {
--- a/rust/crates/tools/Cargo.toml
+++ b/rust/crates/tools/Cargo.toml
@@ -7,11 +7,10 @@ publish.workspace = true

 [dependencies]
 api = { path = "../api" }
-plugins = { path = "../plugins" }
 runtime = { path = "../runtime" }
 reqwest = { version = "0.12", default-features = false, features = ["blocking", "rustls-tls"] }
 serde = { version = "1", features = ["derive"] }
-serde_json.workspace = true
+serde_json = "1"
 tokio = { version = "1", features = ["rt-multi-thread"] }

 [lints]
--- a/rust/crates/tools/src/lib.rs
+++ b/rust/crates/tools/src/lib.rs
@@ -4,11 +4,10 @@ use std::process::Command;
 use std::time::{Duration, Instant};

 use api::{
-    max_tokens_for_model, resolve_model_alias, ContentBlockDelta, InputContentBlock, InputMessage,
-    MessageRequest, MessageResponse, OutputContentBlock, ProviderClient,
-    StreamEvent as ApiStreamEvent, ToolChoice, ToolDefinition, ToolResultContentBlock,
+    read_base_url, AnthropicClient, ContentBlockDelta, InputContentBlock, InputMessage,
+    MessageRequest, MessageResponse, OutputContentBlock, StreamEvent as ApiStreamEvent, ToolChoice,
+    ToolDefinition, ToolResultContentBlock,
 };
-use plugins::PluginTool;
 use reqwest::blocking::Client;
 use runtime::{
    edit_file, execute_bash, glob_search, grep_search, load_system_prompt, read_file, write_file,
@@ -56,161 +55,6 @@ pub struct ToolSpec {
    pub required_permission: PermissionMode,
 }

-#[derive(Debug, Clone, PartialEq)]
-pub struct GlobalToolRegistry {
-    plugin_tools: Vec<PluginTool>,
-}
-
-impl GlobalToolRegistry {
-    #[must_use]
-    pub fn builtin() -> Self {
-        Self {
-            plugin_tools: Vec::new(),
-        }
-    }
-
-    pub fn with_plugin_tools(plugin_tools: Vec<PluginTool>) -> Result<Self, String> {
-        let builtin_names = mvp_tool_specs()
-            .into_iter()
-            .map(|spec| spec.name.to_string())
-            .collect::<BTreeSet<_>>();
-        let mut seen_plugin_names = BTreeSet::new();
-
-        for tool in &plugin_tools {
-            let name = tool.definition().name.clone();
-            if builtin_names.contains(&name) {
-                return Err(format!(
-                    "plugin tool `{name}` conflicts with a built-in tool name"
-                ));
-            }
-            if !seen_plugin_names.insert(name.clone()) {
-                return Err(format!("duplicate plugin tool name `{name}`"));
-            }
-        }
-
-        Ok(Self { plugin_tools })
-    }
-
-    pub fn normalize_allowed_tools(&self, values: &[String]) -> Result<Option<BTreeSet<String>>, String> {
-        if values.is_empty() {
-            return Ok(None);
-        }
-
-        let builtin_specs = mvp_tool_specs();
-        let canonical_names = builtin_specs
-            .iter()
-            .map(|spec| spec.name.to_string())
-            .chain(self.plugin_tools.iter().map(|tool| tool.definition().name.clone()))
-            .collect::<Vec<_>>();
-        let mut name_map = canonical_names
-            .iter()
-            .map(|name| (normalize_tool_name(name), name.clone()))
-            .collect::<BTreeMap<_, _>>();
-
-        for (alias, canonical) in [
-            ("read", "read_file"),
-            ("write", "write_file"),
-            ("edit", "edit_file"),
-            ("glob", "glob_search"),
-            ("grep", "grep_search"),
-        ] {
-            name_map.insert(alias.to_string(), canonical.to_string());
-        }
-
-        let mut allowed = BTreeSet::new();
-        for value in values {
-            for token in value
-                .split(|ch: char| ch == ',' || ch.is_whitespace())
-                .filter(|token| !token.is_empty())
-            {
-                let normalized = normalize_tool_name(token);
-                let canonical = name_map.get(&normalized).ok_or_else(|| {
-                    format!(
-                        "unsupported tool in --allowedTools: {token} (expected one of: {})",
-                        canonical_names.join(", ")
-                    )
-                })?;
-                allowed.insert(canonical.clone());
-            }
-        }
-
-        Ok(Some(allowed))
-    }
-
-    #[must_use]
-    pub fn definitions(&self, allowed_tools: Option<&BTreeSet<String>>) -> Vec<ToolDefinition> {
-        let builtin = mvp_tool_specs()
-            .into_iter()
-            .filter(|spec| allowed_tools.is_none_or(|allowed| allowed.contains(spec.name)))
-            .map(|spec| ToolDefinition {
-                name: spec.name.to_string(),
-                description: Some(spec.description.to_string()),
-                input_schema: spec.input_schema,
-            });
-        let plugin = self
-            .plugin_tools
-            .iter()
-            .filter(|tool| {
-                allowed_tools.is_none_or(|allowed| allowed.contains(tool.definition().name.as_str()))
-            })
-            .map(|tool| ToolDefinition {
-                name: tool.definition().name.clone(),
-                description: tool.definition().description.clone(),
-                input_schema: tool.definition().input_schema.clone(),
-            });
-        builtin.chain(plugin).collect()
-    }
-
-    #[must_use]
-    pub fn permission_specs(
-        &self,
-        allowed_tools: Option<&BTreeSet<String>>,
-    ) -> Vec<(String, PermissionMode)> {
-        let builtin = mvp_tool_specs()
-            .into_iter()
-            .filter(|spec| allowed_tools.is_none_or(|allowed| allowed.contains(spec.name)))
-            .map(|spec| (spec.name.to_string(), spec.required_permission));
-        let plugin = self
-            .plugin_tools
-            .iter()
-            .filter(|tool| {
-                allowed_tools.is_none_or(|allowed| allowed.contains(tool.definition().name.as_str()))
-            })
-            .map(|tool| {
-                (
-                    tool.definition().name.clone(),
-                    permission_mode_from_plugin(tool.required_permission()),
-                )
-            });
-        builtin.chain(plugin).collect()
-    }
-
-    pub fn execute(&self, name: &str, input: &Value) -> Result<String, String> {
-        if mvp_tool_specs().iter().any(|spec| spec.name == name) {
-            return execute_tool(name, input);
-        }
-        self.plugin_tools
-            .iter()
-            .find(|tool| tool.definition().name == name)
-            .ok_or_else(|| format!("unsupported tool: {name}"))?
-            .execute(input)
-            .map_err(|error| error.to_string())
-    }
-}
-
-fn normalize_tool_name(value: &str) -> String {
-    value.trim().replace('-', "_").to_ascii_lowercase()
-}
-
-fn permission_mode_from_plugin(value: &str) -> PermissionMode {
-    match value {
-        "read-only" => PermissionMode::ReadOnly,
-        "workspace-write" => PermissionMode::WorkspaceWrite,
-        "danger-full-access" => PermissionMode::DangerFullAccess,
-        other => panic!("unsupported plugin permission: {other}"),
-    }
-}
-
 #[must_use]
 #[allow(clippy::too_many_lines)]
 pub fn mvp_tool_specs() -> Vec<ToolSpec> {
@@ -1464,12 +1308,6 @@ fn resolve_skill_path(skill: &str) -> Result<std::path::PathBuf, String> {
    if let Ok(codex_home) = std::env::var("CODEX_HOME") {
        candidates.push(std::path::PathBuf::from(codex_home).join("skills"));
    }
-    if let Ok(home) = std::env::var("HOME") {
-        let home = std::path::PathBuf::from(home);
-        candidates.push(home.join(".agents").join("skills"));
-        candidates.push(home.join(".config").join("opencode").join("skills"));
-        candidates.push(home.join(".codex").join("skills"));
-    }
    candidates.push(std::path::PathBuf::from("/home/bellman/.codex/skills"));

    for root in candidates {
@@ -1621,14 +1459,14 @@ fn run_agent_job(job: &AgentJob) -> Result<(), String> {

 fn build_agent_runtime(
    job: &AgentJob,
-) -> Result<ConversationRuntime<ProviderRuntimeClient, SubagentToolExecutor>, String> {
+) -> Result<ConversationRuntime<AnthropicRuntimeClient, SubagentToolExecutor>, String> {
    let model = job
        .manifest
        .model
        .clone()
        .unwrap_or_else(|| DEFAULT_AGENT_MODEL.to_string());
    let allowed_tools = job.allowed_tools.clone();
-    let api_client = ProviderRuntimeClient::new(model, allowed_tools.clone())?;
+    let api_client = AnthropicRuntimeClient::new(model, allowed_tools.clone())?;
    let tool_executor = SubagentToolExecutor::new(allowed_tools);
    Ok(ConversationRuntime::new(
        Session::new(),
@@ -1699,7 +1537,7 @@ fn allowed_tools_for_subagent(subagent_type: &str) -> BTreeSet<String> {
            "SendUserMessage",
            "PowerShell",
        ],
-        "claw-guide" => vec![
+        "claude-code-guide" => vec![
            "read_file",
            "glob_search",
            "grep_search",
@@ -1797,17 +1635,18 @@ fn format_agent_terminal_output(status: &str, result: Option<&str>, error: Optio
    sections.join("")
 }

-struct ProviderRuntimeClient {
+struct AnthropicRuntimeClient {
    runtime: tokio::runtime::Runtime,
-    client: ProviderClient,
+    client: AnthropicClient,
    model: String,
    allowed_tools: BTreeSet<String>,
 }

-impl ProviderRuntimeClient {
+impl AnthropicRuntimeClient {
    fn new(model: String, allowed_tools: BTreeSet<String>) -> Result<Self, String> {
-        let model = resolve_model_alias(&model).to_string();
-        let client = ProviderClient::from_model(&model).map_err(|error| error.to_string())?;
+        let client = AnthropicClient::from_env()
+            .map_err(|error| error.to_string())?
+            .with_base_url(read_base_url());
        Ok(Self {
            runtime: tokio::runtime::Runtime::new().map_err(|error| error.to_string())?,
            client,
@@ -1817,7 +1656,7 @@ impl ProviderRuntimeClient {
    }
 }

-impl ApiClient for ProviderRuntimeClient {
+impl ApiClient for AnthropicRuntimeClient {
    fn stream(&mut self, request: ApiRequest) -> Result<Vec<AssistantEvent>, RuntimeError> {
        let tools = tool_specs_for_allowed_tools(Some(&self.allowed_tools))
            .into_iter()
@@ -1829,7 +1668,7 @@ impl ApiClient for ProviderRuntimeClient {
            .collect::<Vec<_>>();
        let message_request = MessageRequest {
            model: self.model.clone(),
-            max_tokens: max_tokens_for_model(&self.model),
+            max_tokens: 32_000,
            messages: convert_messages(&request.messages),
            system: (!request.system_prompt.is_empty()).then(|| request.system_prompt.join("\n\n")),
            tools: (!tools.is_empty()).then_some(tools),
@@ -1844,7 +1683,7 @@ impl ApiClient for ProviderRuntimeClient {
                .await
                .map_err(|error| RuntimeError::new(error.to_string()))?;
            let mut events = Vec::new();
-            let mut pending_tools: BTreeMap<u32, (String, String, String)> = BTreeMap::new();
+            let mut pending_tool: Option<(String, String, String)> = None;
            let mut saw_stop = false;

            while let Some(event) = stream
@@ -1855,15 +1694,14 @@ impl ApiClient for ProviderRuntimeClient {
                match event {
                    ApiStreamEvent::MessageStart(start) => {
                        for block in start.message.content {
-                            push_output_block(block, 0, &mut events, &mut pending_tools, true);
+                            push_output_block(block, &mut events, &mut pending_tool, true);
                        }
                    }
                    ApiStreamEvent::ContentBlockStart(start) => {
                        push_output_block(
                            start.content_block,
-                            start.index,
                            &mut events,
-                            &mut pending_tools,
+                            &mut pending_tool,
                            true,
                        );
                    }
@@ -1874,15 +1712,13 @@ impl ApiClient for ProviderRuntimeClient {
                            }
                        }
                        ContentBlockDelta::InputJsonDelta { partial_json } => {
-                            if let Some((_, _, input)) = pending_tools.get_mut(&delta.index) {
+                            if let Some((_, _, input)) = &mut pending_tool {
                                input.push_str(&partial_json);
                            }
                        }
-                        ContentBlockDelta::ThinkingDelta { .. }
-                        | ContentBlockDelta::SignatureDelta { .. } => {}
                    },
-                    ApiStreamEvent::ContentBlockStop(stop) => {
-                        if let Some((id, name, input)) = pending_tools.remove(&stop.index) {
+                    ApiStreamEvent::ContentBlockStop(_) => {
+                        if let Some((id, name, input)) = pending_tool.take() {
                            events.push(AssistantEvent::ToolUse { id, name, input });
                        }
                    }
@@ -2003,9 +1839,8 @@ fn convert_messages(messages: &[ConversationMessage]) -> Vec<InputMessage> {

 fn push_output_block(
    block: OutputContentBlock,
-    block_index: u32,
    events: &mut Vec<AssistantEvent>,
-    pending_tools: &mut BTreeMap<u32, (String, String, String)>,
+    pending_tool: &mut Option<(String, String, String)>,
    streaming_tool_input: bool,
 ) {
    match block {
@@ -2023,20 +1858,18 @@ fn push_output_block(
            } else {
                input.to_string()
            };
-            pending_tools.insert(block_index, (id, name, initial_input));
+            *pending_tool = Some((id, name, initial_input));
        }
-        OutputContentBlock::Thinking { .. } | OutputContentBlock::RedactedThinking { .. } => {}
    }
 }

 fn response_to_events(response: MessageResponse) -> Vec<AssistantEvent> {
    let mut events = Vec::new();
-    let mut pending_tools = BTreeMap::new();
+    let mut pending_tool = None;

-    for (index, block) in response.content.into_iter().enumerate() {
-        let index = u32::try_from(index).expect("response block index overflow");
-        push_output_block(block, index, &mut events, &mut pending_tools, false);
-        if let Some((id, name, input)) = pending_tools.remove(&index) {
+    for block in response.content {
+        push_output_block(block, &mut events, &mut pending_tool, false);
+        if let Some((id, name, input)) = pending_tool.take() {
            events.push(AssistantEvent::ToolUse { id, name, input });
        }
    }
@@ -2254,7 +2087,7 @@ fn normalize_subagent_type(subagent_type: Option<&str>) -> String {
        "verification" | "verificationagent" | "verify" | "verifier" => {
            String::from("Verification")
        }
-        "clawguide" | "clawguideagent" | "guide" => String::from("claw-guide"),
+        "claudecodeguide" | "claudecodeguideagent" | "guide" => String::from("claude-code-guide"),
        "statusline" | "statuslinesetup" => String::from("statusline-setup"),
        _ => trimmed.to_string(),
    }
@@ -2754,16 +2587,16 @@ fn config_file_for_scope(scope: ConfigScope) -> Result<PathBuf, String> {
    let cwd = std::env::current_dir().map_err(|error| error.to_string())?;
    Ok(match scope {
        ConfigScope::Global => config_home_dir()?.join("settings.json"),
-        ConfigScope::Settings => cwd.join(".claw").join("settings.local.json"),
+        ConfigScope::Settings => cwd.join(".claude").join("settings.local.json"),
    })
 }

 fn config_home_dir() -> Result<PathBuf, String> {
-    if let Ok(path) = std::env::var("CLAW_CONFIG_HOME") {
+    if let Ok(path) = std::env::var("CLAUDE_CONFIG_HOME") {
        return Ok(PathBuf::from(path));
    }
    let home = std::env::var("HOME").map_err(|_| String::from("HOME is not set"))?;
-    Ok(PathBuf::from(home).join(".claw"))
+    Ok(PathBuf::from(home).join(".claude"))
 }

 fn read_json_object(path: &Path) -> Result<serde_json::Map<String, Value>, String> {
@@ -3060,7 +2893,6 @@ fn parse_skill_description(contents: &str) -> Option<String> {

 #[cfg(test)]
 mod tests {
-    use std::collections::BTreeMap;
    use std::collections::BTreeSet;
    use std::fs;
    use std::io::{Read, Write};
@@ -3073,9 +2905,8 @@ mod tests {
    use super::{
        agent_permission_policy, allowed_tools_for_subagent, execute_agent_with_spawn,
        execute_tool, final_assistant_text, mvp_tool_specs, persist_agent_terminal_state,
-        push_output_block, AgentInput, AgentJob, SubagentToolExecutor,
+        AgentInput, AgentJob, SubagentToolExecutor,
    };
-    use api::OutputContentBlock;
    use runtime::{ApiRequest, AssistantEvent, ConversationRuntime, RuntimeError, Session};
    use serde_json::json;

@@ -3290,63 +3121,6 @@ mod tests {
        assert!(error.contains("relative URL without a base") || error.contains("empty host"));
    }

-    #[test]
-    fn pending_tools_preserve_multiple_streaming_tool_calls_by_index() {
-        let mut events = Vec::new();
-        let mut pending_tools = BTreeMap::new();
-
-        push_output_block(
-            OutputContentBlock::ToolUse {
-                id: "tool-1".to_string(),
-                name: "read_file".to_string(),
-                input: json!({}),
-            },
-            1,
-            &mut events,
-            &mut pending_tools,
-            true,
-        );
-        push_output_block(
-            OutputContentBlock::ToolUse {
-                id: "tool-2".to_string(),
-                name: "grep_search".to_string(),
-                input: json!({}),
-            },
-            2,
-            &mut events,
-            &mut pending_tools,
-            true,
-        );
-
-        pending_tools
-            .get_mut(&1)
-            .expect("first tool pending")
-            .2
-            .push_str("{\"path\":\"src/main.rs\"}");
-        pending_tools
-            .get_mut(&2)
-            .expect("second tool pending")
-            .2
-            .push_str("{\"pattern\":\"TODO\"}");
-
-        assert_eq!(
-            pending_tools.remove(&1),
-            Some((
-                "tool-1".to_string(),
-                "read_file".to_string(),
-                "{\"path\":\"src/main.rs\"}".to_string(),
-            ))
-        );
-        assert_eq!(
-            pending_tools.remove(&2),
-            Some((
-                "tool-2".to_string(),
-                "grep_search".to_string(),
-                "{\"pattern\":\"TODO\"}".to_string(),
-            ))
-        );
-    }
-
    #[test]
    fn todo_write_persists_and_returns_previous_state() {
        let _guard = env_lock()
@@ -4208,19 +3982,19 @@ mod tests {
        ));
        let home = root.join("home");
        let cwd = root.join("cwd");
-        std::fs::create_dir_all(home.join(".claw")).expect("home dir");
-        std::fs::create_dir_all(cwd.join(".claw")).expect("cwd dir");
+        std::fs::create_dir_all(home.join(".claude")).expect("home dir");
+        std::fs::create_dir_all(cwd.join(".claude")).expect("cwd dir");
        std::fs::write(
-            home.join(".claw").join("settings.json"),
+            home.join(".claude").join("settings.json"),
            r#"{"verbose":false}"#,
        )
        .expect("write global settings");

        let original_home = std::env::var("HOME").ok();
-        let original_config_home = std::env::var("CLAW_CONFIG_HOME").ok();
+        let original_claude_home = std::env::var("CLAUDE_CONFIG_HOME").ok();
        let original_dir = std::env::current_dir().expect("cwd");
        std::env::set_var("HOME", &home);
-        std::env::remove_var("CLAW_CONFIG_HOME");
+        std::env::remove_var("CLAUDE_CONFIG_HOME");
        std::env::set_current_dir(&cwd).expect("set cwd");

        let get = execute_tool("Config", &json!({"setting": "verbose"})).expect("get config");
@@ -4253,9 +4027,9 @@ mod tests {
            Some(value) => std::env::set_var("HOME", value),
            None => std::env::remove_var("HOME"),
        }
-        match original_config_home {
-            Some(value) => std::env::set_var("CLAW_CONFIG_HOME", value),
-            None => std::env::remove_var("CLAW_CONFIG_HOME"),
+        match original_claude_home {
+            Some(value) => std::env::set_var("CLAUDE_CONFIG_HOME", value),
+            None => std::env::remove_var("CLAUDE_CONFIG_HOME"),
        }
        let _ = std::fs::remove_dir_all(root);
    }
Author	SHA1	Message	Date
Yeachan-Heo	5cee042e59	feat: jsonl-session progress	2026-04-01 06:15:14 +00:00
Yeachan-Heo	c80603556d	wip: jsonl-session progress	2026-04-01 04:30:27 +00:00