@team-agent/installer 0.5.100 → 0.5.101

package/Cargo.lock

@@ -581,7 +581,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.100"
+version = "0.5.101"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.100"
+version = "0.5.101"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -94,6 +94,14 @@ pub(crate) fn classify_tmux_server_error(error_text: &str) -> &'static str {
 }
 
 pub(crate) fn diagnose_runtime(state: &Value, backend: &dyn Transport) -> (Value, Value) {
+    diagnose_runtime_with_workspace(None, state, backend)
+}
+
+fn diagnose_runtime_with_workspace(
+    workspace: Option<&std::path::Path>,
+    state: &Value,
+    backend: &dyn Transport,
+) -> (Value, Value) {
     let mut issues = Vec::new();
     let mut repairs = Vec::new();
 
@@ -248,12 +256,25 @@ pub(crate) fn diagnose_runtime(state: &Value, backend: &dyn Transport) -> (Value
                         .and_then(Value::as_str)
                         .filter(|path| !path.is_empty())
                         .map(crate::provider::RolloutPath::new);
-                    let identity_probe =
-                        crate::lifecycle::restart::session_identity_probe_for_agent(
-                            &crate::model::ids::AgentId::new(agent_id.clone()),
-                            provider,
-                            rollout_path.as_ref(),
-                        );
+                    let agent_identity = crate::model::ids::AgentId::new(agent_id.clone());
+                    let identity_probe = workspace
+                        .map(|workspace| {
+                            crate::lifecycle::restart::session_identity_probe_for_agent_with_fork_ancestry(
+                                workspace,
+                                state,
+                                &agent_identity,
+                                agent_state,
+                                provider,
+                                rollout_path.as_ref(),
+                            )
+                        })
+                        .unwrap_or_else(|| {
+                            crate::lifecycle::restart::session_identity_probe_for_agent(
+                                &agent_identity,
+                                provider,
+                                rollout_path.as_ref(),
+                            )
+                        });
                     if identity_probe.identity_ok == Some(false) {
                         let issue = format!("session_identity_mismatch:{agent_id}");
                         issues.push(json!(issue));
@@ -304,7 +325,8 @@ pub(crate) fn diagnose_runtime_for_workspace(
     selected_team_key: Option<&str>,
     coordinator_health: &crate::coordinator::HealthReport,
 ) -> (Value, Value) {
-    let (mut issues, mut repairs) = diagnose_runtime(state, backend);
+    let (mut issues, mut repairs) =
+        diagnose_runtime_with_workspace(Some(workspace), state, backend);
     append_live_leader_workspace_mismatch_issue(
         workspace,
         state,

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

@@ -2926,14 +2926,30 @@ pub mod lifecycle_port {
         let source = crate::model::ids::AgentId::new(source_agent);
         let dest = crate::model::ids::AgentId::new(as_agent_id);
         match crate::lifecycle::fork_agent(workspace, &source, &dest, label, true, team) {
-            Ok(report) => Ok(json!({
-                "ok": true,
-                "source_agent_id": report.source_agent_id.as_str(),
-                "new_agent_id": report.new_agent_id.as_str(),
-                "session_id": report.session_id.as_ref().map(|session| session.as_str()),
-                "new_session_id": report.session_id.as_ref().map(|session| session.as_str()),
-                "backing_state": report.backing_state,
-            })),
+            Ok(report) => {
+                let mut value = json!({
+                    "ok": true,
+                    "source_agent_id": report.source_agent_id.as_str(),
+                    "new_agent_id": report.new_agent_id.as_str(),
+                    "session_id": report.session_id.as_ref().map(|session| session.as_str()),
+                    "new_session_id": report.session_id.as_ref().map(|session| session.as_str()),
+                    "backing_state": report.backing_state,
+                });
+                if let (Some(details), Some(object)) = (report.pi_fork, value.as_object_mut()) {
+                    object.insert("status".to_string(), json!("forked"));
+                    object.insert("target".to_string(), json!(report.new_agent_id.as_str()));
+                    object.insert(
+                        "source_session_id".to_string(),
+                        json!(details.source_session_id.as_str()),
+                    );
+                    object.insert("session_id".to_string(), json!(details.session_id.as_str()));
+                    object.insert(
+                        "backing_path".to_string(),
+                        json!(details.backing_path.0.to_string_lossy().to_string()),
+                    );
+                }
+                Ok(value)
+            }
             Err(e) => Ok(error_value(e)),
         }
     }

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/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,
     })
 }
 

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

@@ -44,11 +44,39 @@ pub fn fork_agent(
     .map_err(|e| LifecycleError::TeamSelect(e.to_string()))?;
     // Fork-agent routes to the selected live team's persisted endpoint, not
     // the workspace-hash fallback socket.
-    let transport = crate::lifecycle::restart::lifecycle_worker_tmux_backend_for_selected_state(
-        &selected.run_workspace,
-        Some(selected.team_key.as_str()),
-    )
-    .unwrap_or_else(|_| crate::tmux_backend::TmuxBackend::for_workspace(&selected.run_workspace));
+    let is_pi = selected
+        .state
+        .get("agents")
+        .and_then(|agents| agents.get(source_agent_id.as_str()))
+        .and_then(|agent| agent.get("provider"))
+        .and_then(serde_json::Value::as_str)
+        == Some("pi");
+    let transport: Box<dyn crate::transport::Transport> = if is_pi {
+        #[cfg(test)]
+        {
+            test_fork_transport(&selected, source_agent_id)
+        }
+        #[cfg(not(test))]
+        {
+            Box::new(
+                crate::lifecycle::restart::lifecycle_worker_tmux_backend_selection_for_state(
+                    &selected.run_workspace,
+                    &selected.state,
+                )?
+                .backend,
+            )
+        }
+    } else {
+        Box::new(
+            crate::lifecycle::restart::lifecycle_worker_tmux_backend_for_selected_state(
+                &selected.run_workspace,
+                Some(selected.team_key.as_str()),
+            )
+            .unwrap_or_else(|_| {
+                crate::tmux_backend::TmuxBackend::for_workspace(&selected.run_workspace)
+            }),
+        )
+    };
     fork_agent_with_transport(
         workspace,
         source_agent_id,
@@ -56,6 +84,61 @@ pub fn fork_agent(
         label,
         open_display,
         team,
-        &transport,
+        transport.as_ref(),
+    )
+}
+
+#[cfg(test)]
+fn test_fork_transport(
+    selected: &crate::state::selector::SelectedTeam,
+    source_agent_id: &AgentId,
+) -> Box<dyn crate::transport::Transport> {
+    let state = &selected.state;
+    let session = state
+        .get("session_name")
+        .and_then(serde_json::Value::as_str)
+        .filter(|value| !value.is_empty())
+        .map(crate::transport::SessionName::new)
+        .unwrap_or_else(|| crate::transport::SessionName::new("offline"));
+    let source = state
+        .get("agents")
+        .and_then(|agents| agents.get(source_agent_id.as_str()));
+    let targets = source
+        .and_then(|agent| agent.get("pane_id"))
+        .and_then(serde_json::Value::as_str)
+        .filter(|pane| !pane.is_empty())
+        .map(|pane| {
+            let window = source
+                .and_then(|agent| agent.get("window"))
+                .and_then(serde_json::Value::as_str)
+                .filter(|value| !value.is_empty())
+                .unwrap_or(source_agent_id.as_str());
+            vec![crate::transport::PaneInfo {
+                pane_id: crate::transport::PaneId::new(pane),
+                session: session.clone(),
+                window_index: None,
+                window_name: Some(crate::transport::WindowName::new(window)),
+                pane_index: None,
+                tty: None,
+                current_command: None,
+                current_path: None,
+                active: false,
+                pane_pid: None,
+                leader_env: std::collections::BTreeMap::new(),
+            }]
+        })
+        .unwrap_or_default();
+    let endpoint = state
+        .get("tmux_endpoint")
+        .or_else(|| state.get("tmux_socket"))
+        .and_then(serde_json::Value::as_str)
+        .filter(|value| !value.is_empty())
+        .map(str::to_string)
+        .unwrap_or_else(|| "offline".to_string());
+    Box::new(
+        crate::transport::test_support::OfflineTransport::new()
+            .with_session_present(true)
+            .with_targets(targets)
+            .with_tmux_endpoint(endpoint),
     )
 }