@team-agent/installer 0.5.101 → 0.5.103

package/crates/team-agent/src/mcp_server/tests.rs

@@ -1,25 +1,8 @@
-//! ---
-//! purpose: MCP no-compaction contract test with fixture-owned workspace and path provenance
-//! contract:
-//!   provides:
-//!     - name: mcp_state_fixture
-//!       what: supplies explicit process-owned workspace and state-file paths without mutating process-global environment
-//!     - name: mcp_state_path_provenance
-//!       what: records raw/canonical workspace, resolved state path, and filesystem ownership facts
-//!   depends:
-//!     - crate::mcp_server::lifecycle_tools::state_status
-//!     - crate::state::selector
-//! boundary:
-//!   - the owned no-compaction test writes only within its fixture root
-//!   - this suite does not alter persistence semantics
-//! maturity: wired
-//! ---
-//! step 14a · mcp_server::tests — WAVE-2 RED contracts (Python v0.2.11 golden).
+//! MCP server unit-test fixtures and focused stdio/wire contract tests.
 #![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
 use super::*;
 use serde_json::json;
-use sha2::{Digest, Sha256};
 use std::path::{Path, PathBuf};
 
 // ── helpers ──────────────────────────────────────────────────────────────
@@ -35,11 +18,9 @@ fn keys(v: &Value) -> Vec<String> {
     v.as_object().unwrap().keys().cloned().collect()
 }
 
-/// A UNIQUE throwaway workspace dir per test (mirrors the state/coordinator idiom):
-/// tests that open the db (MessageStore) or write the filesystem MUST NOT share
-/// `/tmp/ws`, or they flake under parallel cargo (sqlite "database is locked" / NotFound).
-/// Pure-function / dispatch-shape tests that never touch fs/db keep a dummy fixed path.
-fn unique_ws(tag: &str) -> std::path::PathBuf {
+/// A UNIQUE throwaway workspace dir per test. Filesystem and database tests
+/// must not share `/tmp/ws` under parallel cargo.
+fn unique_ws(tag: &str) -> PathBuf {
     use std::io::ErrorKind;
     use std::sync::atomic::{AtomicU64, Ordering};
     static N: AtomicU64 = AtomicU64::new(0);
@@ -54,183 +35,6 @@ fn unique_ws(tag: &str) -> std::path::PathBuf {
     }
 }
 
-static MCP_FIXTURE_SEQ: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
-
-/// One process-owned root for update_state tests. All paths are passed explicitly
-/// to the code under test; the fixture never changes process-global environment.
-struct McpStateFixture {
-    root: PathBuf,
-    workspace: PathBuf,
-    receipt: PathBuf,
-}
-
-impl McpStateFixture {
-    fn new(_tag: &str) -> Self {
-        let seq = MCP_FIXTURE_SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
-        let base = if cfg!(target_os = "macos") {
-            PathBuf::from("/private/tmp")
-        } else {
-            PathBuf::from("/tmp")
-        };
-        let raw_root = base.join(format!("ta-mcp-{}-{seq}", std::process::id()));
-        std::fs::create_dir(&raw_root).unwrap();
-        let root = std::fs::canonicalize(raw_root).unwrap();
-        let workspace = root.join("workspace");
-        let receipt = root
-            .parent()
-            .unwrap()
-            .join(format!("ta-mcp-receipt-{}-{seq}.json", std::process::id()));
-        std::fs::create_dir(&workspace).unwrap();
-
-        let fixture = Self {
-            root,
-            workspace,
-            receipt,
-        };
-        fixture.seed_spec("team_state.md");
-        crate::state::repository::StateRepository::new(&fixture.workspace)
-            .save(
-                crate::state::repository::StateWriteIntent::FakeE2eSeed,
-                &json!({
-                    "session_name": "mcp-fixture",
-                    "active_team_key": "current",
-                    "agents": {},
-                    "tasks": []
-                }),
-            )
-            .unwrap();
-        fixture
-    }
-
-    fn seed_spec(&self, state_file: &str) {
-        std::fs::write(
-            self.workspace.join("team.spec.yaml"),
-            format!(
-                "team:\n  name: mcp-fixture\n  objective: path contract\nagents: []\ntasks: []\ncontext:\n  state_file: {state_file}\n"
-            ),
-        )
-        .unwrap();
-    }
-
-    fn state_file(&self, relative: &str) -> PathBuf {
-        self.workspace.join(relative)
-    }
-
-    fn record_provenance(&self, raw_workspace: &Path, state_file: &Path) -> PathBuf {
-        let canonical_workspace =
-            crate::model::paths::canonical_run_workspace(raw_workspace).unwrap();
-        assert!(self.under_root(raw_workspace));
-        assert!(self.under_root(&canonical_workspace));
-        assert!(self.under_root(state_file));
-        let team_dir = self.workspace.join(".team");
-        let runtime_dir = team_dir.join("runtime");
-        let runtime_state = crate::state::persist::runtime_state_path(&self.workspace);
-        let paths = [
-            ("root", self.root.as_path()),
-            ("raw_workspace", raw_workspace),
-            ("canonical_workspace", canonical_workspace.as_path()),
-            ("team_dir", team_dir.as_path()),
-            ("runtime_dir", runtime_dir.as_path()),
-            ("state_parent", state_file.parent().unwrap()),
-            ("runtime_state", runtime_state.as_path()),
-        ];
-        let mut facts = paths
-            .into_iter()
-            .map(|(name, path)| {
-                let metadata = std::fs::symlink_metadata(path).unwrap();
-                json!({
-                    "name": name,
-                    "path": path.display().to_string(),
-                    "uid": metadata_uid(&metadata),
-                    "mode": metadata_mode(&metadata),
-                    "device": metadata_device(&metadata)
-                })
-            })
-            .collect::<Vec<_>>();
-        if let Ok(metadata) = std::fs::symlink_metadata(state_file) {
-            facts.push(json!({
-                "name": "state_file",
-                "path": state_file.display().to_string(),
-                "uid": metadata_uid(&metadata),
-                "mode": metadata_mode(&metadata),
-                "device": metadata_device(&metadata)
-            }));
-        }
-        let payload = json!({
-            "raw_workspace": raw_workspace.display().to_string(),
-            "canonical_workspace": canonical_workspace.display().to_string(),
-            "resolved_state_file": state_file.display().to_string(),
-            "runtime_state_path": runtime_state.display().to_string(),
-            "facts": facts
-        });
-        let payload_bytes = serde_json::to_vec(&payload).unwrap();
-        let payload_sha256 = format!("{:x}", Sha256::digest(&payload_bytes));
-        let receipt = json!({
-            "schema": "mcp-state-provenance-v1",
-            "payload": payload,
-            "payload_sha256": payload_sha256
-        });
-        let receipt_bytes = serde_json::to_vec_pretty(&receipt).unwrap();
-        use std::io::Write;
-        let mut file = std::fs::OpenOptions::new()
-            .write(true)
-            .create_new(true)
-            .open(&self.receipt)
-            .unwrap();
-        file.write_all(&receipt_bytes).unwrap();
-        file.sync_all().unwrap();
-        self.receipt.clone()
-    }
-
-    fn under_root(&self, path: &Path) -> bool {
-        let candidate = if path.exists() {
-            std::fs::canonicalize(path).unwrap()
-        } else {
-            path.to_path_buf()
-        };
-        candidate.starts_with(&self.root)
-    }
-}
-
-impl Drop for McpStateFixture {
-    fn drop(&mut self) {
-        let _ = std::fs::remove_dir_all(&self.root);
-    }
-}
-
-#[cfg(unix)]
-fn metadata_uid(metadata: &std::fs::Metadata) -> u32 {
-    use std::os::unix::fs::MetadataExt;
-    metadata.uid()
-}
-
-#[cfg(not(unix))]
-fn metadata_uid(_: &std::fs::Metadata) -> u32 {
-    0
-}
-
-#[cfg(unix)]
-fn metadata_mode(metadata: &std::fs::Metadata) -> u32 {
-    use std::os::unix::fs::MetadataExt;
-    metadata.mode()
-}
-
-#[cfg(not(unix))]
-fn metadata_mode(_: &std::fs::Metadata) -> u32 {
-    0
-}
-
-#[cfg(unix)]
-fn metadata_device(metadata: &std::fs::Metadata) -> u64 {
-    use std::os::unix::fs::MetadataExt;
-    metadata.dev()
-}
-
-#[cfg(not(unix))]
-fn metadata_device(_: &std::fs::Metadata) -> u64 {
-    0
-}
-
 include!("tests/normalize.rs");
 include!("tests/wire.rs");
 include!("tests/send.rs");

package/crates/team-agent/src/mcp_server/tools.rs

@@ -1,5 +1,5 @@
 //!
-//! step 14a · mcp_server::tools — `TeamOrchestratorTools`, the 12 typed handlers.
+//! step 14a · mcp_server::tools — `TeamOrchestratorTools`, the three MCP handlers.
 
 use std::path::{Path, PathBuf};
 
@@ -13,16 +13,14 @@ use crate::model::ids::{AgentId, TaskId, TeamKey};
 use crate::event_log::EventLog;
 
 // ── REUSE: step 5 state persist / projection ────────────────────────────────
-use crate::state::persist::{
-    load_runtime_state, save_runtime_state, save_runtime_state_reapplying_after_conflict,
-};
+use crate::state::persist::load_runtime_state;
 
 // ── REUSE: step 11 messaging delegate surface ───────────────────────────────
 use crate::messaging::{self, DeliveryStatus, MessageTarget, SendOptions, TrustedSender};
 
 use super::helpers::{
     current_reportable_message_for, delivery_outcome_value, direct_message_attribution_for,
-    ensure_object, enum_value, is_worker_recipient, json_dumps_default, latest_task_for_assignee,
+    ensure_object, enum_value, is_worker_recipient, latest_task_for_assignee,
     non_empty_string, object_fields, requires_ack_for_target, tool_runtime_error,
     DirectMessageAttribution,
 };
@@ -35,7 +33,7 @@ use super::types::{
 };
 
 // ═══════════════════════════════════════════════════════════════════════════
-// TeamOrchestratorTools (tools.py:72) — the 12 typed tool handlers.
+// TeamOrchestratorTools — the three typed MCP handlers.
 // Identity/scope anchored on spawn-time env (TEAM_AGENT_ID / TEAM_AGENT_OWNER_TEAM_ID);
 // every handler delegates to runtime/MessageStore/EventLog. These ARE the
 // contract-callable behavioral entry fns.
@@ -183,100 +181,6 @@ impl TeamOrchestratorTools {
         error
     }
 
-    /// `assign_task` (`tools.py:84-133`): C8 Family-B task-view reconcile then deliver.
-    /// Resolves team key from owner-team env (or `active_team_key`), appends or
-    /// field-updates the task in state, then delegates delivery to
-    /// [`Self::send_message`] and compacts the result.
-    pub fn assign_task(&self, task: &Value, message: Option<&str>) -> ToolResult {
-        self.validate_rpc_scope_args("assign_task", task)?;
-        let Some(task_obj) = task.as_object() else {
-            return Err(ToolError::new(
-                ToolErrorReason::InvalidToolArguments,
-                "assign_task task must be an object",
-                "ValueError",
-            ));
-        };
-        let Some(task_id) = task
-            .get("id")
-            .and_then(Value::as_str)
-            .and_then(non_empty_string)
-        else {
-            return Err(ToolError::new(
-                ToolErrorReason::InvalidToolArguments,
-                "assign_task task.id is required",
-                "ValueError",
-            ));
-        };
-        let Some(assignee) = task
-            .get("assignee")
-            .and_then(Value::as_str)
-            .and_then(non_empty_string)
-        else {
-            return Err(ToolError::new(
-                ToolErrorReason::InvalidToolArguments,
-                "assign_task task.assignee is required",
-                "ValueError",
-            ));
-        };
-        if let Some(route) = task.get("result_route") {
-            let Some(route) = route.as_str() else {
-                return Err(ToolError::new(
-                    ToolErrorReason::InvalidToolArguments,
-                    "assign_task task.result_route must be 'leader' or 'pipeline'",
-                    "ValueError",
-                ));
-            };
-            if crate::messaging::results::ResultRoute::parse(route).is_none() {
-                return Err(ToolError::new(
-                    ToolErrorReason::InvalidToolArguments,
-                    format!("assign_task task.result_route has unknown value: {route}"),
-                    "ValueError",
-                ));
-            }
-        }
-
-        let task_value = Value::Object(task_obj.clone());
-        let recovery = task_recovery_marker(&task_value);
-        let mut state = load_runtime_state(&self.workspace).map_err(tool_runtime_error)?;
-        ensure_object(&mut state);
-        let team_key = self
-            .canonical_owner_team_key()?
-            .map(|team| team.as_str().to_string())
-            .or_else(|| assignment_team_key(&state));
-        crate::state::repository::StateRepository::new(&self.workspace)
-            .commit(
-                crate::state::repository::StateWriteIntent::McpAssignTask {
-                    team_key: team_key.as_deref(),
-                    task_id,
-                },
-                |latest| {
-                    ensure_object(latest);
-                    let latest_team_key = team_key.clone().or_else(|| assignment_team_key(latest));
-                    reconcile_assigned_task(latest, latest_team_key.as_deref(), &task_value);
-                },
-            )
-            .map_err(tool_runtime_error)?;
-
-        let content = assignment_message(task, message);
-        let out = self.send_message(
-            &MessageTarget::Single(assignee.to_string()),
-            &content,
-            Some(task_id),
-            None,
-            None,
-        )?;
-        let mut ok = compact_tool_result(&out.to_value())?;
-        if recovery {
-            ok.fields
-                .insert("recovery".to_string(), serde_json::json!(true));
-            ok.fields.insert(
-                "acceptance_marker".to_string(),
-                Value::String("recovery".to_string()),
-            );
-        }
-        Ok(ok)
-    }
-
     /// `send_message` (`tools.py:135-183`): C14/C15/C17 scope resolution.
     ///   - sender = immutable `TEAM_AGENT_ID` captured when the MCP server starts.
     ///   - `requires_ack` defaults from target (`_requires_ack_for_target`).
@@ -722,207 +626,12 @@ impl TeamOrchestratorTools {
         .and_then(|value| compact_tool_result(&value))
     }
 
-    /// `update_state` (`tools.py:316-325`): delegated through the lifecycle tools
-    /// facade. S0 preserves the old placeholder behavior.
-    pub fn update_state(&self, note: &str) -> ToolResult {
-        let owner_team = self.canonical_owner_team_key()?;
-        super::lifecycle_tools::update_state(&self.workspace, owner_team.as_ref(), note)
-    }
-
-    /// `get_team_status` (`tools.py:327-328`): delegated through the lifecycle tools
-    /// facade. S0 preserves the old placeholder behavior.
+    /// `get_team_status`: return the owner-team-scoped machine-readable status.
     pub fn get_team_status(&self) -> ToolResult {
         let owner_team = self.canonical_owner_team_key()?;
         super::lifecycle_tools::get_team_status(&self.workspace, owner_team.as_ref())
     }
 
-    /// `stop_agent` (`tools.py:330-331`): delegated through the lifecycle tools facade.
-    pub fn stop_agent(&self, agent_id: &str) -> ToolResult {
-        let owner_team = self.canonical_owner_team_key()?;
-        super::lifecycle_tools::stop_agent(&self.workspace, owner_team.as_ref(), agent_id)
-    }
-
-    /// `reset_agent` (`tools.py:333-334`): delegated through the lifecycle tools facade.
-    pub fn reset_agent(&self, agent_id: &str, discard_session: bool) -> ToolResult {
-        let owner_team = self.canonical_owner_team_key()?;
-        super::lifecycle_tools::reset_agent(
-            &self.workspace,
-            owner_team.as_ref(),
-            agent_id,
-            discard_session,
-        )
-    }
-
-    /// `add_agent` (`tools.py:336-337`): delegate to real lifecycle add-agent
-    /// under the spawn-time owner team.
-    pub fn add_agent(&self, new_agent_id: &str, role_file_path: &str) -> ToolResult {
-        let owner_team = self
-            .canonical_owner_team_key()?
-            .ok_or_else(|| self.scope_refused("add_agent requires TEAM_AGENT_OWNER_TEAM_ID"))?;
-        let role_file = Path::new(role_file_path);
-        let role_file = if role_file.is_absolute() {
-            role_file.to_path_buf()
-        } else {
-            self.workspace.join(role_file)
-        };
-        crate::lifecycle::launch::add_agent(
-            &self.workspace,
-            &AgentId::new(new_agent_id.to_string()),
-            &role_file,
-            false,
-            Some(owner_team.as_str()),
-        )
-        .map_err(tool_runtime_error)
-        .and_then(|report| {
-            compact_tool_result(&serde_json::json!({
-                "ok": true,
-                "status": "added",
-                "agent_id": new_agent_id,
-                "state_file": report.env.state_file.to_string_lossy().to_string(),
-                "coordinator_started": report.env.coordinator_started,
-                "start_mode": format!("{:?}", report.start_mode),
-                "role_file": report.role_file.to_string_lossy().to_string(),
-            }))
-        })
-    }
-
-    /// `fork_agent` (`tools.py:339-340`): delegated through the lifecycle tools facade.
-    pub fn fork_agent(
-        &self,
-        source_agent_id: &str,
-        as_agent_id: &str,
-        label: Option<&str>,
-    ) -> ToolResult {
-        let owner_team = self.canonical_owner_team_key()?;
-        super::lifecycle_tools::fork_agent(
-            &self.workspace,
-            owner_team.as_ref(),
-            source_agent_id,
-            as_agent_id,
-            label,
-        )
-    }
-
-    pub fn clone_agent(
-        &self,
-        source_agent_id: &str,
-        as_agent_id: &str,
-        label: Option<&str>,
-    ) -> ToolResult {
-        let owner_team = self.canonical_owner_team_key()?;
-        super::lifecycle_tools::clone_agent(
-            &self.workspace,
-            owner_team.as_ref(),
-            source_agent_id,
-            as_agent_id,
-            label,
-        )
-    }
-
-    /// `request_human` (`tools.py:342-346`): create a `requires_ack` leader message via
-    /// the shared leader-delivery funnel; sender = env / inferred / `"unknown"`.
-    /// Returns `{ok:true, message_id, status:"needs_human"}`.
-    pub fn request_human(
-        &self,
-        question: &str,
-        task_id: Option<&str>,
-        agent_id: Option<&str>,
-    ) -> ToolResult {
-        let _owner_team = self.canonical_owner_team_key()?;
-        let explicit_sender = agent_id.and_then(non_empty_string);
-        let sender = explicit_sender
-            .or_else(|| self.agent_id.as_ref().map(AgentId::as_str))
-            .unwrap_or("unknown");
-        let event_log = EventLog::new(&self.workspace);
-        if explicit_sender.is_none() && self.agent_id.is_none() {
-            event_log
-                .write(
-                    "mcp.identity_inference_failed",
-                    serde_json::json!({"tool": "request_human"}),
-                )
-                .map_err(tool_runtime_error)?;
-        }
-        // #230 N31/N32 funnel: request_human is a leader-bound caller and must go through
-        // the same primitive as send_message(to=leader) / report_result / idle reminder.
-        // The legacy path was a raw store insert for recipient="leader" that
-        // bypassed the leader-delivery audit (no deliver_to_leader.submit emit, no rebind
-        // guard, no leader_notification_log dedup). funnel it now.
-        let state = crate::state::persist::load_runtime_state(&self.workspace)
-            .unwrap_or(serde_json::json!({}));
-        let task = task_id.map(|t| TaskId::new(t.to_string()));
-        let outcome = crate::messaging::send_to_leader_receiver(
-            &self.workspace,
-            &state,
-            "leader",
-            question,
-            task.as_ref(),
-            sender,
-            true,
-            None,
-            &event_log,
-        )
-        .map_err(tool_runtime_error)?;
-        let mut fields = serde_json::Map::new();
-        fields.insert("ok".to_string(), Value::Bool(outcome.ok));
-        fields.insert(
-            "message_id".to_string(),
-            outcome
-                .message_id
-                .clone()
-                .map_or(Value::Null, Value::String),
-        );
-        fields.insert(
-            "status".to_string(),
-            Value::String("needs_human".to_string()),
-        );
-        Ok(ToolOk { fields })
-    }
-
-    /// `stuck_list` (`tools.py:348-349`): delegate to [`messaging::stuck_list`] (the
-    /// team-scoped suppressed-alert projection).
-    pub fn stuck_list(&self) -> ToolResult {
-        let _owner_team = self.canonical_owner_team_key()?;
-        messaging::stuck_list(&self.workspace)
-            .map_err(tool_runtime_error)
-            .map(|v| ToolOk {
-                fields: object_fields(v),
-            })
-    }
-
-    /// `stuck_cancel` (`tools.py:351-352`): delegate to [`messaging::stuck_cancel`];
-    /// `suppressed_by` = env agent_id / `"leader"`.
-    pub fn stuck_cancel(&self, agent_id: &str, alert_type: &str) -> ToolResult {
-        let _owner_team = self.canonical_owner_team_key()?;
-        let alert = match alert_type {
-            "stuck" => Some(messaging::AlertType::Stuck),
-            "idle_fallback" => Some(messaging::AlertType::IdleFallback),
-            "cross_worker_deadlock" => Some(messaging::AlertType::CrossWorkerDeadlock),
-            "all" => None,
-            // scheduler.py:268-273 — an unknown alert_type refuses with the Python
-            // literal instead of silently widening to suppressing ALL alert families.
-            _ => {
-                return Ok(ToolOk {
-                    fields: object_fields(serde_json::json!({
-                        "ok": false,
-                        "status": "refused",
-                        "reason": "invalid_alert_type",
-                        "alert_type": alert_type,
-                    })),
-                });
-            }
-        };
-        let suppressed_by = self
-            .agent_id
-            .as_ref()
-            .map(AgentId::as_str)
-            .unwrap_or("leader");
-        messaging::stuck_cancel(&self.workspace, agent_id, alert, suppressed_by)
-            .map_err(tool_runtime_error)
-            .map(|v| ToolOk {
-                fields: object_fields(v),
-            })
-    }
-
     /// `get_visible_peers` (`tools.py:226-247`): C16 scope-filtered peer list — live
     /// agents within the spawn-time owner-team scope only; other teams and dead/stopped
     /// agents are filtered server-side and never named.
@@ -1275,63 +984,6 @@ fn requested_scope_arg(args: &Value) -> Option<String> {
         .or_else(|| args.get("workspace").map(|_| "workspace".to_string()))
 }
 
-fn assignment_team_key(state: &Value) -> Option<String> {
-    state
-        .get("active_team_key")
-        .and_then(Value::as_str)
-        .and_then(non_empty_string)
-        .map(ToString::to_string)
-}
-
-fn reconcile_assigned_task(state: &mut Value, team_key: Option<&str>, task: &Value) {
-    let mut top = state
-        .get("tasks")
-        .and_then(Value::as_array)
-        .cloned()
-        .unwrap_or_default();
-    upsert_task_in_place(&mut top, task);
-    if let Some(root) = state.as_object_mut() {
-        root.insert("tasks".to_string(), Value::Array(top.clone()));
-    }
-    if let Some(key) = team_key {
-        let mut team_tasks = state
-            .get("teams")
-            .and_then(|v| v.get(key))
-            .and_then(|team| team.get("tasks"))
-            .and_then(Value::as_array)
-            .cloned()
-            .unwrap_or_default();
-        upsert_task_in_place(&mut team_tasks, task);
-        write_team_tasks(state, key, team_tasks);
-    }
-}
-
-fn upsert_task_in_place(tasks: &mut Vec<Value>, task: &Value) {
-    let Some(task_id) = task.get("id").and_then(Value::as_str) else {
-        return;
-    };
-    for existing in tasks.iter_mut() {
-        if existing.get("id").and_then(Value::as_str) == Some(task_id) {
-            merge_object_fields(existing, task);
-            return;
-        }
-    }
-    tasks.push(task.clone());
-}
-
-fn merge_object_fields(existing: &mut Value, incoming: &Value) {
-    let Some(existing_obj) = existing.as_object_mut() else {
-        *existing = incoming.clone();
-        return;
-    };
-    let Some(incoming_obj) = incoming.as_object() else {
-        return;
-    };
-    for (key, value) in incoming_obj {
-        existing_obj.insert(key.clone(), value.clone());
-    }
-}
-
 fn push_report_warning(obj: &mut serde_json::Map<String, Value>, warning: Value) {
     let Some(code) = warning.get("code").and_then(Value::as_str) else {
         return;
@@ -1355,49 +1007,6 @@ fn push_report_warning(obj: &mut serde_json::Map<String, Value>, warning: Value)
     }
 }
 
-fn write_team_tasks(state: &mut Value, team_key: &str, tasks: Vec<Value>) {
-    let Some(root) = state.as_object_mut() else {
-        return;
-    };
-    let teams = root
-        .entry("teams".to_string())
-        .or_insert_with(|| Value::Object(serde_json::Map::new()));
-    let Some(teams_obj) = teams.as_object_mut() else {
-        return;
-    };
-    let team = teams_obj.entry(team_key.to_string()).or_insert_with(|| {
-        let mut team = serde_json::Map::new();
-        team.insert("tasks".to_string(), Value::Array(Vec::new()));
-        team.insert("status".to_string(), Value::String("alive".to_string()));
-        Value::Object(team)
-    });
-    let Some(team_obj) = team.as_object_mut() else {
-        return;
-    };
-    team_obj.insert("tasks".to_string(), Value::Array(tasks));
-}
-
-fn assignment_message(task: &Value, explicit: Option<&str>) -> String {
-    if let Some(message) = explicit.and_then(non_empty_string) {
-        return message.to_string();
-    }
-    for key in ["description", "title"] {
-        if let Some(text) = task
-            .get(key)
-            .and_then(Value::as_str)
-            .and_then(non_empty_string)
-        {
-            return text.to_string();
-        }
-    }
-    json_dumps_default(task)
-}
-
-fn task_recovery_marker(task: &Value) -> bool {
-    task.get("recovery").and_then(Value::as_bool) == Some(true)
-        || task.get("acceptance_marker").and_then(Value::as_str) == Some("recovery")
-}
-
 fn scope_override_name(scope: Scope) -> Option<&'static str> {
     match scope {
         Scope::Team => Some("team"),