handoff-mcp-server 0.7.2 → 0.8.0

package/Cargo.lock

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

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "handoff-mcp"
-version = "0.7.2"
+version = "0.8.0"
 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.2",
+  "version": "0.8.0",
   "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/check_criterion.rs

@@ -28,8 +28,11 @@ pub fn handle(arguments: &Value) -> Result<String> {
         .and_then(|v| v.as_bool())
         .ok_or_else(|| anyhow::anyhow!("'checked' parameter is required (boolean)"))?;
 
-    let task_dir = find_task_dir_by_id(&tasks_dir, task_id)?
-        .ok_or_else(|| anyhow::anyhow!("Task not found: {task_id}"))?;
+    let task_dir = find_task_dir_by_id(&tasks_dir, task_id)?.ok_or_else(|| {
+        anyhow::anyhow!(
+            "Task not found: {task_id}. Use handoff_list_tasks to see available task IDs."
+        )
+    })?;
 
     let (mut data, status) = read_task(&task_dir)?
         .ok_or_else(|| anyhow::anyhow!("Task file not found in {}", task_dir.display()))?;

package/src/mcp/handlers/get_task.rs

@@ -16,8 +16,11 @@ pub fn handle(arguments: &Value) -> Result<String> {
         .and_then(|v| v.as_str())
         .ok_or_else(|| anyhow::anyhow!("'task_id' parameter is required"))?;
 
-    let task_dir = find_task_dir_by_id(&tasks_dir, task_id)?
-        .ok_or_else(|| anyhow::anyhow!("Task not found: {task_id}"))?;
+    let task_dir = find_task_dir_by_id(&tasks_dir, task_id)?.ok_or_else(|| {
+        anyhow::anyhow!(
+            "Task not found: {task_id}. Use handoff_list_tasks to see available task IDs."
+        )
+    })?;
 
     let (data, status) = read_task(&task_dir)?
         .ok_or_else(|| anyhow::anyhow!("Task file not found in {}", task_dir.display()))?;

package/src/mcp/handlers/import_context.rs

@@ -7,8 +7,7 @@ use crate::storage::config::read_config;
 use crate::storage::ensure_handoff_exists;
 use crate::storage::git::capture_git_state;
 use crate::storage::sessions::{
-    close_active_sessions, close_open_sessions, enforce_history_limit, write_open_session,
-    SessionData,
+    close_active_sessions, enforce_history_limit, write_open_session, SessionData,
 };
 use crate::storage::tasks::*;
 
@@ -60,7 +59,6 @@ pub fn handle(arguments: &Value) -> Result<String> {
             })?;
 
         close_active_sessions(&sessions_dir)?;
-        let closed = close_open_sessions(&sessions_dir)?;
         let git_state = capture_git_state(&project_dir)?;
         let now = Utc::now().to_rfc3339();
 
@@ -117,12 +115,10 @@ pub fn handle(arguments: &Value) -> Result<String> {
         };
         enforce_history_limit(&sessions_dir, history_limit)?;
 
-        let _ = closed;
         session_saved = true;
     } else if let Some(raw_notes) = arguments.get("raw_notes").and_then(|v| v.as_str()) {
         if !raw_notes.is_empty() {
             close_active_sessions(&sessions_dir)?;
-            let closed = close_open_sessions(&sessions_dir)?;
             let git_state = capture_git_state(&project_dir)?;
             let now = Utc::now().to_rfc3339();
 
@@ -162,7 +158,6 @@ pub fn handle(arguments: &Value) -> Result<String> {
             };
             enforce_history_limit(&sessions_dir, history_limit)?;
 
-            let _ = closed;
             session_saved = true;
         }
     }

package/src/mcp/handlers/save_context.rs

@@ -9,9 +9,9 @@ use crate::storage::config::read_config;
 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, read_active_sessions,
-    write_open_session, SessionData,
+    close_active_sessions, close_session_by_id, enforce_history_limit, generate_session_id,
+    pause_active_sessions, pause_session_by_id, read_active_sessions, write_session_with_status,
+    SessionData,
 };
 
 pub fn handle(arguments: &Value) -> Result<String> {
@@ -32,6 +32,17 @@ pub fn handle(arguments: &Value) -> Result<String> {
         .get("pause_active")
         .and_then(|v| v.as_bool())
         .unwrap_or(false);
+    let session_status = arguments
+        .get("session_status")
+        .and_then(|v| v.as_str())
+        .unwrap_or("open");
+
+    if session_status != "open" && session_status != "active" {
+        anyhow::bail!(
+            "Invalid session_status '{}': must be 'open' or 'active'",
+            session_status
+        );
+    }
 
     let mut total_paused = 0usize;
     if let Some(id) = pause_id {
@@ -50,8 +61,7 @@ pub fn handle(arguments: &Value) -> Result<String> {
             0
         }
     } else if pause_id.is_some() || pause_all {
-        let closed_open = close_open_sessions(&sessions_dir)?;
-        closed_open.len()
+        0
     } else {
         let active = read_active_sessions(&sessions_dir)?;
         if active.len() > 1 {
@@ -64,8 +74,7 @@ pub fn handle(arguments: &Value) -> Result<String> {
             );
         }
         let closed_active = close_active_sessions(&sessions_dir)?;
-        let closed_open = close_open_sessions(&sessions_dir)?;
-        closed_active.len() + closed_open.len()
+        closed_active.len()
     };
 
     let git_state = capture_git_state(&project_dir)?;
@@ -89,7 +98,7 @@ pub fn handle(arguments: &Value) -> Result<String> {
         environment: arguments.get("environment").cloned(),
     };
 
-    let path = write_open_session(&sessions_dir, &data)?;
+    let path = write_session_with_status(&sessions_dir, &data, session_status)?;
 
     let history_limit = if config_path.exists() {
         read_config(&config_path)

package/src/mcp/handlers/update_task.rs

@@ -23,7 +23,11 @@ pub fn handle(arguments: &Value) -> Result<String> {
         if let Some(new_parent_id) = move_to {
             return handle_move(&tasks_dir, existing_id, new_parent_id);
         }
-        return handle_update(&tasks_dir, existing_id, task_val);
+        let task_exists = find_task_dir_by_id(&tasks_dir, existing_id)?.is_some();
+        if task_exists {
+            return handle_update(&tasks_dir, existing_id, task_val);
+        }
+        return handle_upsert_create(&tasks_dir, existing_id, task_val, arguments);
     }
 
     let title = task_val
@@ -106,6 +110,84 @@ fn handle_create(
     Ok(format!("Created task {new_id}: {title} [{status}]"))
 }
 
+fn handle_upsert_create(
+    tasks_dir: &std::path::Path,
+    task_id: &str,
+    task_val: &Value,
+    arguments: &Value,
+) -> Result<String> {
+    let title = task_val
+        .get("title")
+        .and_then(|v| v.as_str())
+        .ok_or_else(|| {
+            anyhow::anyhow!(
+                "Task '{task_id}' does not exist and cannot be created without a title. \
+                 Provide 'title' to create a new task with this ID, or use handoff_list_tasks to find existing task IDs."
+            )
+        })?;
+
+    let parent_id = arguments.get("parent_id").and_then(|v| v.as_str());
+
+    let parent_dir = match parent_id {
+        Some(pid) => find_task_dir_by_id(tasks_dir, pid)?.ok_or_else(|| {
+            anyhow::anyhow!(
+                "Parent task not found: {pid}. Use handoff_list_tasks to see available task IDs."
+            )
+        })?,
+        None => tasks_dir.to_path_buf(),
+    };
+
+    let slug = title_to_slug(title);
+    let dir_name = format!("{task_id}-{slug}");
+    let task_dir = parent_dir.join(&dir_name);
+    std::fs::create_dir_all(&task_dir)
+        .with_context(|| format!("Failed to create task dir: {}", task_dir.display()))?;
+
+    let now = Utc::now().to_rfc3339();
+    let status = task_val
+        .get("status")
+        .and_then(|v| v.as_str())
+        .unwrap_or("todo");
+
+    if !is_valid_status(status) {
+        anyhow::bail!("Invalid status: {status}");
+    }
+
+    let priority = task_val.get("priority").and_then(|v| v.as_str());
+    validate_priority(priority)?;
+
+    let dependencies = extract_string_array(task_val, "dependencies");
+    if !dependencies.is_empty() {
+        validate_dependencies(tasks_dir, task_id, &dependencies)?;
+    }
+
+    let data = TaskData {
+        id: task_id.to_string(),
+        title: title.to_string(),
+        notes: task_val
+            .get("notes")
+            .and_then(|v| v.as_str())
+            .map(String::from),
+        priority: priority.map(String::from),
+        created_at: Some(now.clone()),
+        updated_at: Some(now),
+        completed_at: None,
+        labels: extract_string_array(task_val, "labels"),
+        links: extract_string_array(task_val, "links"),
+        done_criteria: extract_done_criteria(task_val),
+        schedule: extract_schedule(task_val),
+        dependencies,
+        order: task_val
+            .get("order")
+            .and_then(|v| v.as_u64())
+            .map(|v| v as u32),
+    };
+
+    write_task(&task_dir, status, &data)?;
+
+    Ok(format!("Created task {task_id}: {title} [{status}]"))
+}
+
 fn handle_update(tasks_dir: &std::path::Path, task_id: &str, task_val: &Value) -> Result<String> {
     let task_dir = find_task_dir_by_id(tasks_dir, task_id)?
         .ok_or_else(|| anyhow::anyhow!("Task not found: {task_id}"))?;
@@ -179,11 +261,17 @@ fn handle_update(tasks_dir: &std::path::Path, task_id: &str, task_val: &Value) -
 }
 
 fn handle_move(tasks_dir: &std::path::Path, task_id: &str, new_parent_id: &str) -> Result<String> {
-    let task_dir = find_task_dir_by_id(tasks_dir, task_id)?
-        .ok_or_else(|| anyhow::anyhow!("Task not found: {task_id}"))?;
+    let task_dir = find_task_dir_by_id(tasks_dir, task_id)?.ok_or_else(|| {
+        anyhow::anyhow!(
+            "Task not found: {task_id}. Use handoff_list_tasks to see available task IDs."
+        )
+    })?;
 
-    let new_parent_dir = find_task_dir_by_id(tasks_dir, new_parent_id)?
-        .ok_or_else(|| anyhow::anyhow!("New parent task not found: {new_parent_id}"))?;
+    let new_parent_dir = find_task_dir_by_id(tasks_dir, new_parent_id)?.ok_or_else(|| {
+        anyhow::anyhow!(
+            "New parent task not found: {new_parent_id}. Use handoff_list_tasks to see available task IDs."
+        )
+    })?;
 
     let dir_name = task_dir
         .file_name()

package/src/mcp/tools.rs

@@ -57,9 +57,15 @@ pub fn all_tool_definitions() -> Vec<ToolDefinition> {
                         "type": "string",
                         "description": "One-line summary of this session"
                     },
+                    "session_status": {
+                        "type": "string",
+                        "description": "Status of the new session: 'open' (default) = saved but not activated, allows multiple open sessions; 'active' = immediately active for this session.",
+                        "enum": ["open", "active"],
+                        "default": "open"
+                    },
                     "close_session_id": {
                         "type": "string",
-                        "description": "Session ID to close. If omitted (and no pause options set), all active and open sessions are closed."
+                        "description": "Session ID to close. If omitted (and no pause options set), active sessions are closed."
                     },
                     "pause_session_id": {
                         "type": "string",
@@ -238,7 +244,7 @@ pub fn all_tool_definitions() -> Vec<ToolDefinition> {
                     "task": {
                         "type": "object",
                         "properties": {
-                            "id": { "type": "string", "description": "Task ID. Omit for new task (auto-generated)." },
+                            "id": { "type": "string", "description": "Task ID. Omit for auto-generated ID. If provided and task exists, updates it. If provided and task does not exist, creates a new task with that ID (upsert)." },
                             "title": { "type": "string", "description": "Required for new tasks. Optional when updating (id present)." },
                             "status": {
                                 "type": "string",

package/src/storage/sessions.rs

@@ -321,8 +321,24 @@ pub fn enforce_history_limit(sessions_dir: &Path, limit: u32) -> Result<u32> {
     Ok(removed)
 }
 
-// Backward-compatible aliases for tests and migration
-#[doc(hidden)]
-pub fn write_active_session(sessions_dir: &Path, data: &SessionData) -> Result<PathBuf> {
-    write_open_session(sessions_dir, data)
+pub fn write_session_with_status(
+    sessions_dir: &Path,
+    data: &SessionData,
+    status: &str,
+) -> Result<PathBuf> {
+    let mut data = data.clone();
+    if data.id.is_none() {
+        data.id = Some(generate_session_id());
+    }
+
+    let ts_part = compact_timestamp(&data);
+    let base = generate_session_filename(&data.summary, &ts_part);
+    let filename = format!("{base}.{status}.json");
+    let path = sessions_dir.join(&filename);
+
+    let content = serde_json::to_string_pretty(&data).context("Failed to serialize session")?;
+    std::fs::write(&path, content)
+        .with_context(|| format!("Failed to write session: {}", path.display()))?;
+
+    Ok(path)
 }