@team-agent/installer 0.5.52 → 0.5.53

package/crates/team-agent/src/messaging/leader_receiver.rs

@@ -258,8 +258,7 @@ pub fn deliver_to_leader_fallback_pane(
         attempt_payload.clone(),
     )?;
 
-    let Some(pane_id) = pane_id.filter(|pane| !pane.is_empty() && pane != "__team_agent_unbound__")
-    else {
+    let Some(receiver) = leader_receiver_record(state) else {
         let failed = serde_json::json!({
             "message_id": message_id,
             "result_id": result_id,
@@ -267,7 +266,7 @@ pub fn deliver_to_leader_fallback_pane(
             "pane_id": null,
             "primary_error": primary_error,
             "delivered_via": "fallback_pane",
-            "reason": "no_bound_pane",
+            "reason": "no_bound_receiver",
         });
         event_log.write("leader_receiver.fallback_pane_failed", failed)?;
         return Ok(DeliveryOutcome {
@@ -283,7 +282,6 @@ pub fn deliver_to_leader_fallback_pane(
     };
 
     let rendered = render_fallback_pane_message(content, message_id, primary_error);
-    let target = Target::Pane(PaneId::new(&pane_id));
     let payload = InjectPayload::Text(rendered);
     // 0.5.5 gate054 cross-team notify boundary: when the leader receiver
     // has a recorded `tmux_socket` (canonical), that socket is a HARD
@@ -301,25 +299,63 @@ pub fn deliver_to_leader_fallback_pane(
     // stays pending in the store, coordinator surfaces the pending
     // notification via status/monitor, and no cross-server injection is
     // attempted.
-    let inject_result: Result<InjectReport, TransportError> = match leader_tmux_socket(state) {
-        Some(socket) => {
-            let backend = crate::transport_factory::tmux_endpoint_transport(socket);
-            backend.inject(&target, &payload, Key::Enter, true)
-        }
-        None => {
-            // No socket recorded → legacy (pre-0.5) shape where the receiver
-            // was implicitly bound to the workspace-canonical tmux server.
-            // Keep the workspace→default chain here (single team assumption)
-            // but never mix it with a recorded-socket team.
-            let backend = crate::transport_factory::tmux_workspace_transport(workspace);
-            backend
-                .inject(&target, &payload, Key::Enter, true)
-                .or_else(|_| {
-                    let backend = crate::transport_factory::tmux_default_transport();
-                    backend.inject(&target, &payload, Key::Enter, true)
-                })
+    let socket_bound = leader_tmux_socket(state).is_some();
+    let transports: Vec<Box<dyn Transport>> = match leader_tmux_socket(state) {
+        Some(socket) => vec![Box::new(crate::transport_factory::tmux_endpoint_transport(
+            socket,
+        ))],
+        None => vec![
+            Box::new(crate::transport_factory::tmux_workspace_transport(
+                workspace,
+            )),
+            Box::new(crate::transport_factory::tmux_default_transport()),
+        ],
+    };
+    let mut resolved = None;
+    let mut refusal = "leader channel unavailable".to_string();
+    for transport in transports {
+        match super::leader_channel::resolve_live_leader_channel(
+            workspace,
+            receiver,
+            transport.as_ref(),
+        ) {
+            super::leader_channel::LeaderChannelResolution::Live(
+                super::leader_channel::LiveLeaderChannel::DirectTmux(channel),
+            ) => {
+                resolved = Some((transport, channel));
+                break;
+            }
+            other => refusal = format!("{other:?}"),
         }
+    }
+    let Some((transport, channel)) = resolved else {
+        event_log.write(
+            "leader_receiver.fallback_pane_failed",
+            serde_json::json!({
+                "message_id": message_id,
+                "result_id": result_id,
+                "owner_team_id": owner_team_id,
+                "pane_id": pane_id,
+                "primary_error": primary_error,
+                "delivered_via": "fallback_pane",
+                "socket_bound": socket_bound,
+                "reason": refusal,
+            }),
+        )?;
+        return Ok(DeliveryOutcome {
+            ok: false,
+            status: DeliveryStatus::Blocked,
+            message_status: MessageStatusShadow("blocked".to_string()),
+            message_id: Some(message_id.to_string()),
+            verification: Some("run team-agent claim-leader or team-agent takeover".to_string()),
+            stage: None,
+            reason: Some(DeliveryRefusal::LeaderNotAttached),
+            channel: Some("rebind_required".to_string()),
+        });
     };
+    let target = Target::Pane(PaneId::new(channel.pane_id));
+    let inject_result: Result<InjectReport, TransportError> =
+        transport.inject(&target, &payload, Key::Enter, true);
 
     match inject_result {
         Ok(report) => {
@@ -486,6 +522,17 @@ fn leader_record_field<'a>(state: &'a Value, field: &str) -> Option<&'a Value> {
         .or_else(|| receiver_or_owner_field(state, "team_owner", field))
 }
 
+fn leader_receiver_record(state: &Value) -> Option<&Value> {
+    state.get("leader_receiver").or_else(|| {
+        let active = state.get("active_team_key").and_then(Value::as_str)?;
+        state
+            .get("teams")
+            .and_then(Value::as_object)
+            .and_then(|teams| teams.get(active))
+            .and_then(|team| team.get("leader_receiver"))
+    })
+}
+
 fn owner_epoch_i64(state: &Value) -> Option<i64> {
     owner_epoch(state).and_then(|epoch| i64::try_from(epoch).ok())
 }

package/crates/team-agent/src/messaging/tests/runtime.rs

@@ -3221,30 +3221,41 @@ fn gate054_status_surfaces_pending_leader_notifications() {
 
 #[test]
 fn gate054_fallback_pane_grep_guard_no_cross_server_chain_when_socket_recorded() {
-    // Structural grep: the recorded-socket branch of the fallback inject
-    // chain must NOT compose the workspace or default tmux backends after
-    // the endpoint backend rejects. This is the byte-level fence against
-    // silent regression.
+    // Structural grep: the recorded-socket transport set must contain only
+    // the endpoint backend, while workspace/default transports remain in the
+    // no-socket arm. Physical injection must consume the pane returned by the
+    // shared resolver rather than rebuilding a target from state.
     let src = include_str!("../leader_receiver.rs");
-    let inject_start = src
-        .find("let inject_result: Result<InjectReport, TransportError>")
-        .expect("fallback inject chain must remain single-typed");
-    let inject_end = src[inject_start..]
-        .find("};\n\n    match inject_result")
-        .map(|off| inject_start + off + 2)
-        .expect("fallback inject chain must terminate before match");
-    let chain = &src[inject_start..inject_end];
-    // The socket-recorded arm is the `Some(socket) => {..}` block. It must
-    // NOT contain a workspace or default fallback.
-    let some_arm_start = chain.find("Some(socket) => {").expect("Some(socket) arm");
-    let some_arm_end = chain[some_arm_start..]
-        .find("None => {")
-        .map(|off| some_arm_start + off)
-        .expect("None arm must follow");
-    let some_arm = &chain[some_arm_start..some_arm_end];
+    let transports_start = src
+        .find("let transports: Vec<Box<dyn Transport>>")
+        .expect("fallback transport set must remain explicit");
+    let transports_end = src[transports_start..]
+        .find("let mut resolved")
+        .map(|off| transports_start + off)
+        .expect("transport selection must precede shared resolution");
+    let transports = &src[transports_start..transports_end];
+    let socket_arm_start = transports
+        .find("Some(socket) =>")
+        .expect("recorded-socket arm");
+    let socket_arm_end = transports[socket_arm_start..]
+        .find("None =>")
+        .map(|off| socket_arm_start + off)
+        .expect("no-socket arm must follow");
+    let socket_arm = &transports[socket_arm_start..socket_arm_end];
     assert!(
-        !some_arm.contains("tmux_workspace_transport")
-            && !some_arm.contains("tmux_default_transport"),
-        "0.5.5 gate054: socket-recorded fallback arm must not compose workspace/default backends; arm={some_arm}"
+        socket_arm.contains("tmux_endpoint_transport")
+            && !socket_arm.contains("tmux_workspace_transport")
+            && !socket_arm.contains("tmux_default_transport"),
+        "0.5.5 gate054: socket-recorded fallback arm must remain endpoint-only; arm={socket_arm}"
+    );
+    let no_socket_arm = &transports[socket_arm_end..];
+    assert!(
+        no_socket_arm.contains("tmux_workspace_transport")
+            && no_socket_arm.contains("tmux_default_transport"),
+        "0.5.5 gate054: workspace/default transports belong only to the no-socket arm; arm={no_socket_arm}"
+    );
+    assert!(
+        src.contains("let target = Target::Pane(PaneId::new(channel.pane_id));"),
+        "fallback injection must consume the shared resolver's typed channel"
     );
 }

package/crates/team-agent/src/provider/adapter.rs

@@ -301,14 +301,14 @@ impl ProviderAdapter for BasicProviderAdapter {
                 native_mcp_config: false,
                 writes_global_settings: false,
             },
-            // Copilot(C-4-1 cr verdict):resume 走 --resume <sid>;**无 fork** 旗标,
-            // session-store 不支持 branched continuation → caps.fork=false 显式拒。
+            // Copilot resume 走 --resume <sid>;store fork 在隔离 COPILOT_HOME
+            // 复制并重键 session backing 后以 --resume <new sid> 启动。
             // native_mcp_config=true(`--additional-mcp-config` 接 inline JSON 或 @file);
             // writes_global_settings=false(session 走 --session-id 预定 UUID,不污染
             // ~/.copilot/mcp-config.json,help 原文 "augments config for this session")。
             Provider::Copilot => ProviderCaps {
                 resume: true,
-                fork: false,
+                fork: true,
                 native_mcp_config: true,
                 writes_global_settings: false,
             },
@@ -829,10 +829,9 @@ impl ProviderAdapter for BasicProviderAdapter {
                 argv.push("--fork-session".to_string());
                 Ok(argv)
             }
-            // C-4-2 cr verdict: copilot 无 fork 旗标 + session-store 不支持 branched
-            // continuation → 显式 CapabilityUnsupported,**绝不** silent fallback 到
-            // restart-from-scratch(MUST-NOT-13 诚实)。本分支理论上不可达(caps.fork=false
-            // 已在 fork_with_context 入口拦截,line 582),保留作 totality 守护。
+            // Context-free adapter calls cannot materialize the Copilot store fork.
+            // The lifecycle path uses `fork_plan`, which receives the prepared isolated
+            // backing; never degrade this context-free call to a fresh spawn.
             Provider::Copilot => Err(ProviderError::CapabilityUnsupported(
                 "copilot CLI 无 fork 旗标,session-store 不支持 branched continuation".to_string(),
             )),
@@ -858,11 +857,11 @@ impl ProviderAdapter for BasicProviderAdapter {
                         provider_wire(self.provider)
                     )));
                 }
-                let Some(session_id) = session_id else {
+                if session_id.is_none() {
                     return Err(ProviderError::ResumeUnavailable(
                         "fork requires session_id".to_string(),
                     ));
-                };
+                }
                 let expected = next_session_token();
                 let managed = ctx
                     .profile_launch
@@ -881,11 +880,8 @@ impl ProviderAdapter for BasicProviderAdapter {
                     managed,
                     ctx.effort,
                 )?;
-                argv.push("--session-id".to_string());
-                argv.push(expected.clone());
                 argv.push("--resume".to_string());
-                argv.push(session_id.as_str().to_string());
-                argv.push("--fork-session".to_string());
+                argv.push(expected.clone());
                 Ok(CommandPlan {
                     argv,
                     expected_session_id: Some(SessionId::new(expected)),
@@ -918,6 +914,51 @@ impl ProviderAdapter for BasicProviderAdapter {
                 argv.push(session_id.as_str().to_string());
                 Ok(CommandPlan::argv_only(argv))
             }
+            Provider::Copilot => {
+                if ctx.auth_mode == AuthMode::CompatibleApi {
+                    return Err(ProviderError::CapabilityUnsupported(
+                        "copilot does not support session fork in compatible_api mode".to_string(),
+                    ));
+                }
+                let profile = ctx.profile_launch.ok_or_else(|| {
+                    ProviderError::Command(
+                        "copilot fork requires a prepared provider profile".to_string(),
+                    )
+                })?;
+                let expected = profile
+                    .env_overlay
+                    .get("TEAM_AGENT_INTERNAL_COPILOT_FORK_SESSION_ID")
+                    .filter(|value| !value.is_empty())
+                    .map(SessionId::new)
+                    .ok_or_else(|| {
+                        ProviderError::Command(
+                            "copilot fork session backing was not materialized".to_string(),
+                        )
+                    })?;
+                let root = profile
+                    .env_overlay
+                    .get("COPILOT_HOME")
+                    .filter(|value| !value.is_empty())
+                    .map(PathBuf::from)
+                    .ok_or_else(|| {
+                        ProviderError::Command("copilot fork root was not materialized".to_string())
+                    })?;
+                let mut argv = copilot_base_command_resume(
+                    ctx.auth_mode,
+                    ctx.mcp_config,
+                    ctx.system_prompt,
+                    ctx.model,
+                    ctx.tools,
+                );
+                argv.push("--resume".to_string());
+                argv.push(expected.as_str().to_string());
+                Ok(CommandPlan {
+                    argv,
+                    expected_session_id: Some(expected),
+                    provider_projects_root: Some(root),
+                    managed_mcp_config: profile.managed_mcp_config,
+                })
+            }
             _ => self
                 .fork_with_context(
                     session_id,

package/crates/team-agent/src/provider/adapters/claude_fork.rs

@@ -0,0 +1,122 @@
+use std::path::{Path, PathBuf};
+
+use crate::provider::{ProviderError, SessionId};
+
+#[derive(Debug)]
+pub(crate) struct ClaudeForkMaterialization {
+    path: PathBuf,
+    keep: bool,
+}
+
+impl ClaudeForkMaterialization {
+    pub(crate) fn path(&self) -> &Path {
+        &self.path
+    }
+
+    pub(crate) fn keep(&mut self) {
+        self.keep = true;
+    }
+}
+
+impl Drop for ClaudeForkMaterialization {
+    fn drop(&mut self) {
+        if !self.keep {
+            let _ = std::fs::remove_file(&self.path);
+        }
+    }
+}
+
+pub(crate) fn materialize_claude_fork(
+    source_path: &Path,
+    source_session_id: &SessionId,
+    target_session_id: &SessionId,
+) -> Result<ClaudeForkMaterialization, ProviderError> {
+    let parent = source_path.parent().ok_or_else(|| {
+        ProviderError::Io(format!(
+            "claude source backing has no parent: {}",
+            source_path.display()
+        ))
+    })?;
+    let target_path = parent.join(format!("{}.jsonl", target_session_id.as_str()));
+    if target_path.exists() {
+        return Err(ProviderError::Io(format!(
+            "claude fork destination already exists: {}",
+            target_path.display()
+        )));
+    }
+    let source = std::fs::read_to_string(source_path)
+        .map_err(|error| ProviderError::Io(error.to_string()))?;
+    let rewritten = source.replace(source_session_id.as_str(), target_session_id.as_str());
+    validate_jsonl(&rewritten)?;
+    let temp = parent.join(format!(
+        ".{}.tmp-{}",
+        target_session_id.as_str(),
+        std::process::id()
+    ));
+    let result = std::fs::write(&temp, rewritten)
+        .and_then(|_| std::fs::rename(&temp, &target_path))
+        .map_err(|error| ProviderError::Io(error.to_string()));
+    if let Err(error) = result {
+        let _ = std::fs::remove_file(&temp);
+        return Err(error);
+    }
+    Ok(ClaudeForkMaterialization {
+        path: target_path,
+        keep: false,
+    })
+}
+
+fn validate_jsonl(text: &str) -> Result<(), ProviderError> {
+    let mut rows = 0_usize;
+    for (index, line) in text.lines().enumerate() {
+        if line.trim().is_empty() {
+            continue;
+        }
+        serde_json::from_str::<serde_json::Value>(line).map_err(|error| {
+            ProviderError::Io(format!(
+                "claude fork source has invalid JSONL at line {}: {error}",
+                index + 1
+            ))
+        })?;
+        rows += 1;
+    }
+    if rows == 0 {
+        return Err(ProviderError::Io(
+            "claude fork source backing has no JSONL records".to_string(),
+        ));
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn snapshot_rekeys_every_record_and_preserves_source() {
+        let dir = std::env::temp_dir().join(format!("ta-claude-fork-copy-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        let source_id = SessionId::new("11111111-1111-4111-8111-111111111111");
+        let target_id = SessionId::new("22222222-2222-4222-8222-222222222222");
+        let source_path = dir.join(format!("{}.jsonl", source_id.as_str()));
+        let source = format!(
+            "{{\"sessionId\":\"{}\"}}\n{{\"payload\":{{\"session_id\":\"{}\"}}}}\n",
+            source_id.as_str(),
+            source_id.as_str()
+        );
+        std::fs::write(&source_path, &source).unwrap();
+
+        let mut materialized =
+            materialize_claude_fork(&source_path, &source_id, &target_id).unwrap();
+        let target_path = dir.join(format!("{}.jsonl", target_id.as_str()));
+        let target = std::fs::read_to_string(&target_path).unwrap();
+        assert!(!target.contains(source_id.as_str()));
+        assert!(target.contains(target_id.as_str()));
+        assert_eq!(std::fs::read_to_string(&source_path).unwrap(), source);
+        materialized.keep();
+        drop(materialized);
+        assert!(target_path.is_file());
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+}