@team-agent/installer 0.5.105 → 0.5.107

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

@@ -373,6 +373,8 @@ pub(crate) fn start_agent_at_paths(
     };
     let into_existing_session =
         session_live_or_default(transport, &session_name, session_name_present(&state));
+    let inherited_generation =
+        crate::state::projection::session_generation(&state).map(str::to_string);
     let safety = crate::lifecycle::launch::effective_runtime_config_for_worker_spawn_json(
         &agent,
         provider,
@@ -441,6 +443,24 @@ pub(crate) fn start_agent_at_paths(
         &safety,
         start_mode,
     )?;
+    let generation = if into_existing_session {
+        inherited_generation.as_deref()
+    } else {
+        Some(spawn.spawned_at.as_str())
+    };
+    if let Some(generation) = generation {
+        state["generation"] = serde_json::json!(generation);
+        if !into_existing_session {
+            transport
+                .set_session_owner_with_generation(
+                    &session_name,
+                    workspace,
+                    &resolved_team_key,
+                    generation,
+                )
+                .map_err(|error| LifecycleError::Transport(error.to_string()))?;
+        }
+    }
     // 0.5.66 bypass 单源 §2.7:启动即带 bypass → 审计留痕。
     if safety.enabled {
         let state_agent = state
@@ -1156,6 +1176,30 @@ pub(super) fn stop_agent_at_paths(
         || !same_role_panes.is_empty()
         || (pane_id.is_none() && window_exists(transport, &session_name, &window));
     if stopped {
+        let stop_targets =
+            if let Some(pane) = pane_id.as_ref().filter(|_| stored_pane_live) {
+                vec![Target::Pane(pane.clone())]
+            } else if !same_role_panes.is_empty() {
+                same_role_panes
+                    .iter()
+                    .map(|pane| Target::Pane(pane.pane_id.clone()))
+                    .collect()
+            } else {
+                vec![Target::SessionWindow {
+                    session: session_name.clone(),
+                    window: WindowName::new(&window),
+                }]
+            };
+        // Explicit kill-pane/kill-window ignores remain-on-exit on the worker.
+        // Preserve the last window BEFORE killing it, or the coordinator sees
+        // a missing session and stops while the seat is merely being stopped.
+        transport
+            .preserve_session_before_stop(&session_name, &stop_targets)
+            .map_err(|error| {
+                LifecycleError::Transport(format!(
+                    "failed to preserve session before stopping agent {agent_id}: {error}"
+                ))
+            })?;
         // golden operations.py:84-86: a non-zero kill-window raises
         // RuntimeError(f"failed to stop agent {agent_id}: {proc.stderr.strip()}").
         //

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

@@ -509,6 +509,8 @@ 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 inherited_generation =
+        crate::state::projection::session_generation(&state).map(str::to_string);
     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 {
@@ -998,6 +1000,25 @@ fn restart_with_selected_team_and_transport(
             }
         }
     }
+    if !fatal_resume_failure && !successful_agents.is_empty() {
+        let generation = if live_worker_session_deferred_teardown {
+            inherited_generation
+        } else {
+            // A recreated session gets the first successful NEW worker's birth,
+            // not an arbitrary old stopped worker still present in the roster.
+            successful_agents.first().and_then(|agent| {
+                state
+                    .get("agents")?
+                    .get(agent.agent_id.as_str())?
+                    .get("spawned_at")?
+                    .as_str()
+                    .map(str::to_string)
+            })
+        };
+        if let Some(generation) = generation {
+            state["generation"] = serde_json::json!(generation);
+        }
+    }
     save_restart_state_with_lifecycle_topology_authority_and_capture_backfill_skip(
         &selected.run_workspace,
         &mut state,
@@ -1040,23 +1061,9 @@ fn restart_with_selected_team_and_transport(
             attach_commands,
         });
     }
-    // Respawn changes the generation used by shutdown's ownership check, even
-    // when build-before-destroy keeps the tmux session itself alive. Stamp only
-    // the selected session, after its replacement state is durable.
-    if let Some(generation) = state
-        .get("generation")
-        .and_then(serde_json::Value::as_str)
-        .or_else(|| {
-            state
-                .get("agents")
-                .and_then(serde_json::Value::as_object)
-                .and_then(|agents| {
-                    agents.values().find_map(|agent| {
-                        agent.get("spawned_at").and_then(serde_json::Value::as_str)
-                    })
-                })
-        })
-    {
+    // Stamp the physical session birth after durable state. Replacing workers
+    // in a retained session does not create a new session generation.
+    if let Some(generation) = crate::state::projection::session_generation(&state) {
         transport
             .set_session_owner_with_generation(
                 &session_name,

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

@@ -365,15 +365,6 @@ fn add_agent_joins_w2_into_running_roster_and_existing_session() {
     );
 }
 
-// REAL-MACHINE e2e boundary (rt-host-a verifies): after `add-agent w2`, the coordinator delivers
-// `send w2` and w2 reports a result (full round-trip). #[ignore] — needs a live tmux session + worker.
-#[test]
-#[ignore = "real-machine: add-agent then send w2 round-trips"]
-fn add_agent_then_send_w2_round_trips() {
-    // The framework asserts: add-agent w2 -> w2 in the live session + roster -> `send w2 <msg>` ->
-    // coordinator delivers -> w2 emits a result_envelope (results row). Not unit-testable in-process.
-}
-
 #[derive(Clone)]
 struct SocketRecordingRunner {
     recorded: std::sync::Arc<std::sync::Mutex<Vec<Vec<String>>>>,
@@ -505,6 +496,7 @@ session="${TEAM_AGENT_E27_SESSION_NAME}"
 pane="${TEAM_AGENT_E27_PANE_ID}"
 killed_marker="${log}.killed"
 spawned_marker="${log}.spawned"
+anchor_marker="${log}.anchor"
 track=0
 case "$*" in
   *"$expected"*|*"$session"*|*"$pane"*) track=1 ;;
@@ -544,6 +536,23 @@ case "$*" in
     ;;
 esac
 case "$*" in
+  *"list-panes -s -t =$session -F"*)
+    if [ -f "$anchor_marker" ]; then
+      printf '%%9299\t[team-agent keepalive]\n'
+    fi
+    if [ ! -f "$killed_marker" ]; then
+      printf '%s\talpha\n' "$pane"
+    fi
+    if [ -f "$spawned_marker" ]; then
+      printf '%%9288\talpha\n'
+    fi
+    exit 0
+    ;;
+  *"new-window "*"[team-agent keepalive]"*)
+    : > "$anchor_marker"
+    printf '%%9299\n'
+    exit 0
+    ;;
   *"new-window "*|*"new-session "*)
     : > "$spawned_marker"
     printf '%%9288\n'
@@ -651,6 +660,10 @@ fn e27_stop_agent_uses_attached_explicit_state_socket() {
         "attached explicit-socket worker should be stopped"
     );
     assert_only_expected_socket_used(&shim.log, endpoint);
+    let raw = std::fs::read_to_string(&shim.log).unwrap();
+    assert!(raw.contains(&format!("list-panes -s -t ={session_name}")));
+    assert!(raw.contains("set-window-option -t %9299 remain-on-exit on"));
+    assert!(raw.contains("respawn-pane -k -t %9299 exit 0"));
     let state = crate::state::persist::load_runtime_state(&ws).unwrap();
     assert_eq!(
         state

package/crates/team-agent/src/lifecycle/tests/fixtures/pi_native_mcp_host.mjs

@@ -0,0 +1,71 @@
+import { writeFile } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+
+const [wrapperPath, receiptPath, cwd] = process.argv.slice(2);
+if (!wrapperPath || !receiptPath || !cwd) throw new Error("expected wrapper, receipt, and cwd");
+
+const registrations = [];
+const unregistrations = [];
+const handlers = new Map();
+const extensionCommands = [{
+  name: "mcp",
+  source: "extension",
+  sourceInfo: { path: "builtin:mcp", source: "builtin", scope: "user", origin: "top-level" },
+}];
+const pi = {
+  on(event, handler) {
+    const list = handlers.get(event) ?? [];
+    list.push(handler);
+    handlers.set(event, list);
+  },
+  getCommands() {
+    return extensionCommands;
+  },
+  getMcpServers() {
+    return registrations.map(({ name, config }) => ({ name, config, extensionPath: "<native-n1-fixture>" }));
+  },
+  getAllTools() {
+    return registrations.flatMap(({ name, config }) => Object.entries(config.toolExposure ?? {})
+      .map(([tool, exposure]) => ({ name: `mcp__${name}__${tool}`, namespace: { name: `mcp__${name}` }, exposure })));
+  },
+  getActiveTools() {
+    return this.getAllTools().filter((tool) => tool.exposure !== "hidden").map((tool) => tool.name);
+  },
+  registerMcpServer(name, config) {
+    registrations.push({ name, config });
+  },
+  unregisterMcpServer(name) {
+    unregistrations.push(name);
+  },
+};
+
+const extension = await import(pathToFileURL(wrapperPath).href);
+if (typeof extension.default !== "function") throw new Error("generated wrapper has no default extension factory");
+await extension.default(pi);
+const context = {
+  cwd,
+  sessionManager: {
+    getSessionFile: () => undefined,
+    getLeafId: () => undefined,
+    getEntries: () => [],
+  },
+};
+for (const handler of handlers.get("session_start") ?? []) {
+  await handler({ type: "session_start" }, context);
+}
+if (registrations.length !== 1) throw new Error(`expected one native MCP registration, saw ${registrations.length}`);
+const expectedTools = Object.keys(registrations[0].config.toolExposure ?? {})
+  .map((tool) => `mcp__${registrations[0].name}__${tool}`);
+const deadline = Date.now() + 3_000;
+while (!expectedTools.every((name) => pi.getActiveTools().includes(name))) {
+  if (Date.now() >= deadline) throw new Error(`native MCP tools never became active: ${pi.getActiveTools()}`);
+  await new Promise((resolve) => setTimeout(resolve, 10));
+}
+const beforeAgentStart = handlers.get("before_agent_start")?.[0];
+if (typeof beforeAgentStart !== "function") throw new Error("generated wrapper omitted before_agent_start wire binding");
+const binding = await beforeAgentStart({ systemPrompt: "N1 fixture" }, context);
+const wirePrompt = binding?.systemPrompt;
+if (typeof wirePrompt !== "string" || !expectedTools.every((name) => wirePrompt.includes(name))) {
+  throw new Error(`native Team tool wire binding is incomplete: ${wirePrompt}`);
+}
+await writeFile(receiptPath, `${JSON.stringify({ registrations, unregistrations, activeTools: pi.getActiveTools(), expectedTools, wirePrompt }, null, 2)}\n`, "utf8");

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

@@ -73,6 +73,8 @@ pub(super) struct LaneTransport {
     killed: LaneKills,
     spawns: LaneSpawns,
     spawn_observed_at: std::sync::Arc<std::sync::Mutex<Vec<String>>>,
+    stop_preservation: std::sync::Mutex<Vec<(Vec<crate::transport::Target>, Vec<String>)>>,
+    fail_stop_preservation: bool,
 }
 impl LaneTransport {
     pub(super) fn new(session: &str, windows: &[&str]) -> Self {
@@ -85,6 +87,8 @@ impl LaneTransport {
             killed: std::sync::Arc::new(std::sync::Mutex::new(Vec::new())),
             spawns: std::sync::Arc::new(std::sync::Mutex::new(Vec::new())),
             spawn_observed_at: std::sync::Arc::new(std::sync::Mutex::new(Vec::new())),
+            stop_preservation: std::sync::Mutex::new(Vec::new()),
+            fail_stop_preservation: false,
         }
     }
     pub(super) fn killed(&self) -> Vec<String> {
@@ -297,6 +301,21 @@ impl crate::transport::Transport for LaneTransport {
     ) -> Result<crate::transport::SetEnvOutcome, crate::transport::TransportError> {
         Ok(crate::transport::SetEnvOutcome::Applied)
     }
+    fn preserve_session_before_stop(
+        &self,
+        session: &crate::transport::SessionName,
+        targets: &[crate::transport::Target],
+    ) -> Result<(), crate::transport::TransportError> {
+        self.stop_preservation
+            .lock()
+            .unwrap()
+            .push((targets.to_vec(), self.killed()));
+        if self.fail_stop_preservation {
+            Err(crate::transport::TransportError::TargetNotFound { target: session.as_str().to_string() })
+        } else {
+            Ok(())
+        }
+    }
     fn kill_session(
         &self,
         _s: &crate::transport::SessionName,
@@ -408,6 +427,30 @@ fn lanea_one_agent_ws(alpha_status: &str) -> PathBuf {
     ws
 }
 
+#[test]
+fn stop_session_preservation_runs_before_kill_and_failure_preserves_worker_state() {
+    for fail in [false, true] {
+        let ws = lanea_one_agent_ws("running");
+        let mut tx = LaneTransport::new("team-laneateam", &["alpha"]);
+        tx.fail_stop_preservation = fail;
+        let result = stop_agent_with_transport(&ws, &aid("alpha"), None, &tx);
+        let calls = tx.stop_preservation.lock().unwrap();
+        assert_eq!(calls.len(), 1);
+        assert_eq!(calls[0].1, Vec::<String>::new(), "preserve must precede all worker kills");
+        assert_eq!(calls[0].0, vec![crate::transport::Target::Pane(crate::transport::PaneId::new("%alpha"))]);
+        let state = crate::state::persist::load_runtime_state(&ws).unwrap();
+        if fail {
+            assert!(result.is_err());
+            assert!(tx.killed().is_empty());
+            assert_eq!(state["agents"]["alpha"]["status"], "running");
+        } else {
+            assert!(result.unwrap().stopped);
+            assert_eq!(tx.killed(), vec!["%alpha".to_string()]);
+            assert_eq!(state["agents"]["alpha"]["status"], "stopped");
+        }
+    }
+}
+
 fn selected_spec_path(ws: &std::path::Path) -> std::path::PathBuf {
     crate::state::selector::resolve_active_team(
         ws,
@@ -1278,33 +1321,6 @@ fn lanea_stop_window_present_kills_and_stopped_true() {
     );
 }
 
-// ── STOP #2 (stop-display-noop-2) [RED] — close ghostty_workspace slot: persist display.status/pane_title
-// Golden operations.py:88-92 -> display/close.py:84-85 relabels the slot: display["status"]="stopped",
-// display["pane_title"]=f"stopped: {agent_id}", written back into the persisted agent entry. Rust never
-// touches the display (mark_agent_stopped leaves it as-is) and hardcodes display_closed:false. RED: the
-// persisted display.status/pane_title are the in-process observable.
-#[test]
-#[ignore = "legacy external display contract removed; runtime is silent tmux only"]
-fn lanea_stop_ghostty_workspace_relabels_slot_to_stopped() {
-    let ws = lanea_ws_agents(json!({
-        "alpha": { "status": "running", "provider": "codex", "window": "alpha",
-                   "display": { "backend": "ghostty_workspace", "pane_id": "%5", "linked_session": "disp-alpha", "status": "running", "pane_title": "alpha" } }
-    }));
-    let tx = LaneTransport::new("team-laneateam", &["alpha"]);
-    let _ = stop_agent_with_transport(&ws, &aid("alpha"), None, &tx).expect("stop ok");
-    let state = crate::state::persist::load_runtime_state(&ws).expect("load state");
-    assert_eq!(
-        state.pointer("/agents/alpha/display/status").and_then(serde_json::Value::as_str),
-        Some("stopped"),
-        "stop must relabel a ghostty_workspace slot: display.status='stopped' (close.py:84); Rust leaves it 'running'"
-    );
-    assert_eq!(
-        state.pointer("/agents/alpha/display/pane_title").and_then(serde_json::Value::as_str),
-        Some("stopped: alpha"),
-        "stop must set display.pane_title='stopped: <id>' (close.py:85); Rust never touches the display"
-    );
-}
-
 // ── RESET #3 (reset-paused-restart-2) [RED] — reset of a PAUSED agent returns ok=true (NOT an Err) ───
 // Golden operations.py:126-140: after discard, reset re-spawns via start_agent(force,allow_fresh).
 // discard does NOT clear `paused`, so start_agent returns the refusal-shaped {ok:False,status:paused,
@@ -1808,42 +1824,3 @@ fn fresh_start_persists_boundary_from_before_transport_spawn() {
          spawned_at={spawned_at}, transport_observed_at={transport_observed_at}"
     );
 }
-
-// ── REMOVE #6/#12 (remove-rollback-no-agent-health-3 / remove-rollback-health-1) [SEAM #[ignore]] ────
-// Golden _RemoveRollback captures `self.health = copy.deepcopy(store.agent_health().get(agent_id))`
-// (agents.py:185) and restore() re-upserts it via _restore_agent_health (agents.py:215-218,268-278). The
-// Rust RemoveRollback has NO health field and never restores it (restart.rs:972-1067). This is only
-// observable when a step AFTER the agent_health delete fails — but Rust's only post-delete step is the
-// snapshot, which golden runs OUTSIDE the rollback-protected region (agents.py:135). Exercising it
-// golden-faithfully needs a production failure-injection seam at an in-try step after the delete (mirror
-// the coordinator SaveHook). PORTER: add `health: Option<Value>` to RemoveRollback (capture the row
-// before delete; restore re-upserts status||"IDLE"/last_output_at/context_usage_pct/current_task_id, or
-// deletes if None) AND move save_team_runtime_snapshot OUTSIDE the rollback region (golden agents.py:135).
-#[test]
-#[ignore = "seam: agent_health rollback restore needs a failure-injection hook (post-delete, in-try) to \
-            exercise in-process; golden agents.py:185/215-218/268-278. Porter adds RemoveRollback.health + \
-            moves save_team_runtime_snapshot outside the rollback region."]
-fn lanea_remove_rollback_restores_agent_health() {
-    // Golden contract (verified by reading agents.py): on a mid-remove failure after the agent_health
-    // row is deleted, rollback re-upserts the captured row so the health history is not lost.
-}
-
-// ── FORK (fork-incomplete-rollback) [SEAM #[ignore]] — post-spawn rollback arms ─────────────────────
-// Golden operations.py:384-394 wraps spec-mutation..start_coordinator in try/except; on ANY failure it
-// (1) kills the spawned tmux window if present, (2) adapter.cleanup_mcp, (3) restores old spec text, and
-// (4) restores prior state. Rust only restores the spec on the spawn_into arm (launch.rs:481); the
-// save_runtime_state (486-487) and start_coordinator (488-493) failure arms leave the spec mutated, the
-// already-spawned window un-killed, and the state un-rolled-back; install_mcp/cleanup_mcp are absent.
-// The adapter.fork_plan arm IS covered HARD above (lanea_fork_gate_error_text_and_spec_rollback_on_adapter_arm).
-// The post-SPAWN arms need a failure-injection seam after spawn_into (codex+subscription forks past
-// adapter.fork_plan, so the spawn succeeds and there is no in-process way to fail save/coordinator cleanly).
-// PORTER: a Drop guard armed after the spec write, disarmed on success — kills the window, restores spec
-// + state, runs cleanup_mcp on every post-write error arm.
-#[test]
-#[ignore = "seam: fork post-spawn rollback arms (save_runtime_state / start_coordinator failure) need a \
-            failure-injection hook after spawn_into; golden operations.py:384-394. Porter wires a Drop \
-            guard (kill window + restore spec/state + cleanup_mcp) armed after the spec write."]
-fn lanea_fork_rollback_complete_on_post_spawn_failure() {
-    // Golden contract (operations.py:384-394): a post-spawn failure kills the spawned window, restores
-    // the old spec text + prior state, and runs cleanup_mcp before re-raising.
-}