@team-agent/installer 0.5.1 → 0.5.3

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> {

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

@@ -75,6 +75,38 @@ fn leader_team(session: &str, pane: &str, socket: &str) -> serde_json::Value {
     })
 }
 
+fn app_server_leader_team(
+    ws: &Path,
+    endpoint: &str,
+    thread_id: &str,
+    session_id: &str,
+) -> serde_json::Value {
+    json!({
+        "session_name": "alpha-session",
+        "agents": {},
+        "leader_receiver": {
+            "mode": "codex_app_server",
+            "transport_kind": "codex_app_server",
+            "status": "attached",
+            "provider": "codex",
+            "owner_epoch": 3,
+            "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": 3
+        }
+    })
+}
+
 fn pane(session: &str, window: &str, pane_id: &str) -> PaneInfo {
     PaneInfo {
         pane_id: PaneId::new(pane_id),
@@ -323,6 +355,109 @@ fn resolve_leader_name_after_rebind() {
     let _ = std::fs::remove_dir_all(&ws);
 }
 
+// 0.5.x Windows portability Batch 5: `FakeAppServer` uses Unix
+// domain sockets — Unix-only.
+#[cfg(unix)]
+#[test]
+fn resolve_app_server_leader_name_uses_typed_receiver_not_tmux_pane() {
+    let ws = named_ws("appserver-leader-resolve");
+    let fake = crate::app_server_test_support::FakeAppServer::start(
+        "named-resolve",
+        crate::app_server_test_support::FakeAppServerScript::happy(
+            "thread-live",
+            "session-live",
+            ws.to_str().unwrap(),
+        ),
+    );
+    seed_state(
+        &ws,
+        state_with_teams(json!({
+            "alpha": app_server_leader_team(&ws, fake.endpoint(), "thread-live", "session-live")
+        })),
+    );
+
+    let resolved = resolve_name_with_transport(&ws, "alpha/leader", &OfflineTransport::new())
+        .expect("app-server leader name resolves by typed receiver");
+
+    assert_eq!(resolved.target_kind, NamedTargetKind::Leader);
+    assert_eq!(resolved.transport_kind.as_deref(), Some("codex_app_server"));
+    assert!(
+        resolved.pane_id.is_empty(),
+        "app-server leader is not pane-addressed"
+    );
+    assert_eq!(
+        resolved
+            .app_server
+            .as_ref()
+            .and_then(|app| app.get("thread_id"))
+            .and_then(serde_json::Value::as_str),
+        Some("thread-live")
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[test]
+fn resolve_app_server_leader_name_fails_closed_on_transport_conflict() {
+    let ws = named_ws("appserver-leader-conflict");
+    let mut team = app_server_leader_team(
+        &ws,
+        "unix:///tmp/team-agent-should-not-connect.sock",
+        "thread-live",
+        "session-live",
+    );
+    team["leader_receiver"]["mode"] = json!("direct_tmux");
+    seed_state(
+        &ws,
+        state_with_teams(json!({
+            "alpha": team
+        })),
+    );
+
+    let err = resolve_name_with_transport(&ws, "alpha/leader", &OfflineTransport::new())
+        .expect_err("conflicting mode/transport_kind must fail closed");
+
+    assert_eq!(err.kind, NamedAddressErrorKind::NameNotLive);
+    assert!(err.log.contains("mode=direct_tmux"), "{err}");
+    assert!(err.log.contains("transport_kind=codex_app_server"), "{err}");
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[cfg(unix)]
+#[test]
+fn send_to_name_app_server_leader_submits_turn_without_tmux_pane() {
+    let ws = named_ws("appserver-leader-send");
+    let fake = crate::app_server_test_support::FakeAppServer::start(
+        "named-send",
+        crate::app_server_test_support::FakeAppServerScript::happy(
+            "thread-live",
+            "session-live",
+            ws.to_str().unwrap(),
+        ),
+    );
+    seed_state(
+        &ws,
+        state_with_teams(json!({
+            "alpha": app_server_leader_team(&ws, fake.endpoint(), "thread-live", "session-live")
+        })),
+    );
+    let args = named_send_args(&ws, Some("alpha/leader"), None, None, &["hello appserver"]);
+
+    let result = cmd_send(&args).expect("named app-server send should succeed");
+    let value = match result.output {
+        CmdOutput::Json(value) => value,
+        other => panic!("expected json output, got {other:?}"),
+    };
+
+    assert_eq!(value["ok"], json!(true));
+    assert_eq!(value["transport_kind"], json!("codex_app_server"));
+    assert_eq!(fake.received_turns().len(), 1);
+    assert_eq!(
+        fake.received_turns()[0]["params"]["clientUserMessageId"],
+        value["message_id"]
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
 #[test]
 fn resolve_name_invalid_syntax() {
     let ws = named_ws("invalid");

package/crates/team-agent/src/cli/tests/run_delegation.rs

@@ -206,6 +206,7 @@ fn current_uid() -> Option<String> {
             team_id: None,
             yes: true,
             no_display: false,
+            backend: None,
             json: true,
         };
         let _ = cmd_quick_start(&args); // real quick_start compiles the spec before any coordinator/launch step
@@ -240,6 +241,7 @@ fn current_uid() -> Option<String> {
             team_id: None,
             yes: false,
             no_display: false,
+            backend: None,
             json: true,
         };
         let text = outcome_text(cmd_quick_start(&args));

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

@@ -272,6 +272,13 @@ pub struct QuickStartArgs {
     pub yes: bool,
     pub no_display: bool,
     pub json: bool,
+    /// 0.5.x Phase 1d Batch 2: explicit backend override
+    /// (`--backend <tmux|conpty>`). `None` = default (factory 5-layer
+    /// resolution; almost always `tmux` on a cold quick-start).
+    /// Explicit `Some("conpty")` on a host without a live shim client
+    /// surfaces `MuxUnavailable` honestly (CR C-1 ①) — NEVER silent
+    /// downgrade to tmux. Explicit `Some("pty")` refuses (CR C-1 ②).
+    pub backend: Option<String>,
     // Stage QR (quick-start/restart separation, design doc
     // .team/artifacts/quickstart-restart-separation-design.md): the
     // `fresh` field is intentionally REMOVED. Reset semantics now live
@@ -440,6 +447,16 @@ pub struct AttachLeaderArgs {
     pub json: bool,
 }
 
+/// Explicit Codex app-server leader binding args.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AttachAppServerLeaderArgs {
+    pub workspace: PathBuf,
+    pub team: Option<String>,
+    pub socket: String,
+    pub thread_id: String,
+    pub json: bool,
+}
+
 /// `identity`(`parser.py:256`)。
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct IdentityArgs {