@team-agent/installer 0.5.58 → 0.5.60

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.58"
+version = "0.5.60"
 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.58"
+version = "0.5.60"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -3,7 +3,7 @@
 
 use super::spec::{command_spec, CommandKind, CommandTier, ALL_DISPATCH_KINDS, COMMAND_SPECS};
 use super::*;
-use std::io::Write as _;
+use std::io::{ErrorKind, Write as _};
 
 /// `emit`(`helpers.py:12-23`):`--json`→`json.dumps(indent=2, ensure_ascii=False, sort_keys=True)`;
 /// 否则 dict 逐键 `key: value`(嵌套 dict/list 内联 compact json,`ensure_ascii=False`)、非 dict 直接 print。
@@ -77,12 +77,40 @@ pub fn run(argv: &[String], cwd: &Path) -> ExitCode {
 /// Print a handler's CmdResult to stdout (emit formats json/human), then surface its exit code.
 /// (parser.py: `print(emit(result, as_json))` then the ok→exit mapping.)
 fn emit_result(r: CmdResult) -> ExitCode {
+    let persisted_message_id = match &r.output {
+        CmdOutput::Json(value) => value
+            .get("message_id")
+            .and_then(Value::as_str)
+            .map(ToString::to_string),
+        _ => None,
+    };
     if let Some(text) = emit(&r.output, r.as_json) {
-        println!("{text}");
+        if let Err(error) = write_stdout_line(&text) {
+            if let Some(message_id) = persisted_message_id {
+                let stderr = std::io::stderr();
+                let mut stderr = stderr.lock();
+                let _ = writeln!(
+                    stderr,
+                    "stdout unavailable after durable send; persisted_message_id={message_id}"
+                );
+            }
+            return if error.kind() == ErrorKind::BrokenPipe {
+                r.exit
+            } else {
+                ExitCode::Error
+            };
+        }
     }
     r.exit
 }
 
+fn write_stdout_line(text: &str) -> std::io::Result<()> {
+    let stdout = std::io::stdout();
+    let mut stdout = stdout.lock();
+    stdout.write_all(text.as_bytes())?;
+    stdout.write_all(b"\n")
+}
+
 fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliError> {
     let Some(spec) = command_spec(command) else {
         return Ok(emit_unknown_subcommand_usage(command));

package/crates/team-agent/src/cli/send/mailbox.rs

@@ -37,8 +37,8 @@ pub(super) fn maybe_enqueue_offline_leader_mailbox(
         Ok(s) => s,
         Err(_) => return Ok(None),
     };
-    let team_alive = target_team_is_alive_for_mailbox(&state, &team_key);
-    if !team_alive {
+    let attachment_history = target_team_mailbox_history(&state, &team_key);
+    if attachment_history == MailboxAttachmentHistory::NotEligible {
         return Ok(None);
     }
     let event_log = crate::event_log::EventLog::new(&target_workspace);
@@ -53,47 +53,90 @@ pub(super) fn maybe_enqueue_offline_leader_mailbox(
     )
     .map_err(|e| CliError::Runtime(e.to_string()))?;
     let message_id = outcome.message_id.clone().unwrap_or_else(|| "".to_string());
-    Ok(Some(json!({
-        "ok": true,
-        "status": "queued_until_leader_attach",
-        "message_status": "queued_until_leader_attach",
-        "channel": "leader_mailbox",
-        "delivered": false,
-        "to_name": to_name,
-        "target_workspace": target_workspace.display().to_string(),
-        "team_key": team_key,
-        "recipient": "leader",
-        "leader_attached": false,
-        "message_id": message_id,
-    })))
+    let receipt = match attachment_history {
+        MailboxAttachmentHistory::NeverAttached => json!({
+            "ok": true,
+            "status": "deferred",
+            "deferred_reason": "never_attached",
+            "message_status": "queued_until_leader_attach",
+            "channel": "leader_mailbox",
+            "delivered": false,
+            "to_name": to_name,
+            "target_workspace": target_workspace.display().to_string(),
+            "team_key": team_key,
+            "recipient": "leader",
+            "leader_attached": false,
+            "message_id": message_id,
+        }),
+        MailboxAttachmentHistory::PreviouslyAttached => json!({
+            "ok": true,
+            "status": "queued_until_leader_attach",
+            "deferred_reason": "leader_currently_unattached",
+            "message_status": "queued_until_leader_attach",
+            "channel": "leader_mailbox",
+            "delivered": false,
+            "to_name": to_name,
+            "target_workspace": target_workspace.display().to_string(),
+            "team_key": team_key,
+            "recipient": "leader",
+            "leader_attached": false,
+            "message_id": message_id,
+        }),
+        MailboxAttachmentHistory::NotEligible => unreachable!("refused before persistence"),
+    };
+    Ok(Some(receipt))
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum MailboxAttachmentHistory {
+    PreviouslyAttached,
+    NeverAttached,
+    NotEligible,
 }
 
-/// Positive-source liveness heuristic per offline-mailbox-toname-design.md §4:
+/// Positive-source mailbox eligibility per offline-mailbox-toname-design.md §4:
 /// - target workspace has state and the team key is present + not archived/down;
-/// - AND at least one live tmux fact — a persisted `session_name` OR any
-///   agent with a recorded pane on the recorded socket.
+/// - AND a persisted session name establishes a durable replay target;
+/// - a persisted receiver attachment timestamp distinguishes previously attached
+///   teams from teams whose first successful leader attachment is still pending.
 ///
 /// We deliberately do NOT poll coordinator health here — enqueuing is
 /// safe even when the coordinator is transiently down; attach-leader
 /// itself replays via `requeue_blocked_leader_messages` regardless.
-pub(super) fn target_team_is_alive_for_mailbox(state: &Value, team_key: &str) -> bool {
+fn target_team_mailbox_history(state: &Value, team_key: &str) -> MailboxAttachmentHistory {
     let team = state
         .get("teams")
         .and_then(|v| v.as_object())
         .and_then(|teams| teams.get(team_key));
     let Some(team) = team else {
-        return false;
+        return MailboxAttachmentHistory::NotEligible;
     };
     let status = team
         .get("status")
         .and_then(|v| v.as_str())
         .unwrap_or("alive");
     if matches!(status, "archived" | "down" | "stopped") {
-        return false;
+        return MailboxAttachmentHistory::NotEligible;
     }
-    // A recorded session_name is enough — target's coordinator/attach
-    // path will re-verify tmux presence when the replay fires.
-    team.get("session_name")
+    let has_session = team
+        .get("session_name")
         .and_then(|v| v.as_str())
-        .is_some_and(|s| !s.is_empty())
+        .is_some_and(|s| !s.is_empty());
+    if !has_session {
+        return MailboxAttachmentHistory::NotEligible;
+    }
+    let previously_attached = team
+        .get("leader_receiver")
+        .and_then(Value::as_object)
+        .is_some_and(|receiver| {
+            receiver
+                .get("attached_at")
+                .and_then(Value::as_str)
+                .is_some_and(|value| !value.is_empty())
+        });
+    if previously_attached {
+        MailboxAttachmentHistory::PreviouslyAttached
+    } else {
+        MailboxAttachmentHistory::NeverAttached
+    }
 }

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

@@ -155,7 +155,7 @@ pub(crate) struct CommandSpec {
 #[rustfmt::skip]
 pub(crate) const COMMAND_SPECS: &[CommandSpec] = &[
     CommandSpec { name: "quick-start", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::Dispatch(DispatchKind::QuickStart), summary: "start or attach a team from TEAM.md", usage: "usage: team-agent quick-start [TEAMDIR] [--workspace WORKSPACE] [--name NAME] [--team-id TEAM|--team TEAM] [--yes] [--no-display] [--backend tmux|conpty] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: None, action: None, governance: None },
-    CommandSpec { name: "send", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Send), summary: "persist a message for a logical recipient", usage: "usage: team-agent send TO MESSAGE... [--workspace WORKSPACE] [--team TEAM] [--presentation-sink leader|casefile|silent --message-class CLASS [--case-id CASE]] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: Some("next compatibility release"), action: Some("use positional logical TO and the returned message id"), governance: None },
+    CommandSpec { name: "send", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Send), summary: "persist a message for an in-team short name or fully-qualified logical recipient", usage: "usage: team-agent send TO MESSAGE... [--workspace WORKSPACE] [--team TEAM] [--presentation-sink leader|casefile|silent --message-class CLASS [--case-id CASE]] [--json]\nTO forms are co-equal: an in-team short name (for example `team-agent send reviewer \"Review\"`) or `<workspace>::<team>/<agent>`.", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: Some("next compatibility release"), action: Some("use positional logical TO and the returned message id"), governance: None },
     CommandSpec { name: "status", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Status), summary: "show current team status", usage: "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "collect", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Collect), summary: "collect reported results", usage: "usage: team-agent collect [--workspace WORKSPACE] [--team TEAM] [--result-file FILE] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "restart", tier: CommandTier::Core, category: CommandCategory::TeamLifecycle, kind: CommandKind::Dispatch(DispatchKind::Restart), summary: "restart the selected team", usage: "usage: team-agent restart [WORKSPACE] [--team TEAM] [--allow-fresh] [--session-converge-deadline SECONDS] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: None, action: None, governance: None },

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

@@ -269,12 +269,17 @@ impl Coordinator {
         }
 
         self.record_step("capture_missing");
-        if let Err(error) = self.capture_missing_sessions(&mut state, &event_log) {
-            let _ = event_log.write(
-                "coordinator.tick.capture_missing_failed",
-                serde_json::json!({"error": error.to_string()}),
-            );
-        }
+        let pending_context_fork_audits =
+            match self.capture_missing_sessions(&mut state, &event_log) {
+                Ok(audits) => audits,
+                Err(error) => {
+                    let _ = event_log.write(
+                        "coordinator.tick.capture_missing_failed",
+                        serde_json::json!({"error": error.to_string()}),
+                    );
+                    Vec::new()
+                }
+            };
 
         // Slice 1 energy gate: one pane snapshot per tick feeds probe eligibility,
         // health sync, and abnormal-exit detection. Missing panes are filtered
@@ -454,6 +459,14 @@ impl Coordinator {
                 collections,
             ));
         }
+        for context_fork in &pending_context_fork_audits {
+            context_fork.write_audit(&event_log).map_err(|error| {
+                eprintln!(
+                    "[coordinator] context_fork audit publish failed after state commit: {error}"
+                );
+                TickError::EventLog(error)
+            })?;
+        }
 
         // 0.5.36 (`.team/artifacts/supermarket-api-error-recovery-locate.md` §7.3):
         // post-save recovery step. Reloads fresh state, consumes due
@@ -487,7 +500,7 @@ impl Coordinator {
         &self,
         state: &mut Value,
         event_log: &EventLog,
-    ) -> Result<(), TickError> {
+    ) -> Result<Vec<crate::lifecycle::launch::ContextForkFinalized>, TickError> {
         let report = crate::session_capture::capture_missing_provider_sessions_once(
             state,
             &mut |provider| self.provider_registry.adapter_for(provider),
@@ -651,7 +664,7 @@ impl Coordinator {
                 }),
             )?;
         }
-        Ok(())
+        Ok(report.context_forks)
     }
 
     fn sync_agent_health(

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

@@ -0,0 +1,58 @@
+use super::super::*;
+
+pub(super) struct CompleteForkInput<'a> {
+    pub workspace: &'a Path,
+    pub team_key: &'a str,
+    pub agent_id: &'a AgentId,
+    pub spawn: &'a crate::transport::SpawnResult,
+    pub window: &'a WindowName,
+    pub transport: &'a dyn Transport,
+    pub session_name: &'a SessionName,
+    pub mcp_config_path: &'a Path,
+    pub profile_launch: &'a crate::provider::ProviderProfileLaunch,
+    pub materialized_role: &'a mut MaterializedRole,
+    pub claude_fork:
+        &'a mut Option<crate::provider::adapters::claude_fork::ClaudeForkMaterialization>,
+    pub copilot_fork:
+        &'a mut Option<crate::provider::adapters::copilot_fork::CopilotForkMaterialization>,
+}
+
+pub(super) fn complete_fork(input: CompleteForkInput<'_>) -> Result<bool, LifecycleError> {
+    if let Err(error) = verify_fork_registration(
+        input.workspace,
+        input.team_key,
+        input.agent_id,
+        input.spawn,
+        input.window,
+    ) {
+        rollback_fork_after_spawn(
+            input.workspace,
+            input.transport,
+            input.session_name,
+            input.window,
+            input.mcp_config_path,
+            input.agent_id,
+            input.profile_launch,
+            input.team_key,
+        );
+        return Err(error);
+    }
+    let coordinator_started = start_fork_coordinator(ForkCoordinatorInput {
+        workspace: input.workspace,
+        team_key: input.team_key,
+        agent_id: input.agent_id,
+        transport: input.transport,
+        session_name: input.session_name,
+        window: input.window,
+        mcp_config_path: input.mcp_config_path,
+        profile_launch: input.profile_launch,
+    })?;
+    input.materialized_role.keep();
+    if let Some(materialized) = input.claude_fork.as_mut() {
+        materialized.keep();
+    }
+    if let Some(materialized) = input.copilot_fork.as_mut() {
+        materialized.keep();
+    }
+    Ok(coordinator_started)
+}

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

@@ -1,16 +1,7 @@
 use super::*;
-use crate::lifecycle::lock::{acquire_agent_lifecycle_lock, LifecycleLockRequest};
 use crate::lifecycle::profile_launch::parse_provider;
-use crate::lifecycle::*;
-use crate::model::enums::{AuthMode, DisplayBackend, Provider, ProviderEffort};
-use crate::model::ids::AgentId;
-use crate::model::permissions::{self, AgentPermissionInput};
-use crate::model::yaml::{self, Value};
-use crate::state::persist::load_runtime_state;
-use crate::transport::{PaneId, SessionName, Target, Transport, WindowName};
-use std::collections::{BTreeMap, BTreeSet};
-use std::path::{Path, PathBuf};
-use std::process::Command;
+
+mod completion;
 
 pub fn fork_agent_with_transport(
     workspace: &Path,
@@ -239,6 +230,23 @@ pub fn fork_agent_with_transport(
         as_agent_id.as_str(),
         Some(&fork_team),
     );
+    let spawned_at = spawn_timestamp_for_agent(1);
+    let mut fork_backing = adapter
+        .materialize_fork_backing(
+            &source_backing,
+            &session_id,
+            source_agent_id.as_str(),
+            as_agent_id.as_str(),
+            &mut plan,
+        )
+        .map_err(|error| {
+            let _ = std::fs::write(&spec_path, text.as_bytes());
+            cleanup_fork_mcp_artifacts(&workspace, as_agent_id, &mcp_config_path, &profile_launch);
+            LifecycleError::Provider(error.to_string())
+        })?;
+    let mut expected_backing_path = fork_backing
+        .as_ref()
+        .map(|materialized| materialized.path().to_path_buf());
     if matches!(provider, Provider::Claude | Provider::ClaudeCode) {
         plan.provider_projects_root = source_backing.parent().map(Path::to_path_buf);
     }
@@ -248,12 +256,19 @@ pub fn fork_agent_with_transport(
         &plan,
         &source_backing,
         &session_id,
+        source_agent_id,
+        as_agent_id,
     )
     .map_err(|error| {
         let _ = std::fs::write(&spec_path, text.as_bytes());
         cleanup_fork_mcp_artifacts(&workspace, as_agent_id, &mcp_config_path, &profile_launch);
         error
     })?;
+    if expected_backing_path.is_none() {
+        expected_backing_path = claude_fork
+            .as_ref()
+            .map(|materialized| materialized.path().to_path_buf());
+    }
     // The framework-created Claude snapshot is only fork input, not provider
     // proof. Observe changes made after materialization so a spawn-only
     // provider cannot turn the copied source backing into a Verified result.
@@ -307,7 +322,6 @@ pub fn fork_agent_with_transport(
     // Release the metadata lock before per-seat provider convergence; finalize reacquires it.
     drop(_lock);
     let spawn_epoch = 1_u64;
-    let spawned_at = spawn_timestamp_for_agent(u32::try_from(spawn_epoch).unwrap_or(u32::MAX));
     let spawn_result = if session_live {
         transport.spawn_into_with_env_unset(
             &session_name,
@@ -343,6 +357,9 @@ pub fn fork_agent_with_transport(
             return Err(LifecycleError::Transport(error.to_string()));
         }
     };
+    if let Some(materialized) = fork_backing.as_mut() {
+        materialized.handoff();
+    }
     ensure_fork_spawn_live(ForkPostSpawnInput {
         workspace: &workspace,
         transport,
@@ -361,7 +378,8 @@ pub fn fork_agent_with_transport(
         &session_id,
         &plan,
         &backing_before,
-        claude_fork.as_ref().map(|materialized| materialized.path()),
+        expected_backing_path.as_deref(),
+        source_agent_id.as_str(),
         as_agent_id.as_str(),
         &workspace,
         &spawned_at,
@@ -414,7 +432,7 @@ pub fn fork_agent_with_transport(
         }
     };
     if let Some(context_proof) = context_proof.as_ref() {
-        if let Err(error) = finalize_fork_state(ForkFinalizeInput {
+        let finalized = match finalize_fork_state(ForkFinalizeInput {
             workspace: &workspace,
             team_key: &fork_team,
             source_agent_id,
@@ -430,51 +448,39 @@ pub fn fork_agent_with_transport(
             spawned_at: &spawned_at,
             spawn_epoch,
         }) {
-            rollback_fork_after_spawn(
-                &workspace,
-                transport,
-                &session_name,
-                &window,
-                &mcp_config_path,
-                as_agent_id,
-                &profile_launch,
-                &fork_team,
-            );
-            return Err(error);
-        }
-    }
-    if let Err(error) =
-        verify_fork_registration(&workspace, &fork_team, as_agent_id, &spawn, &window)
-    {
-        rollback_fork_after_spawn(
-            &workspace,
-            transport,
-            &session_name,
-            &window,
-            &mcp_config_path,
-            as_agent_id,
-            &profile_launch,
-            &fork_team,
-        );
-        return Err(error);
+            Ok(finalized) => finalized,
+            Err(error) => {
+                rollback_fork_after_spawn(
+                    &workspace,
+                    transport,
+                    &session_name,
+                    &window,
+                    &mcp_config_path,
+                    as_agent_id,
+                    &profile_launch,
+                    &fork_team,
+                );
+                return Err(error);
+            }
+        };
+        finalized
+            .write_audit(&crate::event_log::EventLog::new(&workspace))
+            .map_err(|error| LifecycleError::StatePersist(error.to_string()))?;
     }
-    let coordinator_started = start_fork_coordinator(ForkCoordinatorInput {
+    let coordinator_started = completion::complete_fork(completion::CompleteForkInput {
         workspace: &workspace,
         team_key: &fork_team,
         agent_id: as_agent_id,
+        spawn: &spawn,
+        window: &window,
         transport,
         session_name: &session_name,
-        window: &window,
         mcp_config_path: &mcp_config_path,
         profile_launch: &profile_launch,
+        materialized_role: &mut materialized_role,
+        claude_fork: &mut claude_fork,
+        copilot_fork: &mut copilot_fork,
     })?;
-    materialized_role.keep();
-    if let Some(materialized) = claude_fork.as_mut() {
-        materialized.keep();
-    }
-    if let Some(materialized) = copilot_fork.as_mut() {
-        materialized.keep();
-    }
     let backing_state = if context_proof.is_some() {
         ForkBackingState::Verified
     } else {