feat: jsonl-session progress

rust/crates/commands/src/lib.rs

@@ -125,8 +125,8 @@ const SLASH_COMMAND_SPECS: &[SlashCommandSpec] = &[
     },
     SlashCommandSpec {
         name: "session",
-        summary: "List or switch managed local sessions",
-        argument_hint: Some("[list|switch <session-id>]"),
+        summary: "List, switch, or fork managed local sessions",
+        argument_hint: Some("[list|switch <session-id>|fork [branch-name]]"),
         resume_supported: false,
     },
 ];
@@ -229,7 +229,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.json".to_string(),
+        "  [resume] means the command also works with --resume SESSION.jsonl".to_string(),
     ];
     for spec in slash_command_specs() {
         let name = match spec.argument_hint {
@@ -365,12 +365,19 @@ 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.json"));
+        assert!(help.contains("works with --resume SESSION.jsonl"));
         assert!(help.contains("/help"));
         assert!(help.contains("/status"));
         assert!(help.contains("/compact"));
@@ -385,26 +392,24 @@ mod tests {
         assert!(help.contains("/diff"));
         assert!(help.contains("/version"));
         assert!(help.contains("/export [file]"));
-        assert!(help.contains("/session [list|switch <session-id>]"));
+        assert!(help.contains("/session [list|switch <session-id>|fork [branch-name]]"));
         assert_eq!(slash_command_specs().len(), 15);
         assert_eq!(resume_supported_slash_commands().len(), 11);
     }
 
     #[test]
     fn compacts_sessions_via_slash_command() {
-        let session = Session {
-            version: 1,
-            messages: vec![
-                ConversationMessage::user_text("a ".repeat(200)),
-                ConversationMessage::assistant(vec![ContentBlock::Text {
-                    text: "b ".repeat(200),
-                }]),
-                ConversationMessage::tool_result("1", "bash", "ok ".repeat(200), false),
-                ConversationMessage::assistant(vec![ContentBlock::Text {
-                    text: "recent".to_string(),
-                }]),
-            ],
-        };
+        let mut session = Session::new();
+        session.messages = vec![
+            ConversationMessage::user_text("a ".repeat(200)),
+            ConversationMessage::assistant(vec![ContentBlock::Text {
+                text: "b ".repeat(200),
+            }]),
+            ConversationMessage::tool_result("1", "bash", "ok ".repeat(200), false),
+            ConversationMessage::assistant(vec![ContentBlock::Text {
+                text: "recent".to_string(),
+            }]),
+        ];
 
         let result = handle_slash_command(
             "/compact",
@@ -455,6 +460,12 @@ 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,13 +99,14 @@ pub fn compact_session(session: &Session, config: CompactionConfig) -> Compactio
     }];
     compacted_messages.extend(preserved);
 
+    let mut compacted_session = session.clone();
+    compacted_session.messages = compacted_messages;
+    compacted_session.record_compaction(summary.clone(), removed.len());
+
     CompactionResult {
         summary,
         formatted_summary,
-        compacted_session: Session {
-            version: session.version,
-            messages: compacted_messages,
-        },
+        compacted_session,
         removed_message_count: removed.len(),
     }
 }
@@ -390,10 +391,8 @@ mod tests {
 
     #[test]
     fn leaves_small_sessions_unchanged() {
-        let session = Session {
-            version: 1,
-            messages: vec![ConversationMessage::user_text("hello")],
-        };
+        let mut session = Session::new();
+        session.messages = vec![ConversationMessage::user_text("hello")];
 
         let result = compact_session(&session, CompactionConfig::default());
         assert_eq!(result.removed_message_count, 0);
@@ -404,23 +403,21 @@ mod tests {
 
     #[test]
     fn compacts_older_messages_into_a_system_summary() {
-        let session = Session {
-            version: 1,
-            messages: vec![
-                ConversationMessage::user_text("one ".repeat(200)),
-                ConversationMessage::assistant(vec![ContentBlock::Text {
-                    text: "two ".repeat(200),
-                }]),
-                ConversationMessage::tool_result("1", "bash", "ok ".repeat(200), false),
-                ConversationMessage {
-                    role: MessageRole::Assistant,
-                    blocks: vec![ContentBlock::Text {
-                        text: "recent".to_string(),
-                    }],
-                    usage: None,
-                },
-            ],
-        };
+        let mut session = Session::new();
+        session.messages = vec![
+            ConversationMessage::user_text("one ".repeat(200)),
+            ConversationMessage::assistant(vec![ContentBlock::Text {
+                text: "two ".repeat(200),
+            }]),
+            ConversationMessage::tool_result("1", "bash", "ok ".repeat(200), false),
+            ConversationMessage {
+                role: MessageRole::Assistant,
+                blocks: vec![ContentBlock::Text {
+                    text: "recent".to_string(),
+                }],
+                usage: None,
+            },
+        ];
 
         let result = compact_session(
             &session,

rust/crates/runtime/src/config.rs

@@ -42,7 +42,6 @@ pub struct RuntimeFeatureConfig {
     oauth: Option<OAuthConfig>,
     model: Option<String>,
     permission_mode: Option<ResolvedPermissionMode>,
-    permission_rules: RuntimePermissionRuleConfig,
     sandbox: SandboxConfig,
 }
 
@@ -50,14 +49,6 @@ pub struct RuntimeFeatureConfig {
 pub struct RuntimeHookConfig {
     pre_tool_use: Vec<String>,
     post_tool_use: Vec<String>,
-    post_tool_use_failure: Vec<String>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub struct RuntimePermissionRuleConfig {
-    allow: Vec<String>,
-    deny: Vec<String>,
-    ask: Vec<String>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
@@ -244,7 +235,6 @@ impl ConfigLoader {
             oauth: parse_optional_oauth_config(&merged_value, "merged settings.oauth")?,
             model: parse_optional_model(&merged_value),
             permission_mode: parse_optional_permission_mode(&merged_value)?,
-            permission_rules: parse_optional_permission_rules(&merged_value)?,
             sandbox: parse_optional_sandbox_config(&merged_value)?,
         };
 
@@ -316,11 +306,6 @@ impl RuntimeConfig {
         self.feature_config.permission_mode
     }
 
-    #[must_use]
-    pub fn permission_rules(&self) -> &RuntimePermissionRuleConfig {
-        &self.feature_config.permission_rules
-    }
-
     #[must_use]
     pub fn sandbox(&self) -> &SandboxConfig {
         &self.feature_config.sandbox
@@ -359,11 +344,6 @@ impl RuntimeFeatureConfig {
         self.permission_mode
     }
 
-    #[must_use]
-    pub fn permission_rules(&self) -> &RuntimePermissionRuleConfig {
-        &self.permission_rules
-    }
-
     #[must_use]
     pub fn sandbox(&self) -> &SandboxConfig {
         &self.sandbox
@@ -372,15 +352,10 @@ impl RuntimeFeatureConfig {
 
 impl RuntimeHookConfig {
     #[must_use]
-    pub fn new(
-        pre_tool_use: Vec<String>,
-        post_tool_use: Vec<String>,
-        post_tool_use_failure: Vec<String>,
-    ) -> Self {
+    pub fn new(pre_tool_use: Vec<String>, post_tool_use: Vec<String>) -> Self {
         Self {
             pre_tool_use,
             post_tool_use,
-            post_tool_use_failure,
         }
     }
 
@@ -393,33 +368,6 @@ impl RuntimeHookConfig {
     pub fn post_tool_use(&self) -> &[String] {
         &self.post_tool_use
     }
-
-    #[must_use]
-    pub fn post_tool_use_failure(&self) -> &[String] {
-        &self.post_tool_use_failure
-    }
-}
-
-impl RuntimePermissionRuleConfig {
-    #[must_use]
-    pub fn new(allow: Vec<String>, deny: Vec<String>, ask: Vec<String>) -> Self {
-        Self { allow, deny, ask }
-    }
-
-    #[must_use]
-    pub fn allow(&self) -> &[String] {
-        &self.allow
-    }
-
-    #[must_use]
-    pub fn deny(&self) -> &[String] {
-        &self.deny
-    }
-
-    #[must_use]
-    pub fn ask(&self) -> &[String] {
-        &self.ask
-    }
 }
 
 impl McpConfigCollection {
@@ -533,32 +481,6 @@ fn parse_optional_hooks_config(root: &JsonValue) -> Result<RuntimeHookConfig, Co
             .unwrap_or_default(),
         post_tool_use: optional_string_array(hooks, "PostToolUse", "merged settings.hooks")?
             .unwrap_or_default(),
-        post_tool_use_failure: optional_string_array(
-            hooks,
-            "PostToolUseFailure",
-            "merged settings.hooks",
-        )?
-        .unwrap_or_default(),
-    })
-}
-
-fn parse_optional_permission_rules(
-    root: &JsonValue,
-) -> Result<RuntimePermissionRuleConfig, ConfigError> {
-    let Some(object) = root.as_object() else {
-        return Ok(RuntimePermissionRuleConfig::default());
-    };
-    let Some(permissions) = object.get("permissions").and_then(JsonValue::as_object) else {
-        return Ok(RuntimePermissionRuleConfig::default());
-    };
-
-    Ok(RuntimePermissionRuleConfig {
-        allow: optional_string_array(permissions, "allow", "merged settings.permissions")?
-            .unwrap_or_default(),
-        deny: optional_string_array(permissions, "deny", "merged settings.permissions")?
-            .unwrap_or_default(),
-        ask: optional_string_array(permissions, "ask", "merged settings.permissions")?
-            .unwrap_or_default(),
     })
 }
 
@@ -921,7 +843,7 @@ mod tests {
         .expect("write user compat config");
         fs::write(
             home.join("settings.json"),
-            r#"{"model":"sonnet","env":{"A2":"1"},"hooks":{"PreToolUse":["base"]},"permissions":{"defaultMode":"plan","allow":["Read"],"deny":["Bash(rm -rf)"]}}"#,
+            r#"{"model":"sonnet","env":{"A2":"1"},"hooks":{"PreToolUse":["base"]},"permissions":{"defaultMode":"plan"}}"#,
         )
         .expect("write user settings");
         fs::write(
@@ -931,7 +853,7 @@ mod tests {
         .expect("write project compat config");
         fs::write(
             cwd.join(".claude").join("settings.json"),
-            r#"{"env":{"C":"3"},"hooks":{"PostToolUse":["project"],"PostToolUseFailure":["project-failure"]},"permissions":{"ask":["Edit"]},"mcpServers":{"project":{"command":"uvx","args":["project"]}}}"#,
+            r#"{"env":{"C":"3"},"hooks":{"PostToolUse":["project"]},"mcpServers":{"project":{"command":"uvx","args":["project"]}}}"#,
         )
         .expect("write project settings");
         fs::write(
@@ -976,16 +898,6 @@ mod tests {
             .contains_key("PostToolUse"));
         assert_eq!(loaded.hooks().pre_tool_use(), &["base".to_string()]);
         assert_eq!(loaded.hooks().post_tool_use(), &["project".to_string()]);
-        assert_eq!(
-            loaded.hooks().post_tool_use_failure(),
-            &["project-failure".to_string()]
-        );
-        assert_eq!(loaded.permission_rules().allow(), &["Read".to_string()]);
-        assert_eq!(
-            loaded.permission_rules().deny(),
-            &["Bash(rm -rf)".to_string()]
-        );
-        assert_eq!(loaded.permission_rules().ask(), &["Edit".to_string()]);
         assert!(loaded.mcp().get("home").is_some());
         assert!(loaded.mcp().get("project").is_some());
 

rust/crates/runtime/src/conversation.rs

@@ -5,10 +5,8 @@ use crate::compact::{
     compact_session, estimate_session_tokens, CompactionConfig, CompactionResult,
 };
 use crate::config::RuntimeFeatureConfig;
-use crate::hooks::{HookAbortSignal, HookProgressReporter, HookRunResult, HookRunner};
-use crate::permissions::{
-    PermissionContext, PermissionOutcome, PermissionPolicy, PermissionPrompter,
-};
+use crate::hooks::{HookRunResult, HookRunner};
+use crate::permissions::{PermissionOutcome, PermissionPolicy, PermissionPrompter};
 use crate::session::{ContentBlock, ConversationMessage, Session};
 use crate::usage::{TokenUsage, UsageTracker};
 
@@ -99,8 +97,6 @@ pub struct ConversationRuntime<C, T> {
     max_iterations: usize,
     usage_tracker: UsageTracker,
     hook_runner: HookRunner,
-    hook_abort_signal: HookAbortSignal,
-    hook_progress_reporter: Option<Box<dyn HookProgressReporter>>,
 }
 
 impl<C, T> ConversationRuntime<C, T>
@@ -127,7 +123,6 @@ where
     }
 
     #[must_use]
-    #[allow(clippy::needless_pass_by_value)]
     pub fn new_with_features(
         session: Session,
         api_client: C,
@@ -146,8 +141,6 @@ where
             max_iterations: usize::MAX,
             usage_tracker,
             hook_runner: HookRunner::from_feature_config(&feature_config),
-            hook_abort_signal: HookAbortSignal::default(),
-            hook_progress_reporter: None,
         }
     }
 
@@ -157,101 +150,14 @@ where
         self
     }
 
-    #[must_use]
-    pub fn with_hook_abort_signal(mut self, hook_abort_signal: HookAbortSignal) -> Self {
-        self.hook_abort_signal = hook_abort_signal;
-        self
-    }
-
-    #[must_use]
-    pub fn with_hook_progress_reporter(
-        mut self,
-        hook_progress_reporter: Box<dyn HookProgressReporter>,
-    ) -> Self {
-        self.hook_progress_reporter = Some(hook_progress_reporter);
-        self
-    }
-
-    fn run_pre_tool_use_hook(&mut self, tool_name: &str, input: &str) -> HookRunResult {
-        if let Some(reporter) = self.hook_progress_reporter.as_mut() {
-            self.hook_runner.run_pre_tool_use_with_context(
-                tool_name,
-                input,
-                Some(&self.hook_abort_signal),
-                Some(reporter.as_mut()),
-            )
-        } else {
-            self.hook_runner.run_pre_tool_use_with_context(
-                tool_name,
-                input,
-                Some(&self.hook_abort_signal),
-                None,
-            )
-        }
-    }
-
-    fn run_post_tool_use_hook(
-        &mut self,
-        tool_name: &str,
-        input: &str,
-        output: &str,
-        is_error: bool,
-    ) -> HookRunResult {
-        if let Some(reporter) = self.hook_progress_reporter.as_mut() {
-            self.hook_runner.run_post_tool_use_with_context(
-                tool_name,
-                input,
-                output,
-                is_error,
-                Some(&self.hook_abort_signal),
-                Some(reporter.as_mut()),
-            )
-        } else {
-            self.hook_runner.run_post_tool_use_with_context(
-                tool_name,
-                input,
-                output,
-                is_error,
-                Some(&self.hook_abort_signal),
-                None,
-            )
-        }
-    }
-
-    fn run_post_tool_use_failure_hook(
-        &mut self,
-        tool_name: &str,
-        input: &str,
-        output: &str,
-    ) -> HookRunResult {
-        if let Some(reporter) = self.hook_progress_reporter.as_mut() {
-            self.hook_runner.run_post_tool_use_failure_with_context(
-                tool_name,
-                input,
-                output,
-                Some(&self.hook_abort_signal),
-                Some(reporter.as_mut()),
-            )
-        } else {
-            self.hook_runner.run_post_tool_use_failure_with_context(
-                tool_name,
-                input,
-                output,
-                Some(&self.hook_abort_signal),
-                None,
-            )
-        }
-    }
-
-    #[allow(clippy::too_many_lines)]
     pub fn run_turn(
         &mut self,
         user_input: impl Into<String>,
         mut prompter: Option<&mut dyn PermissionPrompter>,
     ) -> Result<TurnSummary, RuntimeError> {
         self.session
-            .messages
-            .push(ConversationMessage::user_text(user_input.into()));
+            .push_user_text(user_input.into())
+            .map_err(|error| RuntimeError::new(error.to_string()))?;
 
         let mut assistant_messages = Vec::new();
         let mut tool_results = Vec::new();
@@ -285,7 +191,9 @@ where
                 })
                 .collect::<Vec<_>>();
 
-            self.session.messages.push(assistant_message.clone());
+            self.session
+                .push_message(assistant_message.clone())
+                .map_err(|error| RuntimeError::new(error.to_string()))?;
             assistant_messages.push(assistant_message);
 
             if pending_tool_uses.is_empty() {
@@ -293,87 +201,59 @@ where
             }
 
             for (tool_use_id, tool_name, input) in pending_tool_uses {
-                let pre_hook_result = self.run_pre_tool_use_hook(&tool_name, &input);
-                let effective_input = pre_hook_result
-                    .updated_input()
-                    .map_or_else(|| input.clone(), ToOwned::to_owned);
-                let permission_context = PermissionContext::new(
-                    pre_hook_result.permission_override(),
-                    pre_hook_result.permission_reason().map(ToOwned::to_owned),
-                );
-
-                let permission_outcome = if pre_hook_result.is_cancelled() {
-                    PermissionOutcome::Deny {
-                        reason: format_hook_message(
-                            &pre_hook_result,
-                            &format!("PreToolUse hook cancelled tool `{tool_name}`"),
-                        ),
-                    }
-                } else if pre_hook_result.is_denied() {
-                    PermissionOutcome::Deny {
-                        reason: format_hook_message(
-                            &pre_hook_result,
-                            &format!("PreToolUse hook denied tool `{tool_name}`"),
-                        ),
-                    }
-                } else if let Some(prompt) = prompter.as_mut() {
-                    self.permission_policy.authorize_with_context(
-                        &tool_name,
-                        &effective_input,
-                        &permission_context,
-                        Some(*prompt),
-                    )
+                let permission_outcome = if let Some(prompt) = prompter.as_mut() {
+                    self.permission_policy
+                        .authorize(&tool_name, &input, Some(*prompt))
                 } else {
-                    self.permission_policy.authorize_with_context(
-                        &tool_name,
-                        &effective_input,
-                        &permission_context,
-                        None,
-                    )
+                    self.permission_policy.authorize(&tool_name, &input, None)
                 };
 
                 let result_message = match permission_outcome {
                     PermissionOutcome::Allow => {
-                        let (mut output, mut is_error) =
-                            match self.tool_executor.execute(&tool_name, &effective_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 = if is_error {
-                            self.run_post_tool_use_failure_hook(
-                                &tool_name,
-                                &effective_input,
-                                &output,
+                        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 {
-                            self.run_post_tool_use_hook(
-                                &tool_name,
-                                &effective_input,
-                                &output,
-                                false,
-                            )
-                        };
-                        if post_hook_result.is_denied() || post_hook_result.is_cancelled() {
-                            is_error = true;
-                        }
-                        output = merge_hook_feedback(
-                            post_hook_result.messages(),
-                            output,
-                            post_hook_result.is_denied() || post_hook_result.is_cancelled(),
-                        );
+                            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);
 
-                        ConversationMessage::tool_result(tool_use_id, tool_name, output, is_error)
+                            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(
+                                tool_use_id,
+                                tool_name,
+                                output,
+                                is_error,
+                            )
+                        }
+                    }
+                    PermissionOutcome::Deny { reason } => {
+                        ConversationMessage::tool_result(tool_use_id, tool_name, reason, true)
                     }
-                    PermissionOutcome::Deny { reason } => ConversationMessage::tool_result(
-                        tool_use_id,
-                        tool_name,
-                        merge_hook_feedback(pre_hook_result.messages(), reason, true),
-                        true,
-                    ),
                 };
-                self.session.messages.push(result_message.clone());
+                self.session
+                    .push_message(result_message.clone())
+                    .map_err(|error| RuntimeError::new(error.to_string()))?;
                 tool_results.push(result_message);
             }
         }
@@ -406,6 +286,11 @@ where
         &self.session
     }
 
+    #[must_use]
+    pub fn fork_session(&self, branch_name: Option<String>) -> Session {
+        self.session.fork(branch_name)
+    }
+
     #[must_use]
     pub fn into_session(self) -> Session {
         self.session
@@ -532,7 +417,9 @@ mod tests {
     use crate::prompt::{ProjectContext, SystemPromptBuilder};
     use crate::session::{ContentBlock, MessageRole, Session};
     use crate::usage::TokenUsage;
+    use std::fs;
     use std::path::PathBuf;
+    use std::time::{SystemTime, UNIX_EPOCH};
 
     struct ScriptedApiClient {
         call_count: usize,
@@ -736,7 +623,6 @@ mod tests {
             RuntimeFeatureConfig::default().with_hooks(RuntimeHookConfig::new(
                 vec![shell_snippet("printf 'blocked by hook'; exit 2")],
                 Vec::new(),
-                Vec::new(),
             )),
         );
 
@@ -803,7 +689,6 @@ mod tests {
             RuntimeFeatureConfig::default().with_hooks(RuntimeHookConfig::new(
                 vec![shell_snippet("printf 'pre hook ran'")],
                 vec![shell_snippet("printf 'post hook ran'")],
-                Vec::new(),
             )),
         );
 
@@ -823,7 +708,7 @@ mod tests {
             "post hook should preserve non-error result: {output:?}"
         );
         assert!(
-            output.contains('4'),
+            output.contains("4"),
             "tool output missing value: {output:?}"
         );
         assert!(
@@ -913,6 +798,86 @@ mod tests {
             result.compacted_session.messages[0].role,
             MessageRole::System
         );
+        assert_eq!(
+            result.compacted_session.session_id,
+            runtime.session().session_id
+        );
+        assert!(result.compacted_session.compaction.is_some());
+    }
+
+    #[test]
+    fn persists_conversation_turn_messages_to_jsonl_session() {
+        struct SimpleApi;
+        impl ApiClient for SimpleApi {
+            fn stream(
+                &mut self,
+                _request: ApiRequest,
+            ) -> Result<Vec<AssistantEvent>, RuntimeError> {
+                Ok(vec![
+                    AssistantEvent::TextDelta("done".to_string()),
+                    AssistantEvent::MessageStop,
+                ])
+            }
+        }
+
+        let path = temp_session_path("persisted-turn");
+        let session = Session::new().with_persistence_path(path.clone());
+        let mut runtime = ConversationRuntime::new(
+            session,
+            SimpleApi,
+            StaticToolExecutor::new(),
+            PermissionPolicy::new(PermissionMode::DangerFullAccess),
+            vec!["system".to_string()],
+        );
+
+        runtime
+            .run_turn("persist this turn", None)
+            .expect("turn should succeed");
+
+        let restored = Session::load_from_path(&path).expect("persisted session should reload");
+        fs::remove_file(&path).expect("temp session file should be removable");
+
+        assert_eq!(restored.messages.len(), 2);
+        assert_eq!(restored.messages[0].role, MessageRole::User);
+        assert_eq!(restored.messages[1].role, MessageRole::Assistant);
+        assert_eq!(restored.session_id, runtime.session().session_id);
+    }
+
+    #[test]
+    fn forks_runtime_session_without_mutating_original() {
+        let mut session = Session::new();
+        session
+            .push_user_text("branch me")
+            .expect("message should append");
+
+        let runtime = ConversationRuntime::new(
+            session.clone(),
+            ScriptedApiClient { call_count: 0 },
+            StaticToolExecutor::new(),
+            PermissionPolicy::new(PermissionMode::DangerFullAccess),
+            vec!["system".to_string()],
+        );
+
+        let forked = runtime.fork_session(Some("alt-path".to_string()));
+
+        assert_eq!(forked.messages, session.messages);
+        assert_ne!(forked.session_id, session.session_id);
+        assert_eq!(
+            forked
+                .fork
+                .as_ref()
+                .map(|fork| (fork.parent_session_id.as_str(), fork.branch_name.as_deref())),
+            Some((session.session_id.as_str(), Some("alt-path")))
+        );
+        assert!(runtime.session().fork.is_none());
+    }
+
+    fn temp_session_path(label: &str) -> PathBuf {
+        let nanos = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("system time should be after epoch")
+            .as_nanos();
+        std::env::temp_dir().join(format!("runtime-conversation-{label}-{nanos}.json"))
     }
 
     #[cfg(windows)]

rust/crates/runtime/src/hooks.rs

@@ -1,90 +1,29 @@
 use std::ffi::OsStr;
-use std::io::Write;
-use std::process::{Command, Stdio};
-use std::sync::{
-    atomic::{AtomicBool, Ordering},
-    Arc,
-};
-use std::thread;
-use std::time::Duration;
+use std::process::Command;
 
-use serde_json::{json, Value};
+use serde_json::json;
 
 use crate::config::{RuntimeFeatureConfig, RuntimeHookConfig};
-use crate::permissions::PermissionOverride;
-
-pub type HookPermissionDecision = PermissionOverride;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum HookEvent {
     PreToolUse,
     PostToolUse,
-    PostToolUseFailure,
 }
 
 impl HookEvent {
-    #[must_use]
-    pub fn as_str(self) -> &'static str {
+    fn as_str(self) -> &'static str {
         match self {
             Self::PreToolUse => "PreToolUse",
             Self::PostToolUse => "PostToolUse",
-            Self::PostToolUseFailure => "PostToolUseFailure",
         }
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum HookProgressEvent {
-    Started {
-        event: HookEvent,
-        tool_name: String,
-        command: String,
-    },
-    Completed {
-        event: HookEvent,
-        tool_name: String,
-        command: String,
-    },
-    Cancelled {
-        event: HookEvent,
-        tool_name: String,
-        command: String,
-    },
-}
-
-pub trait HookProgressReporter {
-    fn on_event(&mut self, event: &HookProgressEvent);
-}
-
-#[derive(Debug, Clone, Default)]
-pub struct HookAbortSignal {
-    aborted: Arc<AtomicBool>,
-}
-
-impl HookAbortSignal {
-    #[must_use]
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn abort(&self) {
-        self.aborted.store(true, Ordering::SeqCst);
-    }
-
-    #[must_use]
-    pub fn is_aborted(&self) -> bool {
-        self.aborted.load(Ordering::SeqCst)
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct HookRunResult {
     denied: bool,
-    cancelled: bool,
     messages: Vec<String>,
-    permission_override: Option<PermissionOverride>,
-    permission_reason: Option<String>,
-    updated_input: Option<String>,
 }
 
 impl HookRunResult {
@@ -92,11 +31,7 @@ impl HookRunResult {
     pub fn allow(messages: Vec<String>) -> Self {
         Self {
             denied: false,
-            cancelled: false,
             messages,
-            permission_override: None,
-            permission_reason: None,
-            updated_input: None,
         }
     }
 
@@ -105,40 +40,10 @@ impl HookRunResult {
         self.denied
     }
 
-    #[must_use]
-    pub fn is_cancelled(&self) -> bool {
-        self.cancelled
-    }
-
     #[must_use]
     pub fn messages(&self) -> &[String] {
         &self.messages
     }
-
-    #[must_use]
-    pub fn permission_override(&self) -> Option<PermissionOverride> {
-        self.permission_override
-    }
-
-    #[must_use]
-    pub fn permission_decision(&self) -> Option<HookPermissionDecision> {
-        self.permission_override
-    }
-
-    #[must_use]
-    pub fn permission_reason(&self) -> Option<&str> {
-        self.permission_reason.as_deref()
-    }
-
-    #[must_use]
-    pub fn updated_input(&self) -> Option<&str> {
-        self.updated_input.as_deref()
-    }
-
-    #[must_use]
-    pub fn updated_input_json(&self) -> Option<&str> {
-        self.updated_input()
-    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
@@ -159,39 +64,16 @@ impl HookRunner {
 
     #[must_use]
     pub fn run_pre_tool_use(&self, tool_name: &str, tool_input: &str) -> HookRunResult {
-        self.run_pre_tool_use_with_context(tool_name, tool_input, None, None)
-    }
-
-    #[must_use]
-    pub fn run_pre_tool_use_with_context(
-        &self,
-        tool_name: &str,
-        tool_input: &str,
-        abort_signal: Option<&HookAbortSignal>,
-        reporter: Option<&mut dyn HookProgressReporter>,
-    ) -> HookRunResult {
-        Self::run_commands(
+        self.run_commands(
             HookEvent::PreToolUse,
             self.config.pre_tool_use(),
             tool_name,
             tool_input,
             None,
             false,
-            abort_signal,
-            reporter,
         )
     }
 
-    #[must_use]
-    pub fn run_pre_tool_use_with_signal(
-        &self,
-        tool_name: &str,
-        tool_input: &str,
-        abort_signal: Option<&HookAbortSignal>,
-    ) -> HookRunResult {
-        self.run_pre_tool_use_with_context(tool_name, tool_input, abort_signal, None)
-    }
-
     #[must_use]
     pub fn run_post_tool_use(
         &self,
@@ -200,147 +82,43 @@ impl HookRunner {
         tool_output: &str,
         is_error: bool,
     ) -> HookRunResult {
-        self.run_post_tool_use_with_context(
-            tool_name,
-            tool_input,
-            tool_output,
-            is_error,
-            None,
-            None,
-        )
-    }
-
-    #[must_use]
-    pub fn run_post_tool_use_with_context(
-        &self,
-        tool_name: &str,
-        tool_input: &str,
-        tool_output: &str,
-        is_error: bool,
-        abort_signal: Option<&HookAbortSignal>,
-        reporter: Option<&mut dyn HookProgressReporter>,
-    ) -> HookRunResult {
-        Self::run_commands(
+        self.run_commands(
             HookEvent::PostToolUse,
             self.config.post_tool_use(),
             tool_name,
             tool_input,
             Some(tool_output),
             is_error,
-            abort_signal,
-            reporter,
         )
     }
 
-    #[must_use]
-    pub fn run_post_tool_use_with_signal(
-        &self,
-        tool_name: &str,
-        tool_input: &str,
-        tool_output: &str,
-        is_error: bool,
-        abort_signal: Option<&HookAbortSignal>,
-    ) -> HookRunResult {
-        self.run_post_tool_use_with_context(
-            tool_name,
-            tool_input,
-            tool_output,
-            is_error,
-            abort_signal,
-            None,
-        )
-    }
-
-    #[must_use]
-    pub fn run_post_tool_use_failure(
-        &self,
-        tool_name: &str,
-        tool_input: &str,
-        tool_error: &str,
-    ) -> HookRunResult {
-        self.run_post_tool_use_failure_with_context(tool_name, tool_input, tool_error, None, None)
-    }
-
-    #[must_use]
-    pub fn run_post_tool_use_failure_with_context(
-        &self,
-        tool_name: &str,
-        tool_input: &str,
-        tool_error: &str,
-        abort_signal: Option<&HookAbortSignal>,
-        reporter: Option<&mut dyn HookProgressReporter>,
-    ) -> HookRunResult {
-        Self::run_commands(
-            HookEvent::PostToolUseFailure,
-            self.config.post_tool_use_failure(),
-            tool_name,
-            tool_input,
-            Some(tool_error),
-            true,
-            abort_signal,
-            reporter,
-        )
-    }
-
-    #[must_use]
-    pub fn run_post_tool_use_failure_with_signal(
-        &self,
-        tool_name: &str,
-        tool_input: &str,
-        tool_error: &str,
-        abort_signal: Option<&HookAbortSignal>,
-    ) -> HookRunResult {
-        self.run_post_tool_use_failure_with_context(
-            tool_name,
-            tool_input,
-            tool_error,
-            abort_signal,
-            None,
-        )
-    }
-
-    #[allow(clippy::too_many_arguments)]
     fn run_commands(
+        &self,
         event: HookEvent,
         commands: &[String],
         tool_name: &str,
         tool_input: &str,
         tool_output: Option<&str>,
         is_error: bool,
-        abort_signal: Option<&HookAbortSignal>,
-        mut reporter: Option<&mut dyn HookProgressReporter>,
     ) -> HookRunResult {
         if commands.is_empty() {
             return HookRunResult::allow(Vec::new());
         }
 
-        if abort_signal.is_some_and(HookAbortSignal::is_aborted) {
-            return HookRunResult {
-                denied: false,
-                cancelled: true,
-                messages: vec![format!(
-                    "{} hook cancelled before execution",
-                    event.as_str()
-                )],
-                permission_override: None,
-                permission_reason: None,
-                updated_input: None,
-            };
-        }
+        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 payload = hook_payload(event, tool_name, tool_input, tool_output, is_error).to_string();
-        let mut result = HookRunResult::allow(Vec::new());
+        let mut messages = Vec::new();
 
         for command in commands {
-            if let Some(reporter) = reporter.as_deref_mut() {
-                reporter.on_event(&HookProgressEvent::Started {
-                    event,
-                    tool_name: tool_name.to_string(),
-                    command: command.clone(),
-                });
-            }
-
-            match Self::run_command(
+            match self.run_command(
                 command,
                 event,
                 tool_name,
@@ -348,60 +126,31 @@ impl HookRunner {
                 tool_output,
                 is_error,
                 &payload,
-                abort_signal,
             ) {
-                HookCommandOutcome::Allow { parsed } => {
-                    if let Some(reporter) = reporter.as_deref_mut() {
-                        reporter.on_event(&HookProgressEvent::Completed {
-                            event,
-                            tool_name: tool_name.to_string(),
-                            command: command.clone(),
-                        });
+                HookCommandOutcome::Allow { message } => {
+                    if let Some(message) = message {
+                        messages.push(message);
                     }
-                    merge_parsed_hook_output(&mut result, parsed);
                 }
-                HookCommandOutcome::Deny { parsed } => {
-                    if let Some(reporter) = reporter.as_deref_mut() {
-                        reporter.on_event(&HookProgressEvent::Completed {
-                            event,
-                            tool_name: tool_name.to_string(),
-                            command: command.clone(),
-                        });
-                    }
-                    merge_parsed_hook_output(&mut result, parsed);
-                    result.denied = true;
-                    return result;
-                }
-                HookCommandOutcome::Warn { message } => {
-                    if let Some(reporter) = reporter.as_deref_mut() {
-                        reporter.on_event(&HookProgressEvent::Completed {
-                            event,
-                            tool_name: tool_name.to_string(),
-                            command: command.clone(),
-                        });
-                    }
-                    result.messages.push(message);
-                }
-                HookCommandOutcome::Cancelled { message } => {
-                    if let Some(reporter) = reporter.as_deref_mut() {
-                        reporter.on_event(&HookProgressEvent::Cancelled {
-                            event,
-                            tool_name: tool_name.to_string(),
-                            command: command.clone(),
-                        });
-                    }
-                    result.cancelled = true;
-                    result.messages.push(message);
-                    return result;
+                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),
             }
         }
 
-        result
+        HookRunResult::allow(messages)
     }
 
-    #[allow(clippy::too_many_arguments)]
     fn run_command(
+        &self,
         command: &str,
         event: HookEvent,
         tool_name: &str,
@@ -409,12 +158,11 @@ impl HookRunner {
         tool_output: Option<&str>,
         is_error: bool,
         payload: &str,
-        abort_signal: Option<&HookAbortSignal>,
     ) -> HookCommandOutcome {
         let mut child = shell_command(command);
-        child.stdin(Stdio::piped());
-        child.stdout(Stdio::piped());
-        child.stderr(Stdio::piped());
+        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);
@@ -423,30 +171,19 @@ impl HookRunner {
             child.env("HOOK_TOOL_OUTPUT", tool_output);
         }
 
-        match child.output_with_stdin(payload.as_bytes(), abort_signal) {
-            Ok(CommandExecution::Finished(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 parsed = parse_hook_output(&stdout);
+                let message = (!stdout.is_empty()).then_some(stdout);
                 match output.status.code() {
-                    Some(0) => {
-                        if parsed.deny {
-                            HookCommandOutcome::Deny { parsed }
-                        } else {
-                            HookCommandOutcome::Allow { parsed }
-                        }
-                    }
-                    Some(2) => HookCommandOutcome::Deny {
-                        parsed: parsed.with_fallback_message(format!(
-                            "{} hook denied tool `{tool_name}`",
-                            event.as_str()
-                        )),
-                    },
+                    Some(0) => HookCommandOutcome::Allow { message },
+                    Some(2) => HookCommandOutcome::Deny { message },
                     Some(code) => HookCommandOutcome::Warn {
                         message: format_hook_warning(
                             command,
                             code,
-                            parsed.primary_message(),
+                            message.as_deref(),
                             stderr.as_str(),
                         ),
                     },
@@ -458,12 +195,6 @@ impl HookRunner {
                     },
                 }
             }
-            Ok(CommandExecution::Cancelled) => HookCommandOutcome::Cancelled {
-                message: format!(
-                    "{} hook `{command}` cancelled while handling `{tool_name}`",
-                    event.as_str()
-                ),
-            },
             Err(error) => HookCommandOutcome::Warn {
                 message: format!(
                     "{} hook `{command}` failed to start for `{tool_name}`: {error}",
@@ -475,131 +206,12 @@ impl HookRunner {
 }
 
 enum HookCommandOutcome {
-    Allow { parsed: ParsedHookOutput },
-    Deny { parsed: ParsedHookOutput },
+    Allow { message: Option<String> },
+    Deny { message: Option<String> },
     Warn { message: String },
-    Cancelled { message: String },
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-struct ParsedHookOutput {
-    messages: Vec<String>,
-    deny: bool,
-    permission_override: Option<PermissionOverride>,
-    permission_reason: Option<String>,
-    updated_input: Option<String>,
-}
-
-impl ParsedHookOutput {
-    fn with_fallback_message(mut self, fallback: String) -> Self {
-        if self.messages.is_empty() {
-            self.messages.push(fallback);
-        }
-        self
-    }
-
-    fn primary_message(&self) -> Option<&str> {
-        self.messages.first().map(String::as_str)
-    }
-}
-
-fn merge_parsed_hook_output(target: &mut HookRunResult, parsed: ParsedHookOutput) {
-    target.messages.extend(parsed.messages);
-    if parsed.permission_override.is_some() {
-        target.permission_override = parsed.permission_override;
-    }
-    if parsed.permission_reason.is_some() {
-        target.permission_reason = parsed.permission_reason;
-    }
-    if parsed.updated_input.is_some() {
-        target.updated_input = parsed.updated_input;
-    }
-}
-
-fn parse_hook_output(stdout: &str) -> ParsedHookOutput {
-    if stdout.is_empty() {
-        return ParsedHookOutput::default();
-    }
-
-    let Ok(Value::Object(root)) = serde_json::from_str::<Value>(stdout) else {
-        return ParsedHookOutput {
-            messages: vec![stdout.to_string()],
-            ..ParsedHookOutput::default()
-        };
-    };
-
-    let mut parsed = ParsedHookOutput::default();
-
-    if let Some(message) = root.get("systemMessage").and_then(Value::as_str) {
-        parsed.messages.push(message.to_string());
-    }
-    if let Some(message) = root.get("reason").and_then(Value::as_str) {
-        parsed.messages.push(message.to_string());
-    }
-    if root.get("continue").and_then(Value::as_bool) == Some(false)
-        || root.get("decision").and_then(Value::as_str) == Some("block")
-    {
-        parsed.deny = true;
-    }
-
-    if let Some(Value::Object(specific)) = root.get("hookSpecificOutput") {
-        if let Some(Value::String(additional_context)) = specific.get("additionalContext") {
-            parsed.messages.push(additional_context.clone());
-        }
-        if let Some(decision) = specific.get("permissionDecision").and_then(Value::as_str) {
-            parsed.permission_override = match decision {
-                "allow" => Some(PermissionOverride::Allow),
-                "deny" => Some(PermissionOverride::Deny),
-                "ask" => Some(PermissionOverride::Ask),
-                _ => None,
-            };
-        }
-        if let Some(reason) = specific
-            .get("permissionDecisionReason")
-            .and_then(Value::as_str)
-        {
-            parsed.permission_reason = Some(reason.to_string());
-        }
-        if let Some(updated_input) = specific.get("updatedInput") {
-            parsed.updated_input = serde_json::to_string(updated_input).ok();
-        }
-    }
-
-    if parsed.messages.is_empty() {
-        parsed.messages.push(stdout.to_string());
-    }
-
-    parsed
-}
-
-fn hook_payload(
-    event: HookEvent,
-    tool_name: &str,
-    tool_input: &str,
-    tool_output: Option<&str>,
-    is_error: bool,
-) -> Value {
-    match event {
-        HookEvent::PostToolUseFailure => json!({
-            "hook_event_name": event.as_str(),
-            "tool_name": tool_name,
-            "tool_input": parse_tool_input(tool_input),
-            "tool_input_json": tool_input,
-            "tool_error": tool_output,
-            "tool_result_is_error": true,
-        }),
-        _ => 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,
-        }),
-    }
-}
-
-fn parse_tool_input(tool_input: &str) -> Value {
+fn parse_tool_input(tool_input: &str) -> serde_json::Value {
     serde_json::from_str(tool_input).unwrap_or_else(|_| json!({ "raw": tool_input }))
 }
 
@@ -643,17 +255,17 @@ impl CommandWithStdin {
         Self { command }
     }
 
-    fn stdin(&mut self, cfg: Stdio) -> &mut Self {
+    fn stdin(&mut self, cfg: std::process::Stdio) -> &mut Self {
         self.command.stdin(cfg);
         self
     }
 
-    fn stdout(&mut self, cfg: Stdio) -> &mut Self {
+    fn stdout(&mut self, cfg: std::process::Stdio) -> &mut Self {
         self.command.stdout(cfg);
         self
     }
 
-    fn stderr(&mut self, cfg: Stdio) -> &mut Self {
+    fn stderr(&mut self, cfg: std::process::Stdio) -> &mut Self {
         self.command.stderr(cfg);
         self
     }
@@ -667,64 +279,26 @@ impl CommandWithStdin {
         self
     }
 
-    fn output_with_stdin(
-        &mut self,
-        stdin: &[u8],
-        abort_signal: Option<&HookAbortSignal>,
-    ) -> std::io::Result<CommandExecution> {
+    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)?;
         }
-
-        loop {
-            if abort_signal.is_some_and(HookAbortSignal::is_aborted) {
-                let _ = child.kill();
-                let _ = child.wait_with_output();
-                return Ok(CommandExecution::Cancelled);
-            }
-
-            match child.try_wait()? {
-                Some(_) => return child.wait_with_output().map(CommandExecution::Finished),
-                None => thread::sleep(Duration::from_millis(20)),
-            }
-        }
+        child.wait_with_output()
     }
 }
 
-enum CommandExecution {
-    Finished(std::process::Output),
-    Cancelled,
-}
-
 #[cfg(test)]
 mod tests {
-    use std::thread;
-    use std::time::Duration;
-
-    use super::{
-        HookAbortSignal, HookEvent, HookProgressEvent, HookProgressReporter, HookRunResult,
-        HookRunner,
-    };
+    use super::{HookRunResult, HookRunner};
     use crate::config::{RuntimeFeatureConfig, RuntimeHookConfig};
-    use crate::permissions::PermissionOverride;
-
-    struct RecordingReporter {
-        events: Vec<HookProgressEvent>,
-    }
-
-    impl HookProgressReporter for RecordingReporter {
-        fn on_event(&mut self, event: &HookProgressEvent) {
-            self.events.push(event.clone());
-        }
-    }
 
     #[test]
     fn allows_exit_code_zero_and_captures_stdout() {
         let runner = HookRunner::new(RuntimeHookConfig::new(
             vec![shell_snippet("printf 'pre ok'")],
             Vec::new(),
-            Vec::new(),
         ));
 
         let result = runner.run_pre_tool_use("Read", r#"{"path":"README.md"}"#);
@@ -737,7 +311,6 @@ mod tests {
         let runner = HookRunner::new(RuntimeHookConfig::new(
             vec![shell_snippet("printf 'blocked by hook'; exit 2")],
             Vec::new(),
-            Vec::new(),
         ));
 
         let result = runner.run_pre_tool_use("Bash", r#"{"command":"pwd"}"#);
@@ -752,7 +325,6 @@ mod tests {
             RuntimeHookConfig::new(
                 vec![shell_snippet("printf 'warning hook'; exit 1")],
                 Vec::new(),
-                Vec::new(),
             ),
         ));
 
@@ -765,82 +337,6 @@ mod tests {
             .any(|message| message.contains("allowing tool execution to continue")));
     }
 
-    #[test]
-    fn parses_pre_hook_permission_override_and_updated_input() {
-        let runner = HookRunner::new(RuntimeHookConfig::new(
-            vec![shell_snippet(
-                r#"printf '%s' '{"systemMessage":"updated","hookSpecificOutput":{"permissionDecision":"allow","permissionDecisionReason":"hook ok","updatedInput":{"command":"git status"}}}'"#,
-            )],
-            Vec::new(),
-            Vec::new(),
-        ));
-
-        let result = runner.run_pre_tool_use("bash", r#"{"command":"pwd"}"#);
-
-        assert_eq!(
-            result.permission_override(),
-            Some(PermissionOverride::Allow)
-        );
-        assert_eq!(result.permission_reason(), Some("hook ok"));
-        assert_eq!(result.updated_input(), Some(r#"{"command":"git status"}"#));
-        assert!(result.messages().iter().any(|message| message == "updated"));
-    }
-
-    #[test]
-    fn runs_post_tool_use_failure_hooks() {
-        let runner = HookRunner::new(RuntimeHookConfig::new(
-            Vec::new(),
-            Vec::new(),
-            vec![shell_snippet("printf 'failure hook ran'")],
-        ));
-
-        let result =
-            runner.run_post_tool_use_failure("bash", r#"{"command":"false"}"#, "command failed");
-
-        assert!(!result.is_denied());
-        assert_eq!(result.messages(), &["failure hook ran".to_string()]);
-    }
-
-    #[test]
-    fn abort_signal_cancels_long_running_hook_and_reports_progress() {
-        let runner = HookRunner::new(RuntimeHookConfig::new(
-            vec![shell_snippet("sleep 5")],
-            Vec::new(),
-            Vec::new(),
-        ));
-        let abort_signal = HookAbortSignal::new();
-        let abort_signal_for_thread = abort_signal.clone();
-        let mut reporter = RecordingReporter { events: Vec::new() };
-
-        thread::spawn(move || {
-            thread::sleep(Duration::from_millis(100));
-            abort_signal_for_thread.abort();
-        });
-
-        let result = runner.run_pre_tool_use_with_context(
-            "bash",
-            r#"{"command":"sleep 5"}"#,
-            Some(&abort_signal),
-            Some(&mut reporter),
-        );
-
-        assert!(result.is_cancelled());
-        assert!(reporter.events.iter().any(|event| matches!(
-            event,
-            HookProgressEvent::Started {
-                event: HookEvent::PreToolUse,
-                ..
-            }
-        )));
-        assert!(reporter.events.iter().any(|event| matches!(
-            event,
-            HookProgressEvent::Cancelled {
-                event: HookEvent::PreToolUse,
-                ..
-            }
-        )));
-    }
-
     #[cfg(windows)]
     fn shell_snippet(script: &str) -> String {
         script.replace('\'', "\"")

rust/crates/runtime/src/lib.rs

@@ -28,7 +28,7 @@ pub use config::{
     McpConfigCollection, McpOAuthConfig, McpRemoteServerConfig, McpSdkServerConfig,
     McpServerConfig, McpStdioServerConfig, McpTransport, McpWebSocketServerConfig, OAuthConfig,
     ResolvedPermissionMode, RuntimeConfig, RuntimeFeatureConfig, RuntimeHookConfig,
-    RuntimePermissionRuleConfig, ScopedMcpServerConfig, CLAUDE_CODE_SETTINGS_SCHEMA_NAME,
+    ScopedMcpServerConfig, CLAUDE_CODE_SETTINGS_SCHEMA_NAME,
 };
 pub use conversation::{
     ApiClient, ApiRequest, AssistantEvent, ConversationRuntime, RuntimeError, StaticToolExecutor,
@@ -39,9 +39,7 @@ pub use file_ops::{
     GrepSearchInput, GrepSearchOutput, ReadFileOutput, StructuredPatchHunk, TextFilePayload,
     WriteFileOutput,
 };
-pub use hooks::{
-    HookAbortSignal, HookEvent, HookProgressEvent, HookProgressReporter, HookRunResult, HookRunner,
-};
+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,
@@ -66,8 +64,8 @@ pub use oauth::{
     PkceChallengeMethod, PkceCodePair,
 };
 pub use permissions::{
-    PermissionContext, PermissionMode, PermissionOutcome, PermissionOverride, PermissionPolicy,
-    PermissionPromptDecision, PermissionPrompter, PermissionRequest,
+    PermissionMode, PermissionOutcome, PermissionPolicy, PermissionPromptDecision,
+    PermissionPrompter, PermissionRequest,
 };
 pub use prompt::{
     load_system_prompt, prepend_bullets, ContextFile, ProjectContext, PromptBuildError,
@@ -78,7 +76,10 @@ pub use remote::{
     RemoteSessionContext, UpstreamProxyBootstrap, UpstreamProxyState, DEFAULT_REMOTE_BASE_URL,
     DEFAULT_SESSION_TOKEN_PATH, DEFAULT_SYSTEM_CA_BUNDLE, NO_PROXY_HOSTS, UPSTREAM_PROXY_ENV_KEYS,
 };
-pub use session::{ContentBlock, ConversationMessage, MessageRole, Session, SessionError};
+pub use session::{
+    ContentBlock, ConversationMessage, MessageRole, Session, SessionCompaction, SessionError,
+    SessionFork,
+};
 pub use usage::{
     format_usd, pricing_for_model, ModelPricing, TokenUsage, UsageCostEstimate, UsageTracker,
 };

rust/crates/runtime/src/permissions.rs

@@ -1,9 +1,5 @@
 use std::collections::BTreeMap;
 
-use serde_json::Value;
-
-use crate::config::RuntimePermissionRuleConfig;
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub enum PermissionMode {
     ReadOnly,
@@ -26,49 +22,12 @@ impl PermissionMode {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum PermissionOverride {
-    Allow,
-    Deny,
-    Ask,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub struct PermissionContext {
-    override_decision: Option<PermissionOverride>,
-    override_reason: Option<String>,
-}
-
-impl PermissionContext {
-    #[must_use]
-    pub fn new(
-        override_decision: Option<PermissionOverride>,
-        override_reason: Option<String>,
-    ) -> Self {
-        Self {
-            override_decision,
-            override_reason,
-        }
-    }
-
-    #[must_use]
-    pub fn override_decision(&self) -> Option<PermissionOverride> {
-        self.override_decision
-    }
-
-    #[must_use]
-    pub fn override_reason(&self) -> Option<&str> {
-        self.override_reason.as_deref()
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct PermissionRequest {
     pub tool_name: String,
     pub input: String,
     pub current_mode: PermissionMode,
     pub required_mode: PermissionMode,
-    pub reason: Option<String>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -91,9 +50,6 @@ pub enum PermissionOutcome {
 pub struct PermissionPolicy {
     active_mode: PermissionMode,
     tool_requirements: BTreeMap<String, PermissionMode>,
-    allow_rules: Vec<PermissionRule>,
-    deny_rules: Vec<PermissionRule>,
-    ask_rules: Vec<PermissionRule>,
 }
 
 impl PermissionPolicy {
@@ -102,9 +58,6 @@ impl PermissionPolicy {
         Self {
             active_mode,
             tool_requirements: BTreeMap::new(),
-            allow_rules: Vec::new(),
-            deny_rules: Vec::new(),
-            ask_rules: Vec::new(),
         }
     }
 
@@ -119,26 +72,6 @@ impl PermissionPolicy {
         self
     }
 
-    #[must_use]
-    pub fn with_permission_rules(mut self, config: &RuntimePermissionRuleConfig) -> Self {
-        self.allow_rules = config
-            .allow()
-            .iter()
-            .map(|rule| PermissionRule::parse(rule))
-            .collect();
-        self.deny_rules = config
-            .deny()
-            .iter()
-            .map(|rule| PermissionRule::parse(rule))
-            .collect();
-        self.ask_rules = config
-            .ask()
-            .iter()
-            .map(|rule| PermissionRule::parse(rule))
-            .collect();
-        self
-    }
-
     #[must_use]
     pub fn active_mode(&self) -> PermissionMode {
         self.active_mode
@@ -157,121 +90,38 @@ impl PermissionPolicy {
         &self,
         tool_name: &str,
         input: &str,
-        prompter: Option<&mut dyn PermissionPrompter>,
+        mut prompter: Option<&mut dyn PermissionPrompter>,
     ) -> PermissionOutcome {
-        self.authorize_with_context(tool_name, input, &PermissionContext::default(), prompter)
-    }
-
-    #[must_use]
-    #[allow(clippy::too_many_lines)]
-    pub fn authorize_with_context(
-        &self,
-        tool_name: &str,
-        input: &str,
-        context: &PermissionContext,
-        prompter: Option<&mut dyn PermissionPrompter>,
-    ) -> PermissionOutcome {
-        if let Some(rule) = Self::find_matching_rule(&self.deny_rules, tool_name, input) {
-            return PermissionOutcome::Deny {
-                reason: format!(
-                    "Permission to use {tool_name} has been denied by rule '{}'",
-                    rule.raw
-                ),
-            };
-        }
-
         let current_mode = self.active_mode();
         let required_mode = self.required_mode_for(tool_name);
-        let ask_rule = Self::find_matching_rule(&self.ask_rules, tool_name, input);
-        let allow_rule = Self::find_matching_rule(&self.allow_rules, tool_name, input);
-
-        match context.override_decision() {
-            Some(PermissionOverride::Deny) => {
-                return PermissionOutcome::Deny {
-                    reason: context.override_reason().map_or_else(
-                        || format!("tool '{tool_name}' denied by hook"),
-                        ToOwned::to_owned,
-                    ),
-                };
-            }
-            Some(PermissionOverride::Ask) => {
-                let reason = context.override_reason().map_or_else(
-                    || format!("tool '{tool_name}' requires approval due to hook guidance"),
-                    ToOwned::to_owned,
-                );
-                return Self::prompt_or_deny(
-                    tool_name,
-                    input,
-                    current_mode,
-                    required_mode,
-                    Some(reason),
-                    prompter,
-                );
-            }
-            Some(PermissionOverride::Allow) => {
-                if let Some(rule) = ask_rule {
-                    let reason = format!(
-                        "tool '{tool_name}' requires approval due to ask rule '{}'",
-                        rule.raw
-                    );
-                    return Self::prompt_or_deny(
-                        tool_name,
-                        input,
-                        current_mode,
-                        required_mode,
-                        Some(reason),
-                        prompter,
-                    );
-                }
-                if allow_rule.is_some()
-                    || current_mode == PermissionMode::Allow
-                    || current_mode >= required_mode
-                {
-                    return PermissionOutcome::Allow;
-                }
-            }
-            None => {}
-        }
-
-        if let Some(rule) = ask_rule {
-            let reason = format!(
-                "tool '{tool_name}' requires approval due to ask rule '{}'",
-                rule.raw
-            );
-            return Self::prompt_or_deny(
-                tool_name,
-                input,
-                current_mode,
-                required_mode,
-                Some(reason),
-                prompter,
-            );
-        }
-
-        if allow_rule.is_some()
-            || current_mode == PermissionMode::Allow
-            || current_mode >= required_mode
-        {
+        if current_mode == PermissionMode::Allow || current_mode >= required_mode {
             return PermissionOutcome::Allow;
         }
 
+        let request = PermissionRequest {
+            tool_name: tool_name.to_string(),
+            input: input.to_string(),
+            current_mode,
+            required_mode,
+        };
+
         if current_mode == PermissionMode::Prompt
             || (current_mode == PermissionMode::WorkspaceWrite
                 && required_mode == PermissionMode::DangerFullAccess)
         {
-            let reason = Some(format!(
-                "tool '{tool_name}' requires approval to escalate from {} to {}",
-                current_mode.as_str(),
-                required_mode.as_str()
-            ));
-            return Self::prompt_or_deny(
-                tool_name,
-                input,
-                current_mode,
-                required_mode,
-                reason,
-                prompter,
-            );
+            return match prompter.as_mut() {
+                Some(prompter) => match prompter.decide(&request) {
+                    PermissionPromptDecision::Allow => PermissionOutcome::Allow,
+                    PermissionPromptDecision::Deny { reason } => PermissionOutcome::Deny { reason },
+                },
+                None => PermissionOutcome::Deny {
+                    reason: format!(
+                        "tool '{tool_name}' requires approval to escalate from {} to {}",
+                        current_mode.as_str(),
+                        required_mode.as_str()
+                    ),
+                },
+            };
         }
 
         PermissionOutcome::Deny {
@@ -282,191 +132,14 @@ impl PermissionPolicy {
             ),
         }
     }
-
-    fn prompt_or_deny(
-        tool_name: &str,
-        input: &str,
-        current_mode: PermissionMode,
-        required_mode: PermissionMode,
-        reason: Option<String>,
-        mut prompter: Option<&mut dyn PermissionPrompter>,
-    ) -> PermissionOutcome {
-        let request = PermissionRequest {
-            tool_name: tool_name.to_string(),
-            input: input.to_string(),
-            current_mode,
-            required_mode,
-            reason: reason.clone(),
-        };
-
-        match prompter.as_mut() {
-            Some(prompter) => match prompter.decide(&request) {
-                PermissionPromptDecision::Allow => PermissionOutcome::Allow,
-                PermissionPromptDecision::Deny { reason } => PermissionOutcome::Deny { reason },
-            },
-            None => PermissionOutcome::Deny {
-                reason: reason.unwrap_or_else(|| {
-                    format!(
-                        "tool '{tool_name}' requires approval to run while mode is {}",
-                        current_mode.as_str()
-                    )
-                }),
-            },
-        }
-    }
-
-    fn find_matching_rule<'a>(
-        rules: &'a [PermissionRule],
-        tool_name: &str,
-        input: &str,
-    ) -> Option<&'a PermissionRule> {
-        rules.iter().find(|rule| rule.matches(tool_name, input))
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-struct PermissionRule {
-    raw: String,
-    tool_name: String,
-    matcher: PermissionRuleMatcher,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-enum PermissionRuleMatcher {
-    Any,
-    Exact(String),
-    Prefix(String),
-}
-
-impl PermissionRule {
-    fn parse(raw: &str) -> Self {
-        let trimmed = raw.trim();
-        let open = find_first_unescaped(trimmed, '(');
-        let close = find_last_unescaped(trimmed, ')');
-
-        if let (Some(open), Some(close)) = (open, close) {
-            if close == trimmed.len() - 1 && open < close {
-                let tool_name = trimmed[..open].trim();
-                let content = &trimmed[open + 1..close];
-                if !tool_name.is_empty() {
-                    let matcher = parse_rule_matcher(content);
-                    return Self {
-                        raw: trimmed.to_string(),
-                        tool_name: tool_name.to_string(),
-                        matcher,
-                    };
-                }
-            }
-        }
-
-        Self {
-            raw: trimmed.to_string(),
-            tool_name: trimmed.to_string(),
-            matcher: PermissionRuleMatcher::Any,
-        }
-    }
-
-    fn matches(&self, tool_name: &str, input: &str) -> bool {
-        if self.tool_name != tool_name {
-            return false;
-        }
-
-        match &self.matcher {
-            PermissionRuleMatcher::Any => true,
-            PermissionRuleMatcher::Exact(expected) => {
-                extract_permission_subject(input).is_some_and(|candidate| candidate == *expected)
-            }
-            PermissionRuleMatcher::Prefix(prefix) => extract_permission_subject(input)
-                .is_some_and(|candidate| candidate.starts_with(prefix)),
-        }
-    }
-}
-
-fn parse_rule_matcher(content: &str) -> PermissionRuleMatcher {
-    let unescaped = unescape_rule_content(content.trim());
-    if unescaped.is_empty() || unescaped == "*" {
-        PermissionRuleMatcher::Any
-    } else if let Some(prefix) = unescaped.strip_suffix(":*") {
-        PermissionRuleMatcher::Prefix(prefix.to_string())
-    } else {
-        PermissionRuleMatcher::Exact(unescaped)
-    }
-}
-
-fn unescape_rule_content(content: &str) -> String {
-    content
-        .replace(r"\(", "(")
-        .replace(r"\)", ")")
-        .replace(r"\\", r"\")
-}
-
-fn find_first_unescaped(value: &str, needle: char) -> Option<usize> {
-    let mut escaped = false;
-    for (idx, ch) in value.char_indices() {
-        if ch == '\\' {
-            escaped = !escaped;
-            continue;
-        }
-        if ch == needle && !escaped {
-            return Some(idx);
-        }
-        escaped = false;
-    }
-    None
-}
-
-fn find_last_unescaped(value: &str, needle: char) -> Option<usize> {
-    let chars = value.char_indices().collect::<Vec<_>>();
-    for (pos, (idx, ch)) in chars.iter().enumerate().rev() {
-        if *ch != needle {
-            continue;
-        }
-        let mut backslashes = 0;
-        for (_, prev) in chars[..pos].iter().rev() {
-            if *prev == '\\' {
-                backslashes += 1;
-            } else {
-                break;
-            }
-        }
-        if backslashes % 2 == 0 {
-            return Some(*idx);
-        }
-    }
-    None
-}
-
-fn extract_permission_subject(input: &str) -> Option<String> {
-    let parsed = serde_json::from_str::<Value>(input).ok();
-    if let Some(Value::Object(object)) = parsed {
-        for key in [
-            "command",
-            "path",
-            "file_path",
-            "filePath",
-            "notebook_path",
-            "notebookPath",
-            "url",
-            "pattern",
-            "code",
-            "message",
-        ] {
-            if let Some(value) = object.get(key).and_then(Value::as_str) {
-                return Some(value.to_string());
-            }
-        }
-    }
-
-    (!input.trim().is_empty()).then(|| input.to_string())
 }
 
 #[cfg(test)]
 mod tests {
     use super::{
-        PermissionContext, PermissionMode, PermissionOutcome, PermissionOverride, PermissionPolicy,
-        PermissionPromptDecision, PermissionPrompter, PermissionRequest,
+        PermissionMode, PermissionOutcome, PermissionPolicy, PermissionPromptDecision,
+        PermissionPrompter, PermissionRequest,
     };
-    use crate::config::RuntimePermissionRuleConfig;
 
     struct RecordingPrompter {
         seen: Vec<PermissionRequest>,
@@ -556,120 +229,4 @@ mod tests {
             PermissionOutcome::Deny { reason } if reason == "not now"
         ));
     }
-
-    #[test]
-    fn applies_rule_based_denials_and_allows() {
-        let rules = RuntimePermissionRuleConfig::new(
-            vec!["bash(git:*)".to_string()],
-            vec!["bash(rm -rf:*)".to_string()],
-            Vec::new(),
-        );
-        let policy = PermissionPolicy::new(PermissionMode::ReadOnly)
-            .with_tool_requirement("bash", PermissionMode::DangerFullAccess)
-            .with_permission_rules(&rules);
-
-        assert_eq!(
-            policy.authorize("bash", r#"{"command":"git status"}"#, None),
-            PermissionOutcome::Allow
-        );
-        assert!(matches!(
-            policy.authorize("bash", r#"{"command":"rm -rf /tmp/x"}"#, None),
-            PermissionOutcome::Deny { reason } if reason.contains("denied by rule")
-        ));
-    }
-
-    #[test]
-    fn ask_rules_force_prompt_even_when_mode_allows() {
-        let rules = RuntimePermissionRuleConfig::new(
-            Vec::new(),
-            Vec::new(),
-            vec!["bash(git:*)".to_string()],
-        );
-        let policy = PermissionPolicy::new(PermissionMode::DangerFullAccess)
-            .with_tool_requirement("bash", PermissionMode::DangerFullAccess)
-            .with_permission_rules(&rules);
-        let mut prompter = RecordingPrompter {
-            seen: Vec::new(),
-            allow: true,
-        };
-
-        let outcome = policy.authorize("bash", r#"{"command":"git status"}"#, Some(&mut prompter));
-
-        assert_eq!(outcome, PermissionOutcome::Allow);
-        assert_eq!(prompter.seen.len(), 1);
-        assert!(prompter.seen[0]
-            .reason
-            .as_deref()
-            .is_some_and(|reason| reason.contains("ask rule")));
-    }
-
-    #[test]
-    fn hook_allow_still_respects_ask_rules() {
-        let rules = RuntimePermissionRuleConfig::new(
-            Vec::new(),
-            Vec::new(),
-            vec!["bash(git:*)".to_string()],
-        );
-        let policy = PermissionPolicy::new(PermissionMode::ReadOnly)
-            .with_tool_requirement("bash", PermissionMode::DangerFullAccess)
-            .with_permission_rules(&rules);
-        let context = PermissionContext::new(
-            Some(PermissionOverride::Allow),
-            Some("hook approved".to_string()),
-        );
-        let mut prompter = RecordingPrompter {
-            seen: Vec::new(),
-            allow: true,
-        };
-
-        let outcome = policy.authorize_with_context(
-            "bash",
-            r#"{"command":"git status"}"#,
-            &context,
-            Some(&mut prompter),
-        );
-
-        assert_eq!(outcome, PermissionOutcome::Allow);
-        assert_eq!(prompter.seen.len(), 1);
-    }
-
-    #[test]
-    fn hook_deny_short_circuits_permission_flow() {
-        let policy = PermissionPolicy::new(PermissionMode::DangerFullAccess)
-            .with_tool_requirement("bash", PermissionMode::DangerFullAccess);
-        let context = PermissionContext::new(
-            Some(PermissionOverride::Deny),
-            Some("blocked by hook".to_string()),
-        );
-
-        assert_eq!(
-            policy.authorize_with_context("bash", "{}", &context, None),
-            PermissionOutcome::Deny {
-                reason: "blocked by hook".to_string(),
-            }
-        );
-    }
-
-    #[test]
-    fn hook_ask_forces_prompt() {
-        let policy = PermissionPolicy::new(PermissionMode::DangerFullAccess)
-            .with_tool_requirement("bash", PermissionMode::DangerFullAccess);
-        let context = PermissionContext::new(
-            Some(PermissionOverride::Ask),
-            Some("hook requested confirmation".to_string()),
-        );
-        let mut prompter = RecordingPrompter {
-            seen: Vec::new(),
-            allow: true,
-        };
-
-        let outcome = policy.authorize_with_context("bash", "{}", &context, Some(&mut prompter));
-
-        assert_eq!(outcome, PermissionOutcome::Allow);
-        assert_eq!(prompter.seen.len(), 1);
-        assert_eq!(
-            prompter.seen[0].reason.as_deref(),
-            Some("hook requested confirmation")
-        );
-    }
 }

rust/crates/runtime/src/session.rs

@@ -1,11 +1,19 @@
 use std::collections::BTreeMap;
 use std::fmt::{Display, Formatter};
-use std::fs;
-use std::path::Path;
+use std::fs::{self, OpenOptions};
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{SystemTime, UNIX_EPOCH};
 
 use crate::json::{JsonError, JsonValue};
 use crate::usage::TokenUsage;
 
+const SESSION_VERSION: u32 = 1;
+const ROTATE_AFTER_BYTES: u64 = 256 * 1024;
+const MAX_ROTATED_FILES: usize = 3;
+static SESSION_ID_COUNTER: AtomicU64 = AtomicU64::new(0);
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum MessageRole {
     System,
@@ -40,11 +48,49 @@ pub struct ConversationMessage {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SessionCompaction {
+    pub count: u32,
+    pub removed_message_count: usize,
+    pub summary: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SessionFork {
+    pub parent_session_id: String,
+    pub branch_name: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct SessionPersistence {
+    path: PathBuf,
+}
+
+#[derive(Debug, Clone)]
 pub struct Session {
     pub version: u32,
+    pub session_id: String,
+    pub created_at_ms: u64,
+    pub updated_at_ms: u64,
     pub messages: Vec<ConversationMessage>,
+    pub compaction: Option<SessionCompaction>,
+    pub fork: Option<SessionFork>,
+    persistence: Option<SessionPersistence>,
 }
 
+impl PartialEq for Session {
+    fn eq(&self, other: &Self) -> bool {
+        self.version == other.version
+            && self.session_id == other.session_id
+            && self.created_at_ms == other.created_at_ms
+            && self.updated_at_ms == other.updated_at_ms
+            && self.messages == other.messages
+            && self.compaction == other.compaction
+            && self.fork == other.fork
+    }
+}
+
+impl Eq for Session {}
+
 #[derive(Debug)]
 pub enum SessionError {
     Io(std::io::Error),
@@ -79,20 +125,84 @@ impl From<JsonError> for SessionError {
 impl Session {
     #[must_use]
     pub fn new() -> Self {
+        let now = current_time_millis();
         Self {
-            version: 1,
+            version: SESSION_VERSION,
+            session_id: generate_session_id(),
+            created_at_ms: now,
+            updated_at_ms: now,
             messages: Vec::new(),
+            compaction: None,
+            fork: None,
+            persistence: None,
         }
     }
 
+    #[must_use]
+    pub fn with_persistence_path(mut self, path: impl Into<PathBuf>) -> Self {
+        self.persistence = Some(SessionPersistence { path: path.into() });
+        self
+    }
+
+    #[must_use]
+    pub fn persistence_path(&self) -> Option<&Path> {
+        self.persistence.as_ref().map(|value| value.path.as_path())
+    }
+
     pub fn save_to_path(&self, path: impl AsRef<Path>) -> Result<(), SessionError> {
-        fs::write(path, self.to_json().render())?;
+        let path = path.as_ref();
+        rotate_session_file_if_needed(path)?;
+        write_atomic(path, &self.render_jsonl_snapshot())?;
+        cleanup_rotated_logs(path)?;
         Ok(())
     }
 
     pub fn load_from_path(path: impl AsRef<Path>) -> Result<Self, SessionError> {
+        let path = path.as_ref();
         let contents = fs::read_to_string(path)?;
-        Self::from_json(&JsonValue::parse(&contents)?)
+        let session = match JsonValue::parse(&contents) {
+            Ok(value) => Self::from_json(&value)?,
+            Err(_) => Self::from_jsonl(&contents)?,
+        };
+        Ok(session.with_persistence_path(path.to_path_buf()))
+    }
+
+    pub fn push_message(&mut self, message: ConversationMessage) -> Result<(), SessionError> {
+        self.touch();
+        self.messages.push(message.clone());
+        self.append_persisted_message(&message)
+    }
+
+    pub fn push_user_text(&mut self, text: impl Into<String>) -> Result<(), SessionError> {
+        self.push_message(ConversationMessage::user_text(text))
+    }
+
+    pub fn record_compaction(&mut self, summary: impl Into<String>, removed_message_count: usize) {
+        self.touch();
+        let count = self.compaction.as_ref().map_or(1, |value| value.count + 1);
+        self.compaction = Some(SessionCompaction {
+            count,
+            removed_message_count,
+            summary: summary.into(),
+        });
+    }
+
+    #[must_use]
+    pub fn fork(&self, branch_name: Option<String>) -> Self {
+        let now = current_time_millis();
+        Self {
+            version: self.version,
+            session_id: generate_session_id(),
+            created_at_ms: now,
+            updated_at_ms: now,
+            messages: self.messages.clone(),
+            compaction: self.compaction.clone(),
+            fork: Some(SessionFork {
+                parent_session_id: self.session_id.clone(),
+                branch_name: normalize_optional_string(branch_name),
+            }),
+            persistence: None,
+        }
     }
 
     #[must_use]
@@ -102,6 +212,18 @@ impl Session {
             "version".to_string(),
             JsonValue::Number(i64::from(self.version)),
         );
+        object.insert(
+            "session_id".to_string(),
+            JsonValue::String(self.session_id.clone()),
+        );
+        object.insert(
+            "created_at_ms".to_string(),
+            JsonValue::Number(i64_from_u64(self.created_at_ms, "created_at_ms")),
+        );
+        object.insert(
+            "updated_at_ms".to_string(),
+            JsonValue::Number(i64_from_u64(self.updated_at_ms, "updated_at_ms")),
+        );
         object.insert(
             "messages".to_string(),
             JsonValue::Array(
@@ -111,6 +233,12 @@ impl Session {
                     .collect(),
             ),
         );
+        if let Some(compaction) = &self.compaction {
+            object.insert("compaction".to_string(), compaction.to_json());
+        }
+        if let Some(fork) = &self.fork {
+            object.insert("fork".to_string(), fork.to_json());
+        }
         JsonValue::Object(object)
     }
 
@@ -131,7 +259,179 @@ impl Session {
             .iter()
             .map(ConversationMessage::from_json)
             .collect::<Result<Vec<_>, _>>()?;
-        Ok(Self { version, messages })
+        let now = current_time_millis();
+        let session_id = object
+            .get("session_id")
+            .and_then(JsonValue::as_str)
+            .map(ToOwned::to_owned)
+            .unwrap_or_else(generate_session_id);
+        let created_at_ms = object
+            .get("created_at_ms")
+            .map(|value| required_u64_from_value(value, "created_at_ms"))
+            .transpose()?
+            .unwrap_or(now);
+        let updated_at_ms = object
+            .get("updated_at_ms")
+            .map(|value| required_u64_from_value(value, "updated_at_ms"))
+            .transpose()?
+            .unwrap_or(created_at_ms);
+        let compaction = object
+            .get("compaction")
+            .map(SessionCompaction::from_json)
+            .transpose()?;
+        let fork = object.get("fork").map(SessionFork::from_json).transpose()?;
+        Ok(Self {
+            version,
+            session_id,
+            created_at_ms,
+            updated_at_ms,
+            messages,
+            compaction,
+            fork,
+            persistence: None,
+        })
+    }
+
+    fn from_jsonl(contents: &str) -> Result<Self, SessionError> {
+        let mut version = SESSION_VERSION;
+        let mut session_id = None;
+        let mut created_at_ms = None;
+        let mut updated_at_ms = None;
+        let mut messages = Vec::new();
+        let mut compaction = None;
+        let mut fork = None;
+
+        for (line_number, raw_line) in contents.lines().enumerate() {
+            let line = raw_line.trim();
+            if line.is_empty() {
+                continue;
+            }
+            let value = JsonValue::parse(line).map_err(|error| {
+                SessionError::Format(format!(
+                    "invalid JSONL record at line {}: {}",
+                    line_number + 1,
+                    error
+                ))
+            })?;
+            let object = value.as_object().ok_or_else(|| {
+                SessionError::Format(format!(
+                    "JSONL record at line {} must be an object",
+                    line_number + 1
+                ))
+            })?;
+            match object
+                .get("type")
+                .and_then(JsonValue::as_str)
+                .ok_or_else(|| {
+                    SessionError::Format(format!(
+                        "JSONL record at line {} missing type",
+                        line_number + 1
+                    ))
+                })? {
+                "session_meta" => {
+                    version = required_u32(object, "version")?;
+                    session_id = Some(required_string(object, "session_id")?);
+                    created_at_ms = Some(required_u64(object, "created_at_ms")?);
+                    updated_at_ms = Some(required_u64(object, "updated_at_ms")?);
+                    fork = object.get("fork").map(SessionFork::from_json).transpose()?;
+                }
+                "message" => {
+                    let message_value = object.get("message").ok_or_else(|| {
+                        SessionError::Format(format!(
+                            "JSONL record at line {} missing message",
+                            line_number + 1
+                        ))
+                    })?;
+                    messages.push(ConversationMessage::from_json(message_value)?);
+                }
+                "compaction" => {
+                    compaction = Some(SessionCompaction::from_json(&JsonValue::Object(
+                        object.clone(),
+                    ))?);
+                }
+                other => {
+                    return Err(SessionError::Format(format!(
+                        "unsupported JSONL record type at line {}: {other}",
+                        line_number + 1
+                    )))
+                }
+            }
+        }
+
+        let now = current_time_millis();
+        Ok(Self {
+            version,
+            session_id: session_id.unwrap_or_else(generate_session_id),
+            created_at_ms: created_at_ms.unwrap_or(now),
+            updated_at_ms: updated_at_ms.unwrap_or(created_at_ms.unwrap_or(now)),
+            messages,
+            compaction,
+            fork,
+            persistence: None,
+        })
+    }
+
+    fn render_jsonl_snapshot(&self) -> String {
+        let mut lines = vec![self.meta_record().render()];
+        if let Some(compaction) = &self.compaction {
+            lines.push(compaction.to_jsonl_record().render());
+        }
+        lines.extend(
+            self.messages
+                .iter()
+                .map(|message| message_record(message).render()),
+        );
+        let mut rendered = lines.join("\n");
+        rendered.push('\n');
+        rendered
+    }
+
+    fn append_persisted_message(&self, message: &ConversationMessage) -> Result<(), SessionError> {
+        let Some(path) = self.persistence_path() else {
+            return Ok(());
+        };
+
+        let needs_bootstrap = !path.exists() || fs::metadata(path)?.len() == 0;
+        if needs_bootstrap {
+            self.save_to_path(path)?;
+            return Ok(());
+        }
+
+        let mut file = OpenOptions::new().append(true).open(path)?;
+        writeln!(file, "{}", message_record(message).render())?;
+        Ok(())
+    }
+
+    fn meta_record(&self) -> JsonValue {
+        let mut object = BTreeMap::new();
+        object.insert(
+            "type".to_string(),
+            JsonValue::String("session_meta".to_string()),
+        );
+        object.insert(
+            "version".to_string(),
+            JsonValue::Number(i64::from(self.version)),
+        );
+        object.insert(
+            "session_id".to_string(),
+            JsonValue::String(self.session_id.clone()),
+        );
+        object.insert(
+            "created_at_ms".to_string(),
+            JsonValue::Number(i64_from_u64(self.created_at_ms, "created_at_ms")),
+        );
+        object.insert(
+            "updated_at_ms".to_string(),
+            JsonValue::Number(i64_from_u64(self.updated_at_ms, "updated_at_ms")),
+        );
+        if let Some(fork) = &self.fork {
+            object.insert("fork".to_string(), fork.to_json());
+        }
+        JsonValue::Object(object)
+    }
+
+    fn touch(&mut self) {
+        self.updated_at_ms = current_time_millis();
     }
 }
 
@@ -324,6 +624,92 @@ impl ContentBlock {
     }
 }
 
+impl SessionCompaction {
+    #[must_use]
+    pub fn to_json(&self) -> JsonValue {
+        let mut object = BTreeMap::new();
+        object.insert(
+            "count".to_string(),
+            JsonValue::Number(i64::from(self.count)),
+        );
+        object.insert(
+            "removed_message_count".to_string(),
+            JsonValue::Number(i64_from_usize(
+                self.removed_message_count,
+                "removed_message_count",
+            )),
+        );
+        object.insert(
+            "summary".to_string(),
+            JsonValue::String(self.summary.clone()),
+        );
+        JsonValue::Object(object)
+    }
+
+    #[must_use]
+    pub fn to_jsonl_record(&self) -> JsonValue {
+        let mut object = self
+            .to_json()
+            .as_object()
+            .cloned()
+            .expect("compaction should render to object");
+        object.insert(
+            "type".to_string(),
+            JsonValue::String("compaction".to_string()),
+        );
+        JsonValue::Object(object)
+    }
+
+    fn from_json(value: &JsonValue) -> Result<Self, SessionError> {
+        let object = value
+            .as_object()
+            .ok_or_else(|| SessionError::Format("compaction must be an object".to_string()))?;
+        Ok(Self {
+            count: required_u32(object, "count")?,
+            removed_message_count: required_usize(object, "removed_message_count")?,
+            summary: required_string(object, "summary")?,
+        })
+    }
+}
+
+impl SessionFork {
+    #[must_use]
+    pub fn to_json(&self) -> JsonValue {
+        let mut object = BTreeMap::new();
+        object.insert(
+            "parent_session_id".to_string(),
+            JsonValue::String(self.parent_session_id.clone()),
+        );
+        if let Some(branch_name) = &self.branch_name {
+            object.insert(
+                "branch_name".to_string(),
+                JsonValue::String(branch_name.clone()),
+            );
+        }
+        JsonValue::Object(object)
+    }
+
+    fn from_json(value: &JsonValue) -> Result<Self, SessionError> {
+        let object = value
+            .as_object()
+            .ok_or_else(|| SessionError::Format("fork metadata must be an object".to_string()))?;
+        Ok(Self {
+            parent_session_id: required_string(object, "parent_session_id")?,
+            branch_name: object
+                .get("branch_name")
+                .and_then(JsonValue::as_str)
+                .map(ToOwned::to_owned),
+        })
+    }
+}
+
+fn message_record(message: &ConversationMessage) -> JsonValue {
+    let mut object = BTreeMap::new();
+    object.insert("type".to_string(), JsonValue::String("message".to_string()));
+    object.insert("message".to_string(), message.to_json());
+    JsonValue::Object(object)
+}
+
 fn usage_to_json(usage: TokenUsage) -> JsonValue {
     let mut object = BTreeMap::new();
     object.insert(
@@ -376,22 +762,155 @@ fn required_u32(object: &BTreeMap<String, JsonValue>, key: &str) -> Result<u32,
     u32::try_from(value).map_err(|_| SessionError::Format(format!("{key} out of range")))
 }
 
+fn required_u64(object: &BTreeMap<String, JsonValue>, key: &str) -> Result<u64, SessionError> {
+    let value = object
+        .get(key)
+        .ok_or_else(|| SessionError::Format(format!("missing {key}")))?;
+    required_u64_from_value(value, key)
+}
+
+fn required_u64_from_value(value: &JsonValue, key: &str) -> Result<u64, SessionError> {
+    let value = value
+        .as_i64()
+        .ok_or_else(|| SessionError::Format(format!("missing {key}")))?;
+    u64::try_from(value).map_err(|_| SessionError::Format(format!("{key} out of range")))
+}
+
+fn required_usize(object: &BTreeMap<String, JsonValue>, key: &str) -> Result<usize, SessionError> {
+    let value = object
+        .get(key)
+        .and_then(JsonValue::as_i64)
+        .ok_or_else(|| SessionError::Format(format!("missing {key}")))?;
+    usize::try_from(value).map_err(|_| SessionError::Format(format!("{key} out of range")))
+}
+
+fn i64_from_u64(value: u64, key: &str) -> i64 {
+    i64::try_from(value).unwrap_or_else(|_| panic!("{key} out of range for JSON number"))
+}
+
+fn i64_from_usize(value: usize, key: &str) -> i64 {
+    i64::try_from(value).unwrap_or_else(|_| panic!("{key} out of range for JSON number"))
+}
+
+fn normalize_optional_string(value: Option<String>) -> Option<String> {
+    value.and_then(|value| {
+        let trimmed = value.trim();
+        if trimmed.is_empty() {
+            None
+        } else {
+            Some(trimmed.to_string())
+        }
+    })
+}
+
+fn current_time_millis() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|duration| duration.as_millis() as u64)
+        .unwrap_or_default()
+}
+
+fn generate_session_id() -> String {
+    let millis = current_time_millis();
+    let counter = SESSION_ID_COUNTER.fetch_add(1, Ordering::Relaxed);
+    format!("session-{millis}-{counter}")
+}
+
+fn write_atomic(path: &Path, contents: &str) -> Result<(), SessionError> {
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+    let temp_path = temporary_path_for(path);
+    fs::write(&temp_path, contents)?;
+    fs::rename(temp_path, path)?;
+    Ok(())
+}
+
+fn temporary_path_for(path: &Path) -> PathBuf {
+    let file_name = path
+        .file_name()
+        .and_then(|value| value.to_str())
+        .unwrap_or("session");
+    path.with_file_name(format!(
+        "{file_name}.tmp-{}-{}",
+        current_time_millis(),
+        SESSION_ID_COUNTER.fetch_add(1, Ordering::Relaxed)
+    ))
+}
+
+fn rotate_session_file_if_needed(path: &Path) -> Result<(), SessionError> {
+    let Ok(metadata) = fs::metadata(path) else {
+        return Ok(());
+    };
+    if metadata.len() < ROTATE_AFTER_BYTES {
+        return Ok(());
+    }
+    let rotated_path = rotated_log_path(path);
+    fs::rename(path, rotated_path)?;
+    Ok(())
+}
+
+fn rotated_log_path(path: &Path) -> PathBuf {
+    let stem = path
+        .file_stem()
+        .and_then(|value| value.to_str())
+        .unwrap_or("session");
+    path.with_file_name(format!("{stem}.rot-{}.jsonl", current_time_millis()))
+}
+
+fn cleanup_rotated_logs(path: &Path) -> Result<(), SessionError> {
+    let Some(parent) = path.parent() else {
+        return Ok(());
+    };
+    let stem = path
+        .file_stem()
+        .and_then(|value| value.to_str())
+        .unwrap_or("session");
+    let prefix = format!("{stem}.rot-");
+    let mut rotated_paths = fs::read_dir(parent)?
+        .filter_map(Result::ok)
+        .map(|entry| entry.path())
+        .filter(|entry_path| {
+            entry_path
+                .file_name()
+                .and_then(|value| value.to_str())
+                .is_some_and(|name| name.starts_with(&prefix) && name.ends_with(".jsonl"))
+        })
+        .collect::<Vec<_>>();
+
+    rotated_paths.sort_by_key(|entry_path| {
+        fs::metadata(entry_path)
+            .and_then(|metadata| metadata.modified())
+            .unwrap_or(UNIX_EPOCH)
+    });
+
+    let remove_count = rotated_paths.len().saturating_sub(MAX_ROTATED_FILES);
+    for stale_path in rotated_paths.into_iter().take(remove_count) {
+        fs::remove_file(stale_path)?;
+    }
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
-    use super::{ContentBlock, ConversationMessage, MessageRole, Session};
+    use super::{
+        cleanup_rotated_logs, rotate_session_file_if_needed, ContentBlock, ConversationMessage,
+        MessageRole, Session, SessionFork,
+    };
+    use crate::json::JsonValue;
     use crate::usage::TokenUsage;
     use std::fs;
+    use std::path::PathBuf;
     use std::time::{SystemTime, UNIX_EPOCH};
 
     #[test]
-    fn persists_and_restores_session_json() {
+    fn persists_and_restores_session_jsonl() {
         let mut session = Session::new();
         session
-            .messages
-            .push(ConversationMessage::user_text("hello"));
+            .push_user_text("hello")
+            .expect("user message should append");
         session
-            .messages
-            .push(ConversationMessage::assistant_with_usage(
+            .push_message(ConversationMessage::assistant_with_usage(
                 vec![
                     ContentBlock::Text {
                         text: "thinking".to_string(),
@@ -408,16 +927,15 @@ mod tests {
                     cache_creation_input_tokens: 1,
                     cache_read_input_tokens: 2,
                 }),
-            ));
-        session.messages.push(ConversationMessage::tool_result(
-            "tool-1", "bash", "hi", false,
-        ));
+            ))
+            .expect("assistant message should append");
+        session
+            .push_message(ConversationMessage::tool_result(
+                "tool-1", "bash", "hi", false,
+            ))
+            .expect("tool result should append");
 
-        let nanos = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .expect("system time should be after epoch")
-            .as_nanos();
-        let path = std::env::temp_dir().join(format!("runtime-session-{nanos}.json"));
+        let path = temp_session_path("jsonl");
         session.save_to_path(&path).expect("session should save");
         let restored = Session::load_from_path(&path).expect("session should load");
         fs::remove_file(&path).expect("temp file should be removable");
@@ -428,5 +946,157 @@ mod tests {
             restored.messages[1].usage.expect("usage").total_tokens(),
             17
         );
+        assert_eq!(restored.session_id, session.session_id);
+    }
+
+    #[test]
+    fn loads_legacy_session_json_object() {
+        let path = temp_session_path("legacy");
+        let legacy = JsonValue::Object(
+            [
+                ("version".to_string(), JsonValue::Number(1)),
+                (
+                    "messages".to_string(),
+                    JsonValue::Array(vec![ConversationMessage::user_text("legacy").to_json()]),
+                ),
+            ]
+            .into_iter()
+            .collect(),
+        );
+        fs::write(&path, legacy.render()).expect("legacy file should write");
+
+        let restored = Session::load_from_path(&path).expect("legacy session should load");
+        fs::remove_file(&path).expect("temp file should be removable");
+
+        assert_eq!(restored.messages.len(), 1);
+        assert_eq!(
+            restored.messages[0],
+            ConversationMessage::user_text("legacy")
+        );
+        assert!(!restored.session_id.is_empty());
+    }
+
+    #[test]
+    fn appends_messages_to_persisted_jsonl_session() {
+        let path = temp_session_path("append");
+        let mut session = Session::new().with_persistence_path(path.clone());
+        session
+            .save_to_path(&path)
+            .expect("initial save should succeed");
+        session
+            .push_user_text("hi")
+            .expect("user append should succeed");
+        session
+            .push_message(ConversationMessage::assistant(vec![ContentBlock::Text {
+                text: "hello".to_string(),
+            }]))
+            .expect("assistant append should succeed");
+
+        let restored = Session::load_from_path(&path).expect("session should replay from jsonl");
+        fs::remove_file(&path).expect("temp file should be removable");
+
+        assert_eq!(restored.messages.len(), 2);
+        assert_eq!(restored.messages[0], ConversationMessage::user_text("hi"));
+    }
+
+    #[test]
+    fn persists_compaction_metadata() {
+        let path = temp_session_path("compaction");
+        let mut session = Session::new();
+        session
+            .push_user_text("before")
+            .expect("message should append");
+        session.record_compaction("summarized earlier work", 4);
+        session.save_to_path(&path).expect("session should save");
+
+        let restored = Session::load_from_path(&path).expect("session should load");
+        fs::remove_file(&path).expect("temp file should be removable");
+
+        let compaction = restored.compaction.expect("compaction metadata");
+        assert_eq!(compaction.count, 1);
+        assert_eq!(compaction.removed_message_count, 4);
+        assert!(compaction.summary.contains("summarized"));
+    }
+
+    #[test]
+    fn forks_sessions_with_branch_metadata_and_persists_it() {
+        let path = temp_session_path("fork");
+        let mut session = Session::new();
+        session
+            .push_user_text("before fork")
+            .expect("message should append");
+
+        let forked = session
+            .fork(Some("investigation".to_string()))
+            .with_persistence_path(path.clone());
+        forked
+            .save_to_path(&path)
+            .expect("forked session should save");
+
+        let restored = Session::load_from_path(&path).expect("forked session should load");
+        fs::remove_file(&path).expect("temp file should be removable");
+
+        assert_ne!(restored.session_id, session.session_id);
+        assert_eq!(
+            restored.fork,
+            Some(SessionFork {
+                parent_session_id: session.session_id,
+                branch_name: Some("investigation".to_string()),
+            })
+        );
+        assert_eq!(restored.messages, forked.messages);
+    }
+
+    #[test]
+    fn rotates_and_cleans_up_large_session_logs() {
+        let path = temp_session_path("rotation");
+        fs::write(&path, "x".repeat((super::ROTATE_AFTER_BYTES + 10) as usize))
+            .expect("oversized file should write");
+        rotate_session_file_if_needed(&path).expect("rotation should succeed");
+        assert!(
+            !path.exists(),
+            "original path should be rotated away before rewrite"
+        );
+
+        for _ in 0..5 {
+            let rotated = super::rotated_log_path(&path);
+            fs::write(&rotated, "old").expect("rotated file should write");
+        }
+        cleanup_rotated_logs(&path).expect("cleanup should succeed");
+
+        let rotated_count = rotation_files(&path).len();
+        assert!(rotated_count <= super::MAX_ROTATED_FILES);
+        for rotated in rotation_files(&path) {
+            fs::remove_file(rotated).expect("rotated file should be removable");
+        }
+    }
+
+    fn temp_session_path(label: &str) -> PathBuf {
+        let nanos = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("system time should be after epoch")
+            .as_nanos();
+        std::env::temp_dir().join(format!("runtime-session-{label}-{nanos}.json"))
+    }
+
+    fn rotation_files(path: &PathBuf) -> Vec<PathBuf> {
+        let stem = path
+            .file_stem()
+            .and_then(|value| value.to_str())
+            .expect("temp path should have file stem")
+            .to_string();
+        fs::read_dir(path.parent().expect("temp path should have parent"))
+            .expect("temp dir should read")
+            .filter_map(Result::ok)
+            .map(|entry| entry.path())
+            .filter(|entry_path| {
+                entry_path
+                    .file_name()
+                    .and_then(|value| value.to_str())
+                    .is_some_and(|name| {
+                        name.starts_with(&format!("{stem}.rot-")) && name.ends_with(".jsonl")
+                    })
+            })
+            .collect()
     }
 }

rust/crates/runtime/src/usage.rs

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

rust/crates/rusty-claude-cli/Cargo.toml

@@ -19,7 +19,7 @@ rustyline = "15"
 runtime = { path = "../runtime" }
 serde_json = "1"
 syntect = "5"
-tokio = { version = "1", features = ["rt-multi-thread", "signal", "time"] }
+tokio = { version = "1", features = ["rt-multi-thread", "time"] }
 tools = { path = "../tools" }
 
 [lints]

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

@@ -9,9 +9,7 @@ use std::io::{self, Read, Write};
 use std::net::TcpListener;
 use std::path::{Path, PathBuf};
 use std::process::Command;
-use std::sync::mpsc::{self, Receiver, Sender};
-use std::thread::{self, JoinHandle};
-use std::time::{SystemTime, UNIX_EPOCH};
+use std::time::UNIX_EPOCH;
 
 use api::{
     resolve_startup_auth_source, AnthropicClient, AuthSource, ContentBlockDelta, InputContentBlock,
@@ -49,6 +47,8 @@ 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,7 +591,19 @@ fn print_version() {
 }
 
 fn resume_session(session_path: &Path, commands: &[String]) {
-    let session = match Session::load_from_path(session_path) {
+    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) {
         Ok(session) => session,
         Err(error) => {
             eprintln!("failed to restore session: {error}");
@@ -602,7 +614,7 @@ fn resume_session(session_path: &Path, commands: &[String]) {
     if commands.is_empty() {
         println!(
             "Restored session from {} ({} messages).",
-            session_path.display(),
+            resolved_path.display(),
             session.messages.len()
         );
         return;
@@ -614,7 +626,7 @@ fn resume_session(session_path: &Path, commands: &[String]) {
             eprintln!("unsupported resumed command: {raw_command}");
             std::process::exit(2);
         };
-        match run_resume_command(session_path, &session, &command) {
+        match run_resume_command(&resolved_path, &session, &command) {
             Ok(ResumeCommandOutcome {
                 session: next_session,
                 message,
@@ -975,6 +987,8 @@ struct ManagedSessionSummary {
     path: PathBuf,
     modified_epoch_secs: u64,
     message_count: usize,
+    parent_session_id: Option<String>,
+    branch_name: Option<String>,
 }
 
 struct LiveCli {
@@ -986,61 +1000,6 @@ struct LiveCli {
     session: SessionHandle,
 }
 
-struct HookAbortMonitor {
-    stop_tx: Option<Sender<()>>,
-    join_handle: Option<JoinHandle<()>>,
-}
-
-impl HookAbortMonitor {
-    fn spawn(abort_signal: runtime::HookAbortSignal) -> Self {
-        Self::spawn_with_waiter(abort_signal, move |stop_rx, abort_signal| {
-            let Ok(runtime) = tokio::runtime::Builder::new_current_thread()
-                .enable_all()
-                .build()
-            else {
-                return;
-            };
-
-            runtime.block_on(async move {
-                let wait_for_stop = tokio::task::spawn_blocking(move || {
-                    let _ = stop_rx.recv();
-                });
-
-                tokio::select! {
-                    result = tokio::signal::ctrl_c() => {
-                        if result.is_ok() {
-                            abort_signal.abort();
-                        }
-                    }
-                    _ = wait_for_stop => {}
-                }
-            });
-        })
-    }
-
-    fn spawn_with_waiter<F>(abort_signal: runtime::HookAbortSignal, wait_for_interrupt: F) -> Self
-    where
-        F: FnOnce(Receiver<()>, runtime::HookAbortSignal) + Send + 'static,
-    {
-        let (stop_tx, stop_rx) = mpsc::channel();
-        let join_handle = thread::spawn(move || wait_for_interrupt(stop_rx, abort_signal));
-
-        Self {
-            stop_tx: Some(stop_tx),
-            join_handle: Some(join_handle),
-        }
-    }
-
-    fn stop(mut self) {
-        if let Some(stop_tx) = self.stop_tx.take() {
-            let _ = stop_tx.send(());
-        }
-        if let Some(join_handle) = self.join_handle.take() {
-            let _ = join_handle.join();
-        }
-    }
-}
-
 impl LiveCli {
     fn new(
         model: String,
@@ -1049,9 +1008,10 @@ impl LiveCli {
         permission_mode: PermissionMode,
     ) -> Result<Self, Box<dyn std::error::Error>> {
         let system_prompt = build_system_prompt()?;
-        let session = create_managed_session_handle()?;
+        let session_state = Session::new();
+        let session = create_managed_session_handle(&session_state.session_id)?;
         let runtime = build_runtime(
-            Session::new(),
+            session_state.with_persistence_path(session.path.clone()),
             model.clone(),
             system_prompt.clone(),
             enable_tools,
@@ -1096,34 +1056,7 @@ impl LiveCli {
         )
     }
 
-    fn prepare_turn_runtime(
-        &self,
-        emit_output: bool,
-    ) -> Result<
-        (
-            ConversationRuntime<AnthropicRuntimeClient, CliToolExecutor>,
-            HookAbortMonitor,
-        ),
-        Box<dyn std::error::Error>,
-    > {
-        let hook_abort_signal = runtime::HookAbortSignal::new();
-        let runtime = build_runtime(
-            self.runtime.session().clone(),
-            self.model.clone(),
-            self.system_prompt.clone(),
-            true,
-            emit_output,
-            self.allowed_tools.clone(),
-            self.permission_mode,
-        )?
-        .with_hook_abort_signal(hook_abort_signal.clone());
-        let hook_abort_monitor = HookAbortMonitor::spawn(hook_abort_signal);
-
-        Ok((runtime, hook_abort_monitor))
-    }
-
     fn run_turn(&mut self, input: &str) -> Result<(), Box<dyn std::error::Error>> {
-        let (mut runtime, hook_abort_monitor) = self.prepare_turn_runtime(true)?;
         let mut spinner = Spinner::new();
         let mut stdout = io::stdout();
         spinner.tick(
@@ -1132,9 +1065,7 @@ impl LiveCli {
             &mut stdout,
         )?;
         let mut permission_prompter = CliPermissionPrompter::new(self.permission_mode);
-        let result = runtime.run_turn(input, Some(&mut permission_prompter));
-        hook_abort_monitor.stop();
-        self.runtime = runtime;
+        let result = self.runtime.run_turn(input, Some(&mut permission_prompter));
         match result {
             Ok(_) => {
                 spinner.finish(
@@ -1169,11 +1100,18 @@ impl LiveCli {
     }
 
     fn run_prompt_json(&mut self, input: &str) -> Result<(), Box<dyn std::error::Error>> {
-        let (mut runtime, hook_abort_monitor) = self.prepare_turn_runtime(false)?;
+        let session = self.runtime.session().clone();
+        let mut runtime = build_runtime(
+            session,
+            self.model.clone(),
+            self.system_prompt.clone(),
+            true,
+            false,
+            self.allowed_tools.clone(),
+            self.permission_mode,
+        )?;
         let mut permission_prompter = CliPermissionPrompter::new(self.permission_mode);
-        let result = runtime.run_turn(input, Some(&mut permission_prompter));
-        hook_abort_monitor.stop();
-        let summary = result?;
+        let summary = runtime.run_turn(input, Some(&mut permission_prompter))?;
         self.runtime = runtime;
         self.persist_session()?;
         println!(
@@ -1376,9 +1314,10 @@ impl LiveCli {
             return Ok(false);
         }
 
-        self.session = create_managed_session_handle()?;
+        let session_state = Session::new();
+        self.session = create_managed_session_handle(&session_state.session_id)?;
         self.runtime = build_runtime(
-            Session::new(),
+            session_state.with_persistence_path(self.session.path.clone()),
             self.model.clone(),
             self.system_prompt.clone(),
             true,
@@ -1412,6 +1351,7 @@ 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(),
@@ -1421,7 +1361,10 @@ impl LiveCli {
             self.allowed_tools.clone(),
             self.permission_mode,
         )?;
-        self.session = handle;
+        self.session = SessionHandle {
+            id: session_id,
+            path: handle.path,
+        };
         println!(
             "{}",
             format_resume_report(
@@ -1484,6 +1427,7 @@ 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(),
@@ -1493,7 +1437,10 @@ impl LiveCli {
                     self.allowed_tools.clone(),
                     self.permission_mode,
                 )?;
-                self.session = handle;
+                self.session = SessionHandle {
+                    id: session_id,
+                    path: handle.path,
+                };
                 println!(
                     "Session switched\n  Active session   {}\n  File             {}\n  Messages         {}",
                     self.session.id,
@@ -1502,8 +1449,41 @@ 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 or /session switch <session-id>.");
+                println!(
+                    "Unknown /session action '{other}'. Use /session list, /session switch <session-id>, or /session fork [branch-name]."
+                );
                 Ok(false)
             }
         }
@@ -1536,44 +1516,61 @@ fn sessions_dir() -> Result<PathBuf, Box<dyn std::error::Error>> {
     Ok(path)
 }
 
-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"));
+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}"));
     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 {
-        sessions_dir()?.join(format!("{reference}.json"))
-    };
-    if !path.exists() {
+    } else if looks_like_path {
         return Err(format!("session not found: {reference}").into());
-    }
+    } else {
+        resolve_managed_session_path(reference)?
+    };
     let id = path
-        .file_stem()
+        .file_name()
         .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 path.extension().and_then(|ext| ext.to_str()) != Some("json") {
+        if !is_managed_session_file(&path) {
             continue;
         }
         let metadata = entry.metadata()?;
@@ -1583,19 +1580,41 @@ 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 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();
+        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()
+                        .and_then(|value| value.to_str())
+                        .unwrap_or("unknown")
+                        .to_string(),
+                    0,
+                    None,
+                    None,
+                )
+            });
         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));
@@ -1618,11 +1637,23 @@ 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} path={path}",
+            "  {id:<20} {marker:<10} msgs={msgs:<4} modified={modified}{lineage} path={path}",
             id = session.id,
             msgs = session.message_count,
             modified = session.modified_epoch_secs,
+            lineage = lineage,
             path = session.path.display(),
         ));
     }
@@ -2001,52 +2032,14 @@ fn build_runtime(
     permission_mode: PermissionMode,
 ) -> Result<ConversationRuntime<AnthropicRuntimeClient, CliToolExecutor>, Box<dyn std::error::Error>>
 {
-    let feature_config = build_runtime_feature_config()?;
-    let mut runtime = ConversationRuntime::new_with_features(
+    Ok(ConversationRuntime::new_with_features(
         session,
         AnthropicRuntimeClient::new(model, enable_tools, emit_output, allowed_tools.clone())?,
         CliToolExecutor::new(allowed_tools, emit_output),
-        permission_policy(permission_mode, &feature_config),
+        permission_policy(permission_mode),
         system_prompt,
-        feature_config,
-    );
-    if emit_output {
-        runtime = runtime.with_hook_progress_reporter(Box::new(CliHookProgressReporter));
-    }
-    Ok(runtime)
-}
-
-struct CliHookProgressReporter;
-
-impl runtime::HookProgressReporter for CliHookProgressReporter {
-    fn on_event(&mut self, event: &runtime::HookProgressEvent) {
-        match event {
-            runtime::HookProgressEvent::Started {
-                event,
-                tool_name,
-                command,
-            } => eprintln!(
-                "[hook {event_name}] {tool_name}: {command}",
-                event_name = event.as_str()
-            ),
-            runtime::HookProgressEvent::Completed {
-                event,
-                tool_name,
-                command,
-            } => eprintln!(
-                "[hook done {event_name}] {tool_name}: {command}",
-                event_name = event.as_str()
-            ),
-            runtime::HookProgressEvent::Cancelled {
-                event,
-                tool_name,
-                command,
-            } => eprintln!(
-                "[hook cancelled {event_name}] {tool_name}: {command}",
-                event_name = event.as_str()
-            ),
-        }
-    }
+        build_runtime_feature_config()?,
+    ))
 }
 
 struct CliPermissionPrompter {
@@ -2069,9 +2062,6 @@ impl runtime::PermissionPrompter for CliPermissionPrompter {
         println!("  Tool             {}", request.tool_name);
         println!("  Current mode     {}", self.current_mode.as_str());
         println!("  Required mode    {}", request.required_mode.as_str());
-        if let Some(reason) = &request.reason {
-            println!("  Reason           {reason}");
-        }
         println!("  Input            {}", request.input);
         print!("Approve this tool call? [y/N]: ");
         let _ = io::stdout().flush();
@@ -2484,15 +2474,13 @@ fn format_bash_result(icon: &str, parsed: &serde_json::Value) -> String {
         .get("backgroundTaskId")
         .and_then(|value| value.as_str())
     {
-        use std::fmt::Write as _;
-        let _ = write!(lines[0], " backgrounded ({task_id})");
+        lines[0].push_str(&format!(" backgrounded ({task_id})"));
     } else if let Some(status) = parsed
         .get("returnCodeInterpretation")
         .and_then(|value| value.as_str())
         .filter(|status| !status.is_empty())
     {
-        use std::fmt::Write as _;
-        let _ = write!(lines[0], " {status}");
+        lines[0].push_str(&format!(" {status}"));
     }
 
     if let Some(stdout) = parsed.get("stdout").and_then(|value| value.as_str()) {
@@ -2514,15 +2502,15 @@ fn format_read_result(icon: &str, parsed: &serde_json::Value) -> String {
     let path = extract_tool_path(file);
     let start_line = file
         .get("startLine")
-        .and_then(serde_json::Value::as_u64)
+        .and_then(|value| value.as_u64())
         .unwrap_or(1);
     let num_lines = file
         .get("numLines")
-        .and_then(serde_json::Value::as_u64)
+        .and_then(|value| value.as_u64())
         .unwrap_or(0);
     let total_lines = file
         .get("totalLines")
-        .and_then(serde_json::Value::as_u64)
+        .and_then(|value| value.as_u64())
         .unwrap_or(num_lines);
     let content = file
         .get("content")
@@ -2548,7 +2536,8 @@ fn format_write_result(icon: &str, parsed: &serde_json::Value) -> String {
     let line_count = parsed
         .get("content")
         .and_then(|value| value.as_str())
-        .map_or(0, |content| content.lines().count());
+        .map(|content| content.lines().count())
+        .unwrap_or(0);
     format!(
         "{icon} \x1b[1;32m✏️ {} {path}\x1b[0m \x1b[2m({line_count} lines)\x1b[0m",
         if kind == "create" { "Wrote" } else { "Updated" },
@@ -2579,7 +2568,7 @@ fn format_edit_result(icon: &str, parsed: &serde_json::Value) -> String {
     let path = extract_tool_path(parsed);
     let suffix = if parsed
         .get("replaceAll")
-        .and_then(serde_json::Value::as_bool)
+        .and_then(|value| value.as_bool())
         .unwrap_or(false)
     {
         " (replace all)"
@@ -2607,7 +2596,7 @@ fn format_edit_result(icon: &str, parsed: &serde_json::Value) -> String {
 fn format_glob_result(icon: &str, parsed: &serde_json::Value) -> String {
     let num_files = parsed
         .get("numFiles")
-        .and_then(serde_json::Value::as_u64)
+        .and_then(|value| value.as_u64())
         .unwrap_or(0);
     let filenames = parsed
         .get("filenames")
@@ -2631,11 +2620,11 @@ fn format_glob_result(icon: &str, parsed: &serde_json::Value) -> String {
 fn format_grep_result(icon: &str, parsed: &serde_json::Value) -> String {
     let num_matches = parsed
         .get("numMatches")
-        .and_then(serde_json::Value::as_u64)
+        .and_then(|value| value.as_u64())
         .unwrap_or(0);
     let num_files = parsed
         .get("numFiles")
-        .and_then(serde_json::Value::as_u64)
+        .and_then(|value| value.as_u64())
         .unwrap_or(0);
     let content = parsed
         .get("content")
@@ -2794,14 +2783,12 @@ impl ToolExecutor for CliToolExecutor {
     }
 }
 
-fn permission_policy(
-    mode: PermissionMode,
-    feature_config: &runtime::RuntimeFeatureConfig,
-) -> PermissionPolicy {
-    tool_permission_specs().into_iter().fold(
-        PermissionPolicy::new(mode).with_permission_rules(feature_config.permission_rules()),
-        |policy, spec| policy.with_tool_requirement(spec.name, spec.required_permission),
-    )
+fn permission_policy(mode: PermissionMode) -> PermissionPolicy {
+    tool_permission_specs()
+        .into_iter()
+        .fold(PermissionPolicy::new(mode), |policy, spec| {
+            policy.with_tool_requirement(spec.name, spec.required_permission)
+        })
 }
 
 fn tool_permission_specs() -> Vec<ToolSpec> {
@@ -2870,7 +2857,7 @@ fn print_help_to(out: &mut impl Write) -> io::Result<()> {
     writeln!(out, "      Shorthand non-interactive prompt mode")?;
     writeln!(
         out,
-        "  claw --resume SESSION.json [/status] [/compact] [...]"
+        "  claw --resume SESSION.jsonl [/status] [/compact] [...]"
     )?;
     writeln!(
         out,
@@ -2930,7 +2917,7 @@ fn print_help_to(out: &mut impl Write) -> io::Result<()> {
     )?;
     writeln!(
         out,
-        "  claw --resume session.json /status /diff /export notes.txt"
+        "  claw --resume session.jsonl /status /diff /export notes.txt"
     )?;
     writeln!(out, "  claw login")?;
     writeln!(out, "  claw init")?;
@@ -2944,23 +2931,23 @@ fn print_help() {
 #[cfg(test)]
 mod tests {
     use super::{
-        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,
+        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,
         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, response_to_events, resume_supported_slash_commands, status_context,
-        CliAction, CliOutputFormat, HookAbortMonitor, SlashCommand, StatusUsage, DEFAULT_MODEL,
+        resolve_model_alias, resolve_session_reference, 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, HookAbortSignal, MessageRole,
-        PermissionMode,
+        AssistantEvent, ContentBlock, ConversationMessage, MessageRole, PermissionMode, Session,
     };
     use serde_json::json;
     use std::path::PathBuf;
-    use std::sync::mpsc;
-    use std::time::Duration;
+    use std::sync::{Mutex, OnceLock};
 
     #[test]
     fn defaults_to_repl_when_no_args() {
@@ -3134,13 +3121,13 @@ mod tests {
     fn parses_resume_flag_with_slash_command() {
         let args = vec![
             "--resume".to_string(),
-            "session.json".to_string(),
+            "session.jsonl".to_string(),
             "/compact".to_string(),
         ];
         assert_eq!(
             parse_args(&args).expect("args should parse"),
             CliAction::ResumeSession {
-                session_path: PathBuf::from("session.json"),
+                session_path: PathBuf::from("session.jsonl"),
                 commands: vec!["/compact".to_string()],
             }
         );
@@ -3150,7 +3137,7 @@ mod tests {
     fn parses_resume_flag_with_multiple_slash_commands() {
         let args = vec![
             "--resume".to_string(),
-            "session.json".to_string(),
+            "session.jsonl".to_string(),
             "/status".to_string(),
             "/compact".to_string(),
             "/cost".to_string(),
@@ -3158,7 +3145,7 @@ mod tests {
         assert_eq!(
             parse_args(&args).expect("args should parse"),
             CliAction::ResumeSession {
-                session_path: PathBuf::from("session.json"),
+                session_path: PathBuf::from("session.jsonl"),
                 commands: vec![
                     "/status".to_string(),
                     "/compact".to_string(),
@@ -3186,7 +3173,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.json"));
+        assert!(help.contains("works with --resume SESSION.jsonl"));
     }
 
     #[test]
@@ -3206,7 +3193,7 @@ mod tests {
         assert!(help.contains("/diff"));
         assert!(help.contains("/version"));
         assert!(help.contains("/export [file]"));
-        assert!(help.contains("/session [list|switch <session-id>]"));
+        assert!(help.contains("/session [list|switch <session-id>|fork [branch-name]]"));
         assert!(help.contains("/exit"));
     }
 
@@ -3227,9 +3214,9 @@ mod tests {
 
     #[test]
     fn resume_report_uses_sectioned_layout() {
-        let report = format_resume_report("session.json", 14, 6);
+        let report = format_resume_report("session.jsonl", 14, 6);
         assert!(report.contains("Session resumed"));
-        assert!(report.contains("Session file     session.json"));
+        assert!(report.contains("Session file     session.jsonl"));
         assert!(report.contains("Messages         14"));
         assert!(report.contains("Turns            6"));
     }
@@ -3331,7 +3318,7 @@ mod tests {
             "workspace-write",
             &super::StatusContext {
                 cwd: PathBuf::from("/tmp/project"),
-                session_path: Some(PathBuf::from("session.json")),
+                session_path: Some(PathBuf::from("session.jsonl")),
                 loaded_config_files: 2,
                 discovered_config_files: 3,
                 memory_file_count: 4,
@@ -3348,7 +3335,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.json"));
+        assert!(status.contains("Session          session.jsonl"));
         assert!(status.contains("Config files     loaded 2/3"));
         assert!(status.contains("Memory files     4"));
     }
@@ -3423,9 +3410,9 @@ mod tests {
     #[test]
     fn parses_resume_and_config_slash_commands() {
         assert_eq!(
-            SlashCommand::parse("/resume saved-session.json"),
+            SlashCommand::parse("/resume saved-session.jsonl"),
             Some(SlashCommand::Resume {
-                session_path: Some("saved-session.json".to_string())
+                session_path: Some("saved-session.jsonl".to_string())
             })
         );
         assert_eq!(
@@ -3444,6 +3431,65 @@ 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]
@@ -3619,43 +3665,4 @@ mod tests {
                 if name == "read_file" && input == "{\"path\":\"rust/Cargo.toml\"}"
         ));
     }
-
-    #[test]
-    fn hook_abort_monitor_stops_without_aborting() {
-        let abort_signal = HookAbortSignal::new();
-        let (ready_tx, ready_rx) = mpsc::channel();
-        let monitor = HookAbortMonitor::spawn_with_waiter(
-            abort_signal.clone(),
-            move |stop_rx, abort_signal| {
-                ready_tx.send(()).expect("ready signal");
-                let _ = stop_rx.recv();
-                assert!(!abort_signal.is_aborted());
-            },
-        );
-
-        ready_rx.recv().expect("waiter should be ready");
-        monitor.stop();
-
-        assert!(!abort_signal.is_aborted());
-    }
-
-    #[test]
-    fn hook_abort_monitor_propagates_interrupt() {
-        let abort_signal = HookAbortSignal::new();
-        let (done_tx, done_rx) = mpsc::channel();
-        let monitor = HookAbortMonitor::spawn_with_waiter(
-            abort_signal.clone(),
-            move |_stop_rx, abort_signal| {
-                abort_signal.abort();
-                done_tx.send(()).expect("done signal");
-            },
-        );
-
-        done_rx
-            .recv_timeout(Duration::from_secs(1))
-            .expect("interrupt should complete");
-        monitor.stop();
-
-        assert!(abort_signal.is_aborted());
-    }
 }

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

@@ -286,7 +286,7 @@ impl TerminalRenderer {
     ) {
         match event {
             Event::Start(Tag::Heading { level, .. }) => {
-                Self::start_heading(state, level as u8, output);
+                self.start_heading(state, level as u8, output)
             }
             Event::End(TagEnd::Paragraph) => output.push_str("\n\n"),
             Event::Start(Tag::BlockQuote(..)) => self.start_quote(state, output),
@@ -426,7 +426,7 @@ impl TerminalRenderer {
         }
     }
 
-    fn start_heading(state: &mut RenderState, level: u8, output: &mut String) {
+    fn start_heading(&self, state: &mut RenderState, level: u8, output: &mut String) {
         state.heading_level = Some(level);
         if !output.is_empty() {
             output.push('\n');