@team-agent/installer 0.5.2 → 0.5.4

package/crates/team-agent/src/state/projection.rs

@@ -17,6 +17,7 @@ use super::StateError;
 use crate::state::persist::{
     load_runtime_state, save_runtime_state_with_deleted_agents,
     save_runtime_state_with_lifecycle_topology_authority,
+    save_runtime_state_with_lifecycle_topology_authority_and_capture_backfill_skip,
     save_runtime_state_with_team_tombstone_lifecycle_topology_authority,
     save_runtime_state_with_team_tombstoned_agents,
 };
@@ -595,7 +596,7 @@ pub(crate) fn save_team_scoped_state_with_tombstone_lifecycle_topology_authority
     team_state: &Value,
     agent_ids: &[&str],
 ) -> Result<(), StateError> {
-    save_team_scoped_state_with_merge_options(workspace, team_state, &[], agent_ids, agent_ids)
+    save_team_scoped_state_with_merge_options(workspace, team_state, &[], agent_ids, &[], agent_ids)
 }
 
 pub(crate) fn save_team_scoped_state_with_lifecycle_topology_authority(
@@ -603,7 +604,23 @@ pub(crate) fn save_team_scoped_state_with_lifecycle_topology_authority(
     team_state: &Value,
     agent_ids: &[&str],
 ) -> Result<(), StateError> {
-    save_team_scoped_state_with_merge_options(workspace, team_state, &[], &[], agent_ids)
+    save_team_scoped_state_with_merge_options(workspace, team_state, &[], &[], &[], agent_ids)
+}
+
+pub(crate) fn save_team_scoped_state_with_lifecycle_topology_authority_and_capture_backfill_skip(
+    workspace: &Path,
+    team_state: &Value,
+    skip_capture_backfill_agent_ids: &[&str],
+    topology_agent_ids: &[&str],
+) -> Result<(), StateError> {
+    save_team_scoped_state_with_merge_options(
+        workspace,
+        team_state,
+        &[],
+        &[],
+        skip_capture_backfill_agent_ids,
+        topology_agent_ids,
+    )
 }
 
 fn save_team_scoped_state_with_merge_exceptions(
@@ -618,6 +635,7 @@ fn save_team_scoped_state_with_merge_exceptions(
         deleted_agent_ids,
         tombstoned_agent_ids,
         &[],
+        &[],
     )
 }
 
@@ -626,6 +644,7 @@ fn save_team_scoped_state_with_merge_options(
     team_state: &Value,
     deleted_agent_ids: &[&str],
     tombstoned_agent_ids: &[&str],
+    skip_capture_backfill_agent_ids: &[&str],
     topology_agent_ids: &[&str],
 ) -> Result<(), StateError> {
     let target_key = team_state_key(team_state);
@@ -669,12 +688,30 @@ fn save_team_scoped_state_with_merge_options(
                     topology_agent_ids,
                 );
             }
+            if !skip_capture_backfill_agent_ids.is_empty() {
+                return save_runtime_state_with_lifecycle_topology_authority_and_capture_backfill_skip(
+                    workspace,
+                    &merged,
+                    &target_key,
+                    skip_capture_backfill_agent_ids,
+                    topology_agent_ids,
+                );
+            }
             return save_runtime_state_with_lifecycle_topology_authority(
                 workspace,
                 &merged,
                 topology_agent_ids,
             );
         }
+        if !skip_capture_backfill_agent_ids.is_empty() {
+            return save_runtime_state_with_lifecycle_topology_authority_and_capture_backfill_skip(
+                workspace,
+                &merged,
+                &target_key,
+                skip_capture_backfill_agent_ids,
+                &[],
+            );
+        }
         if tombstoned_agent_ids.is_empty() {
             return save_runtime_state_with_deleted_agents(workspace, &merged, deleted_agent_ids);
         }
@@ -709,10 +746,28 @@ fn save_team_scoped_state_with_merge_options(
     }
     if tombstoned_agent_ids.is_empty() {
         if !topology_agent_ids.is_empty() {
-            save_runtime_state_with_lifecycle_topology_authority(
+            if !skip_capture_backfill_agent_ids.is_empty() {
+                save_runtime_state_with_lifecycle_topology_authority_and_capture_backfill_skip(
+                    workspace,
+                    &Value::Object(merged),
+                    &target_key,
+                    skip_capture_backfill_agent_ids,
+                    topology_agent_ids,
+                )
+            } else {
+                save_runtime_state_with_lifecycle_topology_authority(
+                    workspace,
+                    &Value::Object(merged),
+                    topology_agent_ids,
+                )
+            }
+        } else if !skip_capture_backfill_agent_ids.is_empty() {
+            save_runtime_state_with_lifecycle_topology_authority_and_capture_backfill_skip(
                 workspace,
                 &Value::Object(merged),
-                topology_agent_ids,
+                &target_key,
+                skip_capture_backfill_agent_ids,
+                &[],
             )
         } else {
             save_runtime_state_with_deleted_agents(

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

@@ -18,6 +18,13 @@
 use std::collections::BTreeMap;
 use std::hash::{Hash, Hasher};
 use std::io::{Read, Write};
+// 0.5.x Windows portability Batch 1: gate the sole Unix API surface
+// in this concrete tmux backend (FileTypeExt::is_socket + libc::geteuid
+// tmux-socket-root derivation). The rest of the file is Command::new
+// "tmux" shellouts that compile on Windows but return runtime errors
+// honestly (tmux binary absent → typed subprocess error).
+// Truth source: `.team/artifacts/0.5.x-windows-portability-survey-design.md` §Batch 1.
+#[cfg(unix)]
 use std::os::unix::fs::FileTypeExt;
 use std::path::{Path, PathBuf};
 use std::process::Stdio;
@@ -489,10 +496,24 @@ pub(crate) fn socket_path_for_name(socket_name: &str) -> Option<PathBuf> {
     if let Some(existing) = existing_socket_path_for_name(socket_name) {
         return Some(existing);
     }
-    let uid = unsafe { libc::geteuid() };
-    let default_root = PathBuf::from(format!("/tmp/tmux-{uid}"));
-    let default_root = default_root.canonicalize().unwrap_or(default_root);
-    Some(default_root.join(socket_name))
+    // Batch 1: tmux uses `/tmp/tmux-<uid>/` on Unix; on Windows this
+    // helper is dead code (Command::new "tmux" fails at spawn time
+    // before this path is dereferenced). N38 typed unsupported honored
+    // at the shellout boundary.
+    #[cfg(unix)]
+    {
+        let uid = unsafe { libc::geteuid() };
+        let default_root = PathBuf::from(format!("/tmp/tmux-{uid}"));
+        let default_root = default_root.canonicalize().unwrap_or(default_root);
+        Some(default_root.join(socket_name))
+    }
+    #[cfg(not(unix))]
+    {
+        // Windows: tmux socket-root derivation is meaningless. Return
+        // None so the caller sees the honest "no such socket" branch.
+        let _ = socket_name;
+        None
+    }
 }
 
 fn existing_socket_path_for_name(socket_name: &str) -> Option<PathBuf> {
@@ -582,14 +603,25 @@ pub(crate) fn attach_commands_for_windows<'a>(
 }
 
 pub(crate) fn tmux_socket_roots() -> Vec<PathBuf> {
-    let uid = unsafe { libc::geteuid() };
-    let mut roots = vec![PathBuf::from(format!("/tmp/tmux-{uid}"))];
-    if let Some(tmpdir) = std::env::var_os("TMPDIR") {
-        roots.push(PathBuf::from(tmpdir).join(format!("tmux-{uid}")));
+    // Batch 1: `/tmp/tmux-<uid>` root enumeration is Unix-only tmux
+    // convention. On Windows return empty so the caller loops zero
+    // times (honest "no tmux socket roots" — tmux is not deployed on
+    // native Windows without WSL, and WSL is out of scope).
+    #[cfg(unix)]
+    {
+        let uid = unsafe { libc::geteuid() };
+        let mut roots = vec![PathBuf::from(format!("/tmp/tmux-{uid}"))];
+        if let Some(tmpdir) = std::env::var_os("TMPDIR") {
+            roots.push(PathBuf::from(tmpdir).join(format!("tmux-{uid}")));
+        }
+        roots.sort();
+        roots.dedup();
+        roots
+    }
+    #[cfg(not(unix))]
+    {
+        Vec::new()
     }
-    roots.sort();
-    roots.dedup();
-    roots
 }
 
 pub(crate) fn tmux_socket_endpoints() -> Vec<String> {
@@ -602,7 +634,20 @@ pub(crate) fn tmux_socket_endpoints() -> Vec<String> {
             let Ok(file_type) = entry.file_type() else {
                 continue;
             };
-            if !file_type.is_socket() {
+            // Batch 1: `FileTypeExt::is_socket` is Unix-only. Dead code
+            // on Windows because `tmux_socket_roots()` returns empty
+            // there (no /tmp/tmux-<uid> convention). We still cfg the
+            // method call so `cargo check --target x86_64-pc-windows-msvc`
+            // sees no `std::os::unix::fs::FileTypeExt` reference.
+            #[cfg(unix)]
+            {
+                if !file_type.is_socket() {
+                    continue;
+                }
+            }
+            #[cfg(not(unix))]
+            {
+                let _ = file_type;
                 continue;
             }
             let path = entry.path();
@@ -2249,5 +2294,10 @@ fn non_empty(raw: &str) -> Option<&str> {
     }
 }
 
-#[cfg(test)]
+// 0.5.x Windows portability Batch 5: the `tmux_backend/tests.rs`
+// module uses `std::os::unix::net::UnixListener` for its mock
+// runner + verifies Unix-specific socket-root derivation. Since the
+// tmux backend itself only functions on Unix (design § Route B —
+// tmux is a Unix concept), the test module stays Unix-only.
+#[cfg(all(test, unix))]
 mod tests;

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

@@ -351,12 +351,61 @@ fn build_conpty(
     // the same source of truth the tmux short-socket derivation uses,
     // so the shim + tmux socket see identical workspace identity.
     let workspace_hash = crate::tmux_backend::workspace_short_hash_pub(input.workspace);
-    // No pipe client is wired here (that's Batch 2/3 scope). Without
-    // a live client, `ConPtyBackend` degrades to `MuxUnavailable`
-    // honestly — which is exactly what C-1 requires when the caller
-    // asked for conpty on a host with no shim.
-    let backend = ConPtyBackend::new(workspace_hash, team_key);
+    // `mut` because the Windows branch below may reassign after a
+    // successful pipe connect + `with_pipe_client` handshake. On
+    // Unix the binding stays as-constructed.
+    #[cfg_attr(not(windows), allow(unused_mut))]
+    let mut backend = ConPtyBackend::new(workspace_hash.clone(), team_key);
     let mut notices = Vec::new();
+    // 0.5.x CR C-5 fix (leader msg_a89b5a03bbf0): factory returns to
+    // pure assembly. `build_conpty` used to call
+    // `NamedPipeClient::connect(_, 2000)` inline when
+    // `conpty_pipe_ready(input)` said state hinted the shim was up.
+    // That was a real CR C-5 violation — every `status`/`diagnose`
+    // resolve on Windows could block 2 seconds probing a
+    // non-existent pipe.
+    //
+    // Post-fix: the factory only STASHES the pipe hint via
+    // `ConPtyBackend::with_pipe_hint(pipe_name)`. The backend's
+    // `ensure_pipe_client` performs the connect + Hello lazily on
+    // the first Op that needs the pipe. Callers that don't need
+    // the pipe (status, resolve-only paths) never pay the connect
+    // cost.
+    //
+    // The Batch 6 direct-handoff path (`lifecycle/launch.rs`
+    // quick-start conpty) stays byte-compatible: it hands its
+    // Hello-connected client to `with_pipe_client` AFTER
+    // `resolve_transport` returns, and the client just becomes the
+    // backend's initial cache value so lazy connect is a no-op on
+    // the first Op.
+    #[cfg(windows)]
+    {
+        if let Some(state) = input.state {
+            if let Some(pipe_name) = state
+                .pointer("/transport/shim/pipe_name")
+                .and_then(|v| v.as_str())
+            {
+                backend = backend.with_pipe_hint(pipe_name);
+            }
+        }
+        // Non-state env override still respected (test/diagnostic
+        // path). When set, derive the hint from workspace_hash +
+        // team_key so `dispatch` can lazily connect the first Op.
+        if std::env::var("TEAM_AGENT_FORCE_CONPTY_PIPE_CONNECT")
+            .map(|v| v == "1")
+            .unwrap_or(false)
+            && backend.pipe_hint_ref().is_none()
+        {
+            let pipe_name = conpty_transport::pipe_name_for(&workspace_hash, team_key);
+            backend = backend.with_pipe_hint(pipe_name);
+        }
+    }
+    // Suppress unused warnings on Unix where the cfg(windows) block
+    // above compiles to nothing.
+    #[cfg(not(windows))]
+    {
+        let _ = &workspace_hash;
+    }
     // C-3: if state has BOTH `transport.kind=conpty` and a legacy
     // `tmux_endpoint`, tell the caller so they emit
     // `transport.legacy_tmux_endpoint_ignored`. Same shape for the
@@ -608,6 +657,76 @@ mod tests {
         assert!(resolved.notices.is_empty());
     }
 
+    // 0.5.x Windows portability Batch 5: pipe_ready gate — without a
+    // shim.pipe_ready hint (or the force-env override) the factory
+    // must NOT attempt a connect. Cross-platform test — the
+    // `conpty_pipe_ready` gate is only referenced inside cfg(windows)
+    // but the observable behavior (no notice, no wired client) is
+    // identical on Unix.
+    #[test]
+    fn conpty_without_pipe_ready_hint_emits_no_pipe_client_notice() {
+        let workspace = ws();
+        let state = serde_json::json!({ "transport": { "kind": "conpty" } });
+        let input = TransportFactoryInput::new(&workspace, TransportPurpose::LifecycleWorker)
+            .with_team_key(Some("team-a"))
+            .with_state(Some(&state));
+        let resolved = resolve_transport(input).expect("must succeed");
+        assert_eq!(resolved.kind, BackendKind::ConPty);
+        // No pipe-client notice must appear regardless of platform:
+        // on Unix the block is cfg'd out; on Windows the gate is
+        // closed because no `transport.shim.pipe_ready = true` in
+        // state.
+        for notice in &resolved.notices {
+            assert_ne!(
+                notice.event, "transport.conpty_pipe_client_unwired",
+                "no pipe-client notice without a pipe_ready hint"
+            );
+        }
+    }
+
+    // 0.5.x CR C-5 fix (leader msg_a89b5a03bbf0): factory returns to
+    // pure assembly. The `transport.conpty_pipe_client_unwired`
+    // notice is REMOVED from `build_conpty` — connect is deferred to
+    // the backend's `ensure_pipe_client` lazy path, which surfaces
+    // failures as `TransportError::MuxUnavailable` at Op call time
+    // (not at resolve time).
+    //
+    // Cross-platform: resolve NEVER emits pipe-client notices on
+    // either platform now. This test locks that invariant so a
+    // future revert would fire loudly.
+    #[test]
+    fn conpty_resolve_emits_no_pipe_client_notice_after_c5_fix() {
+        let workspace = ws();
+        let state = serde_json::json!({
+            "transport": {
+                "kind": "conpty",
+                "shim": {
+                    "pipe_name": r"\\.\pipe\team-agent-conpty-test-team-a",
+                    "pipe_ready": true
+                },
+            }
+        });
+        let input = TransportFactoryInput::new(&workspace, TransportPurpose::LifecycleWorker)
+            .with_team_key(Some("team-a"))
+            .with_state(Some(&state));
+        let resolved = resolve_transport(input).expect("must succeed");
+        assert_eq!(resolved.kind, BackendKind::ConPty);
+        let pipe_notices: Vec<_> = resolved
+            .notices
+            .iter()
+            .filter(|n| n.event == "transport.conpty_pipe_client_unwired")
+            .collect();
+        assert!(
+            pipe_notices.is_empty(),
+            "CR C-5 fix: resolve must not emit pipe-client notices \
+             (connect deferred to backend lazy path). Found: {:?}",
+            pipe_notices
+                .iter()
+                .map(|n| &n.event)
+                .collect::<Vec<_>>()
+        );
+    }
+
     // Wire-string invariants for RequestedTransportBackend so a rename
     // in Rust cannot silently drift the CLI accept-list.
     #[test]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.5.2",
-    "@team-agent/cli-darwin-x64": "0.5.2",
-    "@team-agent/cli-linux-x64": "0.5.2"
+    "@team-agent/cli-darwin-arm64": "0.5.4",
+    "@team-agent/cli-darwin-x64": "0.5.4",
+    "@team-agent/cli-linux-x64": "0.5.4"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",