@team-agent/installer 0.5.78 → 0.5.81

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

@@ -1,5 +1,7 @@
 //!
-//! StateRepository facade.
+//! StateRepository facade. Task/note commits apply bounded mutations under the
+//! existing state-save lock; coordinator commits carry only observation deltas.
+//! Other writer clusters retain their legacy dispatch below.
 //!
 //! Ref:
 //! - `.team/artifacts/s1a-state-repository-design.md` (skeleton)
@@ -142,8 +144,152 @@ impl<'a> StateRepository<'a> {
     where
         F: FnOnce(&mut Value),
     {
+        #[cfg(test)]
+        test_support::before_commit();
         route_reapply(self.workspace, intent, state, reapply)
     }
+
+    /// Commit a task/note delta once against latest under state-save. Return
+    /// the committed Team view for callers that produce Markdown afterwards.
+    pub fn commit<F>(&self, intent: StateWriteIntent<'_>, update: F) -> Result<Value, StateError>
+    where
+        F: FnOnce(&mut Value),
+    {
+        #[cfg(test)]
+        test_support::before_commit();
+        let team_key = match intent {
+            // Assignment's existing reconcile helper updates the root task
+            // array and the explicit Team array independently (legacy parity).
+            StateWriteIntent::McpAssignTask { .. } => None,
+            StateWriteIntent::McpUpdateStateNote { team_key } => team_key,
+            StateWriteIntent::ResultCollection { owner_team_id } => owner_team_id,
+            _ => return Err(StateError::SaveFailed("intent does not accept a task/note delta".into())),
+        };
+        let committed = super::persist::update_runtime_state(self.workspace, |latest| {
+            let mut selected = bounded_team_view(latest, team_key)?;
+            update(&mut selected);
+            Ok(match team_key {
+                Some(key) => super::projection::merge_committed_team(latest, &selected, key),
+                None => selected,
+            })
+        })?;
+        bounded_team_view(&committed, team_key)
+    }
+
+    /// Fence the sampled incarnation with the existing persist guards, then
+    /// commit only this tick's agent observations and coordinator bookkeeping.
+    pub fn commit_observations(
+        &self,
+        intent: StateWriteIntent<'_>,
+        before: &Value,
+        observed: &Value,
+    ) -> Result<(), StateError> {
+        let StateWriteIntent::CoordinatorTick { team_key } = intent else {
+            return Err(StateError::SaveFailed("intent does not accept observations".into()));
+        };
+        let sampled_legacy =
+            legacy_single_team_state(before) && legacy_single_team_state(observed);
+        let sampled_identity = legacy_team_identity(before);
+        super::persist::update_runtime_state(self.workspace, |latest| {
+            if sampled_legacy {
+                if sampled_identity != legacy_team_identity(observed)
+                    || !legacy_single_team_state(latest)
+                    || sampled_identity != legacy_team_identity(latest)
+                {
+                    return Err(StateError::SaveConflict(
+                        "legacy coordinator observation scope changed before commit".to_string(),
+                    ));
+                }
+                let mut checked = observed.clone();
+                super::persist::merge_ordinary_state(&mut checked, latest)?;
+                if !legacy_single_team_state(&checked)
+                    || sampled_identity != legacy_team_identity(&checked)
+                {
+                    return Err(StateError::SaveConflict(
+                        "legacy coordinator observation scope changed during validation"
+                            .to_string(),
+                    ));
+                }
+                let mut selected = latest.clone();
+                for field in ["agents", "coordinator"] {
+                    if before[field] != checked[field] {
+                        apply_observation_delta(
+                            &before[field],
+                            &checked[field],
+                            &mut selected[field],
+                        );
+                    }
+                }
+                return Ok(selected);
+            }
+            let mut checked = super::projection::merge_committed_team(latest, observed, team_key);
+            super::persist::merge_ordinary_state(&mut checked, latest)?;
+            let checked = bounded_team_view(&checked, Some(team_key))?;
+            let mut selected = bounded_team_view(latest, Some(team_key))?;
+            for field in ["agents", "coordinator"] {
+                if before[field] != checked[field] {
+                    apply_observation_delta(&before[field], &checked[field], &mut selected[field]);
+                }
+            }
+            Ok(super::projection::merge_committed_team(latest, &selected, team_key))
+        })?;
+        Ok(())
+    }
+}
+
+fn legacy_single_team_state(state: &Value) -> bool {
+    match state.get("teams") {
+        None => true,
+        Some(Value::Object(teams)) => teams.is_empty(),
+        Some(_) => false,
+    }
+}
+
+fn legacy_team_identity(state: &Value) -> [Option<String>; 5] {
+    [
+        "active_team_key",
+        "team_key",
+        "session_name",
+        "team_dir",
+        "spec_path",
+    ]
+    .map(|field| {
+        state
+            .get(field)
+            .and_then(Value::as_str)
+            .filter(|value| !value.is_empty())
+            .map(str::to_string)
+    })
+}
+
+fn bounded_team_view(state: &Value, team_key: Option<&str>) -> Result<Value, StateError> {
+    let Some(key) = team_key else { return Ok(state.clone()); };
+    if state.get("teams").and_then(Value::as_object).is_some_and(|teams| teams.contains_key(key)) {
+        return Ok(super::projection::project_top_level_view(state, key));
+    }
+    if state.get("teams").and_then(Value::as_object).is_some_and(|teams| !teams.is_empty()) {
+        return Err(StateError::TeamSelect(format!("team no longer exists: {key}")));
+    }
+    Ok(state.clone())
+}
+
+// Diffing is limited to the two observation blocks above, never a whole-state
+// merge. Equal fields retain a concurrent writer's value; removed fields clear.
+fn apply_observation_delta(before: &Value, observed: &Value, latest: &mut Value) {
+    if before == observed { return; }
+    if let Some(observed) = observed.as_object() {
+        if !latest.is_object() { *latest = serde_json::json!({}); }
+        if let Some(before) = before.as_object() {
+            for key in before.keys().filter(|key| !observed.contains_key(*key)) {
+                if let Some(latest) = latest.as_object_mut() { latest.remove(key); }
+            }
+        }
+        for (key, value) in observed {
+            apply_observation_delta(&before[key], value, &mut latest[key]);
+        }
+    } else {
+        *latest = observed.clone();
+    }
 }
 
 /// Closed semantic catalog of workspace state writes. Every allowlisted
@@ -555,6 +701,11 @@ fn route_reapply<F>(
 where
     F: FnOnce(&mut Value),
 {
+    if matches!(&intent, StateWriteIntent::McpAssignTask { .. }
+        | StateWriteIntent::McpUpdateStateNote { .. } | StateWriteIntent::ResultCollection { .. })
+    {
+        return StateRepository::new(workspace).commit(intent, reapply).map(|_| ());
+    }
     if reapply_scope(&intent) == ReapplyScope::Team {
         helper_write_team_scoped_reapply(workspace, state, reapply)
     } else {
@@ -564,3 +715,20 @@ where
 
 #[cfg(test)]
 mod tests;
+
+#[cfg(test)]
+pub(crate) mod test_support {
+    thread_local! {
+        static BEFORE_COMMIT: std::cell::RefCell<Option<Box<dyn FnOnce()>>> = const {
+            std::cell::RefCell::new(None)
+        };
+    }
+
+    pub(crate) fn set_before_commit(hook: impl FnOnce() + 'static) {
+        BEFORE_COMMIT.with(|slot| *slot.borrow_mut() = Some(Box::new(hook)));
+    }
+
+    pub(super) fn before_commit() {
+        if let Some(hook) = BEFORE_COMMIT.with(|slot| slot.borrow_mut().take()) { hook(); }
+    }
+}

package/crates/team-agent/src/tmux_backend/tests.rs

@@ -355,6 +355,34 @@ fn backend_with(default: MockResp, queued: Vec<MockResp>) -> (TmuxBackend, Recor
     (TmuxBackend::with_runner(Box::new(runner)), recorded)
 }
 
+#[test]
+fn provider_exit_receipt_accepts_only_shell_exit_status() {
+    for (text, expected) in [
+        ("", None),
+        ("running", None),
+        ("[team-agent] pi exited with 0", None),
+        ("256", None),
+        ("0\n", Some(0)),
+        ("17\n", Some(17)),
+        ("143\n", Some(143)),
+    ] {
+        let (backend, recorded) = backend_with(MockResp::Out(ok(text)), Vec::new());
+        assert_eq!(
+            backend.provider_exit_status(&PaneId::new("%47")).unwrap(),
+            expected
+        );
+        let calls = recorded.lock().unwrap();
+        assert_eq!(calls.len(), 1);
+        assert_eq!(calls[0][4], "%47");
+        assert_eq!(calls[0][5], "#{@team-agent-provider-exit-status}");
+    }
+    let (backend, _) = backend_with(MockResp::Out(fail(1, "pane unavailable")), Vec::new());
+    assert_eq!(
+        backend.provider_exit_status(&PaneId::new("%47")).unwrap(),
+        None
+    );
+}
+
 fn backend_with_stdin(
     default: MockResp,
     queued: Vec<MockResp>,

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

@@ -2656,24 +2656,22 @@ fn append_caller_context_assignments(parts: &mut Vec<String>, provider: Option<&
     ));
 }
 
-/// 0.4.x (CR R6): single-source marker prefix. The exit marker emitted by
-/// `leader_shell_wrapper_command` and the substring detected by
-/// `leader_provider_health` MUST share this prefix exactly. Format:
+/// Public exit-marker text emitted by `leader_shell_wrapper_command`. Format:
 /// `"[team-agent] {provider_label} exited with {rc}"`.
 pub const LEADER_PROVIDER_EXIT_MARKER_PREFIX: &str = "[team-agent]";
 pub const LEADER_PROVIDER_EXIT_MARKER_SUFFIX: &str = "exited with";
+const PROVIDER_EXIT_STATUS_OPTION: &str = "@team-agent-provider-exit-status";
 
 /// 0.4.x (CR R6): build the leader exit marker text for `provider_label`.
-/// Used by both the shell wrapper (printf source) and the health check
-/// (capture substring) so they cannot drift.
+/// Used by the shell wrapper for human-readable output.
 /// ---
 /// purpose: 单一来源地拼出 leader pane 的 provider 退出标记文本
 /// params:
 ///   provider_label: 人类可读的 provider 名,原样嵌入标记
 /// returns: 前缀 + provider 名 + 后缀 拼成的标记(不含退出码,退出码由 shell 的 printf 补)
 /// boundary:
-///   - 写标记的 shell wrapper 与读标记的健康检查必须都用这一个函数,禁止各写一份字面量
-///   - 这是内容信号:pane 里出现同样文本(如 cat 日志)就会误触发,判定强度到此为止
+///   - shell wrapper 统一使用此显示标记,进程状态另由监督 shell 收据证明
+///   - 仅供显示;历史正文可包含相同文本,不得据此判定进程退出
 /// ---
 pub fn leader_provider_exit_marker(provider_label: &str) -> String {
     format!(
@@ -2905,6 +2903,11 @@ pub fn leader_shell_wrapper_command(
         parts.push(key.clone());
         parts.push("&&".to_string());
     }
+    // Clear any prior receipt before invoking the provider. Terminal content,
+    // including replayed sessions, must never be treated as an exit receipt.
+    parts.push(format!(
+        "{{ tmux -S \"${{TMUX%%,*}}\" set-option -p -t \"$TMUX_PANE\" {PROVIDER_EXIT_STATUS_OPTION} running >/dev/null 2>&1 || :; }} &&"
+    ));
     // 3. env exports + provider (NO `exec` so the provider is a child).
     // 0.4.x ordering fix: skip keys present in env_unset so KEY=val does not
     // re-introduce a just-unset variable from the inherited env map.
@@ -2918,6 +2921,9 @@ pub fn leader_shell_wrapper_command(
     parts.push(";".to_string());
     // 4. exit marker + inert shell tail
     parts.push("rc=$?;".to_string());
+    parts.push(format!(
+        "tmux -S \"${{TMUX%%,*}}\" set-option -p -t \"$TMUX_PANE\" {PROVIDER_EXIT_STATUS_OPTION} \"$rc\" >/dev/null 2>&1;"
+    ));
     parts.push("printf".to_string());
     // CR R6: marker text comes from single-source `leader_provider_exit_marker`.
     parts.push(shell_quote(&format!(
@@ -2930,8 +2936,8 @@ pub fn leader_shell_wrapper_command(
 }
 
 fn inert_pane_tail_command() -> String {
-    // `sh` is deliberate: provider-exit health checks use the shell basename
-    // to reach the exit-marker branch. `sh -c` does not read commands from
+    // `sh` is deliberate: exited-wrapper input classifiers recognize shell
+    // basenames. `sh -c` does not read commands from
     // stdin; disabling echo also prevents input from appearing accepted.
     let script = r#"trap '' INT QUIT; stty -echo 2>/dev/null; printf "%s\n" "[team-agent] Provider exited; this pane no longer accepts input. Restart from another pane with the appropriate team-agent start command."; while :; do sleep 3600 & wait "$!"; done"#;
     format!("exec /bin/sh -c {}", shell_quote(script))
@@ -3743,6 +3749,22 @@ impl Transport for TmuxBackend {
         Ok(Some(output.stdout.trim().to_string()))
     }
 
+    fn provider_exit_status(&self, pane: &PaneId) -> Result<Option<u8>, TransportError> {
+        let argv = self.tmux_argv(&[
+            "tmux".to_string(),
+            "display-message".to_string(),
+            "-p".to_string(),
+            "-t".to_string(),
+            pane.as_str().to_string(),
+            format!("#{{{PROVIDER_EXIT_STATUS_OPTION}}}"),
+        ]);
+        let output = self.runner.run(&argv)?;
+        if !output.success {
+            return Ok(None);
+        }
+        Ok(output.stdout.trim().parse::<u8>().ok())
+    }
+
     fn liveness(&self, pane: &PaneId) -> Result<PaneLiveness, TransportError> {
         let argv = self.tmux_argv(&[
             "tmux".to_string(),

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

@@ -981,6 +981,12 @@ pub trait Transport: Send + Sync {
     /// pane 存活三态(`PaneLiveness`,bug-085 穷尽 match;unknown ≠ dead ≠ live)。
     fn liveness(&self, pane: &PaneId) -> Result<PaneLiveness, TransportError>;
 
+    /// Exit status recorded by the provider's supervising wrapper, never inferred
+    /// from terminal text. None means running or no authoritative receipt.
+    fn provider_exit_status(&self, _pane: &PaneId) -> Result<Option<u8>, TransportError> {
+        Ok(None)
+    }
+
     /// Cheap direct pane existence check when a backend can prove it. `Ok(None)`
     /// preserves the existing Unknown boundary.
     fn has_pane(&self, pane: &PaneId) -> Result<Option<bool>, TransportError> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.78",
+  "version": "0.5.81",
   "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.78",
-    "@team-agent/cli-darwin-x64": "0.5.78",
-    "@team-agent/cli-linux-x64": "0.5.78"
+    "@team-agent/cli-darwin-arm64": "0.5.81",
+    "@team-agent/cli-darwin-x64": "0.5.81",
+    "@team-agent/cli-linux-x64": "0.5.81"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",