@team-agent/installer 0.5.45 → 0.5.47

package/crates/team-agent/src/lifecycle/restart/common.rs

@@ -14,6 +14,142 @@ pub(super) struct SpawnedAgentWindow {
     pub owner_team_id: Option<String>,
 }
 
+#[derive(Clone)]
+pub(super) struct SameRoleCohortTarget {
+    pub agent_id: String,
+    pub window: String,
+    pub expected_pane_id: Option<String>,
+}
+
+impl SameRoleCohortTarget {
+    pub(super) fn new(agent_id: &AgentId, window: &str) -> Self {
+        Self {
+            agent_id: agent_id.as_str().to_string(),
+            window: window.to_string(),
+            expected_pane_id: None,
+        }
+    }
+
+    pub(super) fn with_expected_pane_id(mut self, pane_id: Option<&str>) -> Self {
+        self.expected_pane_id = pane_id.map(ToString::to_string);
+        self
+    }
+}
+
+pub(super) fn is_per_agent_cohort_window(window: &str, agent_id: &AgentId) -> bool {
+    window == agent_id.as_str() && !crate::lifecycle::launch::is_adaptive_layout_window_pub(window)
+}
+
+pub(super) fn same_role_cohort_pre_spawn_error(
+    transport: &dyn crate::transport::Transport,
+    session_name: &SessionName,
+    operation: &str,
+    targets: &[SameRoleCohortTarget],
+) -> Option<String> {
+    same_role_cohort_error(transport, session_name, operation, targets, 0, true)
+}
+
+pub(super) fn same_role_cohort_exactly_one_error(
+    transport: &dyn crate::transport::Transport,
+    session_name: &SessionName,
+    operation: &str,
+    targets: &[SameRoleCohortTarget],
+) -> Option<String> {
+    same_role_cohort_error(transport, session_name, operation, targets, 1, false)
+}
+
+pub(super) fn retire_expected_same_role_cohorts(
+    transport: &dyn crate::transport::Transport,
+    operation: &str,
+    targets: &[SameRoleCohortTarget],
+) -> Result<(), String> {
+    for target in targets {
+        let Some(pane_id) = target.expected_pane_id.as_deref() else {
+            continue;
+        };
+        let pane = crate::transport::PaneId::new(pane_id);
+        if transport.has_pane(&pane).ok().flatten() == Some(false) {
+            continue;
+        }
+        transport.kill_pane(&pane).map_err(|error| {
+            format!(
+                "{operation} failed to retire old same-role cohort {}:window={}:pane={pane_id}: {error}",
+                target.agent_id, target.window
+            )
+        })?;
+    }
+    Ok(())
+}
+
+fn same_role_cohort_error(
+    transport: &dyn crate::transport::Transport,
+    session_name: &SessionName,
+    operation: &str,
+    targets: &[SameRoleCohortTarget],
+    expected_live: usize,
+    expected_old_only: bool,
+) -> Option<String> {
+    let panes = transport.list_targets().ok()?;
+    let mut cardinality_proofs = Vec::new();
+    let mut binding_proofs = Vec::new();
+    for target in targets {
+        let live_panes = panes
+            .iter()
+            .filter(|pane| pane.session.as_str() == session_name.as_str())
+            .filter(|pane| {
+                pane.window_name
+                    .as_ref()
+                    .is_some_and(|window| window.as_str() == target.window)
+            })
+            .filter(|pane| {
+                !expected_old_only
+                    || target
+                        .expected_pane_id
+                        .as_deref()
+                        .is_some_and(|expected| pane.pane_id.as_str() == expected)
+            })
+            .filter(|pane| {
+                transport
+                    .liveness(&pane.pane_id)
+                    .is_ok_and(|live| live == crate::transport::PaneLiveness::Live)
+            })
+            .map(|pane| pane.pane_id.as_str().to_string())
+            .collect::<Vec<_>>();
+        if live_panes.len() != expected_live {
+            cardinality_proofs.push(format!(
+                "{}:window={}:live_panes=[{}]",
+                target.agent_id,
+                target.window,
+                live_panes.join(",")
+            ));
+        } else if !expected_old_only {
+            let observed = live_panes.first().map(String::as_str);
+            if target.expected_pane_id.as_deref() != observed {
+                binding_proofs.push(format!(
+                    "{}:window={}:expected_pane={}:observed_pane={}",
+                    target.agent_id,
+                    target.window,
+                    target.expected_pane_id.as_deref().unwrap_or("<missing>"),
+                    observed.unwrap_or("<missing>")
+                ));
+            }
+        }
+    }
+    if !binding_proofs.is_empty() {
+        return Some(format!(
+            "{operation} refused: spawn identity/binding mismatch; {}",
+            binding_proofs.join("; ")
+        ));
+    }
+    if !cardinality_proofs.is_empty() {
+        return Some(format!(
+            "{operation} refused: same-role cohort duplicate proof failed; {}",
+            cardinality_proofs.join("; ")
+        ));
+    }
+    None
+}
+
 #[allow(clippy::too_many_arguments)]
 pub(super) fn spawn_agent_window(
     workspace: &Path,

package/crates/team-agent/src/lifecycle/restart/rebuild.rs

@@ -428,6 +428,18 @@ fn restart_with_selected_team_and_transport(
     let live_worker_session_deferred_teardown =
         session_live_or_default(transport, &session_name, false)
             && !collect_live_agents_from_state(&state).is_empty();
+    let same_role_cohort_targets =
+        same_role_cohort_targets_from_decisions(&state, spec_workspace, &plan.decisions);
+    let pre_spawn_pane_ids = if live_worker_session_deferred_teardown {
+        transport
+            .list_targets()
+            .map_err(|error| LifecycleError::Transport(error.to_string()))?
+            .into_iter()
+            .map(|pane| pane.pane_id.as_str().to_string())
+            .collect::<std::collections::BTreeSet<_>>()
+    } else {
+        std::collections::BTreeSet::new()
+    };
     if session_live_or_default(transport, &session_name, false)
         && !live_worker_session_deferred_teardown
     {
@@ -779,6 +791,46 @@ fn restart_with_selected_team_and_transport(
         );
     }
     // END_B5_RESTART_ISOLATION_LOOP
+    if live_worker_session_deferred_teardown {
+        let successful_agent_ids = successful_agents
+            .iter()
+            .map(|agent| agent.agent_id.as_str())
+            .collect::<std::collections::BTreeSet<_>>();
+        let old_successful_targets = same_role_cohort_targets
+            .iter()
+            .filter(|target| successful_agent_ids.contains(target.agent_id.as_str()))
+            .cloned()
+            .collect::<Vec<_>>();
+        let successful_targets =
+            same_role_cohort_targets_from_decisions(&state, spec_workspace, &successful_agents);
+        let actual_spawn_panes = actual_successful_restart_spawn_panes(
+            transport,
+            &session_name,
+            &successful_targets,
+            &pre_spawn_pane_ids,
+        )?;
+        if let Some(error) =
+            actual_restart_spawn_binding_error(&successful_targets, &actual_spawn_panes)
+        {
+            cleanup_actual_restart_spawns(transport, &actual_spawn_panes);
+            return Err(LifecycleError::RequirementUnmet(error));
+        }
+        if let Err(error) =
+            retire_expected_same_role_cohorts(transport, "restart", &old_successful_targets)
+        {
+            cleanup_actual_restart_spawns(transport, &actual_spawn_panes);
+            return Err(LifecycleError::RequirementUnmet(error));
+        }
+        if let Some(error) = same_role_cohort_exactly_one_error(
+            transport,
+            &session_name,
+            "restart",
+            &successful_targets,
+        ) {
+            cleanup_actual_restart_spawns(transport, &actual_spawn_panes);
+            return Err(LifecycleError::RequirementUnmet(error));
+        }
+    }
     let mut topology_authority_agent_ids = successful_agents
         .iter()
         .map(|agent| agent.agent_id.as_str().to_string())
@@ -2090,6 +2142,122 @@ fn mark_fake_harness_agent_respawned(
     agent.insert("owner_team_id".to_string(), serde_json::json!(team_key));
 }
 
+fn same_role_cohort_targets_from_decisions(
+    state: &serde_json::Value,
+    spec_workspace: &Path,
+    agents: &[RestartedAgent],
+) -> Vec<SameRoleCohortTarget> {
+    let mut targets = Vec::new();
+    for restarted in agents {
+        let agent_id = &restarted.agent_id;
+        let raw_agent = state
+            .get("agents")
+            .and_then(|agents| agents.get(agent_id.as_str()));
+        let effective_agent = raw_agent.map(|agent| {
+            rehydrate_agent_command_context_from_spec(spec_workspace, agent_id, agent)
+        });
+        if effective_agent
+            .as_ref()
+            .and_then(|agent| agent.get("provider"))
+            .and_then(serde_json::Value::as_str)
+            .is_some_and(|provider| provider.eq_ignore_ascii_case("fake"))
+        {
+            continue;
+        }
+        let window = raw_agent
+            .and_then(|agent| agent.get("window"))
+            .and_then(serde_json::Value::as_str)
+            .filter(|value| !value.is_empty())
+            .unwrap_or_else(|| agent_id.as_str());
+        if is_per_agent_cohort_window(window, agent_id) {
+            let expected_pane_id = raw_agent
+                .and_then(|agent| agent.get("pane_id"))
+                .and_then(serde_json::Value::as_str)
+                .filter(|value| !value.is_empty());
+            targets.push(
+                SameRoleCohortTarget::new(agent_id, window).with_expected_pane_id(expected_pane_id),
+            );
+        }
+    }
+    targets
+}
+
+fn actual_successful_restart_spawn_panes(
+    transport: &dyn crate::transport::Transport,
+    session_name: &SessionName,
+    targets: &[SameRoleCohortTarget],
+    pre_spawn_pane_ids: &std::collections::BTreeSet<String>,
+) -> Result<Vec<crate::transport::PaneInfo>, LifecycleError> {
+    let windows = targets
+        .iter()
+        .map(|target| target.window.as_str())
+        .collect::<std::collections::BTreeSet<_>>();
+    let panes = transport
+        .list_targets()
+        .map_err(|error| LifecycleError::Transport(error.to_string()))?
+        .into_iter()
+        .filter(|pane| !pre_spawn_pane_ids.contains(pane.pane_id.as_str()))
+        .filter(|pane| pane.session.as_str() == session_name.as_str())
+        .filter(|pane| {
+            pane.window_name
+                .as_ref()
+                .is_some_and(|window| windows.contains(window.as_str()))
+        })
+        .filter(|pane| {
+            transport
+                .liveness(&pane.pane_id)
+                .is_ok_and(|state| state == crate::transport::PaneLiveness::Live)
+        })
+        .collect();
+    Ok(panes)
+}
+
+fn actual_restart_spawn_binding_error(
+    targets: &[SameRoleCohortTarget],
+    actual_spawn_panes: &[crate::transport::PaneInfo],
+) -> Option<String> {
+    let mut mismatches = Vec::new();
+    for target in targets {
+        let observed = actual_spawn_panes
+            .iter()
+            .filter(|pane| {
+                pane.window_name
+                    .as_ref()
+                    .is_some_and(|window| window.as_str() == target.window)
+            })
+            .map(|pane| pane.pane_id.as_str().to_string())
+            .collect::<Vec<_>>();
+        if observed.len() != 1
+            || target.expected_pane_id.as_deref() != observed.first().map(String::as_str)
+        {
+            mismatches.push(format!(
+                "{}:window={}:expected_pane={}:actual_spawn_panes=[{}]",
+                target.agent_id,
+                target.window,
+                target.expected_pane_id.as_deref().unwrap_or("<missing>"),
+                observed.join(",")
+            ));
+        }
+    }
+    if mismatches.is_empty() {
+        None
+    } else {
+        Some(format!(
+            "restart refused: spawn identity/binding mismatch; {}",
+            mismatches.join("; ")
+        ))
+    }
+}
+
+fn cleanup_actual_restart_spawns(
+    transport: &dyn crate::transport::Transport,
+    actual_spawn_panes: &[crate::transport::PaneInfo],
+) {
+    for pane in actual_spawn_panes {
+        let _ = transport.kill_pane(&pane.pane_id);
+    }
+}
+
 fn write_fake_harness_spawn_argv_event(
     workspace: &Path,
     decision: &RestartedAgent,

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

@@ -402,6 +402,11 @@ case "$*" in
     ;;
 esac
 case "$*" in
+  *"new-window "*|*"new-session "*)
+    : > "$spawned_marker"
+    printf '%%9288\n'
+    exit 0
+    ;;
   *"display-message -p -t $pane #{pane_id}"*)
     if [ -f "$killed_marker" ]; then
       echo "can't find pane: $pane" >&2
@@ -410,11 +415,6 @@ case "$*" in
     printf '%s\n' "$pane"
     exit 0
     ;;
-  *"display-message -p -t $session:alpha #{pane_id}"*)
-    : > "$spawned_marker"
-    printf '%%9288\n'
-    exit 0
-    ;;
   *"list-windows -t $session -F #{window_name}"*)
     exit 0
     ;;
@@ -873,8 +873,8 @@ fn reset_agent_stop_not_proven_grep_guard_hard_gate_wired() {
         "reset_agent_at_paths must emit reset_agent.stop_not_proven via the writer"
     );
     assert!(
-        contents.contains("if !agent_is_paused && !stop.stopped"),
-        "gate must run only when stop.stopped=false (the dangerous case)"
+        contents.contains("if !agent_is_paused {"),
+        "gate must run after stop for every non-paused reset, including stop.stopped=true residue"
     );
     assert!(
         contents.contains("list_same_role_panes") && contents.contains("is_per_agent_window"),

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

@@ -744,7 +744,7 @@ impl Transport for BRealTransport {
         if matches!(self.mode, BRealMode::Misowned) {
             targets.push(pane_info("team-phaseb", "w2", "%5", 502));
         }
-        if matches!(self.mode, BRealMode::Owned) {
+        if matches!(self.mode, BRealMode::Owned) && !self.spawns.lock().unwrap().is_empty() {
             targets.push(pane_info("team-phaseb", "w1", "%10", 501));
         }
         Ok(targets)

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

@@ -553,6 +553,9 @@ fn normalize_value(value: Value, ctx: &mut NormalizeCtx, key: Option<&str>) -> V
             let sorted = map.into_iter().collect::<BTreeMap<_, _>>();
             let mut out = Map::new();
             for (child_key, child) in sorted {
+                if matches!(child_key.as_str(), "model_source" | "provider_source") {
+                    continue;
+                }
                 out.insert(
                     child_key.clone(),
                     normalize_value(child, ctx, Some(child_key.as_str())),

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

@@ -632,6 +632,9 @@ pub enum ResetAgentOutcome {
         discarded_session_id: Option<SessionId>,
         session_id: Option<SessionId>,
         new_session_id: Option<SessionId>,
+        capture_state: String,
+        reset_proof: String,
+        weak_reset_warning: Option<String>,
     },
     /// 未传 discard_session → 拒绝(不丢上下文的误用保护)。
     Refused { reason: ResetRefusal },

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

@@ -67,6 +67,9 @@ pub(crate) fn reset_agent(
             discarded_session_id,
             session_id,
             new_session_id,
+            capture_state,
+            reset_proof,
+            weak_reset_warning,
         } => Ok(ToolOk {
             fields: object_fields(serde_json::json!({
                 "ok": true,
@@ -78,6 +81,13 @@ pub(crate) fn reset_agent(
                 "discarded_session_id": discarded_session_id.as_ref().map(|id| id.as_str()),
                 "session_id": session_id.as_ref().map(|id| id.as_str()),
                 "new_session_id": new_session_id.as_ref().map(|id| id.as_str()),
+                "capture_state": match capture_state.as_str() {
+                    "captured" => "captured",
+                    "attribution_ambiguous" => "attribution_ambiguous",
+                    _ => "transcript_missing",
+                },
+                "reset_proof": if reset_proof == "weak" { "weak" } else { "strong" },
+                "weak_reset_warning": weak_reset_warning,
             })),
         }),
         ResetAgentOutcome::Refused { reason } => Ok(ToolOk {

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

@@ -204,6 +204,7 @@ fn run_stdio_loop_inner<R: BufRead, W: Write>(
         report.requests_read = report.requests_read.saturating_add(1);
         let frame = handle_stdin_line(tools, &line, report)?;
         if let Some(value) = frame {
+            let value = crate::redaction::redact_external_value(&value);
             serde_json::to_writer(&mut *writer, &value)?;
             writer.write_all(b"\n")?;
             writer.flush()?;
@@ -266,7 +267,8 @@ fn rpc_id_from_request(request: &Value) -> RpcId {
 }
 
 fn tool_call_result_value(is_error: bool, body: &Value) -> Value {
-    let text = json_dumps_default(body);
+    let body = crate::redaction::redact_external_value(body);
+    let text = json_dumps_default(&body);
     let mut content = serde_json::Map::new();
     content.insert("type".to_string(), Value::String("text".to_string()));
     content.insert("text".to_string(), Value::String(text));