@team-agent/installer 0.5.1 → 0.5.2

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

@@ -112,6 +112,10 @@ fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliE
         "claim-leader" => cmd_claim_leader(&claim_leader_args(args, cwd)).map(emit_result),
         // Real dispatch: `cmd_attach_leader` writes the `leader_receiver` binding.
         "attach-leader" => cmd_attach_leader(&attach_leader_args(args, cwd)?).map(emit_result),
+        "attach-app-server-leader" => {
+            cmd_attach_app_server_leader(&attach_app_server_leader_args(args, cwd)?)
+                .map(emit_result)
+        }
         "identity" => cmd_identity(&identity_args(args, cwd)).map(emit_result),
         "approvals" => cmd_approvals(&approvals_args(args, cwd)).map(emit_result),
         "inbox" => cmd_inbox(&inbox_args(args, cwd)?).map(emit_result),
@@ -167,6 +171,7 @@ const DISPATCH_COMMANDS: &[&str] = &[
     "takeover",
     "claim-leader",
     "attach-leader",
+    "attach-app-server-leader",
     "identity",
     "approvals",
     "inbox",
@@ -210,6 +215,23 @@ fn is_known_subcommand(command: &str) -> bool {
     DISPATCH_COMMANDS.contains(&command) || SPEC_ONLY_HELP_COMMANDS.contains(&command)
 }
 
+/// Test-only public accessor for `command_help` — allows integration
+/// tests to grep the help copy without depending on internal parser
+/// machinery.
+pub fn __test_command_help(command: Option<&str>) -> String {
+    command_help(command)
+}
+
+/// Test-only public accessor for `quick_start_args` — allows
+/// integration tests to exercise the parser without going through
+/// stdio + the full `main` entrypoint.
+pub fn __test_quick_start_args(
+    args: &[String],
+    cwd: &std::path::Path,
+) -> Result<crate::cli::types::QuickStartArgs, crate::cli::CliError> {
+    quick_start_args(args, cwd)
+}
+
 fn command_help(command: Option<&str>) -> String {
     match command {
         None => {
@@ -222,7 +244,7 @@ fn command_help(command: Option<&str>) -> String {
             )
         }
         Some("init") => "usage: team-agent init [--workspace WORKSPACE] [--force] [--json]".to_string(),
-        Some("quick-start") => "usage: team-agent quick-start [TEAMDIR] [--workspace WORKSPACE] [--name NAME] [--team-id TEAM|--team TEAM] [--yes] [--no-display] [--json]\n\ndefaults: display_backend=adaptive; set display_backend: none in TEAM.md or pass --no-display to use one worker window per agent.".to_string(),
+        Some("quick-start") => "usage: team-agent quick-start [TEAMDIR] [--workspace WORKSPACE] [--name NAME] [--team-id TEAM|--team TEAM] [--yes] [--no-display] [--backend tmux|conpty] [--json]\n\ndefaults: display_backend=adaptive; set display_backend: none in TEAM.md or pass --no-display to use one worker window per agent.\n\n--backend selects the worker transport (Phase 1d Batch 2): tmux (default on POSIX; unchanged behavior), conpty (Windows-native ConPTY worker transport; requires the shim binary and Windows host).".to_string(),
         Some("start") => "usage: team-agent start [TEAMDIR] [--yes] [--fresh] [--json]".to_string(),
         Some("compile") => "usage: team-agent compile --team TEAM [--out FILE] [--json]".to_string(),
         Some("send") => "usage: team-agent send TARGET MESSAGE... [--workspace WORKSPACE] [--team TEAM] [--targets AGENTS] [--to-name NAME] [--pane PANE] [--task TASK] [--sender SENDER] [--watch-result] [--requires-ack|--no-ack] [--no-wait] [--timeout SECONDS] [--confirm-human] [--message-id ID] [--json]\n\nMVP: name-based cross-workspace addressing assumes trusted local caller; no auth gate.".to_string(),
@@ -247,6 +269,7 @@ fn command_help(command: Option<&str>) -> String {
         Some("takeover") => "usage: team-agent takeover [--workspace WORKSPACE] [--team TEAM] [--confirm] [--json]".to_string(),
         Some("claim-leader") => "usage: team-agent claim-leader [--workspace WORKSPACE] [--team TEAM] [--confirm] [--json]".to_string(),
         Some("attach-leader") => "usage: team-agent attach-leader [--workspace WORKSPACE] [--team TEAM] [--pane PANE] [--provider PROVIDER] [--confirm] [--json]".to_string(),
+        Some("attach-app-server-leader") => "usage: team-agent attach-app-server-leader [--workspace WORKSPACE] [--team TEAM] --socket unix:///path.sock --thread-id THREAD_ID [--json]".to_string(),
         Some("identity") => "usage: team-agent identity [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("approvals") => "usage: team-agent approvals [AGENT] [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("inbox") => "usage: team-agent inbox AGENT [--workspace WORKSPACE] [--team TEAM] [--limit N] [--since CURSOR] [--json]".to_string(),
@@ -670,12 +693,18 @@ struct ParsedArgs {
     pane: Option<String>,
     to_name: Option<String>,
     provider: Option<String>,
+    socket: Option<String>,
+    thread_id: Option<String>,
     message_id: Option<String>,
     content: Option<String>,
     primary_error: Option<String>,
     agent_id: Option<String>,
     task_id: Option<String>,
     result_json: Option<String>,
+    /// 0.5.x Phase 1d Batch 2: quick-start `--backend <tmux|conpty>`.
+    /// Raw string (validated at the quick-start builder); the factory
+    /// enforces literal semantics.
+    backend: Option<String>,
 }
 
 fn parse_args(args: &[String]) -> ParsedArgs {
@@ -717,6 +746,7 @@ fn parse_args(args: &[String]) -> ParsedArgs {
             }
             "--force" => parsed.force = true,
             "--no-display" => parsed.no_display = true,
+            "--backend" => parsed.backend = next_arg(args, &mut i),
             "--discard-session" => parsed.discard_session = true,
             "--role-file" => parsed.role_file = next_arg(args, &mut i),
             "--as" => parsed.as_agent = next_arg(args, &mut i),
@@ -753,6 +783,8 @@ fn parse_args(args: &[String]) -> ParsedArgs {
             "--pane" => parsed.pane = next_arg(args, &mut i),
             "--to-name" => parsed.to_name = next_arg(args, &mut i),
             "--provider" => parsed.provider = next_arg(args, &mut i),
+            "--socket" => parsed.socket = next_arg(args, &mut i),
+            "--thread-id" => parsed.thread_id = next_arg(args, &mut i),
             "--message-id" => parsed.message_id = next_arg(args, &mut i),
             "--content" => parsed.content = next_arg(args, &mut i),
             "--primary-error" => parsed.primary_error = next_arg(args, &mut i),
@@ -770,6 +802,12 @@ fn parse_args(args: &[String]) -> ParsedArgs {
             other if other.starts_with("--provider=") => {
                 parsed.provider = Some(other.trim_start_matches("--provider=").to_string());
             }
+            other if other.starts_with("--socket=") => {
+                parsed.socket = Some(other.trim_start_matches("--socket=").to_string());
+            }
+            other if other.starts_with("--thread-id=") => {
+                parsed.thread_id = Some(other.trim_start_matches("--thread-id=").to_string());
+            }
             other if other.starts_with('-') => {}
             other => parsed.positionals.push(other.to_string()),
         }
@@ -833,6 +871,20 @@ fn quick_start_args(args: &[String], cwd: &Path) -> Result<QuickStartArgs, CliEr
     } else {
         workspace.join(agents_dir)
     };
+    // 0.5.x Phase 1d Batch 2: validate the `--backend` literal up-front
+    // so users get a fast, actionable error instead of a downstream
+    // factory refusal. Accept the same literals as the factory
+    // `RequestedTransportBackend::parse_literal`.
+    if let Some(literal) = parsed.backend.as_deref() {
+        let normalized = literal.trim().to_ascii_lowercase();
+        if normalized != "tmux" && normalized != "conpty" {
+            return Err(CliError::Usage(format!(
+                "--backend must be `tmux` or `conpty`, got {literal:?}. \
+                 `pty` is not a supported literal in Phase 1d (design \
+                 §Non-Goals + CR C-1 ②)."
+            )));
+        }
+    }
     Ok(QuickStartArgs {
         workspace,
         agents_dir,
@@ -841,6 +893,7 @@ fn quick_start_args(args: &[String], cwd: &Path) -> Result<QuickStartArgs, CliEr
         yes: parsed.yes,
         no_display: parsed.no_display,
         json: parsed.json,
+        backend: parsed.backend,
     })
 }
 
@@ -1079,6 +1132,26 @@ fn attach_leader_args(args: &[String], cwd: &Path) -> Result<AttachLeaderArgs, C
     })
 }
 
+fn attach_app_server_leader_args(
+    args: &[String],
+    cwd: &Path,
+) -> Result<AttachAppServerLeaderArgs, CliError> {
+    let parsed = parse_args(args);
+    Ok(AttachAppServerLeaderArgs {
+        workspace: workspace(&parsed, cwd),
+        team: parsed.team,
+        socket: parsed
+            .socket
+            .filter(|socket| !socket.is_empty())
+            .ok_or_else(|| CliError::Usage("missing --socket".to_string()))?,
+        thread_id: parsed
+            .thread_id
+            .filter(|thread_id| !thread_id.is_empty())
+            .ok_or_else(|| CliError::Usage("missing --thread-id".to_string()))?,
+        json: parsed.json,
+    })
+}
+
 fn identity_args(args: &[String], cwd: &Path) -> IdentityArgs {
     let parsed = parse_args(args);
     IdentityArgs {

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

@@ -53,6 +53,7 @@ pub(crate) const SEND_REMINDER: &str = "Message delivered. Wait for the worker t
 pub(crate) const STATUS_REMINDER: &str = "To wait for results use --watch-result or team-agent collect. Do not capture-pane worker terminals.";
 
 pub mod adapters;
+pub mod attach_app_server_leader;
 pub mod diagnose;
 pub mod emit;
 pub mod helpers;
@@ -64,6 +65,7 @@ pub mod status;
 pub mod types;
 
 pub use adapters::*;
+pub use attach_app_server_leader::*;
 pub use diagnose::*;
 pub use emit::*;
 pub use leader::*;
@@ -120,14 +122,16 @@ pub mod lifecycle_port {
         team_id: Option<&str>,
         yes: bool,
         open_display: bool,
+        backend: Option<&str>,
     ) -> Result<Value, CliError> {
-        match crate::lifecycle::quick_start_in_workspace_with_display(
+        match crate::lifecycle::quick_start_in_workspace_with_display_and_backend(
             workspace,
             agents_dir,
             name,
             yes,
             team_id,
             open_display,
+            backend,
         ) {
             Ok(report) => Ok(quick_start_value(report)),
             Err(e) => Ok(error_value(e)),
@@ -192,16 +196,40 @@ pub mod lifecycle_port {
         crate::tmux_backend::attach_command_for_workspace(cwd, session, window.as_str())
     }
     /// `runtime.shutdown`(`cmd_shutdown`)。
+    ///
+    /// 0.5.x Phase 1d Batch 5: the workspace-transport branch now routes
+    /// through `transport_factory::resolve_read_only_transport` so a
+    /// conpty team's shutdown reaches the shim rather than a
+    /// no-op tmux backend. Legacy tmux endpoint literal in state still
+    /// takes the `shutdown_transport_for_endpoint` tmux channel helper
+    /// path (intentional — this is the "attached explicit tmux
+    /// endpoint" branch and stays tmux-typed).
+    ///
+    /// `shutdown_with_transport_and_state` is generic over `&dyn
+    /// Transport`, so we hand the boxed factory backend down as
+    /// `&*box`. Factory refusal falls back to the workspace tmux
+    /// backend byte-equivalent to today so daemon liveness paths
+    /// don't crash.
     pub fn shutdown(workspace: &Path, keep_logs: bool, team: Option<&str>) -> Result<Value, CliError> {
         let run_ws = crate::model::paths::canonical_run_workspace(workspace)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         let state = shutdown_state_for_team(&run_ws, team)?;
-        let transport = if let Some(endpoint) = legacy_worker_tmux_endpoint(&state) {
-            shutdown_transport_for_endpoint(endpoint)
-        } else {
-            shutdown_workspace_transport(&run_ws)
-        };
-        shutdown_with_transport_and_state(workspace, keep_logs, team, &transport, Some(state))
+        if let Some(endpoint) = legacy_worker_tmux_endpoint(&state) {
+            let transport = shutdown_transport_for_endpoint(endpoint);
+            return shutdown_with_transport_and_state(
+                workspace, keep_logs, team, &transport, Some(state),
+            );
+        }
+        let boxed: Box<dyn crate::transport::Transport> =
+            match crate::transport_factory::resolve_read_only_transport(
+                &run_ws,
+                Some(&state),
+                crate::transport_factory::TransportPurpose::Shutdown,
+            ) {
+                Ok(r) => r.backend,
+                Err(_) => Box::new(shutdown_workspace_transport(&run_ws)),
+            };
+        shutdown_with_transport_and_state(workspace, keep_logs, team, boxed.as_ref(), Some(state))
     }
 
     /// E12 ①:从 state 锚 pane_id(leader_receiver/team_owner,top+teams)映射到其所在 session
@@ -1191,24 +1219,41 @@ pub mod lifecycle_port {
                 }
             }
         }
-        let workspace_transport = shutdown_workspace_transport(workspace);
-        match crate::transport::Transport::has_session(&workspace_transport, session) {
-            Ok(true) => residual = true,
-            Ok(false) => {}
-            Err(err) if tmux_absent_error(&err.to_string()) => {}
-            Err(err) => {
-                error.get_or_insert_with(|| err.to_string());
-                residual = true;
-            }
-        }
-        let default_transport = crate::tmux_backend::TmuxBackend::new();
-        match crate::transport::Transport::has_session(&default_transport, session) {
-            Ok(true) => residual = true,
-            Ok(false) => {}
-            Err(err) if tmux_absent_error(&err.to_string()) => {}
-            Err(err) => {
-                error.get_or_insert_with(|| err.to_string());
-                residual = true;
+        // 0.5.x Phase 1d Batch 5 (design §Batch 5 point 4): a ConPTY
+        // team's residual check MUST NOT read the workspace tmux socket
+        // + shared default tmux socket as evidence for/against ConPTY
+        // residual. Those probes are meaningless for a shim-owned pane
+        // universe: they will always return `has_session=false` (no
+        // tmux session exists) which would look like "no residual" but
+        // gives zero honest information about whether the shim / child
+        // panes have actually been reaped. Skip the tmux fallback
+        // probes when the primary transport is ConPTY; the primary
+        // transport check above already covered the honest question
+        // ("does the shim still have this session?").
+        let primary_is_conpty = matches!(
+            transport.kind(),
+            crate::transport::BackendKind::ConPty
+        );
+        if !primary_is_conpty {
+            let workspace_transport = shutdown_workspace_transport(workspace);
+            match crate::transport::Transport::has_session(&workspace_transport, session) {
+                Ok(true) => residual = true,
+                Ok(false) => {}
+                Err(err) if tmux_absent_error(&err.to_string()) => {}
+                Err(err) => {
+                    error.get_or_insert_with(|| err.to_string());
+                    residual = true;
+                }
+            }
+            let default_transport = crate::tmux_backend::TmuxBackend::new();
+            match crate::transport::Transport::has_session(&default_transport, session) {
+                Ok(true) => residual = true,
+                Ok(false) => {}
+                Err(err) if tmux_absent_error(&err.to_string()) => {}
+                Err(err) => {
+                    error.get_or_insert_with(|| err.to_string());
+                    residual = true;
+                }
             }
         }
         let sessions = if residual {

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

@@ -98,6 +98,8 @@ pub(crate) struct ResolvedNamedAddress {
     pub session_name: Option<String>,
     pub window_name: Option<String>,
     pub tmux_endpoint: Option<String>,
+    pub transport_kind: Option<String>,
+    pub app_server: Option<Value>,
     pub state_pane_id: Option<String>,
     pub state_pane_stale: bool,
     pub agent_status: Option<String>,
@@ -428,6 +430,8 @@ fn resolve_worker(
                 session_name: Some(session.to_string()),
                 window_name: Some(window.to_string()),
                 tmux_endpoint: transport.tmux_endpoint(),
+                transport_kind: Some("direct_tmux".to_string()),
+                app_server: None,
                 state_pane_id,
                 state_pane_stale,
                 agent_status,
@@ -541,6 +545,28 @@ fn resolve_leader(
         state.get("leader_receiver")
     }
     .ok_or_else(|| name_not_live_leader(team, None, None, None, transport.tmux_endpoint()))?;
+    if let Some((mode, transport_kind)) = receiver_transport_conflict(receiver) {
+        let mut err = NamedAddressError::new(
+            NamedAddressErrorKind::NameNotLive,
+            "leader_receiver mode/transport_kind conflict",
+        );
+        err.action =
+            "Rebind the leader: team-agent claim-leader, takeover, or attach-app-server-leader"
+                .to_string();
+        err.log = format!(
+            "name={team}/leader mode={mode} transport_kind={transport_kind} expected=single_transport_kind"
+        );
+        return Err(err);
+    }
+    if crate::codex_app_server::receiver_is_app_server(receiver) {
+        return resolve_app_server_leader(
+            sender_workspace,
+            target_workspace,
+            team,
+            parsed,
+            receiver,
+        );
+    }
     let pane_id = string_field(receiver, "pane_id")
         .filter(|pane| !pane.is_empty())
         .ok_or_else(|| name_not_live_leader(team, None, None, None, transport.tmux_endpoint()))?;
@@ -566,6 +592,8 @@ fn resolve_leader(
             session_name: session.map(str::to_string),
             window_name: window.map(str::to_string),
             tmux_endpoint: socket,
+            transport_kind: Some("direct_tmux".to_string()),
+            app_server: None,
             state_pane_id: Some(pane_id.to_string()),
             state_pane_stale: false,
             agent_status: None,
@@ -597,6 +625,87 @@ fn resolve_leader(
     }
 }
 
+fn receiver_transport_conflict(receiver: &Value) -> Option<(String, String)> {
+    let mode = receiver.get("mode").and_then(Value::as_str)?;
+    let transport_kind = receiver.get("transport_kind").and_then(Value::as_str)?;
+    if !mode.is_empty() && !transport_kind.is_empty() && mode != transport_kind {
+        return Some((mode.to_string(), transport_kind.to_string()));
+    }
+    None
+}
+
+fn resolve_app_server_leader(
+    sender_workspace: &Path,
+    target_workspace: &Path,
+    team: &str,
+    parsed: &ParsedNamedAddress,
+    receiver: &Value,
+) -> Result<ResolvedNamedAddress, NamedAddressError> {
+    let expected = crate::codex_app_server::binding_from_receiver(receiver).map_err(|error| {
+        let mut err = NamedAddressError::new(
+            NamedAddressErrorKind::NameNotLive,
+            format!("app-server leader receiver is incomplete: {error}"),
+        );
+        err.action = format!("Rebind the leader: team-agent attach-app-server-leader --team {team} --socket <socket> --thread-id <thread_id>");
+        err.log = format!("name={team}/leader expected=leader_receiver.app_server");
+        err
+    })?;
+    let actual = crate::codex_app_server::attach_probe(&expected.socket, &expected.thread_id)
+        .map_err(|error| {
+            let mut err = NamedAddressError::new(
+                NamedAddressErrorKind::NameNotLive,
+                format!("app-server leader thread is not live: {error}"),
+            );
+            err.action = format!("Rebind the leader: team-agent attach-app-server-leader --team {team} --socket {} --thread-id {}", expected.socket, expected.thread_id);
+            err.log = format!(
+                "name={team}/leader socket={} thread_id={} reason={}",
+                expected.socket,
+                expected.thread_id,
+                error
+            );
+            err
+        })?;
+    if actual.thread_id != expected.thread_id
+        || actual.session_id != expected.session_id
+        || actual.cwd != expected.cwd
+        || actual.cli_version != expected.cli_version
+    {
+        let mut err = NamedAddressError::new(
+            NamedAddressErrorKind::NameNotLive,
+            "app-server leader thread identity tuple is stale",
+        );
+        err.action = format!("Rebind the leader: team-agent attach-app-server-leader --team {team} --socket {} --thread-id {}", expected.socket, expected.thread_id);
+        err.log = format!(
+            "name={team}/leader expected_thread={} actual_thread={} expected_session={} actual_session={} expected_cwd={} actual_cwd={}",
+            expected.thread_id,
+            actual.thread_id,
+            expected.session_id,
+            actual.session_id,
+            expected.cwd,
+            actual.cwd
+        );
+        return Err(err);
+    }
+    Ok(ResolvedNamedAddress {
+        raw_name: parsed.display_name(),
+        target_kind: NamedTargetKind::Leader,
+        sender_workspace: sender_workspace.to_path_buf(),
+        target_workspace: target_workspace.to_path_buf(),
+        team_key: Some(team.to_string()),
+        agent_id: None,
+        pane_id: String::new(),
+        session_name: None,
+        window_name: None,
+        tmux_endpoint: None,
+        transport_kind: Some("codex_app_server".to_string()),
+        app_server: receiver.get("app_server").cloned(),
+        state_pane_id: None,
+        state_pane_stale: false,
+        agent_status: None,
+        warning: None,
+    })
+}
+
 fn resolve_session_window(
     sender_workspace: &Path,
     target_workspace: &Path,
@@ -619,6 +728,8 @@ fn resolve_session_window(
             session_name: Some(session.to_string()),
             window_name: Some(window.to_string()),
             tmux_endpoint: transport.tmux_endpoint(),
+            transport_kind: Some("direct_tmux".to_string()),
+            app_server: None,
             state_pane_id: None,
             state_pane_stale: false,
             agent_status: None,

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

@@ -17,7 +17,9 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
         }
         let content = args.message.join(" ");
         if content.is_empty() {
-            return Err(CliError::Usage("--to-name requires a non-empty message".to_string()));
+            return Err(CliError::Usage(
+                "--to-name requires a non-empty message".to_string(),
+            ));
         }
         let (resolved, transport) =
             match crate::cli::named_address::resolve_name_for_cli(&args.workspace, to_name) {
@@ -52,7 +54,9 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
         }
         let content = args.message.join(" ");
         if content.is_empty() {
-            return Err(CliError::Usage("--pane requires a non-empty message".to_string()));
+            return Err(CliError::Usage(
+                "--pane requires a non-empty message".to_string(),
+            ));
         }
         let mut value = send_to_pane_direct(
             &args.workspace,
@@ -191,13 +195,22 @@ fn send_to_named_pane_direct(
 
     let message_id = format!("named_send_{}", chrono::Utc::now().timestamp_millis());
     let rendered = render_message(sender, task_id, content, &message_id);
-    let target = Target::Pane(PaneId::new(&resolved.pane_id));
     let sender_run_workspace = crate::model::paths::canonical_run_workspace(sender_workspace)
         .unwrap_or_else(|_| sender_workspace.to_path_buf());
     let event_log = crate::event_log::EventLog::new(&sender_run_workspace);
     if let Some(warning) = &resolved.warning {
         eprintln!("warning: {warning}");
     }
+    if resolved.transport_kind.as_deref() == Some("codex_app_server") {
+        return send_to_named_app_server_leader(
+            &event_log,
+            resolved,
+            &message_id,
+            &rendered,
+            sender,
+        );
+    }
+    let target = Target::Pane(PaneId::new(&resolved.pane_id));
     let report = transport
         .inject(&target, &InjectPayload::Text(rendered), Key::Enter, true)
         .map_err(|e| {
@@ -241,6 +254,88 @@ fn send_to_named_pane_direct(
     Ok(value)
 }
 
+fn send_to_named_app_server_leader(
+    event_log: &crate::event_log::EventLog,
+    resolved: &crate::cli::named_address::ResolvedNamedAddress,
+    message_id: &str,
+    rendered: &str,
+    sender: &str,
+) -> Result<serde_json::Value, CliError> {
+    let receiver = serde_json::json!({
+        "mode": "codex_app_server",
+        "transport_kind": "codex_app_server",
+        "app_server": resolved.app_server.clone().unwrap_or(serde_json::Value::Null),
+    });
+    let binding = crate::codex_app_server::binding_from_receiver(&receiver)
+        .map_err(|error| CliError::Runtime(format!("invalid app-server named leader: {error}")))?;
+    let target_kind = named_target_kind_wire(resolved.target_kind);
+    let base_event = serde_json::json!({
+        "to_name": resolved.raw_name,
+        "target_kind": target_kind,
+        "sender": sender,
+        "sender_workspace": resolved.sender_workspace.display().to_string(),
+        "target_workspace": resolved.target_workspace.display().to_string(),
+        "team_key": resolved.team_key,
+        "agent_id": resolved.agent_id,
+        "transport_kind": "codex_app_server",
+        "socket": binding.socket,
+        "thread_id": binding.thread_id,
+        "message_id": message_id,
+    });
+    match crate::codex_app_server::submit_to_bound_thread(&binding, message_id, rendered) {
+        Ok(submit) => {
+            let event = merge_json(
+                base_event.clone(),
+                serde_json::json!({
+                    "ok": true,
+                    "turn_id": submit.turn_id,
+                    "turn_status": submit.turn_status,
+                }),
+            );
+            let _ = event_log.write("send.name_app_server", event.clone());
+            Ok(event)
+        }
+        Err(crate::codex_app_server::AppServerError::LeaderBusy(message)) => {
+            let event = merge_json(
+                base_event.clone(),
+                serde_json::json!({
+                    "ok": false,
+                    "status": "retry_scheduled",
+                    "reason": "leader_busy",
+                    "channel": "leader_busy",
+                    "error": message,
+                }),
+            );
+            let _ = event_log.write("send.name_app_server", event.clone());
+            Ok(event)
+        }
+        Err(error) => {
+            let event = merge_json(
+                base_event.clone(),
+                serde_json::json!({
+                    "ok": false,
+                    "status": "refused",
+                    "reason": error.code(),
+                    "channel": "rebind_required",
+                    "error": error.to_string(),
+                    "action": "run team-agent attach-app-server-leader for the target team",
+                }),
+            );
+            let _ = event_log.write("send.name_app_server", event.clone());
+            Ok(event)
+        }
+    }
+}
+
+fn merge_json(mut left: serde_json::Value, right: serde_json::Value) -> serde_json::Value {
+    if let (Some(left), Some(right)) = (left.as_object_mut(), right.as_object()) {
+        for (key, value) in right {
+            left.insert(key.clone(), value.clone());
+        }
+    }
+    left
+}
+
 fn named_target_kind_wire(kind: crate::cli::named_address::NamedTargetKind) -> &'static str {
     match kind {
         crate::cli::named_address::NamedTargetKind::Worker => "worker",

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

@@ -280,7 +280,29 @@ use rusqlite::params;
         if let (Some(session), Some(agents)) = (session, state.get("agents").and_then(Value::as_object)) {
             let run_ws = crate::model::paths::canonical_run_workspace(workspace)
                 .unwrap_or_else(|_| workspace.to_path_buf());
-            let backend = crate::tmux_backend::TmuxBackend::for_workspace(&run_ws);
+            // 0.5.x Phase 1d Batch 3: use the factory-resolved backend
+            // so conpty teams get their scrollback from the shim rather
+            // than a fake tmux capture that always returns empty. Tmux
+            // teams take the same code path as before (byte-equivalent).
+            let resolved = crate::transport_factory::resolve_read_only_transport(
+                &run_ws,
+                Some(state),
+                crate::transport_factory::TransportPurpose::Status,
+            );
+            let backend: Box<dyn crate::transport::Transport> = match resolved {
+                Ok(r) => r.backend,
+                Err(_) => {
+                    // Read-path fallback: refused factory means we don't
+                    // try to inspect approval prompts. Empty vec = no
+                    // waiting approvals, honest.
+                    return Ok(json!({
+                        "ok": true,
+                        "waiting": false,
+                        "waiting_count": 0,
+                        "approvals": [],
+                    }));
+                }
+            };
             for (agent_id, agent_state) in agents {
                 if agent.is_some_and(|wanted| wanted != agent_id) {
                     continue;
@@ -469,14 +491,30 @@ use rusqlite::params;
         }
         let run_ws = crate::model::paths::canonical_run_workspace(workspace)
             .unwrap_or_else(|_| workspace.to_path_buf());
-        let selection = crate::tmux_backend::tmux_backend_for_runtime_state_or_workspace(
+        // 0.5.x Phase 1d Batch 3: route through the factory so a
+        // conpty team does NOT get its `has_session` probe served by a
+        // tmux backend (which would always return false and drive the
+        // reader into a false `tmux_session_missing` state — design
+        // §Batch 3 Verification anchor). Tmux teams see byte-equivalent
+        // behavior because factory Layer 3 (legacy tmux endpoint) uses
+        // the same `tmux_backend_for_runtime_state_or_workspace` shape.
+        let resolved = crate::transport_factory::resolve_read_only_transport(
             &run_ws,
             Some(state),
+            crate::transport_factory::TransportPurpose::Status,
         );
-        selection
-            .backend
-            .has_session(&crate::transport::SessionName::new(name))
-            .unwrap_or(false)
+        match resolved {
+            Ok(r) => r
+                .backend
+                .has_session(&crate::transport::SessionName::new(name))
+                .unwrap_or(false),
+            Err(_) => {
+                // Factory refused (e.g. explicit conpty without a
+                // resolvable team_key). Honest: return false rather
+                // than pretend a tmux session exists.
+                false
+            }
+        }
     }
 
     fn message_counts(conn: &rusqlite::Connection, owner_team_id: Option<&str>) -> Result<Value, CliError> {