@team-agent/installer 0.5.0 → 0.5.2

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,238 @@ 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
+            }
+        }
+    })
+}
+
+#[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:?}"
+    );
+}
+
+#[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:?}"
+    );
+}
+
+#[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/tmux_backend.rs

@@ -430,6 +430,37 @@ fn runtime_tmux_endpoint_from_state(
 /// stable FNV-1a hash over the canonicalized path. AF_UNIX `sun_path` is ~104 chars and the socket
 /// lives at `/tmp/tmux-<uid>/<name>`, so we must NOT use the (~88-char) session name. §10: a
 /// canonicalize failure falls back to the raw path (never panics).
+/// Public re-export of the crate-private canonical workspace hash used
+/// by the tmux short-socket derivation. `transport_factory` uses this
+/// same hash for the ConPTY `workspace_hash` so both backends see
+/// identical workspace identity. Adding a wrapper (not calling
+/// `socket_name_for_workspace` directly outside this file) keeps the
+/// existing internal API stable.
+pub fn workspace_short_hash_pub(workspace: &Path) -> String {
+    // The tmux short-socket name is `ta-<12 hex>`; the workspace-hash
+    // used by the ConPTY workspace identity is the raw 12-hex portion
+    // (no `ta-` prefix), which is what the shim/pipe name derivation
+    // expects. Reuse the exact same hash so drift is impossible.
+    let name = socket_name_for_workspace(workspace);
+    name.strip_prefix("ta-").unwrap_or(&name).to_string()
+}
+
+/// Public re-export of the crate-private `runtime_tmux_endpoint_from_state`
+/// probe. `transport_factory` uses this to spot the legacy tmux endpoint
+/// in `state` without duplicating the field-precedence logic.
+pub fn runtime_tmux_endpoint_from_state_pub(
+    state: Option<&serde_json::Value>,
+) -> Option<(String, &'static str)> {
+    runtime_tmux_endpoint_from_state(state).map(|(endpoint, source)| {
+        let src = match source {
+            RuntimeTmuxEndpointSource::StateTmuxEndpoint => "state.tmux_endpoint",
+            RuntimeTmuxEndpointSource::StateTmuxSocket => "state.tmux_socket",
+            RuntimeTmuxEndpointSource::WorkspaceFallback => "workspace_fallback",
+        };
+        (endpoint.to_string(), src)
+    })
+}
+
 pub(crate) fn socket_name_for_workspace(workspace: &Path) -> String {
     let canonical = workspace
         .canonicalize()