@team-agent/installer 0.5.29 → 0.5.32

package/crates/team-agent/src/cli/send.rs

@@ -615,120 +615,6 @@ fn named_target_kind_wire(kind: crate::cli::named_address::NamedTargetKind) -> &
     }
 }
 
-pub fn cmd_fallback_send_leader(args: &FallbackSendLeaderArgs) -> Result<CmdResult, CliError> {
-    if let Some(value) = fallback_business_refusal(&args.primary_error, args.json) {
-        return Ok(value);
-    }
-    let selected = crate::state::selector::resolve_active_team(
-        &args.workspace,
-        args.team.as_deref(),
-        crate::state::selector::SelectorMode::RuntimeOnly,
-    )?;
-    let target = MessageTarget::Single("leader".to_string());
-    let opts = SendOptions {
-        task_id: args.task.as_ref().map(|task| TaskId::new(task.clone())),
-        route_task_id: false,
-        sender: args.sender.clone(),
-        requires_ack: false,
-        wait_visible: false,
-        block_until_delivered: false,
-        team: Some(TeamKey::new(selected.team_key.clone())),
-        message_id: Some(args.message_id.clone()),
-        ..SendOptions::default()
-    };
-    let primary = messaging::send_message(&selected.run_workspace, &target, &args.content, &opts);
-    let message_id = match &primary {
-        Ok(outcome) => outcome
-            .message_id
-            .clone()
-            .unwrap_or_else(|| args.message_id.clone()),
-        Err(_) => args.message_id.clone(),
-    };
-    if let Ok(outcome) = &primary {
-        if is_business_refusal_outcome(outcome) {
-            let value = json!({
-                "ok": false,
-                "status": "refused",
-                "reason": "business_reject",
-                "primary_error": args.primary_error,
-                "message_id": outcome.message_id,
-                "action": "N38 fallback refused: business rule refusals must not use fallback pane delivery",
-            });
-            return Ok(CmdResult::from_json(value, args.json));
-        }
-    }
-
-    let state = selected_state_with_active_key(&selected);
-    let event_log = crate::event_log::EventLog::new(&selected.run_workspace);
-    let primary_error = match primary {
-        Ok(outcome) if primary_delivery_succeeded(outcome.status) => {
-            let mut value = delivery_outcome_json(&outcome, &target, &args.content, &opts);
-            if let Some(obj) = value.as_object_mut() {
-                obj.insert("fallback_used".to_string(), json!(false));
-                obj.insert("primary_error".to_string(), json!(args.primary_error));
-            }
-            return Ok(CmdResult::from_json(value, args.json));
-        }
-        Ok(outcome) => format!(
-            "{}; fallback_cli_primary_status={}",
-            args.primary_error,
-            delivery_status_wire(outcome.status)
-        ),
-        Err(error) => format!("{}; fallback_cli_primary_error={error}", args.primary_error),
-    };
-    let outcome = messaging::deliver_to_leader_fallback_pane(
-        &selected.run_workspace,
-        &state,
-        &message_id,
-        None,
-        &args.content,
-        false,
-        Some(&primary_error),
-        &event_log,
-    )?;
-    let mut value = delivery_outcome_json(&outcome, &target, &args.content, &opts);
-    if let Some(obj) = value.as_object_mut() {
-        obj.insert("primary_error".to_string(), json!(args.primary_error));
-        obj.insert("delivered_via".to_string(), json!("fallback_pane"));
-        obj.insert(
-            "next_action".to_string(),
-            json!("run team-agent restart-agent to refresh the worker MCP transport"),
-        );
-    }
-    Ok(CmdResult::from_json(value, args.json))
-}
-
-pub fn cmd_fallback_report_result(args: &FallbackReportResultArgs) -> Result<CmdResult, CliError> {
-    if let Some(value) = fallback_business_refusal(&args.primary_error, args.json) {
-        return Ok(value);
-    }
-    let selected = crate::state::selector::resolve_active_team(
-        &args.workspace,
-        args.team.as_deref(),
-        crate::state::selector::SelectorMode::RuntimeOnly,
-    )?;
-    let envelope = fallback_result_envelope(args)?;
-    let value = messaging::report_result_for_owner_team_with_primary_error(
-        &selected.run_workspace,
-        &envelope,
-        Some(&selected.team_key),
-        Some(&args.primary_error),
-    )?;
-    let mut value = value;
-    if let Some(obj) = value.as_object_mut() {
-        obj.insert("primary_error".to_string(), json!(args.primary_error));
-        obj.insert(
-            "fallback_protocol".to_string(),
-            json!("fallback-report-result"),
-        );
-        obj.insert(
-            "next_action".to_string(),
-            json!("run team-agent restart-agent to refresh the worker MCP transport"),
-        );
-    }
-    Ok(CmdResult::from_json(value, args.json))
-}
-
 fn routing_ambiguous_value(
     workspace: &Path,
     args: &SendArgs,
@@ -783,69 +669,6 @@ fn selected_state_with_active_key(selected: &crate::state::selector::SelectedTea
     state
 }
 
-fn fallback_result_envelope(args: &FallbackReportResultArgs) -> Result<Value, CliError> {
-    let mut envelope: Value = serde_json::from_str(&args.result_json)?;
-    let Some(obj) = envelope.as_object_mut() else {
-        return Err(CliError::Usage(
-            "--result-json must be a JSON object".to_string(),
-        ));
-    };
-    obj.entry("schema_version".to_string())
-        .or_insert_with(|| json!("result_envelope_v1"));
-    obj.entry("task_id".to_string())
-        .or_insert_with(|| json!(args.task_id));
-    obj.entry("agent_id".to_string())
-        .or_insert_with(|| json!(args.agent_id));
-    obj.entry("status".to_string())
-        .or_insert_with(|| json!("success"));
-    obj.entry("summary".to_string())
-        .or_insert_with(|| json!("completed"));
-    for key in ["changes", "tests", "risks", "artifacts", "next_actions"] {
-        obj.entry(key.to_string()).or_insert_with(|| json!([]));
-    }
-    Ok(envelope)
-}
-
-fn fallback_business_refusal(primary_error: &str, as_json: bool) -> Option<CmdResult> {
-    is_business_reject_text(primary_error).then(|| {
-        CmdResult::from_json(
-            json!({
-                "ok": false,
-                "status": "refused",
-                "reason": "business_reject",
-                "primary_error": primary_error,
-                "action": "N38 fallback refused: business rule refusals must not use fallback pane delivery",
-            }),
-            as_json,
-        )
-    })
-}
-
-fn is_business_refusal_outcome(outcome: &DeliveryOutcome) -> bool {
-    matches!(
-        outcome.reason,
-        Some(
-            DeliveryRefusal::TargetNotInTeam
-                | DeliveryRefusal::HumanConfirmationRequired
-                | DeliveryRefusal::MissingPermissions
-                | DeliveryRefusal::UnknownRecipient
-                | DeliveryRefusal::TeamOwnerMismatch
-                | DeliveryRefusal::Ambiguous
-                | DeliveryRefusal::RecipientPaneInNonInputMode
-                | DeliveryRefusal::SessionDrift
-                | DeliveryRefusal::RoutingAmbiguous
-                | DeliveryRefusal::EmptyTargetList
-        )
-    )
-}
-
-fn primary_delivery_succeeded(status: DeliveryStatus) -> bool {
-    matches!(
-        status,
-        DeliveryStatus::Delivered | DeliveryStatus::AlreadyDelivered
-    )
-}
-
 fn initial_delivery_allows_watch(status: DeliveryStatus) -> bool {
     matches!(
         status,
@@ -888,27 +711,6 @@ fn observe_initial_delivery_for_watch(
     .map_err(CliError::from)
 }
 
-fn is_business_reject_text(error: &str) -> bool {
-    let lower = error.to_ascii_lowercase();
-    [
-        "peer_not_in_scope",
-        "target_not_in_team",
-        "permission denied",
-        "missing_permissions",
-        "human_confirmation_required",
-        "unknown_recipient",
-        "routing_ambiguous",
-        "quota",
-        "rate limit",
-        "rate_limit",
-        "blacklist",
-        "blacklisted",
-        "forbidden",
-    ]
-    .iter()
-    .any(|needle| lower.contains(needle))
-}
-
 /// `_send_target`(`commands.py:181-184`):`--to` comma-split fanout / `target` 单值 / None。
 pub fn send_target(targets: Option<&str>, target: Option<&str>) -> MessageTarget {
     if let Some(targets) = targets.filter(|s| !s.is_empty()) {
@@ -1488,46 +1290,3 @@ pub fn send_to_canonical_leader_target(
     }
     Ok(value)
 }
-
-#[cfg(test)]
-mod e23_tests {
-    use super::*;
-
-    #[test]
-    fn fallback_error_classifier_allows_transport_and_primary_bugs() {
-        for error in [
-            "Transport closed",
-            "Connection refused",
-            "Broken pipe",
-            "EOF on transport",
-            "MCP timeout after 5s",
-            "internal assertion failed: unwrap on Err",
-            "primary_delivery_error: serialize failed",
-        ] {
-            assert!(
-                !is_business_reject_text(error),
-                "failure should be fallback-eligible, not classified as a business refusal: {error}"
-            );
-        }
-    }
-
-    #[test]
-    fn fallback_error_classifier_blocks_business_refusals() {
-        for error in [
-            "peer_not_in_scope",
-            "target_not_in_team",
-            "permission denied",
-            "missing_permissions",
-            "human_confirmation_required",
-            "unknown_recipient",
-            "quota exceeded",
-            "rate_limit",
-            "blacklisted target",
-        ] {
-            assert!(
-                is_business_reject_text(error),
-                "business refusal must not use fallback pane delivery: {error}"
-            );
-        }
-    }
-}

package/crates/team-agent/src/cli/spec.rs

@@ -45,8 +45,6 @@ pub(crate) enum DispatchKind {
     QuickStart,
     Compile,
     Send,
-    FallbackSendLeader,
-    FallbackReportResult,
     AllowPeerTalk,
     Status,
     Stop,
@@ -76,10 +74,7 @@ pub(crate) enum DispatchKind {
     Validate,
     InstallSkill,
     Profile,
-    ValidateResult,
     Collect,
-    Settle,
-    RepairState,
     Diagnose,
     Preflight,
     WaitReady,
@@ -93,8 +88,6 @@ pub(crate) const ALL_DISPATCH_KINDS: &[DispatchKind] = &[
     DispatchKind::QuickStart,
     DispatchKind::Compile,
     DispatchKind::Send,
-    DispatchKind::FallbackSendLeader,
-    DispatchKind::FallbackReportResult,
     DispatchKind::AllowPeerTalk,
     DispatchKind::Status,
     DispatchKind::Stop,
@@ -124,10 +117,7 @@ pub(crate) const ALL_DISPATCH_KINDS: &[DispatchKind] = &[
     DispatchKind::Validate,
     DispatchKind::InstallSkill,
     DispatchKind::Profile,
-    DispatchKind::ValidateResult,
     DispatchKind::Collect,
-    DispatchKind::Settle,
-    DispatchKind::RepairState,
     DispatchKind::Diagnose,
     DispatchKind::Preflight,
     DispatchKind::WaitReady,
@@ -185,15 +175,9 @@ pub(crate) const COMMAND_SPECS: &[CommandSpec] = &[
     CommandSpec { name: "start", tier: CommandTier::CompatHidden, category: CommandCategory::Compat, kind: CommandKind::SpecOnlyAlias { alias_of: "quick-start" }, summary: "legacy start alias", usage: "usage: team-agent start [TEAMDIR] [--yes] [--fresh] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::Conditional, alias_of: Some("quick-start"), sunset: Some("C2"), action: Some("use `team-agent quick-start` or `team-agent restart`"), governance: None },
     CommandSpec { name: "stop", tier: CommandTier::CompatHidden, category: CommandCategory::Compat, kind: CommandKind::Dispatch(DispatchKind::Stop), summary: "legacy shutdown alias", usage: "usage: team-agent stop [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: Some("shutdown"), sunset: Some("C2"), action: Some("use `team-agent shutdown`"), governance: None },
     CommandSpec { name: "restart-agent", tier: CommandTier::CompatHidden, category: CommandCategory::Compat, kind: CommandKind::Dispatch(DispatchKind::RestartAgent), summary: "legacy reset-agent alias", usage: "usage: team-agent restart-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--discard-session] [--no-display] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::Conditional, alias_of: Some("reset-agent"), sunset: Some("C2"), action: Some("use `team-agent reset-agent`"), governance: None },
-    CommandSpec { name: "fallback-send-leader", tier: CommandTier::CompatHidden, category: CommandCategory::Compat, kind: CommandKind::Dispatch(DispatchKind::FallbackSendLeader), summary: "legacy leader send fallback", usage: "usage: team-agent fallback-send-leader --workspace WORKSPACE --team TEAM --sender AGENT --message-id ID --content TEXT --primary-error ERROR [--task TASK] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: Some("C2"), action: Some("use `team-agent send` and `team-agent diagnose`"), governance: None },
-    CommandSpec { name: "fallback-report-result", tier: CommandTier::CompatHidden, category: CommandCategory::Compat, kind: CommandKind::Dispatch(DispatchKind::FallbackReportResult), summary: "legacy report_result fallback", usage: "usage: team-agent fallback-report-result --workspace WORKSPACE --team TEAM --agent-id AGENT --task-id TASK --result-json JSON --primary-error ERROR [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: Some("C2"), action: Some("use `team-agent collect` or MCP `report_result`"), governance: None },
-    CommandSpec { name: "settle", tier: CommandTier::CompatHidden, category: CommandCategory::Compat, kind: CommandKind::Dispatch(DispatchKind::Settle), summary: "legacy settle helper", usage: "usage: team-agent settle [--workspace WORKSPACE] [--team TEAM] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: Some("C2"), action: Some("use `team-agent collect`"), governance: None },
-    CommandSpec { name: "validate-result", tier: CommandTier::CompatHidden, category: CommandCategory::Compat, kind: CommandKind::Dispatch(DispatchKind::ValidateResult), summary: "legacy result validation helper", usage: "usage: team-agent validate-result [ENVELOPE] [--file FILE|--result JSON] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: Some("C2"), action: Some("use report_result validation through normal `team-agent collect` flow"), governance: None },
     CommandSpec { name: "stuck-list", tier: CommandTier::CompatHidden, category: CommandCategory::Compat, kind: CommandKind::Dispatch(DispatchKind::StuckList), summary: "legacy stuck alert listing", usage: "usage: team-agent stuck-list [--workspace WORKSPACE] [--team TEAM] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: Some("C2"), action: Some("use `team-agent diagnose`"), governance: None },
     CommandSpec { name: "stuck-cancel", tier: CommandTier::CompatHidden, category: CommandCategory::Compat, kind: CommandKind::Dispatch(DispatchKind::StuckCancel), summary: "legacy stuck alert suppression", usage: "usage: team-agent stuck-cancel AGENT [--workspace WORKSPACE] [--alert-type stuck|idle_fallback|cross_worker_deadlock|all] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: Some("C2"), action: Some("use the concrete notification action or `team-agent diagnose`"), governance: None },
     CommandSpec { name: "acknowledge-idle", tier: CommandTier::CompatHidden, category: CommandCategory::Compat, kind: CommandKind::Dispatch(DispatchKind::AcknowledgeIdle), summary: "legacy idle acknowledgement", usage: "usage: team-agent acknowledge-idle [--workspace WORKSPACE] [--team TEAM] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: Some("C2"), action: Some("use the concrete idle notification action or `team-agent diagnose`"), governance: None },
-
-    CommandSpec { name: "repair-state", tier: CommandTier::Guided, category: CommandCategory::GuidedRecovery, kind: CommandKind::Dispatch(DispatchKind::RepairState), summary: "guided state repair helper", usage: "usage: team-agent repair-state --task TASK --status STATUS [SUMMARY] [--assignee AGENT] [--workspace WORKSPACE] [--team TEAM] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "leaders", tier: CommandTier::Secondary, category: CommandCategory::Observe, kind: CommandKind::Dispatch(DispatchKind::Leaders), summary: "inspect registered host leaders", usage: "usage: team-agent leaders [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "doctor", tier: CommandTier::Secondary, category: CommandCategory::Setup, kind: CommandKind::Dispatch(DispatchKind::Doctor), summary: "run host maintenance checks", usage: "usage: team-agent doctor [SPEC] [--workspace WORKSPACE] [--team TEAM] [--gate orphans|comms] [--comms] [--fix] [--fix-schema] [--cleanup-orphans] [--confirm] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "attach-app-server-leader", tier: CommandTier::Guided, category: CommandCategory::GuidedRecovery, kind: CommandKind::Dispatch(DispatchKind::AttachAppServerLeader), summary: "bind an app-server leader receiver", usage: "usage: team-agent attach-app-server-leader [--workspace WORKSPACE] [--team TEAM] --socket unix:///path.sock --thread-id THREAD_ID [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },

package/crates/team-agent/src/cli/tests/main_preserved.rs

@@ -597,27 +597,6 @@ fn seed_team_spec(ws: &std::path::Path) {
         );
     }
     #[test]
-    fn validate_result_file_good_and_inline_garbage_are_distinct() {
-        let ws = tmp_workspace();
-        let envelope_path = ws.join("result.json");
-        std::fs::write(&envelope_path, valid_result_envelope().to_string()).unwrap();
-        let good = run(
-            &cli_argv(&["validate-result", "--file", &envelope_path.to_string_lossy(), "--json"]),
-            &ws,
-        );
-        assert_eq!(
-            good,
-            ExitCode::Ok,
-            "Python cmd_validate_result accepts --file and returns {{ok:true,task_id,agent_id,status}} for a valid envelope"
-        );
-        let garbage = run(&cli_argv(&["validate-result", "{garbage", "--json"]), &ws);
-        assert_eq!(
-            garbage,
-            ExitCode::Error,
-            "garbage JSON must be invalid, not indistinguishable from the good-envelope path"
-        );
-    }
-    #[test]
     fn collect_uncollected_result_marks_db_and_outputs_result() {
         let ws = tmp_workspace();
         seed_collect_state(&ws);
@@ -784,42 +763,3 @@ fn seed_team_spec(ws: &std::path::Path) {
             "acknowledge-idle must emit coordinator.idle_acknowledged"
         );
     }
-    #[test]
-    fn repair_state_done_persists_after_status_and_summary() {
-        let ws = tmp_workspace();
-        seed_collect_state(&ws);
-        let out = json_output(
-            cmd_repair_state(&RepairStateArgs {
-                workspace: ws.clone(),
-                task_id: "task_impl".to_string(),
-                assignee: None,
-                status: "done".to_string(),
-                summary: Some("manual repair accepted".to_string()),
-                json: true,
-                team: None,
-            })
-            .expect("repair-state should not fail on a valid runtime state"),
-        );
-        assert_eq!(out["ok"], json!(true));
-        assert_eq!(
-            out["after"]["status"],
-            json!("done"),
-            "repair-state --status done must return after.status=done; ok:true with null after fields is a false success"
-        );
-        assert_eq!(out["after"]["assignee"], json!("fake_impl"));
-        assert_eq!(out["after"]["last_result_summary"], json!("manual repair accepted"));
-        let state = read_state(&ws);
-        let task = state["tasks"]
-            .as_array()
-            .unwrap()
-            .iter()
-            .find(|task| task["id"] == json!("task_impl"))
-            .unwrap();
-        assert_eq!(
-            task["status"],
-            json!("done"),
-            "repair-state --status done must persist the task status, not only emit a success envelope"
-        );
-        assert_eq!(task["last_result_summary"], json!("manual repair accepted"));
-        let _ = std::fs::remove_dir_all(&ws);
-    }

package/crates/team-agent/src/cli/tests/missing_subcommands.rs

@@ -38,9 +38,9 @@ impl Drop for WorkspaceCleanup {
 }
 
     // =========================================================================
-    // WAVE-2 NON-SUB CHECKPOINT — 9 MISSING CLI subcommands (ABSENT from cli/emit.rs dispatch).
-    // emit.rs:53-78 `dispatch` has NO arm for: sessions, peek, collect, e2e, diagnose, repair-state,
-    // validate-result, preflight, wait-ready -> they fall to `_ => Ok(ExitCode::Error)`. These REDs
+    // WAVE-2 NON-SUB CHECKPOINT — missing CLI subcommands (ABSENT from cli/emit.rs dispatch).
+    // emit.rs `dispatch` has NO arm for sessions, peek, collect, e2e, diagnose,
+    // preflight, wait-ready -> they fall to `_ => Ok(ExitCode::Error)`. These REDs
     // assert the dispatch ROUTES each subcommand: `run([sub,...]) == ExitCode::Ok` for a golden
     // EXIT-0 scenario (today unrouted -> ExitCode::Error -> RED; green once the porter adds the
     // dispatch arm + handler). Golden exit codes + JSON shapes probed via `python3 -m team_agent <sub>`.
@@ -63,7 +63,7 @@ impl Drop for WorkspaceCleanup {
 
     /// The exact golden fake spec (cli/e2e.py `_fake_spec`, dumped via simple_yaml) with the literal
     /// `/WS` placeholder substituted to the real workspace — the minimal VALID team.spec.yaml that
-    /// `collect`/`repair-state` (load_spec) accept. (load_spec rejects partial specs: requires
+    /// `collect` accepts. (load_spec rejects partial specs: requires
     /// communication/context/leader/routing/runtime/tasks.)
     const FAKE_SPEC_YAML: &str = r#"version: 1
 team:
@@ -214,22 +214,6 @@ tasks:
         let _ = std::fs::remove_dir_all(&ws);
     }
 
-    // ── validate-result ── golden parser.py:312 `cmd_validate_result` (commands.py:206). A FULL valid
-    // result_envelope_v1 -> {"agent_id":"a1","ok":true,"status":"success","task_id":"t1"} EXIT 0.
-    // RED: unrouted -> Error. (A partial envelope golden-exits 1 — that would be false-green, so the
-    // RED uses the complete envelope that golden accepts.)
-    #[test]
-    fn dispatch_routes_validate_result_valid_envelope() {
-        let envelope = r#"{"schema_version":"result_envelope_v1","task_id":"t1","agent_id":"a1","status":"success","summary":"done","artifacts":[],"changes":[],"tests":[],"risks":[],"next_actions":[]}"#;
-        let code = run(&cli_argv(&["validate-result", envelope, "--json"]), std::path::Path::new("."));
-        assert_eq!(
-            code,
-            ExitCode::Ok,
-            "`validate-result <valid envelope> --json` must ROUTE to cmd_validate_result (parser.py:312) \
-             and exit 0 with {{agent_id,ok,status,task_id}}; today -> unknown-subcommand Error"
-        );
-    }
-
     // ── collect ── golden parser.py:292 `cmd_collect` -> runtime.collect(ws). With a valid
     // team.spec.yaml present and nothing to collect -> EXIT 0, golden:
     //   {"collected":[],"collected_results":[],"coordinator":{"ok":false,"status":"not_required"},
@@ -265,40 +249,6 @@ tasks:
         );
     }
 
-    // ── repair-state ── golden parser.py:303 `cmd_repair_state` -> runtime.repair_state (quick_start.py:285).
-    // `--task <id>` required; `--status` must be in TASK_STATUSES{blocked,cancelled,done,failed,
-    // needs_retry,pending,ready,running}. With a seeded task + --status done -> EXIT 0:
-    //   {"after":{...},"before":{...},"ok":true,"state_file":"<ws>/team_state.md","task_id":"fake_impl"}
-    // RED: unrouted -> Error.
-    #[test]
-    fn dispatch_routes_repair_state_with_task() {
-        let ws = tmp_workspace();
-        seed_team_spec(&ws);
-        std::fs::write(
-            ws.join(".team").join("runtime").join("state.json"),
-            serde_json::to_vec(&json!({
-                "leader": {"id": "leader"},
-                "tasks": [{"id": "fake_impl", "title": "impl", "status": "open", "assignee": "fake_impl", "type": "implementation"}],
-            }))
-            .unwrap(),
-        )
-        .unwrap();
-        let code = run(
-            &cli_argv(&[
-                "repair-state", "--workspace", &ws.to_string_lossy(),
-                "--task", "fake_impl", "--status", "done", "--summary", "ok", "--json",
-            ]),
-            &ws,
-        );
-        assert_eq!(
-            code,
-            ExitCode::Ok,
-            "`repair-state --task <id> --status done` must ROUTE to cmd_repair_state (parser.py:303) and \
-             exit 0 {{after,before,ok,state_file,task_id}}; today -> unknown-subcommand Error"
-        );
-        let _ = std::fs::remove_dir_all(&ws);
-    }
-
     // ── diagnose ── golden parser.py:298 `cmd_diagnose` -> runtime.diagnose(ws) (diagnose/health.py:19).
     // ok:true only when there are zero issues. Seed leader_receiver=attached + NO session_name + NO
     // agents -> issues=[] -> EXIT 0, golden top keys (sort): event_log,issues,ok,runtime,suggested_repairs.

package/crates/team-agent/src/cli/tests/mod.rs

@@ -88,12 +88,10 @@ mod lane_c;
 mod leader_watch;
 mod missing_subcommands;
 mod named_address;
-mod repair_state_byte_lock;
 mod peer_allow;
 mod run_delegation;
 mod status_send;
 mod verb_validate;
-mod verb_settle;
 mod verb_profile;
 mod verb_install_skill;
 mod main_preserved;

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

@@ -49,7 +49,7 @@ pub enum CliError {
     /// I/O(cli-error 落盘、inbox 游标读写)。bug-084:写路径降级,不裸 panic。
     #[error("io: {0}")]
     Io(#[from] std::io::Error),
-    /// JSON 解析(`validate-result` 读 envelope)。
+    /// JSON 解析。
     #[error("json: {0}")]
     Json(#[from] serde_json::Error),
 }
@@ -341,33 +341,6 @@ pub struct SendArgs {
     pub to_leader: Option<String>,
 }
 
-/// E23 worker-side emergency fallback for `team_orchestrator.send_message`
-/// transport failures. This is not a general control-plane send path.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct FallbackSendLeaderArgs {
-    pub workspace: PathBuf,
-    pub team: Option<String>,
-    pub sender: String,
-    pub task: Option<String>,
-    pub message_id: String,
-    pub content: String,
-    pub primary_error: String,
-    pub json: bool,
-}
-
-/// E23 worker-side emergency fallback for `team_orchestrator.report_result`
-/// transport failures. It must still persist through the results DB.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct FallbackReportResultArgs {
-    pub workspace: PathBuf,
-    pub team: Option<String>,
-    pub agent_id: String,
-    pub task_id: String,
-    pub result_json: String,
-    pub primary_error: String,
-    pub json: bool,
-}
-
 /// `allow-peer-talk`(`parser.py`): allow direct peer communication between two agents.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct AllowPeerTalkArgs {
@@ -649,15 +622,6 @@ pub struct ProfileArgs {
     pub json: bool,
 }
 
-/// `validate-result`(`parser.py:312`)。
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ValidateResultArgs {
-    pub envelope: Option<String>,
-    pub file: Option<PathBuf>,
-    pub result: Option<String>,
-    pub json: bool,
-}
-
 /// `collect`(`parser.py:292`)。
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct CollectArgs {
@@ -670,33 +634,6 @@ pub struct CollectArgs {
     pub team: Option<String>,
 }
 
-/// `settle`(`parser.py:177`)。
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SettleArgs {
-    pub workspace: PathBuf,
-    /// Bug #6 (prerelease 0.4.0 gate review): explicit team scope. When
-    /// `Some`, settle scopes collect/status/team-state to this team via
-    /// `resolve_active_team(workspace, Some(team), ...)`. When `None`,
-    /// the selector falls back to top-level `active_team_key` (legacy).
-    pub team: Option<String>,
-    pub json: bool,
-}
-
-/// `repair-state`(`parser.py:303`)。
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct RepairStateArgs {
-    pub workspace: PathBuf,
-    pub task_id: String,
-    pub assignee: Option<String>,
-    pub status: String,
-    pub summary: Option<String>,
-    pub json: bool,
-    /// Stage 4: explicit `--team` scope. Destructive (rewrites task state);
-    /// CLI dispatch refuses bare invocation in a multi-alive-team
-    /// workspace.
-    pub team: Option<String>,
-}
-
 /// `diagnose`(`parser.py:298`) runtime health report, distinct from `doctor`.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct DiagnoseArgs {

package/crates/team-agent/src/coordinator/health.rs

@@ -853,7 +853,7 @@ pub(crate) fn message_store_schema_health(workspace: &WorkspacePath) -> SchemaHe
             error: Some(SchemaError::InitFailed {
                 message: e.to_string(),
             }),
-            action: Some("run team-agent repair-state --schema".to_string()),
+            action: Some("run team-agent doctor --fix-schema --json".to_string()),
         },
     }
 }

package/crates/team-agent/src/coordinator/tick.rs

@@ -1319,7 +1319,7 @@ impl Coordinator {
     }
 
     /// `message_store_schema_health`(`lifecycle.py:197`)。DB 列兼容门:区分 pre-init 必需列缺失
-    /// (拒启)vs migratable 列缺失(可迁移)。`advanced repair-state --schema` 用其 action hint。
+    /// (拒启)vs migratable 列缺失(可迁移)。`doctor --fix-schema` 用其 action hint。
     pub fn schema_health(&self) -> SchemaHealth {
         // A-8: the gate must inspect the REAL team.db (Python lifecycle.py:197+
         // message_store_schema_health); a hardcoded ok:true left the card §89
@@ -1807,6 +1807,31 @@ fn parse_rfc3339_utc(raw: &str) -> Option<chrono::DateTime<chrono::Utc>> {
         .map(|value| value.with_timezone(&chrono::Utc))
 }
 
+/// 0.5.32 (`.team/artifacts/restart-resumed-stale-activity-locate.md` §5):
+/// return true when the rollout file's modification time is not newer than
+/// the agent's current `spawned_at`. Used by `jsonl_activity_for_agent` to
+/// refuse classifying a pre-spawn transcript tail into fresh-cohort activity.
+/// Missing `spawned_at`, missing mtime, or unparseable timestamp → false
+/// (do not block classification; the caller keeps the pre-0.5.32 behavior).
+fn jsonl_older_than_spawn_boundary(agent: &Value, metadata: &std::fs::Metadata) -> bool {
+    let Some(spawned_at) = agent
+        .get("spawned_at")
+        .and_then(Value::as_str)
+        .and_then(parse_rfc3339_utc)
+    else {
+        return false;
+    };
+    let Ok(mtime) = metadata.modified() else {
+        return false;
+    };
+    let Ok(mtime_since_epoch) = mtime.duration_since(std::time::UNIX_EPOCH) else {
+        return false;
+    };
+    let mtime_utc =
+        chrono::DateTime::<chrono::Utc>::from(std::time::UNIX_EPOCH + mtime_since_epoch);
+    mtime_utc <= spawned_at
+}
+
 fn matching_capture_pane_info(
     agent: &Value,
     session: &crate::transport::SessionName,
@@ -1902,6 +1927,16 @@ fn jsonl_activity_for_agent(agent: &Value) -> Option<crate::messaging::AgentActi
     let metadata = std::fs::metadata(&rollout_path).ok()?;
     let size = metadata.len();
     let mtime_ns = crate::coordinator::steps::abnormal::metadata_mtime_ns(&metadata)?;
+    // 0.5.32 (`.team/artifacts/restart-resumed-stale-activity-locate.md` §5):
+    // freshness gate — a rollout file whose last modification is older than
+    // the agent's current `spawned_at` cannot describe post-spawn behavior.
+    // Refusing to classify (return None) here keeps stale pre-restart
+    // Working tails from re-poisoning a fresh cohort's activity/worker_state;
+    // pane fallback in the caller is still free to produce a fresh
+    // classification when a live pane observation exists.
+    if jsonl_older_than_spawn_boundary(agent, &metadata) {
+        return None;
+    }
     if let Ok(cache) = jsonl_activity_cache().lock() {
         if let Some(entry) = cache.get(&rollout_path) {
             if entry.size == size && entry.mtime_ns == mtime_ns {