@team-agent/installer 0.5.99 → 0.5.101

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

@@ -106,92 +106,6 @@ fn seed_team_spec(ws: &std::path::Path) {
     std::fs::write(ws.join("team.spec.yaml"), spec).unwrap();
 }
 
-// ── ACK-CRACK [P1 byte-shape] — acknowledge_idle must write golden's TTL suppression shape ───────
-// golden runtime.py:680-688: manual-acknowledge persists
-//   coordinator.idle_acknowledged[team] = {acknowledged_at, expires_at, ttl_seconds}
-//   coordinator.suppressed_idle_alerts[team][worker].idle_fallback =
-//     {suppressed_at, suppressed_by:"manual_acknowledge", manual_acknowledge:true, expires_at, ttl_seconds}
-// The clear logic does datetime.fromisoformat(entry["expires_at"]); a MISSING expires_at -> ValueError
-// -> "invalid_suppression_timestamp" -> immediate self-clear (latent crack once detect_idle_fallbacks
-// is ported). So BOTH idle_acknowledged and the entry MUST carry a non-empty expires_at.
-#[test]
-fn acknowledge_idle_writes_golden_ttl_suppression_shape() {
-    let ws = tmp_workspace();
-    crate::state::persist::save_runtime_state(
-        &ws,
-        &serde_json::json!({
-            "active_team_key": "teamX",
-            "agents": {"w1": {"status": "running", "provider": "codex"}}
-        }),
-    )
-    .unwrap();
-    let _ = lifecycle_port::acknowledge_idle(&ws, None).expect("acknowledge_idle ok");
-    let state = crate::state::persist::load_runtime_state(&ws).unwrap();
-    let ack = &state["coordinator"]["idle_acknowledged"]["teamX"];
-    assert!(
-        ack.get("expires_at")
-            .and_then(serde_json::Value::as_str)
-            .is_some_and(|s| !s.is_empty()),
-        "ACK-CRACK: idle_acknowledged[team] must carry a non-empty expires_at (golden); got {ack}"
-    );
-    assert!(
-        ack.get("ttl_seconds").is_some(),
-        "idle_acknowledged[team] must carry ttl_seconds; got {ack}"
-    );
-    let entry = &state["coordinator"]["suppressed_idle_alerts"]["teamX"]["w1"]["idle_fallback"];
-    assert!(
-            entry.get("expires_at").and_then(serde_json::Value::as_str).is_some_and(|s| !s.is_empty()),
-            "ACK-CRACK: the manual-ack suppression entry must carry expires_at (else clear logic ValueErrors \
-             -> instant self-clear); got {entry}"
-        );
-    assert_eq!(
-        entry["suppressed_by"],
-        serde_json::json!("manual_acknowledge"),
-        "golden suppressed_by; got {entry}"
-    );
-    assert_eq!(
-        entry["manual_acknowledge"],
-        serde_json::json!(true),
-        "golden manual_acknowledge:true; got {entry}"
-    );
-}
-// ── ACK return-shape [P1 byte-parity] — acknowledge_idle must RETURN golden's keys ───────────────
-// golden runtime.py:691: return {ok, team, agent_id, acknowledged_at, expires_at, ttl_seconds}.
-// Rust (cli/mod.rs) returns only {ok, team, ttl_seconds} -> missing agent_id, acknowledged_at,
-// expires_at. RED. (acknowledged_at/expires_at are the same values written into idle_acknowledged.)
-#[test]
-fn acknowledge_idle_return_carries_golden_keys() {
-    let ws = tmp_workspace();
-    crate::state::persist::save_runtime_state(
-            &ws,
-            &serde_json::json!({ "active_team_key": "teamX", "agents": {"w1": {"status": "running", "provider": "codex"}} }),
-        )
-        .unwrap();
-    let r = lifecycle_port::acknowledge_idle(&ws, None).expect("acknowledge_idle ok");
-    let obj = r.as_object().expect("ack returns a dict");
-    for key in [
-        "ok",
-        "team",
-        "agent_id",
-        "acknowledged_at",
-        "expires_at",
-        "ttl_seconds",
-    ] {
-        assert!(
-            obj.contains_key(key),
-            "ACK return-shape: golden return carries `{key}` (runtime.py:691: ok/team/agent_id/\
-                 acknowledged_at/expires_at/ttl_seconds); Rust omits it. got keys {:?}",
-            obj.keys().collect::<Vec<_>>()
-        );
-    }
-    assert!(
-        obj.get("expires_at")
-            .and_then(serde_json::Value::as_str)
-            .is_some_and(|s| !s.is_empty()),
-        "ACK return-shape: expires_at must be a non-empty timestamp; got {r}"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
 // ── BUG-2 [real bug] — inbox must RETURN the stored messages, not a hardcoded []. ────────────────
 // Golden status/inbox.py:35-38 -> MessageStore.inbox(agent_id) (core.py:242, owner_team_id=None):
 //   select <MESSAGE_SELECT> from messages where sender = ? or recipient = ? order by created_at desc
@@ -680,16 +594,7 @@ fn remove_agent_from_spec_refusal_is_not_success_envelope() {
 fn stuck_cancel_persists_suppression_and_stuck_list_reads_state() {
     let ws = tmp_workspace();
     seed_collect_state(&ws);
-    let out = json_output(
-        cmd_stuck_cancel(&StuckCancelArgs {
-            agent: "fake_impl".to_string(),
-            workspace: ws.clone(),
-            alert_type: None,
-            json: true,
-            team: None,
-        })
-        .unwrap(),
-    );
+    let out = messaging::stuck_cancel(&ws, "fake_impl", None, "leader").unwrap();
     let team_key = seeded_team_key(&ws);
     assert_eq!(out["ok"], json!(true));
     assert_eq!(
@@ -715,98 +620,10 @@ fn stuck_cancel_persists_suppression_and_stuck_list_reads_state() {
                 && e["agent_id"] == json!("fake_impl")),
         "stuck_cancel must write coordinator.idle_alert_suppressed"
     );
-    let listed = json_output(
-        cmd_stuck_list(&StuckListArgs {
-            workspace: ws.clone(),
-            json: true,
-            team: None,
-        })
-        .unwrap(),
-    );
+    let listed = messaging::stuck_list(&ws).unwrap();
     assert_eq!(
         listed["suppressed_idle_alerts"]["fake_impl"]["stuck"]["suppressed_by"],
         json!("leader"),
         "stuck-list must read the persisted state mirror, not return a hard-coded empty list"
     );
 }
-
-#[test]
-fn stuck_cancel_explicit_team_is_rejected_until_backend_is_scoped() {
-    let ws = tmp_workspace();
-    seed_collect_state(&ws);
-    let err = cmd_stuck_cancel(&StuckCancelArgs {
-        agent: "fake_impl".to_string(),
-        workspace: ws.clone(),
-        alert_type: None,
-        json: true,
-        team: Some("current".to_string()),
-    })
-    .expect_err("explicit --team must not silently write global stuck suppression");
-    assert!(
-            err.to_string().contains("not supported yet"),
-            "stuck-cancel --team must be an explicit refusal until backend supports scoped writes; got {err}"
-        );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-#[test]
-fn stuck_cancel_invalid_alert_type_is_rejected() {
-    let ws = tmp_workspace();
-    seed_collect_state(&ws);
-    let code = run(
-        &cli_argv(&[
-            "stuck-cancel",
-            "fake_impl",
-            "--workspace",
-            &ws.to_string_lossy(),
-            "--alert-type",
-            "bogus",
-            "--json",
-        ]),
-        &ws,
-    );
-    assert_eq!(
-            code,
-            ExitCode::Error,
-            "Python rejects alert_type outside stuck/idle_fallback/cross_worker_deadlock/all; Rust must not silently coerce bogus to stuck"
-        );
-}
-#[test]
-fn acknowledge_idle_records_manual_idle_fallback_suppression_and_event() {
-    let ws = tmp_workspace();
-    seed_collect_state(&ws);
-    let out = json_output(
-        cmd_acknowledge_idle(&AcknowledgeIdleArgs {
-            team: None,
-            workspace: ws.clone(),
-            json: true,
-        })
-        .unwrap(),
-    );
-    let team_key = seeded_team_key(&ws);
-    assert_eq!(out["ok"], json!(true));
-    assert_eq!(out["team"], json!(team_key));
-    assert_eq!(out["ttl_seconds"], json!(1800));
-    let state = read_state(&ws);
-    let ack = &state["coordinator"]["idle_acknowledged"][&team_key];
-    assert_eq!(ack["ttl_seconds"], json!(1800));
-    assert!(ack["acknowledged_at"].as_str().is_some());
-    assert_eq!(
-        state["coordinator"]["suppressed_idle_alerts"][&team_key]["fake_impl"]["idle_fallback"]
-            ["suppressed_by"],
-        json!("manual_acknowledge")
-    );
-    assert_eq!(
-        state["coordinator"]["suppressed_idle_alerts"][&team_key]["fake_impl"]["idle_fallback"]
-            ["manual_acknowledge"],
-        json!(true)
-    );
-    assert!(
-        read_events(&ws)
-            .iter()
-            .any(|e| e["event"] == json!("coordinator.idle_acknowledged")
-                && e["team"] == json!(team_key)
-                && e["ttl_seconds"] == json!(1800)),
-        "acknowledge-idle must emit coordinator.idle_acknowledged"
-    );
-}

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

@@ -332,15 +332,15 @@ fn dispatch_routes_diagnose_checks_runtime_beyond_healthy_leader() {
             leader_env: Default::default(),
         }]);
     crate::transport_factory::with_leader_endpoint_transport(endpoint, transport, || {
-        for command in ["doctor", "diagnose"] {
-            let code = run(
-                &cli_argv(&[command, "--workspace", &ws.to_string_lossy(), "--json"]),
-                &ws,
-            );
-            assert_eq!(code, ExitCode::Error, "healthy binding alone cannot hide missing coordinator");
-        }
-        let result = cmd_diagnose(&DiagnoseArgs {
+        let code = run(
+            &cli_argv(&["doctor", "--workspace", &ws.to_string_lossy(), "--json"]),
+            &ws,
+        );
+        assert_eq!(code, ExitCode::Error, "healthy binding alone cannot hide missing coordinator");
+        let result = cmd_doctor(&DoctorArgs {
             workspace: ws.clone(), json: true, team: None,
+            spec: None, gate: None, comms: false, fix: false,
+            fix_schema: false, cleanup_orphans: false, confirm: false,
         }).expect("diagnostic report");
         let CmdOutput::Json(report) = result.output else {
             panic!("expected JSON diagnostic report");
@@ -377,7 +377,7 @@ fn dispatch_routes_diagnose_self_signed_attached_without_registry_is_not_ok() {
     let ws = tmp_workspace();
     seed_self_signed_attached_leader(&ws);
     let code = run(
-        &cli_argv(&["diagnose", "--workspace", &ws.to_string_lossy(), "--json"]),
+        &cli_argv(&["doctor", "--workspace", &ws.to_string_lossy(), "--json"]),
         &ws,
     );
     assert_ne!(

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

@@ -138,7 +138,7 @@ mod tests {
             "providers": {"claude": {"version": "secret"}},
             "runtime": {"workspace": "/tmp/secret"}
         });
-        let output = render("diagnose", &report);
+        let output = render("doctor", &report);
         assert!(output.contains("issue: short_issue"));
         assert!(output.contains("issue: code=object_issue"));
         assert!(output.contains("repair: action=run repair"));

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

@@ -312,14 +312,6 @@ pub struct QuickStartArgs {
     // user-confirmed. quick-start is now an initial-creation-only verb.
 }
 
-/// `init`(`parser.py` bootstrap verb)。
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct InitArgs {
-    pub workspace: PathBuf,
-    pub force: bool,
-    pub json: bool,
-}
-
 /// `send`(`parser.py:262`)。`target` xor `--to`(fanout);`message` 多 token join 空格。
 #[derive(Debug, Clone, PartialEq)]
 pub struct SendArgs {
@@ -554,36 +546,6 @@ pub struct RemoveAgentArgs {
     pub json: bool,
 }
 
-/// `stuck-list`(`parser.py:424`)。
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct StuckListArgs {
-    pub workspace: PathBuf,
-    pub json: bool,
-    /// Stage 4: explicit `--team` scope (read-only enumeration).
-    pub team: Option<String>,
-}
-
-/// `stuck-cancel`(`parser.py:429`)。`--alert-type` ∈ {stuck, idle_fallback, all},默认 stuck。
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct StuckCancelArgs {
-    pub agent: String,
-    pub workspace: PathBuf,
-    /// `None` 表 `all`(展开全集);`Some(AlertType)` 表单类型。
-    pub alert_type: Option<AlertType>,
-    pub json: bool,
-    /// Parsed but rejected until stuck suppression storage grows a team-scoped
-    /// backend selector.
-    pub team: Option<String>,
-}
-
-/// `acknowledge-idle`(`parser.py:436`)。
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct AcknowledgeIdleArgs {
-    pub team: Option<String>,
-    pub workspace: PathBuf,
-    pub json: bool,
-}
-
 /// `doctor`(`parser.py:318`)。`--gate` ∈ {orphans, comms};`--fix` 须配 `--gate`(`cmd_doctor` 校验)。
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct DoctorArgs {
@@ -683,17 +645,6 @@ pub struct WaitArgs {
     pub json: bool,
 }
 
-/// `diagnose` compatibility spelling for the canonical `doctor` health report.
-/// The CLI normalizes it to `DoctorArgs`; this narrow type remains for direct
-/// Rust callers that used the pre-unification API.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct DiagnoseArgs {
-    pub workspace: PathBuf,
-    pub json: bool,
-    /// Stage 4: explicit `--team` scope (read-only health report).
-    pub team: Option<String>,
-}
-
 /// `preflight`(`parser.py:160`)。
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct PreflightArgs {

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

@@ -555,6 +555,9 @@ fn compile_role_agent_with_mode(
             ]),
         ),
     ];
+    if let Some(label) = string_field(&meta, "label") {
+        agent_items.insert(1, ("label", Value::Str(label)));
+    }
     if let Some(profile) = string_field(&meta, "profile") {
         agent_items.push(("profile", Value::Str(profile)));
     }

package/crates/team-agent/src/leader/lease.rs

@@ -1313,7 +1313,7 @@ fn apply_endpoint_convergence(
                 "persisted": false,
                 "checked_paths": convergence_checked_paths(team_id.as_str()),
                 "action": format!(
-                    "old tmux endpoint {old_endpoint} still has this team's session or pane tuple; run team-agent diagnose --json before retrying restart"
+                    "old tmux endpoint {old_endpoint} still has this team's session or pane tuple; run team-agent doctor --json before retrying restart"
                 ),
             })),
             false,

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

@@ -177,6 +177,216 @@ pub(super) fn upsert_agent_state_from_role(
             "runtime state agents is not an object".to_string(),
         ));
     };
+    let entry = starting_agent_entry(workspace, agent_id, meta, dynamic_role_file);
+    agent_map.insert(agent_id.as_str().to_string(), entry);
+    crate::lifecycle::restart::remove::clear_agent_retirement_in_state(&mut state, agent_id);
+    save_launched_team_state_for_key(
+        workspace,
+        &state,
+        Some(canonical_team_key),
+        Some(agent_id.as_str()),
+    )
+}
+
+/// ---
+/// purpose: 首次登记 Pi fork 席位，原子带入目标角色与完整 fork capture seed
+/// returns: 成功后 TARGET 已按 ForkAgent typed intent 登记为 starting
+/// errors: 重复席位、无效 capture seed 或 state 写入失败时拒绝
+/// ---
+pub(crate) fn fork_upsert_agent_state_from_role(
+    workspace: &Path,
+    canonical_team_key: &str,
+    agent_id: &AgentId,
+    meta: &Value,
+    compiled_agent: &Value,
+    dynamic_role_file: &Path,
+    seed: &ForkCaptureSeed,
+) -> Result<(), LifecycleError> {
+    if agent_id == &seed.source_agent_id {
+        return Err(LifecycleError::RequirementUnmet(
+            "fork target must differ from source".to_string(),
+        ));
+    }
+    if seed.captured.captured_via != crate::provider::CaptureVia::ForkSnapshot
+        || seed.captured.attribution_confidence != crate::provider::Confidence::High
+        || seed.captured.session_id.is_none()
+        || seed.captured.rollout_path.is_none()
+        || seed.captured_at.is_empty()
+    {
+        return Err(LifecycleError::RequirementUnmet(
+            "fork capture seed is incomplete or not a verified Pi snapshot".to_string(),
+        ));
+    }
+    if compiled_agent.get("id").and_then(Value::as_str) != Some(agent_id.as_str()) {
+        return Err(LifecycleError::Compile(
+            "compiled fork role id does not match target".to_string(),
+        ));
+    }
+    let sessions_root = std::fs::canonicalize(&seed.pi_sessions_root)
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    let backing = seed.captured.rollout_path.as_ref().ok_or_else(|| {
+        LifecycleError::RequirementUnmet("fork backing path is missing".to_string())
+    })?;
+    let backing_path = std::fs::canonicalize(&backing.0)
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    if !backing_path.starts_with(&sessions_root) {
+        return Err(LifecycleError::RequirementUnmet(
+            "fork backing is outside the target Pi session root".to_string(),
+        ));
+    }
+
+    let mut state =
+        crate::state::projection::select_runtime_state(workspace, Some(canonical_team_key))
+            .map_err(|e| LifecycleError::TeamSelect(e.to_string()))?;
+    if !state.is_object() {
+        state = serde_json::json!({});
+    }
+    let root = state.as_object_mut().ok_or_else(|| {
+        LifecycleError::StatePersist("runtime state root is not an object".to_string())
+    })?;
+    let agents = root
+        .entry("agents".to_string())
+        .or_insert_with(|| serde_json::json!({}));
+    if !agents.is_object() {
+        *agents = serde_json::json!({});
+    }
+    let agent_map = agents.as_object_mut().ok_or_else(|| {
+        LifecycleError::StatePersist("runtime state agents is not an object".to_string())
+    })?;
+    if agent_map.contains_key(agent_id.as_str()) {
+        return Err(LifecycleError::RequirementUnmet(format!(
+            "agent id already exists in selected team: {}",
+            agent_id
+        )));
+    }
+
+    let source_profile_dir = agent_map
+        .get(seed.source_agent_id.as_str())
+        .and_then(serde_json::Value::as_object)
+        .and_then(|source| source.get("_profile_dir"))
+        .and_then(serde_json::Value::as_str)
+        .filter(|path| !path.is_empty())
+        .map(|path| serde_json::json!(path));
+    let mut entry = starting_agent_entry(workspace, agent_id, meta, dynamic_role_file);
+    let entry_object = entry.as_object_mut().ok_or_else(|| {
+        LifecycleError::StatePersist("fork target entry is not an object".to_string())
+    })?;
+    for field in [
+        "provider",
+        "auth_mode",
+        "role",
+        "model",
+        "effort",
+        "profile",
+        "tools",
+        "system_prompt",
+        "output_contract",
+        "communication_mode",
+        "working_directory",
+        "cwd",
+        "config",
+        "name",
+        "dangerously_skip_permissions",
+    ] {
+        if let Some(value) = compiled_agent.get(field) {
+            entry_object.insert(field.to_string(), yaml_value_to_json(value));
+        }
+    }
+    if compiled_agent.get("model").is_some() && !entry_object.contains_key("model_source") {
+        entry_object.insert("model_source".to_string(), serde_json::json!("team"));
+    }
+    entry_object.insert("agent_id".to_string(), serde_json::json!(agent_id.as_str()));
+    entry_object.insert("label".to_string(), serde_json::json!(agent_id.as_str()));
+    entry_object.insert(
+        "owner_team_id".to_string(),
+        serde_json::json!(canonical_team_key),
+    );
+    entry_object.insert(
+        "claude_projects_root".to_string(),
+        serde_json::json!(sessions_root.to_string_lossy().to_string()),
+    );
+    entry_object.insert(
+        "forked_from".to_string(),
+        serde_json::json!(seed.source_agent_id.as_str()),
+    );
+    entry_object.insert(
+        "spawn_cwd".to_string(),
+        serde_json::json!(seed.captured.spawn_cwd.to_string_lossy().to_string()),
+    );
+    entry_object.insert(
+        "session_id".to_string(),
+        serde_json::json!(seed.captured.session_id.as_ref().map(|id| id.as_str())),
+    );
+    let backing = seed.captured.rollout_path.as_ref().ok_or_else(|| {
+        LifecycleError::RequirementUnmet("fork backing path is missing".to_string())
+    })?;
+    entry_object.insert(
+        "rollout_path".to_string(),
+        serde_json::json!(backing.0.to_string_lossy().to_string()),
+    );
+    entry_object.insert(
+        "captured_at".to_string(),
+        serde_json::json!(seed.captured_at.as_str()),
+    );
+    entry_object.insert(
+        "captured_via".to_string(),
+        serde_json::to_value(seed.captured.captured_via)
+            .map_err(|e| LifecycleError::StatePersist(e.to_string()))?,
+    );
+    entry_object.insert(
+        "attribution_confidence".to_string(),
+        serde_json::to_value(seed.captured.attribution_confidence)
+            .map_err(|e| LifecycleError::StatePersist(e.to_string()))?,
+    );
+    entry_object.insert("capture_state".to_string(), serde_json::json!("captured"));
+    if let Some(profile_dir) = source_profile_dir {
+        entry_object.insert("_profile_dir".to_string(), profile_dir);
+    } else {
+        entry_object.insert(
+            "_profile_dir".to_string(),
+            serde_json::json!(seed.profile_dir.to_string_lossy().to_string()),
+        );
+    }
+    agent_map.insert(agent_id.as_str().to_string(), entry);
+    crate::lifecycle::restart::remove::clear_agent_retirement_in_state(&mut state, agent_id);
+    crate::state::repository::StateRepository::new(workspace)
+        .save(
+            crate::state::repository::StateWriteIntent::ForkAgent {
+                team_key: canonical_team_key,
+                agent_id: agent_id.as_str(),
+            },
+            &state,
+        )
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))
+}
+
+fn yaml_value_to_json(value: &Value) -> serde_json::Value {
+    match value {
+        Value::Null => serde_json::Value::Null,
+        Value::Bool(value) => serde_json::json!(value),
+        Value::Int(value) => serde_json::json!(value),
+        Value::Float(value) => serde_json::Number::from_f64(*value)
+            .map(serde_json::Value::Number)
+            .unwrap_or(serde_json::Value::Null),
+        Value::Str(value) => serde_json::json!(value),
+        Value::List(values) => {
+            serde_json::Value::Array(values.iter().map(yaml_value_to_json).collect())
+        }
+        Value::Map(values) => serde_json::Value::Object(
+            values
+                .iter()
+                .map(|(key, value)| (key.clone(), yaml_value_to_json(value)))
+                .collect(),
+        ),
+    }
+}
+
+fn starting_agent_entry(
+    workspace: &Path,
+    agent_id: &AgentId,
+    meta: &Value,
+    dynamic_role_file: &Path,
+) -> serde_json::Value {
     let provider = meta
         .get("provider")
         .and_then(Value::as_str)
@@ -189,10 +399,6 @@ pub(super) fn upsert_agent_state_from_role(
         .get("role")
         .and_then(Value::as_str)
         .unwrap_or_else(|| agent_id.as_str());
-    // E42 (0.3.24 P0, double-spec deadlock): persist the initial state row as
-    // "starting" (not "running"). The caller (add_agent_with_transport_at_paths)
-    // promotes to "running" only after start_agent_at_paths returns Running.
-    // If the spawn fails, the rollback below removes the entry entirely.
     let mut entry = serde_json::json!({
         "provider": provider,
         "auth_mode": auth_mode,
@@ -221,9 +427,6 @@ pub(super) 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() {
@@ -232,7 +435,6 @@ pub(super) fn upsert_agent_state_from_role(
         }
     }
     if let Some(obj) = entry.as_object_mut() {
-        // 0.5.66 bypass 单源:policy 从 role 文档字段派生,不再用全队 `DangerousApproval`。
         let meta_provider = meta
             .get("provider")
             .and_then(Value::as_str)
@@ -240,14 +442,7 @@ pub(super) fn upsert_agent_state_from_role(
             .unwrap_or(Provider::Codex);
         persist_effective_approval_policy_from_yaml_agent(obj, meta, meta_provider);
     }
-    agent_map.insert(agent_id.as_str().to_string(), entry);
-    crate::lifecycle::restart::remove::clear_agent_retirement_in_state(&mut state, agent_id);
-    save_launched_team_state_for_key(
-        workspace,
-        &state,
-        Some(canonical_team_key),
-        Some(agent_id.as_str()),
-    )
+    entry
 }
 
 /// ---

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

@@ -59,6 +59,7 @@ pub fn clone_agent(
         source_agent_id,
         as_agent_id,
         label,
+        None,
     )?;
     // The materialized role carries the source role's DECLARED tools verbatim —
     // a clone must preserve the source seat's full tools set (add-agent does

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

@@ -1,9 +1,9 @@
 //! ---
-//! purpose: 在当前席位窗口注入官方斜杠命令完成就地分身，不读 provider session 落盘
+//! purpose: Pi 以完整会话快照创建独立席位；已验证的其他 provider 保持窗口内分身
 //! contract:
 //!   provides:
 //!     - name: fork_agent_with_transport
-//!       what: grok/claude subscription 注入纯净斜杠命令；屏幕出现该 provider 的实测标记才算成功
+//!       what: Pi 走锁内快照新席位；已验证的其他 provider 保持窗口内斜杠 fork
 //!     - name: in_window_fork
 //!       what: 已验证的 provider+subscription 给出 command+screen_mark；未验证返回 None
 //!   depends:
@@ -12,8 +12,8 @@
 //!     - crate::lifecycle::profile_launch
 //!     - crate::transport::Transport
 //! boundary:
-//!   - 不 spawn 新 pane，不改 TEAM_AGENT_ID / MCP / 席位名
-//!   - 不读 provider 会话落盘文件取会话身份
+//!   - 仅 Pi 的锁内专用管道读取 exact backing、注册并启动新席位
+//!   - 非 Pi 不 spawn 新 pane，不改 TEAM_AGENT_ID / MCP / 席位名
 //!   - 重试只重按回车，不重粘 /fork
 //!   - 不把 pane 锁超时从 200ms 调大
 //!   - 未验证的 provider 不猜斜杠命令
@@ -99,7 +99,7 @@ pub fn fork_agent_with_transport(
     workspace: &Path,
     source_agent_id: &AgentId,
     as_agent_id: &AgentId,
-    _label: Option<&str>,
+    label: Option<&str>,
     _open_display: bool,
     team: Option<&str>,
     transport: &dyn Transport,
@@ -142,6 +142,15 @@ pub fn fork_agent_with_transport(
         .unwrap_or("subscription");
     let provider = parse_provider(provider_raw).unwrap_or(Provider::Grok);
     let auth = parse_auth_mode(auth_raw).unwrap_or(AuthMode::Subscription);
+    if provider == Provider::Pi {
+        return crate::lifecycle::restart::fork_pi_new_seat_locked(
+            &selected,
+            source_agent_id,
+            as_agent_id,
+            label,
+            transport,
+        );
+    }
     let Some(spec) = in_window_fork(provider, auth) else {
         return Err(refuse_missing_in_window_fork(provider, provider_raw));
     };
@@ -201,6 +210,7 @@ pub fn fork_agent_with_transport(
         },
         session_id: None,
         backing_state: ForkBackingState::Verified,
+        pi_fork: None,
     })
 }