@team-agent/installer 0.5.100 → 0.5.102

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

@@ -9,55 +9,118 @@
 //!   - 不读 provider session 落盘
 //! maturity: wired
 //! ---
+use std::fs::OpenOptions;
+use std::io::Write;
+use std::os::unix::fs::MetadataExt;
 use std::path::{Path, PathBuf};
+use std::time::{SystemTime, UNIX_EPOCH};
 
 use crate::lifecycle::LifecycleError;
 use crate::model::ids::AgentId;
 use crate::model::yaml::{self, Value};
 
-fn set_yaml_map_value(
-    value: &mut Value,
-    key: &str,
-    next: Value,
-) -> Result<(), LifecycleError> {
+fn set_yaml_map_value(value: &mut Value, key: &str, next: Value) -> Result<(), LifecycleError> {
     let Value::Map(pairs) = value else {
         return Err(LifecycleError::Compile(
             "agent entry is not a map".to_string(),
         ));
     };
-    if let Some((_, existing)) = pairs.iter_mut().find(|(k, _)| k == key) {
-        *existing = next;
-    } else {
+    let mut found = false;
+    for (_, existing) in pairs
+        .iter_mut()
+        .filter(|(existing_key, _)| existing_key.as_str() == key)
+    {
+        *existing = next.clone();
+        found = true;
+    }
+    if !found {
         pairs.push((key.to_string(), next));
     }
     Ok(())
 }
 
-pub(super) struct MaterializedRole {
+fn dump_role_frontmatter(meta: &Value) -> String {
+    let Value::Map(pairs) = meta else {
+        return yaml::dumps(meta);
+    };
+    let mut rendered = String::new();
+    for (key, value) in pairs {
+        if value.as_str().is_some_and(is_plain_frontmatter_scalar) {
+            if let Some(value) = value.as_str() {
+                rendered.push_str(&format!("{key}: {value}\n"));
+            }
+        } else {
+            rendered.push_str(&yaml::dumps(&Value::Map(vec![(
+                key.clone(),
+                value.clone(),
+            )])));
+        }
+    }
+    rendered
+}
+
+fn is_plain_frontmatter_scalar(value: &str) -> bool {
+    !value.is_empty()
+        && value.trim() == value
+        && value
+            .chars()
+            .any(|character| character.is_ascii_alphabetic() || character == '_')
+        && value.chars().all(|character| {
+            character.is_ascii_alphanumeric() || matches!(character, '_' | '-' | '.' | ' ' | '/')
+        })
+        && !matches!(
+            value.to_ascii_lowercase().as_str(),
+            "true" | "false" | "null" | "yes" | "no" | "on" | "off"
+        )
+}
+
+fn strip_label_quotes(mut label: &str) -> &str {
+    loop {
+        let bytes = label.as_bytes();
+        if bytes.len() >= 2
+            && matches!(bytes[0], b'\'' | b'"')
+            && bytes[0] == bytes[bytes.len() - 1]
+        {
+            label = &label[1..label.len() - 1];
+        } else {
+            return label;
+        }
+    }
+}
+
+pub(crate) struct MaterializedRole {
     path: PathBuf,
+    device: u64,
+    inode: u64,
     keep: bool,
 }
 
 impl MaterializedRole {
-/// ---
-/// purpose: 取物化出来的角色文件路径
-/// returns: 落盘路径
-/// ---
-    pub(super) fn path(&self) -> &Path {
+    /// ---
+    /// purpose: 取物化出来的角色文件路径
+    /// returns: 落盘路径
+    /// ---
+    pub(crate) fn path(&self) -> &Path {
         &self.path
     }
 
-/// ---
-/// purpose: 标记该文件由调用方接管，Drop 时不再删除
-/// ---
-    pub(super) fn keep(&mut self) {
+    /// ---
+    /// purpose: 标记该文件由调用方接管，Drop 时不再删除
+    /// ---
+    pub(crate) fn keep(&mut self) {
         self.keep = true;
     }
 }
 
 impl Drop for MaterializedRole {
     fn drop(&mut self) {
-        if !self.keep {
+        if !self.keep
+            && std::fs::symlink_metadata(&self.path).is_ok_and(|metadata| {
+                metadata.file_type().is_file()
+                    && metadata.dev() == self.device
+                    && metadata.ino() == self.inode
+            })
+        {
             let _ = std::fs::remove_file(&self.path);
         }
     }
@@ -69,16 +132,18 @@ impl Drop for MaterializedRole {
 ///   state: 用于找源席的 dynamic_role_file，找不到时退到 team 目录下的同名 md
 ///   as_agent_id: 新席位名，写进 front matter 的 name
 ///   label: 非空时覆盖 front matter 的 role
+///   agent_label: 非空时写入 front matter 的 label
 /// returns: 物化结果，未调用 keep 时 Drop 会删掉该文件
 /// errors: 源文件缺失、未声明 name 或声明与源席不符时返回 Compile；目标已存在返回 RequirementUnmet；建目录或写盘失败返回 StatePersist
 /// ---
-pub(super) fn materialize_latest_role(
+pub(crate) fn materialize_latest_role(
     run_workspace: &Path,
     team_dir: &Path,
     state: &serde_json::Value,
     source_agent_id: &AgentId,
     as_agent_id: &AgentId,
     label: Option<&str>,
+    agent_label: Option<&str>,
 ) -> Result<MaterializedRole, LifecycleError> {
     let source_path = resolve_role_source(run_workspace, team_dir, state, source_agent_id)?;
     let (mut meta, body) = crate::compiler::read_front_matter(&source_path)
@@ -104,32 +169,103 @@ pub(super) fn materialize_latest_role(
         "name",
         Value::Str(as_agent_id.as_str().to_string()),
     )?;
-    if let Some(label) = label.filter(|value| !value.is_empty()) {
+    if let Some(label) = label
+        .map(strip_label_quotes)
+        .filter(|value| !value.is_empty())
+    {
         set_yaml_map_value(&mut meta, "role", Value::Str(label.to_string()))?;
     }
+    if let Some(agent_label) = agent_label
+        .map(strip_label_quotes)
+        .filter(|value| !value.is_empty())
+    {
+        set_yaml_map_value(&mut meta, "label", Value::Str(agent_label.to_string()))?;
+    }
+    if let Some(role) = meta.get("role").and_then(Value::as_str).map(str::to_string) {
+        let role_without_quotes = strip_label_quotes(&role);
+        if !role_without_quotes.is_empty() && role_without_quotes != role {
+            set_yaml_map_value(
+                &mut meta,
+                "role",
+                Value::Str(role_without_quotes.to_string()),
+            )?;
+        }
+    }
 
     let managed_dir = run_workspace.join(".team").join("dynamic-role-files");
     std::fs::create_dir_all(&managed_dir)
         .map_err(|error| LifecycleError::StatePersist(error.to_string()))?;
     let path = managed_dir.join(format!("{}.md", as_agent_id.as_str()));
-    if path.exists() {
-        return Err(LifecycleError::RequirementUnmet(format!(
-            "managed role file already exists: {}",
-            path.display()
-        )));
+    match std::fs::symlink_metadata(&path) {
+        Ok(_) => {
+            return Err(LifecycleError::RequirementUnmet(format!(
+                "managed role file already exists: {}",
+                path.display()
+            )))
+        }
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
+        Err(error) => return Err(LifecycleError::StatePersist(error.to_string())),
     }
-    let rendered = format!("---\n{}---\n\n{}", yaml::dumps(&meta), body);
-    let temp = path.with_extension(format!("md.tmp-{}", std::process::id()));
-    std::fs::write(&temp, rendered.as_bytes())
+    let rendered = format!("---\n{}---\n\n{}", dump_role_frontmatter(&meta), body);
+    let nonce = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map_err(|error| LifecycleError::StatePersist(error.to_string()))?
+        .as_nanos();
+    let temp = managed_dir.join(format!(
+        ".{}.md.tmp-{}-{nonce}",
+        as_agent_id.as_str(),
+        std::process::id()
+    ));
+    let mut file = OpenOptions::new()
+        .write(true)
+        .create_new(true)
+        .open(&temp)
         .map_err(|error| LifecycleError::StatePersist(error.to_string()))?;
-    if let Err(error) = std::fs::rename(&temp, &path) {
+    if let Err(error) = file
+        .write_all(rendered.as_bytes())
+        .and_then(|_| file.sync_all())
+    {
+        drop(file);
+        let _ = std::fs::remove_file(&temp);
+        return Err(LifecycleError::StatePersist(error.to_string()));
+    }
+    let metadata = match file.metadata() {
+        Ok(metadata) => metadata,
+        Err(error) => {
+            drop(file);
+            let _ = std::fs::remove_file(&temp);
+            return Err(LifecycleError::StatePersist(error.to_string()));
+        }
+    };
+    let (device, inode) = (metadata.dev(), metadata.ino());
+    drop(file);
+    if let Err(error) = std::fs::hard_link(&temp, &path) {
         let _ = std::fs::remove_file(&temp);
+        if error.kind() == std::io::ErrorKind::AlreadyExists {
+            return Err(LifecycleError::RequirementUnmet(format!(
+                "managed role file already exists: {}",
+                path.display()
+            )));
+        }
+        return Err(LifecycleError::StatePersist(error.to_string()));
+    }
+    if let Err(error) = std::fs::remove_file(&temp) {
+        if std::fs::symlink_metadata(&path).is_ok_and(|metadata| {
+            metadata.file_type().is_file() && metadata.dev() == device && metadata.ino() == inode
+        }) {
+            let _ = std::fs::remove_file(&path);
+        }
         return Err(LifecycleError::StatePersist(error.to_string()));
     }
-    Ok(MaterializedRole { path, keep: false })
+    Ok(MaterializedRole {
+        path,
+        device,
+        inode,
+        keep: false,
+    })
 }
 
-fn resolve_role_source(
+pub(crate) fn resolve_role_source(
     run_workspace: &Path,
     team_dir: &Path,
     state: &serde_json::Value,

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

@@ -167,7 +167,7 @@ pub(super) fn spawn_agents(
                     model: command_model,
                     effort: agent_effort,
                     system_prompt: &system_prompt,
-                    team_mcp_tools: &["send_message", "report_result"],
+                    team_mcp_tools: &["send_message", "report_result", "get_team_status"],
                     mcp_config: &mcp_config,
                     session_scope: crate::lifecycle::launch::pi_mcp::PiSessionScope::Isolated,
                 },

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

@@ -23,6 +23,15 @@ use crate::transport::{PaneId, SessionName, Target, Transport, WindowName};
 
 use crate::lifecycle::lock::{acquire_agent_lifecycle_lock, LifecycleLockRequest};
 
+#[derive(Clone, Debug)]
+pub(crate) struct ForkCaptureSeed {
+    pub source_agent_id: AgentId,
+    pub captured: crate::provider::CapturedSession,
+    pub captured_at: String,
+    pub pi_sessions_root: PathBuf,
+    pub profile_dir: PathBuf,
+}
+
 use super::*;
 
 // ── lifecycle::launch —— 冷启 / quick-start / 危险审批探测 ──────────────────
@@ -395,8 +404,7 @@ pub(super) use add_agent::*;
 pub use add_agent::{add_agent, add_agent_force};
 pub(crate) use add_agent::{add_agent_with_transport, add_agent_with_transport_force};
 
-mod add_agent_state;
-pub(crate) use add_agent_state::inject_agent_into_spec;
+pub(crate) mod add_agent_state;
 pub(super) use add_agent_state::*;
 
 mod fork_agent;
@@ -406,7 +414,7 @@ pub use fork_agent::{fork_agent_with_transport, in_window_fork, in_window_fork_c
 mod fork_entry;
 pub use fork_entry::fork_agent;
 
-mod role_source;
+pub(crate) mod role_source;
 pub(super) use role_source::*;
 
 mod clone_agent;

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

@@ -217,7 +217,13 @@ fn prepare_profile_launch(
     let Some(profile) = agent.profile.as_deref() else {
         return Ok(ProviderProfileLaunch::default());
     };
-    let loaded = load_profile(workspace, profile, agent.profile_dir.as_deref())?;
+    let Some(path) = find_profile_file(workspace, profile, agent.profile_dir.as_deref()) else {
+        if agent.provider == Provider::Pi && agent.auth_mode == AuthMode::Subscription {
+            return Ok(ProviderProfileLaunch::default());
+        }
+        return Err(profile_not_found(profile));
+    };
+    let loaded = read_profile_file(path)?;
     validate_profile(&agent, profile, &loaded)?;
 
     let mut env_overlay = provider_env_exports(agent.provider, agent.auth_mode, &loaded.values);
@@ -290,9 +296,14 @@ pub(crate) fn load_profile(
     name: &str,
     profile_dir: Option<&Path>,
 ) -> Result<ProfileValues, LifecycleError> {
+    let path =
+        find_profile_file(workspace, name, profile_dir).ok_or_else(|| profile_not_found(name))?;
+    read_profile_file(path)
+}
+
+fn find_profile_file(workspace: &Path, name: &str, profile_dir: Option<&Path>) -> Option<PathBuf> {
     let dirs = profile_lookup_dirs(workspace, profile_dir);
-    let path = dirs
-        .iter()
+    dirs.iter()
         .map(|directory| directory.join(format!("{name}.env")))
         .find(|path| path.exists())
         .or_else(|| {
@@ -300,11 +311,15 @@ pub(crate) fn load_profile(
                 .map(|directory| directory.join(format!("{name}.example.env")))
                 .find(|path| path.exists())
         })
-        .ok_or_else(|| {
-            LifecycleError::RequirementUnmet(format!(
-                "profile {name} not found; run team-agent profile init {name} --auth-mode subscription"
-            ))
-        })?;
+}
+
+fn profile_not_found(name: &str) -> LifecycleError {
+    LifecycleError::RequirementUnmet(format!(
+        "profile {name} not found; run team-agent profile init {name} --auth-mode subscription"
+    ))
+}
+
+fn read_profile_file(path: PathBuf) -> Result<ProfileValues, LifecycleError> {
     let text = std::fs::read_to_string(&path)
         .map_err(|e| LifecycleError::StatePersist(format!("{}: {e}", path.display())))?;
     Ok(ProfileValues {

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

@@ -546,7 +546,7 @@ fn replay_worker_target_missing_messages(
     Ok(())
 }
 
-fn verify_spawned_pane_matches_target(
+pub(super) fn verify_spawned_pane_matches_target(
     transport: &dyn crate::transport::Transport,
     pane: &crate::transport::PaneId,
     session: &crate::transport::SessionName,
@@ -1244,7 +1244,7 @@ pub(super) fn resolve_team_scoped_state_or_refuse(
     })
 }
 
-fn mark_agent_started(
+pub(super) fn mark_agent_started(
     state: &mut serde_json::Value,
     agent_id: &AgentId,
     window: &str,