handoff-mcp-server 0.4.0 → 0.6.1

package/tests/storage_sessions.rs

@@ -9,6 +9,7 @@ fn setup() -> TempDir {
 fn make_session(summary: &str, ended_at: &str) -> SessionData {
     SessionData {
         version: 2,
+        id: None,
         ended_at: Some(ended_at.to_string()),
         summary: summary.to_string(),
         branch: Some("main".to_string()),
@@ -25,17 +26,17 @@ fn make_session(summary: &str, ended_at: &str) -> SessionData {
 }
 
 #[test]
-fn write_active_session_creates_file() {
+fn write_open_session_creates_file() {
     let dir = setup();
     let sessions_dir = dir.path().join("sessions");
     fs::create_dir_all(&sessions_dir).unwrap();
 
     let data = make_session("test session", "2026-06-13T14:30:00Z");
-    let path = write_active_session(&sessions_dir, &data).unwrap();
+    let path = write_open_session(&sessions_dir, &data).unwrap();
 
     assert!(path.exists());
     assert!(
-        path.to_string_lossy().ends_with(".active.json"),
+        path.to_string_lossy().ends_with(".open.json"),
         "filename: {}",
         path.display()
     );
@@ -47,26 +48,26 @@ fn write_active_session_creates_file() {
 }
 
 #[test]
-fn read_active_sessions_empty() {
+fn read_open_sessions_empty() {
     let dir = setup();
     let sessions_dir = dir.path().join("sessions");
     fs::create_dir_all(&sessions_dir).unwrap();
 
-    let sessions = read_active_sessions(&sessions_dir).unwrap();
+    let sessions = read_open_sessions(&sessions_dir).unwrap();
     assert!(sessions.is_empty());
 }
 
 #[test]
-fn read_active_sessions_returns_active_only() {
+fn read_open_sessions_returns_open_only() {
     let dir = setup();
     let sessions_dir = dir.path().join("sessions");
     fs::create_dir_all(&sessions_dir).unwrap();
 
-    let s1 = make_session("active one", "2026-06-13T10:00:00Z");
-    write_active_session(&sessions_dir, &s1).unwrap();
+    let s1 = make_session("open one", "2026-06-13T10:00:00Z");
+    write_open_session(&sessions_dir, &s1).unwrap();
 
-    let s2 = make_session("active two", "2026-06-13T11:00:00Z");
-    write_active_session(&sessions_dir, &s2).unwrap();
+    let s2 = make_session("open two", "2026-06-13T11:00:00Z");
+    write_open_session(&sessions_dir, &s2).unwrap();
 
     fs::write(
         sessions_dir.join("20260612-090000-old.closed.json"),
@@ -74,10 +75,26 @@ fn read_active_sessions_returns_active_only() {
     )
     .unwrap();
 
-    let sessions = read_active_sessions(&sessions_dir).unwrap();
+    let sessions = read_open_sessions(&sessions_dir).unwrap();
     assert_eq!(sessions.len(), 2);
 }
 
+#[test]
+fn activate_open_sessions_renames_to_active() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let s1 = make_session("session one", "2026-06-13T10:00:00Z");
+    let open_path = write_open_session(&sessions_dir, &s1).unwrap();
+
+    let activated = activate_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(activated.len(), 1);
+    assert!(!open_path.exists());
+    assert!(activated[0].exists());
+    assert!(activated[0].to_string_lossy().contains(".active.json"));
+}
+
 #[test]
 fn close_active_sessions_renames_to_closed() {
     let dir = setup();
@@ -85,7 +102,9 @@ fn close_active_sessions_renames_to_closed() {
     fs::create_dir_all(&sessions_dir).unwrap();
 
     let s1 = make_session("session one", "2026-06-13T10:00:00Z");
-    let active_path = write_active_session(&sessions_dir, &s1).unwrap();
+    write_open_session(&sessions_dir, &s1).unwrap();
+    let activated = activate_open_sessions(&sessions_dir).unwrap();
+    let active_path = &activated[0];
 
     let closed = close_active_sessions(&sessions_dir).unwrap();
     assert_eq!(closed.len(), 1);
@@ -95,22 +114,51 @@ fn close_active_sessions_renames_to_closed() {
 }
 
 #[test]
-fn close_active_then_create_new() {
+fn close_open_sessions_renames_to_closed() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let s1 = make_session("session one", "2026-06-13T10:00:00Z");
+    let open_path = write_open_session(&sessions_dir, &s1).unwrap();
+
+    let closed = close_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(closed.len(), 1);
+    assert!(!open_path.exists());
+    assert!(closed[0].exists());
+    assert!(closed[0].to_string_lossy().contains(".closed.json"));
+}
+
+#[test]
+fn full_session_lifecycle_open_active_closed() {
     let dir = setup();
     let sessions_dir = dir.path().join("sessions");
     fs::create_dir_all(&sessions_dir).unwrap();
 
     let s1 = make_session("first session", "2026-06-13T10:00:00Z");
-    write_active_session(&sessions_dir, &s1).unwrap();
+    write_open_session(&sessions_dir, &s1).unwrap();
 
-    close_active_sessions(&sessions_dir).unwrap();
+    let open = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(open.len(), 1);
+    assert_eq!(open[0].summary, "first session");
 
-    let s2 = make_session("second session", "2026-06-13T14:00:00Z");
-    write_active_session(&sessions_dir, &s2).unwrap();
+    activate_open_sessions(&sessions_dir).unwrap();
 
+    assert!(read_open_sessions(&sessions_dir).unwrap().is_empty());
     let active = read_active_sessions(&sessions_dir).unwrap();
     assert_eq!(active.len(), 1);
-    assert_eq!(active[0].summary, "second session");
+    assert_eq!(active[0].summary, "first session");
+
+    close_active_sessions(&sessions_dir).unwrap();
+
+    assert!(read_active_sessions(&sessions_dir).unwrap().is_empty());
+
+    let s2 = make_session("second session", "2026-06-13T14:00:00Z");
+    write_open_session(&sessions_dir, &s2).unwrap();
+
+    let open2 = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(open2.len(), 1);
+    assert_eq!(open2[0].summary, "second session");
 }
 
 #[test]
@@ -140,7 +188,7 @@ fn enforce_history_limit_removes_oldest() {
 }
 
 #[test]
-fn enforce_history_limit_ignores_active() {
+fn enforce_history_limit_ignores_open_and_active() {
     let dir = setup();
     let sessions_dir = dir.path().join("sessions");
     fs::create_dir_all(&sessions_dir).unwrap();
@@ -154,13 +202,13 @@ fn enforce_history_limit_ignores_active() {
         .unwrap();
     }
 
-    let s = make_session("active", "2026-06-13T10:00:00Z");
-    write_active_session(&sessions_dir, &s).unwrap();
+    let s = make_session("open session", "2026-06-13T10:00:00Z");
+    write_open_session(&sessions_dir, &s).unwrap();
 
     enforce_history_limit(&sessions_dir, 2).unwrap();
 
-    let active = read_active_sessions(&sessions_dir).unwrap();
-    assert_eq!(active.len(), 1);
+    let open = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(open.len(), 1);
 }
 
 #[test]
@@ -187,9 +235,125 @@ fn generate_session_filename_format() {
 }
 
 #[test]
-fn read_active_sessions_nonexistent_dir() {
+fn read_open_sessions_nonexistent_dir() {
     let dir = setup();
     let sessions_dir = dir.path().join("nonexistent");
-    let sessions = read_active_sessions(&sessions_dir).unwrap();
+    let sessions = read_open_sessions(&sessions_dir).unwrap();
     assert!(sessions.is_empty());
 }
+
+#[test]
+fn generate_session_id_format() {
+    let id = generate_session_id();
+    assert!(id.starts_with("s-"), "should start with s-: {id}");
+    assert!(id.len() > 20, "should be long enough: {id}");
+    let parts: Vec<&str> = id.splitn(2, '-').collect();
+    assert_eq!(parts[0], "s");
+}
+
+#[test]
+fn write_open_session_assigns_id() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let s = make_session("test", "2026-06-15T10:00:00Z");
+    assert!(s.id.is_none());
+
+    write_open_session(&sessions_dir, &s).unwrap();
+
+    let sessions = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(sessions.len(), 1);
+    assert!(
+        sessions[0].id.is_some(),
+        "written session should have an id"
+    );
+    assert!(sessions[0].id.as_ref().unwrap().starts_with("s-"));
+}
+
+#[test]
+fn read_old_session_without_id_gets_synthesized_id() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    // Write a session file without id field (simulating pre-upgrade file)
+    fs::write(
+        sessions_dir.join("20260613-143000-old-session.open.json"),
+        r#"{"version":2,"summary":"old session"}"#,
+    )
+    .unwrap();
+
+    let sessions = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(sessions.len(), 1);
+    assert!(
+        sessions[0].id.is_some(),
+        "old session should get a synthesized id"
+    );
+    let id = sessions[0].id.as_ref().unwrap();
+    assert!(id.starts_with("s-"), "synthesized id format: {id}");
+    assert!(
+        id.contains("20260613-143000"),
+        "synthesized id should contain original timestamp: {id}"
+    );
+}
+
+#[test]
+fn close_session_by_id_closes_only_targeted() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let s1 = make_session("session one", "2026-06-15T10:00:00Z");
+    let s2 = make_session("session two", "2026-06-15T11:00:00Z");
+    write_open_session(&sessions_dir, &s1).unwrap();
+    write_open_session(&sessions_dir, &s2).unwrap();
+
+    let sessions = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(sessions.len(), 2);
+
+    let target_id = sessions[0].id.as_ref().unwrap().clone();
+    let other_id = sessions[1].id.as_ref().unwrap().clone();
+
+    let result = close_session_by_id(&sessions_dir, &target_id).unwrap();
+    assert!(result.is_some(), "should close the targeted session");
+
+    let remaining_open = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(remaining_open.len(), 1);
+    assert_eq!(remaining_open[0].id.as_deref().unwrap(), other_id);
+}
+
+#[test]
+fn activate_session_by_id_activates_only_targeted() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let s1 = make_session("session one", "2026-06-15T10:00:00Z");
+    let s2 = make_session("session two", "2026-06-15T11:00:00Z");
+    write_open_session(&sessions_dir, &s1).unwrap();
+    write_open_session(&sessions_dir, &s2).unwrap();
+
+    let sessions = read_open_sessions(&sessions_dir).unwrap();
+    let target_id = sessions[0].id.as_ref().unwrap().clone();
+
+    let result = activate_session_by_id(&sessions_dir, &target_id).unwrap();
+    assert!(result.is_some(), "should activate the targeted session");
+
+    let remaining_open = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(remaining_open.len(), 1, "one session should remain open");
+
+    let active = read_active_sessions(&sessions_dir).unwrap();
+    assert_eq!(active.len(), 1, "one session should be active");
+    assert_eq!(active[0].id.as_deref().unwrap(), target_id);
+}
+
+#[test]
+fn close_session_by_id_nonexistent_returns_none() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let result = close_session_by_id(&sessions_dir, "s-nonexistent").unwrap();
+    assert!(result.is_none());
+}

package/tests/tool_import_context.rs

@@ -360,7 +360,7 @@ fn import_source_recorded_in_environment() {
     let entries: Vec<_> = std::fs::read_dir(&sessions_dir)
         .unwrap()
         .filter_map(|e| e.ok())
-        .filter(|e| e.file_name().to_string_lossy().ends_with(".active.json"))
+        .filter(|e| e.file_name().to_string_lossy().ends_with(".open.json"))
         .collect();
     assert_eq!(entries.len(), 1);
 

package/tests/tool_referrals.rs

@@ -440,3 +440,165 @@ fn no_referrals_dir_is_graceful() {
     let parsed: Value = serde_json::from_str(&text).unwrap();
     assert_eq!(parsed["total"], 0);
 }
+
+#[test]
+fn refer_warns_on_missing_details() {
+    let (_base, proj_a, proj_b) = setup_two_projects();
+
+    let resp = call_tool(
+        "handoff_refer",
+        json!({
+            "project_dir": proj_a.to_string_lossy(),
+            "target_project_dir": proj_b.to_string_lossy(),
+            "summary": "Minimal referral"
+        }),
+    );
+
+    assert!(!is_error(&resp), "error: {}", get_text(&resp));
+    let text = get_text(&resp);
+    assert!(text.contains("Referral sent"));
+    let warning_count = text.matches("Warning").count();
+    assert!(
+        warning_count >= 3,
+        "should have at least 3 warnings (details, tasks, context), got {warning_count}: {text}"
+    );
+    assert!(
+        text.contains("details"),
+        "should warn about missing details: {text}"
+    );
+    assert!(
+        text.contains("tasks"),
+        "should warn about missing tasks: {text}"
+    );
+    assert!(
+        text.contains("context"),
+        "should warn about missing context: {text}"
+    );
+}
+
+#[test]
+fn refer_warns_on_tasks_without_done_criteria() {
+    let (_base, proj_a, proj_b) = setup_two_projects();
+
+    let resp = call_tool(
+        "handoff_refer",
+        json!({
+            "project_dir": proj_a.to_string_lossy(),
+            "target_project_dir": proj_b.to_string_lossy(),
+            "summary": "Referral with bare tasks",
+            "details": "Some details here",
+            "priority": "high",
+            "context": { "branch": "main" },
+            "tasks": [
+                { "title": "Task without criteria" },
+                { "title": "Task with criteria", "done_criteria": [{"item": "check", "checked": false}] }
+            ]
+        }),
+    );
+
+    assert!(!is_error(&resp), "error: {}", get_text(&resp));
+    let text = get_text(&resp);
+    assert!(
+        text.contains("Task #1 'Task without criteria' has no done_criteria"),
+        "should warn about task without criteria: {text}"
+    );
+    assert!(
+        !text.contains("Task #2"),
+        "should NOT warn about task with criteria: {text}"
+    );
+}
+
+#[test]
+fn refer_no_warnings_when_complete() {
+    let (_base, proj_a, proj_b) = setup_two_projects();
+
+    let resp = call_tool(
+        "handoff_refer",
+        json!({
+            "project_dir": proj_a.to_string_lossy(),
+            "target_project_dir": proj_b.to_string_lossy(),
+            "summary": "Complete referral",
+            "referral_type": "request",
+            "priority": "high",
+            "details": "Full description of what needs to happen",
+            "context": {
+                "branch": "feat/x",
+                "commit": "abc123",
+                "spec_docs": [
+                    format!("{}/.handoff/config.toml", proj_a.to_string_lossy()),
+                    "https://gitlab.example.com/project/-/merge_requests/1"
+                ]
+            },
+            "tasks": [
+                {
+                    "title": "Do the thing",
+                    "done_criteria": [{"item": "Thing is done", "checked": false}]
+                }
+            ]
+        }),
+    );
+
+    assert!(!is_error(&resp), "error: {}", get_text(&resp));
+    let text = get_text(&resp);
+    assert!(text.contains("Referral sent"));
+    assert!(
+        !text.contains("Warning"),
+        "should have no warnings when fully specified: {text}"
+    );
+}
+
+#[test]
+fn refer_warns_on_context_without_spec_docs() {
+    let (_base, proj_a, proj_b) = setup_two_projects();
+
+    let resp = call_tool(
+        "handoff_refer",
+        json!({
+            "project_dir": proj_a.to_string_lossy(),
+            "target_project_dir": proj_b.to_string_lossy(),
+            "summary": "Has context but no spec refs",
+            "details": "Description",
+            "priority": "medium",
+            "context": { "branch": "main", "commit": "abc123" },
+            "tasks": [
+                { "title": "Task", "done_criteria": [{"item": "check", "checked": false}] }
+            ]
+        }),
+    );
+
+    assert!(!is_error(&resp), "error: {}", get_text(&resp));
+    let text = get_text(&resp);
+    assert!(
+        text.contains("spec/doc references"),
+        "should warn about missing spec references in context: {text}"
+    );
+}
+
+#[test]
+fn refer_warns_on_nonexistent_spec_path() {
+    let (_base, proj_a, proj_b) = setup_two_projects();
+
+    let resp = call_tool(
+        "handoff_refer",
+        json!({
+            "project_dir": proj_a.to_string_lossy(),
+            "target_project_dir": proj_b.to_string_lossy(),
+            "summary": "Spec path does not exist",
+            "details": "Description",
+            "priority": "medium",
+            "context": {
+                "spec_docs": ["/nonexistent/path/to/spec.md"]
+            },
+            "tasks": [
+                { "title": "Task", "done_criteria": [{"item": "check", "checked": false}] }
+            ]
+        }),
+    );
+
+    assert!(!is_error(&resp), "error: {}", get_text(&resp));
+    let text = get_text(&resp);
+    assert!(
+        text.contains("does not exist"),
+        "should warn about nonexistent spec path: {text}"
+    );
+}