@team-agent/installer 0.3.13 → 0.3.15

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

@@ -116,10 +116,9 @@ pub fn restart_with_transport_with_session_convergence_deadline(
     // 显式存在性门(下移后):selected.spec_path 经读序 B 已定位 runtime/legacy spec。
     // 缺(空目录 restart 等)→ 报真实期望路径,不误导去用户目录找。
     if !selected.spec_path.as_ref().is_some_and(|p| p.exists()) {
-        let expected = selected
-            .spec_path
-            .clone()
-            .unwrap_or_else(|| crate::model::paths::runtime_spec_path(&selected.run_workspace, &selected.team_key));
+        let expected = selected.spec_path.clone().unwrap_or_else(|| {
+            crate::model::paths::runtime_spec_path(&selected.run_workspace, &selected.team_key)
+        });
         return Err(LifecycleError::TeamSelect(format!(
             "missing spec for restart: {} (run `team-agent quick-start <teamdir>` first, or restore the team's role docs)",
             expected.display()
@@ -130,9 +129,11 @@ pub fn restart_with_transport_with_session_convergence_deadline(
     // E5 task#3 / RC-A6a + E4(leader 裁定:每次 restart 都从角色定义重建 runtime spec,覆盖):
     // 角色定义=第一真相源。角色齐 → compile_team 重建 + 保留运行期 override(session_name)+
     // 写 runtime spec。角色缺(TEAM.md/agents 不在)→ 显式拒(列缺哪些),旧 spec 原地保留不删不用。
-    let spec = rebuild_runtime_spec_from_roles(&selected.run_workspace, &selected.team_key, &state)?;
+    let spec =
+        rebuild_runtime_spec_from_roles(&selected.run_workspace, &selected.team_key, &state)?;
     // 重建后 spec_workspace 恒为 runtime spec 的父目录(.team/runtime/<team_key>/)。
-    let runtime_spec = crate::model::paths::runtime_spec_path(&selected.run_workspace, &selected.team_key);
+    let runtime_spec =
+        crate::model::paths::runtime_spec_path(&selected.run_workspace, &selected.team_key);
     let spec_workspace = runtime_spec.parent().ok_or_else(|| {
         LifecycleError::TeamSelect("active team spec workspace not found".to_string())
     })?;
@@ -173,13 +174,23 @@ pub fn restart_with_transport_with_session_convergence_deadline(
         crate::state::projection::save_team_scoped_state(&selected.run_workspace, &state)
             .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
     }
-    let forced_fresh_missing = if convergence.converged {
+    let mut forced_fresh_missing = if convergence.converged {
         std::collections::BTreeSet::new()
     } else {
         convergence.missing.iter().cloned().collect()
     };
     let forced_fresh_convergence = (!convergence.converged).then_some(convergence.clone());
-    let plan = classify_restart_plan_with_resume_validation(Some(&selected.run_workspace), &state, allow_fresh)?;
+    let plan = classify_restart_plan_with_resume_validation(
+        Some(&selected.run_workspace),
+        &state,
+        allow_fresh,
+    )?;
+    for decision in &plan.decisions {
+        if matches!(decision.decision, ResumeDecision::FreshStart) && decision.session_id.is_some()
+        {
+            forced_fresh_missing.insert(decision.agent_id.as_str().to_string());
+        }
+    }
     write_restart_resume_decision_events(
         &selected.run_workspace,
         &state,
@@ -214,10 +225,15 @@ pub fn restart_with_transport_with_session_convergence_deadline(
     }
     let mut successful_agents: Vec<RestartedAgent> = Vec::new();
     let mut failed_agents: Vec<RestartFailedAgent> = Vec::new();
+    let mut fatal_resume_failure = false;
     // B5 restart isolation loop: per-agent spawn failures must be recorded and
-    // isolated here. Do not reintroduce `?`, `break`, or `return` inside this loop.
+    // isolated here. G1 resume-integrity failures set a fatal flag and skip later
+    // spawns; do not reintroduce `?`, `break`, or `return` inside this loop.
     // BEGIN_B5_RESTART_ISOLATION_LOOP
     for decision in &plan.decisions {
+        if fatal_resume_failure {
+            continue;
+        }
         let Some(agent) = state
             .get("agents")
             .and_then(|v| v.get(decision.agent_id.as_str()))
@@ -225,7 +241,12 @@ pub fn restart_with_transport_with_session_convergence_deadline(
         else {
             let error = format!("agent {} not found for restart", decision.agent_id);
             mark_agent_restart_failed(&mut state, decision, &error);
-            let _ = write_restart_agent_failed_event(&selected.run_workspace, decision, "spawn", &error);
+            let _ = write_restart_agent_failed_event(
+                &selected.run_workspace,
+                decision,
+                "spawn",
+                &error,
+            );
             failed_agents.push(restart_failed_agent(decision, "spawn", error));
             continue;
         };
@@ -251,9 +272,21 @@ pub fn restart_with_transport_with_session_convergence_deadline(
                     &error,
                 );
                 failed_agents.push(restart_failed_agent(&previous, "resume", error));
+                if is_resume_integrity_failure(&previous, "resume", "") {
+                    fatal_resume_failure = true;
+                }
                 session_live = false;
             }
         }
+        if fatal_resume_failure {
+            continue;
+        }
+        let layout_placement = crate::lifecycle::launch::adaptive_existing_placement_for_agent(
+            &state,
+            transport,
+            &session_name,
+            &decision.agent_id,
+        );
         let spawn = match spawn_agent_window(
             &selected.run_workspace,
             &session_name,
@@ -263,31 +296,48 @@ pub fn restart_with_transport_with_session_convergence_deadline(
             session_live,
             transport,
             Some(&safety),
+            layout_placement.as_ref(),
             Some(spec_workspace),
         ) {
             Ok(spawn) => spawn,
             Err(error) => {
                 let error = error.to_string();
                 mark_agent_restart_failed(&mut state, decision, &error);
-                let _ = write_restart_agent_failed_event(&selected.run_workspace, decision, "spawn", &error);
-                failed_agents.push(restart_failed_agent(decision, "spawn", error));
+                let phase = restart_failure_phase(decision, "spawn", &error);
+                let _ = write_restart_agent_failed_event(
+                    &selected.run_workspace,
+                    decision,
+                    phase,
+                    &error,
+                );
+                failed_agents.push(restart_failed_agent(decision, phase, error));
+                if phase == "resume" {
+                    fatal_resume_failure = true;
+                }
                 continue;
             }
         };
         if let Err(error) = verify_spawned_agent_live(&decision.agent_id, &spawn, transport)
             .and_then(|_| {
-                mark_agent_respawned(&mut state, &decision.agent_id, &spawn, transport, &safety)
+                mark_agent_respawned(
+                    &mut state,
+                    &decision.agent_id,
+                    decision.restart_mode,
+                    &spawn,
+                    transport,
+                    &safety,
+                )
             })
         {
             let error = error.to_string();
             mark_agent_restart_failed(&mut state, decision, &error);
-            let _ = write_restart_agent_failed_event(
-                &selected.run_workspace,
-                decision,
-                "readiness",
-                &error,
-            );
-            failed_agents.push(restart_failed_agent(decision, "readiness", error));
+            let phase = restart_failure_phase(decision, "readiness", &error);
+            let _ =
+                write_restart_agent_failed_event(&selected.run_workspace, decision, phase, &error);
+            failed_agents.push(restart_failed_agent(decision, phase, error));
+            if phase == "resume" {
+                fatal_resume_failure = true;
+            }
             continue;
         }
         successful_agents.push(decision.clone());
@@ -303,6 +353,22 @@ pub fn restart_with_transport_with_session_convergence_deadline(
     // END_B5_RESTART_ISOLATION_LOOP
     crate::state::projection::save_team_scoped_state(&selected.run_workspace, &state)
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    if fatal_resume_failure {
+        let attach_commands = Vec::new();
+        let next_actions = restart_failure_next_actions(&failed_agents);
+        write_restart_completed_event(
+            &selected.run_workspace,
+            &successful_agents,
+            &failed_agents,
+            "fail",
+        )?;
+        return Ok(RestartReport::Failed {
+            session_name,
+            failed_agents,
+            next_actions,
+            attach_commands,
+        });
+    }
     if successful_agents.is_empty() && !failed_agents.is_empty() {
         let attach_commands = Vec::new();
         let next_actions = restart_failure_next_actions(&failed_agents);
@@ -555,9 +621,9 @@ fn parse_duration_value_seconds_ms(value: &str) -> Option<u64> {
 }
 
 fn restart_readiness_deadline(requested_ms: Option<u64>) -> std::time::Duration {
-    requested_ms.map(std::time::Duration::from_millis).unwrap_or_else(|| {
-        env_duration_ms(&["TEAM_AGENT_RESTART_READINESS_DEADLINE_MS"], 30_000)
-    })
+    requested_ms
+        .map(std::time::Duration::from_millis)
+        .unwrap_or_else(|| env_duration_ms(&["TEAM_AGENT_RESTART_READINESS_DEADLINE_MS"], 30_000))
 }
 
 fn restart_readiness_poll_interval() -> std::time::Duration {
@@ -595,11 +661,14 @@ fn wait_restart_readiness_or_timeout(
         let elapsed = started.elapsed();
         if elapsed >= deadline {
             write_restart_readiness_timeout_event(workspace, readiness, deadline, elapsed)?;
-            return Err(LifecycleError::RequirementUnmet(restart_readiness_timeout_message(
-                workspace, readiness, deadline,
-            )));
+            return Err(LifecycleError::RequirementUnmet(
+                restart_readiness_timeout_message(workspace, readiness, deadline),
+            ));
         }
-        std::thread::sleep(std::cmp::min(poll_interval, deadline.saturating_sub(elapsed)));
+        std::thread::sleep(std::cmp::min(
+            poll_interval,
+            deadline.saturating_sub(elapsed),
+        ));
     }
 }
 
@@ -615,7 +684,11 @@ fn restart_readiness(
     let coordinator_workspace = crate::coordinator::WorkspacePath::new(workspace.to_path_buf());
     let coordinator_alive =
         crate::coordinator::coordinator_health(&coordinator_workspace).ok && session_created;
-    RestartReadiness { session_created, worker_pane_addressable, coordinator_alive }
+    RestartReadiness {
+        session_created,
+        worker_pane_addressable,
+        coordinator_alive,
+    }
 }
 
 fn restart_worker_panes_addressable(
@@ -727,7 +800,11 @@ fn restart_readiness_missing_summary(readiness: RestartReadiness) -> String {
 }
 
 fn yes_no(value: bool) -> &'static str {
-    if value { "yes" } else { "no" }
+    if value {
+        "yes"
+    } else {
+        "no"
+    }
 }
 
 fn verify_spawned_agent_live(
@@ -788,6 +865,7 @@ fn mark_restart_targets_stopped_after_teardown(
 fn mark_agent_respawned(
     state: &mut serde_json::Value,
     agent_id: &AgentId,
+    restart_mode: StartMode,
     spawn: &SpawnedAgentWindow,
     transport: &dyn crate::transport::Transport,
     safety: &DangerousApproval,
@@ -804,6 +882,10 @@ fn mark_agent_respawned(
         )));
     };
     agent.insert("status".to_string(), serde_json::json!("running"));
+    agent.insert(
+        "window".to_string(),
+        serde_json::json!(spawn.spawn.window.as_str()),
+    );
     agent.insert(
         "pane_id".to_string(),
         serde_json::json!(spawn.spawn.pane_id.as_str()),
@@ -819,8 +901,60 @@ fn mark_agent_respawned(
     if let Some(pane_pid) = pane_pid {
         agent.insert("pane_pid".to_string(), serde_json::json!(pane_pid));
     }
+    if matches!(
+        restart_mode,
+        StartMode::Fresh | StartMode::FreshAfterMissingRollout
+    ) {
+        if let Some(session_id) = spawn.plan.expected_session_id.as_ref() {
+            agent.insert(
+                "session_id".to_string(),
+                serde_json::json!(session_id.as_str()),
+            );
+        }
+    }
     crate::lifecycle::launch::persist_command_plan_state(agent, &spawn.plan, &spawn.profile_launch);
     persist_effective_approval_policy_for_restart(agent, safety);
+    if let Some(placement) = spawn.layout_placement.as_ref() {
+        agent.insert(
+            "layout_window".to_string(),
+            serde_json::json!(placement.layout_window.as_str()),
+        );
+        agent.insert(
+            "layout_index".to_string(),
+            serde_json::json!(placement.layout_index),
+        );
+        agent.insert("pane_index".to_string(), serde_json::json!(placement.pane_index));
+        agent.insert(
+            "display".to_string(),
+            serde_json::json!({
+                "backend": "adaptive",
+                "status": "opened",
+                "window": placement.layout_window.as_str(),
+                "workspace_window": null,
+                "pane_id": spawn.spawn.pane_id.as_str(),
+                "pane_title": agent_id.as_str(),
+                "target": spawn.spawn.pane_id.as_str(),
+                "target_worker_session": spawn.spawn.session.as_str(),
+                "linked_session": null,
+                "leader_session": spawn.spawn.session.as_str(),
+                "display_session": null,
+                "fallback": null,
+            }),
+        );
+    }
+    if matches!(
+        restart_mode,
+        StartMode::Fresh | StartMode::FreshAfterMissingRollout
+    ) && spawn.plan.expected_session_id.is_some()
+    {
+        agent.insert("rollout_path".to_string(), serde_json::Value::Null);
+        agent.insert("captured_at".to_string(), serde_json::Value::Null);
+        agent.insert("captured_via".to_string(), serde_json::Value::Null);
+        agent.insert(
+            "attribution_confidence".to_string(),
+            serde_json::Value::Null,
+        );
+    }
     agent.remove("startup_prompts");
     agent.remove("startup_prompt_status");
     Ok(())
@@ -841,6 +975,33 @@ fn restart_failed_agent(
     }
 }
 
+fn restart_failure_phase(
+    decision: &RestartedAgent,
+    phase: &'static str,
+    error: &str,
+) -> &'static str {
+    if is_resume_integrity_failure(decision, phase, error) {
+        "resume"
+    } else {
+        phase
+    }
+}
+
+fn is_resume_integrity_failure(decision: &RestartedAgent, phase: &str, error: &str) -> bool {
+    if !matches!(decision.restart_mode, StartMode::Resumed) {
+        return false;
+    }
+    if phase == "resume" || phase == "readiness" {
+        return true;
+    }
+    error.contains("session_disappeared_after_spawn")
+        || error.contains("provider_resume_exited")
+        || error.contains("resume_not_ready")
+        || error.contains("resume_atomicity")
+        || error.contains("no live pane")
+        || error.contains("no-pane")
+}
+
 fn mark_agent_restart_failed(
     state: &mut serde_json::Value,
     decision: &RestartedAgent,
@@ -1157,13 +1318,16 @@ fn rebuild_runtime_spec_from_roles(
     let agents_dir = team_dir.join("agents");
     let has_role_doc = std::fs::read_dir(&agents_dir)
         .map(|entries| {
-            entries.flatten().any(|e| {
-                e.path().extension().and_then(|x| x.to_str()) == Some("md")
-            })
+            entries
+                .flatten()
+                .any(|e| e.path().extension().and_then(|x| x.to_str()) == Some("md"))
         })
         .unwrap_or(false);
     if !has_role_doc {
-        missing.push(format!("{}/*.md (at least one role doc)", agents_dir.display()));
+        missing.push(format!(
+            "{}/*.md (at least one role doc)",
+            agents_dir.display()
+        ));
     }
     if !missing.is_empty() {
         // N38 三行式:error / action / log。旧 runtime spec 原地保留(不删不用)。

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

@@ -1,5 +1,5 @@
-use super::*;
 use super::common::*;
+use super::*;
 
 /// bug-085 四象限 `start_mode` 决策(`start.py:179-188` + `_resume_rollout_missing` `start.py:66-69`),
 /// **从 start_agent 的整条 lock+spawn 路径里分离出的纯函数**(gate gap:porter 需要单元级 RED
@@ -19,7 +19,8 @@ pub fn decide_start_mode(
     match session_id {
         None => StartMode::Fresh,
         Some(_) => {
-            let missing_resume_backing = resumable_provider_requires_backing(provider) && !rollout_exists;
+            let missing_resume_backing = !provider_wire_supports_resume(provider)
+                || (resumable_provider_requires_backing(provider) && !rollout_exists);
             match (missing_resume_backing, allow_fresh) {
                 (true, true) => StartMode::FreshAfterMissingRollout,
                 (true, false) => StartMode::Noop,
@@ -188,8 +189,10 @@ pub(crate) fn classify_restart_plan_with_resume_validation(
         // (leader 从未发消息 → first_send_at=null → interacted=false)会被它静默 fresh 丢上下文。
         let provider = agent_provider(agent);
         let provider_wire = provider_wire(provider);
-        let resume_backing_exists = match (workspace, session_id.as_ref()) {
-            (Some(workspace), Some(session)) => resume_backing_exists_for_agent(
+        let provider_can_resume = provider_supports_resume(provider);
+        let resume_backing_exists = match (workspace, session_id.as_ref(), provider_can_resume) {
+            (_, Some(_), false) => false,
+            (Some(workspace), Some(session), true) => resume_backing_exists_for_agent(
                 workspace,
                 &agent_id,
                 agent,
@@ -197,14 +200,14 @@ pub(crate) fn classify_restart_plan_with_resume_validation(
                 session,
                 agent_rollout_path(agent).as_ref(),
             ),
-            (None, Some(_)) if resumable_provider_requires_backing(provider_wire) => {
+            (None, Some(_), true) if resumable_provider_requires_backing(provider_wire) => {
                 agent_rollout_path(agent)
                     .as_ref()
                     .is_some_and(|path| path.as_path().exists())
             }
             _ => true,
         };
-        let decision = if session_id.is_some() && resume_backing_exists {
+        let decision = if session_id.is_some() && provider_can_resume && resume_backing_exists {
             ResumeDecision::Resume
         } else if session_id.is_some() && allow_fresh {
             ResumeDecision::FreshStart