@team-agent/installer 0.4.7 → 0.4.9

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

@@ -636,6 +636,105 @@ fn classify_restart_plan_never_captured_null_session_auto_fresh_partial_resume()
     );
 }
 
+#[test]
+fn restart_required_missing_skips_never_captured_workers() {
+    // RESTART-RESUME-001 (0.4.8): the pre-selection convergence missing-set
+    // predicate must skip never-captured workers (null session_id, no
+    // first_send_at/last_result_at/task_prompt_delivered) so a single
+    // never-captured role doesn't burn the capture deadline and trigger
+    // resume_not_ready when the selection stage would auto-fresh it anyway.
+    use crate::lifecycle::restart::restart_required_missing_session_agent_ids;
+    let state = json!({
+        "agents": {
+            "w1": { "provider": "claude", "session_id": null, "status": "running" }
+        }
+    });
+    let missing = restart_required_missing_session_agent_ids(&state);
+    assert!(
+        missing.is_empty(),
+        "never-captured null-session worker must NOT appear in required-missing; \
+         got {missing:?}"
+    );
+}
+
+#[test]
+fn restart_required_missing_keeps_null_session_with_first_send_at() {
+    // RESTART-RESUME-001: null session_id + valid first_send_at means the
+    // leader DID send a message; that context must be preserved → still
+    // missing → restart refuses without --allow-fresh.
+    use crate::lifecycle::restart::restart_required_missing_session_agent_ids;
+    let state = json!({
+        "agents": {
+            "w1": {
+                "provider": "claude",
+                "session_id": null,
+                "status": "running",
+                "spawn_cwd": "/tmp/ws",
+                "first_send_at": "2026-01-01T00:00:00+00:00",
+            }
+        }
+    });
+    let missing = restart_required_missing_session_agent_ids(&state);
+    assert_eq!(
+        missing,
+        vec!["w1".to_string()],
+        "null-session + valid first_send_at (context bearing) must remain in \
+         required-missing; got {missing:?}"
+    );
+}
+
+#[test]
+fn restart_required_missing_keeps_null_session_with_last_result_at() {
+    // RESTART-RESUME-001: MCP / report_result paths may not have
+    // first_send_at, but a non-empty last_result_at means the worker DID
+    // produce a result; that context must be preserved.
+    use crate::lifecycle::restart::restart_required_missing_session_agent_ids;
+    let state = json!({
+        "agents": {
+            "w1": {
+                "provider": "claude",
+                "session_id": null,
+                "status": "running",
+                "spawn_cwd": "/tmp/ws",
+                "last_result_at": "2026-01-01T00:00:00+00:00",
+            }
+        }
+    });
+    let missing = restart_required_missing_session_agent_ids(&state);
+    assert_eq!(
+        missing,
+        vec!["w1".to_string()],
+        "null-session + last_result_at must remain in required-missing; \
+         got {missing:?}"
+    );
+}
+
+#[test]
+fn classify_restart_plan_null_session_with_last_result_at_refuses_without_allow_fresh() {
+    // RESTART-RESUME-001: selection stage must also refuse null-session +
+    // last_result_at (no first_send_at) without --allow-fresh. Otherwise the
+    // pre-selection convergence and selection-stage refuse semantics drift
+    // and the gate fails for MCP-only report paths.
+    let state = json!({
+        "agents": {
+            "w1": {
+                "provider": "claude",
+                "session_id": null,
+                "last_result_at": "2026-01-01T00:00:00+00:00",
+            }
+        }
+    });
+    let plan = classify_restart_plan(&state, false).expect("纯验证不应 Err");
+    assert_eq!(plan.decisions.len(), 1);
+    assert_eq!(
+        plan.decisions[0].decision,
+        ResumeDecision::Refuse,
+        "null-session + last_result_at must Refuse without --allow-fresh \
+         (context to preserve); got {:?}",
+        plan.decisions[0].decision
+    );
+}
+
 #[test]
 fn classify_restart_plan_never_interacted_null_session_with_allow_fresh_marks_forced_fresh() {
     // E6 层2: 同上自启动 null-session worker,但显式 --allow-fresh → 用户主动认账丢上下文 → FreshStart。

package/crates/team-agent/src/messaging/delivery.rs

@@ -452,6 +452,71 @@ pub fn deliver_pending_message(
             channel: None,
         });
     }
+    // S1-CAPTURE-001 (0.4.8, CR M4 Claude phase-1): for Claude/ClaudeCode
+    // recipients with a known authoritative rollout_path, verify the message
+    // token actually reached the worker's transcript before marking
+    // delivered. This catches the gate's mis-attribution: pane inject
+    // succeeded but the token landed in the leader/unassigned transcript,
+    // not the worker's. Budget per architect plan: 64KB tail / single
+    // per-delivery check / short grace window. Phase-1 Claude only —
+    // codex/copilot keep the pre-fix behaviour (will be addressed in
+    // phase-2 once Claude phase-1 is field-validated).
+    if let Some((rollout_path, provider_wire_str)) = claude_recipient_rollout(state, &message.recipient) {
+        let token_marker = format!("[team-agent-token:{message_id}]");
+        let grace = std::time::Duration::from_millis(200);
+        let deadline = std::time::Instant::now() + std::time::Duration::from_millis(500);
+        let mut transcript_has_token = false;
+        loop {
+            transcript_has_token =
+                rollout_tail_contains(&rollout_path, &token_marker, 64 * 1024);
+            if transcript_has_token || std::time::Instant::now() >= deadline {
+                break;
+            }
+            std::thread::sleep(grace);
+        }
+        if !transcript_has_token {
+            // Loud but non-fatal: emit a mismatch event for diagnose/status
+            // observability. Do NOT mark delivered — degrade to
+            // submitted_unverified so capture is forced to re-attribute.
+            let reason = format!(
+                "transcript_missing:provider={provider_wire_str},rollout={}",
+                rollout_path.display()
+            );
+            event_log.write(
+                "provider.session.transcript_mismatch",
+                serde_json::json!({
+                    "message_id": message_id,
+                    "recipient": message.recipient,
+                    "provider": provider_wire_str,
+                    "rollout_path": rollout_path.to_string_lossy(),
+                    "pane_id": state
+                        .get("agents")
+                        .and_then(|a| a.get(&message.recipient))
+                        .and_then(|a| a.get("pane_id"))
+                        .and_then(serde_json::Value::as_str)
+                        .unwrap_or(""),
+                    "spawn_epoch": state
+                        .get("agents")
+                        .and_then(|a| a.get(&message.recipient))
+                        .and_then(|a| a.get("spawn_epoch"))
+                        .and_then(serde_json::Value::as_u64)
+                        .unwrap_or(0),
+                    "reason": "transcript_missing",
+                }),
+            )?;
+            store.mark(message_id, "submitted_unverified", Some(&reason))?;
+            return Ok(DeliveryOutcome {
+                ok: false,
+                status: DeliveryStatus::Failed,
+                message_status: MessageStatusShadow("submitted_unverified".to_string()),
+                message_id: Some(message_id.to_string()),
+                verification: Some(reason),
+                stage: Some(DeliveryStage::Submit),
+                reason: None,
+                channel: None,
+            });
+        }
+    }
     store.mark(message_id, "delivered", None)?;
     event_log.write(
         "message.delivered",
@@ -1690,3 +1755,51 @@ pub fn retry_injection_after_trust_auto_answer(
         channel: None,
     })
 }
+
+/// S1-CAPTURE-001 (0.4.8 phase-1): returns (rollout_path, provider_wire) when
+/// the recipient agent is Claude/ClaudeCode with a known authoritative
+/// rollout_path; otherwise None (skip transcript verify). Phase-1 Claude only —
+/// codex/copilot return None and keep pre-fix delivery semantics.
+fn claude_recipient_rollout(
+    state: &serde_json::Value,
+    recipient: &str,
+) -> Option<(std::path::PathBuf, &'static str)> {
+    let agent = state.get("agents")?.get(recipient)?;
+    let provider = agent.get("provider").and_then(serde_json::Value::as_str)?;
+    let provider_wire_str = match provider {
+        "claude" => "claude",
+        "claude_code" | "claude-code" => "claude_code",
+        _ => return None,
+    };
+    let rollout = agent
+        .get("rollout_path")
+        .and_then(serde_json::Value::as_str)
+        .filter(|s| !s.is_empty())?;
+    Some((std::path::PathBuf::from(rollout), provider_wire_str))
+}
+
+/// S1-CAPTURE-001 (0.4.8 phase-1): bounded tail read of the rollout file
+/// searching for `needle`. Reads up to `tail_bytes` from the end of the file
+/// (default 64KB budget). Returns true iff the needle appears in the tail.
+/// Silent on read errors — callers treat missing/unreadable as "token not
+/// present" which forces the unverified path.
+fn rollout_tail_contains(path: &std::path::Path, needle: &str, tail_bytes: u64) -> bool {
+    use std::io::{Read, Seek, SeekFrom};
+    let Ok(mut file) = std::fs::File::open(path) else {
+        return false;
+    };
+    let Ok(metadata) = file.metadata() else {
+        return false;
+    };
+    let len = metadata.len();
+    let start = len.saturating_sub(tail_bytes);
+    if file.seek(SeekFrom::Start(start)).is_err() {
+        return false;
+    }
+    let mut buf = Vec::with_capacity(tail_bytes.min(len) as usize);
+    if file.take(tail_bytes).read_to_end(&mut buf).is_err() {
+        return false;
+    }
+    let haystack = String::from_utf8_lossy(&buf);
+    haystack.contains(needle)
+}

package/crates/team-agent/src/provider/session/capture.rs

@@ -296,7 +296,24 @@ where
                 .get("rollout_path")
                 .and_then(Value::as_str)
                 .is_some_and(|s| !s.is_empty());
-        if has_session {
+        // S1-CAPTURE-001 (0.4.8): a pending_session_id that differs from the
+        // on-row session_id means a fresh respawn is in flight — the prior
+        // worker's session_id may still be on the row (concurrent capture race,
+        // delayed persist, or persist-backfill replay) but the NEW worker has
+        // not yet been bound. Stamping capture_state=captured here would
+        // falsely declare the OLD session authoritative for the NEW worker
+        // pane — the leader/unassigned mis-attribution surfaced in S1-CAPTURE-001
+        // gate evidence. Only stamp `captured` when session_id agrees with
+        // _pending_session_id (or _pending is absent, meaning no rebind in
+        // flight).
+        let pending_mismatch = match (
+            agent_obj.get("_pending_session_id").and_then(Value::as_str).filter(|s| !s.is_empty()),
+            agent_obj.get("session_id").and_then(Value::as_str).filter(|s| !s.is_empty()),
+        ) {
+            (Some(pending), Some(current)) => pending != current,
+            _ => false,
+        };
+        if has_session && !pending_mismatch {
             // Captured already — fix state field if drifted.
             if agent_obj
                 .get("capture_state")
@@ -684,6 +701,29 @@ fn agent_session_complete(agent: &Value) -> bool {
     if !session_id_ok {
         return false;
     }
+    // S1-CAPTURE-001 (0.4.8, CR M3 provider-agnostic): pending mismatch guard.
+    // When fresh-start has written a new `_pending_session_id` but the old
+    // authoritative `session_id` is still present and differs, the tuple is
+    // STALE — the new process has a different session that has not been
+    // captured yet. Returning true here would let capture skip this agent
+    // and keep treating the old transcript as authoritative (the gate's
+    // observed mis-attribution). Force re-capture by reporting incomplete.
+    // The fresh-tuple clear in mark_agent_started (lifecycle/restart/agent.rs)
+    // is the primary fix; this guard handles historical poison state where
+    // both fields already coexist from a prior version.
+    let pending = agent
+        .get("_pending_session_id")
+        .and_then(Value::as_str)
+        .filter(|s| !s.is_empty());
+    let current = agent
+        .get("session_id")
+        .and_then(Value::as_str)
+        .filter(|s| !s.is_empty());
+    if let (Some(pending), Some(current)) = (pending, current) {
+        if pending != current {
+            return false;
+        }
+    }
     let rollout_path = match agent
         .get("rollout_path")
         .and_then(Value::as_str)
@@ -1002,6 +1042,16 @@ fn apply_captured_session(
         serde_json::to_value(captured.attribution_confidence).unwrap_or(Value::Null),
     );
     agent_obj.remove("attribution_ambiguous");
+    // S1-CAPTURE-001 (0.4.8): after writing the authoritative tuple, the
+    // `_pending_session_id` placeholder is no longer needed — remove it so
+    // future reads don't trip the pending-mismatch guard in
+    // agent_session_complete. Also stamp capture_state="captured" for
+    // diagnose/status observability.
+    agent_obj.remove("_pending_session_id");
+    agent_obj.insert(
+        "capture_state".to_string(),
+        serde_json::json!("captured"),
+    );
     true
 }
 
@@ -1784,4 +1834,84 @@ mod u1_tests {
         let _ = std::fs::remove_dir_all(workspace.join(".team"));
         let _ = std::fs::remove_dir_all(&workspace);
     }
+
+    /// S1-CAPTURE-001 (0.4.8): pending mismatch guard. When fresh-start has
+    /// written a new `_pending_session_id` but the old authoritative
+    /// `session_id` is still present and differs, `agent_session_complete`
+    /// must return false so capture re-runs and re-binds to the new process.
+    /// Without this, the historical poison state (old + new coexist) lets
+    /// the stale rollout look authoritative.
+    #[test]
+    fn agent_session_complete_returns_false_on_pending_mismatch() {
+        let dir = std::env::temp_dir().join(format!(
+            "ta-pending-mismatch-{}",
+            std::process::id()
+        ));
+        let _ = std::fs::create_dir_all(&dir);
+        let rollout = dir.join("old.jsonl");
+        std::fs::write(&rollout, "{\"type\":\"assistant\"}\n").unwrap();
+
+        let agent = serde_json::json!({
+            "provider": "claude",
+            "session_id": "old",
+            "rollout_path": rollout.to_string_lossy(),
+            "captured_at": "2026-01-01T00:00:00+00:00",
+            "captured_via": "fs_watch",
+            "_pending_session_id": "new",
+        });
+
+        assert!(
+            !super::agent_session_complete(&agent),
+            "S1-CAPTURE-001: pending != session_id must force incomplete \
+             (capture must re-attribute to new session)"
+        );
+
+        // Sanity: when they match, complete is true.
+        let agent_match = serde_json::json!({
+            "provider": "claude",
+            "session_id": "new",
+            "rollout_path": rollout.to_string_lossy(),
+            "captured_at": "2026-01-01T00:00:00+00:00",
+            "captured_via": "fs_watch",
+            "_pending_session_id": "new",
+        });
+        assert!(
+            super::agent_session_complete(&agent_match),
+            "pending == session_id (in-progress capture confirmed): must be complete"
+        );
+
+        let _ = std::fs::remove_file(&rollout);
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    /// S1-CAPTURE-001 (0.4.8): apply_captured_session clears
+    /// `_pending_session_id` and stamps `capture_state="captured"` so the
+    /// pending-mismatch guard doesn't fire on subsequent reads.
+    #[test]
+    fn apply_captured_session_clears_pending_and_stamps_capture_state() {
+        let mut agent = serde_json::Map::new();
+        agent.insert(
+            "_pending_session_id".to_string(),
+            serde_json::json!("new-sess"),
+        );
+        let captured = CapturedSession {
+            session_id: Some(SessionId::new("new-sess")),
+            rollout_path: Some(RolloutPath::new(PathBuf::from("/tmp/new.jsonl"))),
+            captured_via: CaptureVia::FsWatch,
+            attribution_confidence: Confidence::High,
+            spawn_cwd: PathBuf::from("/tmp/cwd"),
+        };
+        let written = super::apply_captured_session(&mut agent, &captured);
+        assert!(written, "apply must return true for valid captured");
+        assert!(
+            agent.get("_pending_session_id").is_none(),
+            "S1-CAPTURE-001: _pending_session_id must be removed after capture \
+             (agent={agent:?})"
+        );
+        assert_eq!(
+            agent.get("capture_state").and_then(serde_json::Value::as_str),
+            Some("captured"),
+            "S1-CAPTURE-001: capture_state must be stamped 'captured'"
+        );
+    }
 }

package/crates/team-agent/src/state/paths.rs

@@ -160,10 +160,14 @@ pub enum CommandScope {
     /// Caller passed `--team X` explicitly (or there's only one alive team
     /// and we resolved it). Carries the canonical team_key.
     Resolved(String),
-    /// No `--team` and multiple alive teams. Destructive commands MUST
-    /// refuse with this list of candidates so the operator chooses
-    /// explicitly. Read-only commands may still proceed (their scope is
-    /// "all teams" by default).
+    /// No `--team` and multiple alive teams. Destructive commands AND
+    /// selected-team commands (status, etc.) MUST refuse with this list
+    /// of candidates so the operator chooses explicitly. Only true
+    /// all-team aggregation commands may proceed without --team.
+    /// (S4QR-001 0.4.8: status was previously documented as a read-only
+    /// command that could proceed; in fact it projects a single team's
+    /// view and silently defaulting to the active team caused gate
+    /// failures when multiple alive teams existed.)
     Ambiguous(Vec<String>),
     /// No `--team` and no teams alive yet (fresh workspace) — bare
     /// commands fall through to legacy single-team behaviour.

package/crates/team-agent/src/state/persist.rs

@@ -560,6 +560,23 @@ fn backfill_capture_fields(incoming_agent: &mut Value, latest_agent: &Value) {
     if !latest_complete {
         return;
     }
+    // S1-CAPTURE-001 (0.4.8) Rule 5: a fresh restart marker (`_pending_session_id`
+    // present on incoming) signals the worker just respawned and the prior
+    // tuple was intentionally cleared. The capture scanner is the only path
+    // permitted to promote `_pending_session_id` into the authoritative tuple
+    // after it confirms backing. Persist-side backfill MUST NOT revive the
+    // latest tuple in this state — doing so resurrects the previous worker's
+    // session/rollout pair and delivered tokens land in the OLD transcript
+    // (the leader/unassigned mis-attribution surfaced in S1-CAPTURE-001 gate
+    // evidence). Refuse backfill regardless of whether incoming session_id
+    // is null vs latest's value: the pending marker is authoritative intent.
+    let incoming_pending = incoming_row
+        .get("_pending_session_id")
+        .and_then(Value::as_str)
+        .filter(|s| !s.is_empty());
+    if incoming_pending.is_some() {
+        return;
+    }
     // Rule 2: incoming carries a DIFFERENT non-null session_id → do not mix.
     let incoming_session = incoming_row.get("session_id").and_then(Value::as_str);
     let latest_session = latest_agent.get("session_id").and_then(Value::as_str);

package/crates/team-agent/src/tmux_backend.rs

@@ -636,7 +636,21 @@ impl TmuxBackend {
         first: bool,
     ) -> Result<SpawnResult, TransportError> {
         let command = shell_command(argv, cwd, env, env_unset);
-        let spawn_argv = tmux_spawn_argv(session, window, &command, first);
+        self.spawn_with_command(session, window, &command, first)
+    }
+
+    /// 0.4.x (CR C-2): spawn variant that takes a pre-built shell command
+    /// (used by `spawn_first_with_leader_shell_wrapper` /
+    /// `spawn_into_with_leader_shell_wrapper` to inject the leader wrapper
+    /// shape without going through `shell_command`'s `exec`-only template).
+    fn spawn_with_command(
+        &self,
+        session: &SessionName,
+        window: &WindowName,
+        command: &str,
+        first: bool,
+    ) -> Result<SpawnResult, TransportError> {
+        let spawn_argv = tmux_spawn_argv(session, window, command, first);
         self.run_spawn(&spawn_argv)?;
         let pane_argv = vec![
             "tmux".to_string(),
@@ -1327,6 +1341,75 @@ fn shell_command(
     parts.join(" ")
 }
 
+/// 0.4.x (CR R6): single-source marker prefix. The exit marker emitted by
+/// `leader_shell_wrapper_command` and the substring detected by
+/// `leader_provider_health` MUST share this prefix exactly. Format:
+/// `"[team-agent] {provider_label} exited with {rc}"`.
+pub const LEADER_PROVIDER_EXIT_MARKER_PREFIX: &str = "[team-agent]";
+pub const LEADER_PROVIDER_EXIT_MARKER_SUFFIX: &str = "exited with";
+
+/// 0.4.x (CR R6): build the leader exit marker text for `provider_label`.
+/// Used by both the shell wrapper (printf source) and the health check
+/// (capture substring) so they cannot drift.
+pub fn leader_provider_exit_marker(provider_label: &str) -> String {
+    format!(
+        "{LEADER_PROVIDER_EXIT_MARKER_PREFIX} {provider_label} {LEADER_PROVIDER_EXIT_MARKER_SUFFIX}"
+    )
+}
+
+/// 0.4.x (CR C-2): leader shell wrapper — provider runs as a CHILD of a
+/// long-lived shell, not as the pane's primary process. When the provider
+/// exits, the pane returns to an interactive shell with an explicit exit
+/// marker, matching manual `tmux new-session` then `claude` behaviour.
+///
+/// Four required envelope sections (CR C-2):
+///   1. cd <cwd>                    — same as `shell_command`
+///   2. unset <KEY> ...             — provider env_unset block
+///   3. KEY=val ... <provider>      — env exports + provider invocation
+///                                    (NO `exec` — runs as child)
+///   4. printf exit marker; exec shell -l
+///
+/// `provider_label` is a human-readable provider name (e.g. "claude",
+/// "codex") embedded in the exit marker for diagnostics.
+pub fn leader_shell_wrapper_command(
+    argv: &[String],
+    cwd: &Path,
+    env: &BTreeMap<String, String>,
+    env_unset: &[String],
+    provider_label: &str,
+) -> String {
+    let mut parts = Vec::new();
+    // 1. cd
+    parts.push("cd".to_string());
+    parts.push(shell_quote(&cwd.to_string_lossy()));
+    parts.push("&&".to_string());
+    // 2. unset
+    for key in env_unset {
+        parts.push("unset".to_string());
+        parts.push(key.clone());
+        parts.push("&&".to_string());
+    }
+    // 3. env exports + provider (NO `exec` so the provider is a child)
+    for (key, value) in env {
+        parts.push(format!("{key}={}", shell_quote(value)));
+    }
+    parts.extend(argv.iter().map(|arg| shell_quote(arg)));
+    parts.push(";".to_string());
+    // 4. exit marker + fall back to interactive shell
+    parts.push("rc=$?;".to_string());
+    parts.push("printf".to_string());
+    // CR R6: marker text comes from single-source `leader_provider_exit_marker`.
+    parts.push(shell_quote(&format!(
+        "\n{} %s\n",
+        leader_provider_exit_marker(provider_label)
+    )));
+    parts.push("\"$rc\";".to_string());
+    parts.push("exec".to_string());
+    parts.push("\"${SHELL:-/bin/zsh}\"".to_string());
+    parts.push("-l".to_string());
+    parts.join(" ")
+}
+
 fn shell_quote(raw: &str) -> String {
     if raw.is_empty() {
         return "''".to_string();
@@ -1422,6 +1505,38 @@ impl Transport for TmuxBackend {
         self.spawn_split(session, window, argv, cwd, env, env_unset)
     }
 
+    /// 0.4.x (CR C-2): TmuxBackend override of the leader-shell-wrapper
+    /// variant. Builds the wrapper shell line via
+    /// `leader_shell_wrapper_command` and runs it through
+    /// `spawn_with_command` (bypassing the default `exec <cmd>` shape).
+    fn spawn_first_with_leader_shell_wrapper(
+        &self,
+        session: &SessionName,
+        window: &WindowName,
+        argv: &[String],
+        cwd: &Path,
+        env: &BTreeMap<String, String>,
+        env_unset: &[String],
+        provider_label: &str,
+    ) -> Result<SpawnResult, TransportError> {
+        let command = leader_shell_wrapper_command(argv, cwd, env, env_unset, provider_label);
+        self.spawn_with_command(session, window, &command, true)
+    }
+
+    fn spawn_into_with_leader_shell_wrapper(
+        &self,
+        session: &SessionName,
+        window: &WindowName,
+        argv: &[String],
+        cwd: &Path,
+        env: &BTreeMap<String, String>,
+        env_unset: &[String],
+        provider_label: &str,
+    ) -> Result<SpawnResult, TransportError> {
+        let command = leader_shell_wrapper_command(argv, cwd, env, env_unset, provider_label);
+        self.spawn_with_command(session, window, &command, false)
+    }
+
     fn inject(
         &self,
         target: &Target,

package/crates/team-agent/src/transport/test_support.rs

@@ -50,6 +50,9 @@ struct OfflineState {
     /// U1-C Tail-peek contract: every `capture()` call records its `CaptureRange`,
     /// in order, so a test can prove the delivery peek site narrowed Full → Tail(80).
     capture_ranges: Vec<CaptureRange>,
+    /// 0.4.x (CR C-3 / CR C-5): pre-staged `query(PaneField::PaneCurrentCommand)`
+    /// answer keyed by pane id. Used by leader provider health tests.
+    pane_current_commands: BTreeMap<String, String>,
 }
 
 impl Default for OfflineState {
@@ -73,6 +76,7 @@ impl Default for OfflineState {
             list_targets_error: None,
             capture_text: BTreeMap::new(),
             capture_ranges: Vec::new(),
+            pane_current_commands: BTreeMap::new(),
         }
     }
 }
@@ -163,6 +167,52 @@ impl OfflineTransport {
         self
     }
 
+    /// 0.4.x (CR C-3 / CR C-5): pre-stage a `pane_current_command` answer
+    /// for `query(PaneField::PaneCurrentCommand)`. Used by leader provider
+    /// health tests to simulate "pane is now in a shell" vs
+    /// "pane is running the provider".
+    pub fn with_pane_current_command(
+        self,
+        pane_id: impl Into<String>,
+        command: impl Into<String>,
+    ) -> Self {
+        self.with_state(|state| {
+            state.pane_current_commands.insert(pane_id.into(), command.into());
+        });
+        self
+    }
+
+    /// 0.4.x (CR C-3 / CR C-5): mutable setters for fluent test seeding
+    /// (alternative to builder chain when the transport already exists).
+    pub fn set_pane_addressable(&self, pane: &PaneId, addressable: bool) {
+        self.with_state(|state| {
+            state.liveness.insert(
+                pane.as_str().to_string(),
+                if addressable {
+                    PaneLiveness::Live
+                } else {
+                    PaneLiveness::Dead
+                },
+            );
+        });
+    }
+
+    pub fn set_pane_current_command(&self, pane: &PaneId, command: &str) {
+        self.with_state(|state| {
+            state
+                .pane_current_commands
+                .insert(pane.as_str().to_string(), command.to_string());
+        });
+    }
+
+    pub fn set_pane_capture(&self, pane: &PaneId, text: &str) {
+        self.with_state(|state| {
+            state
+                .capture_text
+                .insert(pane.as_str().to_string(), text.to_string());
+        });
+    }
+
     /// Pre-stage `capture()` output for a `Target::SessionWindow{session,window}` key.
     pub fn with_capture_for_session_window(
         self,
@@ -378,11 +428,20 @@ impl Transport for OfflineTransport {
 
     fn query(
         &self,
-        _target: &Target,
-        _field: PaneField,
+        target: &Target,
+        field: PaneField,
     ) -> Result<Option<String>, TransportError> {
         self.record("query");
-        Ok(None)
+        if !matches!(field, PaneField::PaneCurrentCommand) {
+            return Ok(None);
+        }
+        let pane_id = match target {
+            Target::Pane(p) => p.as_str().to_string(),
+            Target::SessionWindow { .. } => return Ok(None),
+        };
+        Ok(self.with_state(|state| {
+            state.pane_current_commands.get(&pane_id).cloned()
+        }))
     }
 
     fn liveness(&self, pane: &PaneId) -> Result<PaneLiveness, TransportError> {