handoff-mcp-server 0.10.0 → 0.11.0

package/src/storage/mod.rs

@@ -8,6 +8,48 @@ use std::path::{Path, PathBuf};
 
 use anyhow::{Context, Result};
 
+/// Write `content` to `path` atomically: write to a sibling temp file, fsync,
+/// then rename over the target. A rename within the same directory is atomic on
+/// POSIX, so a concurrent reader never observes a partially-written file.
+///
+/// Used by every handoff write path (tasks, config, sessions, referrals) so that
+/// the VSCode extension — which writes the same files — never reads torn data.
+pub fn atomic_write(path: impl AsRef<Path>, content: &[u8]) -> Result<()> {
+    use std::io::Write;
+
+    let path = path.as_ref();
+    let dir = path.parent().ok_or_else(|| {
+        anyhow::anyhow!("Cannot determine parent directory for {}", path.display())
+    })?;
+    let file_name = path
+        .file_name()
+        .and_then(|n| n.to_str())
+        .ok_or_else(|| anyhow::anyhow!("Invalid file name for {}", path.display()))?;
+
+    // Unique-per-process temp name in the same directory (so rename is atomic).
+    let tmp_name = format!(".{file_name}.tmp.{}", std::process::id());
+    let tmp_path = dir.join(tmp_name);
+
+    let mut f = std::fs::File::create(&tmp_path)
+        .with_context(|| format!("Failed to create temp file {}", tmp_path.display()))?;
+    f.write_all(content)
+        .with_context(|| format!("Failed to write temp file {}", tmp_path.display()))?;
+    f.sync_all()
+        .with_context(|| format!("Failed to sync temp file {}", tmp_path.display()))?;
+    drop(f);
+
+    std::fs::rename(&tmp_path, path).with_context(|| {
+        // Best-effort cleanup so a failed rename doesn't leave a stray temp file.
+        let _ = std::fs::remove_file(&tmp_path);
+        format!(
+            "Failed to rename {} -> {}",
+            tmp_path.display(),
+            path.display()
+        )
+    })?;
+    Ok(())
+}
+
 pub fn expand_tilde(path: &str) -> String {
     if let Some(rest) = path.strip_prefix("~/") {
         if let Ok(home) = std::env::var("HOME") {

package/src/storage/referrals.rs

@@ -59,7 +59,7 @@ pub fn write_referral(referrals_dir: &Path, data: &ReferralData) -> Result<PathB
     let file_path = referrals_dir.join(&filename);
 
     let content = serde_json::to_string_pretty(data).context("Failed to serialize referral")?;
-    std::fs::write(&file_path, content)
+    crate::storage::atomic_write(&file_path, content.as_bytes())
         .with_context(|| format!("Failed to write referral: {}", file_path.display()))?;
 
     Ok(file_path)

package/src/storage/sessions.rs

@@ -109,6 +109,10 @@ fn synthesize_id_from_filename(filename: &str) -> String {
     }
 }
 
+fn ids_match(candidate: &str, query: &str) -> bool {
+    candidate == query || candidate.starts_with(query) || query.starts_with(candidate)
+}
+
 pub fn write_open_session(sessions_dir: &Path, data: &SessionData) -> Result<PathBuf> {
     let mut data = data.clone();
     if data.id.is_none() {
@@ -121,7 +125,7 @@ pub fn write_open_session(sessions_dir: &Path, data: &SessionData) -> Result<Pat
     let path = sessions_dir.join(&filename);
 
     let content = serde_json::to_string_pretty(&data).context("Failed to serialize session")?;
-    std::fs::write(&path, content)
+    crate::storage::atomic_write(&path, content.as_bytes())
         .with_context(|| format!("Failed to write session: {}", path.display()))?;
 
     Ok(path)
@@ -165,6 +169,40 @@ 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.
+pub fn append_decision_to_active_sessions(
+    sessions_dir: &Path,
+    decision: serde_json::Value,
+) -> Result<usize> {
+    let suffix = ".active.json";
+    if !sessions_dir.exists() {
+        return Ok(0);
+    }
+
+    let mut count = 0;
+    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(suffix) {
+            continue;
+        }
+        let path = entry.path();
+        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)
+            .with_context(|| format!("Failed to parse session: {}", path.display()))?;
+        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())
+            .with_context(|| format!("Failed to write session: {}", path.display()))?;
+        count += 1;
+    }
+    Ok(count)
+}
+
 fn transition_sessions(sessions_dir: &Path, from: &str, to: &str) -> Result<Vec<PathBuf>> {
     let mut transitioned = Vec::new();
     let from_suffix = format!(".{from}.json");
@@ -206,6 +244,8 @@ fn transition_session_by_id(
         return Ok(None);
     }
 
+    let mut matches: Vec<(PathBuf, String, 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();
@@ -219,25 +259,39 @@ fn transition_session_by_id(
             .with_context(|| format!("Failed to parse session: {}", entry.path().display()))?;
 
         let file_id = data.id.as_deref().unwrap_or("").to_string();
-        let synthesized = if file_id.is_empty() {
+        let resolved_id = if file_id.is_empty() {
             synthesize_id_from_filename(&name)
         } else {
             file_id
         };
 
-        if synthesized == session_id {
-            let new_name = name.replace(&from_suffix, &to_suffix);
-            let new_path = sessions_dir.join(&new_name);
-            std::fs::rename(entry.path(), &new_path).with_context(|| {
-                format!(
-                    "Failed to transition session {from}->{to}: {}",
-                    entry.path().display()
-                )
-            })?;
-            return Ok(Some(new_path));
+        if ids_match(&resolved_id, session_id) {
+            matches.push((entry.path(), name, 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, name, _)) = matches.into_iter().next() {
+        let new_name = name.replace(&from_suffix, &to_suffix);
+        let new_path = sessions_dir.join(&new_name);
+        std::fs::rename(&path, &new_path).with_context(|| {
+            format!(
+                "Failed to transition session {from}->{to}: {}",
+                path.display()
+            )
+        })?;
+        return Ok(Some(new_path));
+    }
+
     Ok(None)
 }
 
@@ -329,6 +383,8 @@ fn find_and_update_active_session(
         return Ok(None);
     }
 
+    let mut matches: Vec<(PathBuf, String, 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();
@@ -338,41 +394,58 @@ fn find_and_update_active_session(
 
         let content = std::fs::read_to_string(entry.path())
             .with_context(|| format!("Failed to read session: {}", entry.path().display()))?;
-        let mut data: SessionData = serde_json::from_str(&content)
+        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("").to_string();
-        let synthesized = if file_id.is_empty() {
+        let resolved_id = if file_id.is_empty() {
             synthesize_id_from_filename(&name)
         } else {
             file_id
         };
 
-        if synthesized != session_id {
-            continue;
+        if ids_match(&resolved_id, session_id) {
+            matches.push((entry.path(), name, 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, name, _)) = 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)
+            .with_context(|| format!("Failed to parse session: {}", path.display()))?;
 
         apply_session_updates(&mut data, updates);
 
         let updated_content =
             serde_json::to_string_pretty(&data).context("Failed to serialize session")?;
-        std::fs::write(entry.path(), &updated_content)
-            .with_context(|| format!("Failed to write session: {}", entry.path().display()))?;
+        crate::storage::atomic_write(&path, updated_content.as_bytes())
+            .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 new_path = sessions_dir.join(&new_name);
-            std::fs::rename(entry.path(), &new_path).with_context(|| {
+            std::fs::rename(&path, &new_path).with_context(|| {
                 format!(
                     "Failed to transition session active->{target_status}: {}",
-                    entry.path().display()
+                    path.display()
                 )
             })?;
             return Ok(Some(new_path));
         }
 
-        return Ok(Some(entry.path()));
+        return Ok(Some(path));
     }
 
     Ok(None)
@@ -440,7 +513,7 @@ pub fn write_session_with_status(
     let path = sessions_dir.join(&filename);
 
     let content = serde_json::to_string_pretty(&data).context("Failed to serialize session")?;
-    std::fs::write(&path, content)
+    crate::storage::atomic_write(&path, content.as_bytes())
         .with_context(|| format!("Failed to write session: {}", path.display()))?;
 
     Ok(path)

package/src/storage/tasks.rs

@@ -4,6 +4,11 @@ use std::path::{Path, PathBuf};
 use anyhow::{Context, Result};
 use chrono::Utc;
 use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+fn is_empty_map(m: &HashMap<String, Value>) -> bool {
+    m.is_empty()
+}
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct TaskData {
@@ -31,9 +36,13 @@ pub struct TaskData {
     pub dependencies: Vec<String>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub order: Option<u32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub assignee: Option<String>,
+    #[serde(flatten, default, skip_serializing_if = "is_empty_map")]
+    pub extra: HashMap<String, Value>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct Schedule {
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub start_date: Option<String>,
@@ -44,7 +53,11 @@ pub struct Schedule {
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub actual_hours: Option<f64>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub remaining_hours: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub milestone: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pinned: Option<bool>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -65,6 +78,8 @@ pub struct TaskIndex {
     pub dependencies: Vec<String>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub order: Option<u32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub assignee: Option<String>,
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub children: Vec<TaskIndex>,
 }
@@ -190,11 +205,60 @@ pub fn read_task(task_dir: &Path) -> Result<Option<(TaskData, String)>> {
 pub fn write_task(task_dir: &Path, status: &str, data: &TaskData) -> Result<()> {
     let file_path = task_dir.join(format!("_task.{status}.json"));
     let content = serde_json::to_string_pretty(data).context("Failed to serialize task")?;
-    std::fs::write(&file_path, content)
+    crate::storage::atomic_write(&file_path, content.as_bytes())
         .with_context(|| format!("Failed to write task: {}", file_path.display()))?;
     Ok(())
 }
 
+/// Read-modify-write a task with optimistic concurrency control.
+///
+/// Reads the current task, runs `mutate` on a copy, then re-reads just before
+/// writing: if the file's `updated_at` changed since the snapshot (another
+/// writer — e.g. the VSCode extension — won the race), the whole cycle retries
+/// up to `MAX_RETRIES` times. This matches the VSCode side's `updated_at`
+/// protocol (wiki/95-concurrency-safety.md) and prevents lost updates that
+/// atomic_write alone cannot (atomic_write stops *torn* reads, not *lost*
+/// updates).
+///
+/// `mutate` receives the current `TaskData` and the resolved status, and returns
+/// the new status the task should have after the change (usually unchanged).
+pub fn read_modify_write_task<F>(task_dir: &Path, mut mutate: F) -> Result<()>
+where
+    F: FnMut(&mut TaskData, &str) -> Result<String>,
+{
+    const MAX_RETRIES: usize = 5;
+
+    for attempt in 0..=MAX_RETRIES {
+        let (mut data, status) = read_task(task_dir)?
+            .ok_or_else(|| anyhow::anyhow!("Task file not found in {}", task_dir.display()))?;
+        let snapshot_updated_at = data.updated_at.clone();
+
+        let new_status = mutate(&mut data, &status)?;
+
+        // Re-read to detect a concurrent writer before committing.
+        let current_updated_at = read_task(task_dir)?.and_then(|(d, _)| d.updated_at);
+        if current_updated_at != snapshot_updated_at {
+            // Someone else wrote between our read and write. Retry from scratch.
+            if attempt == MAX_RETRIES {
+                anyhow::bail!(
+                    "Concurrent modification of task in {} after {} retries; aborting to avoid \
+                     overwriting another writer's changes.",
+                    task_dir.display(),
+                    MAX_RETRIES
+                );
+            }
+            continue;
+        }
+
+        if new_status != status {
+            change_status(task_dir, &new_status)?;
+        }
+        write_task(task_dir, &new_status, &data)?;
+        return Ok(());
+    }
+    unreachable!("loop returns or bails within MAX_RETRIES iterations")
+}
+
 pub fn change_status(task_dir: &Path, new_status: &str) -> Result<()> {
     if !is_valid_status(new_status) {
         anyhow::bail!("Invalid status: {new_status}");
@@ -423,6 +487,7 @@ fn build_index_recursive(
             schedule: data.schedule,
             dependencies: data.dependencies,
             order: data.order,
+            assignee: data.assignee,
             children,
         });
     }