@team-agent/installer 0.5.1 → 0.5.2

package/crates/team-agent/src/conpty/mod.rs

@@ -0,0 +1,32 @@
+//! 0.5.x Windows-native transport Phase 1: ConPTY backend.
+//!
+//! Wire protocol + portable shim state machine live in the
+//! `conpty-transport` crate (portable, no team-agent runtime deps —
+//! consumed directly by the Windows `windows-shim` binary). This
+//! module wires that portable machinery into team-agent's `Transport`
+//! trait via `ConPtyBackend`.
+//!
+//! Truth sources (READ-ONLY):
+//! - Design:    `.team/artifacts/0.5.x-windows-native-transport-design.md`
+//! - CR verdict: `.team/artifacts/0.5.x-windows-transport-cr-verdict.md`
+//!
+//! CR anchors:
+//! - **C-1 pipe_token**: only lives in `ConPtyBackend.pipe_token`
+//!   (Mutex) and the shim's in-memory state; never persisted. Grep
+//!   guard test (`conpty_pipe_token_no_persist_guard.rs`) locks this.
+//! - **C-2 kill_server**: forwards to `Op::Shutdown` per-team, not
+//!   global. See CR pre-check in the gate report.
+//! - **C-3 stale event**: emitted by the backend when `state.shim_pid`
+//!   disagrees with the shim's `hello` response.
+//! - **C-5 pipe_token_mismatch**: `ProtocolError::PipeTokenMismatch`
+//!   maps to `TransportError::MuxUnavailable`, NEVER silent retry.
+
+pub mod backend;
+
+pub use backend::{ConPtyBackend, PipeClientAdapter, PipeClientTrait};
+// Re-export the portable protocol + shim types from the standalone
+// crate so downstream code can `use team_agent::conpty::{Shim,
+// FakePaneRuntime, ...}` without a second dependency.
+pub use conpty_transport::{
+    protocol, shim, FakePaneRuntime, LocalShimClient, PaneRuntime, PipeClient, Shim,
+};

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

@@ -36,19 +36,58 @@ pub fn run_daemon(args: DaemonArgs) -> Result<(), DaemonError> {
     // CP-1: the daemon's whole tick surface (has_session / capture / inject / list_windows / kill)
     // runs through this backend. Prefer the persisted runtime endpoint so attached explicit-socket
     // teams are checked on the same socket as lifecycle worker operations.
+    //
+    // 0.5.x Phase 1d Batch 3: coordinator boot now routes through
+    // `transport_factory::resolve_transport` so `state.transport.kind =
+    // conpty` boots the ConPTY backend, not a tmux backend that would
+    // fake `has_session()`. Tmux behavior is byte-equivalent (Layer 3
+    // legacy `tmux_endpoint` → same `tmux_backend_for_runtime_state_or_workspace`
+    // shape inside the factory's `build_tmux`).
     let state = crate::state::persist::load_runtime_state(args.workspace.as_path()).ok();
-    let tmux_selection = crate::tmux_backend::tmux_backend_for_runtime_state_or_workspace(
+    let factory_input = crate::transport_factory::TransportFactoryInput::new(
         args.workspace.as_path(),
-        state.as_ref(),
-    );
+        crate::transport_factory::TransportPurpose::Coordinator,
+    )
+    .with_state(state.as_ref());
+    let resolved = match crate::transport_factory::resolve_transport(factory_input) {
+        Ok(resolved) => resolved,
+        Err(e) => {
+            // Fail-closed honest degradation: coordinator boots with a
+            // tmux-workspace backend so it doesn't crash, but records
+            // the assembly refusal in the boot metadata source so the
+            // event log shows the reason. This preserves the daemon
+            // liveness path while making the failure explicit.
+            eprintln!(
+                "coordinator: transport_factory refused ({e}); falling back to tmux workspace for daemon liveness"
+            );
+            let sel = crate::tmux_backend::tmux_backend_for_runtime_state_or_workspace(
+                args.workspace.as_path(),
+                state.as_ref(),
+            );
+            let metadata = DaemonTmuxEndpointMetadata {
+                tmux_endpoint_used: sel.tmux_endpoint_used.clone(),
+                tmux_endpoint_source: "factory_refused_fallback",
+            };
+            let coord = Coordinator::new(
+                args.workspace.clone(),
+                Box::new(RealProviderRegistry),
+                Box::new(sel.backend),
+            );
+            return run_daemon_with_coordinator_and_boot_tmux(&args, &coord, Some(metadata));
+        }
+    };
+    // Preserve tmux boot metadata byte-equivalent for tmux teams.
+    // ConPTY teams get their source string but no tmux endpoint (design
+    // §Behavior Equivalence: same `tmux_endpoint_used` for tmux; None
+    // + honest source for conpty).
     let tmux_metadata = DaemonTmuxEndpointMetadata {
-        tmux_endpoint_used: tmux_selection.tmux_endpoint_used.clone(),
-        tmux_endpoint_source: tmux_selection.tmux_endpoint_source.as_str(),
+        tmux_endpoint_used: resolved.tmux_endpoint_used.clone(),
+        tmux_endpoint_source: resolved.source,
     };
     let coordinator = Coordinator::new(
         args.workspace.clone(),
         Box::new(RealProviderRegistry),
-        Box::new(tmux_selection.backend),
+        resolved.backend,
     );
     run_daemon_with_coordinator_and_boot_tmux(&args, &coordinator, Some(tmux_metadata))
 }

package/crates/team-agent/src/diagnose/orphans.rs

@@ -10,7 +10,8 @@ use crate::coordinator::health::{
     coordinator_metadata_ok, pid_is_running, read_coordinator_metadata, terminate_pid_tree,
 };
 use crate::coordinator::types::{OrphanReason, Pid, WorkspacePath};
-use crate::tmux_backend::TmuxBackend;
+// Phase 1d Batch 6: `TmuxBackend` import removed — all sites now use
+// `transport_factory::tmux_socket_name_transport` for grep-visibility.
 use crate::transport::{SessionName, Transport};
 
 #[derive(Debug, Clone)]
@@ -352,7 +353,11 @@ fn tmux_socket_roots() -> Vec<PathBuf> {
 }
 
 fn tmux_list_panes(socket: &str) -> Vec<TmuxPaneRow> {
-    TmuxBackend::for_socket_name(socket)
+    // Phase 1d Batch 6: factory tmux-socket-name helper for
+    // grep-visibility. Tmux-only orphan scanner (enumerates tmux socket
+    // roots); ConPTY orphan diagnostics are a separate shim registry
+    // command, not routed here.
+    crate::transport_factory::tmux_socket_name_transport(socket)
         .list_targets()
         .unwrap_or_default()
         .into_iter()
@@ -664,7 +669,10 @@ fn kill_tmux_session(orphan: &OrphanRecord) -> bool {
     let (Some(socket), Some(session)) = (&orphan.tmux_socket, &orphan.session) else {
         return false;
     };
-    TmuxBackend::for_socket_name(socket)
+    // Phase 1d Batch 6: factory tmux-socket-name helper. Explicit
+    // tmux-only kill; conpty shim orphans are NOT routed here (design
+    // §Batch 6).
+    crate::transport_factory::tmux_socket_name_transport(socket)
         .kill_session(&SessionName::new(session.clone()))
         .is_ok()
 }

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

@@ -134,6 +134,58 @@ pub fn attach_leader(
     })
 }
 
+/// Explicit app-server leader binding. Validates the supplied socket/thread tuple
+/// before writing the typed physical-channel anchor through the lease primitive.
+pub fn attach_app_server_leader(
+    workspace: &Path,
+    team: Option<&str>,
+    socket: &str,
+    thread_id: &str,
+) -> Result<Value, LeaderError> {
+    let binding = crate::codex_app_server::attach_probe(socket, thread_id)
+        .map_err(|error| LeaderError::Validation(error.to_string()))?;
+    let event_log = crate::event_log::EventLog::new(workspace);
+    let scoped_team = team.filter(|value| !value.is_empty());
+    let mut state = if scoped_team.is_some() {
+        crate::state::projection::select_runtime_state(workspace, scoped_team)?
+    } else {
+        crate::state::persist::load_runtime_state(workspace)?
+    };
+    if !state.is_object() {
+        state = json!({});
+    }
+    if let Some(team) = scoped_team {
+        state["active_team_key"] = json!(team);
+    }
+    let team_key = canonical_owner_write_key(&state);
+    let next_epoch = OwnerEpoch(current_owner_epoch(&state).0.saturating_add(1));
+    let receiver = app_server_receiver_value(&binding, next_epoch);
+    let owner = app_server_owner_value(next_epoch);
+    let record = crate::state::ownership::OwnershipWrite::new()
+        .with_leader_receiver(receiver.clone())
+        .with_team_owner(owner.clone())
+        .with_owner_epoch(next_epoch.0);
+    crate::state::ownership::write_owner(&mut state, &team_key, record);
+    write_claim_state(workspace, &state, scoped_team, Some(&team_key))?;
+    event_log.write(
+        super::LeaderEvent::ReceiverAttached.name(),
+        json!({
+            "transport_kind": "codex_app_server",
+            "thread_id": binding.thread_id,
+            "owner_epoch": next_epoch.0,
+            "team": team_key,
+        }),
+    )?;
+    Ok(json!({
+        "ok": true,
+        "status": "claimed",
+        "team": team_key,
+        "owner_epoch": next_epoch.0,
+        "leader_receiver": receiver,
+        "team_owner": owner,
+    }))
+}
+
 #[derive(Clone)]
 struct AttachLeaderTarget {
     info: PaneInfo,
@@ -156,8 +208,11 @@ fn attach_leader_targets(workspace: &Path, state: &Value) -> Vec<AttachLeaderTar
                 }),
         );
     }
+    // Phase 1d Batch 6: factory tmux workspace helper for
+    // grep-visibility. Semantics unchanged; leader lease discovery is
+    // tmux-only (caller pane = tmux pane, MUST-12 anchor).
     targets.extend(
-        crate::tmux_backend::TmuxBackend::for_workspace(workspace)
+        crate::transport_factory::tmux_workspace_transport(workspace)
             .list_targets()
             .unwrap_or_default()
             .into_iter()
@@ -167,10 +222,12 @@ fn attach_leader_targets(workspace: &Path, state: &Value) -> Vec<AttachLeaderTar
 }
 
 fn tmux_backend_for_endpoint(endpoint: &str) -> crate::tmux_backend::TmuxBackend {
+    // Phase 1d Batch 6: factory tmux channel helpers for grep-visibility.
+    // Same tmux-only semantics as before.
     if endpoint.is_empty() || endpoint == "default" {
-        crate::tmux_backend::TmuxBackend::new()
+        crate::transport_factory::tmux_default_transport()
     } else {
-        crate::tmux_backend::TmuxBackend::for_tmux_endpoint(endpoint)
+        crate::transport_factory::tmux_endpoint_transport(endpoint)
     }
 }
 
@@ -320,11 +377,13 @@ pub fn claim_leader(
         .unwrap_or_default();
     let raw_state = crate::state::persist::load_runtime_state(workspace)?;
     let event_log = crate::event_log::EventLog::new(workspace);
-    let mut targets = crate::tmux_backend::TmuxBackend::for_workspace(workspace)
+    // Phase 1d Batch 6: factory tmux channel helpers for grep-visibility.
+    // Tmux-only leader-claim path (caller pane enumeration).
+    let mut targets = crate::transport_factory::tmux_workspace_transport(workspace)
         .list_targets()
         .unwrap_or_default();
     targets.extend(
-        crate::tmux_backend::TmuxBackend::new()
+        crate::transport_factory::tmux_default_transport()
             .list_targets()
             .unwrap_or_default(),
     );
@@ -1055,7 +1114,7 @@ fn write_binding_to_state(
     }
     let team_key = canonical_owner_write_key(state);
     let record = crate::state::ownership::OwnershipWrite::new()
-        .with_leader_receiver(serde_json::to_value(receiver)?)
+        .with_leader_receiver(tmux_receiver_value(receiver)?)
         .with_team_owner(serde_json::to_value(owner)?)
         .with_owner_epoch(owner.owner_epoch.0);
     crate::state::ownership::write_owner(state, &team_key, record);
@@ -1074,11 +1133,89 @@ fn write_receiver_to_state(
     }
     let team_key = canonical_owner_write_key(state);
     let record = crate::state::ownership::OwnershipWrite::new()
-        .with_leader_receiver(serde_json::to_value(receiver)?);
+        .with_leader_receiver(tmux_receiver_value(receiver)?);
     crate::state::ownership::write_owner(state, &team_key, record);
     Ok(())
 }
 
+fn tmux_receiver_value(receiver: &LeaderReceiver) -> Result<Value, LeaderError> {
+    Ok(write_leader_receiver_transport(
+        serde_json::to_value(receiver)?,
+        "direct_tmux",
+    ))
+}
+
+fn app_server_receiver_value(
+    binding: &crate::codex_app_server::AppServerBinding,
+    epoch: OwnerEpoch,
+) -> Value {
+    write_leader_receiver_transport(
+        json!({
+            "status": "attached",
+            "provider": "codex",
+            "owner_epoch": epoch.0,
+            "app_server": {
+                "socket": binding.socket,
+                "thread_id": binding.thread_id,
+                "session_id": binding.session_id,
+                "cwd": binding.cwd,
+                "cli_version": binding.cli_version,
+                "bound_at": binding.bound_at,
+                "source": "app-server"
+            }
+        }),
+        "codex_app_server",
+    )
+}
+
+fn app_server_owner_value(epoch: OwnerEpoch) -> Value {
+    json!({
+        "provider": "codex",
+        "transport_kind": "codex_app_server",
+        "owner_epoch": epoch.0,
+        "claimed_at": now_ts(),
+        "claimed_via": "attach-app-server-leader",
+        "os_user": std::env::var("USER")
+            .or_else(|_| std::env::var("USERNAME"))
+            .unwrap_or_default(),
+    })
+}
+
+fn write_leader_receiver_transport(mut receiver: Value, transport_kind: &str) -> Value {
+    if let Some(obj) = receiver.as_object_mut() {
+        obj.insert("mode".to_string(), json!(transport_kind));
+        match transport_kind {
+            "codex_app_server" => {
+                obj.insert("transport_kind".to_string(), json!(transport_kind));
+                for legacy in [
+                    "pane_id",
+                    "tmux_socket",
+                    "session_name",
+                    "window_index",
+                    "window_name",
+                    "pane_index",
+                    "pane_tty",
+                    "pane_current_command",
+                    "fingerprint",
+                    "leader_session_uuid",
+                    "attached_at",
+                    "discovery",
+                    "requested_provider",
+                    "warning",
+                ] {
+                    obj.remove(legacy);
+                }
+            }
+            "direct_tmux" => {
+                obj.remove("app_server");
+                obj.remove("transport_kind");
+            }
+            _ => {}
+        }
+    }
+    receiver
+}
+
 /// Stage 3 owner persist fix (architect direction 2026-06-24): determine
 /// the canonical team_key for an in-memory ownership write. When the state
 /// carries an `active_team_key` (set by `project_top_level_view` whenever

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

@@ -262,7 +262,9 @@ fn family_a_identity(
 }
 
 fn tmux_pane_current_command(workspace: &Path, pane: &str) -> Result<String, LeaderError> {
-    TmuxBackend::for_workspace(workspace)
+    // Phase 1d Batch 6: factory tmux workspace helper for grep-visibility.
+    // Tmux-only owner-bind (caller pane = tmux pane).
+    crate::transport_factory::tmux_workspace_transport(workspace)
         .query(
             &Target::Pane(PaneId::new(pane)),
             PaneField::PaneCurrentCommand,
@@ -273,7 +275,8 @@ fn tmux_pane_current_command(workspace: &Path, pane: &str) -> Result<String, Lea
 
 fn tmux_pane_info(workspace: &Path, pane: &str) -> Option<PaneInfo> {
     let target = PaneId::new(pane);
-    TmuxBackend::for_workspace(workspace)
+    // Phase 1d Batch 6: same as above.
+    crate::transport_factory::tmux_workspace_transport(workspace)
         .list_targets()
         .ok()?
         .into_iter()

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

@@ -434,7 +434,12 @@ fn execute_managed_leader_plan(
     let Some(window) = plan.leader_window.as_ref() else {
         return Err(LeaderError::Start("managed leader window missing".to_string()));
     };
-    let transport = TmuxBackend::for_workspace(workspace);
+    // 0.5.x Phase 1d Batch 6: use the factory tmux channel helper
+    // (thin wrapper over `TmuxBackend::for_workspace`) for
+    // grep-visibility of every intentional tmux-only leader-launcher
+    // site. Semantics unchanged; managed leader hosting stays
+    // tmux-only per design §Batch 6.
+    let transport = crate::transport_factory::tmux_workspace_transport(workspace);
     let spawned = ensure_managed_leader_pane(&transport, session, window, plan, workspace)?;
     persist_managed_leader_binding(plan, workspace, &spawned)?;
     spawn_managed_provider_startup_prompt_handler(
@@ -1029,7 +1034,9 @@ fn spawn_managed_provider_startup_prompt_handler(
     pane_id: String,
 ) {
     std::thread::spawn(move || {
-        let transport = TmuxBackend::for_workspace(&workspace);
+        // Phase 1d Batch 6: factory tmux workspace helper for
+        // grep-visibility. Semantics unchanged.
+        let transport = crate::transport_factory::tmux_workspace_transport(&workspace);
         let _ = handle_exec_provider_startup_prompts(
             provider,
             &workspace,
@@ -1042,9 +1049,13 @@ fn spawn_managed_provider_startup_prompt_handler(
 }
 
 fn tmux_transport_for_current_pane() -> TmuxBackend {
+    // Phase 1d Batch 6: factory tmux channel helpers for
+    // grep-visibility. Semantics unchanged; this is intentionally
+    // tmux-only (caller pane = tmux `$TMUX` endpoint or default socket,
+    // MUST-12 anchor).
     crate::tmux_backend::socket_name_from_tmux_env()
-        .map(|endpoint| TmuxBackend::for_tmux_endpoint(&endpoint))
-        .unwrap_or_else(TmuxBackend::new)
+        .map(|endpoint| crate::transport_factory::tmux_endpoint_transport(&endpoint))
+        .unwrap_or_else(crate::transport_factory::tmux_default_transport)
 }
 
 pub fn handle_exec_provider_startup_prompts(
@@ -1113,7 +1124,9 @@ fn provider_command_name(provider: Provider) -> &'static str {
 }
 
 fn tmux_session_exists(workspace: &Path, session: &SessionName) -> Result<bool, LeaderError> {
-    TmuxBackend::for_workspace(workspace)
+    // Phase 1d Batch 6: factory tmux workspace helper for
+    // grep-visibility. Tmux-only anchor (managed leader session lookup).
+    crate::transport_factory::tmux_workspace_transport(workspace)
         .has_session(session)
         .map_err(|e| LeaderError::Start(format!("tmux has-session failed: {e}")))
 }

package/crates/team-agent/src/leader/tests/lease_api.rs

@@ -302,3 +302,175 @@ fn r8_requeued_exhausted_watchers_event_payload_golden_shape() {
     assert_eq!(payload.get("count").and_then(|v| v.as_u64()), Some(1), "count == number of requeued watchers");
     assert_eq!(payload.get("trigger").and_then(|v| v.as_str()), Some("attach_leader"));
 }
+
+#[test]
+fn app_server_attach_writes_transport_kind_tuple_and_advances_epoch() {
+    let ws = std::env::temp_dir().join(format!(
+        "ta_rs_app_attach_{}_{}",
+        std::process::id(),
+        chrono::Utc::now().timestamp_millis()
+    ));
+    std::fs::create_dir_all(&ws).unwrap();
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &serde_json::json!({
+            "active_team_key": "team-a",
+            "teams": {"team-a": {"team_key": "team-a", "agents": {}}},
+        }),
+    )
+    .unwrap();
+    let fake = crate::app_server_test_support::FakeAppServer::start(
+        "attach-ok",
+        crate::app_server_test_support::FakeAppServerScript::happy(
+            "thread-live",
+            "session-live",
+            ws.to_str().unwrap(),
+        ),
+    );
+
+    let out = attach_app_server_leader(&ws, Some("team-a"), fake.endpoint(), "thread-live")
+        .expect("app-server attach should succeed");
+
+    assert_eq!(out["ok"], serde_json::json!(true));
+    assert_eq!(out["leader_receiver"]["transport_kind"], serde_json::json!("codex_app_server"));
+    assert_eq!(out["leader_receiver"]["mode"], serde_json::json!("codex_app_server"));
+    assert_eq!(
+        out["leader_receiver"]["app_server"]["thread_id"],
+        serde_json::json!("thread-live")
+    );
+    assert_eq!(
+        out["leader_receiver"]["app_server"]["session_id"],
+        serde_json::json!("session-live")
+    );
+    assert_eq!(
+        out["leader_receiver"]["app_server"]["cwd"],
+        serde_json::json!(ws.to_str().unwrap())
+    );
+
+    let saved = crate::state::projection::select_runtime_state(&ws, Some("team-a")).unwrap();
+    assert_eq!(
+        saved["leader_receiver"]["app_server"]["thread_id"],
+        serde_json::json!("thread-live")
+    );
+    assert_eq!(saved["leader_receiver"].get("pane_id"), None);
+    assert_eq!(saved["team_owner"]["transport_kind"], serde_json::json!("codex_app_server"));
+    assert_eq!(saved["owner_epoch"], serde_json::json!(1));
+}
+
+#[test]
+fn app_server_attach_rejects_world_writable_socket_without_state_write() {
+    let ws = std::env::temp_dir().join(format!(
+        "ta_rs_app_attach_badmode_{}_{}",
+        std::process::id(),
+        chrono::Utc::now().timestamp_millis()
+    ));
+    std::fs::create_dir_all(&ws).unwrap();
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &serde_json::json!({"active_team_key": "team-a", "teams": {"team-a": {"agents": {}}}}),
+    )
+    .unwrap();
+    let fake = crate::app_server_test_support::FakeAppServer::start(
+        "attach-world",
+        crate::app_server_test_support::FakeAppServerScript::happy(
+            "thread-live",
+            "session-live",
+            ws.to_str().unwrap(),
+        ),
+    );
+    let mut perms = std::fs::metadata(fake.path()).unwrap().permissions();
+    use std::os::unix::fs::PermissionsExt;
+    perms.set_mode(0o777);
+    std::fs::set_permissions(fake.path(), perms).unwrap();
+
+    let err = attach_app_server_leader(&ws, Some("team-a"), fake.endpoint(), "thread-live")
+        .expect_err("world-writable app-server socket must be rejected");
+    assert!(
+        err.to_string().contains("socket_ownership_invalid"),
+        "unexpected error: {err}"
+    );
+    let saved = crate::state::projection::select_runtime_state(&ws, Some("team-a")).unwrap();
+    assert!(
+        saved.get("leader_receiver").is_none(),
+        "failed attach must not write leader_receiver: {saved}"
+    );
+}
+
+#[test]
+fn app_server_attach_rejects_missing_user_agent_without_state_write() {
+    let ws = std::env::temp_dir().join(format!(
+        "ta_rs_app_attach_no_ua_{}_{}",
+        std::process::id(),
+        chrono::Utc::now().timestamp_millis()
+    ));
+    std::fs::create_dir_all(&ws).unwrap();
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &serde_json::json!({"active_team_key": "team-a", "teams": {"team-a": {"agents": {}}}}),
+    )
+    .unwrap();
+    let mut script = crate::app_server_test_support::FakeAppServerScript::happy(
+        "thread-live",
+        "session-live",
+        ws.to_str().unwrap(),
+    );
+    script.user_agent = None;
+    let fake = crate::app_server_test_support::FakeAppServer::start("attach-no-ua", script);
+
+    let err = attach_app_server_leader(&ws, Some("team-a"), fake.endpoint(), "thread-live")
+        .expect_err("missing initialize.userAgent must fail closed");
+    assert!(
+        err.to_string()
+            .contains("protocol_mismatch_missing_user_agent"),
+        "unexpected error: {err}"
+    );
+    let saved = crate::state::projection::select_runtime_state(&ws, Some("team-a")).unwrap();
+    assert!(
+        saved.get("leader_receiver").is_none(),
+        "failed attach must not write leader_receiver: {saved}"
+    );
+}
+
+#[test]
+fn app_server_delivery_paths_are_read_only_and_binding_entry_is_explicit() {
+    let delivery = include_str!("../../messaging/delivery.rs");
+    assert!(
+        !delivery.contains("write_owner(")
+            && !delivery.contains("with_leader_receiver(")
+            && !delivery.contains("with_team_owner("),
+        "MUST-12/I-RN-1: delivery may read typed leader_receiver fields but must not write ownership"
+    );
+    let lease = include_str!("../lease.rs");
+    assert!(
+        lease.contains("fn write_leader_receiver_transport("),
+        "C-5: mode and transport_kind must be stamped by a single receiver transport helper"
+    );
+    let cli = include_str!("../../cli/attach_app_server_leader.rs");
+    assert!(
+        cli.contains("attach_app_server_leader("),
+        "I-RN-2: app-server ownership mutation must be reachable through the explicit CLI entry"
+    );
+}
+
+#[test]
+fn messaging_leader_receiver_module_exports_no_ownership_writer() {
+    let leader_receiver = include_str!("../../messaging/leader_receiver.rs");
+    for forbidden in [
+        "pub fn claim_leader_receiver",
+        "write_owner(",
+        "with_leader_receiver(",
+        "with_team_owner(",
+        "save_runtime_state",
+    ] {
+        assert!(
+            !leader_receiver.contains(forbidden),
+            "MUST-12/I-RN-1: messaging/leader_receiver.rs may read receiver fields but must not expose ownership writes; forbidden={forbidden}"
+        );
+    }
+
+    let messaging_mod = include_str!("../../messaging/mod.rs");
+    assert!(
+        !messaging_mod.contains("claim_leader_receiver"),
+        "MUST-12/I-RN-2: messaging/mod.rs must not re-export ownership writer APIs"
+    );
+}

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

@@ -92,4 +92,27 @@ pub mod fake_worker;
 // tmux_backend — concrete tmux Transport executor (Command::new tmux via a CommandRunner seam);
 // the real spawn/capture/inject/has_session backend the daemon + launch use (step 9 shipped only
 // the trait + argv-builders). Real subprocess execution is the #[ignore] real-machine boundary.
+pub mod codex_app_server;
 pub mod tmux_backend;
+
+// 0.5.x Windows-native transport Phase 1: ConPTY backend + named-pipe
+// protocol. `protocol` is portable (pure logic, tested on all hosts);
+// `backend` compiles on all hosts and returns typed MuxUnavailable when
+// no pipe client is wired (honest degradation, not silent success).
+//
+// Truth source:
+// - Design: `.team/artifacts/0.5.x-windows-native-transport-design.md`
+//   §Transport Boundary + §Named Pipe Control Protocol + §Phase 1
+// - CR verdict: `.team/artifacts/0.5.x-windows-transport-cr-verdict.md`
+//   (7 constraints; C-1/C-2/C-3/C-5 anchor into this module)
+pub mod conpty;
+
+// 0.5.x Phase 1d Batch 0: backend assembly factory.
+// Truth sources:
+// - Design:    `.team/artifacts/0.5.x-backend-assembly-factory-design.md`
+// - CR verdict: `.team/artifacts/0.5.x-backend-factory-cr-verdict.md`
+//              (6 constraints anchored inside the module doc)
+pub mod transport_factory;
+
+#[cfg(test)]
+pub(crate) mod app_server_test_support;