handoff-mcp-server 0.16.0 → 0.17.1

package/src/mcp/handlers/update_session.rs

@@ -10,21 +10,28 @@ pub fn handle(arguments: &Value) -> Result<String> {
     let handoff = ensure_handoff_exists(&project_dir)?;
     let sessions_dir = handoff.join("sessions");
 
+    let target_session_id = arguments.get("session_id").and_then(|v| v.as_str());
+
     let active = read_active_sessions(&sessions_dir)?;
     if active.is_empty() {
         anyhow::bail!(
             "No active session. Call save_context with session_status='active' to create one first."
         );
     }
-    if active.len() > 1 {
-        let ids: Vec<String> = active.iter().filter_map(|s| s.id.clone()).collect();
-        anyhow::bail!(
-            "Multiple active sessions ({}). Use save_context to resolve.",
-            ids.join(", ")
-        );
-    }
 
-    let session = &active[0];
+    let session = if let Some(tid) = target_session_id {
+        active
+            .iter()
+            .find(|s| {
+                s.id.as_deref()
+                    .is_some_and(|id| id == tid || id.starts_with(tid) || tid.starts_with(id))
+            })
+            .ok_or_else(|| anyhow::anyhow!("session_id '{tid}' not found among active sessions"))?
+    } else if active.len() == 1 {
+        &active[0]
+    } else {
+        active.last().unwrap()
+    };
     let sid = session.id.as_deref().unwrap_or("");
 
     let checklist_index = arguments

package/src/mcp/handlers/update_task.rs

@@ -247,6 +247,15 @@ fn handle_update(
     }
     if let Some(notes) = task_val.get("notes").and_then(|v| v.as_str()) {
         data.notes = Some(notes.to_string());
+    } else if let Some(append) = task_val.get("notes_append").and_then(|v| v.as_str()) {
+        let timestamp = Utc::now().format("%Y-%m-%dT%H:%M:%S");
+        let block = format!("--- {timestamp}\n{append}");
+        match &mut data.notes {
+            Some(existing) if !existing.is_empty() => {
+                existing.push_str(&format!("\n\n{block}"));
+            }
+            _ => data.notes = Some(block),
+        }
     }
     if let Some(priority) = task_val.get("priority").and_then(|v| v.as_str()) {
         validate_priority(Some(priority))?;

package/src/mcp/tools.rs

@@ -168,6 +168,23 @@ pub fn all_tool_definitions() -> Vec<ToolDefinition> {
                     "environment": {
                         "type": "object",
                         "description": "Free-form environment state"
+                    },
+                    "session_id": {
+                        "type": "string",
+                        "description": "Target active session ID. When multiple active sessions exist, specifies which to update/close. If omitted, uses the latest active session. Lower priority than close_session_id / pause_session_id."
+                    },
+                    "timeline": {
+                        "type": "string",
+                        "description": "Session timeline/group label (e.g. 'feature-x', 'hotfix-y')."
+                    },
+                    "label": {
+                        "type": "string",
+                        "description": "Short human-readable session label for switching UI (e.g. 'WT2作業', 'API設計')."
+                    },
+                    "related_task_ids": {
+                        "type": "array",
+                        "description": "Task IDs this session is primarily working on.",
+                        "items": { "type": "string" }
                     }
                 },
                 "required": ["summary"]
@@ -272,6 +289,7 @@ pub fn all_tool_definitions() -> Vec<ToolDefinition> {
                                 "enum": ["todo", "in_progress", "review", "done", "blocked", "skipped"]
                             },
                             "notes": { "type": "string" },
+                            "notes_append": { "type": "string", "description": "Append text to existing notes with a timestamp heading. If both notes and notes_append are provided, notes (replace) takes precedence." },
                             "priority": {
                                 "type": "string",
                                 "enum": ["low", "medium", "high"]
@@ -695,6 +713,10 @@ pub fn all_tool_definitions() -> Vec<ToolDefinition> {
                         "type": "string",
                         "description": "Project directory path. Defaults to current working directory."
                     },
+                    "session_id": {
+                        "type": "string",
+                        "description": "Target active session ID. When multiple active sessions exist, specifies which to update. If omitted and multiple exist, uses the latest."
+                    },
                     "checklist_index": {
                         "type": "integer",
                         "description": "0-based index of a checklist item to toggle."
@@ -798,9 +820,17 @@ pub fn all_tool_definitions() -> Vec<ToolDefinition> {
                         "enum": ["open", "active", "paused", "closed"],
                         "description": "Filter sessions by status."
                     },
+                    "timeline": {
+                        "type": "string",
+                        "description": "Filter sessions by timeline label."
+                    },
                     "limit": {
                         "type": "integer",
                         "description": "Max sessions to return (default 20)."
+                    },
+                    "include_children": {
+                        "type": "boolean",
+                        "description": "If true, include a 'children' array on each session showing its forked child sessions."
                     }
                 }
             }),
@@ -838,6 +868,8 @@ pub fn all_tool_definitions() -> Vec<ToolDefinition> {
                                 "status": { "type": "string", "enum": ["todo", "in_progress", "review", "done", "blocked", "skipped"] },
                                 "priority": { "type": "string", "enum": ["low", "medium", "high"] },
                                 "assignee": { "type": "string" },
+                                "notes": { "type": "string", "description": "Replace task notes." },
+                                "notes_append": { "type": "string", "description": "Append text to existing notes with a timestamp heading. If both notes and notes_append are provided, notes (replace) takes precedence." },
                                 "schedule": {
                                     "type": "object",
                                     "properties": {
@@ -1082,6 +1114,74 @@ pub fn all_tool_definitions() -> Vec<ToolDefinition> {
                 }
             }),
         },
+        // ---- Session fork/merge tools ----
+        ToolDefinition {
+            name: "handoff_fork_session".to_string(),
+            description: "Fork a new session from an existing one. Inherits decisions, context_pointers, references, and handoff_notes by default. The forked session becomes active with parent_session_id set.".to_string(),
+            input_schema: json!({
+                "type": "object",
+                "properties": {
+                    "project_dir": {
+                        "type": "string",
+                        "description": "Project directory path. Defaults to current working directory."
+                    },
+                    "source_session_id": {
+                        "type": "string",
+                        "description": "Session ID to fork from (active, paused, or closed)."
+                    },
+                    "summary": {
+                        "type": "string",
+                        "description": "Summary for the new forked session."
+                    },
+                    "label": {
+                        "type": "string",
+                        "description": "Short human-readable label for the forked session."
+                    },
+                    "timeline": {
+                        "type": "string",
+                        "description": "Timeline label. Defaults to the source session's timeline."
+                    },
+                    "inherit": {
+                        "type": "array",
+                        "description": "Fields to inherit from the source. Default: [\"decisions\", \"context_pointers\", \"references\", \"handoff_notes\", \"environment\"]. Available: decisions, context_pointers, references, handoff_notes, environment, blockers, checklist.",
+                        "items": { "type": "string" }
+                    },
+                    "related_task_ids": {
+                        "type": "array",
+                        "description": "Task IDs the forked session will work on.",
+                        "items": { "type": "string" }
+                    }
+                },
+                "required": ["source_session_id", "summary"]
+            }),
+        },
+        ToolDefinition {
+            name: "handoff_merge_sessions".to_string(),
+            description: "Merge multiple sessions into one. Combines decisions, notes, references, and context_pointers. Detects duplicate decisions as conflicts. Source sessions (except the target) are closed by default.".to_string(),
+            input_schema: json!({
+                "type": "object",
+                "properties": {
+                    "project_dir": {
+                        "type": "string",
+                        "description": "Project directory path. Defaults to current working directory."
+                    },
+                    "source_session_ids": {
+                        "type": "array",
+                        "description": "Session IDs to merge (must include at least 2).",
+                        "items": { "type": "string" }
+                    },
+                    "target_session_id": {
+                        "type": "string",
+                        "description": "Which source session becomes the merge target (must be one of source_session_ids)."
+                    },
+                    "close_sources": {
+                        "type": "boolean",
+                        "description": "Close non-target source sessions after merge. Default: true."
+                    }
+                },
+                "required": ["source_session_ids", "target_session_id"]
+            }),
+        },
         // ---- Timer coordination tools ----
         ToolDefinition {
             name: "handoff_timer_start".to_string(),

package/src/setup.rs

@@ -56,7 +56,7 @@ fn build_hooks_config() -> BTreeMap<&'static str, Value> {
         "UserPromptSubmit",
         serde_json::json!([{
             "hooks": [mcp_tool_hook(HOOK_TOOL_QUERY, serde_json::json!({
-                "project_dir": "${cwd}",
+                "project_dir": "${CLAUDE_PROJECT_DIR}",
                 "session_id": "${session_id}",
                 "text": "${prompt}"
             }))]
@@ -68,7 +68,7 @@ fn build_hooks_config() -> BTreeMap<&'static str, Value> {
         serde_json::json!([{
             "matcher": "Edit|Write|MultiEdit",
             "hooks": [mcp_tool_hook(HOOK_TOOL_QUERY, serde_json::json!({
-                "project_dir": "${cwd}",
+                "project_dir": "${CLAUDE_PROJECT_DIR}",
                 "session_id": "${session_id}",
                 "tool_name": "${tool_name}",
                 "text": "${tool_input.file_path}",
@@ -81,7 +81,7 @@ fn build_hooks_config() -> BTreeMap<&'static str, Value> {
         "SessionStart",
         serde_json::json!([{
             "hooks": [mcp_tool_hook(HOOK_TOOL_CLEANUP, serde_json::json!({
-                "project_dir": "${cwd}"
+                "project_dir": "${CLAUDE_PROJECT_DIR}"
             }))]
         }]),
     );

package/src/storage/config.rs

@@ -90,6 +90,9 @@ pub struct SettingsConfig {
     /// Idle timeout in minutes for MCP fallback timer. Default 10.
     #[serde(default = "default_timer_idle_timeout_minutes")]
     pub timer_idle_timeout_minutes: u64,
+    /// Allow multiple active sessions simultaneously. Default false (single-active).
+    #[serde(default)]
+    pub multi_session: bool,
     #[serde(default)]
     pub custom_fields: HashMap<String, toml::Value>,
 }
@@ -295,6 +298,7 @@ impl Default for SettingsConfig {
             timer_provider: default_timer_provider(),
             timer_authority_ttl_secs: default_timer_authority_ttl_secs(),
             timer_idle_timeout_minutes: default_timer_idle_timeout_minutes(),
+            multi_session: false,
             custom_fields: HashMap::new(),
         }
     }
@@ -311,6 +315,10 @@ impl Default for DashboardConfig {
 
 impl Config {
     pub fn new(name: &str, description: &str) -> Self {
+        let settings = SettingsConfig {
+            multi_session: true,
+            ..SettingsConfig::default()
+        };
         Self {
             project: ProjectConfig {
                 name: name.to_string(),
@@ -320,7 +328,7 @@ impl Config {
                     Some(description.to_string())
                 },
             },
-            settings: SettingsConfig::default(),
+            settings,
             dashboard: DashboardConfig::default(),
             started_at: None,
             schedule_mode: None,

package/src/storage/sessions.rs

@@ -32,6 +32,14 @@ pub struct SessionData {
     pub context_pointers: Vec<Value>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub environment: Option<Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timeline: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub label: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parent_session_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub related_task_ids: Vec<String>,
 }
 
 pub fn generate_session_id() -> String {
@@ -79,19 +87,34 @@ fn summary_to_slug(summary: &str) -> String {
     }
 }
 
-fn compact_timestamp(data: &SessionData) -> String {
-    let timestamp = data.ended_at.as_deref().unwrap_or("00000000-000000");
-    let ts_compact = timestamp
-        .replace(['-', ':'], "")
-        .replace('T', "-")
-        .replace('Z', "");
-    if ts_compact.len() >= 15 {
-        ts_compact[..15].to_string()
+fn extract_timestamp_from_id(id: &str) -> Option<String> {
+    // "s-20260704-003557-792065" → "20260704-003557"
+    let rest = id.strip_prefix("s-")?;
+    if rest.len() >= 15 {
+        Some(rest[..15].to_string())
     } else {
-        ts_compact
+        None
     }
 }
 
+fn compact_timestamp(data: &SessionData) -> String {
+    data.ended_at
+        .as_deref()
+        .map(|ts| {
+            let compact = ts
+                .replace(['-', ':'], "")
+                .replace('T', "-")
+                .replace('Z', "");
+            if compact.len() >= 15 {
+                compact[..15].to_string()
+            } else {
+                compact
+            }
+        })
+        .or_else(|| data.id.as_deref().and_then(extract_timestamp_from_id))
+        .unwrap_or_else(|| "00000000-000000".to_string())
+}
+
 fn synthesize_id_from_filename(filename: &str) -> String {
     // Old format: YYYYMMDD-HHMMSS-slug.status.json
     // Extract timestamp part and create s-YYYYMMDD-HHMMSS-000000
@@ -169,13 +192,12 @@ pub fn read_active_sessions(sessions_dir: &Path) -> Result<Vec<SessionData>> {
     read_sessions_by_status(sessions_dir, "active")
 }
 
-/// Append `decision` (a decision object: {decision, reason?, confidence?}) to the
-/// `decisions` list of every active session file. Returns the number of sessions
-/// updated. Used by tools like auto_schedule to record applied changes so the
-/// audit trail lives with the session, not just the tool response.
+/// Append `decision` to active session(s). When `target_session_id` is Some,
+/// only the matching session is updated; otherwise all active sessions are updated.
 pub fn append_decision_to_active_sessions(
     sessions_dir: &Path,
     decision: serde_json::Value,
+    target_session_id: Option<&str>,
 ) -> Result<usize> {
     let suffix = ".active.json";
     if !sessions_dir.exists() {
@@ -194,6 +216,14 @@ pub fn append_decision_to_active_sessions(
             .with_context(|| format!("Failed to read session: {}", path.display()))?;
         let mut data: SessionData = serde_json::from_str(&content)
             .with_context(|| format!("Failed to parse session: {}", path.display()))?;
+
+        if let Some(tid) = target_session_id {
+            let file_id = data.id.as_deref().unwrap_or("");
+            if !ids_match(file_id, tid) {
+                continue;
+            }
+        }
+
         data.decisions.push(decision.clone());
         let updated = serde_json::to_string_pretty(&data).context("Failed to serialize session")?;
         crate::storage::atomic_write(&path, updated.as_bytes())
@@ -369,6 +399,15 @@ fn apply_session_updates(data: &mut SessionData, updates: &SessionData) {
     if updates.environment.is_some() {
         data.environment = updates.environment.clone();
     }
+    if updates.timeline.is_some() {
+        data.timeline = updates.timeline.clone();
+    }
+    if updates.label.is_some() {
+        data.label = updates.label.clone();
+    }
+    if !updates.related_task_ids.is_empty() {
+        data.related_task_ids = updates.related_task_ids.clone();
+    }
 }
 
 fn find_and_update_active_session(
@@ -419,7 +458,7 @@ fn find_and_update_active_session(
         );
     }
 
-    if let Some((path, name, _)) = matches.into_iter().next() {
+    if let Some((path, _, _)) = matches.into_iter().next() {
         let content = std::fs::read_to_string(&path)
             .with_context(|| format!("Failed to read session: {}", path.display()))?;
         let mut data: SessionData = serde_json::from_str(&content)
@@ -433,8 +472,9 @@ fn find_and_update_active_session(
             .with_context(|| format!("Failed to write session: {}", path.display()))?;
 
         if let Some(target_status) = transition_to {
-            let target_suffix = format!(".{target_status}.json");
-            let new_name = name.replace(suffix, &target_suffix);
+            let ts_part = compact_timestamp(&data);
+            let base = generate_session_filename(&data.summary, &ts_part);
+            let new_name = format!("{base}.{target_status}.json");
             let new_path = sessions_dir.join(&new_name);
             std::fs::rename(&path, &new_path).with_context(|| {
                 format!(
@@ -467,6 +507,277 @@ pub fn update_active_session(
     find_and_update_active_session(sessions_dir, session_id, updates, None)
 }
 
+pub fn read_session_by_id(sessions_dir: &Path, session_id: &str) -> Result<Option<SessionData>> {
+    if !sessions_dir.exists() {
+        return Ok(None);
+    }
+
+    let mut matches: Vec<(SessionData, String)> = Vec::new();
+
+    for entry in std::fs::read_dir(sessions_dir)? {
+        let entry = entry?;
+        let name = entry.file_name().to_string_lossy().to_string();
+        if !name.ends_with(".json") {
+            continue;
+        }
+        let content = std::fs::read_to_string(entry.path())
+            .with_context(|| format!("Failed to read session: {}", entry.path().display()))?;
+        let data: SessionData = serde_json::from_str(&content)
+            .with_context(|| format!("Failed to parse session: {}", entry.path().display()))?;
+
+        let file_id = data.id.as_deref().unwrap_or("");
+        let resolved_id = if file_id.is_empty() {
+            synthesize_id_from_filename(&name)
+        } else {
+            file_id.to_string()
+        };
+
+        if ids_match(&resolved_id, session_id) {
+            matches.push((data, resolved_id));
+        }
+    }
+
+    if matches.len() > 1 {
+        let candidates: Vec<&str> = matches.iter().map(|(_, id)| id.as_str()).collect();
+        anyhow::bail!(
+            "Ambiguous session_id '{}': matched {} sessions ({}). Provide a more specific ID.",
+            session_id,
+            matches.len(),
+            candidates.join(", ")
+        );
+    }
+
+    Ok(matches.into_iter().next().map(|(data, _)| data))
+}
+
+pub fn fork_session(
+    sessions_dir: &Path,
+    source: &SessionData,
+    summary: &str,
+    label: Option<&str>,
+    timeline: Option<&str>,
+    related_task_ids: Vec<String>,
+    inherit: &[&str],
+) -> Result<SessionData> {
+    let source_id = source
+        .id
+        .as_deref()
+        .ok_or_else(|| anyhow::anyhow!("Source session has no ID"))?;
+
+    let mut forked = SessionData {
+        version: source.version,
+        id: Some(generate_session_id()),
+        ended_at: None,
+        summary: summary.to_string(),
+        branch: None,
+        commit: None,
+        dirty_files: Vec::new(),
+        decisions: Vec::new(),
+        blockers: Vec::new(),
+        checklist: Vec::new(),
+        handoff_notes: Vec::new(),
+        references: Vec::new(),
+        context_pointers: Vec::new(),
+        environment: None,
+        timeline: timeline
+            .map(String::from)
+            .or_else(|| source.timeline.clone()),
+        label: label.map(String::from),
+        parent_session_id: Some(source_id.to_string()),
+        related_task_ids,
+    };
+
+    for field in inherit {
+        match *field {
+            "decisions" => forked.decisions = source.decisions.clone(),
+            "context_pointers" => forked.context_pointers = source.context_pointers.clone(),
+            "references" => forked.references = source.references.clone(),
+            "handoff_notes" => forked.handoff_notes = source.handoff_notes.clone(),
+            "environment" => forked.environment = source.environment.clone(),
+            "blockers" => forked.blockers = source.blockers.clone(),
+            "checklist" => forked.checklist = source.checklist.clone(),
+            _ => {}
+        }
+    }
+
+    write_session_with_status(sessions_dir, &forked, "active")?;
+    Ok(forked)
+}
+
+pub fn merge_sessions(
+    sessions_dir: &Path,
+    source_ids: &[&str],
+    target_id: &str,
+    close_sources: bool,
+) -> Result<MergeResult> {
+    let mut sources: Vec<SessionData> = Vec::new();
+    for sid in source_ids {
+        let session = read_session_by_id(sessions_dir, sid)?
+            .ok_or_else(|| anyhow::anyhow!("Source session not found: {sid}"))?;
+        sources.push(session);
+    }
+
+    let mut target = read_session_by_id(sessions_dir, target_id)?
+        .ok_or_else(|| anyhow::anyhow!("Target session not found: {target_id}"))?;
+
+    let target_actual_id = target.id.clone().unwrap_or_default();
+
+    let mut merged_decisions = 0usize;
+    let mut merged_notes = 0usize;
+    let mut merged_references = 0usize;
+    let mut merged_context_pointers = 0usize;
+    let mut conflicts = Vec::new();
+    let mut closed_sessions = Vec::new();
+
+    for source in &sources {
+        let source_actual_id = source.id.as_deref().unwrap_or("");
+        if source_actual_id == target_actual_id {
+            continue;
+        }
+
+        for d in &source.decisions {
+            let decision_text = d.get("decision").and_then(|v| v.as_str()).unwrap_or("");
+            let already_exists = target.decisions.iter().any(|td| {
+                td.get("decision").and_then(|v| v.as_str()).unwrap_or("") == decision_text
+            });
+            if already_exists {
+                conflicts.push(MergeConflict {
+                    conflict_type: "decision_conflict".to_string(),
+                    description: format!("Duplicate decision: {decision_text}"),
+                    session_a: target_actual_id.clone(),
+                    session_b: source_actual_id.to_string(),
+                });
+            } else {
+                target.decisions.push(d.clone());
+                merged_decisions += 1;
+            }
+        }
+
+        for n in &source.handoff_notes {
+            target.handoff_notes.push(n.clone());
+            merged_notes += 1;
+        }
+
+        for r in &source.references {
+            let label = r.get("label").and_then(|v| v.as_str()).unwrap_or("");
+            let already_exists = target
+                .references
+                .iter()
+                .any(|tr| tr.get("label").and_then(|v| v.as_str()).unwrap_or("") == label);
+            if !already_exists {
+                target.references.push(r.clone());
+                merged_references += 1;
+            }
+        }
+
+        for cp in &source.context_pointers {
+            let path = cp.get("path").and_then(|v| v.as_str()).unwrap_or("");
+            let already_exists = target
+                .context_pointers
+                .iter()
+                .any(|tcp| tcp.get("path").and_then(|v| v.as_str()).unwrap_or("") == path);
+            if !already_exists {
+                target.context_pointers.push(cp.clone());
+                merged_context_pointers += 1;
+            }
+        }
+
+        for task_id in &source.related_task_ids {
+            if !target.related_task_ids.contains(task_id) {
+                target.related_task_ids.push(task_id.clone());
+            }
+        }
+
+        if close_sources {
+            if let Some(path) = close_session_by_id(sessions_dir, source_actual_id)? {
+                let _ = path;
+                closed_sessions.push(source_actual_id.to_string());
+            }
+        }
+    }
+
+    update_session_in_place(sessions_dir, &target_actual_id, &target)?;
+
+    Ok(MergeResult {
+        merged_session_id: target_actual_id,
+        merged_decisions,
+        merged_notes,
+        merged_references,
+        merged_context_pointers,
+        conflicts,
+        closed_sessions,
+    })
+}
+
+fn update_session_in_place(
+    sessions_dir: &Path,
+    session_id: &str,
+    updated: &SessionData,
+) -> Result<()> {
+    if !sessions_dir.exists() {
+        anyhow::bail!("Sessions directory not found");
+    }
+
+    let mut matches: Vec<(PathBuf, String)> = Vec::new();
+
+    for entry in std::fs::read_dir(sessions_dir)? {
+        let entry = entry?;
+        let name = entry.file_name().to_string_lossy().to_string();
+        if !name.ends_with(".json") {
+            continue;
+        }
+        let content = std::fs::read_to_string(entry.path())?;
+        let data: SessionData = serde_json::from_str(&content)?;
+        let file_id = data.id.as_deref().unwrap_or("");
+        let resolved_id = if file_id.is_empty() {
+            synthesize_id_from_filename(&name)
+        } else {
+            file_id.to_string()
+        };
+        if ids_match(&resolved_id, session_id) {
+            matches.push((entry.path(), resolved_id));
+        }
+    }
+
+    if matches.len() > 1 {
+        let candidates: Vec<&str> = matches.iter().map(|(_, id)| id.as_str()).collect();
+        anyhow::bail!(
+            "Ambiguous session_id '{}': matched {} sessions ({}). Provide a more specific ID.",
+            session_id,
+            matches.len(),
+            candidates.join(", ")
+        );
+    }
+
+    if let Some((path, _)) = matches.into_iter().next() {
+        let serialized =
+            serde_json::to_string_pretty(updated).context("Failed to serialize session")?;
+        crate::storage::atomic_write(path, serialized.as_bytes())?;
+        return Ok(());
+    }
+
+    anyhow::bail!("Session not found for in-place update: {session_id}")
+}
+
+#[derive(Debug)]
+pub struct MergeConflict {
+    pub conflict_type: String,
+    pub description: String,
+    pub session_a: String,
+    pub session_b: String,
+}
+
+#[derive(Debug)]
+pub struct MergeResult {
+    pub merged_session_id: String,
+    pub merged_decisions: usize,
+    pub merged_notes: usize,
+    pub merged_references: usize,
+    pub merged_context_pointers: usize,
+    pub conflicts: Vec<MergeConflict>,
+    pub closed_sessions: Vec<String>,
+}
+
 pub fn enforce_history_limit(sessions_dir: &Path, limit: u32) -> Result<u32> {
     if !sessions_dir.exists() {
         return Ok(0);