@team-agent/installer 0.5.100 → 0.5.102

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

@@ -82,6 +82,7 @@ mod pi_command_red;
 mod pi_compiler_red;
 mod pi_dual_entry_red;
 mod pi_executable_mcp_red;
+mod pi_fork_session_inheritance_red;
 mod pi_lifecycle_doctor_red;
 mod pi_session_delivery_red;
 mod quick_start_worker_readiness_red;

package/crates/team-agent/src/lifecycle/types.rs

@@ -605,8 +605,8 @@ pub struct AddAgentReport {
     pub role_file: PathBuf,
 }
 
-/// `fork_agent(...)` 结果(`operations.py:402`)。native session fork(provider 须
-/// supports_session_fork ∧ auth_mode!=compatible_api)。
+/// `fork_agent(...)` 结果。Pi 的 snapshot fork 附带可审计的 source/target backing 细节；
+/// 已支持的其他 provider 保持既有报告字段。
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ForkAgentReport {
     pub source_agent_id: AgentId,
@@ -614,6 +614,14 @@ pub struct ForkAgentReport {
     pub env: AgentActionEnvelope,
     pub session_id: Option<SessionId>,
     pub backing_state: ForkBackingState,
+    pub pi_fork: Option<PiForkDetails>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PiForkDetails {
+    pub source_session_id: SessionId,
+    pub session_id: SessionId,
+    pub backing_path: RolloutPath,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]

package/crates/team-agent/src/lifecycle/worker_command_context.rs

@@ -30,6 +30,9 @@ All communication must go through Team Agent MCP tools.
 - Teammate: {send_message}(to='<agent_id>', content='...')
 - Broadcast: {send_message}(to='*', content='...')
 - Complete: {report_result}(summary='...') — call exactly once
+- Optional roster/status: {get_team_status} — use only when useful; it is not a communication or completion prerequisite.
+
+Only these three Team Agent MCP tools are available. Lifecycle management remains on the separately authorized operator CLI.
 
 ## Rules:
 
@@ -55,7 +58,7 @@ pub(crate) struct WorkerCommandAgent {
     system_prompt_file: Option<String>,
     output_contract_format: Option<String>,
     communication_mode: CommunicationMode,
-    /// 0.5.66 bypass 单源:agent-level `dangerously_skip_permissions`(必填 bool)。
+    /// Missing `dangerously_skip_permissions` defaults to true; an explicit false remains respected.
     dangerously_skip_permissions: bool,
 }
 
@@ -107,9 +110,9 @@ impl WorkerCommandAgent {
                     .get("communication_mode")
                     .and_then(crate::model::yaml::Value::as_str),
             )?,
-            dangerously_skip_permissions: matches!(
+            dangerously_skip_permissions: !matches!(
                 agent.get("dangerously_skip_permissions"),
-                Some(crate::model::yaml::Value::Bool(true))
+                Some(crate::model::yaml::Value::Bool(false))
             ),
         })
     }
@@ -164,7 +167,7 @@ impl WorkerCommandAgent {
             dangerously_skip_permissions: agent
                 .get("dangerously_skip_permissions")
                 .and_then(serde_json::Value::as_bool)
-                .unwrap_or(false),
+                .unwrap_or(true),
         })
     }
 }
@@ -182,15 +185,20 @@ pub(crate) fn compile_worker_system_prompt(
     // C-1 cr verdict / B2 灵魂件 — identity 必须 FIRST(MUST-4 行为层守:空白上下文问
     // "你是谁"必须先答 Team Agent worker 身份)。runtime contract 跟后。
     let send_message = mcp_tool_name(agent.provider, "team_orchestrator", "send_message");
+    let get_team_status = if agent.provider == Provider::Pi {
+        r#"mcp({tool:"team_orchestrator_get_team_status", args:{}})"#.to_string()
+    } else {
+        format!("{}()", mcp_tool_name(agent.provider, "team_orchestrator", "get_team_status"))
+    };
     let report_result = if agent.provider == Provider::Pi {
         r#"mcp({tool:"team_orchestrator_report_result", args:{summary:"..."}})"#.to_string()
     } else {
         mcp_tool_name(agent.provider, "team_orchestrator", "report_result")
     };
     let runtime_contract = if agent.provider == Provider::Pi {
-        pi_runtime_contract_section()
+        pi_runtime_contract_section(&get_team_status)
     } else {
-        runtime_contract_section(&send_message, &report_result)
+        runtime_contract_section(&send_message, &report_result, &get_team_status)
     };
     let communication_contract = if agent.provider == Provider::Pi {
         pi_communication_contract(agent.communication_mode)
@@ -241,13 +249,18 @@ fn mcp_tool_name(provider: Provider, server: &str, tool: &str) -> String {
     }
 }
 
-fn runtime_contract_section(send_message: &str, report_result: &str) -> String {
+fn runtime_contract_section(
+    send_message: &str,
+    report_result: &str,
+    get_team_status: &str,
+) -> String {
     RUNTIME_CONTRACT_SECTION
         .replace("{send_message}", send_message)
         .replace("{report_result}", report_result)
+        .replace("{get_team_status}", get_team_status)
 }
 
-fn pi_runtime_contract_section() -> String {
+fn pi_runtime_contract_section(get_team_status: &str) -> String {
     RUNTIME_CONTRACT_SECTION
         .replace(
             "{send_message}(to='<agent_id>', content='...')",
@@ -261,6 +274,7 @@ fn pi_runtime_contract_section() -> String {
             "{report_result}(summary='...')",
             r#"mcp({tool:"team_orchestrator_report_result", args:{summary:"..."}})"#,
         )
+        .replace("{get_team_status}", get_team_status)
 }
 
 fn pi_communication_contract(mode: CommunicationMode) -> String {

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

@@ -40,22 +40,6 @@ pub fn is_worker_recipient(to: &MessageTarget) -> bool {
     }
 }
 
-/// `_merge_tasks_by_id` (`tools.py:30-49`): dedupe a task list keyed by `id`,
-/// `prefer` entries winning on duplicates (so an earlier `done` is not regressed).
-pub fn merge_tasks_by_id(prefer: &[Value], fallback: &[Value]) -> Vec<Value> {
-    let mut seen = std::collections::BTreeSet::new();
-    let mut out = Vec::new();
-    for item in prefer.iter().chain(fallback.iter()) {
-        let Some(id) = item.get("id").and_then(Value::as_str) else {
-            continue;
-        };
-        if seen.insert(id.to_string()) && item.is_object() {
-            out.push(item.clone());
-        }
-    }
-    out
-}
-
 pub(crate) fn tool_error_reason_wire(reason: ToolErrorReason) -> &'static str {
     match reason {
         ToolErrorReason::UnknownTool => "unknown_tool",

package/crates/team-agent/src/mcp_server/lifecycle_tools/mod.rs

@@ -1,11 +1,6 @@
 //!
-//! MCP lifecycle tool facades.
-//!
-//! S0 keeps the old placeholder behavior behind stable module boundaries so
-//! follow-up lanes can implement real lifecycle logic without touching tools.rs.
+//! MCP status query facade.
 
-mod agent_ops;
 mod state_status;
 
-pub(crate) use agent_ops::{clone_agent, fork_agent, reset_agent, stop_agent};
-pub(crate) use state_status::{get_team_status, update_state};
+pub(crate) use state_status::get_team_status;

package/crates/team-agent/src/mcp_server/lifecycle_tools/state_status.rs

@@ -5,135 +5,9 @@ use serde_json::Value;
 
 use crate::model::ids::TeamKey;
 
-use super::super::helpers::{ensure_object, object_fields, tool_runtime_error};
+use super::super::helpers::{object_fields, tool_runtime_error};
 use super::super::{ToolOk, ToolResult};
 
-pub(crate) fn update_state(
-    workspace: &Path,
-    owner_team: Option<&TeamKey>,
-    note: &str,
-) -> ToolResult {
-    let selected = match crate::state::selector::resolve_active_team(
-        workspace,
-        owner_team.map(TeamKey::as_str),
-        crate::state::selector::SelectorMode::RequireSpec,
-    ) {
-        Ok(selected) => selected,
-        Err(err) if is_missing_active_spec(&err) => {
-            return update_state_without_spec(workspace, owner_team, note);
-        }
-        Err(err) => return Err(tool_runtime_error(err)),
-    };
-    let state = crate::state::repository::StateRepository::new(&selected.run_workspace).commit(
-        crate::state::repository::StateWriteIntent::McpUpdateStateNote {
-            team_key: Some(&selected.team_key),
-        },
-        |latest| {
-            ensure_object(latest);
-            append_note(latest, note);
-        },
-    )
-    .map_err(tool_runtime_error)?;
-    let spec_path = selected
-        .spec_path
-        .ok_or_else(|| tool_runtime_error("active team spec not found for update_state"))?;
-    let spec_workspace = spec_path.parent().ok_or_else(|| {
-        tool_runtime_error(format!(
-            "active team spec has no parent: {}",
-            spec_path.display()
-        ))
-    })?;
-    let spec_text = std::fs::read_to_string(&spec_path).map_err(tool_runtime_error)?;
-    let spec = crate::model::yaml::loads(&spec_text).map_err(tool_runtime_error)?;
-    let path = crate::lifecycle::restart::write_team_state(spec_workspace, &spec, &state)
-        .map_err(tool_runtime_error)?;
-    Ok(update_state_ok(path))
-}
-
-fn update_state_without_spec(
-    workspace: &Path,
-    owner_team: Option<&TeamKey>,
-    note: &str,
-) -> ToolResult {
-    let selected = crate::state::selector::resolve_active_team(
-        workspace,
-        owner_team.map(TeamKey::as_str),
-        crate::state::selector::SelectorMode::RuntimeOnly,
-    )
-    .map_err(tool_runtime_error)?;
-    let state = crate::state::repository::StateRepository::new(&selected.run_workspace).commit(
-        crate::state::repository::StateWriteIntent::McpUpdateStateNote {
-            team_key: Some(&selected.team_key),
-        },
-        |latest| {
-            ensure_object(latest);
-            seed_legacy_team_key(latest, &selected.run_workspace, &selected.team_key);
-            append_note(latest, note);
-        },
-    )
-    .map_err(tool_runtime_error)?;
-    let path = crate::lifecycle::restart::write_team_state(
-        &selected.run_workspace,
-        &crate::model::yaml::Value::Null,
-        &state,
-    )
-    .map_err(tool_runtime_error)?;
-    Ok(update_state_ok(path))
-}
-
-fn append_note(state: &mut Value, note: &str) {
-    if let Some(obj) = state.as_object_mut() {
-        let notes = obj
-            .entry("notes".to_string())
-            .or_insert_with(|| Value::Array(Vec::new()));
-        if !notes.is_array() {
-            *notes = Value::Array(Vec::new());
-        }
-        if let Some(items) = notes.as_array_mut() {
-            items.push(Value::String(note.to_string()));
-        }
-    }
-}
-
-fn seed_legacy_team_key(state: &mut Value, run_workspace: &Path, team_key: &str) {
-    if state.get("team_dir").and_then(Value::as_str).is_some()
-        || state.get("spec_path").and_then(Value::as_str).is_some()
-        || state.get("session_name").and_then(Value::as_str).is_some()
-    {
-        return;
-    }
-    if let Some(obj) = state.as_object_mut() {
-        obj.insert(
-            "team_dir".to_string(),
-            Value::String(
-                run_workspace
-                    .join(".team")
-                    .join(team_key)
-                    .to_string_lossy()
-                    .to_string(),
-            ),
-        );
-    }
-}
-
-fn update_state_ok(path: std::path::PathBuf) -> ToolOk {
-    let mut fields = serde_json::Map::new();
-    fields.insert("ok".to_string(), Value::Bool(true));
-    fields.insert(
-        "state_file".to_string(),
-        Value::String(path.to_string_lossy().to_string()),
-    );
-    ToolOk { fields }
-}
-
-fn is_missing_active_spec(err: &crate::state::StateError) -> bool {
-    matches!(
-        err,
-        crate::state::StateError::TeamSelect(message)
-            if message.starts_with("active team spec not found:")
-    )
-}
-
 pub(crate) fn get_team_status(workspace: &Path, owner_team: Option<&TeamKey>) -> ToolResult {
     let selected = crate::state::selector::resolve_active_team(
         workspace,

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

@@ -4,8 +4,8 @@
 //! Card: `docs/phase0/subsystems/14-mcp_cli.md` (MCP half).
 //! Truth source (READ-ONLY) `team-agent-public` @ v0.2.11 / `439bef8`:
 //!   - `mcp_server/server.py`    — stdio loop + JSON-RPC route (`dispatch`/`handle_mcp`/`main`)
-//!   - `mcp_server/tools.py`     — `TeamOrchestratorTools`: the 12 typed tool handlers
-//!   - `mcp_server/contracts.py` — `TOOLS`: name/description/inputSchema (wire single-truth)
+//!   - `mcp_server/tools.py`     — `TeamOrchestratorTools`: the three retained handlers
+//!   - `mcp_server/contracts.py` — retained tool names/descriptions/inputSchema
 //!   - `mcp_server/normalize.py` — result envelope / compact-result regularization
 //!   - `mcp_server/__init__.py`  — package re-export surface locked by boundary tests
 //!
@@ -17,13 +17,9 @@
 //! `unimplemented!("step14 port: …")`.
 //!
 //! REUSE (do NOT redefine):
-//!   - [`MessageStore`] (step 7) — `request_human` creates the leader message row.
-//!   - [`EventLog`] (step 4) — `mcp.scope_resolved` / `mcp.send_message_refused` /
-//!     `mcp.identity_inference_failed` / `mcp.task_inference_failed` audit events.
-//!   - [`load_runtime_state`] / [`save_runtime_state`] (step 5 persist) — `assign_task`
-//!     / `update_state` read-modify-write; `get_visible_peers` reads team scope.
-//!   - [`messaging`] (step 11) — `send_message` / auto-finalizing `report_result` /
-//!     `stuck_list` / `stuck_cancel` delegated by the tool handlers.
+//!   - [`EventLog`] (step 4) — retained message/result audit events.
+//!   - [`load_runtime_state`] (step 5 persist) — message scope and peer checks.
+//!   - [`messaging`] (step 11) — `send_message` and durable `report_result` delegation.
 //!   - [`crate::model::enums`] (step 2) — [`ResultStatus`] / [`ChangeKind`] /
 //!     [`TestStatus`] / [`RiskSeverity`] are the normalized result-envelope value
 //!     enums; this layer ONLY does string-alias regularization onto them.
@@ -43,9 +39,8 @@
 //!     a frame here would corrupt the stdout JSON-RPC stream.
 //!   - **stdout 是传输通道** (server.py:135): every error is surfaced ON stdout as a
 //!     JSON-RPC frame; logs/warnings MUST go to stderr/file, never stdout.
-//!   - **worker-recipient 异步 accepted** (tools.py:176-183): a worker recipient with
-//!     a message_id → [`SendOutcome::WorkerAccepted`] carrying the byte-stable
-//!     `poll_via = "team-agent inbox <id>"`; leader/`*` → [`SendOutcome::Direct`].
+//!   - **worker-recipient 异步 accepted**: a worker recipient with a message_id →
+//!     [`SendOutcome::WorkerAccepted`]; leader/`*` → [`SendOutcome::Direct`].
 //!   - **兜底字符串字节级保留** (bug-085): `_infer_task_id` failure → `"manual"` (not
 //!     None); `_infer_agent_id` failure → `None` → caller routes to `"unknown"`.
 //!

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

@@ -1,72 +1,4 @@
-/// ---
-/// purpose: scoped MCP no-compaction update_state filesystem contract
-/// contract:
-///   provides:
-///     - name: update_state_path_contracts
-///       what: proves the raw no-compaction response preserves its state-file path in an owned fixture
-///   depends:
-///     - name: mcp_state_fixture
-///       what: fixture-owned root and provenance from tests.rs
-/// boundary:
-///   - retain the raw {ok,state_file} result shape
-///   - the owned selector checks workspace, state-file, and runtime paths remain fixture-owned
-/// maturity: wired
-/// ---
-
-fn verify_cleanup_surviving_receipt(
-    receipt_path: &std::path::Path,
-    raw_workspace: &std::path::Path,
-    canonical_workspace: &std::path::Path,
-    state_file: &std::path::Path,
-    runtime_state: &std::path::Path,
-) {
-    let bytes = std::fs::read(receipt_path)
-        .expect("provenance receipt must survive fixture Drop");
-    let receipt: Value = serde_json::from_slice(&bytes).expect("provenance receipt must be JSON");
-    assert_eq!(receipt["schema"], json!("mcp-state-provenance-v1"));
-    let payload = &receipt["payload"];
-    let payload_bytes = serde_json::to_vec(payload).unwrap();
-    assert_eq!(
-        receipt["payload_sha256"],
-        json!(format!("{:x}", sha2::Sha256::digest(&payload_bytes)))
-    );
-    assert_eq!(
-        payload["raw_workspace"],
-        json!(raw_workspace.display().to_string())
-    );
-    assert_eq!(
-        payload["canonical_workspace"],
-        json!(canonical_workspace.display().to_string())
-    );
-    assert_eq!(
-        payload["resolved_state_file"],
-        json!(state_file.display().to_string())
-    );
-    assert_eq!(
-        payload["runtime_state_path"],
-        json!(runtime_state.display().to_string())
-    );
-    let facts = payload["facts"].as_array().unwrap();
-    for name in [
-        "root",
-        "raw_workspace",
-        "canonical_workspace",
-        "team_dir",
-        "runtime_dir",
-        "state_parent",
-        "runtime_state",
-        "state_file",
-    ] {
-        let fact = facts
-            .iter()
-            .find(|fact| fact["name"] == json!(name))
-            .unwrap_or_else(|| panic!("provenance fact missing: {name}"));
-        assert!(fact["path"].as_str().is_some());
-        assert!(fact["uid"].as_u64().is_some());
-        assert!(fact["mode"].as_u64().is_some());
-        assert!(fact["device"].as_u64().is_some());
-    }
-}
+/// Scoped retained-tool contracts exercise owner binding and team isolation.
 
     #[test]
     fn dispatch_send_message_worker_accepted_returned_verbatim() {
@@ -100,69 +32,6 @@ fn verify_cleanup_surviving_receipt(
         assert_eq!(v.get("poll_via"), Some(&json!(format!("team-agent inbox {mid}"))));
     }
 
-    // ── #32/#47 request_human key order ok,message_id,status (no compaction) ────
-    // GOLDEN (probe_events_red.py REQUEST_HUMAN-KEYS): ['ok','message_id','status'].
-    // Rust compact_tool_result reorders to ok,status,message_id.
-    #[test]
-    fn request_human_key_order_is_ok_message_id_status() {
-        let tools = TeamOrchestratorTools::with_identity(
-            &unique_ws("reqhuman-order"),
-            Some(AgentId::new("worker-3")),
-            None,
-        );
-        let ok = tools.request_human("need approval", Some("task-1"), None).expect("request_human ok");
-        let v = serde_json::to_value(&ok).unwrap();
-        assert_eq!(keys(&v), vec!["ok", "message_id", "status"]);
-        assert_eq!(v.get("status"), Some(&json!("needs_human")));
-    }
-
-    // ── #32 update_state returns RAW {ok, state_file} (NO compaction) ───────────
-    // GOLDEN (tools.py:316-325 + probe_passthrough): update_state is NOT compacted;
-    // state_file survives. Rust runs compact_tool_result whose ok-whitelist DROPS
-    // state_file (not a golden whitelist key), so the key vanishes.
-    #[test]
-    fn update_state_state_file_survives_no_compaction() {
-        let fixture = McpStateFixture::new("writable");
-        let expected = fixture.state_file("team_state.md");
-        let tools = TeamOrchestratorTools::with_identity(
-            &fixture.workspace,
-            Some(AgentId::new("leader")),
-            None,
-        );
-        let ok = tools.update_state("note").expect("update_state ok");
-        let v = serde_json::to_value(&ok).unwrap();
-        assert!(v.get("state_file").and_then(Value::as_str).is_some(),
-            "state_file must survive (update_state is not _compact_tool_result'd)");
-        assert_eq!(keys(&v), vec!["ok", "state_file"]);
-        let returned_state_file = PathBuf::from(v["state_file"].as_str().unwrap());
-        assert_eq!(returned_state_file, expected);
-        let runtime_state = crate::state::persist::runtime_state_path(&fixture.workspace);
-        assert!(fixture.under_root(&returned_state_file));
-        assert!(fixture.under_root(&runtime_state));
-        let canonical_workspace =
-            crate::model::paths::canonical_run_workspace(&fixture.workspace).unwrap();
-        let receipt = fixture.record_provenance(&fixture.workspace, &returned_state_file);
-        let root = fixture.root.clone();
-        drop(fixture);
-        assert!(!root.exists(), "fixture root must be removed before receipt verification");
-        verify_cleanup_surviving_receipt(
-            &receipt,
-            &root.join("workspace"),
-            &canonical_workspace,
-            &returned_state_file,
-            &runtime_state,
-        );
-        let receipt_bytes = std::fs::read(&receipt).unwrap();
-        println!(
-            "F10_PROVENANCE_RECEIPT path={} sha256={:x} payload={}",
-            receipt.display(),
-            sha2::Sha256::digest(&receipt_bytes),
-            String::from_utf8_lossy(&receipt_bytes)
-        );
-        std::fs::remove_file(&receipt).unwrap();
-        assert!(!receipt.exists(), "cleanup must remove only the exact receipt path");
-    }
-
     // ── #36 report_result identity: neither envelope nor args can override capture ─
     #[test]
     fn report_result_rejects_envelope_and_argument_identity_mismatch() {

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

@@ -43,31 +43,6 @@ fn is_worker_recipient_classification() {
     ])));
 }
 
-// ════════════════════════════════════════════════════════════════════════
-// merge_tasks_by_id — prefer wins, prefer-first insertion order (tools.py:30)
-// Golden: prefer t1(done),t2 + fallback t1(pending),t3,{no id},"notdict"
-//   → [t1(done), t2, t3]  (t1 from prefer wins; non-dict / no-id dropped)
-// ════════════════════════════════════════════════════════════════════════
-#[test]
-fn merge_tasks_by_id_prefer_wins_no_done_regression() {
-    let prefer = vec![
-        json!({"id": "t1", "status": "done"}),
-        json!({"id": "t2", "status": "pending"}),
-    ];
-    let fallback = vec![
-        json!({"id": "t1", "status": "pending"}), // must NOT regress t1
-        json!({"id": "t3", "status": "ready"}),
-        json!({"no": "id"}), // dropped (no id)
-        json!("notdict"),    // dropped (not object)
-    ];
-    let merged = merge_tasks_by_id(&prefer, &fallback);
-    assert_eq!(merged.len(), 3);
-    assert_eq!(merged[0]["id"], json!("t1"));
-    assert_eq!(merged[0]["status"], json!("done")); // prefer wins → no regression
-    assert_eq!(merged[1]["id"], json!("t2"));
-    assert_eq!(merged[2]["id"], json!("t3"));
-}
-
 // ════════════════════════════════════════════════════════════════════════
 // SendOutcome::to_value — worker-accepted async envelope (tools.py:177-182)
 // byte-stable: {status:"accepted",delivery_pending:true,
@@ -171,7 +146,7 @@ fn send_message_worker_recipient_returns_accepted_with_poll_hint() {
 }
 
 #[test]
-fn ordinary_send_assign_shape_has_no_recovery_marker() {
+fn ordinary_send_shape_has_no_recovery_marker() {
     let ws = seed_current_worker_state("ordinary-no-recovery");
     let tools = TeamOrchestratorTools::with_identity(
         &ws,
@@ -198,46 +173,6 @@ fn ordinary_send_assign_shape_has_no_recovery_marker() {
         "ordinary send must not carry acceptance marker: {sent}"
     );
 
-    let assigned = tools
-        .assign_task(
-            &json!({"id": "ordinary-task", "assignee": "worker-1", "title": "ordinary"}),
-            None,
-        )
-        .expect("ordinary assign ok");
-    let assigned_value = serde_json::to_value(&assigned).expect("serialize ordinary assign");
-    assert!(
-        !assigned_value.as_object().unwrap().contains_key("recovery"),
-        "ordinary assign must not carry recovery marker: {assigned_value}"
-    );
-    assert!(
-        assigned_value.get("acceptance_marker").is_none(),
-        "ordinary assign must not carry acceptance marker: {assigned_value}"
-    );
-
-    let recovery_false_assigned = tools
-        .assign_task(
-            &json!({
-                "id": "ordinary-recovery-false-task",
-                "assignee": "worker-1",
-                "title": "ordinary recovery false",
-                "recovery": false,
-            }),
-            None,
-        )
-        .expect("recovery=false assign ok");
-    let recovery_false_value =
-        serde_json::to_value(&recovery_false_assigned).expect("serialize recovery=false assign");
-    assert!(
-        !recovery_false_value
-            .as_object()
-            .unwrap()
-            .contains_key("recovery"),
-        "recovery=false assign must not carry recovery marker: {recovery_false_value}"
-    );
-    assert!(
-        recovery_false_value.get("acceptance_marker").is_none(),
-        "recovery=false assign must not carry acceptance marker: {recovery_false_value}"
-    );
 }
 
 #[test]
@@ -256,33 +191,6 @@ fn send_message_without_framework_identity_fails_closed() {
     assert_eq!(error.reason, ToolErrorReason::McpScopeRefused);
 }
 
-#[test]
-fn recovery_assign_shape_has_structured_marker() {
-    let ws = seed_current_worker_state("recovery-marker");
-    let tools = TeamOrchestratorTools::with_identity(
-        &ws,
-        Some(AgentId::new("leader")),
-        Some(TeamKey::new("current")),
-    );
-
-    let assigned = tools
-        .assign_task(
-            &json!({
-                "id": "recovery-task",
-                "assignee": "worker-1",
-                "title": "recover",
-                "recovery": true,
-            }),
-            None,
-        )
-        .expect("recovery assign ok");
-    assert_eq!(assigned.fields.get("recovery"), Some(&json!(true)));
-    assert_eq!(
-        assigned.fields.get("acceptance_marker"),
-        Some(&json!("recovery"))
-    );
-}
-
 #[test]
 fn send_message_worker_recipient_surfaces_dead_coordinator_warning() {
     let ws = unique_ws("send-worker-dead-coord");