handoff-mcp-server 0.10.0 → 0.12.0

package/src/storage/config.rs

@@ -11,6 +11,27 @@ pub struct Config {
     pub settings: SettingsConfig,
     #[serde(default)]
     pub dashboard: DashboardConfig,
+    /// Project-level start timestamp (pre-start mode). RFC3339 string.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub started_at: Option<String>,
+    /// Scheduling mode: "manual" or "auto".
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schedule_mode: Option<String>,
+    /// Project-level label vocabulary.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub labels: Vec<String>,
+    #[serde(default, skip_serializing_if = "CalendarConfig::is_empty")]
+    pub calendar: CalendarConfig,
+    /// Team members keyed by stable assignee key.
+    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
+    pub assignees: HashMap<String, AssigneeConfig>,
+    /// Milestones keyed by milestone name.
+    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
+    pub milestones: HashMap<String, MilestoneConfig>,
+    #[serde(default, skip_serializing_if = "GanttViewConfig::is_empty")]
+    pub gantt_view: GanttViewConfig,
+    #[serde(default, skip_serializing_if = "EffortBudgetConfig::is_empty")]
+    pub effort_budget: EffortBudgetConfig,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -28,6 +49,13 @@ pub struct SettingsConfig {
     pub done_task_limit: u32,
     #[serde(default = "default_auto_git_summary")]
     pub auto_git_summary: bool,
+    /// Require `estimate_hours` when creating/updating leaf tasks. Default true.
+    #[serde(default = "default_require_estimate_hours")]
+    pub require_estimate_hours: bool,
+    /// Multiplier applied to AI-entered `estimate_hours` to derive the
+    /// adjusted (AI-effort) estimate at aggregation time. Default 0.2.
+    #[serde(default = "default_ai_estimate_multiplier")]
+    pub ai_estimate_multiplier: f64,
     #[serde(default)]
     pub context_files: Vec<String>,
     #[serde(default)]
@@ -42,6 +70,121 @@ pub struct DashboardConfig {
     pub exclude_patterns: Vec<String>,
 }
 
+/// Project-wide working calendar. Mirrors VSCode `CalendarConfig`.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct CalendarConfig {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub work_hours_per_day: Option<f64>,
+    /// Weekday numbers (0=Sun..6=Sat) that are non-working.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub closed_weekdays: Vec<u32>,
+    /// Specific YYYY-MM-DD dates that are non-working (override weekdays).
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub closed_dates: Vec<String>,
+    /// Specific YYYY-MM-DD dates that are working even if normally closed.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub open_dates: Vec<String>,
+    /// Per-weekday / per-date working-hour overrides. Key = weekday name or YYYY-MM-DD.
+    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
+    pub day_hours: HashMap<String, f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schedule_mode: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub overwork_limit_percent: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub max_utilization: Option<f64>,
+}
+
+impl CalendarConfig {
+    pub fn is_empty(&self) -> bool {
+        self.work_hours_per_day.is_none()
+            && self.closed_weekdays.is_empty()
+            && self.closed_dates.is_empty()
+            && self.open_dates.is_empty()
+            && self.day_hours.is_empty()
+            && self.schedule_mode.is_none()
+            && self.overwork_limit_percent.is_none()
+            && self.max_utilization.is_none()
+    }
+}
+
+/// A single team member's configuration. Mirrors VSCode `AssigneeConfig`.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct AssigneeConfig {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub color: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub work_hours_per_day: Option<f64>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub closed_weekdays: Vec<u32>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub closed_dates: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub open_dates: Vec<String>,
+    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
+    pub day_hours: HashMap<String, f64>,
+}
+
+/// A milestone definition. Mirrors VSCode `MilestoneConfig`.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct MilestoneConfig {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub date: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub color: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+}
+
+/// Gantt view UI settings. Mirrors VSCode `GanttViewSettings`.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct GanttViewConfig {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sort: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub zoom: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub mode: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub group_by_milestone: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub group_by_assignee: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub show_workload: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filter_assignee: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub workload_view: Option<String>,
+}
+
+impl GanttViewConfig {
+    pub fn is_empty(&self) -> bool {
+        self.sort.is_none()
+            && self.zoom.is_none()
+            && self.mode.is_none()
+            && self.group_by_milestone.is_none()
+            && self.group_by_assignee.is_none()
+            && self.show_workload.is_none()
+            && self.filter_assignee.is_none()
+            && self.workload_view.is_none()
+    }
+}
+
+/// Effort budget. Mirrors VSCode `budgetTotalHours`.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct EffortBudgetConfig {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub total_hours: Option<f64>,
+}
+
+impl EffortBudgetConfig {
+    pub fn is_empty(&self) -> bool {
+        self.total_hours.is_none()
+    }
+}
+
 fn default_history_limit() -> u32 {
     20
 }
@@ -54,6 +197,14 @@ fn default_auto_git_summary() -> bool {
     true
 }
 
+fn default_require_estimate_hours() -> bool {
+    true
+}
+
+fn default_ai_estimate_multiplier() -> f64 {
+    0.2
+}
+
 fn default_scan_dirs() -> Vec<String> {
     vec!["~/pro/".to_string()]
 }
@@ -64,6 +215,8 @@ impl Default for SettingsConfig {
             history_limit: default_history_limit(),
             done_task_limit: default_done_task_limit(),
             auto_git_summary: default_auto_git_summary(),
+            require_estimate_hours: default_require_estimate_hours(),
+            ai_estimate_multiplier: default_ai_estimate_multiplier(),
             context_files: Vec::new(),
             custom_fields: HashMap::new(),
         }
@@ -92,6 +245,14 @@ impl Config {
             },
             settings: SettingsConfig::default(),
             dashboard: DashboardConfig::default(),
+            started_at: None,
+            schedule_mode: None,
+            labels: Vec::new(),
+            calendar: CalendarConfig::default(),
+            assignees: HashMap::new(),
+            milestones: HashMap::new(),
+            gantt_view: GanttViewConfig::default(),
+            effort_budget: EffortBudgetConfig::default(),
         }
     }
 }
@@ -106,7 +267,7 @@ pub fn read_config(path: &Path) -> Result<Config> {
 
 pub fn write_config(path: &Path, config: &Config) -> Result<()> {
     let content = toml::to_string_pretty(config).context("Failed to serialize config")?;
-    std::fs::write(path, content)
+    crate::storage::atomic_write(path, content.as_bytes())
         .with_context(|| format!("Failed to write config: {}", path.display()))?;
     Ok(())
 }

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)
@@ -160,6 +160,44 @@ pub fn change_referral_status(
     Ok(())
 }
 
+/// Read a single referral's full data by ID, returning the data and its status.
+/// Searches every status (open / acknowledged / resolved). Matches by exact ID
+/// first, then falls back to a unique prefix match for convenience.
+pub fn read_referral_by_id(
+    referrals_dir: &Path,
+    referral_id: &str,
+) -> Result<Option<(ReferralData, String)>> {
+    if !referrals_dir.exists() {
+        return Ok(None);
+    }
+
+    let mut prefix_matches: Vec<(ReferralData, String)> = Vec::new();
+
+    for entry in std::fs::read_dir(referrals_dir)? {
+        let entry = entry?;
+        let name = entry.file_name().to_string_lossy().to_string();
+        if let Some(status) = parse_referral_status(&name) {
+            let content = std::fs::read_to_string(entry.path())?;
+            if let Ok(data) = serde_json::from_str::<ReferralData>(&content) {
+                if data.id == referral_id {
+                    return Ok(Some((data, status)));
+                }
+                if data.id.starts_with(referral_id) {
+                    prefix_matches.push((data, status));
+                }
+            }
+        }
+    }
+
+    match prefix_matches.len() {
+        0 => Ok(None),
+        1 => Ok(Some(prefix_matches.into_iter().next().unwrap())),
+        n => anyhow::bail!(
+            "Ambiguous referral id prefix '{referral_id}' matches {n} referrals; use the full id"
+        ),
+    }
+}
+
 pub fn find_referral_file(
     referrals_dir: &Path,
     referral_id: &str,

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)