handoff-mcp-server 0.7.0 → 0.7.1

package/Cargo.lock

@@ -144,7 +144,7 @@ dependencies = [
 
 [[package]]
 name = "handoff-mcp"
-version = "0.7.0"
+version = "0.7.1"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "handoff-mcp"
-version = "0.7.0"
+version = "0.7.1"
 edition = "2021"
 description = "MCP server that gives AI coding agents persistent memory across sessions"
 license = "MIT"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "handoff-mcp-server",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "MCP server that gives AI coding agents persistent memory across sessions",
   "license": "MIT",
   "author": "AlphaElements <66808803+alphaelements@users.noreply.github.com>",

package/src/mcp/handlers/load_context.rs

@@ -5,8 +5,8 @@ use super::resolve_project_dir;
 use crate::storage::config::read_config;
 use crate::storage::referrals::read_referral_summaries;
 use crate::storage::sessions::{
-    activate_open_sessions, activate_session_by_id, read_open_sessions, read_paused_sessions,
-    resume_paused_session_by_id,
+    activate_open_sessions, activate_session_by_id, read_active_sessions, read_open_sessions,
+    read_paused_sessions, resume_paused_session_by_id,
 };
 use crate::storage::tasks::build_task_index;
 use crate::storage::{ensure_handoff_exists, handoff_dir};
@@ -39,11 +39,30 @@ pub fn handle(arguments: &Value) -> Result<String> {
 
     let target_session_id = arguments.get("session_id").and_then(|v| v.as_str());
 
+    let active_sessions = read_active_sessions(&sessions_dir)?;
     let sessions = read_open_sessions(&sessions_dir)?;
     let paused_sessions = read_paused_sessions(&sessions_dir)?;
 
     let selected_session = if let Some(sid) = target_session_id {
-        if activate_session_by_id(&sessions_dir, sid)?.is_some() {
+        let already_active = active_sessions
+            .iter()
+            .any(|s| s.id.as_deref().is_some_and(|id| id == sid));
+        if already_active {
+            active_sessions
+                .into_iter()
+                .find(|s| s.id.as_deref().is_some_and(|id| id == sid))
+        } else if !active_sessions.is_empty() {
+            let active_ids: Vec<String> = active_sessions
+                .iter()
+                .filter_map(|s| s.id.clone())
+                .collect();
+            anyhow::bail!(
+                "Cannot activate session '{sid}': another session is already active ({}).\n\
+                 Use save_context with close_session_id or pause_session_id to \
+                 close/pause the active session first.",
+                active_ids.join(", ")
+            );
+        } else if activate_session_by_id(&sessions_dir, sid)?.is_some() {
             sessions
                 .into_iter()
                 .find(|s| s.id.as_deref().is_some_and(|id| id == sid))
@@ -54,6 +73,16 @@ pub fn handle(arguments: &Value) -> Result<String> {
         } else {
             None
         }
+    } else if !active_sessions.is_empty() {
+        active_sessions.into_iter().last()
+    } else if sessions.len() > 1 {
+        let open_ids: Vec<String> = sessions.iter().filter_map(|s| s.id.clone()).collect();
+        anyhow::bail!(
+            "Multiple open sessions found ({}).\n\
+             Specify session_id to choose one, or use save_context to \
+             close/pause the others first.",
+            open_ids.join(", ")
+        );
     } else {
         activate_open_sessions(&sessions_dir)?;
         sessions.into_iter().last()

package/src/mcp/handlers/save_context.rs

@@ -10,8 +10,8 @@ use crate::storage::ensure_handoff_exists;
 use crate::storage::git::capture_git_state;
 use crate::storage::sessions::{
     close_active_sessions, close_open_sessions, close_session_by_id, enforce_history_limit,
-    generate_session_id, pause_active_sessions, pause_session_by_id, write_open_session,
-    SessionData,
+    generate_session_id, pause_active_sessions, pause_session_by_id, read_active_sessions,
+    write_open_session, SessionData,
 };
 
 pub fn handle(arguments: &Value) -> Result<String> {
@@ -53,6 +53,16 @@ pub fn handle(arguments: &Value) -> Result<String> {
         let closed_open = close_open_sessions(&sessions_dir)?;
         closed_open.len()
     } else {
+        let active = read_active_sessions(&sessions_dir)?;
+        if active.len() > 1 {
+            let active_ids: Vec<String> = active.iter().filter_map(|s| s.id.clone()).collect();
+            anyhow::bail!(
+                "Multiple active sessions found ({}).\n\
+                 Use close_session_id or pause_session_id to specify which to \
+                 close/pause before saving a new session.",
+                active_ids.join(", ")
+            );
+        }
         let closed_active = close_active_sessions(&sessions_dir)?;
         let closed_open = close_open_sessions(&sessions_dir)?;
         closed_active.len() + closed_open.len()

package/tests/tool_sessions.rs

@@ -1192,3 +1192,119 @@ fn full_pause_resume_lifecycle() {
         "no more paused sessions after resume"
     );
 }
+
+// --- active session uniqueness tests ---
+
+#[test]
+fn load_context_rejects_activate_when_another_session_active() {
+    let dir = setup_project();
+    let pd = dir.path().to_string_lossy().to_string();
+
+    // Create session A and activate it
+    call_tool(
+        "handoff_save_context",
+        json!({ "project_dir": &pd, "summary": "session A" }),
+    );
+    let resp = call_tool("handoff_load_context", json!({ "project_dir": &pd }));
+    let text = get_text(&resp);
+    let parsed: Value = serde_json::from_str(&text).unwrap();
+    let sid_a = parsed["session_id"].as_str().unwrap().to_string();
+
+    // Create session B (without closing A — use close_session_id to close only A's open)
+    // Actually: save_context default closes active + open, so A gets closed.
+    // We need to simulate the scenario: write a second open session manually
+    // while A is still active. We'll use pause to keep A alive.
+    call_tool(
+        "handoff_save_context",
+        json!({
+            "project_dir": &pd,
+            "summary": "session B",
+            "pause_session_id": &sid_a
+        }),
+    );
+
+    // Now: A is paused, B is open. Load B (activates it).
+    let resp = call_tool("handoff_load_context", json!({ "project_dir": &pd }));
+    assert!(!is_error(&resp));
+    let text = get_text(&resp);
+    let parsed: Value = serde_json::from_str(&text).unwrap();
+    let sid_b = parsed["session_id"].as_str().unwrap().to_string();
+
+    // Try to resume A while B is active — should fail
+    let resp = call_tool(
+        "handoff_load_context",
+        json!({ "project_dir": &pd, "session_id": &sid_a }),
+    );
+    assert!(
+        is_error(&resp),
+        "should reject activating A while B is active: {}",
+        get_text(&resp)
+    );
+    let text = get_text(&resp);
+    assert!(
+        text.contains("already active"),
+        "error should mention active session: {text}"
+    );
+    assert!(
+        text.contains(&sid_b),
+        "error should mention the blocking session ID: {text}"
+    );
+}
+
+#[test]
+fn load_context_allows_reloading_already_active_session() {
+    let dir = setup_project();
+    let pd = dir.path().to_string_lossy().to_string();
+
+    call_tool(
+        "handoff_save_context",
+        json!({ "project_dir": &pd, "summary": "session A" }),
+    );
+
+    let resp = call_tool("handoff_load_context", json!({ "project_dir": &pd }));
+    let text = get_text(&resp);
+    let parsed: Value = serde_json::from_str(&text).unwrap();
+    let sid = parsed["session_id"].as_str().unwrap().to_string();
+
+    // Loading the same session again should succeed (idempotent)
+    let resp2 = call_tool(
+        "handoff_load_context",
+        json!({ "project_dir": &pd, "session_id": &sid }),
+    );
+    assert!(
+        !is_error(&resp2),
+        "reloading the same active session should succeed: {}",
+        get_text(&resp2)
+    );
+    let text2 = get_text(&resp2);
+    let parsed2: Value = serde_json::from_str(&text2).unwrap();
+    assert_eq!(parsed2["session_id"].as_str().unwrap(), sid);
+}
+
+#[test]
+fn load_context_returns_active_session_without_open() {
+    let dir = setup_project();
+    let pd = dir.path().to_string_lossy().to_string();
+
+    call_tool(
+        "handoff_save_context",
+        json!({ "project_dir": &pd, "summary": "my session" }),
+    );
+
+    // First load activates the open session
+    let resp = call_tool("handoff_load_context", json!({ "project_dir": &pd }));
+    let text = get_text(&resp);
+    let parsed: Value = serde_json::from_str(&text).unwrap();
+    let sid = parsed["session_id"].as_str().unwrap().to_string();
+
+    // Second load (no session_id) should return the active session
+    let resp2 = call_tool("handoff_load_context", json!({ "project_dir": &pd }));
+    assert!(!is_error(&resp2), "error: {}", get_text(&resp2));
+    let text2 = get_text(&resp2);
+    let parsed2: Value = serde_json::from_str(&text2).unwrap();
+    assert_eq!(
+        parsed2["session_id"].as_str().unwrap(),
+        sid,
+        "should return the same active session"
+    );
+}