@team-agent/installer 0.3.6 → 0.3.8

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

@@ -83,28 +83,39 @@ pub fn restart_with_transport_with_session_convergence_deadline(
             workspace.join("team.spec.yaml").display()
         )));
     }
-    let run_candidate = crate::model::paths::canonical_run_workspace(workspace)
-        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
-    if !workspace.join("team.spec.yaml").exists()
-        && !crate::state::persist::runtime_state_path(&run_candidate).exists()
-    {
-        return Err(LifecycleError::TeamSelect(format!(
-            "missing spec for restart: {}",
-            workspace.join("team.spec.yaml").display()
-        )));
-    }
+    // RED-2(P0)修:存在性门下移到 resolve 之后,用 selected.spec_path(读序 B:runtime 优先、
+    // legacy 用户目录回落)判,而非 resolve 前自拼 workspace/team.spec.yaml(spec-demote 后 spec
+    // 不在用户目录 → 旧门误报缺)。resolve_active_team(RequireSpec) 内部已按 spec_path 校验存在性,
+    // 故直接交给它;失败信息(含真实 expected runtime spec 路径)即正确的 N38。
     let selected = crate::state::selector::resolve_active_team(
         workspace,
         team,
         crate::state::selector::SelectorMode::RequireSpec,
     )
     .map_err(|e| LifecycleError::TeamSelect(e.to_string()))?;
+    // 显式存在性门(下移后):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));
+        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()
+        )));
+    }
     let mut state = selected.state;
     crate::lifecycle::launch::ensure_owner_allowed_for_state(&state, None)?;
-    let spec_workspace = selected.spec_workspace.as_ref().ok_or_else(|| {
+    // 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)?;
+    // 重建后 spec_workspace 恒为 runtime spec 的父目录(.team/runtime/<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())
     })?;
-    let spec = load_team_spec(spec_workspace)?;
     let safety = crate::lifecycle::launch::effective_runtime_config(&spec)?;
     let mut convergence = converge_missing_provider_sessions(
         &mut state,
@@ -713,6 +724,74 @@ fn restart_candidate_from_state(
     }
 }
 
+/// E5 task#3 / RC-A6a:每次 restart 都以**角色定义**(team_dir 的 TEAM.md+agents/*.md)
+/// compile_team 重建 runtime spec(覆盖),保留运行期 override(session_name 必须延续,
+/// 否则 tmux session 对不上)。写到 .team/runtime/<team_key>/team.spec.yaml。
+///
+/// 角色定义缺(team_dir 未记 / TEAM.md 不在 / agents 不在)→ **显式拒**(LifecycleError,
+/// CLI N38 三行式),列出缺哪些;**旧 spec 原地保留不删不用**(T2 防数据销毁,无静默路径)。
+fn rebuild_runtime_spec_from_roles(
+    run_workspace: &Path,
+    team_key: &str,
+    state: &serde_json::Value,
+) -> Result<YamlValue, LifecycleError> {
+    // team_dir(角色定义源)优先取 state.team_dir;缺则回落 run_workspace(自含 team-dir 布局,
+    // run_workspace 本身即角色目录)。两者都无角色定义则下面的齐全性检查会显式拒。
+    let team_dir = state
+        .get("team_dir")
+        .and_then(serde_json::Value::as_str)
+        .filter(|s| !s.is_empty())
+        .map(std::path::PathBuf::from)
+        .unwrap_or_else(|| run_workspace.to_path_buf());
+    // 角色定义齐全性检查(显式拒,列缺哪些;旧 spec 不动)。
+    let mut missing: Vec<String> = Vec::new();
+    if !team_dir.join("TEAM.md").exists() {
+        missing.push(format!("{}/TEAM.md", team_dir.display()));
+    }
+    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")
+            })
+        })
+        .unwrap_or(false);
+    if !has_role_doc {
+        missing.push(format!("{}/*.md (at least one role doc)", agents_dir.display()));
+    }
+    if !missing.is_empty() {
+        // N38 三行式:error / action / log。旧 runtime spec 原地保留(不删不用)。
+        return Err(LifecycleError::TeamSelect(format!(
+            "cannot restart: role definitions missing for team '{team_key}': {}. \
+             action: restore the listed role docs (TEAM.md + agents/*.md are the source of truth), \
+             then re-run restart; the previous runtime spec is left in place (not used). \
+             log: team_dir={}",
+            missing.join(", "),
+            team_dir.display(),
+        )));
+    }
+    // 重建:compile_team(角色定义) + 保留运行期 session_name override。
+    let mut spec = crate::compiler::compile_team(&team_dir)
+        .map_err(|e| LifecycleError::Compile(e.to_string()))?;
+    if let Some(session_name) = state
+        .get("session_name")
+        .and_then(serde_json::Value::as_str)
+        .filter(|s| !s.is_empty())
+    {
+        crate::lifecycle::launch::override_spec_session_name(&mut spec, session_name);
+    }
+    // 写 runtime spec(覆盖,原子 tmp+rename;Bug2)。
+    let spec_path = crate::model::paths::runtime_spec_path(run_workspace, team_key);
+    crate::lifecycle::launch::write_spec_atomic(&spec_path, &spec)?;
+    // RC-A6a:重建成功后清理用户目录的 legacy spec(中间产物不该留在角色目录)。
+    // 仅删 team_dir 下的 team.spec.yaml(角色定义 TEAM.md/agents 不动);失败不致命(best-effort)。
+    let legacy_spec = team_dir.join("team.spec.yaml");
+    if legacy_spec.exists() && legacy_spec != spec_path {
+        let _ = std::fs::remove_file(&legacy_spec);
+    }
+    Ok(spec)
+}
+
 fn restart_candidate_spec_path(workspace: &Path, state: &serde_json::Value) -> std::path::PathBuf {
     if let Some(path) = state
         .get("spec_path")

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

@@ -120,8 +120,8 @@ pub fn python_type_name(value: &serde_json::Value) -> &'static str {
 /// `_collect_corrupt_first_send_at`,`orchestration.py:430/467`)。读 fixture state 的
 /// `agents.<id>`,对每非 paused worker:
 /// (1) corrupt first_send_at → 收进 `corrupt_entries`(carry python type-name);
-/// (2) 算 resume 决策(`resumable→Resume` / `!resumable&&!interacted→FreshStart` /
-///     `!resumable&&interacted&&allow_fresh→FreshStart` / 否则 `Refuse`);
+/// (2) 算 resume 决策(`session_id→Resume` / `null session && allow_fresh→FreshStart` /
+///     否则 `Refuse`;E6 层2:null session 不再因 first_send_at=null 静默 fresh);
 /// (3) `Refuse` 的 worker(reason=`no_persisted_session_id`(无 session)|`session_unresumable`)
 ///     进 `unresumable`。
 /// restart() **先**调它再 teardown;corrupt 非空 → `RefusedInvalidFirstSendAt`,unresumable
@@ -171,10 +171,12 @@ pub fn classify_restart_plan(
             .and_then(|v| v.as_str())
             .filter(|s| !s.is_empty())
             .map(SessionId::new);
-        let interacted = matches!(first_send_at_state, FirstSendAtState::Valid);
+        // E6 层2 (C2, 用户裁定"绝不静默 fresh"): null session 只有显式 --allow-fresh 才 fresh,
+        // 否则 Refuse(→ resume_not_ready + 指引)。删 `!interacted` 短路 —— 自启动 worker
+        // (leader 从未发消息 → first_send_at=null → interacted=false)会被它静默 fresh 丢上下文。
         let decision = if session_id.is_some() {
             ResumeDecision::Resume
-        } else if !interacted || allow_fresh {
+        } else if allow_fresh {
             ResumeDecision::FreshStart
         } else {
             ResumeDecision::Refuse

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

@@ -1,4 +1,5 @@
 use super::*;
+use crate::transport::PaneLiveness;
 
 // ───────────────────────────────────────────────────────────────────────
 // classify_first_send_at — _classify_first_send_at (orchestration.py:404)
@@ -491,14 +492,57 @@ fn classify_restart_plan_interacted_unresumable_with_allow_fresh_yields_fresh_st
 }
 
 #[test]
-fn classify_restart_plan_never_interacted_yields_fresh_start() {
-    // first_send_at absent(从未交互)→ FreshStart,即使 !allow_fresh(无 context 可丢)。
+fn classify_restart_plan_never_interacted_null_session_refuses_not_fresh() {
+    // E6 层2 (C2, 用户裁定"绝不静默 fresh"): first_send_at absent(自启动 worker,leader 从未发消息)
+    // + session_id null → 不能再静默 FreshStart(那会丢真实 provider 会话上下文)。
+    // 默认 !allow_fresh → Refuse + unresumable(诚实出口 resume_not_ready)。
     let state = json!({
         "agents": { "w1": { "provider": "claude", "session_id": null } }
     });
     let plan = classify_restart_plan(&state, false).expect("纯验证不应 Err");
     assert_eq!(plan.decisions.len(), 1);
-    assert_eq!(plan.decisions[0].decision, ResumeDecision::FreshStart);
+    assert_eq!(
+        plan.decisions[0].decision,
+        ResumeDecision::Refuse,
+        "null-session 自启动 worker 默认必须 Refuse,不许静默 fresh"
+    );
+    assert_eq!(plan.unresumable.len(), 1, "Refuse 必入 unresumable(诚实出口)");
+    assert_eq!(plan.unresumable[0].reason, "no_persisted_session_id");
+}
+
+#[test]
+fn classify_restart_plan_never_interacted_null_session_with_allow_fresh_marks_forced_fresh() {
+    // E6 层2: 同上自启动 null-session worker,但显式 --allow-fresh → 用户主动认账丢上下文 → FreshStart。
+    let state = json!({
+        "agents": { "w1": { "provider": "claude", "session_id": null } }
+    });
+    let plan = classify_restart_plan(&state, true).expect("纯验证不应 Err");
+    assert_eq!(plan.decisions.len(), 1);
+    assert_eq!(
+        plan.decisions[0].decision,
+        ResumeDecision::FreshStart,
+        "显式 --allow-fresh 才允许 null-session worker fresh"
+    );
+    assert!(
+        plan.unresumable.is_empty(),
+        "allow_fresh 下不触发 unresumable refusal"
+    );
+}
+
+#[test]
+fn classify_restart_plan_codex_with_session_still_resumes() {
+    // E6 层2 回归锁(不误伤): codex worker first_send_at=null 但 session_id 已捕 →
+    // 仍走 Resume(分流轴是 session_id 有无,不是 interacted)。防层2 修法把 has_session 也误判。
+    let state = json!({
+        "agents": { "w1": { "provider": "codex", "session_id": "sess-codex-abc" } }
+    });
+    let plan = classify_restart_plan(&state, false).expect("纯验证不应 Err");
+    assert_eq!(plan.decisions.len(), 1);
+    assert_eq!(
+        plan.decisions[0].decision,
+        ResumeDecision::Resume,
+        "有 session_id 必 Resume,与 first_send_at/interacted 无关"
+    );
     assert!(plan.unresumable.is_empty());
 }
 
@@ -751,6 +795,189 @@ fn detect_dangerous_approval_clean_process_is_disabled() {
     assert!(!got.inherited);
 }
 
+#[test]
+#[serial_test::serial(env)]
+fn leader_pane_env_absent_pane_fails_fast() {
+    let _leader_pane = EnvVarGuard::set("TEAM_AGENT_LEADER_PANE_ID", "%9999");
+    let transport =
+        crate::transport::test_support::OfflineTransport::new().with_pane_presence("%9999", false);
+    let err = validate_active_leader_pane_env(&transport).expect_err("absent pane must fail");
+    let msg = err.to_string();
+    assert!(msg.contains("TEAM_AGENT_LEADER_PANE_ID"), "got: {msg}");
+    assert!(msg.contains("absent"), "got: {msg}");
+    assert!(msg.contains("%9999"), "got: {msg}");
+}
+
+#[test]
+#[serial_test::serial(env)]
+fn leader_pane_env_dead_pane_fails_fast() {
+    let _leader_pane = EnvVarGuard::set("TEAM_AGENT_LEADER_PANE_ID", "%404");
+    let transport = crate::transport::test_support::OfflineTransport::new()
+        .with_liveness("%404", PaneLiveness::Dead);
+    let err = validate_active_leader_pane_env(&transport).expect_err("dead pane must fail");
+    let msg = err.to_string();
+    assert!(msg.contains("TEAM_AGENT_LEADER_PANE_ID"), "got: {msg}");
+    assert!(msg.contains("dead"), "got: {msg}");
+    assert!(msg.contains("%404"), "got: {msg}");
+}
+
+#[test]
+#[serial_test::serial(env)]
+fn leader_pane_env_unset_passes_without_probe() {
+    let _leader_pane = EnvVarGuard::remove("TEAM_AGENT_LEADER_PANE_ID");
+    let transport = crate::transport::test_support::OfflineTransport::new();
+    validate_active_leader_pane_env(&transport).expect("unset env must pass");
+    assert!(
+        transport.calls().is_empty(),
+        "unset env must not probe transport: {:?}",
+        transport.calls()
+    );
+}
+
+#[test]
+#[serial_test::serial(env)]
+fn leader_pane_env_unknown_when_unprovable_does_not_fail_fast() {
+    let _leader_pane = EnvVarGuard::set("TEAM_AGENT_LEADER_PANE_ID", "%8888");
+    let transport = crate::transport::test_support::OfflineTransport::new()
+        .with_default_liveness(PaneLiveness::Unknown);
+    validate_active_leader_pane_env(&transport).expect("unknown/unprovable pane must not fail");
+}
+
+#[test]
+#[serial_test::serial(env)]
+fn leader_pane_env_non_numeric_pane_id_is_unknown_not_absent() {
+    let _leader_pane = EnvVarGuard::set("TEAM_AGENT_LEADER_PANE_ID", "abc-notapane");
+    let transport = crate::transport::test_support::OfflineTransport::new()
+        .with_pane_presence("abc-notapane", false)
+        .with_liveness("abc-notapane", PaneLiveness::Dead);
+    validate_active_leader_pane_env(&transport)
+        .expect("non `%<digits>` env values are unprovable, not absent");
+    assert!(
+        transport.calls().is_empty(),
+        "invalid pane id format must not hit tmux probe: {:?}",
+        transport.calls()
+    );
+}
+
+#[test]
+#[serial_test::serial(env)]
+fn leader_pane_env_invalid_format_writes_warning_event() {
+    let ws = temp_ws();
+    let _leader_pane = EnvVarGuard::set("TEAM_AGENT_LEADER_PANE_ID", "abc-notapane");
+    let transport = crate::transport::test_support::OfflineTransport::new()
+        .with_pane_presence("abc-notapane", false);
+
+    validate_active_leader_pane_env_with_workspace(&transport, Some(&ws))
+        .expect("invalid format is warning-only");
+
+    let events = crate::event_log::EventLog::new(&ws).tail(0).expect("events");
+    let event = events
+        .iter()
+        .find(|event| {
+            event.get("event").and_then(serde_json::Value::as_str)
+                == Some("leader_pane_env.validation_warning")
+        })
+        .expect("warning event");
+    assert_eq!(
+        event.get("value").and_then(serde_json::Value::as_str),
+        Some("abc-notapane")
+    );
+    assert_eq!(
+        event.get("warning").and_then(serde_json::Value::as_str),
+        Some("invalid pane id format, skipping validation")
+    );
+}
+
+#[test]
+#[serial_test::serial(env)]
+fn leader_pane_env_invalid_format_writes_warning_to_all_candidate_workspaces() {
+    let cli_ws = temp_ws();
+    let team_ws = temp_ws();
+    let _leader_pane = EnvVarGuard::set("TEAM_AGENT_LEADER_PANE_ID", "abc-notapane");
+    let transport = crate::transport::test_support::OfflineTransport::new();
+
+    validate_active_leader_pane_env_with_workspaces(&transport, &[&cli_ws, &team_ws])
+        .expect("invalid format is warning-only");
+
+    for ws in [&cli_ws, &team_ws] {
+        let events = crate::event_log::EventLog::new(ws).tail(0).expect("events");
+        assert!(
+            events.iter().any(|event| {
+                event.get("event").and_then(serde_json::Value::as_str)
+                    == Some("leader_pane_env.validation_warning")
+                    && event.get("value").and_then(serde_json::Value::as_str)
+                        == Some("abc-notapane")
+            }),
+            "warning event missing in {}: {events:?}",
+            ws.display()
+        );
+    }
+}
+
+#[test]
+fn leader_pane_env_cross_socket_live_wins() {
+    let pane = crate::transport::PaneId::new("%7");
+    let absent =
+        crate::transport::test_support::OfflineTransport::new().with_pane_presence("%7", false);
+    let live =
+        crate::transport::test_support::OfflineTransport::new().with_pane_presence("%7", true);
+
+    let state = active_leader_pane_state_across_transports(
+        [&absent as &dyn crate::transport::Transport, &live],
+        &pane,
+    );
+
+    assert_eq!(state, LeaderPaneEnvState::Live);
+}
+
+#[test]
+fn leader_pane_env_cross_socket_dead_rejects_without_live() {
+    let pane = crate::transport::PaneId::new("%404");
+    let absent = crate::transport::test_support::OfflineTransport::new()
+        .with_pane_presence("%404", false);
+    let dead = crate::transport::test_support::OfflineTransport::new()
+        .with_liveness("%404", PaneLiveness::Dead);
+
+    let state = active_leader_pane_state_across_transports(
+        [&absent as &dyn crate::transport::Transport, &dead],
+        &pane,
+    );
+
+    assert_eq!(state, LeaderPaneEnvState::Dead);
+}
+
+#[test]
+fn leader_pane_env_cross_socket_absent_when_reachable_servers_confirm_missing() {
+    let pane = crate::transport::PaneId::new("%9999");
+    let absent = crate::transport::test_support::OfflineTransport::new()
+        .with_pane_presence("%9999", false);
+    let unknown = crate::transport::test_support::OfflineTransport::new()
+        .with_default_liveness(PaneLiveness::Unknown);
+
+    let state = active_leader_pane_state_across_transports(
+        [&absent as &dyn crate::transport::Transport, &unknown],
+        &pane,
+    );
+
+    assert_eq!(state, LeaderPaneEnvState::Absent);
+}
+
+#[test]
+fn leader_pane_env_cross_socket_all_probe_errors_stays_unknown() {
+    let pane = crate::transport::PaneId::new("%maybe");
+    let unknown_a = crate::transport::test_support::OfflineTransport::new()
+        .with_default_liveness(PaneLiveness::Unknown);
+    let unknown_b = crate::transport::test_support::OfflineTransport::new()
+        .with_default_liveness(PaneLiveness::Unknown);
+
+    let state = active_leader_pane_state_across_transports(
+        [&unknown_a as &dyn crate::transport::Transport, &unknown_b],
+        &pane,
+    );
+
+    assert_eq!(state, LeaderPaneEnvState::Unknown);
+}
+
 struct EnvVarGuard {
     key: &'static str,
     previous: Option<String>,
@@ -764,6 +991,14 @@ impl EnvVarGuard {
         }
         Self { key, previous }
     }
+
+    fn remove(key: &'static str) -> Self {
+        let previous = std::env::var(key).ok();
+        unsafe {
+            std::env::remove_var(key);
+        }
+        Self { key, previous }
+    }
 }
 
 impl Drop for EnvVarGuard {