@team-agent/installer 0.5.45 → 0.5.47

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.45"
+version = "0.5.47"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.45"
+version = "0.5.47"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/cli/emit.rs

@@ -11,16 +11,22 @@ use std::io::Write as _;
 pub fn emit(output: &CmdOutput, as_json: bool) -> Option<String> {
     match output {
         CmdOutput::None => None,
-        CmdOutput::Human(text) => Some(text.clone()),
-        CmdOutput::Json(value) if as_json => serde_json::to_string_pretty(&sort_json(value)).ok(),
-        CmdOutput::Json(Value::Object(obj)) => {
-            let lines: Vec<String> = obj
-                .iter()
-                .map(|(key, value)| format!("{key}: {}", human_value(value)))
-                .collect();
-            Some(lines.join("\n"))
+        CmdOutput::Human(text) => Some(crate::redaction::redact_external_text(text)),
+        CmdOutput::Json(value) => {
+            let value = crate::redaction::redact_external_value(value);
+            if as_json {
+                return serde_json::to_string_pretty(&sort_json(&value)).ok();
+            }
+            if let Value::Object(obj) = value {
+                let lines: Vec<String> = obj
+                    .iter()
+                    .map(|(key, value)| format!("{key}: {}", human_value(value)))
+                    .collect();
+                Some(lines.join("\n"))
+            } else {
+                Some(human_value(&value))
+            }
         }
-        CmdOutput::Json(value) => Some(human_value(value)),
     }
 }
 
@@ -620,8 +626,24 @@ fn emit_cli_error(command: &str, args: &[String], cwd: &Path, error: &CliError)
     }
     let normalized = normalize_cli_error(error);
     let payload_error = normalized.as_ref().unwrap_or(error);
-    let _ = std::fs::write(&log_path, format!("{payload_error}\n"));
-    let payload = payload_error.to_payload(&log_path, command);
+    let safe_error = crate::redaction::redact_external_text(&payload_error.to_string());
+    let _ = std::fs::write(&log_path, format!("{safe_error}\n"));
+    let mut payload = payload_error.to_payload(&log_path, command);
+    payload.error = safe_error;
+    payload.action = crate::redaction::redact_external_text(&payload.action);
+    payload.log = crate::redaction::redact_external_text(&payload.log);
+    payload.reason = payload
+        .reason
+        .map(|value| crate::redaction::redact_external_text(&value));
+    payload.session_name = payload
+        .session_name
+        .map(|value| crate::redaction::redact_external_text(&value));
+    payload.next_actions = payload.next_actions.map(|values| {
+        values
+            .into_iter()
+            .map(|value| crate::redaction::redact_external_text(&value))
+            .collect()
+    });
     if has_arg(args, "--json") {
         if let Ok(value) = serde_json::to_value(payload) {
             println!("{}", python_compact_json(&value));

package/crates/team-agent/src/cli/mod.rs

@@ -2275,6 +2275,9 @@ pub mod lifecycle_port {
                 discarded_session_id,
                 session_id,
                 new_session_id,
+                capture_state,
+                reset_proof,
+                weak_reset_warning,
             }) => Ok(json!({
                 "ok": true,
                 "agent_id": env.agent_id.as_str(),
@@ -2285,6 +2288,9 @@ pub mod lifecycle_port {
                 "discarded_session_id": discarded_session_id.as_ref().map(|id| id.as_str()),
                 "session_id": session_id.as_ref().map(|id| id.as_str()),
                 "new_session_id": new_session_id.as_ref().map(|id| id.as_str()),
+                "capture_state": capture_state,
+                "reset_proof": reset_proof,
+                "weak_reset_warning": weak_reset_warning,
             })),
             Ok(crate::lifecycle::ResetAgentOutcome::Refused { reason }) => Ok(json!({
                 "ok": false,

package/crates/team-agent/src/cli/status_port.rs

@@ -3,6 +3,7 @@ use super::*;
 use crate::state::projection::OwnerTeamResolution;
 use crate::transport::Transport;
 use rusqlite::params;
+use std::path::PathBuf;
 
 /// `status.status(workspace, as_json, compact)`(`queries.py:33`,**有副作用**:capture→refresh→save)。
 pub fn status(workspace: &Path, compact: bool, detail: bool) -> Result<Value, CliError> {
@@ -48,7 +49,7 @@ pub fn status_scoped(
         !tmux_present,
         &freshness,
     );
-    let agents = enrich_agents(state.get("agents"), tmux_present, &freshness);
+    let agents = enrich_agents(workspace, state, tmux_present, &freshness);
     let tasks = state.get("tasks").cloned().unwrap_or_else(|| json!([]));
     let leader_receiver = state
         .get("leader_receiver")
@@ -88,7 +89,7 @@ pub fn status_scoped(
         );
     }
     let readiness = crate::cli::diagnose::wait_readiness(&readiness_state);
-    let full = json!({
+    let full = crate::redaction::redact_external_value(&json!({
         "ok": true,
         "team": state.pointer("/leader/id").cloned().unwrap_or_else(|| json!("leader")),
         "session_name": state.get("session_name").cloned().unwrap_or(Value::Null),
@@ -123,7 +124,7 @@ pub fn status_scoped(
                 .tail(10)
                 .map_err(|e| CliError::Runtime(e.to_string()))?,
         ),
-    });
+    }));
     if compact {
         Ok(compact_status(full))
     } else {
@@ -548,18 +549,27 @@ pub(crate) fn compute_runtime_freshness(
 }
 
 fn enrich_agents(
-    agents: Option<&Value>,
+    workspace: &Path,
+    state: &Value,
     tmux_session_present: bool,
     freshness: &RuntimeFreshness,
 ) -> Value {
+    let agents = state.get("agents");
     let Some(Value::Object(input)) = agents else {
         return json!({});
     };
+    let team_dir = state
+        .get("team_dir")
+        .and_then(Value::as_str)
+        .filter(|value| !value.is_empty())
+        .map(PathBuf::from)
+        .unwrap_or_else(|| workspace.to_path_buf());
     let mut out = Map::new();
     for (agent_id, value) in input {
         match value {
             Value::Object(obj) => {
                 let mut enriched = obj.clone();
+                apply_effective_role_projection(&team_dir, agent_id, &mut enriched);
                 enriched.insert(
                     "interacted".to_string(),
                     Value::String(interacted_marker(obj.get("first_send_at"))),
@@ -640,6 +650,64 @@ fn enrich_agents(
     Value::Object(out)
 }
 
+fn apply_effective_role_projection(
+    team_dir: &Path,
+    agent_id: &str,
+    agent: &mut Map<String, Value>,
+) {
+    let role_file = agent
+        .get("dynamic_role_file")
+        .and_then(Value::as_str)
+        .filter(|value| !value.is_empty())
+        .map(PathBuf::from)
+        .unwrap_or_else(|| team_dir.join("agents").join(format!("{agent_id}.md")));
+    let Ok((meta, _)) = crate::compiler::read_front_matter(&role_file) else {
+        return;
+    };
+    let Some(meta) = yaml_map(&meta) else {
+        return;
+    };
+    if let Some(provider) = yaml_str(meta, "provider").filter(|value| !value.is_empty()) {
+        agent.insert("provider".to_string(), Value::String(provider.to_string()));
+        agent.insert(
+            "provider_source".to_string(),
+            Value::String("role".to_string()),
+        );
+    }
+    if let Some(model) = yaml_str(meta, "model").filter(|value| !value.is_empty()) {
+        if agent.get("model").and_then(Value::as_str) != Some(model) {
+            agent.insert("model_stale".to_string(), Value::Bool(true));
+        }
+        agent.insert("model".to_string(), Value::String(model.to_string()));
+        agent.insert(
+            "model_source".to_string(),
+            Value::String("role".to_string()),
+        );
+    }
+}
+
+fn yaml_map(
+    value: &crate::model::yaml::Value,
+) -> Option<&Vec<(String, crate::model::yaml::Value)>> {
+    match value {
+        crate::model::yaml::Value::Map(items) => Some(items),
+        _ => None,
+    }
+}
+
+fn yaml_str<'a>(items: &'a [(String, crate::model::yaml::Value)], key: &str) -> Option<&'a str> {
+    items.iter().find_map(|(name, value)| {
+        if name == key {
+            match value {
+                crate::model::yaml::Value::Str(value) => Some(value.as_str()),
+                _ => None,
+            }
+        } else {
+            None
+        }
+    })
+}
+
 fn downgrade_stale_agent(agent: &mut Map<String, Value>) {
     let raw = agent
         .get("status")

package/crates/team-agent/src/coordinator/steps/abnormal.rs

@@ -101,7 +101,7 @@ pub(crate) fn detect_abnormal_exits(
         let fact = crate::provider::latest_explicit_error_fact(agent.provider, &text);
         let error_observation_key = fact
             .as_ref()
-            .map(|fact| abnormal_error_observation_key(&agent, fact, size));
+            .map(|fact| abnormal_error_observation_key(&agent, fact));
         let error_observation_cohort = fact.as_ref().map(|_| abnormal_error_cohort_key(&agent));
         let error_recency = abnormal_error_recency(
             &snapshot,
@@ -116,7 +116,6 @@ pub(crate) fn detect_abnormal_exits(
             fact.as_ref(),
             error_recency,
             error_observation_key.as_deref(),
-            size,
         );
         upsert_abnormal_watch(
             state,
@@ -155,7 +154,7 @@ pub(crate) fn detect_abnormal_exits(
         let fact = match (decision, fact) {
             (AbnormalExitDecision::Notify, Some(fact)) => fact,
             (AbnormalExitDecision::Suppress(reason), _) => {
-                let suppress_key = abnormal_suppression_key(&agent, &liveness, reason, size);
+                let suppress_key = abnormal_suppression_key(&agent, &liveness, reason);
                 if abnormal_last_suppressed_key(state, &agent.agent_id).as_deref()
                     != Some(suppress_key.as_str())
                 {
@@ -167,7 +166,7 @@ pub(crate) fn detect_abnormal_exits(
             (AbnormalExitDecision::NoSignal, _) => continue,
             (AbnormalExitDecision::Notify, None) => continue,
         };
-        let dedupe_key = abnormal_dedupe_key(&agent, &fact, size);
+        let dedupe_key = abnormal_dedupe_key(&agent, &fact);
         if abnormal_last_notified_key(state, &agent.agent_id).as_deref()
             == Some(dedupe_key.as_str())
         {
@@ -555,7 +554,7 @@ fn agent_process_liveness(
     if let Some(command) = agent.current_command.as_deref() {
         return command_process_check_with_marker(agent, transport, command);
     }
-    if let Some(pane_id) = agent.pane_id.as_deref() {
+    if agent.pane_id.is_some() {
         // Even without pane current_command / matching target, try the
         // marker probe directly — the wrapper's printf leaves the marker
         // in the pane's capture tail whether or not the transport
@@ -1135,16 +1134,13 @@ fn write_abnormal_suppressed(
     Ok(())
 }
 
-fn abnormal_dedupe_key(
-    agent: &AbnormalWatchAgent,
-    fact: &crate::provider::FaultFact,
-    size: u64,
-) -> String {
+fn abnormal_dedupe_key(agent: &AbnormalWatchAgent, fact: &crate::provider::FaultFact) -> String {
     let bucket = fact
         .turn_id
         .as_ref()
         .map(|id| id.as_str().to_string())
-        .unwrap_or_else(|| size.to_string());
+        .or_else(|| abnormal_error_fact_identity(fact))
+        .unwrap_or_else(|| "no_error_identity".to_string());
     format!(
         "worker.abnormal_exit:{}:{}:{}:{}",
         agent.agent_id,
@@ -1174,9 +1170,9 @@ fn abnormal_error_cohort_key(agent: &AbnormalWatchAgent) -> String {
 fn abnormal_error_observation_key(
     agent: &AbnormalWatchAgent,
     fact: &crate::provider::FaultFact,
-    size: u64,
 ) -> String {
-    let bucket = abnormal_error_fact_identity(fact).unwrap_or_else(|| size.to_string());
+    let bucket =
+        abnormal_error_fact_identity(fact).unwrap_or_else(|| "no_error_identity".to_string());
     format!(
         "worker.abnormal_exit.error:{}:{}:{}:{}",
         agent.agent_id,
@@ -1217,15 +1213,13 @@ fn abnormal_suppression_key(
     agent: &AbnormalWatchAgent,
     liveness: &ProcessCheck,
     reason: &str,
-    size: u64,
 ) -> String {
     format!(
-        "abnormal_exit.single_signal_suppressed:{}:{}:{}:{}:{}",
+        "abnormal_exit.single_signal_suppressed:{}:{}:{}:{}",
         agent.agent_id,
         agent.rollout_path_display,
         reason,
-        process_liveness_wire(liveness.state),
-        size
+        process_liveness_wire(liveness.state)
     )
 }
 
@@ -1235,17 +1229,15 @@ fn abnormal_check_key(
     fact: Option<&crate::provider::FaultFact>,
     error_recency: ErrorRecency,
     error_observation_key: Option<&str>,
-    size: u64,
 ) -> String {
     format!(
-        "worker.abnormal_exit.check:{}:{}:{}:{}:{}:{}:{}",
+        "worker.abnormal_exit.check:{}:{}:{}:{}:{}:{}",
         agent.agent_id,
         agent.rollout_path_display,
         process_liveness_wire(liveness.state),
         fact.map(|fact| fact.signature.as_str()).unwrap_or("-"),
         error_recency.as_str(),
-        error_observation_key.unwrap_or("-"),
-        size
+        error_observation_key.unwrap_or("-")
     )
 }
 
@@ -2526,7 +2518,7 @@ mod tests {
             "{\"method\":\"turn/completed\",\"params\":{\"turn\":{\"id\":\"t1\",\"status\":\"failed\"}}}\n",
         )
         .unwrap();
-        let observation_key = abnormal_error_observation_key(&agent, &fact, 99);
+        let observation_key = abnormal_error_observation_key(&agent, &fact);
         let state = serde_json::json!({
             "coordinator": {
                 "abnormal_exit_watch": {

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

@@ -147,7 +147,7 @@ impl EventLog {
                 obj.insert(k, v);
             }
         }
-        let event = Value::Object(obj);
+        let event = crate::redaction::redact_external_value(&Value::Object(obj));
         self.maybe_rotate()?;
         // 单次 write_all(line+"\n"):POSIX O_APPEND 对 <PIPE_BUF 写原子,避免并发写者交错(对抗 P1)。
         let mut bytes = to_python_json(&sort_value(&event)).into_bytes();
@@ -176,11 +176,11 @@ impl EventLog {
         let mut out = Vec::new();
         for line in &lines[start..] {
             match serde_json::from_str::<Value>(line) {
-                Ok(v) => out.push(v),
+                Ok(v) => out.push(crate::redaction::redact_external_value(&v)),
                 Err(_) => {
                     let mut m = serde_json::Map::new();
                     m.insert("raw".to_string(), Value::String((*line).to_string()));
-                    out.push(Value::Object(m));
+                    out.push(crate::redaction::redact_external_value(&Value::Object(m)));
                 }
             }
         }

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

@@ -56,6 +56,7 @@ pub use crate::db::message_store;
 // step 8 (provider) — ProviderAdapter trait + typed provider/turn-state/liveness 等(ROUND-0 骨架;
 // fn body unimplemented!(),P2 porter 落实现)。MUST-NOT-13:provider 调用全走 trait。
 pub mod provider;
+mod redaction;
 /// unit-6 (Stage 2) compat shim. Physical home is now
 /// `crate::provider::session::capture`; this re-export keeps every
 /// `crate::session_capture::*` caller working without modification.

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

@@ -485,27 +485,17 @@ fn proxy_scheme(url: &str) -> Option<String> {
 
 fn redact_endpoint(raw: &str) -> String {
     let no_query = raw.split_once('?').map(|(head, _)| head).unwrap_or(raw);
-    let Some((scheme, rest)) = no_query.split_once("://") else {
-        return no_query.to_string();
-    };
-    let slash = rest.find('/').unwrap_or(rest.len());
-    let authority = &rest[..slash];
-    let path = &rest[slash..];
-    if let Some((_, host)) = authority.rsplit_once('@') {
-        format!("{scheme}://[redacted]@{host}{path}")
-    } else {
-        no_query.to_string()
-    }
+    crate::redaction::redact_external_text(no_query)
 }
 
 fn redact_text(raw: &str, secrets: &[&str]) -> String {
     let mut out = raw.chars().take(512).collect::<String>();
     for secret in secrets {
         if !secret.is_empty() {
-            out = out.replace(secret, "[redacted]");
+            out = out.replace(secret, "[REDACTED]");
         }
     }
-    out
+    crate::redaction::redact_external_text(&out)
 }
 
 fn auth_mode_wire(auth_mode: AuthMode) -> &'static str {

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

@@ -113,6 +113,23 @@ pub(crate) fn start_agent_at_paths(
     let window = agent_window(&agent, agent_id);
     let adaptive_layout =
         open_display && crate::lifecycle::launch::state_uses_adaptive_layout(&state);
+    let fake_provider = raw_agent
+        .get("provider")
+        .and_then(serde_json::Value::as_str)
+        .is_some_and(|provider| provider.eq_ignore_ascii_case("fake"));
+    if force && !fake_provider && is_per_agent_window(&window, agent_id) {
+        let expected_pane_id = raw_agent
+            .get("pane_id")
+            .and_then(serde_json::Value::as_str)
+            .filter(|value| !value.is_empty());
+        let target =
+            SameRoleCohortTarget::new(agent_id, &window).with_expected_pane_id(expected_pane_id);
+        if let Some(error) =
+            same_role_cohort_pre_spawn_error(transport, &session_name, "start-agent", &[target])
+        {
+            return Err(LifecycleError::RequirementUnmet(error));
+        }
+    }
     let agent_live = if adaptive_layout {
         agent_pane_live(transport, &raw_agent)
     } else {
@@ -640,7 +657,7 @@ fn list_same_role_panes(
 /// caller falls back to safer behavior (refuse stop, surface
 /// RequirementUnmet/transport error) when this returns false.
 fn is_per_agent_window(window: &str, agent_id: &AgentId) -> bool {
-    window == agent_id.as_str() && !crate::lifecycle::launch::is_adaptive_layout_window_pub(window)
+    is_per_agent_cohort_window(window, agent_id)
 }
 
 fn tmux_start_mode_for_spawn(
@@ -1264,6 +1281,10 @@ fn reset_agent_at_paths(
         .filter(|p| !p.is_empty())
         .map(crate::transport::PaneId::new);
     let old_pane_pid_before = state_pane_pid(&state_before_stop, agent_id);
+    let old_pane_live_before = old_pane_id_before
+        .as_ref()
+        .map(|pane| agent_pane_live_by_id(transport, pane))
+        .unwrap_or(false);
     // CR C-2: take ONE pre-stop snapshot of the team session's panes so
     // the gate below can compute "what survived stop" by set difference,
     // not "what panes exist at all" (which would refuse legitimate
@@ -1286,7 +1307,18 @@ fn reset_agent_at_paths(
         if let Some(session) = pre_stop_session.as_ref() {
             if is_per_agent_window(&pre_stop_window, agent_id) {
                 list_same_role_panes(transport, session, &pre_stop_window)
-                    .iter()
+                    .into_iter()
+                    .filter(|pane| {
+                        if !old_pane_live_before {
+                            return true;
+                        }
+                        let same_old_pane = old_pane_id_before
+                            .as_ref()
+                            .is_some_and(|old| pane.pane_id.as_str() == old.as_str());
+                        let same_old_pid = old_pane_pid_before
+                            .is_some_and(|old_pid| pane.pane_pid == Some(old_pid));
+                        same_old_pane || same_old_pid
+                    })
                     .map(|p| p.pane_id.as_str().to_string())
                     .collect()
             } else {
@@ -1327,17 +1359,12 @@ fn reset_agent_at_paths(
     // CR C-5: gate is reset-specific; standalone stop-agent path keeps
     // existing "already absent is ok" behavior.
     //
-    // Gate scope refinement: when stop.stopped == true, the kill_pane
-    // call already succeeded (and drain_old_pane_and_pid polled for
-    // the pane to become unreachable). Treat that as the authoritative
-    // signal — running the gate again post-stop introduces a race
-    // window where tmux's has_pane lag can spuriously report Live.
-    // Only gate the dangerous case: stop reported stopped == false
-    // (state's stale pane_id pointed at nothing kill-able), which is
-    // exactly the duplicate-window bug pattern from the macmini
-    // evidence: `stop_agent.complete stopped=false` followed by an
-    // unconditional `start_agent.agent_start`.
-    if !agent_is_paused && !stop.stopped {
+    // P0 cohort proof: every non-paused reset takes a post-stop
+    // same-role snapshot. Refuse only on tmux-visible residue; a
+    // standalone old-pane liveness probe can be stale in mocks and
+    // must not mask the later spawn ownership/window-disappeared
+    // verifier.
+    if !agent_is_paused {
         let spec_for_gate = load_team_spec(spec_workspace)?;
         let gate_state = resolve_team_scoped_state_or_refuse(workspace, team)?;
         let session_name_gate = state_session_name_from_spec(&gate_state, &spec_for_gate);
@@ -1349,10 +1376,6 @@ fn reset_agent_at_paths(
             .filter(|s| !s.is_empty())
             .unwrap_or_else(|| agent_id.as_str())
             .to_string();
-        let old_pane_still_live = old_pane_id_before
-            .as_ref()
-            .map(|p| agent_pane_live_by_id(transport, p))
-            .unwrap_or(false);
         // Take a SECOND snapshot post-stop and compute the differential.
         // Only panes present in BOTH snapshots are residue (stop did not
         // remove them).
@@ -1366,16 +1389,10 @@ fn reset_agent_at_paths(
             .into_iter()
             .filter(|p| pre_stop_pane_ids.contains(p.pane_id.as_str()))
             .collect();
-        // Pid-alone aliveness is secondary evidence and noisy under fixtures
-        // (synthetic pids may by chance be live on the test machine). Block
-        // ONLY on tmux-visible residue: old pane still live OR same-role
-        // panes survived stop. The pid is still recorded in the event for
-        // diagnostics.
-        let old_pid_still_live = old_pane_pid_before
-            .filter(|_| old_pane_still_live)
-            .map(|pid| pid_is_alive(pid))
-            .unwrap_or(false);
-        if old_pane_still_live || !remaining_panes.is_empty() {
+        // Pid-alone aliveness is secondary evidence and noisy under
+        // fixtures. Block only on tmux-visible same-role residue; record
+        // the old pid in the event for diagnostics.
+        if !remaining_panes.is_empty() {
             let remaining_pane_ids: Vec<String> = remaining_panes
                 .iter()
                 .map(|p| p.pane_id.as_str().to_string())
@@ -1454,6 +1471,8 @@ fn reset_agent_at_paths(
     )?;
     let started = matches!(start, StartAgentOutcome::Running { .. });
     write_reset_complete_event(workspace, agent_id, stop.stopped, started)?;
+    let (capture_state, reset_proof, weak_reset_warning) =
+        reset_capture_proof(workspace, agent_id, discarded_session_id.as_ref());
     match start {
         StartAgentOutcome::Running {
             env,
@@ -1476,6 +1495,9 @@ fn reset_agent_at_paths(
                 discarded_session_id,
                 session_id: output_session_id,
                 new_session_id,
+                capture_state,
+                reset_proof,
+                weak_reset_warning,
             })
         }
         StartAgentOutcome::Noop { env, .. } => Ok(ResetAgentOutcome::Reset {
@@ -1484,6 +1506,9 @@ fn reset_agent_at_paths(
             discarded_session_id,
             session_id: None,
             new_session_id: None,
+            capture_state,
+            reset_proof,
+            weak_reset_warning,
         }),
         StartAgentOutcome::Paused { .. } => Ok(ResetAgentOutcome::Reset {
             env: AgentActionEnvelope {
@@ -1495,10 +1520,61 @@ fn reset_agent_at_paths(
             discarded_session_id,
             session_id: None,
             new_session_id: None,
+            capture_state,
+            reset_proof,
+            weak_reset_warning,
         }),
     }
 }
 
+fn reset_capture_proof(
+    workspace: &Path,
+    agent_id: &AgentId,
+    discarded_session_id: Option<&SessionId>,
+) -> (String, String, Option<String>) {
+    let state = crate::state::persist::load_runtime_state(workspace)
+        .unwrap_or_else(|_| serde_json::json!({}));
+    let agent = state
+        .get("agents")
+        .and_then(|agents| agents.get(agent_id.as_str()));
+    let capture_state = agent
+        .and_then(|agent| agent.get("capture_state"))
+        .and_then(serde_json::Value::as_str)
+        .filter(|value| !value.is_empty())
+        .or_else(|| {
+            agent
+                .and_then(|agent| agent.get("attribution_ambiguous"))
+                .and_then(serde_json::Value::as_bool)
+                .filter(|ambiguous| *ambiguous)
+                .map(|_| "attribution_ambiguous")
+        })
+        .or_else(|| {
+            let has_session = agent
+                .and_then(|agent| agent.get("session_id"))
+                .and_then(serde_json::Value::as_str)
+                .is_some_and(|value| !value.is_empty());
+            let has_rollout = agent
+                .and_then(|agent| agent.get("rollout_path"))
+                .and_then(serde_json::Value::as_str)
+                .is_some_and(|value| !value.is_empty());
+            (has_session && has_rollout).then_some("captured")
+        })
+        .unwrap_or("transcript_missing")
+        .to_string();
+    let weak = discarded_session_id.is_none()
+        || matches!(
+            capture_state.as_str(),
+            "transcript_missing" | "attribution_ambiguous"
+        );
+    let reset_proof = if weak { "weak" } else { "strong" }.to_string();
+    let weak_reset_warning = weak.then(|| {
+        format!(
+            "weak reset proof: capture_state={capture_state}; lifecycle restarted but attribution did not prove a fresh transcript"
+        )
+    });
+    (capture_state, reset_proof, weak_reset_warning)
+}
+
 #[allow(clippy::too_many_arguments)]
 fn write_start_agent_start_event(
     workspace: &Path,