@team-agent/installer 0.3.39 → 0.4.0

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

@@ -0,0 +1,187 @@
+//! unit-0 (Stage 0) characterization tests for restart resume preflight.
+//!
+//! These pin the current `classify_restart_plan` behavior so that the
+//! Stage 2 refactor (unit-5: replace the opaque `session_unresumable`
+//! string with a `ResumeRefusalReason` enum + structured backing-store
+//! check) is detectable as a behavior change rather than an accidental
+//! regression.
+//!
+//! Pinned invariants:
+//! - A worker with `session_id` set but backing store absent is currently
+//!   tagged with the OPAQUE string `session_unresumable`. unit-5 must
+//!   evolve this to a structured reason (e.g. `session_backing_store_missing`).
+//! - A worker with NO `session_id` is currently tagged
+//!   `no_persisted_session_id` — distinct from the missing-backing case.
+//!   unit-5 must keep this distinction.
+//! - `allow_fresh=true` converts both refusal classes into a `FreshStart`
+//!   decision (no entries in `unresumable`).
+
+use super::*;
+use crate::lifecycle::restart::classify_restart_plan;
+use crate::lifecycle::types::{ResumeDecision, StartMode};
+
+fn agent_codex(session_id: Option<&str>, first_send_at: serde_json::Value) -> serde_json::Value {
+    let mut obj = serde_json::Map::new();
+    obj.insert("provider".to_string(), json!("codex"));
+    obj.insert("status".to_string(), json!("running"));
+    obj.insert("first_send_at".to_string(), first_send_at);
+    if let Some(sid) = session_id {
+        obj.insert("session_id".to_string(), json!(sid));
+    }
+    serde_json::Value::Object(obj)
+}
+
+#[test]
+fn unit0_restart_missing_session_id_is_no_persisted_session_id() {
+    let state = json!({
+        "agents": {
+            "a": agent_codex(None, json!("2026-01-01T00:00:00Z")),
+        }
+    });
+    let plan = classify_restart_plan(&state, false).unwrap();
+    assert_eq!(plan.unresumable.len(), 1);
+    assert_eq!(plan.unresumable[0].agent_id.as_str(), "a");
+    assert_eq!(plan.unresumable[0].reason, "no_persisted_session_id");
+    assert!(plan.unresumable[0].session_id.is_none());
+}
+
+#[test]
+fn unit0_restart_session_id_present_no_backing_is_session_unresumable() {
+    // session_id is set, but resume_backing_exists_for_agent will return
+    // false because no workspace was passed AND rollout_path is missing.
+    // The current behavior is to flatten this into `session_unresumable`
+    // — the opaque reason that unit-5 will replace with structured enum.
+    let state = json!({
+        "agents": {
+            "a": agent_codex(Some("sess-unit0-missing"), json!("2026-01-01T00:00:00Z")),
+        }
+    });
+    let plan = classify_restart_plan(&state, false).unwrap();
+    assert_eq!(plan.unresumable.len(), 1);
+    assert_eq!(plan.unresumable[0].agent_id.as_str(), "a");
+    assert_eq!(plan.unresumable[0].reason, "session_unresumable");
+    assert!(plan.unresumable[0].session_id.is_some());
+}
+
+#[test]
+fn unit0_restart_allow_fresh_converts_refusals_into_fresh_decisions() {
+    let state = json!({
+        "agents": {
+            "a": agent_codex(None, json!("2026-01-01T00:00:00Z")),
+            "b": agent_codex(Some("sess-unit0-allow-fresh"), json!("2026-01-01T00:00:00Z")),
+        }
+    });
+    let plan = classify_restart_plan(&state, true).unwrap();
+    // Both unresumable-class workers should be turned into FreshStart.
+    assert!(
+        plan.unresumable.is_empty(),
+        "allow_fresh should drain the unresumable bucket; got {:?}",
+        plan.unresumable
+    );
+    assert_eq!(plan.decisions.len(), 2);
+    for d in &plan.decisions {
+        assert!(
+            matches!(d.restart_mode, StartMode::Fresh),
+            "agent {} should be Fresh under allow_fresh; got {:?}",
+            d.agent_id.as_str(),
+            d.restart_mode
+        );
+    }
+    let _ = ResumeDecision::FreshStart; // touch the enum so unused-import lint stays quiet.
+}
+
+#[test]
+fn layer2_backing_missing_refusal_carries_checked_paths_and_recovery_hint() {
+    // Leader follow-up 2026-06-22: when classify_restart_plan_with_resume_validation
+    // runs with a real workspace, a codex worker whose session_id is set
+    // but whose rollout_path does not exist on disk should produce a
+    // refusal whose structured ResumeRefusalReason::SessionBackingStoreMissing
+    // carries the actual probed paths (the persisted rollout_path) AND a
+    // RecoveryHint with the agent_id as the picker name.
+    use std::sync::atomic::{AtomicU32, Ordering};
+    static N: AtomicU32 = AtomicU32::new(0);
+    let n = N.fetch_add(1, Ordering::Relaxed);
+    let ws = std::env::temp_dir().join(format!(
+        "ta_rs_l2_backingmiss_{}_{}",
+        std::process::id(),
+        n
+    ));
+    std::fs::create_dir_all(&ws).unwrap();
+
+    let missing_rollout = ws.join(".missing-rollout.jsonl");
+    // Do NOT create the file. Probe must report it as not-existing AND
+    // include it in checked_paths.
+    let mut agent = serde_json::Map::new();
+    agent.insert("provider".to_string(), json!("codex"));
+    agent.insert("status".to_string(), json!("running"));
+    agent.insert("session_id".to_string(), json!("sess-layer2-missing"));
+    agent.insert(
+        "rollout_path".to_string(),
+        json!(missing_rollout.to_string_lossy()),
+    );
+    agent.insert("first_send_at".to_string(), json!("2026-01-01T00:00:00Z"));
+    agent.insert("spawn_cwd".to_string(), json!(ws.to_string_lossy()));
+    let state = json!({ "agents": { "a": serde_json::Value::Object(agent) } });
+
+    let plan = crate::lifecycle::restart::classify_restart_plan_with_resume_validation(
+        Some(&ws),
+        &state,
+        false,
+    )
+    .unwrap();
+    assert_eq!(plan.unresumable.len(), 1);
+    let entry = &plan.unresumable[0];
+    assert_eq!(entry.agent_id.as_str(), "a");
+    assert_eq!(entry.reason, "session_unresumable");
+    match entry.refusal_reason.as_ref() {
+        Some(crate::provider::session::ResumeRefusalReason::SessionBackingStoreMissing {
+            checked_paths,
+            recovery_hint,
+        }) => {
+            assert!(
+                !checked_paths.is_empty(),
+                "checked_paths must be populated; got empty"
+            );
+            assert!(
+                checked_paths.iter().any(|p| p == &missing_rollout),
+                "checked_paths must include the persisted rollout_path; got {checked_paths:?}"
+            );
+            let hint = recovery_hint
+                .as_ref()
+                .expect("recovery_hint should be populated");
+            assert_eq!(
+                hint.provider_session_name_hint.as_deref(),
+                Some("a"),
+                "name hint must equal agent_id"
+            );
+            assert_eq!(
+                hint.spawn_cwd.as_deref(),
+                Some(ws.as_path()),
+                "spawn_cwd should round-trip through the hint"
+            );
+            assert_eq!(hint.provider, "codex");
+        }
+        other => panic!(
+            "expected SessionBackingStoreMissing with structured fields; got {:?}",
+            other
+        ),
+    }
+}
+
+#[test]
+fn unit0_restart_corrupt_first_send_at_blocks_before_resume_classification() {
+    // The corrupt-first_send_at branch is the hard-refuse gate that fires
+    // BEFORE resume classification. This pins that corrupt entries land in
+    // `corrupt_entries` (with python type name) and the unresumable bucket
+    // stays empty for the corrupt agent.
+    let state = json!({
+        "agents": {
+            "a": agent_codex(Some("sess-unit0-corrupt"), json!(false)),
+        }
+    });
+    let plan = classify_restart_plan(&state, false).unwrap();
+    assert_eq!(plan.corrupt_entries.len(), 1);
+    assert_eq!(plan.corrupt_entries[0].worker_id.as_str(), "a");
+    assert_eq!(plan.corrupt_entries[0].raw_first_send_at_type, "bool");
+    assert!(plan.unresumable.is_empty());
+}

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

@@ -25,3 +25,4 @@ mod launch_spawn;
 mod agent_ops;
 mod lane_ops;
 mod main_preserved;
+mod restart;

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

@@ -667,6 +667,18 @@ pub enum RestartReport {
         allow_fresh: bool,
         error: String,
     },
+    /// unit-3 (Stage 1): session-identity preflight refused — `state.session_name`
+    /// is a leader launcher session (`team-agent-leader-*`). Proceeding would
+    /// tear down the leader pane (E49 / 0.3.39). **nothing created or killed**.
+    RefusedDirtyTopology {
+        /// The session name that failed the preflight, verbatim from state.
+        session_name: String,
+        /// Stable machine-readable reason (currently
+        /// `"worker_session_is_leader_session"`).
+        reason: String,
+        /// Human-readable error directing the user to a recovery action.
+        error: String,
+    },
 }
 
 /// 单个重建后的 worker(carry restart_mode)。
@@ -690,11 +702,18 @@ pub struct RestartFailedAgent {
 }
 
 /// atomic refusal 里的不可重建 worker(`orchestration.py:517`)。
+///
+/// unit-5 (Stage 2): `reason` 是历史 free-form 字符串,JSON/CLI 直接吃它;新增
+/// `refusal_reason` 携带 unit-5 的 closed enum(`provider::session::ResumeRefusalReason`)
+/// 同源 wire 字符串。两者必须 round-trip 一致(see `ResumeRefusalReason::wire`)。
+/// 旧调用方读 `reason` 不变;新调用方走 enum 拿到结构化原因。
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct UnresumableWorker {
     pub agent_id: AgentId,
-    /// `no_persisted_session_id` | `session_unresumable`。
+    /// `no_persisted_session_id` | `session_unresumable` | `session_backing_store_missing` | …
     pub reason: String,
+    /// unit-5 structured refusal (optional during migration; populated alongside `reason`).
+    pub refusal_reason: Option<crate::provider::session::ResumeRefusalReason>,
     pub session_id: Option<SessionId>,
     pub first_send_at: Option<String>,
 }

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

@@ -221,9 +221,36 @@ pub(crate) fn delivery_outcome_value(out: &DeliveryOutcome) -> Value {
     value
 }
 
-pub(crate) fn latest_task_for_assignee(workspace: &Path, agent_id: &str) -> Option<String> {
+/// Find the latest nonterminal task assigned to `agent_id`.
+///
+/// Blocker-1 (prerelease 0.4.0): scoped teams own their tasks under
+/// `state.teams.<owner>.tasks`; top-level `state.tasks` is the legacy /
+/// fallback list and is often stale or assigned to a different agent in
+/// scoped-team workspaces. Search the scoped view first (when an owner team
+/// is supplied), then fall back to top-level.
+pub(crate) fn latest_task_for_assignee(
+    workspace: &Path,
+    agent_id: &str,
+    owner_team_id: Option<&str>,
+) -> Option<String> {
     let state = load_runtime_state(workspace).ok()?;
+    if let Some(owner) = owner_team_id.filter(|s| !s.is_empty()) {
+        if let Some(tasks) = state
+            .get("teams")
+            .and_then(|teams| teams.get(owner))
+            .and_then(|team| team.get("tasks"))
+            .and_then(Value::as_array)
+        {
+            if let Some(id) = find_latest_nonterminal_task_for(tasks, agent_id) {
+                return Some(id);
+            }
+        }
+    }
     let tasks = state.get("tasks").and_then(Value::as_array)?;
+    find_latest_nonterminal_task_for(tasks, agent_id)
+}
+
+fn find_latest_nonterminal_task_for(tasks: &[Value], agent_id: &str) -> Option<String> {
     for task in tasks.iter().rev() {
         let assignee = task.get("assignee").and_then(Value::as_str)?;
         if assignee != agent_id {
@@ -246,3 +273,47 @@ pub(crate) fn latest_task_for_assignee(workspace: &Path, agent_id: &str) -> Opti
     }
     None
 }
+
+/// Find the most recent delivered direct message to `agent_id` whose `task_id`
+/// is empty/null AND for which no result row exists yet. Used by
+/// `report_result` as a message-scoped fallback before defaulting to
+/// `"manual"`, so `collect` can correlate via the existing message-scope path
+/// (`messaging::results::is_message_scoped_result`).
+pub(crate) fn latest_uncorrelated_delivered_message_for(
+    workspace: &Path,
+    agent_id: &str,
+    owner_team_id: Option<&str>,
+) -> Option<String> {
+    use crate::db::message_store::MessageStore;
+    let store = MessageStore::open(workspace).ok()?;
+    let conn = crate::db::schema::open_db(store.db_path()).ok()?;
+    let sql = match owner_team_id {
+        Some(_) => "select m.message_id from messages m \
+                     where m.recipient = ?1 and m.status = 'delivered' \
+                       and (m.task_id is null or m.task_id = '') \
+                       and m.owner_team_id = ?2 \
+                       and not exists ( \
+                         select 1 from results r \
+                         where r.task_id = m.message_id and r.agent_id = m.recipient \
+                       ) \
+                     order by m.created_at desc limit 1",
+        None => "select m.message_id from messages m \
+                     where m.recipient = ?1 and m.status = 'delivered' \
+                       and (m.task_id is null or m.task_id = '') \
+                       and not exists ( \
+                         select 1 from results r \
+                         where r.task_id = m.message_id and r.agent_id = m.recipient \
+                       ) \
+                     order by m.created_at desc limit 1",
+    };
+    let mut stmt = conn.prepare(sql).ok()?;
+    let id: Option<String> = match owner_team_id {
+        Some(team) => stmt
+            .query_row(rusqlite::params![agent_id, team], |row| row.get::<_, String>(0))
+            .ok(),
+        None => stmt
+            .query_row(rusqlite::params![agent_id], |row| row.get::<_, String>(0))
+            .ok(),
+    };
+    id
+}

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

@@ -19,7 +19,8 @@ use crate::messaging::{self, MessageTarget, SendOptions};
 
 use super::helpers::{
     delivery_outcome_value, ensure_object, enum_value, insert_array, is_worker_recipient,
-    json_dumps_default, latest_task_for_assignee, non_empty_string, normalized_envelope_value, object_fields,
+    json_dumps_default, latest_task_for_assignee, latest_uncorrelated_delivered_message_for,
+    non_empty_string, normalized_envelope_value, object_fields,
     requires_ack_for_target, tool_runtime_error,
 };
 use super::normalize::{
@@ -292,11 +293,35 @@ impl TeamOrchestratorTools {
                 obj.insert("status".to_string(), enum_value(status));
             }
             if !obj.contains_key("task_id") {
+                // Blocker-1 (prerelease 0.4.0): scoped-team task inference +
+                // message-scoped fallback, before defaulting to "manual".
+                //   1. explicit arg
+                //   2. latest nonterminal task assigned to this agent in
+                //      teams.<owner>.tasks (scoped) → top-level tasks
+                //   3. latest delivered direct message to this agent with no
+                //      task id and no result yet (message-scope correlation —
+                //      collect path: is_message_scoped_result)
+                //   4. "manual" — truly uncorrelated; collect still rejects
+                let owner_team_id_str = self
+                    .owner_team_id
+                    .as_ref()
+                    .map(|t| t.as_str().to_string());
                 let resolved = task_id
                     .map(ToString::to_string)
-                    .or_else(|| self.agent_id
-                        .as_ref()
-                        .and_then(|agent| latest_task_for_assignee(&self.workspace, agent.as_str())))
+                    .or_else(|| self.agent_id.as_ref().and_then(|agent| {
+                        latest_task_for_assignee(
+                            &self.workspace,
+                            agent.as_str(),
+                            owner_team_id_str.as_deref(),
+                        )
+                    }))
+                    .or_else(|| self.agent_id.as_ref().and_then(|agent| {
+                        latest_uncorrelated_delivered_message_for(
+                            &self.workspace,
+                            agent.as_str(),
+                            owner_team_id_str.as_deref(),
+                        )
+                    }))
                     .unwrap_or_else(|| "manual".to_string());
                 obj.insert("task_id".to_string(), Value::String(resolved));
             }

package/crates/team-agent/src/provider/adapter.rs

@@ -455,6 +455,18 @@ impl ProviderAdapter for BasicProviderAdapter {
                 )?;
                 argv.push("--session-id".to_string());
                 argv.push(expected.clone());
+                // Layer 1 self-healing (architect probe 2026-06-22, claude help
+                // `-n, --name <name>`): pass `--name <agent_id>` so the
+                // resume picker and on-disk `~/.claude/sessions/*.json name`
+                // field carry our role label. This is a secondary diagnostic
+                // hint — primary restart key remains `session_id + backing
+                // store revalidation` (see provider/session/resume.rs).
+                if let Some(agent_id) = ctx.agent_id_hint {
+                    if !agent_id.is_empty() {
+                        argv.push("--name".to_string());
+                        argv.push(agent_id.to_string());
+                    }
+                }
                 Ok(CommandPlan {
                     argv,
                     expected_session_id: Some(SessionId::new(expected)),
@@ -654,6 +666,15 @@ impl ProviderAdapter for BasicProviderAdapter {
                 )?;
                 argv.push("--resume".to_string());
                 argv.push(session_id.as_str().to_string());
+                // Layer 1 self-healing: keep the role name on resume too —
+                // makes resumed sessions findable in the picker by agent_id
+                // when state.json drifts.
+                if let Some(agent_id) = ctx.agent_id_hint {
+                    if !agent_id.is_empty() {
+                        argv.push("--name".to_string());
+                        argv.push(agent_id.to_string());
+                    }
+                }
                 let mut plan = CommandPlan::argv_only(argv);
                 plan.provider_projects_root = ctx
                     .profile_launch
@@ -1195,7 +1216,16 @@ fn candidate_session_files(
                 collect_optional_candidate_files(&home.join(".codex").join("sessions"), &context.agent_id, &mut out)?;
             }
             Provider::Claude | Provider::ClaudeCode => {
-                collect_optional_candidate_files(&home.join(".claude").join("sessions"), &context.agent_id, &mut out)?;
+                // Blocker-2 Layer-1 (prerelease 0.4.0): the activity rollout_path
+                // MUST be the real transcript under .claude/projects/<encoded cwd>/
+                // <session_id>.jsonl. ~/.claude/sessions/<pid>.json is a small
+                // session-metadata file (~300-400 bytes) that contains a
+                // sessionId but no lifecycle records; if it wins capture, the
+                // activity classifier reads it forever and never sees the real
+                // transcript. Architect verdict (bugs-prerelease-blockers.md §138):
+                // do not let .claude/sessions/<pid>.json become rollout_path.
+                // Skip that directory entirely; resume backing probe still scans
+                // it via its own path checks in restart/common.rs.
                 // E6 层1·B:优先锚到 ~/.claude/projects/<canonical spawn_cwd 编码> 子目录
                 // (claude 把 cwd 的 '/' 编码成 '-';交互式 worker 的真实 transcript 落在此),
                 // 而非全 projects 树盲扫(交互式 claude 自生成 UUID,锚 cwd 子目录 + 时间窗才能唯一选)。

package/crates/team-agent/src/provider/approvals/runtime_prompts.rs

@@ -16,6 +16,31 @@ pub fn runtime_mcp_prompt_allowlisted(prompt: &ApprovalPrompt) -> bool {
         && prompt.tool.as_deref().is_some_and(runtime_mcp_tool_allowlisted)
 }
 
+/// Issue 1 (Round 3b gate review §6): Team-Agent control-plane MCP tools
+/// that are safe to auto-approve INDEPENDENT of `leader_auto_approval_allowed`.
+/// These tools never execute user-supplied commands; they are pure team-coord
+/// state transitions. Without this carve-out, a worker spawned by a leader
+/// that lacks a dangerous-bypass flag would have `report_result` blocked at
+/// the MCP approval gate, breaking the entire result-collection pipeline.
+///
+/// Strict scope:
+///   * server MUST be `team_orchestrator` (RUNTIME_MCP_APPROVAL_SERVER) —
+///     never broaden to arbitrary MCP servers.
+///   * tool MUST be one of the explicit safe-list entries. `report_result`
+///     is the canonical case; `send_message` is added because a worker
+///     reporting status to leader through the message bus is the same
+///     architectural layer as `report_result` and is harmless. New tools
+///     join only after explicit product decision (per architect note).
+pub fn runtime_mcp_tool_is_internal_control_plane(prompt: &ApprovalPrompt) -> bool {
+    if prompt.server.as_deref() != Some(RUNTIME_MCP_APPROVAL_SERVER) {
+        return false;
+    }
+    matches!(
+        prompt.tool.as_deref(),
+        Some("report_result") | Some("send_message")
+    )
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum RuntimeApprovalDecision {
@@ -81,6 +106,15 @@ pub fn awaiting_human_confirm_reason(
         ApprovalKind::McpTool => {
             if !runtime_mcp_prompt_allowlisted(prompt) {
                 Some("tool_not_allowlisted")
+            } else if runtime_mcp_tool_is_internal_control_plane(prompt) {
+                // Issue 1 (Round 3b gate review §6): Team-Agent control-plane
+                // MCP tools (report_result / send_message) auto-approve
+                // independent of leader dangerous-bypass. Without this,
+                // workers spawned under a non-bypass leader can never
+                // collect results — the entire correlation pipeline blocks
+                // at the MCP approval gate. Command approvals still go
+                // through `ApprovalKind::Command` and stay human-gated.
+                None
             } else if !leader_auto_approval_allowed {
                 Some("leader_restricted")
             } else {

package/crates/team-agent/src/provider/classify.rs

@@ -33,6 +33,28 @@ pub fn classify(
         ));
     }
     let facts = extract_lifecycle_facts(provider, &records);
+    // Blocker-2 Layer-2 (prerelease 0.4.0): Claude background-task lifecycle.
+    // Claude's long-running work (e.g. `Bash run_in_background:true`,
+    // followed by `task-notification status=completed`) can outlive the
+    // assistant turn that started it. The existing lifecycle-fact scan
+    // recognises `assistant.stop_reason=end_turn` as TurnComplete, so the
+    // classifier would otherwise mark the worker idle while a background
+    // shell continues. Synthesize a Working fact when at least one
+    // background task started but has not yet been closed. Architect
+    // verdict: bugs-prerelease-blockers.md §141-§143.
+    if matches!(provider, Provider::Claude | Provider::ClaudeCode) {
+        if let Some(open_turn_id) = claude_background_task_open(&records) {
+            return Ok(decide_state(
+                &lifecycle(
+                    FactKind::TurnOpen,
+                    open_turn_id,
+                    "background_task",
+                    vec!["background_task".to_string()],
+                ),
+                process,
+            ));
+        }
+    }
     let Some(fact) = facts.last() else {
         return Ok(classify_result(
             TurnState::Unknown,
@@ -45,6 +67,122 @@ pub fn classify(
     Ok(decide_state(fact, process))
 }
 
+/// Blocker-2 Layer-2: scan Claude transcript records for background task
+/// lifecycle markers. Returns `Some(turn_id)` when at least one background
+/// task is OPEN (started but not closed) — caller treats as `TurnOpen` with
+/// reason `background_task`. Returns `None` when no background task started,
+/// or every started task has a matching close (completed / failed).
+///
+/// Open markers (set):
+///   * Any record nested string containing
+///     "Command running in background with ID: <id>" (Bash tool output).
+///   * `tool_use_result.backgroundTaskId` (the structured form).
+///
+/// Close markers (clear):
+///   * `task-notification` content with `<task-id>` matching open id and
+///     `<status>completed</status>` or `failed`.
+///   * `tool_use_result.bashOutput.status = "completed" | "failed"` for the
+///     matching backgroundTaskId.
+fn claude_background_task_open(records: &[serde_json::Value]) -> Option<Option<TurnId>> {
+    use std::collections::BTreeSet;
+    let mut open: BTreeSet<String> = BTreeSet::new();
+    let mut last_open_request: Option<String> = None;
+    for record in records {
+        let mut found_open_ids: Vec<String> = Vec::new();
+        collect_background_open_ids(record, &mut found_open_ids);
+        for id in &found_open_ids {
+            open.insert(id.clone());
+        }
+        if !found_open_ids.is_empty() {
+            if let Some(req) = record.get("requestId").and_then(serde_json::Value::as_str) {
+                last_open_request = Some(req.to_string());
+            }
+        }
+        let mut closed_ids: Vec<String> = Vec::new();
+        collect_background_close_ids(record, &mut closed_ids);
+        for id in &closed_ids {
+            open.remove(id);
+        }
+    }
+    if open.is_empty() {
+        None
+    } else {
+        Some(last_open_request.map(TurnId::new))
+    }
+}
+
+fn collect_background_open_ids(value: &serde_json::Value, out: &mut Vec<String>) {
+    const MARKER: &str = "Command running in background with ID: ";
+    match value {
+        serde_json::Value::String(s) => {
+            for piece in s.split(MARKER).skip(1) {
+                let id: String = piece.chars().take_while(|c| !c.is_whitespace() && *c != '\n').collect();
+                if !id.is_empty() {
+                    out.push(id);
+                }
+            }
+        }
+        serde_json::Value::Object(map) => {
+            if let Some(id) = map.get("backgroundTaskId").and_then(serde_json::Value::as_str) {
+                if !id.is_empty() {
+                    out.push(id.to_string());
+                }
+            }
+            for v in map.values() {
+                collect_background_open_ids(v, out);
+            }
+        }
+        serde_json::Value::Array(arr) => {
+            for v in arr {
+                collect_background_open_ids(v, out);
+            }
+        }
+        _ => {}
+    }
+}
+
+fn collect_background_close_ids(value: &serde_json::Value, out: &mut Vec<String>) {
+    // Form A: tool_use_result.bashOutput { backgroundTaskId, status } where status is
+    //   "completed" or "failed".
+    // Form B: <task-notification> wrapper in a string with a status tag.
+    if let serde_json::Value::Object(map) = value {
+        if let Some(bash) = map.get("bashOutput").and_then(serde_json::Value::as_object) {
+            let status = bash.get("status").and_then(serde_json::Value::as_str).unwrap_or("");
+            if matches!(status, "completed" | "failed" | "killed") {
+                if let Some(id) = bash.get("backgroundTaskId").and_then(serde_json::Value::as_str) {
+                    if !id.is_empty() {
+                        out.push(id.to_string());
+                    }
+                }
+            }
+        }
+        for v in map.values() {
+            collect_background_close_ids(v, out);
+        }
+    } else if let serde_json::Value::Array(arr) = value {
+        for v in arr {
+            collect_background_close_ids(v, out);
+        }
+    } else if let serde_json::Value::String(s) = value {
+        // Form B: <task-notification ...><task-id>X</task-id>...<status>completed</status>...
+        if s.contains("<task-notification") && s.contains("<status>completed</status>") {
+            if let Some(id) = extract_xml_tag(s, "task-id") {
+                if !id.is_empty() {
+                    out.push(id);
+                }
+            }
+        }
+    }
+}
+
+fn extract_xml_tag(text: &str, tag: &str) -> Option<String> {
+    let open = format!("<{tag}>");
+    let close = format!("</{tag}>");
+    let start = text.find(&open)? + open.len();
+    let end_rel = text[start..].find(&close)?;
+    Some(text[start..start + end_rel].trim().to_string())
+}
+
 pub fn latest_explicit_error_fact(provider: Provider, session_log_text: &str) -> Option<FaultFact> {
     let record = latest_jsonl_record(session_log_text)?;
     match provider {