handoff-mcp-server 0.26.0 → 0.28.0

package/src/setup.rs

@@ -1,1212 +0,0 @@
-use std::collections::BTreeMap;
-use std::path::{Path, PathBuf};
-
-use anyhow::{Context, Result};
-use serde_json::Value;
-
-const HOOK_SERVER: &str = "handoff";
-const HOOK_TOOL_QUERY: &str = "handoff_memory_query";
-const CLAUDE_MD_MARKER: &str = "## Session Handoff";
-
-const CLAUDE_MD_TEMPLATE: &str = include_str!("../templates/claude-md-section.md");
-
-fn settings_path() -> Result<PathBuf> {
-    let home = std::env::var("HOME")
-        .or_else(|_| std::env::var("USERPROFILE"))
-        .context("cannot determine home directory (HOME / USERPROFILE not set)")?;
-    Ok(Path::new(&home).join(".claude").join("settings.json"))
-}
-
-fn mcp_json_path() -> PathBuf {
-    let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
-    cwd.join(".mcp.json")
-}
-
-fn claude_md_path() -> PathBuf {
-    let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
-    cwd.join("CLAUDE.md")
-}
-
-fn has_claude_md_handoff_section(path: &Path) -> bool {
-    let Ok(text) = std::fs::read_to_string(path) else {
-        return false;
-    };
-    text.contains(CLAUDE_MD_MARKER)
-}
-
-fn ensure_claude_md_section(path: &Path, force: bool) -> Result<bool> {
-    let has_section = path.exists() && has_claude_md_handoff_section(path);
-
-    if has_section && !force {
-        return Ok(false);
-    }
-
-    let mut content = if path.exists() {
-        std::fs::read_to_string(path)
-            .with_context(|| format!("failed to read {}", path.display()))?
-    } else {
-        String::from("# CLAUDE.md\n")
-    };
-
-    if has_section {
-        content = replace_claude_md_section(&content);
-    }
-
-    if !content.ends_with('\n') {
-        content.push('\n');
-    }
-    content.push('\n');
-    content.push_str(CLAUDE_MD_TEMPLATE);
-
-    std::fs::write(path, &content)
-        .with_context(|| format!("failed to write {}", path.display()))?;
-    Ok(true)
-}
-
-fn replace_claude_md_section(text: &str) -> String {
-    let Some(start) = text.find(CLAUDE_MD_MARKER) else {
-        return text.to_string();
-    };
-    let after_marker = start + CLAUDE_MD_MARKER.len();
-    let end = text[after_marker..]
-        .find("\n## ")
-        .map(|pos| after_marker + pos)
-        .unwrap_or(text.len());
-    let mut result = text[..start].trim_end_matches('\n').to_string();
-    let trailing = text[end..].trim_start_matches('\n');
-    if !trailing.is_empty() {
-        result.push_str("\n\n");
-        result.push_str(trailing);
-    }
-    if !result.ends_with('\n') {
-        result.push('\n');
-    }
-    result
-}
-
-fn build_mcp_server_entry() -> Value {
-    serde_json::json!({
-        "type": "stdio",
-        "command": "handoff-mcp",
-        "args": [],
-        "env": {}
-    })
-}
-
-fn ensure_mcp_json_entry(path: &Path) -> Result<bool> {
-    let mut root = if path.exists() {
-        let text = std::fs::read_to_string(path)
-            .with_context(|| format!("failed to read {}", path.display()))?;
-        serde_json::from_str::<Value>(&text)
-            .with_context(|| format!("failed to parse {}", path.display()))?
-    } else {
-        serde_json::json!({ "mcpServers": {} })
-    };
-
-    let servers = root
-        .as_object_mut()
-        .context(".mcp.json root is not an object")?
-        .entry("mcpServers")
-        .or_insert_with(|| Value::Object(serde_json::Map::new()))
-        .as_object_mut()
-        .context(".mcp.json 'mcpServers' is not an object")?;
-
-    if servers.contains_key(HOOK_SERVER) {
-        return Ok(false);
-    }
-
-    servers.insert(HOOK_SERVER.to_string(), build_mcp_server_entry());
-
-    let text = serde_json::to_string_pretty(&root)?;
-    std::fs::write(path, text + "\n")
-        .with_context(|| format!("failed to write {}", path.display()))?;
-    Ok(true)
-}
-
-fn ensure_global_mcp_entry(settings: &mut Value) -> Result<bool> {
-    let obj = settings
-        .as_object_mut()
-        .context("settings.json root is not an object")?;
-    let servers = obj
-        .entry("mcpServers")
-        .or_insert_with(|| Value::Object(serde_json::Map::new()))
-        .as_object_mut()
-        .context("settings.json 'mcpServers' is not an object")?;
-
-    if servers.contains_key(HOOK_SERVER) {
-        return Ok(false);
-    }
-
-    servers.insert(HOOK_SERVER.to_string(), build_mcp_server_entry());
-    Ok(true)
-}
-
-fn has_global_mcp_entry(settings: &Value) -> bool {
-    settings
-        .get("mcpServers")
-        .and_then(|s| s.get(HOOK_SERVER))
-        .is_some()
-}
-
-fn remove_global_mcp_entry(settings: &mut Value) -> bool {
-    let Some(servers) = settings
-        .get_mut("mcpServers")
-        .and_then(|v| v.as_object_mut())
-    else {
-        return false;
-    };
-    let removed = servers.remove(HOOK_SERVER).is_some();
-    if removed && servers.is_empty() {
-        if let Some(obj) = settings.as_object_mut() {
-            obj.remove("mcpServers");
-        }
-    }
-    removed
-}
-
-fn has_mcp_json_entry(path: &Path) -> bool {
-    if !path.exists() {
-        return false;
-    }
-    let Ok(text) = std::fs::read_to_string(path) else {
-        return false;
-    };
-    let Ok(root) = serde_json::from_str::<Value>(&text) else {
-        return false;
-    };
-    root.get("mcpServers")
-        .and_then(|s| s.get(HOOK_SERVER))
-        .is_some()
-}
-
-fn read_settings(path: &Path) -> Result<Value> {
-    if path.exists() {
-        let text = std::fs::read_to_string(path)
-            .with_context(|| format!("failed to read {}", path.display()))?;
-        serde_json::from_str(&text).with_context(|| format!("failed to parse {}", path.display()))
-    } else {
-        Ok(Value::Object(serde_json::Map::new()))
-    }
-}
-
-fn write_settings(path: &Path, value: &Value) -> Result<()> {
-    let parent = path
-        .parent()
-        .context("settings path has no parent directory")?;
-    std::fs::create_dir_all(parent)
-        .with_context(|| format!("failed to create {}", parent.display()))?;
-
-    let text = serde_json::to_string_pretty(value)?;
-    let tmp = parent.join(".settings.json.tmp");
-    std::fs::write(&tmp, text + "\n")
-        .with_context(|| format!("failed to write {}", tmp.display()))?;
-    std::fs::rename(&tmp, path)
-        .with_context(|| format!("failed to rename {} -> {}", tmp.display(), path.display()))
-}
-
-fn mcp_tool_hook(tool: &str, input: Value) -> Value {
-    serde_json::json!({
-        "type": "mcp_tool",
-        "server": HOOK_SERVER,
-        "tool": tool,
-        "input": input
-    })
-}
-
-fn build_hooks_config() -> BTreeMap<&'static str, Value> {
-    let mut hooks = BTreeMap::new();
-
-    hooks.insert(
-        "UserPromptSubmit",
-        serde_json::json!([{
-            "hooks": [mcp_tool_hook(HOOK_TOOL_QUERY, serde_json::json!({
-                "project_dir": "${CLAUDE_PROJECT_DIR}",
-                "session_id": "${session_id}",
-                "text": "${prompt}"
-            }))]
-        }]),
-    );
-
-    hooks.insert(
-        "PreToolUse",
-        serde_json::json!([{
-            "matcher": "Edit|Write|MultiEdit",
-            "hooks": [mcp_tool_hook(HOOK_TOOL_QUERY, serde_json::json!({
-                "project_dir": "${CLAUDE_PROJECT_DIR}",
-                "session_id": "${session_id}",
-                "tool_name": "${tool_name}",
-                "text": "${tool_input.file_path}",
-                "file_paths": ["${tool_input.file_path}"]
-            }))]
-        }]),
-    );
-
-    hooks
-}
-
-fn has_handoff_hook(arr: &Value) -> bool {
-    let Some(entries) = arr.as_array() else {
-        return false;
-    };
-    for entry in entries {
-        let Some(hooks) = entry.get("hooks").and_then(|v| v.as_array()) else {
-            continue;
-        };
-        for hook in hooks {
-            if hook.get("server").and_then(|v| v.as_str()) == Some(HOOK_SERVER) {
-                return true;
-            }
-        }
-    }
-    false
-}
-
-/// Legacy event that used to carry a synchronous `handoff_memory_cleanup`
-/// hook. Removed as a desired hook in this fix (see wiki/100-stdio-concurrency.md)
-/// because it was the trigger for the VSCode hang under many parallel
-/// sub-agents. Still used to detect and migrate away stale installs from
-/// before this fix.
-const LEGACY_SESSION_START_EVENT: &str = "SessionStart";
-
-/// True if `settings` still has a handoff-owned hook registered under the
-/// legacy `SessionStart` event (i.e. an install performed before this fix
-/// removed the synchronous cleanup hook). Used both to auto-migrate on
-/// `setup` re-run and to flag the issue in `setup --check`.
-fn has_legacy_session_start_hook(settings: &Value) -> bool {
-    settings
-        .get("hooks")
-        .and_then(|h| h.get(LEGACY_SESSION_START_EVENT))
-        .map(has_handoff_hook)
-        .unwrap_or(false)
-}
-
-/// Removes handoff-owned hook entries from the legacy `SessionStart` event,
-/// leaving any other (non-handoff) hooks registered under that event intact.
-/// Returns true if anything was removed.
-fn strip_legacy_session_start_hook(hooks_obj: &mut serde_json::Map<String, Value>) -> bool {
-    let Some(arr) = hooks_obj
-        .get_mut(LEGACY_SESSION_START_EVENT)
-        .and_then(|v| v.as_array_mut())
-    else {
-        return false;
-    };
-
-    let before = arr.len();
-    arr.retain(|entry| {
-        let Some(hooks) = entry.get("hooks").and_then(|v| v.as_array()) else {
-            return true;
-        };
-        !hooks
-            .iter()
-            .any(|h| h.get("server").and_then(|v| v.as_str()) == Some(HOOK_SERVER))
-    });
-    let removed = arr.len() != before;
-
-    if arr.is_empty() {
-        hooks_obj.remove(LEGACY_SESSION_START_EVENT);
-    }
-
-    removed
-}
-
-pub fn run_setup(check_only: bool, uninstall: bool) -> Result<()> {
-    run_setup_with_opts(check_only, uninstall, false, false, false, false)
-}
-
-pub fn run_setup_with_opts(
-    check_only: bool,
-    uninstall: bool,
-    mcp_json: bool,
-    yes: bool,
-    global: bool,
-    force: bool,
-) -> Result<()> {
-    anyhow::ensure!(
-        !(check_only && uninstall),
-        "--check and --uninstall cannot be used together"
-    );
-
-    let path = settings_path()?;
-    let mut settings = read_settings(&path)?;
-
-    if check_only {
-        return run_check(&settings, &path, global);
-    }
-
-    if uninstall {
-        return run_uninstall(&mut settings, &path, global);
-    }
-
-    if mcp_json {
-        return run_mcp_json_only(global, &mut settings, &path);
-    }
-
-    run_install(&mut settings, &path, yes, global, force)
-}
-
-fn run_check(settings: &Value, path: &Path, global: bool) -> Result<()> {
-    println!("Settings file: {}", path.display());
-
-    let hooks_obj = settings.get("hooks");
-    let desired = build_hooks_config();
-    let mut all_ok = true;
-
-    for event in desired.keys() {
-        let installed = hooks_obj
-            .and_then(|h| h.get(*event))
-            .map(has_handoff_hook)
-            .unwrap_or(false);
-
-        if installed {
-            println!("  {event}: installed");
-        } else {
-            println!("  {event}: NOT installed");
-            all_ok = false;
-        }
-    }
-
-    if has_legacy_session_start_hook(settings) {
-        println!(
-            "  {LEGACY_SESSION_START_EVENT}: legacy handoff_memory_cleanup hook found (removed in this version)"
-        );
-        println!(
-            "\nWARNING: a synchronous SessionStart cleanup hook from an older install was \
-             found. This is the known trigger for VSCode hangs under many parallel \
-             sub-agents. Run `handoff-mcp setup` (without --check) to remove it."
-        );
-        all_ok = false;
-    }
-
-    if global {
-        if has_global_mcp_entry(settings) {
-            println!("  settings.json mcpServers: handoff server configured (global)");
-        } else {
-            println!("  settings.json mcpServers: handoff server NOT configured (global)");
-            all_ok = false;
-        }
-    } else {
-        let mcp_path = mcp_json_path();
-        if has_mcp_json_entry(&mcp_path) {
-            println!("  .mcp.json: handoff server configured");
-        } else if mcp_path.exists() {
-            println!("  .mcp.json: handoff server NOT configured");
-            all_ok = false;
-        } else {
-            println!("  .mcp.json: not found (hooks need it — run `handoff-mcp setup`)");
-            all_ok = false;
-        }
-    }
-
-    let claude_md = claude_md_path();
-    if has_claude_md_handoff_section(&claude_md) {
-        println!("  CLAUDE.md: handoff section present");
-    } else if claude_md.exists() {
-        println!("  CLAUDE.md: handoff section NOT present");
-        all_ok = false;
-    } else {
-        println!("  CLAUDE.md: not found");
-        all_ok = false;
-    }
-
-    if all_ok {
-        println!("\nAll hooks are configured. Memory auto-injection is active.");
-    } else {
-        println!("\nSome items need attention. Run `handoff-mcp setup` to install/migrate them.");
-    }
-
-    Ok(())
-}
-
-fn prompt_yn(question: &str) -> bool {
-    use std::io::{self, Write};
-    print!("{question} [Y/n] ");
-    io::stdout().flush().ok();
-    let mut input = String::new();
-    if io::stdin().read_line(&mut input).is_err() {
-        return true;
-    }
-    let trimmed = input.trim().to_lowercase();
-    trimmed.is_empty() || trimmed == "y" || trimmed == "yes"
-}
-
-fn run_mcp_json_only(global: bool, settings: &mut Value, settings_path: &Path) -> Result<()> {
-    if global {
-        if has_global_mcp_entry(settings) {
-            println!("  settings.json mcpServers: handoff server already configured (global). Nothing to do.");
-            return Ok(());
-        }
-        let added = ensure_global_mcp_entry(settings)?;
-        if added {
-            write_settings(settings_path, settings)?;
-            println!("  settings.json mcpServers: added handoff server entry (global)");
-            println!("\nRestart Claude Code for changes to take effect.");
-        }
-    } else {
-        let mcp_path = mcp_json_path();
-        if has_mcp_json_entry(&mcp_path) {
-            println!("  .mcp.json: handoff server already configured. Nothing to do.");
-            return Ok(());
-        }
-        let added = ensure_mcp_json_entry(&mcp_path)?;
-        if added {
-            println!("  .mcp.json: added handoff server entry");
-            println!("\nRestart Claude Code for changes to take effect.");
-        }
-    }
-    Ok(())
-}
-
-fn run_install(
-    settings: &mut Value,
-    path: &Path,
-    yes: bool,
-    global: bool,
-    force: bool,
-) -> Result<()> {
-    let obj = settings
-        .as_object_mut()
-        .context("settings.json root is not an object")?;
-
-    let hooks_val = obj
-        .entry("hooks")
-        .or_insert_with(|| Value::Object(serde_json::Map::new()));
-    let hooks_obj = hooks_val
-        .as_object_mut()
-        .context("settings.json 'hooks' is not an object")?;
-
-    let desired = build_hooks_config();
-    let mut installed = 0u32;
-    let mut skipped = 0u32;
-
-    for (event, config) in desired {
-        let existing = hooks_obj.get(event);
-        if existing.map(has_handoff_hook).unwrap_or(false) {
-            println!("  {event}: already installed, skipping");
-            skipped += 1;
-            continue;
-        }
-
-        match existing {
-            Some(Value::Array(arr)) => {
-                let mut merged = arr.clone();
-                if let Some(new_entries) = config.as_array() {
-                    merged.extend(new_entries.iter().cloned());
-                }
-                hooks_obj.insert(event.to_string(), Value::Array(merged));
-                println!("  {event}: merged with existing hooks");
-            }
-            _ => {
-                hooks_obj.insert(event.to_string(), config);
-                println!("  {event}: installed");
-            }
-        }
-        installed += 1;
-    }
-
-    let migrated = strip_legacy_session_start_hook(hooks_obj);
-    if migrated {
-        println!(
-            "  {LEGACY_SESSION_START_EVENT}: removed legacy handoff_memory_cleanup hook \
-             (known VSCode hang trigger)"
-        );
-    }
-
-    let mut settings_dirty = installed > 0 || migrated;
-
-    if global {
-        if has_global_mcp_entry(settings) {
-            println!("  settings.json mcpServers: handoff server already configured (global)");
-        } else {
-            let added = ensure_global_mcp_entry(settings)?;
-            if added {
-                println!("  settings.json mcpServers: added handoff server entry (global)");
-                settings_dirty = true;
-            }
-        }
-    }
-
-    if settings_dirty {
-        write_settings(path, settings)?;
-        println!("\nWrote {path}", path = path.display());
-        if installed > 0 {
-            println!("{installed} hook(s) installed, {skipped} already present.");
-        }
-        if migrated {
-            println!("Legacy SessionStart cleanup hook removed. See README for migration details.");
-        }
-    } else {
-        println!("\nAll hooks already installed.");
-    }
-
-    if !global {
-        let mcp_path = mcp_json_path();
-        let needs_mcp = !has_mcp_json_entry(&mcp_path);
-
-        if needs_mcp {
-            let should_write = if yes {
-                true
-            } else {
-                println!();
-                prompt_yn("Add handoff server to .mcp.json? (required for hooks)")
-            };
-
-            if should_write {
-                let added = ensure_mcp_json_entry(&mcp_path)?;
-                if added {
-                    println!("  .mcp.json: added handoff server entry");
-                }
-            } else {
-                println!(
-                    "  .mcp.json: skipped. Hooks will not work without a handoff server.\n  \
-                     Run `handoff-mcp setup --mcp-json` later, or add it manually."
-                );
-            }
-        } else {
-            println!("  .mcp.json: handoff server already configured");
-        }
-    }
-
-    // CLAUDE.md template
-    let claude_md = claude_md_path();
-    let has_section = has_claude_md_handoff_section(&claude_md);
-    if has_section && !force {
-        println!("  CLAUDE.md: handoff section already present");
-    } else {
-        let prompt_msg = if has_section {
-            "Replace existing session handoff section in CLAUDE.md?"
-        } else {
-            "Add session handoff section to CLAUDE.md?"
-        };
-        let should_write = if yes || force {
-            true
-        } else {
-            println!();
-            prompt_yn(prompt_msg)
-        };
-
-        if should_write {
-            let existed = claude_md.exists();
-            let added = ensure_claude_md_section(&claude_md, force)?;
-            if added {
-                let verb = if has_section {
-                    "replaced"
-                } else if existed {
-                    "appended to"
-                } else {
-                    "created"
-                };
-                println!("  CLAUDE.md: session handoff section {verb}");
-            }
-        } else {
-            println!("  CLAUDE.md: skipped");
-        }
-    }
-
-    println!("\nRestart Claude Code for changes to take effect.");
-    Ok(())
-}
-
-fn run_uninstall(settings: &mut Value, path: &Path, global: bool) -> Result<()> {
-    let mut anything_removed = false;
-
-    if let Some(hooks_obj) = settings.get_mut("hooks").and_then(|v| v.as_object_mut()) {
-        let events: Vec<String> = hooks_obj.keys().cloned().collect();
-        let mut removed = 0u32;
-
-        for event in &events {
-            let Some(arr) = hooks_obj.get_mut(event).and_then(|v| v.as_array_mut()) else {
-                continue;
-            };
-
-            let before = arr.len();
-            arr.retain(|entry| {
-                let Some(hooks) = entry.get("hooks").and_then(|v| v.as_array()) else {
-                    return true;
-                };
-                !hooks
-                    .iter()
-                    .any(|h| h.get("server").and_then(|v| v.as_str()) == Some(HOOK_SERVER))
-            });
-
-            let after = arr.len();
-            if before != after {
-                println!("  {event}: removed handoff hook(s)");
-                removed += 1;
-            }
-
-            if arr.is_empty() {
-                hooks_obj.remove(event);
-            }
-        }
-
-        if hooks_obj.is_empty() {
-            if let Some(obj) = settings.as_object_mut() {
-                obj.remove("hooks");
-            }
-        }
-
-        if removed > 0 {
-            anything_removed = true;
-            println!("{removed} hook event(s) cleaned up.");
-        }
-    }
-
-    if global && remove_global_mcp_entry(settings) {
-        println!("  settings.json mcpServers: removed handoff server entry (global)");
-        anything_removed = true;
-    }
-
-    if anything_removed {
-        write_settings(path, settings)?;
-        println!("\nWrote {path}", path = path.display());
-        println!("\nRestart Claude Code for changes to take effect.");
-    } else {
-        println!("No handoff hooks found. Nothing to remove.");
-    }
-
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn build_hooks_has_two_events() {
-        let hooks = build_hooks_config();
-        assert_eq!(hooks.len(), 2);
-        assert!(hooks.contains_key("UserPromptSubmit"));
-        assert!(hooks.contains_key("PreToolUse"));
-        assert!(!hooks.contains_key("SessionStart"));
-    }
-
-    #[test]
-    fn has_handoff_hook_detects_presence() {
-        let arr = serde_json::json!([{
-            "hooks": [{"type": "mcp_tool", "server": "handoff", "tool": "handoff_memory_query"}]
-        }]);
-        assert!(has_handoff_hook(&arr));
-    }
-
-    #[test]
-    fn has_handoff_hook_returns_false_for_other_server() {
-        let arr = serde_json::json!([{
-            "hooks": [{"type": "mcp_tool", "server": "other", "tool": "other_tool"}]
-        }]);
-        assert!(!has_handoff_hook(&arr));
-    }
-
-    #[test]
-    fn has_handoff_hook_returns_false_for_empty() {
-        assert!(!has_handoff_hook(&serde_json::json!([])));
-    }
-
-    #[test]
-    fn install_into_empty_settings() {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join("settings.json");
-
-        let mut settings = Value::Object(serde_json::Map::new());
-        run_install(&mut settings, &path, false, false, false).unwrap();
-
-        let written: Value =
-            serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
-        let hooks = written.get("hooks").unwrap().as_object().unwrap();
-        assert!(hooks.contains_key("UserPromptSubmit"));
-        assert!(hooks.contains_key("PreToolUse"));
-        assert!(!hooks.contains_key("SessionStart"));
-    }
-
-    #[test]
-    fn install_merges_with_existing_hooks() {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join("settings.json");
-
-        let mut settings = serde_json::json!({
-            "hooks": {
-                "UserPromptSubmit": [{
-                    "hooks": [{"type": "command", "command": "my-other-hook"}]
-                }]
-            }
-        });
-
-        run_install(&mut settings, &path, false, false, false).unwrap();
-
-        let written: Value =
-            serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
-        let user_prompt = written["hooks"]["UserPromptSubmit"].as_array().unwrap();
-        assert_eq!(user_prompt.len(), 2);
-        assert!(has_handoff_hook(&written["hooks"]["UserPromptSubmit"]));
-    }
-
-    #[test]
-    fn install_skips_if_already_present() {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join("settings.json");
-
-        let mut settings = Value::Object(serde_json::Map::new());
-        run_install(&mut settings, &path, false, false, false).unwrap();
-
-        let mut settings2 = serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
-        run_install(&mut settings2, &path, false, false, false).unwrap();
-
-        let written: Value =
-            serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
-        let user_prompt = written["hooks"]["UserPromptSubmit"].as_array().unwrap();
-        assert_eq!(user_prompt.len(), 1);
-        assert!(!written["hooks"]
-            .as_object()
-            .unwrap()
-            .contains_key("SessionStart"));
-    }
-
-    #[test]
-    fn uninstall_removes_handoff_hooks() {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join("settings.json");
-
-        let mut settings = Value::Object(serde_json::Map::new());
-        run_install(&mut settings, &path, false, false, false).unwrap();
-
-        let mut settings2: Value =
-            serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
-        run_uninstall(&mut settings2, &path, false).unwrap();
-
-        let written: Value =
-            serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
-        assert!(written.get("hooks").is_none());
-    }
-
-    #[test]
-    fn check_and_uninstall_conflict_is_rejected() {
-        assert!(run_setup(true, true).is_err());
-    }
-
-    #[test]
-    fn install_preserves_key_order() {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join("settings.json");
-
-        let original = r#"{
-  "env": {"A": "1", "B": "2"},
-  "model": "opus",
-  "permissions": {"defaultMode": "auto"}
-}
-"#;
-        std::fs::write(&path, original).unwrap();
-
-        let mut settings: Value = serde_json::from_str(original).unwrap();
-        run_install(&mut settings, &path, false, false, false).unwrap();
-
-        let written = std::fs::read_to_string(&path).unwrap();
-        let env_pos = written.find("\"env\"").unwrap();
-        let hooks_pos = written.find("\"hooks\"").unwrap();
-        let model_pos = written.find("\"model\"").unwrap();
-        assert!(env_pos < model_pos, "env should come before model");
-        assert!(
-            hooks_pos > env_pos,
-            "hooks should be appended after existing keys"
-        );
-    }
-
-    #[test]
-    fn install_removes_legacy_session_start_cleanup_hook() {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join("settings.json");
-
-        // Simulate a settings.json written by a pre-fix version of
-        // `handoff-mcp setup`, which still installed a SessionStart
-        // cleanup hook (the very hang trigger this task removes).
-        let mut settings = serde_json::json!({
-            "hooks": {
-                "SessionStart": [{
-                    "hooks": [{
-                        "type": "mcp_tool",
-                        "server": "handoff",
-                        "tool": "handoff_memory_cleanup",
-                        "input": {"project_dir": "${CLAUDE_PROJECT_DIR}"}
-                    }]
-                }],
-                "UserPromptSubmit": [{
-                    "hooks": [{"type": "mcp_tool", "server": "handoff", "tool": "handoff_memory_query"}]
-                }],
-                "PreToolUse": [{
-                    "matcher": "Edit|Write|MultiEdit",
-                    "hooks": [{"type": "mcp_tool", "server": "handoff", "tool": "handoff_memory_query"}]
-                }]
-            }
-        });
-
-        run_install(&mut settings, &path, false, false, false).unwrap();
-
-        let written: Value =
-            serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
-        let hooks = written.get("hooks").unwrap().as_object().unwrap();
-        assert!(
-            !hooks.contains_key("SessionStart"),
-            "legacy SessionStart cleanup hook must be removed by re-running setup"
-        );
-        assert!(hooks.contains_key("UserPromptSubmit"));
-        assert!(hooks.contains_key("PreToolUse"));
-    }
-
-    #[test]
-    fn install_preserves_non_handoff_session_start_hooks() {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join("settings.json");
-
-        let mut settings = serde_json::json!({
-            "hooks": {
-                "SessionStart": [
-                    {"hooks": [{"type": "command", "command": "my-other-hook"}]},
-                    {"hooks": [{"type": "mcp_tool", "server": "handoff", "tool": "handoff_memory_cleanup"}]}
-                ]
-            }
-        });
-
-        run_install(&mut settings, &path, false, false, false).unwrap();
-
-        let written: Value =
-            serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
-        let session_start = written["hooks"]["SessionStart"].as_array().unwrap();
-        assert_eq!(session_start.len(), 1);
-        assert!(!has_handoff_hook(&written["hooks"]["SessionStart"]));
-    }
-
-    #[test]
-    fn check_flags_legacy_session_start_cleanup_hook() {
-        let settings = serde_json::json!({
-            "hooks": {
-                "SessionStart": [{
-                    "hooks": [{"type": "mcp_tool", "server": "handoff", "tool": "handoff_memory_cleanup"}]
-                }]
-            }
-        });
-
-        assert!(has_legacy_session_start_hook(&settings));
-    }
-
-    #[test]
-    fn check_does_not_flag_when_no_legacy_hook_present() {
-        let settings = serde_json::json!({
-            "hooks": {
-                "UserPromptSubmit": [{
-                    "hooks": [{"type": "mcp_tool", "server": "handoff", "tool": "handoff_memory_query"}]
-                }]
-            }
-        });
-
-        assert!(!has_legacy_session_start_hook(&settings));
-    }
-
-    #[test]
-    fn uninstall_preserves_other_hooks() {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join("settings.json");
-
-        let mut settings = serde_json::json!({
-            "hooks": {
-                "UserPromptSubmit": [
-                    {"hooks": [{"type": "command", "command": "my-hook"}]},
-                    {"hooks": [{"type": "mcp_tool", "server": "handoff", "tool": "handoff_memory_query"}]}
-                ]
-            }
-        });
-        run_uninstall(&mut settings, &path, false).unwrap();
-
-        let written: Value =
-            serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
-        let user_prompt = written["hooks"]["UserPromptSubmit"].as_array().unwrap();
-        assert_eq!(user_prompt.len(), 1);
-        assert!(!has_handoff_hook(&written["hooks"]["UserPromptSubmit"]));
-    }
-
-    #[test]
-    fn ensure_mcp_json_creates_file_when_absent() {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join(".mcp.json");
-        assert!(!path.exists());
-
-        let added = ensure_mcp_json_entry(&path).unwrap();
-        assert!(added);
-        assert!(path.exists());
-
-        let root: Value = serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
-        assert!(root["mcpServers"]["handoff"]["command"]
-            .as_str()
-            .unwrap()
-            .contains("handoff-mcp"));
-    }
-
-    #[test]
-    fn ensure_mcp_json_adds_to_existing_file() {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join(".mcp.json");
-        std::fs::write(
-            &path,
-            r#"{"mcpServers":{"context7":{"type":"stdio","command":"npx"}}}"#,
-        )
-        .unwrap();
-
-        let added = ensure_mcp_json_entry(&path).unwrap();
-        assert!(added);
-
-        let root: Value = serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
-        assert!(root["mcpServers"].get("context7").is_some());
-        assert!(root["mcpServers"].get("handoff").is_some());
-    }
-
-    #[test]
-    fn ensure_mcp_json_skips_when_already_present() {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join(".mcp.json");
-        std::fs::write(
-            &path,
-            r#"{"mcpServers":{"handoff":{"type":"stdio","command":"handoff-mcp"}}}"#,
-        )
-        .unwrap();
-
-        let added = ensure_mcp_json_entry(&path).unwrap();
-        assert!(!added);
-    }
-
-    #[test]
-    fn has_mcp_json_entry_checks_correctly() {
-        let dir = tempfile::tempdir().unwrap();
-
-        let absent = dir.path().join("absent.json");
-        assert!(!has_mcp_json_entry(&absent));
-
-        let present = dir.path().join("present.json");
-        std::fs::write(&present, r#"{"mcpServers":{"handoff":{"type":"stdio"}}}"#).unwrap();
-        assert!(has_mcp_json_entry(&present));
-
-        let no_handoff = dir.path().join("other.json");
-        std::fs::write(
-            &no_handoff,
-            r#"{"mcpServers":{"context7":{"type":"stdio"}}}"#,
-        )
-        .unwrap();
-        assert!(!has_mcp_json_entry(&no_handoff));
-    }
-
-    // --- Global MCP entry tests ---
-
-    #[test]
-    fn ensure_global_mcp_adds_to_empty_settings() {
-        let mut settings = Value::Object(serde_json::Map::new());
-        let added = ensure_global_mcp_entry(&mut settings).unwrap();
-        assert!(added);
-        assert!(has_global_mcp_entry(&settings));
-        assert!(settings["mcpServers"]["handoff"]["command"]
-            .as_str()
-            .unwrap()
-            .contains("handoff-mcp"));
-    }
-
-    #[test]
-    fn ensure_global_mcp_preserves_existing_servers() {
-        let mut settings = serde_json::json!({
-            "mcpServers": {
-                "context7": {"type": "stdio", "command": "npx"}
-            }
-        });
-        let added = ensure_global_mcp_entry(&mut settings).unwrap();
-        assert!(added);
-        assert!(settings["mcpServers"].get("context7").is_some());
-        assert!(settings["mcpServers"].get("handoff").is_some());
-    }
-
-    #[test]
-    fn ensure_global_mcp_skips_when_present() {
-        let mut settings = serde_json::json!({
-            "mcpServers": {
-                "handoff": {"type": "stdio", "command": "handoff-mcp"}
-            }
-        });
-        let added = ensure_global_mcp_entry(&mut settings).unwrap();
-        assert!(!added);
-    }
-
-    #[test]
-    fn remove_global_mcp_entry_removes_handoff() {
-        let mut settings = serde_json::json!({
-            "mcpServers": {
-                "handoff": {"type": "stdio"},
-                "context7": {"type": "stdio"}
-            }
-        });
-        assert!(remove_global_mcp_entry(&mut settings));
-        assert!(settings["mcpServers"].get("context7").is_some());
-        assert!(settings["mcpServers"].get("handoff").is_none());
-    }
-
-    #[test]
-    fn remove_global_mcp_entry_cleans_empty_section() {
-        let mut settings = serde_json::json!({
-            "mcpServers": {
-                "handoff": {"type": "stdio"}
-            }
-        });
-        assert!(remove_global_mcp_entry(&mut settings));
-        assert!(settings.get("mcpServers").is_none());
-    }
-
-    #[test]
-    fn remove_global_mcp_entry_returns_false_when_absent() {
-        let mut settings = Value::Object(serde_json::Map::new());
-        assert!(!remove_global_mcp_entry(&mut settings));
-    }
-
-    #[test]
-    fn uninstall_with_global_removes_mcp_entry() {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join("settings.json");
-
-        let mut settings = serde_json::json!({
-            "hooks": {
-                "UserPromptSubmit": [{
-                    "hooks": [{"type": "mcp_tool", "server": "handoff", "tool": "handoff_memory_query"}]
-                }]
-            },
-            "mcpServers": {
-                "handoff": {"type": "stdio", "command": "handoff-mcp"}
-            }
-        });
-
-        run_uninstall(&mut settings, &path, true).unwrap();
-
-        let written: Value =
-            serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
-        assert!(written.get("hooks").is_none());
-        assert!(written.get("mcpServers").is_none());
-    }
-
-    // --- CLAUDE.md tests ---
-
-    #[test]
-    fn ensure_claude_md_creates_new_file() {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join("CLAUDE.md");
-        assert!(!path.exists());
-
-        let added = ensure_claude_md_section(&path, false).unwrap();
-        assert!(added);
-
-        let content = std::fs::read_to_string(&path).unwrap();
-        assert!(content.contains(CLAUDE_MD_MARKER));
-        assert!(content.contains("handoff_load_context"));
-    }
-
-    #[test]
-    fn ensure_claude_md_appends_to_existing() {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join("CLAUDE.md");
-        std::fs::write(&path, "# My Project\n\nSome existing content.\n").unwrap();
-
-        let added = ensure_claude_md_section(&path, false).unwrap();
-        assert!(added);
-
-        let content = std::fs::read_to_string(&path).unwrap();
-        assert!(content.starts_with("# My Project"));
-        assert!(content.contains("Some existing content."));
-        assert!(content.contains(CLAUDE_MD_MARKER));
-    }
-
-    #[test]
-    fn ensure_claude_md_skips_when_marker_present() {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join("CLAUDE.md");
-        std::fs::write(
-            &path,
-            "# Project\n\n## Session Handoff\n\nCustom handoff instructions.\n",
-        )
-        .unwrap();
-
-        let added = ensure_claude_md_section(&path, false).unwrap();
-        assert!(!added);
-
-        let content = std::fs::read_to_string(&path).unwrap();
-        assert!(content.contains("Custom handoff instructions."));
-        assert!(!content.contains("handoff_load_context"));
-    }
-
-    #[test]
-    fn has_claude_md_handoff_section_detects_correctly() {
-        let dir = tempfile::tempdir().unwrap();
-
-        let absent = dir.path().join("absent.md");
-        assert!(!has_claude_md_handoff_section(&absent));
-
-        let present = dir.path().join("present.md");
-        std::fs::write(&present, "# X\n\n## Session Handoff\n\nfoo\n").unwrap();
-        assert!(has_claude_md_handoff_section(&present));
-
-        let without = dir.path().join("without.md");
-        std::fs::write(&without, "# X\n\nSome content\n").unwrap();
-        assert!(!has_claude_md_handoff_section(&without));
-    }
-
-    // --- Force replace tests ---
-
-    #[test]
-    fn ensure_claude_md_force_replaces_existing_section() {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join("CLAUDE.md");
-        std::fs::write(
-            &path,
-            "# Project\n\n## Session Handoff\n\nOld stale content here.\n",
-        )
-        .unwrap();
-
-        let added = ensure_claude_md_section(&path, false).unwrap();
-        assert!(!added, "should skip without force");
-
-        let added = ensure_claude_md_section(&path, true).unwrap();
-        assert!(added, "should replace with force");
-
-        let content = std::fs::read_to_string(&path).unwrap();
-        assert!(!content.contains("Old stale content"));
-        assert!(content.contains("handoff_load_context"));
-        assert!(content.starts_with("# Project"));
-    }
-
-    #[test]
-    fn force_replace_preserves_sections_after() {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join("CLAUDE.md");
-        std::fs::write(
-            &path,
-            "# Project\n\n## Session Handoff\n\nOld content.\n\n## Other Section\n\nKeep this.\n",
-        )
-        .unwrap();
-
-        let added = ensure_claude_md_section(&path, true).unwrap();
-        assert!(added);
-
-        let content = std::fs::read_to_string(&path).unwrap();
-        assert!(content.contains("## Other Section"));
-        assert!(content.contains("Keep this."));
-        assert!(content.contains("handoff_load_context"));
-        assert!(!content.contains("Old content."));
-    }
-
-    #[test]
-    fn replace_claude_md_section_strips_only_handoff() {
-        let text = "# Top\n\n## Session Handoff\n\nOld stuff.\n\n## Build\n\ncargo test\n";
-        let result = replace_claude_md_section(text);
-        assert!(!result.contains("Old stuff."));
-        assert!(!result.contains("Session Handoff"));
-        assert!(result.contains("# Top"));
-        assert!(result.contains("## Build"));
-        assert!(result.contains("cargo test"));
-    }
-
-    #[test]
-    fn replace_claude_md_section_handles_eof() {
-        let text = "# Top\n\n## Session Handoff\n\nOnly section.\n";
-        let result = replace_claude_md_section(text);
-        assert!(!result.contains("Only section."));
-        assert!(result.contains("# Top"));
-    }
-}