@team-agent/installer 0.3.1 → 0.3.3

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

@@ -64,18 +64,19 @@ pub fn run(
                 .and_then(serde_json::Value::as_str)
                 .unwrap_or("unknown");
             let task_id = payload.get("task_id").and_then(serde_json::Value::as_str);
-            report_fake_result(workspace, agent_id, message_id, task_id, &mut output)?;
+            report_fake_result(workspace, agent_id, message_id, task_id, None, &mut output)?;
             block = None;
         } else if let Some(parsed) = parse_rendered_header(trimmed) {
             block = Some(parsed);
         } else if let Some(token) = parse_token(trimmed) {
             if let Some(current) = block.take() {
-                let _content = current.content();
+                let content = current.content();
                 report_fake_result(
                     workspace,
                     agent_id,
                     &token,
                     current.task_id.as_deref(),
+                    Some(&content),
                     &mut output,
                 )?;
             }
@@ -126,15 +127,157 @@ fn report_fake_result(
     agent_id: &str,
     message_id: &str,
     task_id: Option<&str>,
+    source_content: Option<&str>,
     output: &mut impl Write,
 ) -> Result<(), FakeWorkerError> {
     let envelope = fake_envelope(workspace, agent_id, message_id, task_id);
-    crate::messaging::report_result(workspace, &envelope)
+    let owner_team = std::env::var("TEAM_AGENT_OWNER_TEAM_ID")
+        .ok()
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty());
+    mirror_fake_result_to_leader(workspace, owner_team.as_deref(), &envelope, source_content);
+    crate::messaging::report_result_for_owner_team(workspace, &envelope, owner_team.as_deref())
         .map_err(|e| FakeWorkerError::Report(e.to_string()))?;
+    mirror_fake_result_to_leader(workspace, owner_team.as_deref(), &envelope, source_content);
     writeln!(output, "{}", serde_json::to_string(&envelope)?)?;
     Ok(())
 }
 
+fn mirror_fake_result_to_leader(
+    workspace: &Path,
+    owner_team: Option<&str>,
+    envelope: &serde_json::Value,
+    source_content: Option<&str>,
+) {
+    let Ok(raw_state) = crate::state::persist::load_runtime_state(workspace) else {
+        return;
+    };
+    let state = owner_team
+        .and_then(|team| crate::state::projection::resolve_owner_team_id(&raw_state, team).canonical_key().map(str::to_string))
+        .map(|team| crate::state::projection::project_top_level_view(&raw_state, &team))
+        .unwrap_or(raw_state);
+    let attached = state
+        .get("leader_receiver")
+        .and_then(|receiver| receiver.get("status"))
+        .and_then(serde_json::Value::as_str)
+        == Some("attached");
+    let pane_id = state
+        .get("leader_receiver")
+        .and_then(|receiver| receiver.get("pane_id"))
+        .and_then(serde_json::Value::as_str)
+        .filter(|pane| !pane.is_empty())
+        .map(str::to_string)
+        .or_else(|| owner_team.and_then(|team| claimed_pane_from_events(workspace, team)));
+    let Some(pane_id) = pane_id.filter(|_| attached || owner_team.is_some()) else {
+        return;
+    };
+    let summary = envelope
+        .get("summary")
+        .and_then(serde_json::Value::as_str)
+        .unwrap_or("Fake worker completed");
+    let result_id = envelope
+        .get("result_id")
+        .and_then(serde_json::Value::as_str)
+        .unwrap_or("");
+    let text = match source_content.filter(|content| !content.trim().is_empty()) {
+        Some(content) => format!(
+            "Fake worker result: {summary}\nMessage content: {}\nResult id: {result_id}",
+            content.trim()
+        ),
+        None => format!("Fake worker result: {summary}\nResult id: {result_id}"),
+    };
+    let target = crate::transport::Target::Pane(crate::transport::PaneId::new(&pane_id));
+    let payload = crate::transport::InjectPayload::Text(text.clone());
+    let key = crate::transport::Key::Enter;
+    if let Some(socket) = leader_receiver_full_socket(&state) {
+        let endpoint_backend = crate::tmux_backend::TmuxBackend::for_tmux_endpoint(socket);
+        if crate::transport::Transport::inject(&endpoint_backend, &target, &payload, key, true).is_ok() {
+            mirror_to_team_session_panes(&state, workspace, agent_id_from_envelope(envelope), &text);
+            return;
+        }
+    }
+    let workspace_backend = crate::tmux_backend::TmuxBackend::for_workspace(workspace);
+    let _ = crate::transport::Transport::inject(&workspace_backend, &target, &payload, key, true);
+    mirror_to_team_session_panes(&state, workspace, agent_id_from_envelope(envelope), &text);
+}
+
+fn leader_receiver_full_socket(state: &serde_json::Value) -> Option<&str> {
+    state
+        .get("leader_receiver")
+        .and_then(|receiver| receiver.get("tmux_socket"))
+        .and_then(serde_json::Value::as_str)
+        .filter(|socket| !socket.is_empty() && Path::new(socket).is_absolute())
+}
+
+fn claimed_pane_from_events(workspace: &Path, owner_team: &str) -> Option<String> {
+    crate::event_log::EventLog::new(workspace)
+        .tail(50)
+        .ok()?
+        .into_iter()
+        .rev()
+        .find_map(|event| {
+            if event.get("event").and_then(serde_json::Value::as_str)
+                != Some("leader_receiver.rebind_applied")
+            {
+                return None;
+            }
+            if event.get("team_id").and_then(serde_json::Value::as_str) != Some(owner_team) {
+                return None;
+            }
+            event
+                .get("new_pane_id")
+                .and_then(serde_json::Value::as_str)
+                .filter(|pane| !pane.is_empty())
+                .map(str::to_string)
+        })
+}
+
+fn agent_id_from_envelope(envelope: &serde_json::Value) -> Option<&str> {
+    envelope.get("agent_id").and_then(serde_json::Value::as_str)
+}
+
+fn mirror_to_team_session_panes(
+    state: &serde_json::Value,
+    workspace: &Path,
+    agent_id: Option<&str>,
+    text: &str,
+) {
+    let Some(session) = state
+        .get("session_name")
+        .and_then(serde_json::Value::as_str)
+        .filter(|session| !session.is_empty())
+    else {
+        return;
+    };
+    let worker_pane = agent_id.and_then(|agent_id| {
+        state
+            .get("agents")
+            .and_then(|agents| agents.get(agent_id))
+            .and_then(|agent| agent.get("pane_id"))
+            .and_then(serde_json::Value::as_str)
+    });
+    if let Some(socket) = leader_receiver_full_socket(state) {
+        let backend = crate::tmux_backend::TmuxBackend::for_tmux_endpoint(socket);
+        for pane in crate::transport::Transport::list_targets(&backend).unwrap_or_default() {
+            if pane.session.as_str() != session || Some(pane.pane_id.as_str()) == worker_pane {
+                continue;
+            }
+            let target = crate::transport::Target::Pane(pane.pane_id);
+            let payload = crate::transport::InjectPayload::Text(text.to_string());
+            let _ = crate::transport::Transport::inject(&backend, &target, &payload, crate::transport::Key::Enter, true);
+        }
+    }
+    let backend = crate::tmux_backend::TmuxBackend::for_workspace(workspace);
+    for pane in crate::transport::Transport::list_targets(&backend).unwrap_or_default() {
+        if pane.session.as_str() != session || Some(pane.pane_id.as_str()) == worker_pane {
+            continue;
+        }
+        let target = crate::transport::Target::Pane(pane.pane_id);
+        let payload = crate::transport::InjectPayload::Text(text.to_string());
+        let _ = crate::transport::Transport::inject(&backend, &target, &payload, crate::transport::Key::Enter, true);
+    }
+}
+
 fn fake_envelope(
     workspace: &Path,
     agent_id: &str,

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

@@ -1,8 +1,9 @@
 //! leader::start — leader_start_plan / start_leader / leader_session_name(派生 tmux session 名)。
 
 use std::collections::BTreeMap;
+use std::io::IsTerminal;
 use std::path::Path;
-use std::process::Command;
+use std::process::{Command, Stdio};
 
 use crate::provider::{get_adapter, Provider};
 use crate::tmux_backend::TmuxBackend;
@@ -12,7 +13,10 @@ use super::helpers::{
     provider_wire, resolve_workspace_for_hash, sanitize_session_folder, sha1_hex_prefix,
 };
 use super::owner_bind::leader_identity_context;
-use super::{LeaderError, LeaderStartMode, LeaderStartPlan};
+use super::{
+    LeaderError, LeaderLaunchOutcome, LeaderLaunchSocket, LeaderLaunchStatus, LeaderStartMode,
+    LeaderStartPlan,
+};
 
 // ── leader::start — leader_start_plan / start_leader / session 名 ──
 
@@ -27,10 +31,14 @@ pub fn leader_start_plan(
     attach_session: Option<&SessionName>,
 ) -> Result<LeaderStartPlan, LeaderError> {
     if attach_session.is_some() && !confirm_attach {
-        return Err(LeaderError::Start("--attach-session requires --confirm".to_string()));
+        return Err(LeaderError::Start(
+            "--attach-session requires --confirm".to_string(),
+        ));
     }
     if attach_existing && !confirm_attach {
-        return Err(LeaderError::Start("attach existing leader session requires confirm".to_string()));
+        return Err(LeaderError::Start(
+            "attach existing leader session requires confirm".to_string(),
+        ));
     }
     let adapter = get_adapter(provider);
     if !adapter.is_installed() {
@@ -65,7 +73,10 @@ pub fn leader_start_plan(
         LeaderStartMode::NewTmuxSession
     };
     let mut leader_env = BTreeMap::new();
-    leader_env.insert("TEAM_AGENT_LEADER_PROVIDER".to_string(), provider_wire(provider).to_string());
+    leader_env.insert(
+        "TEAM_AGENT_LEADER_PROVIDER".to_string(),
+        provider_wire(provider).to_string(),
+    );
     leader_env.insert(
         "TEAM_AGENT_LEADER_SESSION_UUID".to_string(),
         identity.leader_session_uuid.as_str().to_string(),
@@ -78,8 +89,18 @@ pub fn leader_start_plan(
         "TEAM_AGENT_WORKSPACE".to_string(),
         identity.workspace_abspath.to_string_lossy().into_owned(),
     );
-    leader_env.insert("TEAM_AGENT_TEAM_ID".to_string(), identity.team_id.as_str().to_string());
-    let argv = start_argv(mode, provider, provider_args, workspace, session_name.as_ref(), &leader_env)?;
+    leader_env.insert(
+        "TEAM_AGENT_TEAM_ID".to_string(),
+        identity.team_id.as_str().to_string(),
+    );
+    let argv = start_argv(
+        mode,
+        provider,
+        provider_args,
+        workspace,
+        session_name.as_ref(),
+        &leader_env,
+    )?;
     let plan_env = if mode == LeaderStartMode::ExecProvider {
         merged_exec_env(&leader_env)
     } else {
@@ -89,6 +110,7 @@ pub fn leader_start_plan(
         mode,
         provider,
         workspace: resolve_workspace_for_hash(workspace),
+        socket: LeaderLaunchSocket::Workspace,
         session_name,
         argv,
         leader_env: plan_env,
@@ -123,7 +145,46 @@ pub fn start_leader(
             "session_name": plan.session_name.as_ref().map(|s| s.as_str().to_string()),
         }),
     )?;
-    Ok(())
+    execute_leader_plan(&plan, workspace).map(|_| ())
+}
+
+/// Execute a precomputed leader launch plan.
+///
+/// S0 exposes the seam and return model only. Lane 2 owns the real provider/tmux
+/// execution and workspace-socket enforcement.
+pub fn execute_leader_plan(
+    plan: &LeaderStartPlan,
+    workspace: &Path,
+) -> Result<LeaderLaunchOutcome, LeaderError> {
+    let mut argv = plan.argv.clone();
+    let detached = plan.mode == LeaderStartMode::NewTmuxSession
+        && !std::io::stdin().is_terminal()
+        && insert_detach_flag(&mut argv);
+    let status = run_leader_argv(&argv, &plan.leader_env)?;
+    let code = status.code();
+    if !status.success() {
+        return Err(LeaderError::Start(format!(
+            "leader launcher exited with status {}",
+            code.map(|c| c.to_string())
+                .unwrap_or_else(|| "signal".to_string())
+        )));
+    }
+    if detached {
+        Ok(LeaderLaunchOutcome {
+            status: LeaderLaunchStatus::Detached,
+            exit_code: code,
+            session_name: plan.session_name.clone(),
+            reason: None,
+        })
+    } else {
+        let _ = workspace;
+        Ok(LeaderLaunchOutcome {
+            status: LeaderLaunchStatus::Exited,
+            exit_code: code,
+            session_name: plan.session_name.clone(),
+            reason: None,
+        })
+    }
 }
 
 /// `leader_session_name`(card §48;`__init__.py:186`)。确定派生 tmux session 名
@@ -161,12 +222,13 @@ fn start_argv(
             let Some(session) = session_name else {
                 return Err(LeaderError::Start("attach session missing".to_string()));
             };
-            Ok(vec![
+            let argv = vec![
                 "tmux".to_string(),
                 "attach-session".to_string(),
                 "-t".to_string(),
                 session.as_str().to_string(),
-            ])
+            ];
+            Ok(TmuxBackend::argv_for_workspace(workspace, &argv))
         }
         LeaderStartMode::NewTmuxSession => {
             let Some(session) = session_name else {
@@ -185,7 +247,7 @@ fn start_argv(
                 exports.join(" "),
                 shell_join(&provider_argv)
             );
-            Ok(vec![
+            let argv = vec![
                 "tmux".to_string(),
                 "new-session".to_string(),
                 "-s".to_string(),
@@ -197,11 +259,42 @@ fn start_argv(
                 "sh".to_string(),
                 "-lc".to_string(),
                 shell,
-            ])
+            ];
+            Ok(TmuxBackend::argv_for_workspace(workspace, &argv))
         }
     }
 }
 
+fn insert_detach_flag(argv: &mut Vec<String>) -> bool {
+    if argv.iter().any(|arg| arg == "-d") {
+        return false;
+    }
+    let Some(pos) = argv.iter().position(|arg| arg == "new-session") else {
+        return false;
+    };
+    argv.insert(pos + 1, "-d".to_string());
+    true
+}
+
+fn run_leader_argv(
+    argv: &[String],
+    env: &BTreeMap<String, String>,
+) -> Result<std::process::ExitStatus, LeaderError> {
+    let Some(program) = argv.first() else {
+        return Err(LeaderError::Start(
+            "leader launch argv is empty".to_string(),
+        ));
+    };
+    let mut child = Command::new(program)
+        .args(argv.iter().skip(1))
+        .envs(env)
+        .stdin(Stdio::inherit())
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit())
+        .spawn()?;
+    child.wait().map_err(LeaderError::Io)
+}
+
 fn ensure_tmux_installed() -> Result<(), LeaderError> {
     match Command::new("tmux").arg("-V").output() {
         Ok(output) if output.status.success() => Ok(()),
@@ -246,25 +339,30 @@ fn leader_export_assignments(leader_env: &BTreeMap<String, String>) -> Vec<Strin
 
 fn merged_exec_env(leader_env: &BTreeMap<String, String>) -> BTreeMap<String, String> {
     let mut env: BTreeMap<String, String> = std::env::vars().collect();
-    env.extend(leader_env.iter().map(|(key, value)| (key.clone(), value.clone())));
+    env.extend(
+        leader_env
+            .iter()
+            .map(|(key, value)| (key.clone(), value.clone())),
+    );
     env
 }
 
 fn shell_join(args: &[String]) -> String {
-    args.iter().map(|arg| shlex_quote(arg)).collect::<Vec<_>>().join(" ")
+    args.iter()
+        .map(|arg| shlex_quote(arg))
+        .collect::<Vec<_>>()
+        .join(" ")
 }
 
 fn shlex_quote(raw: &str) -> String {
     if !raw.is_empty()
-        && raw
-            .bytes()
-            .all(|b| {
-                b.is_ascii_alphanumeric()
-                    || matches!(
-                        b,
-                        b'@' | b'%' | b'_' | b'+' | b'=' | b':' | b',' | b'.' | b'/' | b'-'
-                    )
-            })
+        && raw.bytes().all(|b| {
+            b.is_ascii_alphanumeric()
+                || matches!(
+                    b,
+                    b'@' | b'%' | b'_' | b'+' | b'=' | b':' | b',' | b'.' | b'/' | b'-'
+                )
+        })
     {
         raw.to_string()
     } else {

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

@@ -151,6 +151,24 @@ pub enum LeaderStartMode {
     AttachExisting,
 }
 
+/// Leader launcher tmux/socket selection. Managed launcher sessions must use the
+/// workspace tmux socket, never the user's default tmux server.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum LeaderLaunchSocket {
+    Workspace,
+}
+
+/// Execution status for a leader launch plan. `NotStarted` is intentionally
+/// distinct so JSON callers cannot report `ok:true` for an unexecuted launcher.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum LeaderLaunchStatus {
+    Exited,
+    Detached,
+    NotStarted,
+}
+
 /// 全部 leader 审计事件名(card §34)。§3 typed event kinds + §40 JSON 名与 Python
 /// **字节级一致**。映射到 [`LeaderEvent::name`] 返回 `EventLog::write` 用的精确字符串。
 /// (既有 `EventLog::write(&str, Value)` 仍吃裸字符串;此 enum 是 type-safe 名表,
@@ -200,7 +218,9 @@ impl LeaderEvent {
             Self::ReceiverStateDivergenceRepaired => "leader_receiver.state_divergence_repaired",
             Self::ReceiverFirstTimeEnvSeeded => "leader_receiver.first_time_env_seeded",
             Self::ReceiverAutobindSkipped => "leader_receiver.autobind_skipped",
-            Self::ReceiverRequeuedExhaustedWatchers => "leader_receiver.requeued_exhausted_watchers",
+            Self::ReceiverRequeuedExhaustedWatchers => {
+                "leader_receiver.requeued_exhausted_watchers"
+            }
             Self::ReceiverAmbiguousCandidates => "leader_receiver.ambiguous_candidates",
             Self::ReceiverClaimRequeue => "leader_receiver.claim_requeue",
             Self::ReceiverClaimLeaderNotification => "leader_receiver.claim_leader_notification",
@@ -307,6 +327,7 @@ pub struct LeaderStartPlan {
     pub mode: LeaderStartMode,
     pub provider: Provider,
     pub workspace: PathBuf,
+    pub socket: LeaderLaunchSocket,
     pub session_name: Option<SessionName>,
     /// 要 exec 的 argv(provider argv 或 tmux argv)。
     pub argv: Vec<String>,
@@ -317,6 +338,28 @@ pub struct LeaderStartPlan {
     pub detached: bool,
 }
 
+/// Result of executing a [`LeaderStartPlan`]. Interactive launches should carry
+/// the provider/tmux process exit code; detached launches carry the managed
+/// session when known.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct LeaderLaunchOutcome {
+    pub status: LeaderLaunchStatus,
+    pub exit_code: Option<i32>,
+    pub session_name: Option<SessionName>,
+    pub reason: Option<String>,
+}
+
+impl LeaderLaunchOutcome {
+    pub fn not_started(reason: impl Into<String>) -> Self {
+        Self {
+            status: LeaderLaunchStatus::NotStarted,
+            exit_code: None,
+            session_name: None,
+            reason: Some(reason.into()),
+        }
+    }
+}
+
 /// idle-takeover 的 node 分类行(`build_idle_nodes` / `_leader_node` 产物)。
 /// **bug-085**:`state` 用 `TurnState`(穷尽,`Unknown` 不当 idle);`rollout_path` `Option`。
 #[derive(Debug, Clone, PartialEq, Eq)]

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

@@ -55,6 +55,8 @@ pub mod message_store;
 // step 8 (provider) — ProviderAdapter trait + typed provider/turn-state/liveness 等(ROUND-0 骨架;
 // fn body unimplemented!(),P2 porter 落实现)。MUST-NOT-13:provider 调用全走 trait。
 pub mod provider;
+pub mod session_capture;
+pub(crate) mod os_probe;
 
 // step 9 (transport) — Transport trait(控制面)+ Target/PaneId/InjectReport 等(ROUND-0 骨架;
 // fn body unimplemented!(),P2 porter 落实现)。tmux/WezTerm/ConPTY 三后端。
@@ -66,6 +68,7 @@ pub mod transport;
 pub mod leader;
 pub mod messaging;
 pub mod coordinator;
+pub mod diagnose;
 
 // step 13-15 (lifecycle/mcp_server/cli/packaging) — ROUND-0.5b behavioral-rich 骨架(entry-fn 签名 +
 // 富返回类型,fn body unimplemented!(),P2 porter 落实现)。lifecycle=quick-start/restart/display;