@team-agent/installer 0.5.75 → 0.5.77

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

@@ -653,12 +653,30 @@ pub fn recover_watchers_for_incident(
 /// row for watcher-backed messages. A `submitted_pending_acceptance` row has
 /// already crossed the transport boundary and is claim-immutable. Any future
 /// retry belongs to a separate typed recovery arm, not attach/claim convergence.
+/// Compatibility helper retained for callers that only need the total.
+/// The typed recovery path below is the single writer; this wrapper performs
+/// no second requeue and only maps the first result to `total()`.
 pub(crate) fn requeue_blocked_leader_messages(
     store: &MessageStore,
     event_log: &EventLog,
     owner_team_id: &TeamKey,
     claimed_pane_id: &PaneId,
 ) -> Result<usize, MessagingError> {
+    requeue_blocked_leader_messages_with_counts(
+        store,
+        event_log,
+        owner_team_id,
+        claimed_pane_id,
+    )
+    .map(crate::message_store::BlockedLeaderRequeueCounts::total)
+}
+
+pub(crate) fn requeue_blocked_leader_messages_with_counts(
+    store: &MessageStore,
+    event_log: &EventLog,
+    owner_team_id: &TeamKey,
+    claimed_pane_id: &PaneId,
+) -> Result<crate::message_store::BlockedLeaderRequeueCounts, MessagingError> {
     // E6 (0.5.9 offline-mailbox §6.5): also requeue rows that a third-party
     // sender left in `queued_until_leader_attach` via the leader mailbox.
     // Same idempotent requeue funnel (row/message_id/leader_notification_log
@@ -690,7 +708,7 @@ pub(crate) fn requeue_blocked_leader_messages(
             }),
         )?;
     }
-    Ok(requeued)
+    Ok(counts)
 }
 
 /// `requeue_delivery_exhausted_watchers`: attach-leader 成功后把已经耗尽投递
@@ -702,12 +720,33 @@ pub(crate) fn requeue_blocked_leader_messages(
 /// `deliver_pending_messages` never re-picks — the new leader would never see the
 /// pending notification.
 pub fn requeue_delivery_exhausted_watchers(
-    _workspace: &Path,
+    workspace: &Path,
     store: &MessageStore,
     event_log: &EventLog,
     owner_team_id: &TeamKey,
     claimed_pane_id: &PaneId,
 ) -> Result<Vec<WatcherNotice>, MessagingError> {
+    requeue_delivery_exhausted_watchers_with_counts(
+        workspace,
+        store,
+        event_log,
+        owner_team_id,
+        claimed_pane_id,
+    )
+    .map(|(notices, _)| notices)
+}
+
+/// Attach-leader's typed recovery result. The counts come from the same
+/// owner-team scoped attach-recovery call (the watcher and message updates
+/// remain their existing transactions), so an attach caller can expose only
+/// this operation's debt rather than scanning arbitrary historical events.
+pub(crate) fn requeue_delivery_exhausted_watchers_with_counts(
+    _workspace: &Path,
+    store: &MessageStore,
+    event_log: &EventLog,
+    owner_team_id: &TeamKey,
+    claimed_pane_id: &PaneId,
+) -> Result<(Vec<WatcherNotice>, crate::message_store::BlockedLeaderRequeueCounts), MessagingError> {
     let conn = crate::db::schema::open_db(store.db_path())?;
     let mut stmt = conn.prepare(
         "select watcher_id, result_id, status from result_watchers
@@ -748,8 +787,13 @@ pub fn requeue_delivery_exhausted_watchers(
         )?;
     }
     drop(stmt);
-    let _ = requeue_blocked_leader_messages(store, event_log, owner_team_id, claimed_pane_id)?;
-    Ok(out)
+    let counts = requeue_blocked_leader_messages_with_counts(
+        store,
+        event_log,
+        owner_team_id,
+        claimed_pane_id,
+    )?;
+    Ok((out, counts))
 }
 
 /// `delivered_result_message` (`result_delivery.py:394`):内容级去重 —— 查某 result_id 是否已有

package/crates/team-agent/src/state/paths.rs

@@ -27,7 +27,7 @@
 use std::path::{Path, PathBuf};
 
 use crate::model::paths::{runtime_dir, runtime_spec_path};
-use crate::state::persist::load_runtime_state;
+use crate::state::persist::{load_runtime_state, load_runtime_state_without_migrations};
 use crate::state::projection::team_state_candidates;
 
 /// The identity of a team within a workspace. Carries the *workspace root*
@@ -193,10 +193,25 @@ impl CommandScope {
     /// On any I/O error the empty case is returned — destructive commands
     /// will run their own selector and surface the real error.
     pub fn resolve(workspace: &Path, requested_team: Option<&str>) -> Self {
+        Self::resolve_from_state(requested_team, load_runtime_state(workspace))
+    }
+
+    /// Ambiguity gate for read-only commands. Must not migrate or persist state.
+    pub fn resolve_readonly(workspace: &Path, requested_team: Option<&str>) -> Self {
+        Self::resolve_from_state(
+            requested_team,
+            load_runtime_state_without_migrations(workspace),
+        )
+    }
+
+    fn resolve_from_state(
+        requested_team: Option<&str>,
+        loaded: Result<serde_json::Value, crate::state::StateError>,
+    ) -> Self {
         if let Some(team) = requested_team.filter(|t| !t.is_empty()) {
             return Self::Resolved(team.to_string());
         }
-        let Ok(state) = load_runtime_state(workspace) else {
+        let Ok(state) = loaded else {
             return Self::EmptyWorkspace;
         };
         let alive = team_state_candidates(&state);

package/crates/team-agent/src/state/projection.rs

@@ -16,7 +16,8 @@ use serde_json::{json, Map, Value};
 
 use super::StateError;
 use crate::state::persist::{
-    load_runtime_state, save_runtime_state_with_deleted_agents,
+    load_runtime_state, load_runtime_state_without_migrations,
+    save_runtime_state_with_deleted_agents,
     save_runtime_state_with_lifecycle_topology_authority,
     save_runtime_state_with_lifecycle_topology_authority_and_capture_backfill_skip,
     save_runtime_state_with_team_tombstone_lifecycle_topology_authority,
@@ -504,7 +505,22 @@ pub fn resolve_runtime_team_scope(
     workspace: &Path,
     team: Option<&str>,
 ) -> Result<TeamScopeResolution, StateError> {
-    let state = load_runtime_state(workspace)?;
+    resolve_runtime_team_scope_loaded(load_runtime_state(workspace)?, team)
+}
+
+/// Same team selection as [`resolve_runtime_team_scope`], but never migrates or
+/// writes runtime state. Status and other read-only CLI surfaces must use this.
+pub fn resolve_runtime_team_scope_readonly(
+    workspace: &Path,
+    team: Option<&str>,
+) -> Result<TeamScopeResolution, StateError> {
+    resolve_runtime_team_scope_loaded(load_runtime_state_without_migrations(workspace)?, team)
+}
+
+fn resolve_runtime_team_scope_loaded(
+    state: Value,
+    team: Option<&str>,
+) -> Result<TeamScopeResolution, StateError> {
     let alive = team_state_candidates(&state);
     // Python `if team:` —— 空串 falsy,等同无 team(对抗 P1:此前 Some("") 误入 team 分支,空
     // team_dir 匹配致歧义/未找到错误串漂移)。

package/crates/team-agent/src/state/selector.rs

@@ -7,7 +7,9 @@ use serde_json::Value;
 
 use crate::model::paths::{canonical_run_workspace, runtime_spec_path, team_workspace};
 use crate::state::persist::runtime_state_path;
-use crate::state::projection::resolve_runtime_team_scope;
+use crate::state::projection::{
+    resolve_runtime_team_scope, resolve_runtime_team_scope_readonly, TeamScopeResolution,
+};
 use crate::state::StateError;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -35,6 +37,24 @@ pub fn resolve_active_team(
     input: &Path,
     team: Option<&str>,
     mode: SelectorMode,
+) -> Result<SelectedTeam, StateError> {
+    resolve_active_team_with(input, team, mode, resolve_runtime_team_scope)
+}
+
+/// Status-path selector: in-memory projection only, no runtime-state writeback.
+pub fn resolve_active_team_readonly(
+    input: &Path,
+    team: Option<&str>,
+    mode: SelectorMode,
+) -> Result<SelectedTeam, StateError> {
+    resolve_active_team_with(input, team, mode, resolve_runtime_team_scope_readonly)
+}
+
+fn resolve_active_team_with(
+    input: &Path,
+    team: Option<&str>,
+    mode: SelectorMode,
+    resolve_scope: fn(&Path, Option<&str>) -> Result<TeamScopeResolution, StateError>,
 ) -> Result<SelectedTeam, StateError> {
     let explicit_spec = input.join("team.spec.yaml");
     let (run_workspace, resolved) = if explicit_spec.exists() {
@@ -44,7 +64,7 @@ pub fn resolve_active_team(
         } else {
             team_run
         };
-        let resolved = resolve_runtime_team_scope(&run, team)?;
+        let resolved = resolve_scope(&run, team)?;
         (run, resolved)
     } else {
         let run =
@@ -59,7 +79,7 @@ pub fn resolve_active_team(
                 input.display()
             )));
         }
-        let resolved = resolve_runtime_team_scope(&run, team)?;
+        let resolved = resolve_scope(&run, team)?;
         (run, resolved)
     };
     let state = resolved.state;

package/crates/team-agent/src/test_support/models_timeout_fixture.rs

@@ -0,0 +1,122 @@
+use std::fs::OpenOptions;
+use std::io::{Read, Write};
+use std::os::unix::net::{UnixListener, UnixStream};
+use std::path::{Path, PathBuf};
+use std::process::{Command, Stdio};
+use std::time::Duration;
+
+const CHILD_FLAG: &str = "--team-agent-models-timeout-child";
+const LIST_MODELS_FLAG: &str = "--list-models";
+const RECEIPT_ENV: &str = "TEAM_AGENT_MODELS_TIMEOUT_RECEIPT";
+const MODE_ENV: &str = "TEAM_AGENT_MODELS_TIMEOUT_MODE";
+const READY_SOCKET_ENV: &str = "TEAM_AGENT_MODELS_TIMEOUT_READY_SOCKET";
+const STDOUT_MARKER: &[u8] = b"__team_agent_models_timeout_descendant_stdout_v1__\n";
+
+fn receipt_path() -> PathBuf {
+    std::env::var_os(RECEIPT_ENV)
+        .map(PathBuf::from)
+        .unwrap_or_else(|| std::process::exit(4))
+}
+
+fn append_receipt(path: &Path, key: &str, value: impl std::fmt::Display) -> Result<(), ()> {
+    let mut receipt = OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(path)
+        .map_err(|_| ())?;
+    writeln!(receipt, "{key}={value}").map_err(|_| ())
+}
+
+fn child_main(args: &[String]) {
+    if args.len() != 1 || args[0] != CHILD_FLAG {
+        std::process::exit(5);
+    }
+    let receipt = receipt_path();
+    let socket = std::env::var_os(READY_SOCKET_ENV)
+        .map(PathBuf::from)
+        .unwrap_or_else(|| std::process::exit(5));
+
+    let mut stdout = std::io::stdout();
+    if stdout.write_all(STDOUT_MARKER).is_err() || stdout.flush().is_err() {
+        std::process::exit(5);
+    }
+    if append_receipt(&receipt, "child_argv_exact", 1).is_err()
+        || append_receipt(&receipt, "descendant_pid", std::process::id()).is_err()
+        || append_receipt(&receipt, "descendant_started", 1).is_err()
+        || append_receipt(&receipt, "descendant_stdout_inherited", 1).is_err()
+    {
+        std::process::exit(5);
+    }
+
+    let mut ready = UnixStream::connect(socket).unwrap_or_else(|_| std::process::exit(5));
+    if ready.write_all(b"1").is_err() {
+        std::process::exit(5);
+    }
+    std::thread::sleep(Duration::from_secs(2));
+}
+
+fn main() {
+    let args: Vec<String> = std::env::args().skip(1).collect();
+    if args.first().is_some_and(|arg| arg == CHILD_FLAG) {
+        child_main(&args);
+        return;
+    }
+    if args.len() != 1 || args[0] != LIST_MODELS_FLAG {
+        std::process::exit(2);
+    }
+
+    match std::env::var(MODE_ENV) {
+        Ok(mode) if mode == "exit7" => {
+            eprintln!("sensitive-token");
+            std::process::exit(7);
+        }
+        Ok(mode) if mode == "oversize" => {
+            let mut stdout = std::io::stdout();
+            let bytes = [b'x'; 64];
+            let _ = stdout.write_all(&bytes);
+            let _ = stdout.flush();
+            return;
+        }
+        Ok(mode) if mode == "sleep" => {
+            std::thread::sleep(Duration::from_secs(2));
+            return;
+        }
+        Ok(mode) if mode == "descendant" => {}
+        Err(std::env::VarError::NotPresent) => {}
+        Ok(_) | Err(std::env::VarError::NotUnicode(_)) => std::process::exit(2),
+    }
+
+    let receipt = receipt_path();
+    let socket = PathBuf::from(format!("{}.sock", receipt.display()));
+    let _ = std::fs::remove_file(&socket);
+    let listener = UnixListener::bind(&socket).unwrap_or_else(|_| std::process::exit(4));
+    if append_receipt(&receipt, "parent_started_once", 1).is_err()
+        || append_receipt(&receipt, "parent_argv_exact", 1).is_err()
+        || append_receipt(&receipt, "parent_pid", std::process::id()).is_err()
+        || append_receipt(&receipt, "child_spawn_attempts", 1).is_err()
+    {
+        std::process::exit(4);
+    }
+
+    let executable = std::env::current_exe().unwrap_or_else(|_| std::process::exit(4));
+    let child = Command::new(executable)
+        .arg(CHILD_FLAG)
+        .env(RECEIPT_ENV, &receipt)
+        .env(READY_SOCKET_ENV, &socket)
+        .stdin(Stdio::null())
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::null())
+        .spawn()
+        .unwrap_or_else(|_| std::process::exit(4));
+    let (mut ready, _) = listener.accept().unwrap_or_else(|_| std::process::exit(4));
+    let mut byte = [0_u8; 1];
+    if ready.read_exact(&mut byte).is_err() || byte != [b'1'] {
+        std::process::exit(4);
+    }
+    if append_receipt(&receipt, "child_pid", child.id()).is_err() {
+        std::process::exit(4);
+    }
+    let _ = std::fs::remove_file(&socket);
+    // The parent exits successfully without waiting; the child retains the
+    // inherited stdout pipe and self-exits after the real reader deadline.
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.75",
+  "version": "0.5.77",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.5.75",
-    "@team-agent/cli-darwin-x64": "0.5.75",
-    "@team-agent/cli-linux-x64": "0.5.75"
+    "@team-agent/cli-darwin-arm64": "0.5.77",
+    "@team-agent/cli-darwin-x64": "0.5.77",
+    "@team-agent/cli-linux-x64": "0.5.77"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",