@team-agent/installer 0.2.11 → 0.3.0

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

@@ -0,0 +1,208 @@
+use super::*;
+use super::common::*;
+
+/// bug-085 四象限 `start_mode` 决策(`start.py:179-188` + `_resume_rollout_missing` `start.py:66-69`),
+/// **从 start_agent 的整条 lock+spawn 路径里分离出的纯函数**(gate gap:porter 需要单元级 RED
+/// for `FreshAfterMissingRollout`,而 start_agent 全路径不可单测)。语义:
+/// - `_resume_rollout_missing` 仅 codex 且有 session_id 时可能 true:`!rollout_path || !exists`。
+/// - 初始 `start_mode = if session_id { Resumed } else { Fresh }`(`start.py:179`)。
+/// - **仅当** `missing && allow_fresh` 才升级为 `FreshAfterMissingRollout` 并清空 session_id
+///   (`start.py:180-190`)。`missing && !allow_fresh` 仍 `Resumed`(随后真实 resume 会 fail)。
+/// - 非 codex:rollout 永不"缺失",直接看 session_id。
+pub fn decide_start_mode(
+    provider: &str,
+    session_id: Option<&SessionId>,
+    rollout_path: Option<&RolloutPath>,
+    rollout_exists: bool,
+    allow_fresh: bool,
+) -> StartMode {
+    match session_id {
+        None => StartMode::Fresh,
+        Some(_) => {
+            let missing_codex_rollout =
+                provider == "codex" && (rollout_path.is_none() || !rollout_exists);
+            if missing_codex_rollout && allow_fresh {
+                StartMode::FreshAfterMissingRollout
+            } else {
+                StartMode::Resumed
+            }
+        }
+    }
+}
+
+/// `first_send_at` 严格分类(`_classify_first_send_at`,`orchestration.py:399`)。
+/// **绝不靠 truthiness**:`""`/`0`/`False`/`"null"`/非 ISO → `Corrupt`。
+pub fn classify_first_send_at(raw: &serde_json::Value) -> FirstSendAtState {
+    match raw {
+        serde_json::Value::Null => FirstSendAtState::Absent,
+        serde_json::Value::String(s) => {
+            if is_python_fromisoformat_like(s) {
+                FirstSendAtState::Valid
+            } else {
+                FirstSendAtState::Corrupt
+            }
+        }
+        serde_json::Value::Bool(_)
+        | serde_json::Value::Number(_)
+        | serde_json::Value::Array(_)
+        | serde_json::Value::Object(_) => FirstSendAtState::Corrupt,
+    }
+}
+
+fn is_python_fromisoformat_like(raw: &str) -> bool {
+    if raw.is_empty() {
+        return false;
+    }
+    if chrono::DateTime::parse_from_rfc3339(raw).is_ok()
+        || chrono::DateTime::parse_from_str(raw, "%Y-%m-%dT%H:%M:%S%z").is_ok()
+        || chrono::DateTime::parse_from_str(raw, "%Y-%m-%dT%H:%M:%S%.f%z").is_ok()
+    {
+        return true;
+    }
+
+    let normalized = normalize_iso_separator(raw);
+    for pattern in [
+        "%Y-%m-%d",
+        "%Y%m%d",
+        "%Y-%m-%dT%H:%M",
+        "%Y-%m-%dT%H:%M:%S",
+        "%Y-%m-%dT%H:%M:%S%.f",
+        "%Y-%m-%dT%H:%M%z",
+        "%Y-%m-%dT%H:%M:%S%z",
+        "%Y-%m-%dT%H:%M:%S%.f%z",
+        "%Y%m%dT%H%M%S",
+    ] {
+        if chrono::NaiveDate::parse_from_str(&normalized, pattern).is_ok()
+            || chrono::NaiveDateTime::parse_from_str(&normalized, pattern).is_ok()
+            || chrono::DateTime::parse_from_str(&normalized, pattern).is_ok()
+        {
+            return true;
+        }
+    }
+    false
+}
+
+fn normalize_iso_separator(raw: &str) -> String {
+    let mut out = String::with_capacity(raw.len());
+    for (idx, ch) in raw.chars().enumerate() {
+        if idx == 10 && matches!(ch, ' ' | 't' | '_') {
+            out.push('T');
+        } else {
+            out.push(ch);
+        }
+    }
+    out
+}
+
+/// Python `type(value).__name__` 映射(`orchestration.py:446`):corrupt first_send_at
+/// 条目的 `raw_first_send_at_type` golden。锁死跨语言一致:`null→"NoneType"`、`""/"x"→"str"`、
+/// `0/123→"int"`、`false→"bool"`、`[]→"list"`、`{}→"dict"`、float→`"float"`。
+/// **绝不**用 Rust 的 `"null"/"string"/"number"/"boolean"/"array"/"object"`(serde 名)—— 必须是
+/// Python 名,否则 audit payload 与真相源不一致。
+pub fn python_type_name(value: &serde_json::Value) -> &'static str {
+    match value {
+        serde_json::Value::Null => "NoneType",
+        serde_json::Value::String(_) => "str",
+        serde_json::Value::Bool(_) => "bool",
+        serde_json::Value::Array(_) => "list",
+        serde_json::Value::Object(_) => "dict",
+        serde_json::Value::Number(n) => {
+            if n.is_i64() || n.is_u64() {
+                "int"
+            } else {
+                "float"
+            }
+        }
+    }
+}
+
+/// Route B 全量验证(纯计算,**无破坏性副作用**;`_emit_resume_decisions` +
+/// `_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`);
+/// (3) `Refuse` 的 worker(reason=`no_persisted_session_id`(无 session)|`session_unresumable`)
+///     进 `unresumable`。
+/// restart() **先**调它再 teardown;corrupt 非空 → `RefusedInvalidFirstSendAt`,unresumable
+/// 非空且 !allow_fresh → `RefusedResumeAtomicity`。**refuse 早于一切 teardown,nothing created**。
+pub fn classify_restart_plan(
+    state: &serde_json::Value,
+    allow_fresh: bool,
+) -> Result<RestartPlan, LifecycleError> {
+    let mut decisions = Vec::new();
+    let mut corrupt_entries = Vec::new();
+    let mut unresumable = Vec::new();
+
+    let Some(agents) = state.get("agents").and_then(|v| v.as_object()) else {
+        return Ok(RestartPlan {
+            decisions,
+            corrupt_entries,
+            unresumable,
+        });
+    };
+
+    for (worker_id, agent) in agents {
+        if agent
+            .get("status")
+            .and_then(|v| v.as_str())
+            .map(|s| s == "paused")
+            .unwrap_or(false)
+        {
+            continue;
+        }
+
+        let first_send_at_raw = agent
+            .get("first_send_at")
+            .cloned()
+            .unwrap_or(serde_json::Value::Null);
+        let first_send_at_state = classify_first_send_at(&first_send_at_raw);
+        if matches!(first_send_at_state, FirstSendAtState::Corrupt) {
+            corrupt_entries.push(CorruptFirstSendAt {
+                worker_id: AgentId::new(worker_id.clone()),
+                raw_first_send_at_type: python_type_name(&first_send_at_raw).to_string(),
+                raw_first_send_at: first_send_at_raw,
+            });
+            continue;
+        }
+
+        let session_id = agent
+            .get("session_id")
+            .and_then(|v| v.as_str())
+            .filter(|s| !s.is_empty())
+            .map(SessionId::new);
+        let interacted = matches!(first_send_at_state, FirstSendAtState::Valid);
+        let decision = if session_id.is_some() {
+            ResumeDecision::Resume
+        } else if !interacted || allow_fresh {
+            ResumeDecision::FreshStart
+        } else {
+            ResumeDecision::Refuse
+        };
+        let agent_id = AgentId::new(worker_id.clone());
+        if matches!(decision, ResumeDecision::Refuse) {
+            unresumable.push(UnresumableWorker {
+                agent_id: agent_id.clone(),
+                reason: "no_persisted_session_id".to_string(),
+                session_id: session_id.clone(),
+                first_send_at: first_send_at_raw.as_str().map(|s| s.to_string()),
+            });
+        }
+        decisions.push(RestartedAgent {
+            agent_id,
+            restart_mode: match decision {
+                ResumeDecision::Resume => StartMode::Resumed,
+                ResumeDecision::FreshStart => StartMode::Fresh,
+                ResumeDecision::Refuse => StartMode::Noop,
+            },
+            decision,
+            session_id,
+        });
+    }
+
+    Ok(RestartPlan {
+        decisions,
+        corrupt_entries,
+        unresumable,
+    })
+}

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

@@ -0,0 +1,242 @@
+use super::*;
+
+pub(crate) fn write_team_state(
+    workspace: &Path,
+    spec: &YamlValue,
+    state: &serde_json::Value,
+) -> Result<std::path::PathBuf, LifecycleError> {
+    let rel = spec
+        .get("context")
+        .and_then(|v| v.get("state_file"))
+        .and_then(YamlValue::as_str)
+        .unwrap_or("team_state.md");
+    let path = workspace.join(rel);
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)
+            .map_err(|e| LifecycleError::StatePersist(format!("write team_state: {e}")))?;
+    }
+    // golden state.py:625-686 — byte-faithful layout (probed). Blank line after the title and after each
+    // '##' header; '## Team' / '## Latest Results' sections; Task Graph as
+    // `- {id} [{status}], assignee={assignee|unassigned}, deps={deps|none}: {title}`.
+    let mut lines: Vec<String> = Vec::new();
+    lines.push("# Team State".to_string());
+    lines.push(String::new());
+    lines.push(format!("Updated: {}", team_state_now()));
+    lines.push(String::new());
+    lines.push("## Objective".to_string());
+    lines.push(String::new());
+    lines.push(
+        spec.get("team")
+            .and_then(|v| v.get("objective"))
+            .and_then(YamlValue::as_str)
+            .unwrap_or("")
+            .to_string(),
+    );
+    lines.push(String::new());
+    lines.push("## Team".to_string());
+    lines.push(String::new());
+    lines.push(format!(
+        "- Name: {}",
+        spec.get("team")
+            .and_then(|v| v.get("name"))
+            .and_then(YamlValue::as_str)
+            .unwrap_or("None")
+    ));
+    lines.push(format!(
+        "- Runtime session: {}",
+        state
+            .get("session_name")
+            .and_then(|v| v.as_str())
+            .unwrap_or("None")
+    ));
+    // leader_receiver (golden state.py:642-651): direct_tmux line, else inbox-fallback + log lines.
+    if let Some(receiver) = state
+        .get("leader_receiver")
+        .and_then(|v| v.as_object())
+        .filter(|m| !m.is_empty())
+    {
+        let g = |k: &str| receiver.get(k).and_then(|v| v.as_str()).unwrap_or("None");
+        if receiver.get("mode").and_then(|v| v.as_str()) == Some("direct_tmux") {
+            lines.push(format!(
+                "- Leader receiver: direct tmux {} ({}, {})",
+                g("pane_id"),
+                g("provider"),
+                g("status")
+            ));
+        } else {
+            lines.push(format!(
+                "- Leader inbox fallback: {}:{} ({})",
+                g("session"),
+                g("window"),
+                g("status")
+            ));
+            lines.push(format!("- Leader inbox log: {}", g("path")));
+        }
+    }
+    lines.push(String::new());
+    lines.push("## Agents".to_string());
+    lines.push(String::new());
+    if let Some(agents) = spec.get("agents").and_then(YamlValue::as_list) {
+        for agent in agents {
+            let Some(id) = agent.get("id").and_then(YamlValue::as_str) else {
+                continue;
+            };
+            let role = agent
+                .get("role")
+                .and_then(YamlValue::as_str)
+                .unwrap_or(id);
+            let provider = agent
+                .get("provider")
+                .and_then(YamlValue::as_str)
+                .unwrap_or("codex");
+            let status = state
+                .get("agents")
+                .and_then(|v| v.get(id))
+                .and_then(|v| v.get("status"))
+                .and_then(|v| v.as_str())
+                .unwrap_or("unknown");
+            lines.push(format!("- {id}: {role} on {provider} ({status})"));
+        }
+    }
+    lines.push(String::new());
+    lines.push("## Task Graph".to_string());
+    lines.push(String::new());
+    // golden: runtime.get("tasks", spec.get("tasks", [])) — state tasks else spec tasks.
+    let tasks = team_state_tasks(spec, state);
+    for task in &tasks {
+        let id = task_field_str(task, "id");
+        let title = task_field_str(task, "title");
+        let status = {
+            let s = task_field_str(task, "status");
+            if s.is_empty() { "pending".to_string() } else { s }
+        };
+        let assignee = {
+            let a = task_field_str(task, "assignee");
+            if a.is_empty() { "unassigned".to_string() } else { a }
+        };
+        let deps = {
+            let d = task_field_list(task, "deps");
+            if d.is_empty() { "none".to_string() } else { d.join(", ") }
+        };
+        lines.push(format!("- {id} [{status}], assignee={assignee}, deps={deps}: {title}"));
+        let summary = task_field_str(task, "last_result_summary");
+        if !summary.is_empty() {
+            lines.push(format!("  Summary: {summary}"));
+        }
+        for art in task_artifact_refs(task) {
+            lines.push(art);
+        }
+    }
+    lines.push(String::new());
+    lines.push("## Latest Results".to_string());
+    lines.push(String::new());
+    // remove/stop/reset pass no results -> header + blank only (golden).
+    lines.push(String::new());
+    lines.push("## Blockers".to_string());
+    lines.push(String::new());
+    let blockers: Vec<&TeamStateTask> = tasks
+        .iter()
+        .filter(|t| matches!(task_field_str(t, "status").as_str(), "blocked" | "failed" | "needs_retry"))
+        .collect();
+    if blockers.is_empty() {
+        lines.push("- None".to_string());
+    } else {
+        for task in blockers {
+            let id = task_field_str(task, "id");
+            let summary = {
+                let s = task_field_str(task, "last_result_summary");
+                if s.is_empty() { task_field_str(task, "title") } else { s }
+            };
+            lines.push(format!("- {id}: {summary}"));
+        }
+    }
+    lines.push(String::new());
+    lines.push("## Next Step".to_string());
+    lines.push(String::new());
+    lines.push("- Continue routing ready tasks and collect result envelopes.".to_string());
+    let text = format!("{}\n", lines.join("\n"));
+    std::fs::write(&path, text)
+        .map_err(|e| LifecycleError::StatePersist(format!("write team_state: {e}")))?;
+    Ok(path)
+}
+
+/// A task row sourced from either runtime state (serde_json) or the spec (YAML), so write_team_state
+/// can mirror golden's `runtime.get("tasks", spec.get("tasks", []))` fallback.
+enum TeamStateTask {
+    Json(serde_json::Value),
+    Yaml(YamlValue),
+}
+
+/// golden `datetime.now(timezone.utc).isoformat()` analog (microseconds + `+00:00`).
+fn team_state_now() -> String {
+    chrono::Utc::now().format("%Y-%m-%dT%H:%M:%S%.6f+00:00").to_string()
+}
+
+fn team_state_tasks(spec: &YamlValue, state: &serde_json::Value) -> Vec<TeamStateTask> {
+    if let Some(tasks) = state.get("tasks").and_then(|v| v.as_array()) {
+        return tasks.iter().cloned().map(TeamStateTask::Json).collect();
+    }
+    if let Some(tasks) = spec.get("tasks").and_then(YamlValue::as_list) {
+        return tasks.iter().cloned().map(TeamStateTask::Yaml).collect();
+    }
+    Vec::new()
+}
+
+fn task_field_str(task: &TeamStateTask, key: &str) -> String {
+    match task {
+        TeamStateTask::Json(v) => v.get(key).and_then(|v| v.as_str()).unwrap_or("").to_string(),
+        TeamStateTask::Yaml(v) => v.get(key).and_then(YamlValue::as_str).unwrap_or("").to_string(),
+    }
+}
+
+fn task_field_list(task: &TeamStateTask, key: &str) -> Vec<String> {
+    match task {
+        TeamStateTask::Json(v) => v
+            .get(key)
+            .and_then(|v| v.as_array())
+            .map(|items| items.iter().filter_map(|i| i.as_str().map(str::to_string)).collect())
+            .unwrap_or_default(),
+        TeamStateTask::Yaml(v) => v
+            .get(key)
+            .and_then(YamlValue::as_list)
+            .map(|items| items.iter().filter_map(|i| i.as_str().map(str::to_string)).collect())
+            .unwrap_or_default(),
+    }
+}
+
+fn task_artifact_refs(task: &TeamStateTask) -> Vec<String> {
+    match task {
+        TeamStateTask::Json(v) => v
+            .get("artifact_refs")
+            .and_then(|v| v.as_array())
+            .map(|refs| {
+                refs.iter()
+                    .map(|r| match r.as_object() {
+                        Some(m) => format!(
+                            "  Artifact: {} - {}",
+                            m.get("path").and_then(|v| v.as_str()).unwrap_or("None"),
+                            m.get("description").and_then(|v| v.as_str()).unwrap_or("")
+                        ),
+                        None => format!("  Artifact: INVALID artifact ref {r}"),
+                    })
+                    .collect()
+            })
+            .unwrap_or_default(),
+        TeamStateTask::Yaml(v) => v
+            .get("artifact_refs")
+            .and_then(YamlValue::as_list)
+            .map(|refs| {
+                refs.iter()
+                    .map(|r| match r.as_map() {
+                        Some(_) => format!(
+                            "  Artifact: {} - {}",
+                            r.get("path").and_then(YamlValue::as_str).unwrap_or("None"),
+                            r.get("description").and_then(YamlValue::as_str).unwrap_or("")
+                        ),
+                        None => format!("  Artifact: INVALID artifact ref {:?}", r),
+                    })
+                    .collect()
+            })
+            .unwrap_or_default(),
+    }
+}

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

@@ -0,0 +1,76 @@
+//! lifecycle::restart —— 单 worker 起/停/重置/删 + 整队 Route B 重建 + plan halt/status。
+
+use std::path::Path;
+use std::collections::BTreeMap;
+
+use crate::model::enums::{AuthMode, Provider};
+use crate::model::ids::AgentId;
+use crate::model::yaml::{self, Value as YamlValue};
+use crate::provider::{RolloutPath, SessionId};
+use crate::transport::{SessionName, Target, WindowName};
+
+use super::*;
+
+// ── lifecycle::agent —— 单 worker 起/停/重置/增/fork/删(全部 owner-gate 优先 + 回滚)─
+
+struct LifecyclePaths {
+    run_workspace: std::path::PathBuf,
+    spec_workspace: std::path::PathBuf,
+}
+
+struct LifecyclePathRefs<'a> {
+    run_workspace: &'a Path,
+    spec_workspace: &'a Path,
+}
+
+mod agent;
+mod common;
+mod orchestrator;
+mod rebuild;
+mod remove;
+mod selection;
+mod team_state;
+
+pub use agent::{reset_agent, reset_agent_with_transport, start_agent, start_agent_with_transport, stop_agent, stop_agent_with_transport};
+pub(crate) use agent::start_agent_at_paths;
+pub use orchestrator::{halt_plan, plan_status};
+pub use rebuild::{restart, restart_candidates, restart_with_transport, select_restart_state};
+pub use remove::{remove_agent, remove_agent_with_transport};
+pub use selection::{classify_first_send_at, classify_restart_plan, decide_start_mode, python_type_name};
+pub(crate) use team_state::write_team_state;
+
+pub(crate) fn lifecycle_run_workspace(workspace: &Path) -> Result<std::path::PathBuf, LifecycleError> {
+    crate::model::paths::canonical_run_workspace(workspace)
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))
+}
+
+fn lifecycle_paths(workspace: &Path, team: Option<&str>) -> Result<LifecyclePaths, LifecycleError> {
+    let selected = crate::state::selector::resolve_active_team(
+        workspace,
+        team,
+        crate::state::selector::SelectorMode::RequireSpec,
+    )
+    .map_err(|e| LifecycleError::TeamSelect(e.to_string()))?;
+    let spec_workspace = selected_state_spec_workspace(&selected.state)
+        .or(selected.spec_workspace)
+        .ok_or_else(|| LifecycleError::TeamSelect("active team spec workspace not found".to_string()))?;
+    Ok(LifecyclePaths {
+        run_workspace: selected.run_workspace,
+        spec_workspace,
+    })
+}
+
+fn selected_state_spec_workspace(state: &serde_json::Value) -> Option<std::path::PathBuf> {
+    state
+        .get("spec_path")
+        .and_then(serde_json::Value::as_str)
+        .filter(|s| !s.is_empty())
+        .and_then(|s| Path::new(s).parent().map(Path::to_path_buf))
+        .or_else(|| {
+            state
+                .get("team_dir")
+                .and_then(serde_json::Value::as_str)
+                .filter(|s| !s.is_empty())
+                .map(std::path::PathBuf::from)
+        })
+}