@team-agent/installer 0.5.1 → 0.5.3

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

@@ -724,6 +724,19 @@ fn report_result_for_owner_team_inner(
         &event_log,
     ) {
         Ok(outcome) => outcome,
+        Err(error) if report_state_has_app_server_receiver(&state) => {
+            let message_id = format!("fallback:{result_id}");
+            crate::messaging::DeliveryOutcome {
+                ok: false,
+                status: crate::messaging::DeliveryStatus::Failed,
+                message_status: super::helpers::MessageStatusShadow("failed".to_string()),
+                message_id: Some(message_id),
+                verification: Some(format!("leader_funnel_error:{error}")),
+                stage: None,
+                reason: Some(crate::messaging::DeliveryRefusal::LeaderNotAttached),
+                channel: Some("codex_app_server".to_string()),
+            }
+        }
         Err(error) => {
             let message_id = format!("fallback:{result_id}");
             let fallback_error = fallback_primary_error_text(
@@ -744,17 +757,32 @@ fn report_result_for_owner_team_inner(
     };
     if let Some(message_id) = outcome.message_id.clone() {
         let store = MessageStore::open(workspace)?;
-        let transport = crate::tmux_backend::TmuxBackend::for_workspace(workspace);
+        // 0.5.x Phase 1d Batch 4: report_result retry uses the runtime
+        // factory transport so a conpty team's report notification
+        // goes to the shim (design §Batch 4). Previously we always
+        // built `TmuxBackend::for_workspace`, which for a conpty team
+        // silently no-op'd the retry. Factory refusal falls back to
+        // tmux workspace (byte-equivalent tmux teams; honest failure
+        // for conpty teams without a resolvable factory input).
         let delivery_state_raw = crate::state::persist::load_runtime_state(workspace)
             .unwrap_or_else(|_| state_for_owner.clone());
         let delivery_state = report_owner_state(&delivery_state_raw, &owner_team);
+        let transport: Box<dyn crate::transport::Transport> =
+            match crate::transport_factory::resolve_read_only_transport(
+                workspace,
+                Some(&delivery_state),
+                crate::transport_factory::TransportPurpose::MessageDelivery,
+            ) {
+                Ok(r) => r.backend,
+                Err(_) => Box::new(crate::tmux_backend::TmuxBackend::for_workspace(workspace)),
+            };
         let mut primary_error: Option<String> = None;
         for attempt in 0..3 {
             let _ = store.mark(&message_id, "accepted", None);
             match super::delivery::deliver_pending_message(
                 workspace,
                 &store,
-                &transport,
+                transport.as_ref(),
                 &message_id,
                 &event_log,
                 &delivery_state,
@@ -781,7 +809,7 @@ fn report_result_for_owner_team_inner(
             match super::delivery::deliver_pending_messages(
                 workspace,
                 &delivery_state,
-                &transport,
+                transport.as_ref(),
                 &event_log,
             ) {
                 Ok(delivered)
@@ -824,24 +852,26 @@ fn report_result_for_owner_team_inner(
             }
         }
         if !outcome.ok {
-            let fallback_error = primary_error.unwrap_or_else(|| {
-                format!(
-                    "leader_notification_primary_failed:{}",
-                    super::helpers::status_wire(outcome.status)
-                )
-            });
-            let fallback_error =
-                fallback_primary_error_text(fallback_primary_error, fallback_error);
-            outcome = super::leader_receiver::deliver_to_leader_fallback_pane(
-                workspace,
-                &delivery_state,
-                &message_id,
-                Some(&result_id),
-                &content,
-                false,
-                Some(&fallback_error),
-                &event_log,
-            )?;
+            if !report_state_has_app_server_receiver(&delivery_state) {
+                let fallback_error = primary_error.unwrap_or_else(|| {
+                    format!(
+                        "leader_notification_primary_failed:{}",
+                        super::helpers::status_wire(outcome.status)
+                    )
+                });
+                let fallback_error =
+                    fallback_primary_error_text(fallback_primary_error, fallback_error);
+                outcome = super::leader_receiver::deliver_to_leader_fallback_pane(
+                    workspace,
+                    &delivery_state,
+                    &message_id,
+                    Some(&result_id),
+                    &content,
+                    false,
+                    Some(&fallback_error),
+                    &event_log,
+                )?;
+            }
         }
     }
     let leader_notified = outcome.ok;
@@ -937,6 +967,33 @@ fn report_owner_state(state: &serde_json::Value, owner_team: &str) -> serde_json
     state
 }
 
+fn report_state_has_app_server_receiver(state: &serde_json::Value) -> bool {
+    report_leader_receiver_value(state).is_some_and(crate::codex_app_server::receiver_is_app_server)
+}
+
+fn report_leader_receiver_value(state: &serde_json::Value) -> Option<&serde_json::Value> {
+    state
+        .get("leader_receiver")
+        .or_else(|| {
+            state
+                .get("active_team_key")
+                .and_then(serde_json::Value::as_str)
+                .and_then(|team| state.get("teams").and_then(|teams| teams.get(team)))
+                .and_then(|team| team.get("leader_receiver"))
+        })
+        .or_else(|| {
+            let teams = state.get("teams").and_then(serde_json::Value::as_object)?;
+            if teams.len() == 1 {
+                teams
+                    .values()
+                    .next()
+                    .and_then(|team| team.get("leader_receiver"))
+            } else {
+                None
+            }
+        })
+}
+
 fn insert_result_if_absent(
     conn: &rusqlite::Connection,
     result_id: &str,

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

@@ -1894,6 +1894,243 @@ fn e51_delivery_keeps_same_socket_pane_conflict_guard() {
     );
 }
 
+fn app_server_state(
+    ws: &Path,
+    endpoint: &str,
+    thread_id: &str,
+    session_id: &str,
+) -> serde_json::Value {
+    serde_json::json!({
+        "active_team_key": "team-a",
+        "teams": {
+            "team-a": {
+                "team_key": "team-a",
+                "agents": {},
+                "leader_receiver": {
+                    "mode": "codex_app_server",
+                    "transport_kind": "codex_app_server",
+                    "status": "attached",
+                    "provider": "codex",
+                    "owner_epoch": 7,
+                    "app_server": {
+                        "socket": endpoint,
+                        "thread_id": thread_id,
+                        "session_id": session_id,
+                        "cwd": ws.to_string_lossy(),
+                        "cli_version": "codex-appserver-team-agent-test/0.139.0",
+                        "bound_at": "2026-07-05T00:00:00Z"
+                    }
+                },
+                "team_owner": {
+                    "provider": "codex",
+                    "transport_kind": "codex_app_server",
+                    "owner_epoch": 7
+                },
+                "owner_epoch": 7
+            }
+        }
+    })
+}
+
+// 0.5.x Windows portability Batch 5: FakeAppServer uses Unix domain
+// sockets — Unix-only.
+#[cfg(unix)]
+#[test]
+fn app_server_leader_delivery_marks_delivered_without_tmux_transport() {
+    let ws = tmp_ws("appdeliver");
+    let fake = crate::app_server_test_support::FakeAppServer::start(
+        "deliver-ok",
+        crate::app_server_test_support::FakeAppServerScript::happy(
+            "thread-live",
+            "session-live",
+            ws.to_str().unwrap(),
+        ),
+    );
+    let state = app_server_state(&ws, fake.endpoint(), "thread-live", "session-live");
+    crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+    let store = store_for(&ws);
+    let log = EventLog::new(&ws);
+    let message_id = store
+        .create_message(
+            None,
+            "worker_a",
+            "leader",
+            "app server hello",
+            None,
+            false,
+            Some("team-a"),
+        )
+        .unwrap();
+
+    let out = deliver_pending_message(&ws, &store, &NoopTransport, &message_id, &log, &state)
+        .expect("app-server delivery should not require tmux transport");
+
+    assert!(
+        out.ok,
+        "app-server turn/start acceptance is delivery proof: {out:?}"
+    );
+    assert_eq!(out.message_status.0, "delivered");
+    assert_eq!(out.channel.as_deref(), Some("codex_app_server"));
+    let turns = fake.received_turns();
+    assert_eq!(turns.len(), 1);
+    assert_eq!(
+        turns[0]["params"]["clientUserMessageId"],
+        serde_json::json!(message_id)
+    );
+    let events = log.tail(0).unwrap();
+    assert!(
+        events.iter().any(|event| {
+            event.get("event").and_then(serde_json::Value::as_str)
+                == Some("leader_receiver.app_server_submitted")
+        }),
+        "delivery must emit app-server submission event; events={events:?}"
+    );
+}
+
+#[cfg(unix)]
+#[test]
+fn app_server_leader_delivery_stale_tuple_fails_closed_with_event() {
+    let ws = tmp_ws("appstale");
+    let fake = crate::app_server_test_support::FakeAppServer::start(
+        "deliver-stale",
+        crate::app_server_test_support::FakeAppServerScript::happy(
+            "thread-live",
+            "session-new",
+            ws.to_str().unwrap(),
+        ),
+    );
+    let state = app_server_state(&ws, fake.endpoint(), "thread-live", "session-old");
+    crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+    let store = store_for(&ws);
+    let log = EventLog::new(&ws);
+    let message_id = store
+        .create_message(
+            None,
+            "worker_a",
+            "leader",
+            "stale",
+            None,
+            false,
+            Some("team-a"),
+        )
+        .unwrap();
+
+    let out = deliver_pending_message(&ws, &store, &NoopTransport, &message_id, &log, &state)
+        .expect("stale app-server binding should be a business failure, not panic");
+
+    assert!(!out.ok);
+    assert_eq!(out.channel.as_deref(), Some("rebind_required"));
+    assert_eq!(out.message_status.0, "failed");
+    let events = log.tail(0).unwrap();
+    assert!(
+        events.iter().any(|event| {
+            event.get("event").and_then(serde_json::Value::as_str)
+                == Some("leader_receiver.app_server_thread_stale")
+                && event.get("message_id").and_then(serde_json::Value::as_str)
+                    == Some(message_id.as_str())
+        }),
+        "stale app-server tuple must emit app_server_thread_stale; events={events:?}"
+    );
+}
+
+#[test]
+fn app_server_leader_delivery_fails_closed_on_mode_transport_conflict() {
+    let ws = tmp_ws("appconflict");
+    let mut state = app_server_state(
+        &ws,
+        "unix:///tmp/team-agent-should-not-connect.sock",
+        "thread-live",
+        "session-live",
+    );
+    state["teams"]["team-a"]["leader_receiver"]["mode"] = serde_json::json!("direct_tmux");
+    crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+    let store = store_for(&ws);
+    let log = EventLog::new(&ws);
+    let message_id = store
+        .create_message(
+            None,
+            "worker_a",
+            "leader",
+            "conflict",
+            None,
+            false,
+            Some("team-a"),
+        )
+        .unwrap();
+
+    let out = deliver_pending_message(&ws, &store, &NoopTransport, &message_id, &log, &state)
+        .expect("transport conflict should be a business failure");
+
+    assert!(!out.ok);
+    assert_eq!(out.channel.as_deref(), Some("rebind_required"));
+    assert_eq!(out.message_status.0, "failed");
+    assert_eq!(
+        out.verification.as_deref(),
+        Some("run team-agent claim-leader, takeover, or attach-app-server-leader")
+    );
+    let events = log.tail(0).unwrap();
+    assert!(
+        events.iter().any(|event| {
+            event.get("event").and_then(serde_json::Value::as_str)
+                == Some("leader_receiver.delivery_blocked")
+                && event.get("reason").and_then(serde_json::Value::as_str)
+                    == Some("leader_receiver_transport_conflict")
+        }),
+        "transport conflict must emit explicit fail-closed event; events={events:?}"
+    );
+}
+
+#[cfg(unix)]
+#[test]
+fn app_server_leader_busy_is_retryable_and_does_not_steer() {
+    let ws = tmp_ws("appbusy");
+    let mut script = crate::app_server_test_support::FakeAppServerScript::happy(
+        "thread-live",
+        "session-live",
+        ws.to_str().unwrap(),
+    );
+    script.turn_error = Some("thread already has an active turn".to_string());
+    let fake = crate::app_server_test_support::FakeAppServer::start("deliver-busy", script);
+    let state = app_server_state(&ws, fake.endpoint(), "thread-live", "session-live");
+    crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+    let store = store_for(&ws);
+    let log = EventLog::new(&ws);
+    let message_id = store
+        .create_message(
+            None,
+            "worker_a",
+            "leader",
+            "busy",
+            None,
+            false,
+            Some("team-a"),
+        )
+        .unwrap();
+
+    let out = deliver_pending_message(&ws, &store, &NoopTransport, &message_id, &log, &state)
+        .expect("leader busy should be retryable");
+
+    assert!(!out.ok);
+    assert_eq!(out.status, DeliveryStatus::RetryScheduled);
+    assert_eq!(out.channel.as_deref(), Some("leader_busy"));
+    let conn = crate::db::schema::open_db(store.db_path()).unwrap();
+    let status: String = conn
+        .query_row(
+            "select status from messages where message_id = ?1",
+            [&message_id],
+            |row| row.get(0),
+        )
+        .unwrap();
+    assert_eq!(status, "target_resolved", "busy leader remains retryable");
+    let turns = fake.received_turns();
+    assert_eq!(
+        turns.len(),
+        1,
+        "must only call turn/start, never turn/steer"
+    );
+    assert_eq!(turns[0]["method"], serde_json::json!("turn/start"));
+}
+
 #[test]
 fn u1_multi_team_send_does_not_backfill_top_level_leader_binding() {
     let ws = tmp_ws("u1backfill");

package/crates/team-agent/src/packaging/tests.rs

@@ -222,12 +222,47 @@ fn linux_aarch64_is_native() {
 }
 
 #[test]
-fn windows_x8664_is_native_per_transport_design() {
-    // skeleton:203/211 — Windows 原生一等 (WezTerm/ConPTY,非 tmux)。
-    // 不是 Unsupported,不是 RequiresWslTmux — 是 Native.
-    assert_eq!(
-        platform_support(ReleaseTarget::WindowsX8664),
-        PlatformSupport::Native
+fn windows_x8664_is_preview_compile_only_during_batch_0_to_5() {
+    // 0.5.x Windows portability CR C-1 (P0):
+    // Windows previously claimed `PlatformSupport::Native` but
+    // `cargo check --target x86_64-pc-windows-msvc` was RED — the
+    // Unix-only `std::os::unix` / `libc::pid_t` calls in
+    // tmux_backend/coordinator/lifecycle/packaging never compiled on
+    // Windows. Claiming Native was a MUST-NOT-13 假绿承诺 (user
+    // installs and immediately hits build failures).
+    //
+    // This test locks the honest downgrade in place until Batch 6/7
+    // real-machine gates pass. Promoting Windows back to `Native`
+    // requires:
+    //   1. Batch 6 fake-provider smoke on the SSH host (design §Batch 6)
+    //   2. Batch 7 real-machine subscription serial (CR §C-5)
+    // Both flip this test to `assert PlatformSupport::Native` in a
+    // deliberate PR — no silent regen.
+    //
+    // Truth source: `.team/artifacts/0.5.x-windows-portability-cr-verdict.md` §C-1.
+    match platform_support(ReleaseTarget::WindowsX8664) {
+        PlatformSupport::PreviewCompileOnly { preview_gate, note } => {
+            assert_eq!(preview_gate, "compile_gate");
+            assert!(note.contains("compile_gate") || note.contains("cargo check"));
+        }
+        other => panic!(
+            "Windows must stay `PreviewCompileOnly` while the compile gate is RED; \
+             promoting back to `Native` requires Batch 6 + Batch 7 real-machine gates. \
+             Got {other:?}"
+        ),
+    }
+}
+
+#[test]
+fn windows_x8664_is_not_native_yet_c1_hard_lock() {
+    // Belt-and-braces companion for the above — a distinct assertion
+    // that fires clearly if a future refactor of `PlatformSupport`
+    // changes variant names.
+    let support = platform_support(ReleaseTarget::WindowsX8664);
+    assert_ne!(
+        support,
+        PlatformSupport::Native,
+        "CR C-1: Windows must NOT be Native until Batch 6/7 gates pass"
     );
 }
 

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

@@ -162,13 +162,27 @@ pub enum ReleaseTarget {
 }
 
 /// 平台支持等级(§8:如实声明,不假装兼容)。
+///
+/// 0.5.x Windows portability CR C-1 (P0) 引入 `PreviewCompileOnly`:
+/// Windows 目前 `cargo check --target x86_64-pc-windows-msvc` **仍红**
+/// (三处 non-Unix fallback + platform 层未接入 + Batch 1-4 未完成);
+/// 保持 `Native` 会构成 MUST-NOT-13 假绿承诺 → 用户装 Windows 二进制
+/// 会真报错。降级为 `PreviewCompileOnly` 明示"当前 Windows 尚未通过
+/// 编译门,Batch 6/7 真机订阅测通过前不承诺 Native"。
+/// Truth source: `.team/artifacts/0.5.x-windows-portability-cr-verdict.md` §C-1。
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case", tag = "level")]
 pub enum PlatformSupport {
-    /// 原生一等(macOS/Linux tmux;Windows WezTerm/ConPTY,见 transport-backend-design.md)。
+    /// 原生一等(macOS/Linux tmux)。
     Native,
     /// 需 WSL + tmux backend(显式标要求,不假装原生)。
     RequiresWslTmux { note: String },
+    /// Windows 移植进行中,`cargo check` 仍红或 Batch 6/7 真机订阅测未过。
+    /// 用户不应期待可运行的 `.exe`;`preview_gate` 字段说明当前挡位
+    /// (`compile_gate` = Batch 0-4 编译门,`fake_provider_smoke` = Batch 6,
+    /// `subscription_realmachine` = Batch 7)。
+    /// 该档位不承诺可用,仅承诺"正在移植 + 每 Batch 有 CI 编译门追踪"。
+    PreviewCompileOnly { preview_gate: String, note: String },
     /// 当前 release 矩阵不覆盖。
     Unsupported { reason: String },
 }
@@ -179,8 +193,22 @@ pub fn platform_support(target: ReleaseTarget) -> PlatformSupport {
         ReleaseTarget::MacosAarch64
         | ReleaseTarget::MacosX8664
         | ReleaseTarget::LinuxX8664
-        | ReleaseTarget::LinuxAarch64
-        | ReleaseTarget::WindowsX8664 => PlatformSupport::Native,
+        | ReleaseTarget::LinuxAarch64 => PlatformSupport::Native,
+        // 0.5.x Windows portability CR C-1 (P0):
+        // `cargo check --target x86_64-pc-windows-msvc` 是当前挡位;
+        // Batch 6 fake-provider smoke + Batch 7 真机订阅测通过后
+        // 才升回 `Native`。历史 tag 期间 Windows 曾声明为 Native 但
+        // 从未通过编译门,构成 MUST-NOT-13 假绿承诺 → 本 batch 降级。
+        ReleaseTarget::WindowsX8664 => PlatformSupport::PreviewCompileOnly {
+            preview_gate: "compile_gate".to_string(),
+            note: "Windows native port in progress; `cargo check --target x86_64-pc-windows-msvc` \
+                   is the current gate. See \
+                   `.team/artifacts/0.5.x-windows-portability-survey-design.md` §Batch 0-6 \
+                   and CR verdict §C-1 for burn-down status. Promote back to `Native` only \
+                   after Batch 6 (fake-provider smoke) + Batch 7 (subscription real-machine) \
+                   pass on the SSH host."
+                .to_string(),
+        },
     }
 }