@team-agent/installer 0.3.6 → 0.3.7

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

@@ -400,15 +400,20 @@ latest result: none";
         let payload = err.to_payload(Path::new("/tmp/cli-error-123.log"), "quick-start");
         assert_eq!(payload.reason.as_deref(), Some("tmux_session_name_conflict"));
         assert_eq!(payload.session_name.as_deref(), Some("my-team"));
+        // E8 (N38): quick-start 撞已有 runtime 引导到 restart(resume),明确 --fresh 会丢上下文。
         assert_eq!(
             payload.action,
-            "tmux session `my-team` already exists. It may be an active team. \
-Do not terminate existing tmux sessions from quick-start; \
-change `name:` in TEAM.md and run quick-start again."
+            "tmux session `my-team` already exists. It may be your own existing team. \
+To resume it use `team-agent restart` (NOT --fresh, which discards context). \
+Only if you want a separate team, change `name:` in TEAM.md and run quick-start again. \
+Never terminate existing tmux sessions from quick-start."
         );
         assert_eq!(
             payload.next_actions,
-            Some(vec!["Change `name:` in TEAM.md and run `team-agent quick-start` again.".to_string()])
+            Some(vec![
+                "If this is your existing team, resume it with `team-agent restart`.".to_string(),
+                "If you want a separate team, change `name:` in TEAM.md and run `team-agent quick-start` again.".to_string(),
+            ])
         );
     }
 

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

@@ -209,10 +209,18 @@ fn current_uid() -> Option<String> {
             json: true,
         };
         let _ = cmd_quick_start(&args); // real quick_start compiles the spec before any coordinator/launch step
+        // E5: spec compiled to .team/runtime/<team_key>/, NOT the user team dir.
+        let team_key = team.file_name().unwrap().to_string_lossy().to_string();
+        let workspace = crate::model::paths::team_workspace(&team).unwrap();
+        let runtime_spec = crate::model::paths::runtime_spec_path(&workspace, &team_key);
         assert!(
-            team.join("team.spec.yaml").exists(),
+            runtime_spec.exists(),
             "cmd_quick_start must delegate to crate::lifecycle::quick_start, which compiles team.spec.yaml \
-             under the team dir; the placeholder never writes it"
+             under .team/runtime/<team_key>/; the placeholder never writes it"
+        );
+        assert!(
+            !team.join("team.spec.yaml").exists(),
+            "E5: quick_start must NOT write spec into the user team dir"
         );
     }
 

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

@@ -86,10 +86,11 @@ impl CliError {
             payload.session_name = Some(session.clone());
             if command == "quick-start" {
                 payload.action = format!(
-                    "tmux session `{session}` already exists. It may be an active team. Do not terminate existing tmux sessions from quick-start; change `name:` in TEAM.md and run quick-start again."
+                    "tmux session `{session}` already exists. It may be your own existing team. To resume it use `team-agent restart` (NOT --fresh, which discards context). Only if you want a separate team, change `name:` in TEAM.md and run quick-start again. Never terminate existing tmux sessions from quick-start."
                 );
                 payload.next_actions = Some(vec![
-                    "Change `name:` in TEAM.md and run `team-agent quick-start` again.".to_string(),
+                    "If this is your existing team, resume it with `team-agent restart`.".to_string(),
+                    "If you want a separate team, change `name:` in TEAM.md and run `team-agent quick-start` again.".to_string(),
                 ]);
             } else {
                 payload.action = format!(

package/crates/team-agent/src/compiler.rs

@@ -141,56 +141,9 @@ pub fn compile_team(team_dir: &Path) -> Result<Value, ModelError> {
     let mut agents = Vec::new();
     let mut agent_ids = Vec::new();
     for path in role_paths {
-        let (meta, body) = read_front_matter(&path)?;
-        let id = required_string(&meta, &path, "name")?;
-        let role = required_string(&meta, &path, "role")?;
-        let provider = required_string(&meta, &path, "provider")?;
-        let model = resolve_model(&meta, &team_meta, &provider);
-        let auth_mode = string_field(&meta, "auth_mode")
-            .or_else(|| string_field(&team_meta, "default_auth_mode"))
-            .unwrap_or_else(|| "subscription".to_string());
-        if auth_mode != "subscription" && meta.get("profile").is_none() {
-            return Err(ModelError::Validation(format!(
-                "{}: profile is required when auth_mode is '{auth_mode}'",
-                path.display(),
-            )));
-        }
-        let tools = required_tools(&meta, &path)?;
-        let prompt_inline = non_empty_trimmed(&body).unwrap_or_else(|| role.clone());
-        agent_ids.push(id.clone());
-        let mut agent_items = vec![
-            ("id", Value::Str(id.clone())),
-            ("role", Value::Str(role.clone())),
-            ("provider", Value::Str(provider)),
-            ("model", model),
-            ("auth_mode", Value::Str(auth_mode)),
-            ("working_directory", Value::Str(workspace_s.clone())),
-            (
-                "system_prompt",
-                map(vec![
-                    ("inline", Value::Str(prompt_inline)),
-                    ("file", Value::Null),
-                ]),
-            ),
-            ("tools", list_str(tools)),
-            ("permission_mode", Value::Str("restricted".to_string())),
-            ("preferred_for", list_str(vec![id, role])),
-            ("avoid_for", Value::List(Vec::new())),
-            (
-                "output_contract",
-                map(vec![
-                    ("format", Value::Str("result_envelope_v1".to_string())),
-                    (
-                        "required_fields",
-                        list_str(vec!["task_id", "status", "summary", "artifacts"]),
-                    ),
-                ]),
-            ),
-        ];
-        if let Some(profile) = string_field(&meta, "profile") {
-            agent_items.push(("profile", Value::Str(profile)));
-        }
-        agents.push(map(agent_items));
+        let compiled = compile_role_agent(&path, &team_meta, &workspace_s)?;
+        agent_ids.push(compiled.id);
+        agents.push(compiled.agent);
     }
 
     let default_assignee = agent_ids.first().cloned().unwrap_or_default();
@@ -327,6 +280,76 @@ pub fn compile_team(team_dir: &Path) -> Result<Value, ModelError> {
     Ok(spec)
 }
 
+/// 单个角色文档 → 编译后的 agent spec 条目(从 [`compile_team`] 的 per-role 循环抽出)。
+/// E5 Bug1:add-agent 复用它**就地读** role 文件编译,不再 copy 进平台目录。
+pub struct CompiledRole {
+    pub id: String,
+    pub role: String,
+    pub agent: Value,
+}
+
+/// 把一份 role 文档编译成 agent spec 条目。`team_meta` 供 model/auth_mode 继承;
+/// `workspace_s` 是 working_directory。**纯读 `role_path`,无任何文件落地。**
+pub fn compile_role_agent(
+    role_path: &Path,
+    team_meta: &Value,
+    workspace_s: &str,
+) -> Result<CompiledRole, ModelError> {
+    let (meta, body) = read_front_matter(role_path)?;
+    let id = required_string(&meta, role_path, "name")?;
+    let role = required_string(&meta, role_path, "role")?;
+    let provider = required_string(&meta, role_path, "provider")?;
+    let model = resolve_model(&meta, team_meta, &provider);
+    let auth_mode = string_field(&meta, "auth_mode")
+        .or_else(|| string_field(team_meta, "default_auth_mode"))
+        .unwrap_or_else(|| "subscription".to_string());
+    if auth_mode != "subscription" && meta.get("profile").is_none() {
+        return Err(ModelError::Validation(format!(
+            "{}: profile is required when auth_mode is '{auth_mode}'",
+            role_path.display(),
+        )));
+    }
+    let tools = required_tools(&meta, role_path)?;
+    let prompt_inline = non_empty_trimmed(&body).unwrap_or_else(|| role.clone());
+    let mut agent_items = vec![
+        ("id", Value::Str(id.clone())),
+        ("role", Value::Str(role.clone())),
+        ("provider", Value::Str(provider)),
+        ("model", model),
+        ("auth_mode", Value::Str(auth_mode)),
+        ("working_directory", Value::Str(workspace_s.to_string())),
+        (
+            "system_prompt",
+            map(vec![
+                ("inline", Value::Str(prompt_inline)),
+                ("file", Value::Null),
+            ]),
+        ),
+        ("tools", list_str(tools)),
+        ("permission_mode", Value::Str("restricted".to_string())),
+        ("preferred_for", list_str(vec![id.clone(), role.clone()])),
+        ("avoid_for", Value::List(Vec::new())),
+        (
+            "output_contract",
+            map(vec![
+                ("format", Value::Str("result_envelope_v1".to_string())),
+                (
+                    "required_fields",
+                    list_str(vec!["task_id", "status", "summary", "artifacts"]),
+                ),
+            ]),
+        ),
+    ];
+    if let Some(profile) = string_field(&meta, "profile") {
+        agent_items.push(("profile", Value::Str(profile)));
+    }
+    Ok(CompiledRole {
+        id,
+        role,
+        agent: map(agent_items),
+    })
+}
+
 fn map(items: Vec<(&str, Value)>) -> Value {
     Value::Map(items.into_iter().map(|(k, v)| (k.to_string(), v)).collect())
 }

package/crates/team-agent/src/coordinator/tick.rs

@@ -228,8 +228,18 @@ impl Coordinator {
             );
         }
 
+        // B-4 / 036b N36 三路可用 — 监测步(runtime_prompts / sync_health /
+        // detect_abnormal_exits)失败必须降级+continue,**不能**用 `?` 中断 tick,
+        // 否则 deliver_pending(下行投递主干)够不到,消息卡 accepted。
+        // bug-084 哲学 + A-6 同族:每步独立 try,失败写 `coordinator.tick.<step>_failed`
+        // 事件后继续走下一步;tick 本身仍返 Ok。
         self.record_step("runtime_prompts");
-        self.handle_runtime_approval_prompts(&mut state, &event_log)?;
+        if let Err(error) = self.handle_runtime_approval_prompts(&mut state, &event_log) {
+            let _ = event_log.write(
+                "coordinator.tick.runtime_prompts_failed",
+                serde_json::json!({"error": error.to_string()}),
+            );
+        }
 
         self.record_step("sync_health");
         // P5 (C-P5-1, N3): ONE pane snapshot per tick, shared by sync_health and the
@@ -237,32 +247,71 @@ impl Coordinator {
         // this tick; every tick re-reads).
         let pane_snapshot = self.transport.list_targets().unwrap_or_default();
         let captures_by_agent =
-            self.sync_agent_health(&mut state, &store, &event_log, &pane_snapshot)?;
+            match self.sync_agent_health(&mut state, &store, &event_log, &pane_snapshot) {
+                Ok(captures) => captures,
+                Err(error) => {
+                    let _ = event_log.write(
+                        "coordinator.tick.sync_health_failed",
+                        serde_json::json!({"error": error.to_string()}),
+                    );
+                    BTreeMap::new()
+                }
+            };
         // C-3-4 cr verdict — copilot 一期 classify→None(Unknown);为防 silent,
         // tick 每次发现 copilot agent(从 state.agents 直接扫,不依赖 captures —
         // 离线/未起 tmux 场景仍能写)就发 `provider.classify.unsupported` 事件
         // (字面 reason=`phase1_unknown_pending_sample`,含 provider="copilot" + "classify"
         // 串)。二期接 sqlite turns 表后这条删/降级,届时改 reason 区分。
-        if let Some(agents) = state.get("agents").and_then(Value::as_object) {
-            for (agent_id, agent) in agents {
-                let is_copilot = agent
-                    .get("provider")
-                    .and_then(Value::as_str)
-                    .and_then(parse_provider)
-                    .is_some_and(|p| matches!(p, crate::model::enums::Provider::Copilot));
-                if is_copilot {
-                    let _ = event_log.write(
-                        "provider.classify.unsupported",
-                        serde_json::json!({
-                            "provider": "copilot",
-                            "agent_id": agent_id,
-                            "reason": "phase1_unknown_pending_sample",
-                        }),
-                    );
-                }
+        //
+        // B-4 P4 / 036b 防 dedup-flood:同 (provider, agent_id, reason) 状态跨 tick
+        // 只发一次(check_key 范式,同 abnormal_check_key tick.rs:603 同精神);状态
+        // 变了才再发。check_key 落 state.agents.<id>.classify_unsupported.last_key,
+        // tick-only metadata,不进 #235 owner / receiver 等持久态。
+        let agents_snapshot: Vec<(String, Option<String>)> =
+            if let Some(agents) = state.get("agents").and_then(Value::as_object) {
+                agents
+                    .iter()
+                    .filter_map(|(agent_id, agent)| {
+                        let is_copilot = agent
+                            .get("provider")
+                            .and_then(Value::as_str)
+                            .and_then(parse_provider)
+                            .is_some_and(|p| matches!(p, crate::model::enums::Provider::Copilot));
+                        if !is_copilot {
+                            return None;
+                        }
+                        let last_key = agent
+                            .get("classify_unsupported")
+                            .and_then(|v| v.get("last_key"))
+                            .and_then(Value::as_str)
+                            .map(str::to_string);
+                        Some((agent_id.clone(), last_key))
+                    })
+                    .collect()
+            } else {
+                Vec::new()
+            };
+        for (agent_id, last_key) in agents_snapshot {
+            let check_key = format!("copilot|{agent_id}|phase1_unknown_pending_sample");
+            if last_key.as_deref() == Some(check_key.as_str()) {
+                continue;
             }
+            let _ = event_log.write(
+                "provider.classify.unsupported",
+                serde_json::json!({
+                    "provider": "copilot",
+                    "agent_id": agent_id,
+                    "reason": "phase1_unknown_pending_sample",
+                }),
+            );
+            mark_classify_unsupported(&mut state, &agent_id, &check_key);
+        }
+        if let Err(error) = self.detect_abnormal_exits(&mut state, &event_log, &pane_snapshot) {
+            let _ = event_log.write(
+                "coordinator.tick.detect_abnormal_failed",
+                serde_json::json!({"error": error.to_string()}),
+            );
         }
-        self.detect_abnormal_exits(&mut state, &event_log, &pane_snapshot)?;
 
         self.record_step("deliver_pending");
         let delivered = crate::messaging::deliver_pending_messages(
@@ -389,6 +438,12 @@ impl Coordinator {
         let team = crate::state::projection::team_state_key(&snapshot);
         let team_key = Some(crate::model::ids::TeamKey::new(team.clone()));
         let session_name = state.get("session_name").and_then(Value::as_str).map(str::to_string);
+        // B-4 / 036b N36 三路可用 — sync_health 内 per-agent capture 失败本就降级
+        // (写 coordinator.agent_capture_failed 后 continue),不打断 deliver_pending
+        // 主干。但 contract 要求一条【tick 级】可观测的 step-failed 信号 —
+        // sync_health 失败一旦发生就在末尾 emit `coordinator.tick.sync_health_failed`
+        // (含 "tick" + "_failed" 双串),避免 silent。
+        let mut had_capture_failure = false;
         // P5 (C-P5-2): one list-windows per SESSION per tick — memoized across the
         // agent loop instead of one fork per agent.
         let mut windows_by_session: BTreeMap<String, Result<Vec<crate::transport::WindowName>, String>> =
@@ -409,6 +464,7 @@ impl Coordinator {
                 }) {
                 Ok(windows) => windows.clone(),
                 Err(error) => {
+                    had_capture_failure = true;
                     event_log.write(
                         "coordinator.agent_capture_failed",
                         serde_json::json!({
@@ -429,6 +485,7 @@ impl Coordinator {
             {
                 Ok(captured) => captured,
                 Err(error) => {
+                    had_capture_failure = true;
                     event_log.write(
                         "coordinator.agent_capture_failed",
                         serde_json::json!({
@@ -506,6 +563,15 @@ impl Coordinator {
                 },
             );
         }
+        // B-4 step-level signal:若本 tick 有任一 capture 失败,emit
+        // `coordinator.tick.sync_health_failed`(含 "tick" + "_failed")让 contract
+        // 可观测,deliver_pending 主干不受影响。
+        if had_capture_failure {
+            let _ = event_log.write(
+                "coordinator.tick.sync_health_failed",
+                serde_json::json!({"step": "sync_health", "degraded": true}),
+            );
+        }
         Ok(captures)
     }
 
@@ -1738,6 +1804,28 @@ fn mark_abnormal_suppressed(state: &mut Value, agent_id: &str, key: &str) {
     }
 }
 
+/// B-4 P4 dedup marker — 把 classify.unsupported check_key 写到
+/// state.agents.<id>.classify_unsupported.last_key,只在状态变了才再发事件。
+/// 同 abnormal_check_key (line 603) 同精神,但落 agents 子 obj(per-agent locality,
+/// 不污染 abnormal_exit_watch 命名空间)。
+fn mark_classify_unsupported(state: &mut Value, agent_id: &str, key: &str) {
+    let Some(agents) = state.get_mut("agents").and_then(Value::as_object_mut) else {
+        return;
+    };
+    let Some(agent) = agents.get_mut(agent_id).and_then(Value::as_object_mut) else {
+        return;
+    };
+    let entry = agent
+        .entry("classify_unsupported".to_string())
+        .or_insert_with(|| serde_json::json!({}));
+    if !entry.is_object() {
+        *entry = serde_json::json!({});
+    }
+    if let Some(obj) = entry.as_object_mut() {
+        obj.insert("last_key".to_string(), serde_json::json!(key));
+    }
+}
+
 fn mark_abnormal_checked(state: &mut Value, agent_id: &str, key: &str) {
     if let Some(watch) = coordinator_child_object(state, "abnormal_exit_watch") {
         let entry = watch

package/crates/team-agent/src/db/migration.rs

@@ -84,12 +84,16 @@ pub struct RebuildEvent {
 }
 
 /// `schema_diagnosis` 的只读结论。
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
 pub struct Diagnosis {
     pub ok: bool,
     pub status: String,
     pub user_version: i64,
     pub layout_diffs: Vec<String>,
+    /// Python parity (`schema_migration.py:188/206`): the layered guidance line —
+    /// "missing" carries the initialize_schema first-use hint; drift carries the
+    /// fix-schema command; healthy carries "none".
+    pub recommended_action: String,
 }
 
 fn table_exists(conn: &Connection, table: &str) -> Result<bool, DbError> {
@@ -316,11 +320,18 @@ pub fn ensure_table_layout(
 /// `schema_migration.py:schema_diagnosis`:只读判定(不变更 DB)。
 pub fn schema_diagnosis(db_path: &Path, schema_version: i64) -> Result<Diagnosis, DbError> {
     if !db_path.exists() {
+        // T3-3 cr verdict (A parity lock, 2026-06-10): a missing db is the LEGAL
+        // first-use state — ok:true is layered with the explicit status axis and the
+        // recommended_action guidance (Python schema_migration.py:180-190 verbatim),
+        // never a silent fake-green.
         return Ok(Diagnosis {
             ok: true,
             status: "missing".to_string(),
             user_version: 0,
             layout_diffs: vec![],
+            recommended_action:
+                "No team.db exists yet; initialize_schema will create it on first use."
+                    .to_string(),
         });
     }
     let conn = Connection::open(db_path)?;
@@ -332,6 +343,11 @@ pub fn schema_diagnosis(db_path: &Path, schema_version: i64) -> Result<Diagnosis
         ok,
         status: if ok { "ok".to_string() } else { "schema_repair_available".to_string() },
         user_version: uv,
+        recommended_action: if diff_tables.is_empty() {
+            "none".to_string()
+        } else {
+            "run team-agent doctor --fix-schema --json".to_string()
+        },
         layout_diffs: diff_tables,
     })
 }