Prevent long sessions from stalling and expose the requested internal command surface

The runtime now auto-compacts completed conversations once cumulative input usage
crosses a configurable threshold, preserving recent context while surfacing an
explicit user notice. The CLI also publishes the requested ant-only slash
commands through the shared commands crate and main dispatch, using meaningful
local implementations for commit/PR/issue/teleport/debug workflows.

Constraint: Reuse the existing Rust compaction pipeline instead of introducing a new summarization stack
Constraint: No new dependencies or broad command-framework rewrite
Rejected: Implement API-driven compaction inside ConversationRuntime now | too much new plumbing for this delivery
Rejected: Expose new commands as parse-only stubs | would not satisfy the requested command availability
Confidence: medium
Scope-risk: moderate
Reversibility: clean
Directive: If runtime later gains true API-backed compaction, preserve the TurnSummary auto-compaction metadata shape so CLI call sites stay stable
Tested: cargo test; cargo build --release; cargo fmt --all; git diff --check; LSP diagnostics directory check
Not-tested: Live Anthropic-backed specialist command flows; gh-authenticated PR/issue creation in a real repo

rust/crates/commands/src/lib.rs

@@ -117,6 +117,48 @@ const SLASH_COMMAND_SPECS: &[SlashCommandSpec] = &[
         argument_hint: None,
         resume_supported: true,
     },
+    SlashCommandSpec {
+        name: "bughunter",
+        summary: "Inspect the codebase for likely bugs",
+        argument_hint: Some("[scope]"),
+        resume_supported: false,
+    },
+    SlashCommandSpec {
+        name: "commit",
+        summary: "Generate a commit message and create a git commit",
+        argument_hint: None,
+        resume_supported: false,
+    },
+    SlashCommandSpec {
+        name: "pr",
+        summary: "Draft or create a pull request from the conversation",
+        argument_hint: Some("[context]"),
+        resume_supported: false,
+    },
+    SlashCommandSpec {
+        name: "issue",
+        summary: "Draft or create a GitHub issue from the conversation",
+        argument_hint: Some("[context]"),
+        resume_supported: false,
+    },
+    SlashCommandSpec {
+        name: "ultraplan",
+        summary: "Run a deep planning prompt with multi-step reasoning",
+        argument_hint: Some("[task]"),
+        resume_supported: false,
+    },
+    SlashCommandSpec {
+        name: "teleport",
+        summary: "Jump to a file or symbol by searching the workspace",
+        argument_hint: Some("<symbol-or-path>"),
+        resume_supported: false,
+    },
+    SlashCommandSpec {
+        name: "debug-tool-call",
+        summary: "Replay the last tool call with debug details",
+        argument_hint: None,
+        resume_supported: false,
+    },
     SlashCommandSpec {
         name: "export",
         summary: "Export the current conversation to a file",
@@ -125,8 +167,8 @@ const SLASH_COMMAND_SPECS: &[SlashCommandSpec] = &[
     },
     SlashCommandSpec {
         name: "session",
-        summary: "List, switch, or fork managed local sessions",
-        argument_hint: Some("[list|switch <session-id>|fork [branch-name]]"),
+        summary: "List or switch managed local sessions",
+        argument_hint: Some("[list|switch <session-id>]"),
         resume_supported: false,
     },
 ];
@@ -136,6 +178,23 @@ pub enum SlashCommand {
     Help,
     Status,
     Compact,
+    Bughunter {
+        scope: Option<String>,
+    },
+    Commit,
+    Pr {
+        context: Option<String>,
+    },
+    Issue {
+        context: Option<String>,
+    },
+    Ultraplan {
+        task: Option<String>,
+    },
+    Teleport {
+        target: Option<String>,
+    },
+    DebugToolCall,
     Model {
         model: Option<String>,
     },
@@ -180,6 +239,23 @@ impl SlashCommand {
             "help" => Self::Help,
             "status" => Self::Status,
             "compact" => Self::Compact,
+            "bughunter" => Self::Bughunter {
+                scope: remainder_after_command(trimmed, command),
+            },
+            "commit" => Self::Commit,
+            "pr" => Self::Pr {
+                context: remainder_after_command(trimmed, command),
+            },
+            "issue" => Self::Issue {
+                context: remainder_after_command(trimmed, command),
+            },
+            "ultraplan" => Self::Ultraplan {
+                task: remainder_after_command(trimmed, command),
+            },
+            "teleport" => Self::Teleport {
+                target: remainder_after_command(trimmed, command),
+            },
+            "debug-tool-call" => Self::DebugToolCall,
             "model" => Self::Model {
                 model: parts.next().map(ToOwned::to_owned),
             },
@@ -212,6 +288,15 @@ impl SlashCommand {
     }
 }
 
+fn remainder_after_command(input: &str, command: &str) -> Option<String> {
+    input
+        .trim()
+        .strip_prefix(&format!("/{command}"))
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(ToOwned::to_owned)
+}
+
 #[must_use]
 pub fn slash_command_specs() -> &'static [SlashCommandSpec] {
     SLASH_COMMAND_SPECS
@@ -229,7 +314,7 @@ pub fn resume_supported_slash_commands() -> Vec<&'static SlashCommandSpec> {
 pub fn render_slash_command_help() -> String {
     let mut lines = vec![
         "Slash commands".to_string(),
-        "  [resume] means the command also works with --resume SESSION.jsonl".to_string(),
+        "  [resume] means the command also works with --resume SESSION.json".to_string(),
     ];
     for spec in slash_command_specs() {
         let name = match spec.argument_hint {
@@ -279,6 +364,13 @@ pub fn handle_slash_command(
             session: session.clone(),
         }),
         SlashCommand::Status
+        | SlashCommand::Bughunter { .. }
+        | SlashCommand::Commit
+        | SlashCommand::Pr { .. }
+        | SlashCommand::Issue { .. }
+        | SlashCommand::Ultraplan { .. }
+        | SlashCommand::Teleport { .. }
+        | SlashCommand::DebugToolCall
         | SlashCommand::Model { .. }
         | SlashCommand::Permissions { .. }
         | SlashCommand::Clear { .. }
@@ -307,6 +399,41 @@ mod tests {
     fn parses_supported_slash_commands() {
         assert_eq!(SlashCommand::parse("/help"), Some(SlashCommand::Help));
         assert_eq!(SlashCommand::parse(" /status "), Some(SlashCommand::Status));
+        assert_eq!(
+            SlashCommand::parse("/bughunter runtime"),
+            Some(SlashCommand::Bughunter {
+                scope: Some("runtime".to_string())
+            })
+        );
+        assert_eq!(SlashCommand::parse("/commit"), Some(SlashCommand::Commit));
+        assert_eq!(
+            SlashCommand::parse("/pr ready for review"),
+            Some(SlashCommand::Pr {
+                context: Some("ready for review".to_string())
+            })
+        );
+        assert_eq!(
+            SlashCommand::parse("/issue flaky test"),
+            Some(SlashCommand::Issue {
+                context: Some("flaky test".to_string())
+            })
+        );
+        assert_eq!(
+            SlashCommand::parse("/ultraplan ship both features"),
+            Some(SlashCommand::Ultraplan {
+                task: Some("ship both features".to_string())
+            })
+        );
+        assert_eq!(
+            SlashCommand::parse("/teleport conversation.rs"),
+            Some(SlashCommand::Teleport {
+                target: Some("conversation.rs".to_string())
+            })
+        );
+        assert_eq!(
+            SlashCommand::parse("/debug-tool-call"),
+            Some(SlashCommand::DebugToolCall)
+        );
         assert_eq!(
             SlashCommand::parse("/model claude-opus"),
             Some(SlashCommand::Model {
@@ -365,22 +492,22 @@ mod tests {
                 target: Some("abc123".to_string())
             })
         );
-        assert_eq!(
-            SlashCommand::parse("/session fork incident-review"),
-            Some(SlashCommand::Session {
-                action: Some("fork".to_string()),
-                target: Some("incident-review".to_string())
-            })
-        );
     }
 
     #[test]
     fn renders_help_from_shared_specs() {
         let help = render_slash_command_help();
-        assert!(help.contains("works with --resume SESSION.jsonl"));
+        assert!(help.contains("works with --resume SESSION.json"));
         assert!(help.contains("/help"));
         assert!(help.contains("/status"));
         assert!(help.contains("/compact"));
+        assert!(help.contains("/bughunter [scope]"));
+        assert!(help.contains("/commit"));
+        assert!(help.contains("/pr [context]"));
+        assert!(help.contains("/issue [context]"));
+        assert!(help.contains("/ultraplan [task]"));
+        assert!(help.contains("/teleport <symbol-or-path>"));
+        assert!(help.contains("/debug-tool-call"));
         assert!(help.contains("/model [model]"));
         assert!(help.contains("/permissions [read-only|workspace-write|danger-full-access]"));
         assert!(help.contains("/clear [--confirm]"));
@@ -392,15 +519,16 @@ mod tests {
         assert!(help.contains("/diff"));
         assert!(help.contains("/version"));
         assert!(help.contains("/export [file]"));
-        assert!(help.contains("/session [list|switch <session-id>|fork [branch-name]]"));
-        assert_eq!(slash_command_specs().len(), 15);
+        assert!(help.contains("/session [list|switch <session-id>]"));
+        assert_eq!(slash_command_specs().len(), 22);
         assert_eq!(resume_supported_slash_commands().len(), 11);
     }
 
     #[test]
     fn compacts_sessions_via_slash_command() {
-        let mut session = Session::new();
-        session.messages = vec![
+        let session = Session {
+            version: 1,
+            messages: vec![
                 ConversationMessage::user_text("a ".repeat(200)),
                 ConversationMessage::assistant(vec![ContentBlock::Text {
                     text: "b ".repeat(200),
@@ -409,7 +537,8 @@ mod tests {
                 ConversationMessage::assistant(vec![ContentBlock::Text {
                     text: "recent".to_string(),
                 }]),
-        ];
+            ],
+        };
 
         let result = handle_slash_command(
             "/compact",
@@ -439,6 +568,22 @@ mod tests {
         let session = Session::new();
         assert!(handle_slash_command("/unknown", &session, CompactionConfig::default()).is_none());
         assert!(handle_slash_command("/status", &session, CompactionConfig::default()).is_none());
+        assert!(
+            handle_slash_command("/bughunter", &session, CompactionConfig::default()).is_none()
+        );
+        assert!(handle_slash_command("/commit", &session, CompactionConfig::default()).is_none());
+        assert!(handle_slash_command("/pr", &session, CompactionConfig::default()).is_none());
+        assert!(handle_slash_command("/issue", &session, CompactionConfig::default()).is_none());
+        assert!(
+            handle_slash_command("/ultraplan", &session, CompactionConfig::default()).is_none()
+        );
+        assert!(
+            handle_slash_command("/teleport foo", &session, CompactionConfig::default()).is_none()
+        );
+        assert!(
+            handle_slash_command("/debug-tool-call", &session, CompactionConfig::default())
+                .is_none()
+        );
         assert!(
             handle_slash_command("/model claude", &session, CompactionConfig::default()).is_none()
         );
@@ -460,12 +605,6 @@ mod tests {
             CompactionConfig::default()
         )
         .is_none());
-        assert!(handle_slash_command(
-            "/resume session.jsonl",
-            &session,
-            CompactionConfig::default()
-        )
-        .is_none());
         assert!(handle_slash_command("/config", &session, CompactionConfig::default()).is_none());
         assert!(
             handle_slash_command("/config env", &session, CompactionConfig::default()).is_none()

rust/crates/runtime/src/compact.rs

@@ -99,14 +99,13 @@ 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,
+        compacted_session: Session {
+            version: session.version,
+            messages: compacted_messages,
+        },
         removed_message_count: removed.len(),
     }
 }
@@ -391,8 +390,10 @@ mod tests {
 
     #[test]
     fn leaves_small_sessions_unchanged() {
-        let mut session = Session::new();
-        session.messages = vec![ConversationMessage::user_text("hello")];
+        let session = Session {
+            version: 1,
+            messages: vec![ConversationMessage::user_text("hello")],
+        };
 
         let result = compact_session(&session, CompactionConfig::default());
         assert_eq!(result.removed_message_count, 0);
@@ -403,8 +404,9 @@ mod tests {
 
     #[test]
     fn compacts_older_messages_into_a_system_summary() {
-        let mut session = Session::new();
-        session.messages = vec![
+        let session = Session {
+            version: 1,
+            messages: vec![
                 ConversationMessage::user_text("one ".repeat(200)),
                 ConversationMessage::assistant(vec![ContentBlock::Text {
                     text: "two ".repeat(200),
@@ -417,7 +419,8 @@ mod tests {
                     }],
                     usage: None,
                 },
-        ];
+            ],
+        };
 
         let result = compact_session(
             &session,

rust/crates/runtime/src/config.rs

@@ -37,7 +37,6 @@ pub struct RuntimeConfig {
 
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub struct RuntimeFeatureConfig {
-    hooks: RuntimeHookConfig,
     mcp: McpConfigCollection,
     oauth: Option<OAuthConfig>,
     model: Option<String>,
@@ -45,12 +44,6 @@ pub struct RuntimeFeatureConfig {
     sandbox: SandboxConfig,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub struct RuntimeHookConfig {
-    pre_tool_use: Vec<String>,
-    post_tool_use: Vec<String>,
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub struct McpConfigCollection {
     servers: BTreeMap<String, ScopedMcpServerConfig>,
@@ -228,7 +221,6 @@ impl ConfigLoader {
         let merged_value = JsonValue::Object(merged.clone());
 
         let feature_config = RuntimeFeatureConfig {
-            hooks: parse_optional_hooks_config(&merged_value)?,
             mcp: McpConfigCollection {
                 servers: mcp_servers,
             },
@@ -286,11 +278,6 @@ impl RuntimeConfig {
         &self.feature_config.mcp
     }
 
-    #[must_use]
-    pub fn hooks(&self) -> &RuntimeHookConfig {
-        &self.feature_config.hooks
-    }
-
     #[must_use]
     pub fn oauth(&self) -> Option<&OAuthConfig> {
         self.feature_config.oauth.as_ref()
@@ -313,17 +300,6 @@ impl RuntimeConfig {
 }
 
 impl RuntimeFeatureConfig {
-    #[must_use]
-    pub fn with_hooks(mut self, hooks: RuntimeHookConfig) -> Self {
-        self.hooks = hooks;
-        self
-    }
-
-    #[must_use]
-    pub fn hooks(&self) -> &RuntimeHookConfig {
-        &self.hooks
-    }
-
     #[must_use]
     pub fn mcp(&self) -> &McpConfigCollection {
         &self.mcp
@@ -350,26 +326,6 @@ impl RuntimeFeatureConfig {
     }
 }
 
-impl RuntimeHookConfig {
-    #[must_use]
-    pub fn new(pre_tool_use: Vec<String>, post_tool_use: Vec<String>) -> Self {
-        Self {
-            pre_tool_use,
-            post_tool_use,
-        }
-    }
-
-    #[must_use]
-    pub fn pre_tool_use(&self) -> &[String] {
-        &self.pre_tool_use
-    }
-
-    #[must_use]
-    pub fn post_tool_use(&self) -> &[String] {
-        &self.post_tool_use
-    }
-}
-
 impl McpConfigCollection {
     #[must_use]
     pub fn servers(&self) -> &BTreeMap<String, ScopedMcpServerConfig> {
@@ -468,22 +424,6 @@ fn parse_optional_model(root: &JsonValue) -> Option<String> {
         .map(ToOwned::to_owned)
 }
 
-fn parse_optional_hooks_config(root: &JsonValue) -> Result<RuntimeHookConfig, ConfigError> {
-    let Some(object) = root.as_object() else {
-        return Ok(RuntimeHookConfig::default());
-    };
-    let Some(hooks_value) = object.get("hooks") else {
-        return Ok(RuntimeHookConfig::default());
-    };
-    let hooks = expect_object(hooks_value, "merged settings.hooks")?;
-    Ok(RuntimeHookConfig {
-        pre_tool_use: optional_string_array(hooks, "PreToolUse", "merged settings.hooks")?
-            .unwrap_or_default(),
-        post_tool_use: optional_string_array(hooks, "PostToolUse", "merged settings.hooks")?
-            .unwrap_or_default(),
-    })
-}
-
 fn parse_optional_permission_mode(
     root: &JsonValue,
 ) -> Result<Option<ResolvedPermissionMode>, ConfigError> {
@@ -896,8 +836,6 @@ mod tests {
             .and_then(JsonValue::as_object)
             .expect("hooks object")
             .contains_key("PostToolUse"));
-        assert_eq!(loaded.hooks().pre_tool_use(), &["base".to_string()]);
-        assert_eq!(loaded.hooks().post_tool_use(), &["project".to_string()]);
         assert!(loaded.mcp().get("home").is_some());
         assert!(loaded.mcp().get("project").is_some());
 

rust/crates/runtime/src/conversation.rs

@@ -4,12 +4,13 @@ use std::fmt::{Display, Formatter};
 use crate::compact::{
     compact_session, estimate_session_tokens, CompactionConfig, CompactionResult,
 };
-use crate::config::RuntimeFeatureConfig;
-use crate::hooks::{HookRunResult, HookRunner};
 use crate::permissions::{PermissionOutcome, PermissionPolicy, PermissionPrompter};
 use crate::session::{ContentBlock, ConversationMessage, Session};
 use crate::usage::{TokenUsage, UsageTracker};
 
+const DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD: u32 = 100_000;
+const AUTO_COMPACTION_THRESHOLD_ENV_VAR: &str = "CLAUDE_CODE_AUTO_COMPACT_INPUT_TOKENS";
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ApiRequest {
     pub system_prompt: Vec<String>,
@@ -86,6 +87,12 @@ pub struct TurnSummary {
     pub tool_results: Vec<ConversationMessage>,
     pub iterations: usize,
     pub usage: TokenUsage,
+    pub auto_compaction: Option<AutoCompactionEvent>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct AutoCompactionEvent {
+    pub removed_message_count: usize,
 }
 
 pub struct ConversationRuntime<C, T> {
@@ -96,7 +103,7 @@ pub struct ConversationRuntime<C, T> {
     system_prompt: Vec<String>,
     max_iterations: usize,
     usage_tracker: UsageTracker,
-    hook_runner: HookRunner,
+    auto_compaction_input_tokens_threshold: u32,
 }
 
 impl<C, T> ConversationRuntime<C, T>
@@ -111,25 +118,6 @@ where
         tool_executor: T,
         permission_policy: PermissionPolicy,
         system_prompt: Vec<String>,
-    ) -> Self {
-        Self::new_with_features(
-            session,
-            api_client,
-            tool_executor,
-            permission_policy,
-            system_prompt,
-            RuntimeFeatureConfig::default(),
-        )
-    }
-
-    #[must_use]
-    pub fn new_with_features(
-        session: Session,
-        api_client: C,
-        tool_executor: T,
-        permission_policy: PermissionPolicy,
-        system_prompt: Vec<String>,
-        feature_config: RuntimeFeatureConfig,
     ) -> Self {
         let usage_tracker = UsageTracker::from_session(&session);
         Self {
@@ -140,7 +128,7 @@ where
             system_prompt,
             max_iterations: usize::MAX,
             usage_tracker,
-            hook_runner: HookRunner::from_feature_config(&feature_config),
+            auto_compaction_input_tokens_threshold: auto_compaction_threshold_from_env(),
         }
     }
 
@@ -150,14 +138,20 @@ where
         self
     }
 
+    #[must_use]
+    pub fn with_auto_compaction_input_tokens_threshold(mut self, threshold: u32) -> Self {
+        self.auto_compaction_input_tokens_threshold = threshold;
+        self
+    }
+
     pub fn run_turn(
         &mut self,
         user_input: impl Into<String>,
         mut prompter: Option<&mut dyn PermissionPrompter>,
     ) -> Result<TurnSummary, RuntimeError> {
         self.session
-            .push_user_text(user_input.into())
-            .map_err(|error| RuntimeError::new(error.to_string()))?;
+            .messages
+            .push(ConversationMessage::user_text(user_input.into()));
 
         let mut assistant_messages = Vec::new();
         let mut tool_results = Vec::new();
@@ -191,9 +185,7 @@ where
                 })
                 .collect::<Vec<_>>();
 
-            self.session
-                .push_message(assistant_message.clone())
-                .map_err(|error| RuntimeError::new(error.to_string()))?;
+            self.session.messages.push(assistant_message.clone());
             assistant_messages.push(assistant_message);
 
             if pending_tool_uses.is_empty() {
@@ -210,59 +202,38 @@ where
 
                 let result_message = match permission_outcome {
                     PermissionOutcome::Allow => {
-                        let pre_hook_result = self.hook_runner.run_pre_tool_use(&tool_name, &input);
-                        if pre_hook_result.is_denied() {
-                            let deny_message = format!("PreToolUse hook denied tool `{tool_name}`");
-                            ConversationMessage::tool_result(
-                                tool_use_id,
-                                tool_name,
-                                format_hook_message(&pre_hook_result, &deny_message),
-                                true,
-                            )
-                        } else {
-                            let (mut output, mut is_error) =
                         match self.tool_executor.execute(&tool_name, &input) {
-                                    Ok(output) => (output, false),
-                                    Err(error) => (error.to_string(), true),
-                                };
-                            output = merge_hook_feedback(pre_hook_result.messages(), output, false);
-
-                            let post_hook_result = self
-                                .hook_runner
-                                .run_post_tool_use(&tool_name, &input, &output, is_error);
-                            if post_hook_result.is_denied() {
-                                is_error = true;
-                            }
-                            output = merge_hook_feedback(
-                                post_hook_result.messages(),
-                                output,
-                                post_hook_result.is_denied(),
-                            );
-
-                            ConversationMessage::tool_result(
+                            Ok(output) => ConversationMessage::tool_result(
                                 tool_use_id,
                                 tool_name,
                                 output,
-                                is_error,
-                            )
+                                false,
+                            ),
+                            Err(error) => ConversationMessage::tool_result(
+                                tool_use_id,
+                                tool_name,
+                                error.to_string(),
+                                true,
+                            ),
                         }
                     }
                     PermissionOutcome::Deny { reason } => {
                         ConversationMessage::tool_result(tool_use_id, tool_name, reason, true)
                     }
                 };
-                self.session
-                    .push_message(result_message.clone())
-                    .map_err(|error| RuntimeError::new(error.to_string()))?;
+                self.session.messages.push(result_message.clone());
                 tool_results.push(result_message);
             }
         }
 
+        let auto_compaction = self.maybe_auto_compact();
+
         Ok(TurnSummary {
             assistant_messages,
             tool_results,
             iterations,
             usage: self.usage_tracker.cumulative_usage(),
+            auto_compaction,
         })
     }
 
@@ -286,15 +257,52 @@ 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
     }
+
+    fn maybe_auto_compact(&mut self) -> Option<AutoCompactionEvent> {
+        if self.usage_tracker.cumulative_usage().input_tokens
+            < self.auto_compaction_input_tokens_threshold
+        {
+            return None;
+        }
+
+        let result = compact_session(
+            &self.session,
+            CompactionConfig {
+                max_estimated_tokens: 0,
+                ..CompactionConfig::default()
+            },
+        );
+
+        if result.removed_message_count == 0 {
+            return None;
+        }
+
+        self.session = result.compacted_session;
+        Some(AutoCompactionEvent {
+            removed_message_count: result.removed_message_count,
+        })
+    }
+}
+
+#[must_use]
+pub fn auto_compaction_threshold_from_env() -> u32 {
+    parse_auto_compaction_threshold(
+        std::env::var(AUTO_COMPACTION_THRESHOLD_ENV_VAR)
+            .ok()
+            .as_deref(),
+    )
+}
+
+#[must_use]
+fn parse_auto_compaction_threshold(value: Option<&str>) -> u32 {
+    value
+        .and_then(|raw| raw.trim().parse::<u32>().ok())
+        .filter(|threshold| *threshold > 0)
+        .unwrap_or(DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD)
 }
 
 fn build_assistant_message(
@@ -344,32 +352,6 @@ fn flush_text_block(text: &mut String, blocks: &mut Vec<ContentBlock>) {
     }
 }
 
-fn format_hook_message(result: &HookRunResult, fallback: &str) -> String {
-    if result.messages().is_empty() {
-        fallback.to_string()
-    } else {
-        result.messages().join("\n")
-    }
-}
-
-fn merge_hook_feedback(messages: &[String], output: String, denied: bool) -> String {
-    if messages.is_empty() {
-        return output;
-    }
-
-    let mut sections = Vec::new();
-    if !output.trim().is_empty() {
-        sections.push(output);
-    }
-    let label = if denied {
-        "Hook feedback (denied)"
-    } else {
-        "Hook feedback"
-    };
-    sections.push(format!("{label}:\n{}", messages.join("\n")));
-    sections.join("\n\n")
-}
-
 type ToolHandler = Box<dyn FnMut(&str) -> Result<String, ToolError>>;
 
 #[derive(Default)]
@@ -405,11 +387,11 @@ impl ToolExecutor for StaticToolExecutor {
 #[cfg(test)]
 mod tests {
     use super::{
-        ApiClient, ApiRequest, AssistantEvent, ConversationRuntime, RuntimeError,
-        StaticToolExecutor,
+        parse_auto_compaction_threshold, ApiClient, ApiRequest, AssistantEvent,
+        AutoCompactionEvent, ConversationRuntime, RuntimeError, StaticToolExecutor,
+        DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD,
     };
     use crate::compact::CompactionConfig;
-    use crate::config::{RuntimeFeatureConfig, RuntimeHookConfig};
     use crate::permissions::{
         PermissionMode, PermissionPolicy, PermissionPromptDecision, PermissionPrompter,
         PermissionRequest,
@@ -417,9 +399,7 @@ 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,
@@ -519,6 +499,7 @@ mod tests {
         assert_eq!(summary.tool_results.len(), 1);
         assert_eq!(runtime.session().messages.len(), 4);
         assert_eq!(summary.usage.output_tokens, 10);
+        assert_eq!(summary.auto_compaction, None);
         assert!(matches!(
             runtime.session().messages[1].blocks[1],
             ContentBlock::ToolUse { .. }
@@ -586,141 +567,6 @@ mod tests {
         ));
     }
 
-    #[test]
-    fn denies_tool_use_when_pre_tool_hook_blocks() {
-        struct SingleCallApiClient;
-        impl ApiClient for SingleCallApiClient {
-            fn stream(&mut self, request: ApiRequest) -> Result<Vec<AssistantEvent>, RuntimeError> {
-                if request
-                    .messages
-                    .iter()
-                    .any(|message| message.role == MessageRole::Tool)
-                {
-                    return Ok(vec![
-                        AssistantEvent::TextDelta("blocked".to_string()),
-                        AssistantEvent::MessageStop,
-                    ]);
-                }
-                Ok(vec![
-                    AssistantEvent::ToolUse {
-                        id: "tool-1".to_string(),
-                        name: "blocked".to_string(),
-                        input: r#"{"path":"secret.txt"}"#.to_string(),
-                    },
-                    AssistantEvent::MessageStop,
-                ])
-            }
-        }
-
-        let mut runtime = ConversationRuntime::new_with_features(
-            Session::new(),
-            SingleCallApiClient,
-            StaticToolExecutor::new().register("blocked", |_input| {
-                panic!("tool should not execute when hook denies")
-            }),
-            PermissionPolicy::new(PermissionMode::DangerFullAccess),
-            vec!["system".to_string()],
-            RuntimeFeatureConfig::default().with_hooks(RuntimeHookConfig::new(
-                vec![shell_snippet("printf 'blocked by hook'; exit 2")],
-                Vec::new(),
-            )),
-        );
-
-        let summary = runtime
-            .run_turn("use the tool", None)
-            .expect("conversation should continue after hook denial");
-
-        assert_eq!(summary.tool_results.len(), 1);
-        let ContentBlock::ToolResult {
-            is_error, output, ..
-        } = &summary.tool_results[0].blocks[0]
-        else {
-            panic!("expected tool result block");
-        };
-        assert!(
-            *is_error,
-            "hook denial should produce an error result: {output}"
-        );
-        assert!(
-            output.contains("denied tool") || output.contains("blocked by hook"),
-            "unexpected hook denial output: {output:?}"
-        );
-    }
-
-    #[test]
-    fn appends_post_tool_hook_feedback_to_tool_result() {
-        struct TwoCallApiClient {
-            calls: usize,
-        }
-
-        impl ApiClient for TwoCallApiClient {
-            fn stream(&mut self, request: ApiRequest) -> Result<Vec<AssistantEvent>, RuntimeError> {
-                self.calls += 1;
-                match self.calls {
-                    1 => Ok(vec![
-                        AssistantEvent::ToolUse {
-                            id: "tool-1".to_string(),
-                            name: "add".to_string(),
-                            input: r#"{"lhs":2,"rhs":2}"#.to_string(),
-                        },
-                        AssistantEvent::MessageStop,
-                    ]),
-                    2 => {
-                        assert!(request
-                            .messages
-                            .iter()
-                            .any(|message| message.role == MessageRole::Tool));
-                        Ok(vec![
-                            AssistantEvent::TextDelta("done".to_string()),
-                            AssistantEvent::MessageStop,
-                        ])
-                    }
-                    _ => Err(RuntimeError::new("unexpected extra API call")),
-                }
-            }
-        }
-
-        let mut runtime = ConversationRuntime::new_with_features(
-            Session::new(),
-            TwoCallApiClient { calls: 0 },
-            StaticToolExecutor::new().register("add", |_input| Ok("4".to_string())),
-            PermissionPolicy::new(PermissionMode::DangerFullAccess),
-            vec!["system".to_string()],
-            RuntimeFeatureConfig::default().with_hooks(RuntimeHookConfig::new(
-                vec![shell_snippet("printf 'pre hook ran'")],
-                vec![shell_snippet("printf 'post hook ran'")],
-            )),
-        );
-
-        let summary = runtime
-            .run_turn("use add", None)
-            .expect("tool loop succeeds");
-
-        assert_eq!(summary.tool_results.len(), 1);
-        let ContentBlock::ToolResult {
-            is_error, output, ..
-        } = &summary.tool_results[0].blocks[0]
-        else {
-            panic!("expected tool result block");
-        };
-        assert!(
-            !*is_error,
-            "post hook should preserve non-error result: {output:?}"
-        );
-        assert!(
-            output.contains("4"),
-            "tool output missing value: {output:?}"
-        );
-        assert!(
-            output.contains("pre hook ran"),
-            "tool output missing pre hook feedback: {output:?}"
-        );
-        assert!(
-            output.contains("post hook ran"),
-            "tool output missing post hook feedback: {output:?}"
-        );
-    }
-
     #[test]
     fn reconstructs_usage_tracker_from_restored_session() {
         struct SimpleApi;
@@ -798,15 +644,10 @@ 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() {
+    fn auto_compacts_when_cumulative_input_threshold_is_crossed() {
         struct SimpleApi;
         impl ApiClient for SimpleApi {
             fn stream(
@@ -815,78 +656,100 @@ mod tests {
             ) -> Result<Vec<AssistantEvent>, RuntimeError> {
                 Ok(vec![
                     AssistantEvent::TextDelta("done".to_string()),
+                    AssistantEvent::Usage(TokenUsage {
+                        input_tokens: 120_000,
+                        output_tokens: 4,
+                        cache_creation_input_tokens: 0,
+                        cache_read_input_tokens: 0,
+                    }),
                     AssistantEvent::MessageStop,
                 ])
             }
         }
 
-        let path = temp_session_path("persisted-turn");
-        let session = Session::new().with_persistence_path(path.clone());
+        let session = Session {
+            version: 1,
+            messages: vec![
+                crate::session::ConversationMessage::user_text("one"),
+                crate::session::ConversationMessage::assistant(vec![ContentBlock::Text {
+                    text: "two".to_string(),
+                }]),
+                crate::session::ConversationMessage::user_text("three"),
+                crate::session::ConversationMessage::assistant(vec![ContentBlock::Text {
+                    text: "four".to_string(),
+                }]),
+            ],
+        };
+
         let mut runtime = ConversationRuntime::new(
             session,
             SimpleApi,
             StaticToolExecutor::new(),
             PermissionPolicy::new(PermissionMode::DangerFullAccess),
             vec!["system".to_string()],
-        );
+        )
+        .with_auto_compaction_input_tokens_threshold(100_000);
 
-        runtime
-            .run_turn("persist this turn", None)
+        let summary = runtime
+            .run_turn("trigger", 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);
+        assert_eq!(
+            summary.auto_compaction,
+            Some(AutoCompactionEvent {
+                removed_message_count: 2,
+            })
+        );
+        assert_eq!(runtime.session().messages[0].role, MessageRole::System);
     }
 
     #[test]
-    fn forks_runtime_session_without_mutating_original() {
-        let mut session = Session::new();
-        session
-            .push_user_text("branch me")
-            .expect("message should append");
+    fn skips_auto_compaction_below_threshold() {
+        struct SimpleApi;
+        impl ApiClient for SimpleApi {
+            fn stream(
+                &mut self,
+                _request: ApiRequest,
+            ) -> Result<Vec<AssistantEvent>, RuntimeError> {
+                Ok(vec![
+                    AssistantEvent::TextDelta("done".to_string()),
+                    AssistantEvent::Usage(TokenUsage {
+                        input_tokens: 99_999,
+                        output_tokens: 4,
+                        cache_creation_input_tokens: 0,
+                        cache_read_input_tokens: 0,
+                    }),
+                    AssistantEvent::MessageStop,
+                ])
+            }
+        }
 
-        let runtime = ConversationRuntime::new(
-            session.clone(),
-            ScriptedApiClient { call_count: 0 },
+        let mut runtime = ConversationRuntime::new(
+            Session::new(),
+            SimpleApi,
             StaticToolExecutor::new(),
             PermissionPolicy::new(PermissionMode::DangerFullAccess),
             vec!["system".to_string()],
-        );
+        )
+        .with_auto_compaction_input_tokens_threshold(100_000);
 
-        let forked = runtime.fork_session(Some("alt-path".to_string()));
+        let summary = runtime
+            .run_turn("trigger", None)
+            .expect("turn should succeed");
+        assert_eq!(summary.auto_compaction, None);
+        assert_eq!(runtime.session().messages.len(), 2);
+    }
 
-        assert_eq!(forked.messages, session.messages);
-        assert_ne!(forked.session_id, session.session_id);
+    #[test]
+    fn auto_compaction_threshold_defaults_and_parses_values() {
         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")))
+            parse_auto_compaction_threshold(None),
+            DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD
+        );
+        assert_eq!(parse_auto_compaction_threshold(Some("4321")), 4321);
+        assert_eq!(
+            parse_auto_compaction_threshold(Some("not-a-number")),
+            DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD
         );
-        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)]
-    fn shell_snippet(script: &str) -> String {
-        script.replace('\'', "\"")
-    }
-
-    #[cfg(not(windows))]
-    fn shell_snippet(script: &str) -> String {
-        script.to_string()
     }
 }

rust/crates/runtime/src/hooks.rs

@@ -1,349 +0,0 @@
-use std::ffi::OsStr;
-use std::process::Command;
-
-use serde_json::json;
-
-use crate::config::{RuntimeFeatureConfig, RuntimeHookConfig};
-
-#[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 {
-    config: RuntimeHookConfig,
-}
-
-impl HookRunner {
-    #[must_use]
-    pub fn new(config: RuntimeHookConfig) -> Self {
-        Self { config }
-    }
-
-    #[must_use]
-    pub fn from_feature_config(feature_config: &RuntimeFeatureConfig) -> Self {
-        Self::new(feature_config.hooks().clone())
-    }
-
-    #[must_use]
-    pub fn run_pre_tool_use(&self, tool_name: &str, tool_input: &str) -> HookRunResult {
-        self.run_commands(
-            HookEvent::PreToolUse,
-            self.config.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.config.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 } => {
-                    let message = message.unwrap_or_else(|| {
-                        format!("{} hook denied tool `{tool_name}`", event.as_str())
-                    });
-                    messages.push(message);
-                    return HookRunResult {
-                        denied: true,
-                        messages,
-                    };
-                }
-                HookCommandOutcome::Warn { message } => messages.push(message),
-            }
-        }
-
-        HookRunResult::allow(messages)
-    }
-
-    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 mut 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 = {
-        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;
-            child_stdin.write_all(stdin)?;
-        }
-        child.wait_with_output()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{HookRunResult, HookRunner};
-    use crate::config::{RuntimeFeatureConfig, RuntimeHookConfig};
-
-    #[test]
-    fn allows_exit_code_zero_and_captures_stdout() {
-        let runner = HookRunner::new(RuntimeHookConfig::new(
-            vec![shell_snippet("printf 'pre ok'")],
-            Vec::new(),
-        ));
-
-        let result = runner.run_pre_tool_use("Read", r#"{"path":"README.md"}"#);
-
-        assert_eq!(result, HookRunResult::allow(vec!["pre ok".to_string()]));
-    }
-
-    #[test]
-    fn denies_exit_code_two() {
-        let runner = HookRunner::new(RuntimeHookConfig::new(
-            vec![shell_snippet("printf 'blocked by hook'; exit 2")],
-            Vec::new(),
-        ));
-
-        let result = runner.run_pre_tool_use("Bash", r#"{"command":"pwd"}"#);
-
-        assert!(result.is_denied());
-        assert_eq!(result.messages(), &["blocked by hook".to_string()]);
-    }
-
-    #[test]
-    fn warns_for_other_non_zero_statuses() {
-        let runner = HookRunner::from_feature_config(&RuntimeFeatureConfig::default().with_hooks(
-            RuntimeHookConfig::new(
-                vec![shell_snippet("printf 'warning hook'; exit 1")],
-                Vec::new(),
-            ),
-        ));
-
-        let result = runner.run_pre_tool_use("Edit", r#"{"file":"src/lib.rs"}"#);
-
-        assert!(!result.is_denied());
-        assert!(result
-            .messages()
-            .iter()
-            .any(|message| message.contains("allowing tool execution to continue")));
-    }
-
-    #[cfg(windows)]
-    fn shell_snippet(script: &str) -> String {
-        script.replace('\'', "\"")
-    }
-
-    #[cfg(not(windows))]
-    fn shell_snippet(script: &str) -> String {
-        script.to_string()
-    }
-}

rust/crates/runtime/src/lib.rs

@@ -4,7 +4,6 @@ mod compact;
 mod config;
 mod conversation;
 mod file_ops;
-mod hooks;
 mod json;
 mod mcp;
 mod mcp_client;
@@ -27,19 +26,18 @@ pub use config::{
     ConfigEntry, ConfigError, ConfigLoader, ConfigSource, McpClaudeAiProxyServerConfig,
     McpConfigCollection, McpOAuthConfig, McpRemoteServerConfig, McpSdkServerConfig,
     McpServerConfig, McpStdioServerConfig, McpTransport, McpWebSocketServerConfig, OAuthConfig,
-    ResolvedPermissionMode, RuntimeConfig, RuntimeFeatureConfig, RuntimeHookConfig,
-    ScopedMcpServerConfig, CLAUDE_CODE_SETTINGS_SCHEMA_NAME,
+    ResolvedPermissionMode, RuntimeConfig, RuntimeFeatureConfig, ScopedMcpServerConfig,
+    CLAUDE_CODE_SETTINGS_SCHEMA_NAME,
 };
 pub use conversation::{
-    ApiClient, ApiRequest, AssistantEvent, ConversationRuntime, RuntimeError, StaticToolExecutor,
-    ToolError, ToolExecutor, TurnSummary,
+    auto_compaction_threshold_from_env, ApiClient, ApiRequest, AssistantEvent, AutoCompactionEvent,
+    ConversationRuntime, RuntimeError, StaticToolExecutor, ToolError, ToolExecutor, TurnSummary,
 };
 pub use file_ops::{
     edit_file, glob_search, grep_search, read_file, write_file, EditFileOutput, GlobSearchOutput,
     GrepSearchInput, GrepSearchOutput, ReadFileOutput, StructuredPatchHunk, TextFilePayload,
     WriteFileOutput,
 };
-pub use hooks::{HookEvent, HookRunResult, HookRunner};
 pub use mcp::{
     mcp_server_signature, mcp_tool_name, mcp_tool_prefix, normalize_name_for_mcp,
     scoped_mcp_config_hash, unwrap_ccr_proxy_url,
@@ -76,10 +74,7 @@ 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, SessionCompaction, SessionError,
-    SessionFork,
-};
+pub use session::{ContentBlock, ConversationMessage, MessageRole, Session, SessionError};
 pub use usage::{
     format_usd, pricing_for_model, ModelPricing, TokenUsage, UsageCostEstimate, UsageTracker,
 };

rust/crates/runtime/src/session.rs

@@ -1,19 +1,11 @@
 use std::collections::BTreeMap;
 use std::fmt::{Display, Formatter};
-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 std::fs;
+use std::path::Path;
 
 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,
@@ -48,49 +40,11 @@ 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),
@@ -125,84 +79,20 @@ impl From<JsonError> for SessionError {
 impl Session {
     #[must_use]
     pub fn new() -> Self {
-        let now = current_time_millis();
         Self {
-            version: SESSION_VERSION,
-            session_id: generate_session_id(),
-            created_at_ms: now,
-            updated_at_ms: now,
+            version: 1,
             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> {
-        let path = path.as_ref();
-        rotate_session_file_if_needed(path)?;
-        write_atomic(path, &self.render_jsonl_snapshot())?;
-        cleanup_rotated_logs(path)?;
+        fs::write(path, self.to_json().render())?;
         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)?;
-        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,
-        }
+        Self::from_json(&JsonValue::parse(&contents)?)
     }
 
     #[must_use]
@@ -212,18 +102,6 @@ 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(
@@ -233,12 +111,6 @@ 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)
     }
 
@@ -259,179 +131,7 @@ impl Session {
             .iter()
             .map(ConversationMessage::from_json)
             .collect::<Result<Vec<_>, _>>()?;
-        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();
+        Ok(Self { version, messages })
     }
 }
 
@@ -624,92 +324,6 @@ 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(
@@ -762,155 +376,22 @@ 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::{
-        cleanup_rotated_logs, rotate_session_file_if_needed, ContentBlock, ConversationMessage,
-        MessageRole, Session, SessionFork,
-    };
-    use crate::json::JsonValue;
+    use super::{ContentBlock, ConversationMessage, MessageRole, Session};
     use crate::usage::TokenUsage;
     use std::fs;
-    use std::path::PathBuf;
     use std::time::{SystemTime, UNIX_EPOCH};
 
     #[test]
-    fn persists_and_restores_session_jsonl() {
+    fn persists_and_restores_session_json() {
         let mut session = Session::new();
         session
-            .push_user_text("hello")
-            .expect("user message should append");
+            .messages
+            .push(ConversationMessage::user_text("hello"));
         session
-            .push_message(ConversationMessage::assistant_with_usage(
+            .messages
+            .push(ConversationMessage::assistant_with_usage(
                 vec![
                     ContentBlock::Text {
                         text: "thinking".to_string(),
@@ -927,15 +408,16 @@ mod tests {
                     cache_creation_input_tokens: 1,
                     cache_read_input_tokens: 2,
                 }),
-            ))
-            .expect("assistant message should append");
-        session
-            .push_message(ConversationMessage::tool_result(
+            ));
+        session.messages.push(ConversationMessage::tool_result(
             "tool-1", "bash", "hi", false,
-            ))
-            .expect("tool result should append");
+        ));
 
-        let path = temp_session_path("jsonl");
+        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"));
         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");
@@ -946,157 +428,5 @@ 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()
     }
 }

rust/crates/runtime/src/usage.rs

@@ -286,8 +286,9 @@ mod tests {
 
     #[test]
     fn reconstructs_usage_from_session_messages() {
-        let mut session = Session::new();
-        session.messages = vec![ConversationMessage {
+        let session = Session {
+            version: 1,
+            messages: vec![ConversationMessage {
                 role: MessageRole::Assistant,
                 blocks: vec![ContentBlock::Text {
                     text: "done".to_string(),
@@ -298,7 +299,8 @@ mod tests {
                     cache_creation_input_tokens: 1,
                     cache_read_input_tokens: 0,
                 }),
-        }];
+            }],
+        };
 
         let tracker = UsageTracker::from_session(&session);
         assert_eq!(tracker.turns(), 1);

rust/crates/rusty-claude-cli/src/main.rs

@@ -9,7 +9,7 @@ use std::io::{self, Read, Write};
 use std::net::TcpListener;
 use std::path::{Path, PathBuf};
 use std::process::Command;
-use std::time::UNIX_EPOCH;
+use std::time::{SystemTime, UNIX_EPOCH};
 
 use api::{
     resolve_startup_auth_source, AnthropicClient, AuthSource, ContentBlockDelta, InputContentBlock,
@@ -47,8 +47,6 @@ const DEFAULT_OAUTH_CALLBACK_PORT: u16 = 4545;
 const VERSION: &str = env!("CARGO_PKG_VERSION");
 const BUILD_TARGET: Option<&str> = option_env!("TARGET");
 const GIT_SHA: Option<&str> = option_env!("GIT_SHA");
-const PRIMARY_SESSION_EXTENSION: &str = "jsonl";
-const LEGACY_SESSION_EXTENSION: &str = "json";
 
 type AllowedToolSet = BTreeSet<String>;
 
@@ -591,19 +589,7 @@ fn print_version() {
 }
 
 fn resume_session(session_path: &Path, commands: &[String]) {
-    let resolved_path = if session_path.exists() {
-        session_path.to_path_buf()
-    } else {
-        match resolve_session_reference(&session_path.display().to_string()) {
-            Ok(handle) => handle.path,
-            Err(error) => {
-                eprintln!("failed to restore session: {error}");
-                std::process::exit(1);
-            }
-        }
-    };
-
-    let session = match Session::load_from_path(&resolved_path) {
+    let session = match Session::load_from_path(session_path) {
         Ok(session) => session,
         Err(error) => {
             eprintln!("failed to restore session: {error}");
@@ -614,7 +600,7 @@ fn resume_session(session_path: &Path, commands: &[String]) {
     if commands.is_empty() {
         println!(
             "Restored session from {} ({} messages).",
-            resolved_path.display(),
+            session_path.display(),
             session.messages.len()
         );
         return;
@@ -626,7 +612,7 @@ fn resume_session(session_path: &Path, commands: &[String]) {
             eprintln!("unsupported resumed command: {raw_command}");
             std::process::exit(2);
         };
-        match run_resume_command(&resolved_path, &session, &command) {
+        match run_resume_command(session_path, &session, &command) {
             Ok(ResumeCommandOutcome {
                 session: next_session,
                 message,
@@ -789,6 +775,10 @@ fn format_compact_report(removed: usize, resulting_messages: usize, skipped: boo
     }
 }
 
+fn format_auto_compaction_notice(removed: usize) -> String {
+    format!("[auto-compacted: removed {removed} messages]")
+}
+
 fn parse_git_status_metadata(status: Option<&str>) -> (Option<PathBuf>, Option<String>) {
     let Some(status) = status else {
         return (None, None);
@@ -927,7 +917,14 @@ fn run_resume_command(
                 )),
             })
         }
-        SlashCommand::Resume { .. }
+        SlashCommand::Bughunter { .. }
+        | SlashCommand::Commit
+        | SlashCommand::Pr { .. }
+        | SlashCommand::Issue { .. }
+        | SlashCommand::Ultraplan { .. }
+        | SlashCommand::Teleport { .. }
+        | SlashCommand::DebugToolCall
+        | SlashCommand::Resume { .. }
         | SlashCommand::Model { .. }
         | SlashCommand::Permissions { .. }
         | SlashCommand::Session { .. }
@@ -987,8 +984,6 @@ struct ManagedSessionSummary {
     path: PathBuf,
     modified_epoch_secs: u64,
     message_count: usize,
-    parent_session_id: Option<String>,
-    branch_name: Option<String>,
 }
 
 struct LiveCli {
@@ -1008,10 +1003,9 @@ impl LiveCli {
         permission_mode: PermissionMode,
     ) -> Result<Self, Box<dyn std::error::Error>> {
         let system_prompt = build_system_prompt()?;
-        let session_state = Session::new();
-        let session = create_managed_session_handle(&session_state.session_id)?;
+        let session = create_managed_session_handle()?;
         let runtime = build_runtime(
-            session_state.with_persistence_path(session.path.clone()),
+            Session::new(),
             model.clone(),
             system_prompt.clone(),
             enable_tools,
@@ -1067,13 +1061,19 @@ impl LiveCli {
         let mut permission_prompter = CliPermissionPrompter::new(self.permission_mode);
         let result = self.runtime.run_turn(input, Some(&mut permission_prompter));
         match result {
-            Ok(_) => {
+            Ok(summary) => {
                 spinner.finish(
                     "✨ Done",
                     TerminalRenderer::new().color_theme(),
                     &mut stdout,
                 )?;
                 println!();
+                if let Some(event) = summary.auto_compaction {
+                    println!(
+                        "{}",
+                        format_auto_compaction_notice(event.removed_message_count)
+                    );
+                }
                 self.persist_session()?;
                 Ok(())
             }
@@ -1120,6 +1120,10 @@ impl LiveCli {
                 "message": final_assistant_text(&summary),
                 "model": self.model,
                 "iterations": summary.iterations,
+                "auto_compaction": summary.auto_compaction.map(|event| json!({
+                    "removed_messages": event.removed_message_count,
+                    "notice": format_auto_compaction_notice(event.removed_message_count),
+                })),
                 "tool_uses": collect_tool_uses(&summary),
                 "tool_results": collect_tool_results(&summary),
                 "usage": {
@@ -1146,6 +1150,34 @@ impl LiveCli {
                 self.print_status();
                 false
             }
+            SlashCommand::Bughunter { scope } => {
+                self.run_bughunter(scope.as_deref())?;
+                false
+            }
+            SlashCommand::Commit => {
+                self.run_commit()?;
+                true
+            }
+            SlashCommand::Pr { context } => {
+                self.run_pr(context.as_deref())?;
+                false
+            }
+            SlashCommand::Issue { context } => {
+                self.run_issue(context.as_deref())?;
+                false
+            }
+            SlashCommand::Ultraplan { task } => {
+                self.run_ultraplan(task.as_deref())?;
+                false
+            }
+            SlashCommand::Teleport { target } => {
+                self.run_teleport(target.as_deref())?;
+                false
+            }
+            SlashCommand::DebugToolCall => {
+                self.run_debug_tool_call()?;
+                false
+            }
             SlashCommand::Compact => {
                 self.compact()?;
                 false
@@ -1314,10 +1346,9 @@ impl LiveCli {
             return Ok(false);
         }
 
-        let session_state = Session::new();
-        self.session = create_managed_session_handle(&session_state.session_id)?;
+        self.session = create_managed_session_handle()?;
         self.runtime = build_runtime(
-            session_state.with_persistence_path(self.session.path.clone()),
+            Session::new(),
             self.model.clone(),
             self.system_prompt.clone(),
             true,
@@ -1351,7 +1382,6 @@ impl LiveCli {
         let handle = resolve_session_reference(&session_ref)?;
         let session = Session::load_from_path(&handle.path)?;
         let message_count = session.messages.len();
-        let session_id = session.session_id.clone();
         self.runtime = build_runtime(
             session,
             self.model.clone(),
@@ -1361,10 +1391,7 @@ impl LiveCli {
             self.allowed_tools.clone(),
             self.permission_mode,
         )?;
-        self.session = SessionHandle {
-            id: session_id,
-            path: handle.path,
-        };
+        self.session = handle;
         println!(
             "{}",
             format_resume_report(
@@ -1427,7 +1454,6 @@ impl LiveCli {
                 let handle = resolve_session_reference(target)?;
                 let session = Session::load_from_path(&handle.path)?;
                 let message_count = session.messages.len();
-                let session_id = session.session_id.clone();
                 self.runtime = build_runtime(
                     session,
                     self.model.clone(),
@@ -1437,10 +1463,7 @@ impl LiveCli {
                     self.allowed_tools.clone(),
                     self.permission_mode,
                 )?;
-                self.session = SessionHandle {
-                    id: session_id,
-                    path: handle.path,
-                };
+                self.session = handle;
                 println!(
                     "Session switched\n  Active session   {}\n  File             {}\n  Messages         {}",
                     self.session.id,
@@ -1449,41 +1472,8 @@ impl LiveCli {
                 );
                 Ok(true)
             }
-            Some("fork") => {
-                let forked = self.runtime.fork_session(target.map(ToOwned::to_owned));
-                let parent_session_id = self.session.id.clone();
-                let handle = create_managed_session_handle(&forked.session_id)?;
-                let branch_name = forked
-                    .fork
-                    .as_ref()
-                    .and_then(|fork| fork.branch_name.clone());
-                let forked = forked.with_persistence_path(handle.path.clone());
-                let message_count = forked.messages.len();
-                forked.save_to_path(&handle.path)?;
-                self.runtime = build_runtime(
-                    forked,
-                    self.model.clone(),
-                    self.system_prompt.clone(),
-                    true,
-                    true,
-                    self.allowed_tools.clone(),
-                    self.permission_mode,
-                )?;
-                self.session = handle;
-                println!(
-                    "Session forked\n  Parent session   {}\n  Active session   {}\n  Branch           {}\n  File             {}\n  Messages         {}",
-                    parent_session_id,
-                    self.session.id,
-                    branch_name.as_deref().unwrap_or("(unnamed)"),
-                    self.session.path.display(),
-                    message_count,
-                );
-                Ok(true)
-            }
             Some(other) => {
-                println!(
-                    "Unknown /session action '{other}'. Use /session list, /session switch <session-id>, or /session fork [branch-name]."
-                );
+                println!("Unknown /session action '{other}'. Use /session list or /session switch <session-id>.");
                 Ok(false)
             }
         }
@@ -1507,6 +1497,160 @@ impl LiveCli {
         println!("{}", format_compact_report(removed, kept, skipped));
         Ok(())
     }
+
+    fn run_internal_prompt_text(
+        &self,
+        prompt: &str,
+        enable_tools: bool,
+    ) -> Result<String, Box<dyn std::error::Error>> {
+        let session = self.runtime.session().clone();
+        let mut runtime = build_runtime(
+            session,
+            self.model.clone(),
+            self.system_prompt.clone(),
+            enable_tools,
+            false,
+            self.allowed_tools.clone(),
+            self.permission_mode,
+        )?;
+        let mut permission_prompter = CliPermissionPrompter::new(self.permission_mode);
+        let summary = runtime.run_turn(prompt, Some(&mut permission_prompter))?;
+        Ok(final_assistant_text(&summary).trim().to_string())
+    }
+
+    fn run_bughunter(&self, scope: Option<&str>) -> Result<(), Box<dyn std::error::Error>> {
+        let scope = scope.unwrap_or("the current repository");
+        let prompt = format!(
+            "You are /bughunter. Inspect {scope} and identify the most likely bugs or correctness issues. Prioritize concrete findings with file paths, severity, and suggested fixes. Use tools if needed."
+        );
+        println!("{}", self.run_internal_prompt_text(&prompt, true)?);
+        Ok(())
+    }
+
+    fn run_ultraplan(&self, task: Option<&str>) -> Result<(), Box<dyn std::error::Error>> {
+        let task = task.unwrap_or("the current repo work");
+        let prompt = format!(
+            "You are /ultraplan. Produce a deep multi-step execution plan for {task}. Include goals, risks, implementation sequence, verification steps, and rollback considerations. Use tools if needed."
+        );
+        println!("{}", self.run_internal_prompt_text(&prompt, true)?);
+        Ok(())
+    }
+
+    fn run_teleport(&self, target: Option<&str>) -> Result<(), Box<dyn std::error::Error>> {
+        let Some(target) = target.map(str::trim).filter(|value| !value.is_empty()) else {
+            println!("Usage: /teleport <symbol-or-path>");
+            return Ok(());
+        };
+
+        println!("{}", render_teleport_report(target)?);
+        Ok(())
+    }
+
+    fn run_debug_tool_call(&self) -> Result<(), Box<dyn std::error::Error>> {
+        println!("{}", render_last_tool_debug_report(self.runtime.session())?);
+        Ok(())
+    }
+
+    fn run_commit(&mut self) -> Result<(), Box<dyn std::error::Error>> {
+        let status = git_output(&["status", "--short"])?;
+        if status.trim().is_empty() {
+            println!("Commit\n  Result           skipped\n  Reason           no workspace changes");
+            return Ok(());
+        }
+
+        git_status_ok(&["add", "-A"])?;
+        let staged_stat = git_output(&["diff", "--cached", "--stat"])?;
+        let prompt = format!(
+            "Generate a git commit message in plain text Lore format only. Base it on this staged diff summary:\n\n{}\n\nRecent conversation context:\n{}",
+            truncate_for_prompt(&staged_stat, 8_000),
+            recent_user_context(self.runtime.session(), 6)
+        );
+        let message = sanitize_generated_message(&self.run_internal_prompt_text(&prompt, false)?);
+        if message.trim().is_empty() {
+            return Err("generated commit message was empty".into());
+        }
+
+        let path = write_temp_text_file("claw-commit-message.txt", &message)?;
+        let output = Command::new("git")
+            .args(["commit", "--file"])
+            .arg(&path)
+            .current_dir(env::current_dir()?)
+            .output()?;
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
+            return Err(format!("git commit failed: {stderr}").into());
+        }
+
+        println!(
+            "Commit\n  Result           created\n  Message file     {}\n\n{}",
+            path.display(),
+            message.trim()
+        );
+        Ok(())
+    }
+
+    fn run_pr(&self, context: Option<&str>) -> Result<(), Box<dyn std::error::Error>> {
+        let staged = git_output(&["diff", "--stat"])?;
+        let prompt = format!(
+            "Generate a pull request title and body from this conversation and diff summary. Output plain text in this format exactly:\nTITLE: <title>\nBODY:\n<body markdown>\n\nContext hint: {}\n\nDiff summary:\n{}",
+            context.unwrap_or("none"),
+            truncate_for_prompt(&staged, 10_000)
+        );
+        let draft = sanitize_generated_message(&self.run_internal_prompt_text(&prompt, false)?);
+        let (title, body) = parse_titled_body(&draft)
+            .ok_or_else(|| "failed to parse generated PR title/body".to_string())?;
+
+        if command_exists("gh") {
+            let body_path = write_temp_text_file("claw-pr-body.md", &body)?;
+            let output = Command::new("gh")
+                .args(["pr", "create", "--title", &title, "--body-file"])
+                .arg(&body_path)
+                .current_dir(env::current_dir()?)
+                .output()?;
+            if output.status.success() {
+                let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
+                println!(
+                    "PR\n  Result           created\n  Title            {title}\n  URL              {}",
+                    if stdout.is_empty() { "<unknown>" } else { &stdout }
+                );
+                return Ok(());
+            }
+        }
+
+        println!("PR draft\n  Title            {title}\n\n{body}");
+        Ok(())
+    }
+
+    fn run_issue(&self, context: Option<&str>) -> Result<(), Box<dyn std::error::Error>> {
+        let prompt = format!(
+            "Generate a GitHub issue title and body from this conversation. Output plain text in this format exactly:\nTITLE: <title>\nBODY:\n<body markdown>\n\nContext hint: {}\n\nConversation context:\n{}",
+            context.unwrap_or("none"),
+            truncate_for_prompt(&recent_user_context(self.runtime.session(), 10), 10_000)
+        );
+        let draft = sanitize_generated_message(&self.run_internal_prompt_text(&prompt, false)?);
+        let (title, body) = parse_titled_body(&draft)
+            .ok_or_else(|| "failed to parse generated issue title/body".to_string())?;
+
+        if command_exists("gh") {
+            let body_path = write_temp_text_file("claw-issue-body.md", &body)?;
+            let output = Command::new("gh")
+                .args(["issue", "create", "--title", &title, "--body-file"])
+                .arg(&body_path)
+                .current_dir(env::current_dir()?)
+                .output()?;
+            if output.status.success() {
+                let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
+                println!(
+                    "Issue\n  Result           created\n  Title            {title}\n  URL              {}",
+                    if stdout.is_empty() { "<unknown>" } else { &stdout }
+                );
+                return Ok(());
+            }
+        }
+
+        println!("Issue draft\n  Title            {title}\n\n{body}");
+        Ok(())
+    }
 }
 
 fn sessions_dir() -> Result<PathBuf, Box<dyn std::error::Error>> {
@@ -1516,61 +1660,44 @@ fn sessions_dir() -> Result<PathBuf, Box<dyn std::error::Error>> {
     Ok(path)
 }
 
-fn create_managed_session_handle(
-    session_id: &str,
-) -> Result<SessionHandle, Box<dyn std::error::Error>> {
-    let id = session_id.to_string();
-    let path = sessions_dir()?.join(format!("{id}.{PRIMARY_SESSION_EXTENSION}"));
+fn create_managed_session_handle() -> Result<SessionHandle, Box<dyn std::error::Error>> {
+    let id = generate_session_id();
+    let path = sessions_dir()?.join(format!("{id}.json"));
     Ok(SessionHandle { id, path })
 }
 
+fn generate_session_id() -> String {
+    let millis = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|duration| duration.as_millis())
+        .unwrap_or_default();
+    format!("session-{millis}")
+}
+
 fn resolve_session_reference(reference: &str) -> Result<SessionHandle, Box<dyn std::error::Error>> {
     let direct = PathBuf::from(reference);
-    let looks_like_path = direct.extension().is_some() || direct.components().count() > 1;
     let path = if direct.exists() {
         direct
-    } else if looks_like_path {
-        return Err(format!("session not found: {reference}").into());
     } else {
-        resolve_managed_session_path(reference)?
+        sessions_dir()?.join(format!("{reference}.json"))
     };
+    if !path.exists() {
+        return Err(format!("session not found: {reference}").into());
+    }
     let id = path
-        .file_name()
+        .file_stem()
         .and_then(|value| value.to_str())
-        .and_then(|name| {
-            name.strip_suffix(&format!(".{PRIMARY_SESSION_EXTENSION}"))
-                .or_else(|| name.strip_suffix(&format!(".{LEGACY_SESSION_EXTENSION}")))
-        })
         .unwrap_or(reference)
         .to_string();
     Ok(SessionHandle { id, path })
 }
 
-fn resolve_managed_session_path(session_id: &str) -> Result<PathBuf, Box<dyn std::error::Error>> {
-    let directory = sessions_dir()?;
-    for extension in [PRIMARY_SESSION_EXTENSION, LEGACY_SESSION_EXTENSION] {
-        let path = directory.join(format!("{session_id}.{extension}"));
-        if path.exists() {
-            return Ok(path);
-        }
-    }
-    Err(format!("session not found: {session_id}").into())
-}
-
-fn is_managed_session_file(path: &Path) -> bool {
-    path.extension()
-        .and_then(|ext| ext.to_str())
-        .is_some_and(|extension| {
-            extension == PRIMARY_SESSION_EXTENSION || extension == LEGACY_SESSION_EXTENSION
-        })
-}
-
 fn list_managed_sessions() -> Result<Vec<ManagedSessionSummary>, Box<dyn std::error::Error>> {
     let mut sessions = Vec::new();
     for entry in fs::read_dir(sessions_dir()?)? {
         let entry = entry?;
         let path = entry.path();
-        if !is_managed_session_file(&path) {
+        if path.extension().and_then(|ext| ext.to_str()) != Some("json") {
             continue;
         }
         let metadata = entry.metadata()?;
@@ -1580,41 +1707,19 @@ fn list_managed_sessions() -> Result<Vec<ManagedSessionSummary>, Box<dyn std::er
             .and_then(|time| time.duration_since(UNIX_EPOCH).ok())
             .map(|duration| duration.as_secs())
             .unwrap_or_default();
-        let (id, message_count, parent_session_id, branch_name) = Session::load_from_path(&path)
-            .map(|session| {
-                let parent_session_id = session
-                    .fork
-                    .as_ref()
-                    .map(|fork| fork.parent_session_id.clone());
-                let branch_name = session
-                    .fork
-                    .as_ref()
-                    .and_then(|fork| fork.branch_name.clone());
-                (
-                    session.session_id,
-                    session.messages.len(),
-                    parent_session_id,
-                    branch_name,
-                )
-            })
-            .unwrap_or_else(|_| {
-                (
-                    path.file_stem()
+        let message_count = Session::load_from_path(&path)
+            .map(|session| session.messages.len())
+            .unwrap_or_default();
+        let id = path
+            .file_stem()
             .and_then(|value| value.to_str())
             .unwrap_or("unknown")
-                        .to_string(),
-                    0,
-                    None,
-                    None,
-                )
-            });
+            .to_string();
         sessions.push(ManagedSessionSummary {
             id,
             path,
             modified_epoch_secs,
             message_count,
-            parent_session_id,
-            branch_name,
         });
     }
     sessions.sort_by(|left, right| right.modified_epoch_secs.cmp(&left.modified_epoch_secs));
@@ -1637,23 +1742,11 @@ fn render_session_list(active_session_id: &str) -> Result<String, Box<dyn std::e
         } else {
             "○ saved"
         };
-        let lineage = match (
-            session.branch_name.as_deref(),
-            session.parent_session_id.as_deref(),
-        ) {
-            (Some(branch_name), Some(parent_session_id)) => {
-                format!(" branch={branch_name} from={parent_session_id}")
-            }
-            (None, Some(parent_session_id)) => format!(" from={parent_session_id}"),
-            (Some(branch_name), None) => format!(" branch={branch_name}"),
-            (None, None) => String::new(),
-        };
         lines.push(format!(
-            "  {id:<20} {marker:<10} msgs={msgs:<4} modified={modified}{lineage} path={path}",
+            "  {id:<20} {marker:<10} msgs={msgs:<4} modified={modified} path={path}",
             id = session.id,
             msgs = session.message_count,
             modified = session.modified_epoch_secs,
-            lineage = lineage,
             path = session.path.display(),
         ));
     }
@@ -1909,6 +2002,206 @@ fn render_diff_report() -> Result<String, Box<dyn std::error::Error>> {
     Ok(format!("Diff\n\n{}", diff.trim_end()))
 }
 
+fn render_teleport_report(target: &str) -> Result<String, Box<dyn std::error::Error>> {
+    let cwd = env::current_dir()?;
+
+    let file_list = Command::new("rg")
+        .args(["--files"])
+        .current_dir(&cwd)
+        .output()?;
+    let file_matches = if file_list.status.success() {
+        String::from_utf8(file_list.stdout)?
+            .lines()
+            .filter(|line| line.contains(target))
+            .take(10)
+            .map(ToOwned::to_owned)
+            .collect::<Vec<_>>()
+    } else {
+        Vec::new()
+    };
+
+    let content_output = Command::new("rg")
+        .args(["-n", "-S", "--color", "never", target, "."])
+        .current_dir(&cwd)
+        .output()?;
+
+    let mut lines = vec![format!("Teleport\n  Target           {target}")];
+    if !file_matches.is_empty() {
+        lines.push(String::new());
+        lines.push("File matches".to_string());
+        lines.extend(file_matches.into_iter().map(|path| format!("  {path}")));
+    }
+
+    if content_output.status.success() {
+        let matches = String::from_utf8(content_output.stdout)?;
+        if !matches.trim().is_empty() {
+            lines.push(String::new());
+            lines.push("Content matches".to_string());
+            lines.push(truncate_for_prompt(&matches, 4_000));
+        }
+    }
+
+    if lines.len() == 1 {
+        lines.push("  Result           no matches found".to_string());
+    }
+
+    Ok(lines.join("\n"))
+}
+
+fn render_last_tool_debug_report(session: &Session) -> Result<String, Box<dyn std::error::Error>> {
+    let last_tool_use = session
+        .messages
+        .iter()
+        .rev()
+        .find_map(|message| {
+            message.blocks.iter().rev().find_map(|block| match block {
+                ContentBlock::ToolUse { id, name, input } => {
+                    Some((id.clone(), name.clone(), input.clone()))
+                }
+                _ => None,
+            })
+        })
+        .ok_or_else(|| "no prior tool call found in session".to_string())?;
+
+    let tool_result = session.messages.iter().rev().find_map(|message| {
+        message.blocks.iter().rev().find_map(|block| match block {
+            ContentBlock::ToolResult {
+                tool_use_id,
+                tool_name,
+                output,
+                is_error,
+            } if tool_use_id == &last_tool_use.0 => {
+                Some((tool_name.clone(), output.clone(), *is_error))
+            }
+            _ => None,
+        })
+    });
+
+    let mut lines = vec![
+        "Debug tool call".to_string(),
+        format!("  Tool id          {}", last_tool_use.0),
+        format!("  Tool name        {}", last_tool_use.1),
+        "  Input".to_string(),
+        indent_block(&last_tool_use.2, 4),
+    ];
+
+    match tool_result {
+        Some((tool_name, output, is_error)) => {
+            lines.push("  Result".to_string());
+            lines.push(format!("    name           {tool_name}"));
+            lines.push(format!(
+                "    status         {}",
+                if is_error { "error" } else { "ok" }
+            ));
+            lines.push(indent_block(&output, 4));
+        }
+        None => lines.push("  Result           missing tool result".to_string()),
+    }
+
+    Ok(lines.join("\n"))
+}
+
+fn indent_block(value: &str, spaces: usize) -> String {
+    let indent = " ".repeat(spaces);
+    value
+        .lines()
+        .map(|line| format!("{indent}{line}"))
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+fn git_output(args: &[&str]) -> Result<String, Box<dyn std::error::Error>> {
+    let output = Command::new("git")
+        .args(args)
+        .current_dir(env::current_dir()?)
+        .output()?;
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
+        return Err(format!("git {} failed: {stderr}", args.join(" ")).into());
+    }
+    Ok(String::from_utf8(output.stdout)?)
+}
+
+fn git_status_ok(args: &[&str]) -> Result<(), Box<dyn std::error::Error>> {
+    let output = Command::new("git")
+        .args(args)
+        .current_dir(env::current_dir()?)
+        .output()?;
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
+        return Err(format!("git {} failed: {stderr}", args.join(" ")).into());
+    }
+    Ok(())
+}
+
+fn command_exists(name: &str) -> bool {
+    Command::new("which")
+        .arg(name)
+        .output()
+        .map(|output| output.status.success())
+        .unwrap_or(false)
+}
+
+fn write_temp_text_file(
+    filename: &str,
+    contents: &str,
+) -> Result<PathBuf, Box<dyn std::error::Error>> {
+    let path = env::temp_dir().join(filename);
+    fs::write(&path, contents)?;
+    Ok(path)
+}
+
+fn recent_user_context(session: &Session, limit: usize) -> String {
+    let requests = session
+        .messages
+        .iter()
+        .filter(|message| message.role == MessageRole::User)
+        .filter_map(|message| {
+            message.blocks.iter().find_map(|block| match block {
+                ContentBlock::Text { text } => Some(text.trim().to_string()),
+                _ => None,
+            })
+        })
+        .rev()
+        .take(limit)
+        .collect::<Vec<_>>();
+
+    if requests.is_empty() {
+        "<no prior user messages>".to_string()
+    } else {
+        requests
+            .into_iter()
+            .rev()
+            .enumerate()
+            .map(|(index, text)| format!("{}. {}", index + 1, text))
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+}
+
+fn truncate_for_prompt(value: &str, limit: usize) -> String {
+    if value.chars().count() <= limit {
+        value.trim().to_string()
+    } else {
+        let truncated = value.chars().take(limit).collect::<String>();
+        format!("{}\n…[truncated]", truncated.trim_end())
+    }
+}
+
+fn sanitize_generated_message(value: &str) -> String {
+    value.trim().trim_matches('`').trim().replace("\r\n", "\n")
+}
+
+fn parse_titled_body(value: &str) -> Option<(String, String)> {
+    let normalized = sanitize_generated_message(value);
+    let title = normalized
+        .lines()
+        .find_map(|line| line.strip_prefix("TITLE:").map(str::trim))?;
+    let body_start = normalized.find("BODY:")?;
+    let body = normalized[body_start + "BODY:".len()..].trim();
+    Some((title.to_string(), body.to_string()))
+}
+
 fn render_version_report() -> String {
     let git_sha = GIT_SHA.unwrap_or("unknown");
     let target = BUILD_TARGET.unwrap_or("unknown");
@@ -2013,15 +2306,6 @@ fn build_system_prompt() -> Result<Vec<String>, Box<dyn std::error::Error>> {
     )?)
 }
 
-fn build_runtime_feature_config(
-) -> Result<runtime::RuntimeFeatureConfig, Box<dyn std::error::Error>> {
-    let cwd = env::current_dir()?;
-    Ok(ConfigLoader::default_for(cwd)
-        .load()?
-        .feature_config()
-        .clone())
-}
-
 fn build_runtime(
     session: Session,
     model: String,
@@ -2032,13 +2316,12 @@ fn build_runtime(
     permission_mode: PermissionMode,
 ) -> Result<ConversationRuntime<AnthropicRuntimeClient, CliToolExecutor>, Box<dyn std::error::Error>>
 {
-    Ok(ConversationRuntime::new_with_features(
+    Ok(ConversationRuntime::new(
         session,
         AnthropicRuntimeClient::new(model, enable_tools, emit_output, allowed_tools.clone())?,
         CliToolExecutor::new(allowed_tools, emit_output),
         permission_policy(permission_mode),
         system_prompt,
-        build_runtime_feature_config()?,
     ))
 }
 
@@ -2857,7 +3140,7 @@ fn print_help_to(out: &mut impl Write) -> io::Result<()> {
     writeln!(out, "      Shorthand non-interactive prompt mode")?;
     writeln!(
         out,
-        "  claw --resume SESSION.jsonl [/status] [/compact] [...]"
+        "  claw --resume SESSION.json [/status] [/compact] [...]"
     )?;
     writeln!(
         out,
@@ -2917,7 +3200,7 @@ fn print_help_to(out: &mut impl Write) -> io::Result<()> {
     )?;
     writeln!(
         out,
-        "  claw --resume session.jsonl /status /diff /export notes.txt"
+        "  claw --resume session.json /status /diff /export notes.txt"
     )?;
     writeln!(out, "  claw login")?;
     writeln!(out, "  claw init")?;
@@ -2931,23 +3214,18 @@ fn print_help() {
 #[cfg(test)]
 mod tests {
     use super::{
-        create_managed_session_handle, filter_tool_specs, format_compact_report,
-        format_cost_report, format_model_report, format_model_switch_report,
-        format_permissions_report, format_permissions_switch_report, format_resume_report,
-        format_status_report, format_tool_call_start, format_tool_result,
+        filter_tool_specs, format_compact_report, format_cost_report, format_model_report,
+        format_model_switch_report, format_permissions_report, format_permissions_switch_report,
+        format_resume_report, format_status_report, format_tool_call_start, format_tool_result,
         normalize_permission_mode, parse_args, parse_git_status_metadata, print_help_to,
         push_output_block, render_config_report, render_memory_report, render_repl_help,
-        resolve_model_alias, resolve_session_reference, response_to_events,
-        resume_supported_slash_commands, status_context, CliAction, CliOutputFormat, SlashCommand,
-        StatusUsage, DEFAULT_MODEL,
+        resolve_model_alias, response_to_events, resume_supported_slash_commands, status_context,
+        CliAction, CliOutputFormat, SlashCommand, StatusUsage, DEFAULT_MODEL,
     };
     use api::{MessageResponse, OutputContentBlock, Usage};
-    use runtime::{
-        AssistantEvent, ContentBlock, ConversationMessage, MessageRole, PermissionMode, Session,
-    };
+    use runtime::{AssistantEvent, ContentBlock, ConversationMessage, MessageRole, PermissionMode};
     use serde_json::json;
     use std::path::PathBuf;
-    use std::sync::{Mutex, OnceLock};
 
     #[test]
     fn defaults_to_repl_when_no_args() {
@@ -3121,13 +3399,13 @@ mod tests {
     fn parses_resume_flag_with_slash_command() {
         let args = vec![
             "--resume".to_string(),
-            "session.jsonl".to_string(),
+            "session.json".to_string(),
             "/compact".to_string(),
         ];
         assert_eq!(
             parse_args(&args).expect("args should parse"),
             CliAction::ResumeSession {
-                session_path: PathBuf::from("session.jsonl"),
+                session_path: PathBuf::from("session.json"),
                 commands: vec!["/compact".to_string()],
             }
         );
@@ -3137,7 +3415,7 @@ mod tests {
     fn parses_resume_flag_with_multiple_slash_commands() {
         let args = vec![
             "--resume".to_string(),
-            "session.jsonl".to_string(),
+            "session.json".to_string(),
             "/status".to_string(),
             "/compact".to_string(),
             "/cost".to_string(),
@@ -3145,7 +3423,7 @@ mod tests {
         assert_eq!(
             parse_args(&args).expect("args should parse"),
             CliAction::ResumeSession {
-                session_path: PathBuf::from("session.jsonl"),
+                session_path: PathBuf::from("session.json"),
                 commands: vec![
                     "/status".to_string(),
                     "/compact".to_string(),
@@ -3173,7 +3451,7 @@ mod tests {
     fn shared_help_uses_resume_annotation_copy() {
         let help = commands::render_slash_command_help();
         assert!(help.contains("Slash commands"));
-        assert!(help.contains("works with --resume SESSION.jsonl"));
+        assert!(help.contains("works with --resume SESSION.json"));
     }
 
     #[test]
@@ -3193,7 +3471,7 @@ mod tests {
         assert!(help.contains("/diff"));
         assert!(help.contains("/version"));
         assert!(help.contains("/export [file]"));
-        assert!(help.contains("/session [list|switch <session-id>|fork [branch-name]]"));
+        assert!(help.contains("/session [list|switch <session-id>]"));
         assert!(help.contains("/exit"));
     }
 
@@ -3214,9 +3492,9 @@ mod tests {
 
     #[test]
     fn resume_report_uses_sectioned_layout() {
-        let report = format_resume_report("session.jsonl", 14, 6);
+        let report = format_resume_report("session.json", 14, 6);
         assert!(report.contains("Session resumed"));
-        assert!(report.contains("Session file     session.jsonl"));
+        assert!(report.contains("Session file     session.json"));
         assert!(report.contains("Messages         14"));
         assert!(report.contains("Turns            6"));
     }
@@ -3318,7 +3596,7 @@ mod tests {
             "workspace-write",
             &super::StatusContext {
                 cwd: PathBuf::from("/tmp/project"),
-                session_path: Some(PathBuf::from("session.jsonl")),
+                session_path: Some(PathBuf::from("session.json")),
                 loaded_config_files: 2,
                 discovered_config_files: 3,
                 memory_file_count: 4,
@@ -3335,7 +3613,7 @@ mod tests {
         assert!(status.contains("Cwd              /tmp/project"));
         assert!(status.contains("Project root     /tmp"));
         assert!(status.contains("Git branch       main"));
-        assert!(status.contains("Session          session.jsonl"));
+        assert!(status.contains("Session          session.json"));
         assert!(status.contains("Config files     loaded 2/3"));
         assert!(status.contains("Memory files     4"));
     }
@@ -3410,9 +3688,9 @@ mod tests {
     #[test]
     fn parses_resume_and_config_slash_commands() {
         assert_eq!(
-            SlashCommand::parse("/resume saved-session.jsonl"),
+            SlashCommand::parse("/resume saved-session.json"),
             Some(SlashCommand::Resume {
-                session_path: Some("saved-session.jsonl".to_string())
+                session_path: Some("saved-session.json".to_string())
             })
         );
         assert_eq!(
@@ -3431,65 +3709,6 @@ mod tests {
         );
         assert_eq!(SlashCommand::parse("/memory"), Some(SlashCommand::Memory));
         assert_eq!(SlashCommand::parse("/init"), Some(SlashCommand::Init));
-        assert_eq!(
-            SlashCommand::parse("/session fork incident-review"),
-            Some(SlashCommand::Session {
-                action: Some("fork".to_string()),
-                target: Some("incident-review".to_string())
-            })
-        );
-    }
-
-    #[test]
-    fn help_mentions_jsonl_resume_examples() {
-        let mut help = Vec::new();
-        print_help_to(&mut help).expect("help should render");
-        let help = String::from_utf8(help).expect("help should be utf8");
-        assert!(help.contains("claw --resume SESSION.jsonl"));
-        assert!(help.contains("claw --resume session.jsonl /status /diff /export notes.txt"));
-    }
-
-    #[test]
-    fn managed_sessions_default_to_jsonl_and_resolve_legacy_json() {
-        let _guard = cwd_lock().lock().expect("cwd lock");
-        let workspace = temp_workspace("session-resolution");
-        std::fs::create_dir_all(&workspace).expect("workspace should create");
-        let previous = std::env::current_dir().expect("cwd");
-        std::env::set_current_dir(&workspace).expect("switch cwd");
-
-        let handle = create_managed_session_handle("session-alpha").expect("jsonl handle");
-        assert!(handle.path.ends_with("session-alpha.jsonl"));
-
-        let legacy_path = workspace.join(".claude/sessions/legacy.json");
-        std::fs::create_dir_all(
-            legacy_path
-                .parent()
-                .expect("legacy path should have parent directory"),
-        )
-        .expect("session dir should exist");
-        Session::new()
-            .with_persistence_path(legacy_path.clone())
-            .save_to_path(&legacy_path)
-            .expect("legacy session should save");
-
-        let resolved = resolve_session_reference("legacy").expect("legacy session should resolve");
-        assert_eq!(resolved.path, legacy_path);
-
-        std::env::set_current_dir(previous).expect("restore cwd");
-        std::fs::remove_dir_all(workspace).expect("workspace should clean up");
-    }
-
-    fn cwd_lock() -> &'static Mutex<()> {
-        static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
-        LOCK.get_or_init(|| Mutex::new(()))
-    }
-
-    fn temp_workspace(label: &str) -> PathBuf {
-        let nanos = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .expect("system time should be after epoch")
-            .as_nanos();
-        std::env::temp_dir().join(format!("claw-cli-{label}-{nanos}"))
     }
 
     #[test]