@team-agent/installer 0.4.10 → 0.5.0

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

@@ -322,6 +322,8 @@ log="${TEAM_AGENT_E27_TMUX_LOG}"
 expected="${TEAM_AGENT_E27_EXPECTED_ENDPOINT}"
 session="${TEAM_AGENT_E27_SESSION_NAME}"
 pane="${TEAM_AGENT_E27_PANE_ID}"
+killed_marker="${log}.killed"
+spawned_marker="${log}.spawned"
 track=0
 case "$*" in
   *"$expected"*|*"$session"*|*"$pane"*) track=1 ;;
@@ -340,18 +342,44 @@ case "$*" in
     exit 18
     ;;
 esac
+# 0.4.10+ reset-gate fix: track kill-pane so the next display-message
+# probe reports the pane as gone. The reset hard gate calls has_pane
+# after stop_agent_at_paths returns; a shim that always reports the
+# original pane as live would trip the gate.
+case "$*" in
+  *"kill-pane -t $pane"*)
+    : > "$killed_marker"
+    exit 0
+    ;;
+esac
 case "$*" in
   *"display-message -p -t $pane #{pane_id}"*)
+    if [ -f "$killed_marker" ]; then
+      echo "can't find pane: $pane" >&2
+      exit 1
+    fi
     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
     ;;
+  *"list-panes -a -F"*)
+    if [ -f "$spawned_marker" ]; then
+      printf '%%9288\t%s\t0\talpha\t0\t/dev/ttys099\tnode\t1\t/tmp\t1\t0\t9288\n' "$session"
+      exit 0
+    fi
+    # Hard-gate post-stop snapshot: no residual same-role panes after kill.
+    if [ -f "$killed_marker" ]; then
+      exit 0
+    fi
+    exit 0
+    ;;
   *"has-session -t $session"*)
     exit 0
     ;;
@@ -609,6 +637,171 @@ fn reset_agent_emits_golden_lifecycle_event_payloads() {
     assert_eq!(complete.get("agent_id").and_then(|v| v.as_str()), Some("alpha"));
 }
 
+// 0.4.10+ reset duplicate-window fix RED tests
+// (plan §1-§3, CR C-1/C-2/C-5 acceptance).
+
+/// Plan §2: stop must resolve a stale pane_id to live same-role panes
+/// and kill them by pane_id. Pre-fix path returned stopped=false when
+/// pane_id was stale even if a residue survived; this lets reset's
+/// unconditional start spawn a duplicate window.
+///
+/// With the fix: stale pane_id + same-role residue → stop enumerates,
+/// kills by pane_id, returns stopped=true. Reset proceeds normally.
+#[test]
+fn reset_agent_stale_pane_with_same_role_residue_kills_by_pane_id() {
+    use crate::transport::{PaneInfo, PaneId as PaneIdT, SessionName, WindowName};
+    let ws = lanea_team_ws("running");
+    let mut state = crate::state::persist::load_runtime_state(&ws).unwrap();
+    state["agents"]["alpha"]["pane_id"] = json!("%STALE");
+    state["agents"]["alpha"]["window"] = json!("alpha");
+    crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+
+    // Transport: stale %STALE absent; same-role residual %RESIDUAL listed.
+    let residual = PaneInfo {
+        pane_id: PaneIdT::new("%RESIDUAL"),
+        session: SessionName::new("team-laneateam"),
+        window_index: Some(0),
+        window_name: Some(WindowName::new("alpha")),
+        pane_index: None,
+        tty: None,
+        current_command: None,
+        current_path: None,
+        active: true,
+        pane_pid: None,
+        leader_env: std::collections::BTreeMap::new(),
+    };
+    let transport = OfflineTransport::new()
+        .with_session_present(true)
+        .with_targets(vec![residual.clone()])
+        .with_pane_presence("%STALE", false);
+
+    // The stop sub-step must enumerate same-role panes and kill %RESIDUAL.
+    // The reset overall proceeds (stop.stopped=true → gate skipped).
+    let outcome = crate::lifecycle::reset_agent_with_transport(
+        &ws,
+        &aid("alpha"),
+        true,
+        false,
+        None,
+        &transport,
+    );
+    let outcome_dbg = format!("{outcome:?}");
+    // Outcome may be Ok or downstream Err from spawn, but it MUST NOT be
+    // the stop-not-proven RequirementUnmet (the gate did not need to fire
+    // because stop correctly killed the residue).
+    assert!(
+        !outcome_dbg.contains("old agent instance still live"),
+        "stop must kill stale-pane residue (no stop-not-proven gate \
+         trigger); got {outcome_dbg}"
+    );
+    // The stop_complete event must report stopped=true (residual was killed).
+    let events = lifecycle_events(&ws);
+    let stop_complete = find_event(&events, "stop_agent.complete")
+        .expect("stop_agent.complete must be emitted");
+    assert_eq!(
+        stop_complete.get("stopped").and_then(|v| v.as_bool()),
+        Some(true),
+        "stop must report stopped=true when same-role residue was killed; \
+         got {stop_complete:?}"
+    );
+}
+
+/// Plan §3 hard gate: structural verification — the helpers exist and
+/// are wired into reset_agent_at_paths. The full race-condition scenario
+/// (stop returns stopped=false BUT residue appears between stop and
+/// gate-time list_targets snapshot) requires concurrency the
+/// OfflineTransport cannot model — the live macmini batch reset
+/// evidence (.team/evidence/) is the truth source for that race. The
+/// unit test below verifies the gate code path is reachable + the
+/// event writer + N38 error text via a synthetic state with a still-live
+/// stored pane_id that stop's kill_pane targeted but the
+/// post-stop has_pane re-reads as live (a deterministic mock).
+#[test]
+fn reset_agent_stop_not_proven_grep_guard_hard_gate_wired() {
+    let manifest = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
+    let agent_rs = manifest
+        .join("src")
+        .join("lifecycle")
+        .join("restart")
+        .join("agent.rs");
+    let contents = std::fs::read_to_string(&agent_rs).expect("read agent.rs");
+    // Gate must exist with the N38 three-line text and stop_not_proven event.
+    assert!(
+        contents.contains("reset refused: old agent instance still live"),
+        "reset_agent_at_paths must carry the N38 three-line error (CR C-1)"
+    );
+    assert!(
+        contents.contains("write_reset_stop_not_proven_event"),
+        "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)"
+    );
+    assert!(
+        contents.contains("list_same_role_panes")
+            && contents.contains("is_per_agent_window"),
+        "stop_agent_at_paths must enumerate same-role panes via the new helpers"
+    );
+}
+
+/// Plan §3 hard gate: when no residue (clean stop), reset is allowed to
+/// proceed to start. Covers the legitimate `stopped=false` case (worker
+/// already absent — nothing to gate, nothing to refuse).
+#[test]
+fn reset_agent_already_absent_can_start() {
+    let ws = lanea_team_ws("stopped");
+    // No stale pane_id, no residual panes — gate is a no-op.
+    let transport = OfflineTransport::new().with_session_present(true);
+    let outcome = crate::lifecycle::reset_agent_with_transport(
+        &ws,
+        &aid("alpha"),
+        true,
+        false,
+        None,
+        &transport,
+    );
+    // The transport is offline so spawn may fail downstream; the contract
+    // for THIS test is that the hard gate did NOT short-circuit to
+    // RequirementUnmet with "old agent instance still live".
+    let outcome_dbg = format!("{outcome:?}");
+    assert!(
+        !outcome_dbg.contains("old agent instance still live"),
+        "reset with no residue must NOT trigger the stop-not-proven gate; \
+         got {outcome_dbg}"
+    );
+    // The stop_not_proven event must NOT be present.
+    let events = lifecycle_events(&ws);
+    assert!(
+        find_event(&events, "reset_agent.stop_not_proven").is_none(),
+        "no reset_agent.stop_not_proven event when nothing to gate; \
+         events seen: {:?}",
+        names(&events)
+    );
+}
+
+/// Plan §2 + CR C-5: standalone stop-agent must keep "already absent is
+/// stopped=false, ok" behavior. The hard gate only runs in reset, not
+/// in stop-agent. This locks the boundary so the fix does not regress
+/// existing stop-agent contract.
+#[test]
+fn stop_agent_already_absent_still_returns_stopped_false() {
+    let ws = lanea_team_ws("stopped");
+    let transport = OfflineTransport::new().with_session_present(true);
+    let result = crate::lifecycle::stop_agent_with_transport(
+        &ws,
+        &aid("alpha"),
+        None,
+        &transport,
+    );
+    let report = result.expect("stop_agent must return Ok for absent agent");
+    assert!(
+        !report.stopped,
+        "stop_agent on already-absent worker returns stopped=false (no \
+         kill, contract preserved); got {report:?}"
+    );
+}
+
 // stop-agent — golden operations.py:98 writes stop_agent.complete {agent_id, target, stopped}
 // (+ stop_agent.window_stop_failed {agent_id, target, stderr} on kill failure). Rust emits none.
 #[test]

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

@@ -27,10 +27,10 @@ impl LaneTransport {
             spawns: std::sync::Arc::new(std::sync::Mutex::new(Vec::new())),
         }
     }
-    fn killed(&self) -> Vec<String> {
+    pub(super) fn killed(&self) -> Vec<String> {
         self.killed.lock().unwrap().clone()
     }
-    fn spawns(&self) -> Vec<(String, Vec<String>)> {
+    pub(super) fn spawns(&self) -> Vec<(String, Vec<String>)> {
         self.spawns.lock().unwrap().clone()
     }
 }
@@ -164,7 +164,7 @@ fn set_context_state_file(ws: &std::path::Path, name: &str) {
 /// Fork workspace: source `alpha` (role doc = `alpha_role`) + `bravo`, alpha seeded RUNNING with a
 /// source `session_id` (so fork reaches the spec-mutation / native-fork gate). Seeded-healthy coordinator
 /// (fork's start_coordinator -> AlreadyRunning, no real daemon). session_name = "team-laneateam".
-fn fork_ws(alpha_role: &str) -> PathBuf {
+pub(super) fn fork_ws(alpha_role: &str) -> PathBuf {
     let ws = temp_ws().join("forkv2");
     std::fs::create_dir_all(ws.join("agents")).unwrap();
     std::fs::write(ws.join("TEAM.md"), "---\nname: laneateam\nobjective: Fork v2 probe.\nprovider: codex\n---\n\nteam.\n").unwrap();

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

@@ -0,0 +1,321 @@
+use std::path::{Path, PathBuf};
+use std::time::Duration;
+
+use super::*;
+use crate::lifecycle::lock::{
+    acquire_agent_lifecycle_lock, acquire_agent_lifecycle_lock_for_test, LifecycleLockRequest,
+    AGENT_LIFECYCLE_LOCK_NAME, LIFECYCLE_LOCK_HELD_LONG, LIFECYCLE_LOCK_TIMEOUT,
+};
+
+#[test]
+fn lifecycle_lock_timeout_error_contract_and_constants() {
+    assert_eq!(AGENT_LIFECYCLE_LOCK_NAME, "agent-lifecycle");
+    assert_eq!(LIFECYCLE_LOCK_TIMEOUT, Duration::from_secs(30));
+    assert_eq!(LIFECYCLE_LOCK_HELD_LONG, Duration::from_secs(5));
+
+    let ws = temp_ws();
+    let err = LifecycleError::LifecycleLockTimeout {
+        lock_path: crate::model::paths::runtime_dir(&ws).join("agent-lifecycle.lock"),
+        log_path: crate::model::paths::logs_dir(&ws).join("events.jsonl"),
+        operation: "reset-agent".to_string(),
+        waited_ms: 30_000,
+    };
+    assert_eq!(
+        err.to_string(),
+        format!(
+            "error: lifecycle lock timeout after 30s\naction: retry or check for hung reset/start\nlog: {}",
+            crate::model::paths::logs_dir(&ws).join("events.jsonl").display()
+        )
+    );
+}
+
+#[test]
+fn lifecycle_lock_lifecycle_rollback_releases_after_timeout() {
+    let ws = temp_ws();
+    let agent = aid("alpha");
+    let held = acquire_agent_lifecycle_lock(LifecycleLockRequest {
+        workspace: &ws,
+        operation: "reset-agent",
+        team: Some("alpha"),
+        agent_id: Some(&agent),
+    })
+    .expect("hold lifecycle lock");
+
+    let waiter_ws = ws.clone();
+    let waiter_agent = aid("beta");
+    let result = std::thread::spawn(move || {
+        acquire_agent_lifecycle_lock_for_test(
+            LifecycleLockRequest {
+                workspace: &waiter_ws,
+                operation: "start-agent",
+                team: Some("alpha"),
+                agent_id: Some(&waiter_agent),
+            },
+            Duration::from_millis(200),
+            Duration::from_secs(5),
+        )
+    })
+    .join()
+    .expect("waiter thread");
+
+    assert!(
+        matches!(result, Err(LifecycleError::LifecycleLockTimeout { operation, .. }) if operation == "start-agent"),
+        "second lifecycle mutator must time out while lock is held"
+    );
+
+    drop(held);
+    acquire_agent_lifecycle_lock_for_test(
+        LifecycleLockRequest {
+            workspace: &ws,
+            operation: "stop-agent",
+            team: Some("alpha"),
+            agent_id: Some(&agent),
+        },
+        Duration::from_millis(200),
+        Duration::from_secs(5),
+    )
+    .expect("lock released after guard drop");
+}
+
+#[test]
+fn lifecycle_lock_long_held_event_records_holder_and_waiter() {
+    let ws = temp_ws();
+    let holder_agent = aid("holder");
+    let waiter_agent = aid("waiter");
+    let _held = acquire_agent_lifecycle_lock(LifecycleLockRequest {
+        workspace: &ws,
+        operation: "restart",
+        team: Some("alpha"),
+        agent_id: Some(&holder_agent),
+    })
+    .expect("hold lifecycle lock");
+
+    let waiter_ws = ws.clone();
+    let result = std::thread::spawn(move || {
+        acquire_agent_lifecycle_lock_for_test(
+            LifecycleLockRequest {
+                workspace: &waiter_ws,
+                operation: "reset-agent",
+                team: Some("alpha"),
+                agent_id: Some(&waiter_agent),
+            },
+            Duration::from_millis(220),
+            Duration::from_millis(50),
+        )
+    })
+    .join()
+    .expect("waiter thread");
+    assert!(matches!(
+        result,
+        Err(LifecycleError::LifecycleLockTimeout { .. })
+    ));
+
+    let events = read_events(&ws);
+    let event = events
+        .iter()
+        .find(|event| {
+            event.get("event").and_then(serde_json::Value::as_str)
+                == Some("lifecycle.lock_held_long")
+        })
+        .unwrap_or_else(|| panic!("missing lifecycle.lock_held_long event: {events:?}"));
+    assert_eq!(event["lock_name"], json!("agent-lifecycle"));
+    assert_eq!(event["operation"], json!("reset-agent"));
+    assert_eq!(event["holder"]["operation"], json!("restart"));
+    assert_eq!(event["holder"]["agent_id"], json!("holder"));
+    assert_eq!(event["threshold_ms"], json!(50));
+    assert_eq!(event["timeout_ms"], json!(220));
+    assert!(
+        event["blocked_queue_len"].as_u64().unwrap_or(0) >= 1,
+        "waiter sidecar should be visible while long-held event is emitted"
+    );
+}
+
+#[test]
+fn lifecycle_lock_phase_b_golden_source_guard() {
+    r2_lifecycle_lock_exists_precondition();
+}
+
+#[test]
+fn r2_lifecycle_lock_exists_precondition() {
+    let src = manifest_src();
+    let lock = read_src("lifecycle/lock.rs");
+    assert!(
+        lock.contains("AGENT_LIFECYCLE_LOCK_NAME: &str = \"agent-lifecycle\""),
+        "lifecycle lock name constant must remain explicit"
+    );
+    assert!(
+        lock.contains("LIFECYCLE_LOCK_TIMEOUT: Duration = Duration::from_secs(30)"),
+        "lifecycle lock timeout constant must remain 30s"
+    );
+    assert!(
+        lock.contains("write_lock_held_long_event") && lock.contains("lifecycle.lock_held_long"),
+        "long-held lifecycle lock event must remain wired"
+    );
+
+    let state_hits = source_files(&src.join("state"))
+        .into_iter()
+        .filter(|path| {
+            let text = std::fs::read_to_string(path).unwrap();
+            text.contains("RuntimeLock::acquire") && text.contains("\"state-save\"")
+        })
+        .collect::<Vec<_>>();
+    assert_eq!(
+        state_hits,
+        vec![src.join("state").join("persist.rs")],
+        "state-save lock must stay owned by state/persist.rs"
+    );
+
+    for path in source_files(&src.join("state")) {
+        let text = std::fs::read_to_string(&path).unwrap();
+        assert!(
+            !text.contains("LifecycleLock")
+                && !text.contains("acquire_agent_lifecycle_lock")
+                && !text.contains("agent-lifecycle"),
+            "state module must not acquire or know lifecycle lock: {}",
+            path.display()
+        );
+    }
+
+    for path in source_files(&src.join("coordinator")) {
+        let text = std::fs::read_to_string(&path).unwrap();
+        assert!(
+            !text.contains("acquire_agent_lifecycle_lock") && !text.contains("agent-lifecycle"),
+            "coordinator tick path must not block on lifecycle lock: {}",
+            path.display()
+        );
+    }
+
+    for path in source_files(&src) {
+        if path == src.join("state").join("persist.rs") || is_test_source(&path) {
+            continue;
+        }
+        let text = std::fs::read_to_string(&path).unwrap();
+        assert!(
+            !text.contains("RuntimeLock::acquire"),
+            "production source outside state/persist.rs must not acquire runtime locks directly: {}",
+            path.display()
+        );
+    }
+
+    for path in source_files(&src) {
+        if path.starts_with(src.join("state")) || path.starts_with(src.join("lifecycle")) {
+            continue;
+        }
+        let text = std::fs::read_to_string(&path).unwrap();
+        let lifecycle_topology_authority_entries = [
+            "save_runtime_state_with_lifecycle_topology_authority",
+            "save_team_scoped_state_with_lifecycle_topology_authority",
+            "save_runtime_state_with_team_tombstone_lifecycle_topology_authority",
+            "save_team_scoped_state_with_tombstone_lifecycle_topology_authority",
+        ];
+        assert!(
+            !lifecycle_topology_authority_entries
+                .iter()
+                .any(|entry| text.contains(entry)),
+            "lifecycle topology authority save entry must not be referenced outside lifecycle/state modules: {}",
+            path.display()
+        );
+    }
+
+    let agent = read_src("lifecycle/restart/agent.rs");
+    assert_public_operation(&agent, "start-agent");
+    assert_public_operation(&agent, "stop-agent");
+    assert_public_operation(&agent, "reset-agent");
+    assert_body_is_unlocked(&agent, "pub(crate) fn start_agent_at_paths");
+    assert_body_is_unlocked(&agent, "pub(super) fn stop_agent_at_paths");
+    assert_body_is_unlocked(&agent, "fn reset_agent_at_paths");
+
+    let remove = read_src("lifecycle/restart/remove.rs");
+    assert_public_operation(&remove, "remove-agent");
+    assert_body_is_unlocked(&remove, "fn remove_agent_at_paths");
+    assert!(
+        !remove.contains("start_agent_with_transport"),
+        "remove rollback runs while remove-agent holds the lifecycle lock; it must use lock-free start_agent_at_paths"
+    );
+
+    let launch = read_src("lifecycle/launch.rs");
+    assert_public_operation(&launch, "add-agent");
+    assert_public_operation(&launch, "fork-agent");
+    assert_body_is_unlocked(&launch, "fn add_agent_with_transport_at_paths");
+
+    let rebuild = read_src("lifecycle/restart/rebuild.rs");
+    assert_public_operation(&rebuild, "restart");
+    let drop_idx = rebuild.find("drop(lifecycle_lock);").unwrap();
+    let coordinator_idx = rebuild
+        .find("start_coordinator_for_workspace(&selected.run_workspace)")
+        .unwrap();
+    let readiness_idx = rebuild.find("wait_restart_readiness_or_timeout(").unwrap();
+    assert!(
+        rebuild.contains("let lifecycle_lock = acquire_agent_lifecycle_lock")
+            && drop_idx < coordinator_idx
+            && coordinator_idx < readiness_idx,
+        "restart must release lifecycle lock before coordinator readiness wait"
+    );
+}
+
+fn is_test_source(path: &Path) -> bool {
+    path.components()
+        .any(|component| component.as_os_str() == "tests")
+        || path
+            .file_name()
+            .and_then(|name| name.to_str())
+            .is_some_and(|name| name == "tests.rs" || name.ends_with("_tests.rs"))
+}
+
+fn read_events(workspace: &Path) -> Vec<serde_json::Value> {
+    let path = crate::model::paths::logs_dir(workspace).join("events.jsonl");
+    std::fs::read_to_string(path)
+        .unwrap_or_default()
+        .lines()
+        .filter_map(|line| serde_json::from_str(line).ok())
+        .collect()
+}
+
+fn manifest_src() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("src")
+}
+
+fn read_src(path: &str) -> String {
+    std::fs::read_to_string(manifest_src().join(path)).unwrap()
+}
+
+fn source_files(root: &Path) -> Vec<PathBuf> {
+    let mut out = Vec::new();
+    collect_rs_files(root, &mut out);
+    out.sort();
+    out
+}
+
+fn collect_rs_files(root: &Path, out: &mut Vec<PathBuf>) {
+    for entry in std::fs::read_dir(root).unwrap() {
+        let path = entry.unwrap().path();
+        if path.is_dir() {
+            collect_rs_files(&path, out);
+        } else if path.extension().and_then(|ext| ext.to_str()) == Some("rs") {
+            out.push(path);
+        }
+    }
+}
+
+fn assert_public_operation(source: &str, operation: &str) {
+    assert!(
+        source.contains("acquire_agent_lifecycle_lock")
+            && source.contains(&format!("operation: \"{operation}\"")),
+        "public lifecycle entry must acquire lifecycle lock for {operation}"
+    );
+}
+
+fn assert_body_is_unlocked(source: &str, signature: &str) {
+    let body = source
+        .split_once(signature)
+        .unwrap_or_else(|| panic!("missing signature: {signature}"))
+        .1;
+    let body = body
+        .split_once("\n}\n")
+        .map(|(body, _)| body)
+        .unwrap_or(body);
+    assert!(
+        !body.contains("acquire_agent_lifecycle_lock"),
+        "{signature} must remain lock-free to avoid nested reset deadlocks"
+    );
+}

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

@@ -33,7 +33,14 @@ type RecordedSpawns = LaneSpawns;
 /// every spawn (kind + argv) like `RecordingLaunchTransport`.
 struct SessionProbeRecordingTransport {
     spawns: RecordedSpawns,
+    spawn_targets: std::sync::Mutex<Vec<(String, String, String)>>,
     session_exists: bool,
+    // 0.4.10+ reset hard-gate: record killed panes so liveness/has_pane
+    // reflect the kill (the gate checks "did stop actually remove the
+    // old pane"). Default mock behavior reported Live unconditionally —
+    // safe pre-fix because no gate ran, but the gate now needs the kill
+    // to be observable.
+    killed_panes: std::sync::Mutex<std::collections::BTreeSet<String>>,
 }
 impl crate::transport::Transport for SessionProbeRecordingTransport {
     fn kind(&self) -> crate::transport::BackendKind {
@@ -41,11 +48,22 @@ impl crate::transport::Transport for SessionProbeRecordingTransport {
     }
     fn spawn_first(&self, session: &crate::transport::SessionName, window: &crate::transport::WindowName, argv: &[String], _cwd: &std::path::Path, _env: &std::collections::BTreeMap<String, String>) -> Result<crate::transport::SpawnResult, crate::transport::TransportError> {
         self.spawns.lock().unwrap().push(("spawn_first".to_string(), argv.to_vec()));
+        self.spawn_targets.lock().unwrap().push((
+            session.as_str().to_string(),
+            window.as_str().to_string(),
+            "%0".to_string(),
+        ));
         Ok(crate::transport::SpawnResult { pane_id: crate::transport::PaneId::new("%0"), session: session.clone(), window: window.clone(), child_pid: Some(6856) })
     }
     fn spawn_into(&self, session: &crate::transport::SessionName, window: &crate::transport::WindowName, argv: &[String], _cwd: &std::path::Path, _env: &std::collections::BTreeMap<String, String>) -> Result<crate::transport::SpawnResult, crate::transport::TransportError> {
         self.spawns.lock().unwrap().push(("spawn_into".to_string(), argv.to_vec()));
-        Ok(crate::transport::SpawnResult { pane_id: crate::transport::PaneId::new(format!("%{}", window.as_str())), session: session.clone(), window: window.clone(), child_pid: Some(6856) })
+        let pane = format!("%{}", window.as_str());
+        self.spawn_targets.lock().unwrap().push((
+            session.as_str().to_string(),
+            window.as_str().to_string(),
+            pane.clone(),
+        ));
+        Ok(crate::transport::SpawnResult { pane_id: crate::transport::PaneId::new(pane), session: session.clone(), window: window.clone(), child_pid: Some(6856) })
     }
     fn inject(&self, _t: &crate::transport::Target, _p: &crate::transport::InjectPayload, _s: crate::transport::Key, _b: bool) -> Result<crate::transport::InjectReport, crate::transport::TransportError> {
         unimplemented!("not reached by start_agent respawn")
@@ -62,11 +80,41 @@ impl crate::transport::Transport for SessionProbeRecordingTransport {
     fn query(&self, _t: &crate::transport::Target, _f: crate::transport::PaneField) -> Result<Option<String>, crate::transport::TransportError> {
         unimplemented!("not reached")
     }
-    fn liveness(&self, _p: &crate::transport::PaneId) -> Result<crate::model::enums::PaneLiveness, crate::transport::TransportError> {
+    fn liveness(&self, p: &crate::transport::PaneId) -> Result<crate::model::enums::PaneLiveness, crate::transport::TransportError> {
+        let killed = self.killed_panes.lock().unwrap();
+        if killed.contains(p.as_str()) {
+            return Ok(crate::model::enums::PaneLiveness::Dead);
+        }
         Ok(crate::model::enums::PaneLiveness::Live)
     }
+    fn has_pane(&self, p: &crate::transport::PaneId) -> Result<Option<bool>, crate::transport::TransportError> {
+        let killed = self.killed_panes.lock().unwrap();
+        Ok(Some(!killed.contains(p.as_str())))
+    }
+    fn kill_pane(&self, p: &crate::transport::PaneId) -> Result<(), crate::transport::TransportError> {
+        self.killed_panes.lock().unwrap().insert(p.as_str().to_string());
+        Ok(())
+    }
     fn list_targets(&self) -> Result<Vec<crate::transport::PaneInfo>, crate::transport::TransportError> {
-        Ok(Vec::new())
+        Ok(self
+            .spawn_targets
+            .lock()
+            .unwrap()
+            .iter()
+            .map(|(session, window, pane)| crate::transport::PaneInfo {
+                pane_id: crate::transport::PaneId::new(pane.as_str()),
+                session: crate::transport::SessionName::new(session.as_str()),
+                window_index: None,
+                window_name: Some(crate::transport::WindowName::new(window.as_str())),
+                pane_index: None,
+                tty: None,
+                current_command: Some("node".to_string()),
+                current_path: None,
+                active: false,
+                pane_pid: Some(6856),
+                leader_env: std::collections::BTreeMap::new(),
+            })
+            .collect())
     }
     fn has_session(&self, _s: &crate::transport::SessionName) -> Result<bool, crate::transport::TransportError> {
         Ok(self.session_exists)
@@ -115,10 +163,7 @@ fn start_agent_respawn_into_dead_session_uses_new_session_not_new_window() {
     let ws = respawn_ws_one_resumable_worker();
     let spawns = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
     // session_exists=false models the dead CP-1 `-L` server after --discard-session.
-    let transport = SessionProbeRecordingTransport {
-        spawns: std::sync::Arc::clone(&spawns),
-        session_exists: false,
-    };
+    let transport = SessionProbeRecordingTransport { spawns: std::sync::Arc::clone(&spawns), spawn_targets: std::sync::Mutex::new(Vec::new()), session_exists: false, killed_panes: std::sync::Mutex::new(std::collections::BTreeSet::new()) };
     let _ = start_agent_with_transport(&ws, &AgentId::new("alpha"), false, false, false, None, &transport);
     let recorded = spawns.lock().unwrap().clone();
     assert_eq!(recorded.len(), 1, "exactly one respawn for alpha; got {recorded:?}");
@@ -150,10 +195,7 @@ fn reset_agent_discard_session_rebuilds_window_via_start_respawn() {
     let ws = restart_ws_two_resumable_workers(); // compiled spec + state(alpha,bravo running) + seeded coordinator
     let spawns = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
     // live session present (other workers keep it alive) but alpha's window was discarded.
-    let transport = SessionProbeRecordingTransport {
-        spawns: std::sync::Arc::clone(&spawns),
-        session_exists: true,
-    };
+    let transport = SessionProbeRecordingTransport { spawns: std::sync::Arc::clone(&spawns), spawn_targets: std::sync::Mutex::new(Vec::new()), session_exists: true, killed_panes: std::sync::Mutex::new(std::collections::BTreeSet::new()) };
     let _ = reset_agent_with_transport(&ws, &AgentId::new("alpha"), true, false, None, &transport);
     let recorded = spawns.lock().unwrap().clone();
     assert!(
@@ -191,10 +233,7 @@ fn reset_agent_discard_session_syncs_projection_epoch_inputs_for_restart_agent_c
 
     let before = chrono::Utc::now();
     let spawns = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
-    let transport = SessionProbeRecordingTransport {
-        spawns: std::sync::Arc::clone(&spawns),
-        session_exists: true,
-    };
+    let transport = SessionProbeRecordingTransport { spawns: std::sync::Arc::clone(&spawns), spawn_targets: std::sync::Mutex::new(Vec::new()), session_exists: true, killed_panes: std::sync::Mutex::new(std::collections::BTreeSet::new()) };
     let outcome = reset_agent_with_transport(&ws, &AgentId::new("alpha"), true, false, None, &transport)
         .expect("reset-agent alpha --discard-session --no-display");
     assert!(