@team-agent/installer 0.4.9 → 0.4.11

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

@@ -4,7 +4,7 @@ use std::collections::{BTreeMap, BTreeSet};
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
-use crate::model::enums::{AuthMode, DisplayBackend, PaneLiveness, Provider};
+use crate::model::enums::{AuthMode, DisplayBackend, PaneLiveness, Provider, ProviderEffort};
 use crate::model::ids::AgentId;
 use crate::model::permissions::{self, AgentPermissionInput};
 use crate::model::yaml::{self, Value};
@@ -243,6 +243,16 @@ fn spawn_agents(
                 Some(&mcp_config),
             )?;
         let command_model = profile_launch.command_overrides.model.as_deref().or(model);
+        // 0.4.x provider effort MVP step 4 + 7: resolve effort and emit
+        // unsupported warning event when the spec asked for an effort the
+        // provider can't satisfy.
+        let agent_effort = provider_effort_for_spawn(agent, provider);
+        if let Some(event_value) =
+            provider_effort_event_if_dropped(agent, provider, agent_id_raw)
+        {
+            let _ = crate::event_log::EventLog::new(workspace)
+                .write("provider.effort_unsupported", event_value);
+        }
         let mut plan = adapter
             .build_command_plan(crate::provider::ProviderCommandContext {
                 auth_mode,
@@ -256,6 +266,7 @@ fn spawn_agents(
                 // adapters can pass `--name <agent_id>`. Codex has no
                 // equivalent flag and ignores the hint.
                 agent_id_hint: Some(agent_id_raw),
+                effort: agent_effort,
             })
             .map_err(|e| LifecycleError::Provider(e.to_string()))?;
         if !plan.managed_mcp_config && !profile_launch.managed_mcp_config {
@@ -320,7 +331,10 @@ 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> = profile_launch.env_unset.iter().cloned().collect();
+        let env_unset: Vec<String> = 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 灵魂件降级):写
         //   <workspace>/.team/runtime/copilot-instructions/<agent_id>/AGENTS.md
@@ -1721,6 +1735,13 @@ fn running_agent_state(
         model.map_or(serde_json::Value::Null, |m| serde_json::json!(m)),
     );
     state.insert("auth_mode".to_string(), serde_json::json!(auth_mode));
+    // 0.4.x provider effort MVP step 8: persist resolved effort so restart
+    // / resume reads the same value (no re-resolution from role/team).
+    if let Some(effort_str) = agent.get("effort").and_then(Value::as_str) {
+        if !effort_str.is_empty() {
+            state.insert("effort".to_string(), serde_json::json!(effort_str));
+        }
+    }
     state.insert("profile".to_string(), profile);
     if agent.get("profile").is_some() {
         if let Some(profile_dir) = profile_dir {
@@ -2466,6 +2487,112 @@ fn parse_auth_mode(raw: &str) -> Option<AuthMode> {
     }
 }
 
+/// 0.4.x provider effort MVP step 4: low-level from a raw string. Returns
+/// `Some(effort)` when the level parses AND the provider supports it.
+pub(crate) fn provider_effort_from_raw(
+    raw: Option<&str>,
+    provider: Provider,
+) -> Option<ProviderEffort> {
+    let raw = raw?.trim();
+    if raw.is_empty() {
+        return None;
+    }
+    let effort = ProviderEffort::parse(raw)?;
+    if effort.is_supported_by(provider) {
+        Some(effort)
+    } else {
+        None
+    }
+}
+
+/// 0.4.x provider effort MVP step 7: warning event payload when the spec
+/// requested an effort level the provider does not support.
+pub(crate) fn provider_effort_event_payload(
+    raw: Option<&str>,
+    provider: Provider,
+    agent_id: &str,
+) -> Option<serde_json::Value> {
+    let raw = raw?.trim();
+    if raw.is_empty() {
+        return None;
+    }
+    let effort = ProviderEffort::parse(raw)?;
+    if effort.is_supported_by(provider) {
+        return None;
+    }
+    Some(serde_json::json!({
+        "agent_id": agent_id,
+        "provider": format!("{provider:?}").to_lowercase(),
+        "effort": effort.as_str(),
+        "action": "ignored",
+        "reason": "provider does not support effort",
+    }))
+}
+
+/// 0.4.x provider effort MVP step 9: defensive guarantee that `CLAUDE_EFFORT`
+/// is unset in the Claude/ClaudeCode worker spawn env. As of the
+/// `profile_launch::provider_env_unsets` update, the base list already
+/// includes `CLAUDE_EFFORT` for Claude — so this function is idempotent
+/// (returns input unchanged). Kept as a belt-and-braces guard so a future
+/// refactor that bypasses provider_env_unsets cannot silently drop the
+/// scrub. The structural win is in `tmux_backend::shell_command` which now
+/// filters env exports by env_unset (preventing inherited values from
+/// re-introducing keys we just unset).
+pub(crate) fn extend_worker_env_unset_for_effort(
+    base: Vec<String>,
+    provider: Provider,
+) -> Vec<String> {
+    if !matches!(provider, Provider::Claude | Provider::ClaudeCode) {
+        return base;
+    }
+    let mut out = base;
+    if !out.iter().any(|k| k == "CLAUDE_EFFORT") {
+        out.push("CLAUDE_EFFORT".to_string());
+    }
+    out
+}
+
+/// Convenience: resolve effort for a yaml::Value agent (spec / compiled).
+pub(crate) fn provider_effort_for_spawn(
+    agent: &crate::model::yaml::Value,
+    provider: Provider,
+) -> Option<ProviderEffort> {
+    provider_effort_from_raw(agent.get("effort").and_then(|v| v.as_str()), provider)
+}
+
+pub(crate) fn provider_effort_event_if_dropped(
+    agent: &crate::model::yaml::Value,
+    provider: Provider,
+    agent_id: &str,
+) -> Option<serde_json::Value> {
+    provider_effort_event_payload(
+        agent.get("effort").and_then(|v| v.as_str()),
+        provider,
+        agent_id,
+    )
+}
+
+/// Same as [`provider_effort_for_spawn`] but for serde_json state values
+/// (used by restart paths reading from `state.agents[id]`).
+pub(crate) fn provider_effort_for_spawn_json(
+    agent: &serde_json::Value,
+    provider: Provider,
+) -> Option<ProviderEffort> {
+    provider_effort_from_raw(agent.get("effort").and_then(serde_json::Value::as_str), provider)
+}
+
+pub(crate) fn provider_effort_event_if_dropped_json(
+    agent: &serde_json::Value,
+    provider: Provider,
+    agent_id: &str,
+) -> Option<serde_json::Value> {
+    provider_effort_event_payload(
+        agent.get("effort").and_then(serde_json::Value::as_str),
+        provider,
+        agent_id,
+    )
+}
+
 fn quick_start_requested_team_key<'a>(
     team_id: Option<&'a str>,
     name: Option<&'a str>,
@@ -3786,6 +3913,16 @@ fn upsert_agent_state_from_role(
             }
         }
     }
+    // 0.4.x provider effort MVP step 8 (dynamic add-agent): persist effort
+    // from the role doc front matter (compiler.rs validates syntax/semantics
+    // at compile; add-agent path validates here too in case of direct YAML).
+    if let Some(effort_str) = meta.get("effort").and_then(Value::as_str) {
+        if !effort_str.is_empty() {
+            if let Some(obj) = entry.as_object_mut() {
+                obj.insert("effort".to_string(), serde_json::json!(effort_str));
+            }
+        }
+    }
     if let Some(obj) = entry.as_object_mut() {
         persist_effective_approval_policy(obj, safety);
     }
@@ -4075,6 +4212,15 @@ pub fn fork_agent_with_transport(
             Some(&mcp_config),
         )?;
     let command_model = profile_launch.command_overrides.model.as_deref().or(model);
+    // 0.4.x provider effort MVP: fork inherits effort from the new agent JSON
+    // (compiler.rs propagated the role/team effort into the agent at fork-spawn).
+    let fork_effort = provider_effort_for_spawn(new_agent, provider);
+    if let Some(event_value) =
+        provider_effort_event_if_dropped(new_agent, provider, as_agent_id.as_str())
+    {
+        let _ = crate::event_log::EventLog::new(&workspace)
+            .write("provider.effort_unsupported", event_value);
+    }
     let mut plan = adapter
         .fork_plan(
             Some(&session_id),
@@ -4086,6 +4232,7 @@ pub fn fork_agent_with_transport(
                 tools: &resolved_tool_refs,
                 profile_launch: Some(&profile_launch),
                 agent_id_hint: Some(as_agent_id.as_str()),
+                effort: fork_effort,
             },
         )
         .map_err(|e| {
@@ -4111,7 +4258,10 @@ 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> = profile_launch.env_unset.iter().cloned().collect();
+    let env_unset: Vec<String> = 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(
             &session_name,
@@ -4495,6 +4645,8 @@ fn upsert_forked_agent_state(
         "profile",
         "_profile_dir",
         "role",
+        // 0.4.x provider effort MVP step 8: fork inherits compiled effort.
+        "effort",
     ] {
         if let Some(value) = spec_agent.get(key) {
             entry.insert(key.to_string(), yaml_value_to_json(value));

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

@@ -450,6 +450,18 @@ pub(crate) fn provider_env_unsets(provider: Provider, auth_mode: AuthMode) -> BT
             unsets.insert("CLAUDE_CODE_ENTRYPOINT".to_string());
             unsets.insert("CLAUDE_CODE_EXECPATH".to_string());
             unsets.insert("CLAUDECODE".to_string());
+            // 0.4.x provider effort MVP step 9: CLAUDE_EFFORT carried from the
+            // launching shell would silently override the framework's effort
+            // decision (or, when no spec effort is configured, override the
+            // documented "provider default"). Scrubbing here is the single
+            // source — `extend_worker_env_unset_for_effort` is a thin alias
+            // that calls into this list. Applies to BOTH worker spawn AND
+            // leader spawn (leader_env_unset_for_provider also reads this).
+            // MVP scope: leader-effort is not configured yet, but if a
+            // launching shell already carries CLAUDE_EFFORT, the leader
+            // inheriting it would conflict with future leader-effort
+            // semantics. Scrub uniformly for predictability.
+            unsets.insert("CLAUDE_EFFORT".to_string());
             if auth_mode == AuthMode::CompatibleApi {
                 unsets.insert("ANTHROPIC_API_KEY".to_string());
             }

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

@@ -420,6 +420,48 @@ fn agent_pane_live_by_id(
     }
 }
 
+/// 0.4.10+ reset duplicate-window fix (CR-approved, plan §1).
+///
+/// Enumerate live panes whose `(session, window_name)` match the given pair.
+/// Used by `stop_agent_at_paths` (when the stored pane_id is stale/dead but a
+/// same-role window survives) and by the reset hard gate (to prove no
+/// duplicate window residue remains before `start_agent_at_paths`).
+///
+/// `list_targets()` is a point-in-time tmux snapshot — duplicates ARE
+/// preserved in the result so callers can see the full set.
+///
+/// Caller MUST also check `is_per_agent_window(window, agent_id)` before
+/// using this list to kill panes (plan §2 safety constraint): a shared
+/// layout window may host co-tenants.
+fn list_same_role_panes(
+    transport: &dyn crate::transport::Transport,
+    session: &crate::transport::SessionName,
+    window: &str,
+) -> Vec<crate::transport::PaneInfo> {
+    transport
+        .list_targets()
+        .unwrap_or_default()
+        .into_iter()
+        .filter(|pane| {
+            pane.session.as_str() == session.as_str()
+                && pane.window_name.as_ref().map(WindowName::as_str) == Some(window)
+        })
+        .collect()
+}
+
+/// 0.4.10+ reset duplicate-window fix (plan §2 safety constraint).
+///
+/// Returns true only when `window == agent_id`, i.e. the canonical
+/// per-agent window. Adaptive/shared layout windows (`workers`, `team`,
+/// or any layout window name produced by `is_adaptive_layout_window_pub`)
+/// MUST NOT be broad-killed by name — they may host co-tenants. The
+/// 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)
+}
+
 fn tmux_start_mode_for_spawn(
     spawn: &SpawnedAgentWindow,
     into_existing_session: bool,
@@ -602,22 +644,62 @@ pub(super) fn stop_agent_at_paths(
         .as_ref()
         .map(|pane| pane.as_str().to_string())
         .unwrap_or_else(|| format!("{}:{window}", session_name.as_str()));
-    let stopped = pane_id
+    // 0.4.10+ reset duplicate-window fix (plan §2): stop must resolve a
+    // STALE stored pane_id to live same-role panes by `(session, window)`
+    // enumeration BEFORE concluding the worker is absent. Pre-fix logic
+    // returned stopped=false when pane_id was dead even if a residual
+    // duplicate window survived — that residue then collided with
+    // reset's unconditional start, producing the observed
+    // `stopped=false, started=true` duplicate-window pattern.
+    //
+    // Only the STALE-pane-id branch enumerates same-role panes. When
+    // pane_id was never set in state (legacy state shape, never observed
+    // a real spawn), the existing window-based fallback is preserved —
+    // the duplicate-window bug requires a stored-but-stale pane_id as
+    // the trigger.
+    let stored_pane_live = pane_id
         .as_ref()
         .map(|pane| agent_pane_live_by_id(transport, pane))
-        .unwrap_or_else(|| window_exists(transport, &session_name, &window));
+        .unwrap_or(false);
+    let stored_pane_stale = pane_id.is_some() && !stored_pane_live;
+    let same_role_panes: Vec<crate::transport::PaneInfo> =
+        if stored_pane_stale && is_per_agent_window(&window, agent_id) {
+            list_same_role_panes(transport, &session_name, &window)
+        } else {
+            Vec::new()
+        };
+    let stopped = stored_pane_live
+        || !same_role_panes.is_empty()
+        || (pane_id.is_none() && window_exists(transport, &session_name, &window));
     if stopped {
         // golden operations.py:84-86: a non-zero kill-window raises
         // RuntimeError(f"failed to stop agent {agent_id}: {proc.stderr.strip()}").
-        let kill_result = if let Some(pane) = pane_id.as_ref() {
-            transport.kill_pane(pane)
-        } else {
-            let target = Target::SessionWindow {
-                session: session_name.clone(),
-                window: WindowName::new(&window),
+        //
+        // 0.4.10+ kill resolution order (plan §2):
+        //   1. stored pane_id is live → kill it by pane_id.
+        //   2. stored pane_id is stale BUT same-role panes survive →
+        //      kill each by pane_id (duplicate window names make
+        //      kill-window -t session:window ambiguous).
+        //   3. no pane_id at all but window exists → kill_window as
+        //      before (legacy compat for state without pane_id field).
+        let kill_result: Result<(), crate::transport::TransportError> =
+            if let Some(pane) = pane_id.as_ref().filter(|_| stored_pane_live) {
+                transport.kill_pane(pane)
+            } else if !same_role_panes.is_empty() {
+                let mut last_err: Option<crate::transport::TransportError> = None;
+                for residual in &same_role_panes {
+                    if let Err(e) = transport.kill_pane(&residual.pane_id) {
+                        last_err = Some(e);
+                    }
+                }
+                last_err.map(Err).unwrap_or(Ok(()))
+            } else {
+                let target = Target::SessionWindow {
+                    session: session_name.clone(),
+                    window: WindowName::new(&window),
+                };
+                transport.kill_window(&target)
             };
-            transport.kill_window(&target)
-        };
         if let Err(e) = kill_result {
             let stderr = match &e {
                 crate::transport::TransportError::Subprocess { stderr, .. } => stderr.trim().to_string(),
@@ -906,7 +988,158 @@ fn reset_agent_at_paths(
         .filter(|session| !session.is_empty())
         .map(SessionId::new);
     crate::lifecycle::launch::ensure_owner_allowed_for_state(&state_before_stop, Some(agent_id))?;
+    // Capture old pane_id / pane_pid / window BEFORE stop, so the hard gate
+    // below can prove the same prior instance is gone (or refuse start).
+    let old_pane_id_before = state_before_stop
+        .get("agents")
+        .and_then(|v| v.get(agent_id.as_str()))
+        .and_then(|v| v.get("pane_id"))
+        .and_then(|v| v.as_str())
+        .filter(|p| !p.is_empty())
+        .map(crate::transport::PaneId::new);
+    let old_pane_pid_before = state_pane_pid(&state_before_stop, agent_id);
+    // 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
+    // reset flows where stop killed the pane and the post-stop snapshot
+    // includes that same pane id in a transport mock that does not
+    // reflect kill removal).
+    let pre_stop_window = state_before_stop
+        .get("agents")
+        .and_then(|v| v.get(agent_id.as_str()))
+        .and_then(|v| v.get("window"))
+        .and_then(|v| v.as_str())
+        .filter(|s| !s.is_empty())
+        .unwrap_or_else(|| agent_id.as_str())
+        .to_string();
+    let pre_stop_spec = load_team_spec(spec_workspace).ok();
+    let pre_stop_session = pre_stop_spec
+        .as_ref()
+        .map(|spec| state_session_name_from_spec(&state_before_stop, spec));
+    let pre_stop_pane_ids: std::collections::BTreeSet<String> =
+        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()
+                    .map(|p| p.pane_id.as_str().to_string())
+                    .collect()
+            } else {
+                std::collections::BTreeSet::new()
+            }
+        } else {
+            std::collections::BTreeSet::new()
+        };
     let stop = stop_agent_at_paths(workspace, spec_workspace, agent_id, team, transport)?;
+
+    // 0.4.10+ paused agent skip: a paused agent's start path returns
+    // StartAgentOutcome::Paused (no spawn). There is no duplicate-window
+    // hazard, so the gate is a no-op for paused agents.
+    let agent_is_paused = state_before_stop
+        .get("agents")
+        .and_then(|v| v.get(agent_id.as_str()))
+        .and_then(|v| v.get("paused"))
+        .and_then(|v| v.as_bool())
+        .unwrap_or(false);
+    // 0.4.10+ reset duplicate-window fix (plan §3): HARD GATE before start.
+    // After stop_agent_at_paths returns, prove the old instance is gone OR
+    // refuse to spawn. The pre-fix path unconditionally proceeded to
+    // discard/save/start even when stop returned stopped=false (stop's
+    // pane_id was stale), creating the observed duplicate-window pattern.
+    //
+    // Residue definition (correct: differential, not absolute):
+    //   A pane is RESIDUE iff it appears in BOTH the pre-stop snapshot
+    //   AND the post-stop snapshot. The pre-fix attempt used "any
+    //   matching pane exists post-stop" which broke legitimate flows
+    //   where the transport mock does not model kill_pane removal.
+    //
+    // Old pane id / pid checks:
+    //   The OLD stored pane_id / pane_pid must be gone (not just
+    //   reachable but actually killed). For real tmux this is the
+    //   structural truth source; for mocks the differential approach
+    //   above covers the post-stop visibility.
+    //
+    // 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 {
+        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);
+        let gate_window = gate_state
+            .get("agents")
+            .and_then(|v| v.get(agent_id.as_str()))
+            .and_then(|v| v.get("window"))
+            .and_then(|v| v.as_str())
+            .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).
+        let post_stop_panes: Vec<crate::transport::PaneInfo> =
+            if is_per_agent_window(&gate_window, agent_id) {
+                list_same_role_panes(transport, &session_name_gate, &gate_window)
+            } else {
+                Vec::new()
+            };
+        let remaining_panes: Vec<crate::transport::PaneInfo> = post_stop_panes
+            .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() {
+            let remaining_pane_ids: Vec<String> = remaining_panes
+                .iter()
+                .map(|p| p.pane_id.as_str().to_string())
+                .collect();
+            let old_pane_str = old_pane_id_before
+                .as_ref()
+                .map(|p| p.as_str().to_string())
+                .unwrap_or_default();
+            let old_pid_val = old_pane_pid_before.unwrap_or(0);
+            let _ = write_reset_stop_not_proven_event(
+                workspace,
+                agent_id,
+                &old_pane_str,
+                old_pid_val,
+                &remaining_pane_ids,
+            );
+            // CR C-1 N38 three-line error: error / action / log_hint.
+            let _ = stop; // silence unused on the refusal path
+            return Err(LifecycleError::RequirementUnmet(format!(
+                "reset refused: old agent instance still live for {agent_id}\n\
+                 action: stop the worker manually with `team-agent stop-agent {agent_id} --team <team>` then retry reset, or kill the residual tmux panes [{ids}]\n\
+                 log_hint: see reset_agent.stop_not_proven event (old_pane_id={old}, old_pane_pid={pid}, remaining_panes=[{ids}])",
+                agent_id = agent_id.as_str(),
+                ids = remaining_pane_ids.join(", "),
+                old = old_pane_str,
+                pid = old_pid_val,
+            )));
+        }
+    }
+
     let mut state = resolve_team_scoped_state_or_refuse(workspace, team)?;
     let spec = load_team_spec(spec_workspace)?;
     discard_agent_session_fields(&mut state, agent_id)?;
@@ -1058,6 +1291,15 @@ fn write_start_agent_start_event(
         .model
         .as_deref()
         .or(model);
+    // 0.4.x provider effort MVP: start_agent path preserves effort from the
+    // persisted agent JSON.
+    let start_agent_effort = crate::lifecycle::launch::provider_effort_for_spawn_json(&agent, provider);
+    if let Some(event_value) = crate::lifecycle::launch::provider_effort_event_if_dropped_json(
+        &agent, provider, agent_id.as_str(),
+    ) {
+        let _ = crate::event_log::EventLog::new(workspace)
+            .write("provider.effort_unsupported", event_value);
+    }
     let context = crate::provider::ProviderCommandContext {
         auth_mode,
         mcp_config: Some(&mcp_config),
@@ -1066,6 +1308,7 @@ fn write_start_agent_start_event(
         tools: &resolved_tool_refs,
         profile_launch: Some(&profile_launch),
         agent_id_hint: Some(agent_id.as_str()),
+        effort: start_agent_effort,
     };
     let mut plan = match session_id {
         Some(session_id) => adapter
@@ -1188,6 +1431,32 @@ fn write_reset_tombstone_event(
     Ok(())
 }
 
+/// 0.4.10+ reset duplicate-window fix (plan §3): emit a structured event
+/// when the reset hard gate refuses to start because the old instance is
+/// proven still live (old pane id reachable, old pane pid alive, or
+/// same-role panes remain in the team session).
+fn write_reset_stop_not_proven_event(
+    workspace: &Path,
+    agent_id: &AgentId,
+    old_pane_id: &str,
+    old_pane_pid: u32,
+    remaining_panes: &[String],
+) -> Result<(), LifecycleError> {
+    crate::event_log::EventLog::new(workspace)
+        .write(
+            "reset_agent.stop_not_proven",
+            serde_json::json!({
+                "agent_id": agent_id.as_str(),
+                "old_pane_id": old_pane_id,
+                "old_pane_pid": old_pane_pid,
+                "remaining_panes": remaining_panes,
+                "action": "stop the worker manually then retry reset, or kill the residual tmux panes",
+            }),
+        )
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    Ok(())
+}
+
 fn write_reset_complete_event(
     workspace: &Path,
     agent_id: &AgentId,

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

@@ -114,6 +114,15 @@ pub(super) fn spawn_agent_window(
             Some(&mcp_config),
         )?;
     let command_model = profile_launch.command_overrides.model.as_deref().or(model);
+    // 0.4.x provider effort MVP: restart/resume preserves effort from the
+    // persisted agent JSON (state's agent["effort"] field, set by launch).
+    let restart_effort = crate::lifecycle::launch::provider_effort_for_spawn_json(agent, provider);
+    if let Some(event_value) = crate::lifecycle::launch::provider_effort_event_if_dropped_json(
+        agent, provider, agent_id.as_str(),
+    ) {
+        let _ = crate::event_log::EventLog::new(workspace)
+            .write("provider.effort_unsupported", event_value);
+    }
     let context = crate::provider::ProviderCommandContext {
         auth_mode,
         mcp_config: Some(&mcp_config),
@@ -122,6 +131,7 @@ pub(super) fn spawn_agent_window(
         tools: &resolved_tool_refs,
         profile_launch: Some(&profile_launch),
         agent_id_hint: Some(agent_id.as_str()),
+        effort: restart_effort,
     };
     let mut plan = match resume_session_id {
         Some(session_id) => adapter
@@ -167,7 +177,13 @@ pub(super) fn spawn_agent_window(
     // a per-agent YAML `spawn_cwd` field if one is set. Until then, override
     // > workspace; state-based override is silently dropped.
     let spawn_cwd = spawn_cwd_override.unwrap_or(workspace);
-    let env_unset: Vec<String> = profile_launch.env_unset.iter().cloned().collect();
+    // 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(),
+        provider,
+    );
 
     // 0.4.6 Stage 2: write actual spawn plan event BEFORE invoking the
     // transport spawn. Mirrors `launch.rs:359-380` (the reference impl)