An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.
Rust
feat: jsonl-session progress
Yeachan-Heo5cee042e590e
diff --git a/rust/crates/commands/src/lib.rs b/rust/crates/commands/src/lib.rsindex b1ae4b0f..6a3d2341 100644--- a/rust/crates/commands/src/lib.rs+++ b/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,7 +392,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_eq!(slash_command_specs().len(), 15);assert_eq!(resume_supported_slash_commands().len(), 11);}@@ -453,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()diff --git a/rust/crates/runtime/src/conversation.rs b/rust/crates/runtime/src/conversation.rsindex 94cf9ba0..789a23d5 100644--- a/rust/crates/runtime/src/conversation.rs+++ b/rust/crates/runtime/src/conversation.rs@@ -286,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@@ -838,6 +843,35 @@ mod tests {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)diff --git a/rust/crates/runtime/src/lib.rs b/rust/crates/runtime/src/lib.rsindex 6e1a50a5..28e7e41a 100644--- a/rust/crates/runtime/src/lib.rs+++ b/rust/crates/runtime/src/lib.rs@@ -78,6 +78,7 @@ pub use remote::{};pub use session::{ContentBlock, ConversationMessage, MessageRole, Session, SessionCompaction, SessionError,+ SessionFork,};pub use usage::{format_usd, pricing_for_model, ModelPricing, TokenUsage, UsageCostEstimate, UsageTracker,diff --git a/rust/crates/runtime/src/session.rs b/rust/crates/runtime/src/session.rsindex 46f0fc00..f102b3b8 100644--- a/rust/crates/runtime/src/session.rs+++ b/rust/crates/runtime/src/session.rs@@ -54,6 +54,12 @@ pub struct SessionCompaction {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,@@ -67,6 +73,7 @@ pub struct Session {pub updated_at_ms: u64,pub messages: Vec<ConversationMessage>,pub compaction: Option<SessionCompaction>,+ pub fork: Option<SessionFork>,persistence: Option<SessionPersistence>,}@@ -78,6 +85,7 @@ impl PartialEq for Session {&& self.updated_at_ms == other.updated_at_ms&& self.messages == other.messages&& self.compaction == other.compaction+ && self.fork == other.fork}}@@ -125,6 +133,7 @@ impl Session {updated_at_ms: now,messages: Vec::new(),compaction: None,+ fork: None,persistence: None,}}@@ -178,6 +187,24 @@ impl Session {});}+ #[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]pub fn to_json(&self) -> JsonValue {let mut object = BTreeMap::new();@@ -209,6 +236,9 @@ impl Session {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)}@@ -249,6 +279,7 @@ impl Session {.get("compaction").map(SessionCompaction::from_json).transpose()?;+ let fork = object.get("fork").map(SessionFork::from_json).transpose()?;Ok(Self {version,session_id,@@ -256,6 +287,7 @@ impl Session {updated_at_ms,messages,compaction,+ fork,persistence: None,})}@@ -267,6 +299,7 @@ impl Session {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();@@ -300,6 +333,7 @@ impl Session {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(|| {@@ -332,6 +366,7 @@ impl Session {updated_at_ms: updated_at_ms.unwrap_or(created_at_ms.unwrap_or(now)),messages,compaction,+ fork,persistence: None,})}@@ -389,6 +424,9 @@ impl Session {"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)}@@ -634,6 +672,37 @@ impl SessionCompaction {}}+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()));@@ -723,6 +792,17 @@ 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)@@ -815,7 +895,7 @@ fn cleanup_rotated_logs(path: &Path) -> Result<(), SessionError> {mod tests {use super::{cleanup_rotated_logs, rotate_session_file_if_needed, ContentBlock, ConversationMessage,- MessageRole, Session,+ MessageRole, Session, SessionFork,};use crate::json::JsonValue;use crate::usage::TokenUsage;@@ -938,6 +1018,35 @@ mod tests {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");diff --git a/rust/crates/rusty-claude-cli/src/main.rs b/rust/crates/rusty-claude-cli/src/main.rsindex d60e33a8..60120281 100644--- a/rust/crates/rusty-claude-cli/src/main.rs+++ b/rust/crates/rusty-claude-cli/src/main.rs@@ -47,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>;@@ -589,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}");@@ -600,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;@@ -612,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,@@ -973,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 {@@ -1433,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)}}@@ -1471,34 +1520,57 @@ 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}.json"));+ let path = sessions_dir()?.join(format!("{id}.{PRIMARY_SESSION_EXTENSION}"));Ok(SessionHandle { id, path })}fn resolve_session_reference(reference: &str) -> Result<SessionHandle, Box<dyn std::error::Error>> {let direct = PathBuf::from(reference);+ let looks_like_path = direct.extension().is_some() || direct.components().count() > 1;let path = if direct.exists() {direct+ } else if looks_like_path {+ return Err(format!("session not found: {reference}").into());} else {- sessions_dir()?.join(format!("{reference}.json"))+ resolve_managed_session_path(reference)?};- if !path.exists() {- return Err(format!("session not found: {reference}").into());- }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()?;@@ -1508,8 +1580,23 @@ fn list_managed_sessions() -> Result<Vec<ManagedSessionSummary>, Box<dyn std::er.and_then(|time| time.duration_since(UNIX_EPOCH).ok()).map(|duration| duration.as_secs()).unwrap_or_default();- let (id, message_count) = Session::load_from_path(&path)- .map(|session| (session.session_id, session.messages.len()))+ 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()@@ -1517,6 +1604,8 @@ fn list_managed_sessions() -> Result<Vec<ManagedSessionSummary>, Box<dyn std::er.unwrap_or("unknown").to_string(),0,+ None,+ None,)});sessions.push(ManagedSessionSummary {@@ -1524,6 +1613,8 @@ fn list_managed_sessions() -> Result<Vec<ManagedSessionSummary>, Box<dyn std::erpath,modified_epoch_secs,message_count,+ parent_session_id,+ branch_name,});}sessions.sort_by(|left, right| right.modified_epoch_secs.cmp(&left.modified_epoch_secs));@@ -1546,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(),));}@@ -2754,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,@@ -2814,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")?;@@ -2828,18 +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, 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, MessageRole, PermissionMode};+ use runtime::{+ AssistantEvent, ContentBlock, ConversationMessage, MessageRole, PermissionMode, Session,+ };use serde_json::json;use std::path::PathBuf;+ use std::sync::{Mutex, OnceLock};#[test]fn defaults_to_repl_when_no_args() {@@ -3013,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()],});@@ -3029,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(),@@ -3037,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(),@@ -3065,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]@@ -3085,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"));}@@ -3106,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"));}@@ -3210,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,@@ -3227,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"));}@@ -3302,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!(@@ -3323,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]