@team-agent/installer 0.5.77 → 0.5.80

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

@@ -159,6 +159,11 @@ pub(crate) struct CommandSpec {
     pub(crate) governance: Option<GovernanceNote>,
 }
 
+/// Visible default-help contract:
+/// - d40 / v0.5.77 published 15 names including `models` and excluding `results`.
+/// - `results` remains a public handler and must stay discoverable.
+/// - Exact composed set is d40 ∪ {results}. This is a frozen name set, not a
+///   numeric slack threshold.
 #[rustfmt::skip]
 pub(crate) const COMMAND_SPECS: &[CommandSpec] = &[
     CommandSpec { name: "quick-start", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::Dispatch(DispatchKind::QuickStart), summary: "start or attach a team from TEAM.md", usage: "usage: team-agent quick-start [TEAMDIR] [--workspace WORKSPACE] [--name NAME] [--team-id TEAM|--team TEAM] [--yes] [--no-display] [--backend tmux|conpty] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: None, action: None, governance: None },
@@ -166,7 +171,7 @@ pub(crate) const COMMAND_SPECS: &[CommandSpec] = &[
     CommandSpec { name: "status", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Status), summary: "show current team status", usage: "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "models", tier: CommandTier::Core, category: CommandCategory::Observe, kind: CommandKind::Dispatch(DispatchKind::Models), summary: "list exact provider model ids", usage: "usage: team-agent models --provider pi [--search TEXT] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "collect", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Collect), summary: "collect reported results", usage: "usage: team-agent collect [--workspace WORKSPACE] [--team TEAM] [--result-file FILE] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
-    CommandSpec { name: "results", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Results), summary: "read reported results for a case", usage: "usage: team-agent results --case CASE_ID [--workspace WORKSPACE] [--team TEAM] [--json]", default_help: false, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
+    CommandSpec { name: "results", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Results), summary: "read reported results for a case", usage: "usage: team-agent results --case CASE_ID [--workspace WORKSPACE] [--team TEAM] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "wait", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Wait), summary: "block until a task result is stored", usage: "usage: team-agent wait --task TASK [--workspace WORKSPACE] [--json]", default_help: false, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "restart", tier: CommandTier::Core, category: CommandCategory::TeamLifecycle, kind: CommandKind::Dispatch(DispatchKind::Restart), summary: "restart the selected team", usage: "usage: team-agent restart [WORKSPACE] [--team TEAM] [--allow-fresh] [--session-converge-deadline SECONDS] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "shutdown", tier: CommandTier::Core, category: CommandCategory::TeamLifecycle, kind: CommandKind::Dispatch(DispatchKind::Shutdown), summary: "stop the selected team", usage: "usage: team-agent shutdown [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
@@ -201,7 +206,7 @@ pub(crate) const COMMAND_SPECS: &[CommandSpec] = &[
     CommandSpec { name: "clone-agent", tier: CommandTier::Secondary, category: CommandCategory::WorkerLifecycle, kind: CommandKind::Dispatch(DispatchKind::CloneAgent), summary: "clone a worker role into a fresh session", usage: "usage: team-agent clone-agent SOURCE_AGENT --as AGENT [--label LABEL] [--workspace WORKSPACE] [--team TEAM] [--no-display] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::Conditional, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "allow-peer-talk", tier: CommandTier::Secondary, category: CommandCategory::Setup, kind: CommandKind::Dispatch(DispatchKind::AllowPeerTalk), summary: "allow direct worker peer talk", usage: "usage: team-agent allow-peer-talk A B [--workspace WORKSPACE] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: Some(GovernanceNote { decision: "secondary", reason: "capability/config surface" }) },
     CommandSpec { name: "approvals", tier: CommandTier::Secondary, category: CommandCategory::Observe, kind: CommandKind::Dispatch(DispatchKind::Approvals), summary: "inspect provider approval state", usage: "usage: team-agent approvals [AGENT] [--workspace WORKSPACE] [--team TEAM] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: Some(GovernanceNote { decision: "secondary", reason: "approval diagnostics" }) },
-    CommandSpec { name: "profile", tier: CommandTier::Secondary, category: CommandCategory::Setup, kind: CommandKind::Dispatch(DispatchKind::Profile), summary: "manage provider profiles", usage: "usage: team-agent profile COMMAND NAME [--workspace WORKSPACE] [--team TEAM] [--auth-mode MODE] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: Some(GovernanceNote { decision: "secondary", reason: "provider/profile setup" }) },
+    CommandSpec { name: "profile", tier: CommandTier::Secondary, category: CommandCategory::Setup, kind: CommandKind::Dispatch(DispatchKind::Profile), summary: "manage provider profiles", usage: "usage: team-agent profile COMMAND NAME [--workspace WORKSPACE] [--team TEAM] [--auth-mode MODE] [--proxy-mode direct|inherit] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: Some(GovernanceNote { decision: "secondary", reason: "provider/profile setup" }) },
     CommandSpec { name: "install-skill", tier: CommandTier::Secondary, category: CommandCategory::Setup, kind: CommandKind::Dispatch(DispatchKind::InstallSkill), summary: "install or uninstall Team Agent skills", usage: "usage: team-agent install-skill (--source DIR | --uninstall) [--target codex|claude|copilot|all] [--dest DIR] [--dry-run] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: Some(GovernanceNote { decision: "secondary", reason: "capability setup" }) },
     CommandSpec { name: "inbox", tier: CommandTier::Secondary, category: CommandCategory::Observe, kind: CommandKind::Dispatch(DispatchKind::Inbox), summary: "inspect queued messages", usage: "usage: team-agent inbox AGENT [--workspace WORKSPACE] [--team TEAM] [--limit N] [--since CURSOR] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
 

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

@@ -60,19 +60,23 @@ pub(super) fn compact_not_ready(full: &Value) -> Value {
         })
         .unwrap_or_default();
     let mut obj = Map::new();
-    let channel_unbound = reasons
-        .iter()
-        .any(|reason| reason == "leader_receiver_unbound");
     obj.insert(
         "reasons".to_string(),
         Value::Array(reasons.into_iter().map(Value::String).collect()),
     );
     obj.insert("agents".to_string(), Value::Array(agents));
-    if channel_unbound {
-        obj.insert(
-            "next_action".to_string(),
-            Value::String("claim-leader".to_string()),
-        );
+    if let Some(next_action) = full
+        .pointer("/readiness/next_action")
+        .and_then(Value::as_str)
+    {
+        let truly_unbound = full.pointer("/readiness/state").and_then(Value::as_str)
+            == Some("leader_receiver_unbound");
+        if !next_action.contains("claim-leader") || truly_unbound {
+            obj.insert(
+                "next_action".to_string(),
+                Value::String(next_action.to_string()),
+            );
+        }
     }
     Value::Object(obj)
 }

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

@@ -58,7 +58,9 @@ pub(crate) fn compute_runtime_freshness(
             for (agent_id, entry) in watch {
                 let exited =
                     entry.get("worker_provider_exited").and_then(Value::as_bool) == Some(true);
-                if exited {
+                if exited
+                    && crate::state::abnormal_watch::matches_observation(state, agent_id, entry)
+                {
                     provider_exited_agents.insert(agent_id.clone());
                 }
             }

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

@@ -95,18 +95,21 @@ impl RuntimeSnapshot {
             .filter(|team| !team.is_empty())
             .map(str::to_string)
             .unwrap_or_else(|| crate::state::projection::team_state_key(state));
-        if !team_key.is_empty()
-            && !crate::lifecycle::launch::launched_team_receiver_is_attached(workspace, &team_key)
-        {
-            if let Some(object) = readiness.as_object_mut() {
-                object.insert("all_attached_receiver".to_string(), json!(false));
-                object.insert("ready".to_string(), json!(false));
-                object.insert("state".to_string(), json!("leader_receiver_unbound"));
-                object.insert("next_action".to_string(), json!("claim-leader"));
-                object.insert(
-                    "reason".to_string(),
-                    json!("leader registry does not authorize this workspace"),
-                );
+        if !team_key.is_empty() {
+            let class = crate::lifecycle::launch::classify_leader_binding(workspace, &team_key);
+            if class != crate::lifecycle::launch::LeaderBindingClass::Attached {
+                if let Some(object) = readiness.as_object_mut() {
+                    object.insert("all_attached_receiver".to_string(), json!(false));
+                    object.insert("ready".to_string(), json!(false));
+                    object.insert("state".to_string(), json!(class.issue_id()));
+                    object.insert("reason".to_string(), json!(class.issue_id()));
+                    if class == crate::lifecycle::launch::LeaderBindingClass::Unbound {
+                        object.insert(
+                            "next_action".to_string(),
+                            json!(class.repair()),
+                        );
+                    }
+                }
             }
         }
         let grok_slot = crate::cli::grok_slot_report(workspace, state).to_json();

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

@@ -230,7 +230,7 @@ pub(super) fn pending_leader_notifications(
             "created_at": row.get::<_, Option<String>>(4)?,
             "delivery_attempts": row.get::<_, i64>(5)?,
             "channel": channel,
-            "action": "run team-agent attach-leader or team-agent takeover",
+            "action": "historical leader mailbox debt; not proof of current unbound owner",
         }))
     };
     let rows = match owner_team_id {

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

@@ -28,7 +28,12 @@ fn health_fixture() -> crate::coordinator::HealthReport {
 
 #[test]
 fn runtime_freshness_provider_exit_requires_typed_positive_fact() {
-    let state = serde_json::json!({
+    let mut state = serde_json::json!({
+        "active_team_key": "status-team",
+        "agents": {
+            "pane_only": {"provider": "codex", "rollout_path": "/fixture/pane", "spawn_epoch": 1},
+            "typed_exit": {"provider": "codex", "rollout_path": "/fixture/typed", "spawn_epoch": 1}
+        },
         "coordinator": {
             "abnormal_exit_watch": {
                 "pane_only": {
@@ -43,6 +48,10 @@ fn runtime_freshness_provider_exit_requires_typed_positive_fact() {
         }
     });
 
+    for id in ["pane_only", "typed_exit"] {
+        state["coordinator"]["abnormal_exit_watch"][id]["watch_identity"] =
+            crate::state::abnormal_watch::observation_identity(&state, id).unwrap();
+    }
     let freshness = compute_runtime_freshness(
         Path::new("/nonexistent/status-port-typed-provider-exit-test"),
         &state,
@@ -52,3 +61,30 @@ fn runtime_freshness_provider_exit_requires_typed_positive_fact() {
     assert!(!freshness.provider_exited_agents.contains("pane_only"));
     assert!(freshness.provider_exited_agents.contains("typed_exit"));
 }
+
+#[test]
+fn runtime_freshness_rejects_foreign_legacy_and_unknown_watch_identity() {
+    let mut state = json!({
+        "active_team_key": "a",
+        "agents": {"w": {"provider": "codex", "rollout_path": "/fixture/w", "spawn_epoch": 1}},
+        "coordinator": {"abnormal_exit_watch": {"w": {"worker_provider_exited": true}}}
+    });
+    let path = Path::new("/nonexistent/status-watch-188");
+    assert!(compute_runtime_freshness(path, &state, &health_fixture())
+        .provider_exited_agents
+        .is_empty());
+    let identity = crate::state::abnormal_watch::observation_identity(&state, "w").unwrap();
+    state["coordinator"]["abnormal_exit_watch"]["w"]["watch_identity"] = identity;
+    for (pointer, value) in [
+        ("/active_team_key", json!("b")),
+        ("/agents/w/provider", json!("claude")),
+        ("/agents/w/spawn_epoch", json!(2)),
+        ("/agents/w/rollout_path", json!(null)),
+    ] {
+        let mut changed = state.clone();
+        *changed.pointer_mut(pointer).unwrap() = value;
+        assert!(compute_runtime_freshness(path, &changed, &health_fixture())
+            .provider_exited_agents
+            .is_empty());
+    }
+}

package/crates/team-agent/src/cli/tests/missing_subcommands.rs

@@ -90,6 +90,44 @@ fn seed_self_signed_attached_leader(ws: &std::path::Path) {
     .unwrap();
 }
 
+fn seed_canonical_healthy_leader(ws: &std::path::Path, endpoint: &str) {
+    crate::state::persist::save_runtime_state(
+        ws,
+        &json!({
+            "team_key": "current",
+            "workspace": ws,
+            "teams": {
+                "current": {
+                    "team_owner": {
+                        "pane_id": "%1",
+                        "owner_epoch": 1,
+                        "provider": "codex"
+                    },
+                    "leader_receiver": {
+                        "mode": "direct_tmux",
+                        "status": "attached",
+                        "pane_id": "%1",
+                        "owner_epoch": 1,
+                        "provider": "codex",
+                        "tmux_socket": endpoint
+                    }
+                }
+            }
+        }),
+    )
+    .unwrap();
+    assert_eq!(
+        crate::leader::registry::register_binding_from_state_best_effort(
+            ws,
+            Some("current"),
+            "diagnose-healthy-fixture",
+        )
+        .as_ref()
+        .map(|outcome| outcome.status),
+        Some("registered")
+    );
+}
+
 fn seed_leader_registry_entry(ws: &std::path::Path) {
     let entry = crate::leader::registry::build_entry(
         ws,
@@ -345,17 +383,33 @@ fn dispatch_routes_diagnose_healthy_leader() {
     ]);
     let _home = IsolatedHome::enter("diagnose-healthy");
     let ws = tmp_workspace();
-    seed_self_signed_attached_leader(&ws);
-    seed_leader_registry_entry(&ws);
-    let code = run(
-        &cli_argv(&["diagnose", "--workspace", &ws.to_string_lossy(), "--json"]),
-        &ws,
-    );
+    let endpoint = "/tmp/ta-diagnose-healthy.sock";
+    seed_canonical_healthy_leader(&ws, endpoint);
+    let transport = crate::transport::test_support::OfflineTransport::default()
+        .with_tmux_endpoint(endpoint)
+        .with_targets(vec![crate::transport::PaneInfo {
+            pane_id: crate::transport::PaneId::new("%1"),
+            session: crate::transport::SessionName::new("s"),
+            window_index: None,
+            window_name: None,
+            pane_index: None,
+            tty: None,
+            current_command: Some("codex".to_string()),
+            current_path: Some(ws.clone()),
+            active: true,
+            pane_pid: None,
+            leader_env: Default::default(),
+        }]);
+    let code = crate::transport_factory::with_leader_endpoint_transport(endpoint, transport, || {
+        run(
+            &cli_argv(&["diagnose", "--workspace", &ws.to_string_lossy(), "--json"]),
+            &ws,
+        )
+    });
     assert_eq!(
         code,
         ExitCode::Ok,
-        "`diagnose` must be Ok when state.json looks attached AND ~/.team-agent/leaders/ \
-         has a matching attached row; got {code:?}"
+        "`diagnose` must be Ok when canonical owner/receiver, production registry, and live align; got {code:?}"
     );
     let _ = std::fs::remove_dir_all(&ws);
 }

package/crates/team-agent/src/cli/tests/named_address.rs

@@ -234,6 +234,76 @@ fn resolve_name_team_disambiguated() {
     let _ = std::fs::remove_dir_all(&ws);
 }
 
+#[test]
+fn resolve_qualified_name_prefers_unique_state_pane_over_same_window_idle_pane() {
+    let ws = named_ws("qualified-state-pane-disambiguation");
+    seed_state(
+        &ws,
+        state_with_teams(json!({
+            "team-a": worker_team("team-a", "qa", "%worker", "qa")
+        })),
+    );
+    let transport = OfflineTransport::new().with_targets(vec![
+        pane("team-a", "qa", "%worker"),
+        pane("team-a", "qa", "%idle"),
+    ]);
+
+    let resolved = resolve_name_with_transport(
+        &ws,
+        &format!("{}::team-a/qa", ws.display()),
+        &transport,
+    )
+    .expect("a qualified worker address should use its unique state pane");
+    assert_eq!(resolved.pane_id, "%worker");
+    assert_eq!(resolved.state_pane_id.as_deref(), Some("%worker"));
+    assert!(!resolved.state_pane_stale);
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[test]
+fn resolve_qualified_name_state_pane_must_uniquely_match_scoped_candidates() {
+    for scenario in ["missing", "stale", "cross-session", "duplicate"] {
+        let ws = named_ws(&format!("qualified-state-pane-{scenario}"));
+        let mut team = worker_team("team-a", "qa", "%worker", "qa");
+        let targets = match scenario {
+            "missing" => {
+                team["agents"]["qa"]
+                    .as_object_mut()
+                    .unwrap()
+                    .remove("pane_id");
+                vec![pane("team-a", "qa", "%worker"), pane("team-a", "qa", "%idle")]
+            }
+            "stale" => {
+                team["agents"]["qa"]["pane_id"] = json!("%stale");
+                vec![pane("team-a", "qa", "%worker"), pane("team-a", "qa", "%idle")]
+            }
+            "cross-session" => vec![
+                pane("old-team-a", "qa", "%worker"),
+                pane("team-a", "qa", "%current-one"),
+                pane("team-a", "qa", "%current-two"),
+            ],
+            "duplicate" => {
+                team["agents"]["qa"]["pane_id"] = json!("%duplicate");
+                vec![
+                    pane("team-a", "qa", "%duplicate"),
+                    pane("team-a", "qa", "%duplicate"),
+                ]
+            }
+            _ => unreachable!(),
+        };
+        seed_state(&ws, state_with_teams(json!({"team-a": team})));
+        let transport = OfflineTransport::new().with_targets(targets);
+        let err = resolve_name_with_transport(
+            &ws,
+            &format!("{}::team-a/qa", ws.display()),
+            &transport,
+        )
+        .expect_err("non-unique state pane evidence must remain fail-closed");
+        assert_eq!(err.kind, NamedAddressErrorKind::NameAmbiguous, "{scenario}");
+        let _ = std::fs::remove_dir_all(&ws);
+    }
+}
+
 #[test]
 fn resolve_qualified_name_canonicalizes_legacy_session_alias() {
     let ws = named_ws("legacy-session-alias");

package/crates/team-agent/src/cli/tests/verb_profile.rs

@@ -35,7 +35,7 @@ fn seed_official_api_profile(ws: &std::path::Path) {
 
 // Golden source:
 // - cli/parser.py:131-150 registers `profile {init,doctor,show}`:
-//   * init NAME --workspace . --team TEAM --auth-mode choices(sorted AUTH_MODES) --json
+//   * init NAME --workspace . --team TEAM --auth-mode choices(sorted AUTH_MODES) --proxy-mode direct|inherit --json
 //   * doctor NAME --workspace . --team TEAM --json
 //   * show NAME --workspace . --team TEAM --json
 // - cli/commands.py:47-67 resolves scope then delegates to profiles.init_profile/
@@ -52,7 +52,7 @@ fn seed_official_api_profile(ws: &std::path::Path) {
 //   PYTHONPATH=/Users/alauda/Documents/code/team-agent-public/src \
 //     python3 /tmp/probe_profile_cli.py
 //   profile init codex_sub --auth-mode subscription --json rc=0 and creates:
-//   codex_sub.env = "AUTH_MODE=subscription\nPROFILE_NAME=codex_sub\n" (mode 0600),
+//   codex_sub.env = "AUTH_MODE=subscription\nPROFILE_NAME=codex_sub\nPROXY_MODE=inherit\n" (mode 0600),
 //   codex_sub.example.env with same body, plus AGENTS.md/CLAUDE.md secret boundary files.
 #[test]
 fn profile_init_routes_and_creates_secret_boundary_files() {
@@ -87,12 +87,12 @@ fn profile_init_routes_and_creates_secret_boundary_files() {
     );
     assert_eq!(
         std::fs::read_to_string(dir.join("codex_sub.env")).unwrap(),
-        "AUTH_MODE=subscription\nPROFILE_NAME=codex_sub\n",
+        "AUTH_MODE=subscription\nPROFILE_NAME=codex_sub\nPROXY_MODE=inherit\n",
         "subscription profile template body must match golden"
     );
     assert_eq!(
         std::fs::read_to_string(dir.join("codex_sub.example.env")).unwrap(),
-        "AUTH_MODE=subscription\nPROFILE_NAME=codex_sub\n",
+        "AUTH_MODE=subscription\nPROFILE_NAME=codex_sub\nPROXY_MODE=inherit\n",
         "subscription example template body must match golden"
     );
 
@@ -116,7 +116,7 @@ fn profile_init_routes_and_creates_secret_boundary_files() {
     );
     assert_eq!(
         std::fs::read_to_string(dir.join("codex_sub.env")).unwrap(),
-        "AUTH_MODE=subscription\nPROFILE_NAME=codex_sub\n",
+        "AUTH_MODE=subscription\nPROFILE_NAME=codex_sub\nPROXY_MODE=inherit\n",
         "idempotent init must not rewrite existing profile bytes"
     );
     let _ = std::fs::remove_dir_all(&ws);
@@ -145,7 +145,7 @@ fn compatible_api_profile_init_template_contains_common_five_fields() {
     );
 
     let expected =
-        "AUTH_MODE=compatible_api\nPROFILE_NAME=compat\nBASE_URL=\nAPI_KEY=\nMODEL=\n";
+        "AUTH_MODE=compatible_api\nPROFILE_NAME=compat\nPROXY_MODE=inherit\nBASE_URL=\nAPI_KEY=\nMODEL=\n";
     let dir = profiles_dir(&ws);
     assert_eq!(
         std::fs::read_to_string(dir.join("compat.env")).unwrap(),
@@ -160,6 +160,81 @@ fn compatible_api_profile_init_template_contains_common_five_fields() {
     let _ = std::fs::remove_dir_all(&ws);
 }
 
+#[test]
+fn profile_init_accepts_local_proxy_mode_and_rejects_unknown_values() {
+    let ws = tmp_workspace();
+    let direct = run(
+        &profile_argv(&[
+            "profile",
+            "init",
+            "cursor_sub",
+            "--workspace",
+            ".",
+            "--auth-mode",
+            "subscription",
+            "--proxy-mode=direct",
+            "--json",
+        ]),
+        &ws,
+    );
+    assert_eq!(direct, ExitCode::Ok, "direct proxy mode must be accepted");
+    let body = std::fs::read_to_string(profiles_dir(&ws).join("cursor_sub.env")).unwrap();
+    assert!(body.contains("PROXY_MODE=direct\n"));
+
+    let invalid = run(
+        &profile_argv(&[
+            "profile",
+            "init",
+            "bad_proxy",
+            "--workspace",
+            ".",
+            "--proxy-mode",
+            "sideways",
+            "--json",
+        ]),
+        &ws,
+    );
+    assert_eq!(invalid, ExitCode::Error, "unknown proxy mode must fail");
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[test]
+fn profile_init_existing_profile_reports_actual_mode_and_show_matches() {
+    let ws = tmp_workspace();
+    let make_args = |command: &str, mode: Option<&str>| ProfileArgs {
+        command: command.to_string(),
+        name: "cursor_sub".to_string(),
+        workspace: ws.clone(),
+        team: None,
+        auth_mode: Some("subscription".to_string()),
+        proxy_mode: mode.map(str::to_string),
+        json: true,
+    };
+    let first = cmd_profile(&make_args("init", Some("direct"))).unwrap();
+    let first = match first.output {
+        CmdOutput::Json(value) => value,
+        other => panic!("expected json output, got {other:?}"),
+    };
+    assert_eq!(first["proxy_mode"], "direct");
+    assert_eq!(first["proxy_mode_changed"], true);
+
+    let repeat = cmd_profile(&make_args("init", Some("inherit"))).unwrap();
+    let repeat = match repeat.output {
+        CmdOutput::Json(value) => value,
+        other => panic!("expected json output, got {other:?}"),
+    };
+    assert_eq!(repeat["proxy_mode"], "direct");
+    assert_eq!(repeat["proxy_mode_changed"], false);
+
+    let shown = cmd_profile(&make_args("show", None)).unwrap();
+    let shown = match shown.output {
+        CmdOutput::Json(value) => value,
+        other => panic!("expected json output, got {other:?}"),
+    };
+    assert_eq!(shown["proxy_mode"], "direct");
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
 // Golden source:
 // - profiles/core.py:95-119 doctor_profile returns ok=true for existing profiles and
 //   ok=false for missing profiles; parser.py:506-508 maps result.ok false to exit 1.

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

@@ -667,6 +667,7 @@ pub struct ProfileArgs {
     pub workspace: PathBuf,
     pub team: Option<String>,
     pub auth_mode: Option<String>,
+    pub proxy_mode: Option<String>,
     pub json: bool,
 }
 

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

@@ -73,6 +73,8 @@ pub(crate) fn detect_abnormal_exits(
     let team = crate::state::projection::team_state_key(&snapshot);
     let session_name = snapshot.get("session_name").and_then(Value::as_str);
     for agent in abnormal_watch_agents(&snapshot) {
+        // Reject untrusted history without skipping a fresh provider/path observation.
+        crate::state::abnormal_watch::begin_observation(state, &agent.agent_id);
         // Pane/process liveness is independent of transcript content. A
         // frozen rollout is common after pane death, so probe before the
         // metadata dedupe gate; only the expensive tail scan stays deduped.
@@ -109,7 +111,7 @@ pub(crate) fn detect_abnormal_exits(
         // re-read below.
         if let (Some(mtime), Some(stored)) = (
             mtime_ns,
-            abnormal_watch_stored_metadata(&snapshot, &agent.agent_id),
+            abnormal_watch_stored_metadata(state, &agent.agent_id),
         ) {
             if stored == (size, mtime) {
                 refresh_abnormal_watch_liveness(state, &agent.agent_id, &liveness);
@@ -149,7 +151,7 @@ pub(crate) fn detect_abnormal_exits(
             .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,
+            state,
             &agent,
             error_observation_key.as_deref(),
             error_observation_cohort.as_deref(),
@@ -954,6 +956,9 @@ fn abnormal_watch_payload(
 }
 
 fn upsert_abnormal_watch(state: &mut Value, agent_id: &str, mut payload: Value) {
+    if let Some(identity) = crate::state::abnormal_watch::observation_identity(state, agent_id) {
+        payload["watch_identity"] = identity;
+    }
     let preserved = [
         "last_notified_key",
         "last_notified_at",
@@ -1413,6 +1418,121 @@ mod tests {
             crate::provider::get_adapter(provider)
         }
     }
+    #[test]
+    fn resource188_foreign_metadata_and_dedupe_cannot_skip_new_baseline() {
+        let dir = temp_abnormal_dir("188-foreign-watch");
+        let rollout = dir.join("rollout-w1.jsonl");
+        let error = "{\"method\":\"turn/completed\",\"params\":{\"turn\":{\"id\":\"old\",\"status\":\"failed\"}}}\n";
+        std::fs::write(&rollout, error).unwrap();
+        seed_abnormal_state(&dir, &rollout, "alive", 1);
+        let mut state = crate::state::persist::load_runtime_state(&dir).unwrap();
+        let metadata = std::fs::metadata(&rollout).unwrap();
+        let mut foreign = crate::state::abnormal_watch::observation_identity(&state, "w1").unwrap();
+        foreign["team_key"] = serde_json::json!("another-team");
+        state["coordinator"] = serde_json::json!({"abnormal_exit_watch": {"w1": {
+            "watch_identity": foreign,
+            "size": metadata.len(), "mtime_ns": metadata_mtime_ns(&metadata),
+            "last_notified_key": "foreign", "last_check_key": "foreign",
+            "last_error_observation_key": "foreign", "last_error_observation_cohort": "foreign"
+        }}});
+        let log = EventLog::new(&dir);
+        let transport = crate::transport::test_support::OfflineTransport::new();
+        detect_abnormal_exits(&dir, &transport, &mut state, &log, &[]).unwrap();
+        let baseline = state["coordinator"]["abnormal_exit_watch"]["w1"].clone();
+        assert_eq!(baseline["error_recency"], "stale");
+        assert!(baseline.get("last_notified_key").is_none());
+        assert!(crate::state::abnormal_watch::matches_observation(
+            &state, "w1", &baseline
+        ));
+        let events = log.tail(0).unwrap();
+        detect_abnormal_exits(&dir, &transport, &mut state, &log, &[]).unwrap();
+        assert_eq!(
+            log.tail(0).unwrap(),
+            events,
+            "unchanged baseline must not re-alarm"
+        );
+        assert!(find_event(&events, "worker.abnormal_exit").is_none());
+    }
+
+    #[test]
+    fn resource188_legacy_missing_cohort_still_observes_fresh_errors_and_dedupes() {
+        let dir = temp_abnormal_dir("188-legacy-cohort");
+        let rollout = dir.join("rollout-w1.jsonl");
+        let error = "{\"method\":\"turn/completed\",\"params\":{\"turn\":{\"id\":\"old\",\"status\":\"failed\"}}}\n";
+        std::fs::write(&rollout, error).unwrap();
+        seed_abnormal_state(&dir, &rollout, "alive", 1);
+        let mut state = crate::state::persist::load_runtime_state(&dir).unwrap();
+        state["agents"]["w1"]
+            .as_object_mut()
+            .unwrap()
+            .remove("spawn_epoch");
+        let log = EventLog::new(&dir);
+        let transport = crate::transport::test_support::OfflineTransport::new();
+        detect_abnormal_exits(&dir, &transport, &mut state, &log, &[]).unwrap();
+        assert_eq!(
+            state["coordinator"]["abnormal_exit_watch"]["w1"]["error_recency"],
+            "stale"
+        );
+        assert!(find_event(&log.tail(0).unwrap(), "worker.abnormal_exit").is_none());
+        std::fs::OpenOptions::new()
+            .append(true)
+            .open(&rollout)
+            .unwrap()
+            .write_all(error.replace("old", "new-error").as_bytes())
+            .unwrap();
+        detect_abnormal_exits(&dir, &transport, &mut state, &log, &[]).unwrap();
+        let events = log.tail(0).unwrap();
+        assert_eq!(
+            find_event(&events, "worker.abnormal_exit").unwrap()["error_recency"],
+            "fresh"
+        );
+        let notified =
+            state["coordinator"]["abnormal_exit_watch"]["w1"]["last_notified_key"].clone();
+        assert!(notified.is_string());
+        detect_abnormal_exits(&dir, &transport, &mut state, &log, &[]).unwrap();
+        assert_eq!(log.tail(0).unwrap(), events);
+        assert_eq!(
+            state["coordinator"]["abnormal_exit_watch"]["w1"]["last_notified_key"],
+            notified
+        );
+        state["agents"]["w1"]["spawn_epoch"] = serde_json::json!(2);
+        detect_abnormal_exits(&dir, &transport, &mut state, &log, &[]).unwrap();
+        let watch = &state["coordinator"]["abnormal_exit_watch"]["w1"];
+        assert_eq!(
+            watch["error_recency"], "stale",
+            "a known generation must rebaseline unchanged bytes"
+        );
+        assert!(watch.get("last_notified_key").is_none());
+        assert_eq!(
+            log.tail(0)
+                .unwrap()
+                .iter()
+                .filter(|event| event["event"] == "worker.abnormal_exit")
+                .count(),
+            1
+        );
+    }
+
+    #[test]
+    fn resource188_unknown_team_still_records_fresh_liveness_without_reusing_cache() {
+        let dir = temp_abnormal_dir("188-unknown-team");
+        let rollout = dir.join("rollout-w1.jsonl");
+        std::fs::write(&rollout, "").unwrap();
+        seed_abnormal_state(&dir, &rollout, "dead", 1);
+        let mut state = crate::state::persist::load_runtime_state(&dir).unwrap();
+        state.as_object_mut().unwrap().remove("active_team_key");
+        let log = EventLog::new(&dir);
+        let transport = crate::transport::test_support::OfflineTransport::new();
+        detect_abnormal_exits(&dir, &transport, &mut state, &log, &[]).unwrap();
+        assert_eq!(
+            state["coordinator"]["abnormal_exit_watch"]["w1"]["last_liveness"],
+            "dead"
+        );
+        assert!(state["coordinator"]["abnormal_exit_watch"]["w1"]
+            .get("watch_identity")
+            .is_none());
+    }
+
     #[test]
     fn abnormal_stale_error_baselines_then_fresh_alive_error_notifies() {
         let dir = temp_abnormal_dir("alive-fresh");