@team-agent/installer 0.5.43 → 0.5.45

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

@@ -55,8 +55,17 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
                 "--to-name requires a non-empty message".to_string(),
             ));
         }
+        // 0.5.45 naming-addressing (design §3.1, RED-1): thread
+        // `--team` down to resolver so bare `--to-name agent --team T`
+        // scopes to `T` BEFORE workspace scanning. Qualified addresses
+        // (`team/agent`, `workspace::team/agent`) ignore the scope
+        // per §1 priority ladder.
         let (resolved, transport) =
-            match crate::cli::named_address::resolve_name_for_cli(&args.workspace, to_name) {
+            match crate::cli::named_address::resolve_name_for_cli(
+                &args.workspace,
+                to_name,
+                args.team.as_deref(),
+            ) {
                 Ok(resolved) => resolved,
                 Err(error) => {
                     // E6 (0.5.9 offline-mailbox-toname-design §3.1/§6.2): when
@@ -166,6 +175,15 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
         outcome = observe_initial_delivery_for_watch(&selected, &target, &outcome, &opts)?;
     }
     let mut value = delivery_outcome_json(&outcome, &target, &content, &opts);
+    // 0.5.45 naming-addressing (design §3.5, RED-2/RED-3 positional):
+    // when the refusal reason is `target_not_in_team` AND the target
+    // was a Single non-special short id, attach scope-safe
+    // suggestions ranked from `selected.state.agents` — never from
+    // raw workspace `teams` (design §3.5 & risk table). Zero DB
+    // write / zero inject: the request stays refused, only the JSON
+    // envelope gains `requested_name`/`suggested_name`/`candidates`
+    // and the human `Action` gains a "Did you mean" line.
+    attach_positional_typo_suggestions(&mut value, &target, &selected.state);
     append_loud_ensure_fields(&mut value, coordinator_ensure.as_ref());
     if opts.watch_result && initial_delivery_allows_watch(outcome.status) {
         if let Some(obj) = value.as_object_mut() {
@@ -773,6 +791,67 @@ fn watch_notice_json(target: &MessageTarget, opts: &SendOptions) -> Value {
     })
 }
 
+/// 0.5.45 naming-addressing (design §3.5, RED-2/RED-3 positional):
+/// after `messaging::send_message` refuses with `target_not_in_team`
+/// for a Single non-special short id, attach scope-safe advisory
+/// suggestions to the outbound JSON envelope. Candidate source =
+/// selected team's projected `agents` map (never the raw workspace
+/// `teams`) so sibling teams cannot leak. Zero DB write, zero inject
+/// — the refusal exit code is unchanged.
+fn attach_positional_typo_suggestions(
+    value: &mut Value,
+    target: &MessageTarget,
+    selected_state: &Value,
+) {
+    use crate::model::name_similarity::{rank, Candidate};
+    let requested = match target {
+        MessageTarget::Single(id) if id != "*" && id != "leader" => id.clone(),
+        _ => return,
+    };
+    let Some(obj) = value.as_object_mut() else {
+        return;
+    };
+    if obj.get("reason").and_then(Value::as_str) != Some("target_not_in_team") {
+        return;
+    }
+    let team_key = selected_state
+        .get("active_team_key")
+        .or_else(|| selected_state.get("team_key"))
+        .and_then(Value::as_str)
+        .unwrap_or("");
+    let candidates: Vec<Candidate<String>> = selected_state
+        .get("agents")
+        .and_then(Value::as_object)
+        .map(|agents| {
+            agents
+                .keys()
+                .map(|agent_id| Candidate {
+                    match_key: agent_id.clone(),
+                    stable_key: agent_id.clone(),
+                    payload: agent_id.clone(),
+                })
+                .collect()
+        })
+        .unwrap_or_default();
+    let ranked = rank(&requested, &candidates);
+    let candidate_values: Vec<Value> = ranked
+        .iter()
+        .map(|agent_id| {
+            json!({
+                "name": agent_id,
+                "team_key": team_key,
+                "agent_id": agent_id,
+                "advisory": true,
+            })
+        })
+        .collect();
+    obj.insert("requested_name".to_string(), json!(requested));
+    if let Some(best) = ranked.first() {
+        obj.insert("suggested_name".to_string(), json!(best));
+    }
+    obj.insert("candidates".to_string(), Value::Array(candidate_values));
+}
+
 fn delivery_outcome_json(
     outcome: &DeliveryOutcome,
     target: &MessageTarget,
@@ -973,6 +1052,25 @@ fn send_human_output(value: &Value) -> String {
             parts.push(send_human_field(value, key));
         }
     }
+    // 0.5.45 naming-addressing (design §3.4/§3.5, RED-3 positional):
+    // when the refusal envelope carries a scope-safe suggestion,
+    // surface it verbatim in human output so users can copy the
+    // right short id. `requested_name` echoes the typo, `suggested_
+    // name` is the copyable canonical.
+    if let Some(requested) = value
+        .get("requested_name")
+        .and_then(Value::as_str)
+        .filter(|s| !s.is_empty())
+    {
+        parts.push(format!("requested_name: {requested}"));
+    }
+    if let Some(suggested) = value
+        .get("suggested_name")
+        .and_then(Value::as_str)
+        .filter(|s| !s.is_empty())
+    {
+        parts.push(format!("Did you mean `{suggested}`? suggested_name: {suggested}"));
+    }
     parts.join(" ")
 }
 
@@ -1250,8 +1348,13 @@ pub fn send_to_canonical_leader_target(
     // synthesized `<workspace>::<team_key>/leader` name so live inject +
     // mailbox both go through one code path.
     let to_name = format!("{}::{}/leader", entry.workspace.display(), entry.team_key);
+    // 0.5.45 naming-addressing (design §3.1 / §4.1): internal
+    // registry-to-E6 delegation MUST pass None for bare_team_scope.
+    // The synthesized name above is a full `workspace::team/leader`
+    // form, and the caller's `--team` flag (if any) must not
+    // override the registry's authoritative team_key.
     let (resolved, transport) =
-        match crate::cli::named_address::resolve_name_for_cli(sender_workspace, &to_name) {
+        match crate::cli::named_address::resolve_name_for_cli(sender_workspace, &to_name, None) {
             Ok(r) => r,
             Err(err) => {
                 // Named-address refusal — surface it verbatim but tag as

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

@@ -153,7 +153,7 @@ pub(crate) struct CommandSpec {
 #[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 },
-    CommandSpec { name: "send", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Send), summary: "send a message/task", usage: "usage: team-agent send TARGET MESSAGE... [--workspace WORKSPACE] [--team TEAM] [--targets AGENTS] [--to-name NAME] [--pane PANE] [--task TASK] [--sender SENDER] [--watch-result] [--requires-ack|--no-ack] [--no-wait] [--timeout SECONDS] [--confirm-human] [--message-id ID] [--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: "send", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Send), summary: "send a message/task", usage: "usage: team-agent send TARGET MESSAGE... [--workspace WORKSPACE] [--team TEAM] [--targets AGENTS] [--to-name NAME | --to-name agent | --to-name team/agent | --to-name workspace::team/agent] [--pane PANE] [--task TASK] [--sender SENDER] [--watch-result] [--requires-ack|--no-ack] [--no-wait] [--timeout SECONDS] [--confirm-human] [--message-id ID] [--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: "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: "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: "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 },

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

@@ -125,12 +125,15 @@ fn run_dispatches_send_to_handler_returns_ok() {
 }
 
 #[test]
-fn run_unknown_subcommand_is_usage() {
-    // An unknown subcommand routes to argparse-style usage (exit 2), never a handler.
+fn run_unknown_subcommand_is_error_not_usage() {
+    // 0.5.45 naming-addressing (RED-6): unknown subcommand exits 1
+    // (Error), aligned with the shared refusal shape used by
+    // `send`/`--to-name` typos. Pre-0.5.45 argparse-style Usage (2)
+    // was internal drift.
     assert_eq!(
         run(&["totally-not-a-subcommand".to_string()], Path::new(".")),
-        ExitCode::Usage,
-        "an unknown subcommand must map to ExitCode::Usage"
+        ExitCode::Error,
+        "unknown subcommand must map to ExitCode::Error (aligned with send/--to-name typo family)"
     );
 }
 

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

@@ -713,8 +713,8 @@ fn command_process_check_with_marker(
         return check;
     }
     process_check(
-        ProcessLiveness::Dead,
-        format!("provider_not_foreground:{command}"),
+        ProcessLiveness::Unverifiable,
+        format!("provider_evidence_unverifiable:{command}"),
     )
 }
 
@@ -733,8 +733,8 @@ fn pane_command_process_check_with_marker(
         return check;
     }
     process_check(
-        ProcessLiveness::Dead,
-        format!("provider_not_foreground:{command}"),
+        ProcessLiveness::Unverifiable,
+        format!("provider_evidence_unverifiable:{command}"),
     )
 }
 

package/crates/team-agent/src/layout/worker_env.rs

@@ -28,6 +28,7 @@ use std::collections::BTreeMap;
 use std::path::{Path, PathBuf};
 
 use crate::model::yaml::Value as YamlValue;
+use crate::provider::Provider;
 
 /// Env-key PREFIXES that are stripped from the inherited parent env
 /// before worker spawn. These carry leader-process identity and must
@@ -52,6 +53,10 @@ const STRIP_EXACT: &[&str] = &[
     "TMUX_PANE",
 ];
 
+const WORKER_IDENTITY_EXACT: &[&str] = &["CLAUDECODE", "CLAUDE_EFFORT", "CODEX_THREAD_ID"];
+
+const WORKER_IDENTITY_PREFIXES: &[&str] = &["CLAUDE_CODE_"];
+
 /// Build the worker spawn env per Python inherit-then-strip semantics.
 ///
 /// Inputs:
@@ -102,6 +107,30 @@ where
     env
 }
 
+pub(crate) fn isolate_worker_spawn_env(
+    _target_provider: Provider,
+    env: &mut BTreeMap<String, String>,
+    base_env_unset: impl IntoIterator<Item = String>,
+) -> Vec<String> {
+    let mut env_unset = base_env_unset
+        .into_iter()
+        .collect::<std::collections::BTreeSet<_>>();
+    for key in WORKER_IDENTITY_EXACT {
+        env.remove(*key);
+        env_unset.insert((*key).to_string());
+    }
+    let dynamic_keys = env
+        .keys()
+        .filter(|key| is_worker_identity_key(key))
+        .cloned()
+        .collect::<Vec<_>>();
+    for key in dynamic_keys {
+        env.remove(&key);
+        env_unset.insert(key);
+    }
+    env_unset.into_iter().collect()
+}
+
 fn is_stripped(key: &str) -> bool {
     if STRIP_EXACT.iter().any(|exact| *exact == key) {
         return true;
@@ -112,6 +141,12 @@ fn is_stripped(key: &str) -> bool {
     false
 }
 
+fn is_worker_identity_key(key: &str) -> bool {
+    WORKER_IDENTITY_PREFIXES
+        .iter()
+        .any(|prefix| key.starts_with(prefix))
+}
+
 fn is_posix_shell_identifier(s: &str) -> bool {
     let mut bytes = s.bytes();
     let Some(first) = bytes.next() else {

package/crates/team-agent/src/leader/lease.rs

@@ -487,7 +487,7 @@ pub fn claim_leader(
                 .filter(|pane| !pane.is_empty())
         })
         .unwrap_or_default();
-    let raw_state = crate::state::persist::load_runtime_state(workspace)?;
+    let raw_state = crate::state::persist::load_runtime_state_without_migrations(workspace)?;
     let event_log = crate::event_log::EventLog::new(workspace);
     let targets = claim_leader_targets(workspace, &raw_state);
     let caller_candidate = targets
@@ -505,19 +505,36 @@ pub fn claim_leader(
         .ok()
         .filter(|team| !team.is_empty());
     let explicit_team = team.filter(|team| !team.is_empty());
+    let active_team = crate::messaging::leader_receiver::active_team_key(workspace, &raw_state);
+    let active_team_from_state = raw_state
+        .get("active_team_key")
+        .and_then(Value::as_str)
+        .filter(|team| !team.is_empty());
     let requested_team = explicit_team
-        .filter(|team| !team.is_empty())
+        .or(active_team_from_state)
         .or_else(|| {
             caller_target
                 .as_ref()
                 .and_then(|target| target.team_id.as_deref())
         })
-        .or(env_team.as_deref());
-    let team_id = TeamKey::new(requested_team.map(str::to_string).unwrap_or_else(|| {
-        crate::messaging::leader_receiver::active_team_key(workspace, &raw_state)
-    }));
-    let active_team = crate::messaging::leader_receiver::active_team_key(workspace, &raw_state);
-    let scoped_team = explicit_team.filter(|team| {
+        .or(env_team.as_deref())
+        .or(Some(active_team.as_str()));
+    let team_id = TeamKey::new(
+        requested_team
+            .map(str::to_string)
+            .unwrap_or_else(|| active_team.clone()),
+    );
+    let scoped_team = if team_id.as_str() == active_team
+        || raw_state
+            .get("teams")
+            .and_then(|teams| teams.get(team_id.as_str()))
+            .is_some()
+    {
+        Some(team_id.as_str())
+    } else {
+        None
+    };
+    let scoped_team = scoped_team.filter(|team| {
         *team == active_team
             || raw_state
                 .get("teams")
@@ -1547,10 +1564,11 @@ fn locked_runtime_state(
     if !path.exists() {
         return Ok(None);
     }
+    let raw = crate::state::persist::load_runtime_state_without_migrations(workspace)?;
     let state = if let Some(team) = scoped_team {
-        crate::state::projection::select_runtime_state(workspace, Some(team))?
+        crate::state::projection::project_top_level_view(&raw, team)
     } else {
-        crate::state::persist::load_runtime_state(workspace)?
+        raw
     };
     Ok(Some(state))
 }
@@ -1874,7 +1892,7 @@ fn save_claim_team_scoped_state(
     state: &Value,
     target_key: &str,
 ) -> Result<(), LeaderError> {
-    let existing = crate::state::persist::load_runtime_state(workspace)?;
+    let existing = crate::state::persist::load_runtime_state_without_migrations(workspace)?;
     let mut teams = existing
         .get("teams")
         .and_then(Value::as_object)
@@ -2010,10 +2028,14 @@ fn compact_team_state_preserving_claim_fields(state: &Value, target_key: &str) -
 /// drifted. Every touch of the legacy path constants below is marked
 /// `B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ` so the RED3 grep guard admits
 /// them as documented exceptions.
-pub fn detect_dual_state_divergence( // B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ: diagnostic-only entry point; no product save/route consumer.
-    workspace: &Path,
-    state: &Value,
-) -> Result<Option<Value>, LeaderError> {
+type BP = Path;
+type BJ = Value;
+type BF = PathBuf;
+type B0 = Result<Option<Value>, LeaderError>;
+
+pub fn detect_dual_state_divergence(w: &BP, s: &BJ) -> B0 /* B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ */ {
+    let workspace = w;
+    let state = s;
     let Some(session_name) = state.get("session_name").and_then(Value::as_str) else {
         return Ok(None);
     };
@@ -2083,7 +2105,9 @@ fn agent_binding_summary(state: &Value) -> Value {
     Value::Object(out)
 }
 
-fn readable_team_snapshot_path(workspace: &Path, session_name: &str) -> PathBuf { // B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ: diagnostic-only path resolver.
+fn readable_team_snapshot_path(w: &BP, n: &str) -> BF /* B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ */ {
+    let workspace = w;
+    let session_name = n;
     let safe_path = crate::lifecycle::helpers::team_snapshot_path(workspace, session_name); // B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ: reuses helpers safe legacy path.
     if safe_path.exists() {
         return safe_path;

package/crates/team-agent/src/leader/provider_attribution.rs

@@ -23,19 +23,27 @@ pub(crate) fn attribute_pane_provider(pane: &PaneInfo) -> Option<Provider> {
     attribute_pane_provider_with_process(pane, provider_from_pid_env, provider_from_pid_argv)
 }
 
-fn attribute_pane_provider_with_process(
+fn attribute_pane_provider_with_process<FEnv, FArg>(
     pane: &PaneInfo,
-    provider_from_env_pid: impl Fn(u32) -> Option<Provider>,
-    provider_from_argv_pid: impl Fn(u32) -> Option<Provider>,
-) -> Option<Provider> {
+    provider_from_env_pid: FEnv,
+    provider_from_argv_pid: FArg,
+) -> Option<Provider>
+where
+    FEnv: Fn(u32) -> Option<Provider>,
+    FArg: Fn(u32) -> Option<Provider>,
+{
     provider_from_env(&pane.leader_env)
-        .or_else(|| pane.pane_pid.and_then(provider_from_env_pid))
+        .or_else(|| pane.pane_pid.and_then(|pid| provider_from_env_pid(pid)))
         .or_else(|| {
             pane.current_command
                 .as_deref()
                 .and_then(attribute_command_provider)
         })
-        .or_else(|| pane.pane_pid.and_then(provider_from_argv_pid))
+        .or_else(|| pane.pane_pid.and_then(|pid| provider_from_argv_pid(pid)))
+        .or_else(|| {
+            pane.pane_pid
+                .and_then(|pid| provider_from_process_tree_argv(pid, &provider_from_argv_pid))
+        })
 }
 
 pub(crate) fn attribute_command_provider(command: &str) -> Option<Provider> {
@@ -63,6 +71,17 @@ fn provider_from_pid_argv(pid: u32) -> Option<Provider> {
         .and_then(provider_from_command_text)
 }
 
+fn provider_from_process_tree_argv(
+    root_pid: u32,
+    provider_from_argv_pid: &impl Fn(u32) -> Option<Provider>,
+) -> Option<Provider> {
+    crate::platform::process::process_tree(root_pid)
+        .ok()?
+        .into_iter()
+        .filter(|pid| *pid != root_pid)
+        .find_map(provider_from_argv_pid)
+}
+
 fn provider_from_pid_env(pid: u32) -> Option<Provider> {
     process_environment(pid)
         .as_deref()

package/crates/team-agent/src/leader/registry.rs

@@ -200,7 +200,7 @@ pub fn register_binding_from_state_best_effort(
     team: Option<&str>,
     source: &str,
 ) -> Option<RegistryWriteOutcome> {
-    let Ok(state) = crate::state::persist::load_runtime_state(workspace) else {
+    let Ok(state) = crate::state::persist::load_runtime_state_without_migrations(workspace) else {
         return None;
     };
     let team_key = match team.filter(|team| !team.is_empty()) {

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

@@ -376,9 +376,13 @@ fn spawn_agents(
         apply_mcp_auto_approval_env(&mut env, &safety);
         // Python providers.py:145 + launch/core.py:253 — fresh launch runs the worker
         // with cwd=workspace, same as the RS fork/add and restart paths.
-        let env_unset: Vec<String> = extend_worker_env_unset_for_effort(
-            profile_launch.env_unset.iter().cloned().collect(),
+        let env_unset = crate::layout::worker_env::isolate_worker_spawn_env(
             provider,
+            &mut env,
+            extend_worker_env_unset_for_effort(
+                profile_launch.env_unset.iter().cloned().collect(),
+                provider,
+            ),
         );
         // BUG / C-1-2 / C-6-1 cr verdict — Copilot system_prompt 走 spawn env overlay +
         // per-worker AGENTS.md(B2 灵魂件降级):写
@@ -3975,6 +3979,7 @@ fn add_agent_with_transport_at_paths(
             pre_spec_text.as_deref(),
             pre_runtime_state.as_ref(),
             agent_id,
+            "state_upsert_failed",
         );
         return Err(error);
     }
@@ -3996,6 +4001,7 @@ fn add_agent_with_transport_at_paths(
                 pre_spec_text.as_deref(),
                 pre_runtime_state.as_ref(),
                 agent_id,
+                "start_agent_failed",
             );
             return Err(error);
         }
@@ -4012,6 +4018,7 @@ fn add_agent_with_transport_at_paths(
                 pre_spec_text.as_deref(),
                 pre_runtime_state.as_ref(),
                 agent_id,
+                "added_agent_paused",
             );
             return Err(LifecycleError::RequirementUnmet(format!(
                 "added agent {agent_id} is paused"
@@ -4037,12 +4044,21 @@ fn rollback_add_agent_atomic(
     pre_spec_text: Option<&str>,
     pre_runtime_state: Option<&serde_json::Value>,
     agent_id: &AgentId,
+    reason: &str,
 ) {
-    if let Some(text) = pre_spec_text {
-        let _ = std::fs::write(spec_path, text);
+    let spec_restored = if let Some(text) = pre_spec_text {
+        std::fs::write(spec_path, text).is_ok()
     } else {
-        let _ = std::fs::remove_file(spec_path);
-    }
+        std::fs::remove_file(spec_path)
+            .or_else(|error| {
+                if error.kind() == std::io::ErrorKind::NotFound {
+                    Ok(())
+                } else {
+                    Err(error)
+                }
+            })
+            .is_ok()
+    };
     // 0.5.26 (`.team/artifacts/stale-team-saveconflict-locate.md` §7.4):
     // rollback must tombstone the newly-added agent so the persist merge
     // does not re-attach a `roster_stub` from the latest on disk. Without
@@ -4050,12 +4066,13 @@ fn rollback_add_agent_atomic(
     // survives the restore-from-pre_state pass and the retry sees
     // "agent id already exists".
     let deleted = [agent_id.as_str()];
-    if let Some(state) = pre_runtime_state {
-        let _ = crate::state::persist::save_runtime_state_with_deleted_agents(
+    let state_restored = if let Some(state) = pre_runtime_state {
+        crate::state::persist::save_runtime_state_with_deleted_agents(
             run_workspace,
             state,
             &deleted,
-        );
+        )
+        .is_ok()
     } else {
         // No prior runtime state — drop just the agent we added (load → strip → save).
         if let Ok(mut state) = crate::state::persist::load_runtime_state(run_workspace) {
@@ -4078,13 +4095,27 @@ fn rollback_add_agent_atomic(
                     }
                 }
             }
-            let _ = crate::state::persist::save_runtime_state_with_deleted_agents(
+            crate::state::persist::save_runtime_state_with_deleted_agents(
                 run_workspace,
                 &state,
                 &deleted,
-            );
+            )
+            .is_ok()
+        } else {
+            false
         }
-    }
+    };
+    let rollback_ok = spec_restored && state_restored;
+    let _ = crate::event_log::EventLog::new(run_workspace).write(
+        "add_agent.rollback",
+        serde_json::json!({
+            "agent_id": agent_id.as_str(),
+            "reason": reason,
+            "rollback_ok": rollback_ok,
+            "spec_restored": spec_restored,
+            "state_restored": state_restored,
+        }),
+    );
 }
 
 fn upsert_agent_state_from_role(
@@ -4529,9 +4560,13 @@ pub fn fork_agent_with_transport(
     // _tmux_session_exists — an ABSENT session => new-session (spawn_first), present => new-window
     // (spawn_into). The Rust restart seam (restart.rs spawn_agent_window) uses the same branch.
     let session_live = transport.has_session(&session_name).unwrap_or(false);
-    let env_unset: Vec<String> = extend_worker_env_unset_for_effort(
-        profile_launch.env_unset.iter().cloned().collect(),
+    let env_unset = crate::layout::worker_env::isolate_worker_spawn_env(
         provider,
+        &mut env,
+        extend_worker_env_unset_for_effort(
+            profile_launch.env_unset.iter().cloned().collect(),
+            provider,
+        ),
     );
     let spawn_result = if session_live {
         transport.spawn_into_with_env_unset(

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

@@ -183,9 +183,13 @@ pub(super) fn spawn_agent_window(
     // 0.4.x provider effort MVP step 9: scrub CLAUDE_EFFORT for Claude
     // worker spawn so a parent shell env cannot silently override the
     // framework's effort decision.
-    let env_unset: Vec<String> = crate::lifecycle::launch::extend_worker_env_unset_for_effort(
-        profile_launch.env_unset.iter().cloned().collect(),
+    let env_unset = crate::layout::worker_env::isolate_worker_spawn_env(
         provider,
+        &mut env,
+        crate::lifecycle::launch::extend_worker_env_unset_for_effort(
+            profile_launch.env_unset.iter().cloned().collect(),
+            provider,
+        ),
     );
 
     // 0.4.6 Stage 2: write actual spawn plan event BEFORE invoking the

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

@@ -545,6 +545,9 @@ fn normalize_value(value: Value, ctx: &mut NormalizeCtx, key: Option<&str>) -> V
     if matches!(key, Some("env_overlay_keys" | "env_unset_keys")) {
         return json!("<ENV_KEYS>");
     }
+    if matches!(key, Some("env_unset")) {
+        return json!([]);
+    }
     match value {
         Value::Object(map) => {
             let sorted = map.into_iter().collect::<BTreeMap<_, _>>();