@team-agent/installer 0.5.49 → 0.5.51

package/crates/team-agent/src/messaging/tests/runtime.rs

@@ -18,12 +18,11 @@ fn pane_info(pane_id: &str, session: &str, window: &str) -> PaneInfo {
 }
 
 // ════════════════════════════════════════════════════════════════════════
-// GROUP E — _fail_leader_delivery: bug-52 fallback-log semantics. ok=True but
-// status=FallbackLog (NOT a real submit). leader.py:394-436.
+// GROUP E — legacy diagnostics may only advance an existing durable row.
 // ════════════════════════════════════════════════════════════════════════
 
 #[test]
-fn fail_leader_delivery_returns_fallback_log_ok_true_not_submitted() {
+fn fail_leader_delivery_without_message_id_does_not_invent_a_row() {
     let ws = tmp_ws("faillead");
     let payload = json(serde_json::json!({
         "to": "leader", "content": "hi", "sender": "coordinator"
@@ -35,12 +34,17 @@ fn fail_leader_delivery_returns_fallback_log_ok_true_not_submitted() {
         Some("No direct leader tmux pane is attached. Run team-agent attach-leader."),
     )
     .unwrap();
-    // leader.py:423-431 — ok True, status fallback_log, channel fallback_inbox.
-    assert!(out.ok);
+    assert!(!out.ok);
     assert_eq!(out.status, DeliveryStatus::FallbackLog);
     assert_eq!(out.reason, Some(DeliveryRefusal::LeaderNotAttached));
-    // The audit must be distinguishable from a real submit (Delivered).
+    assert_eq!(out.message_id, None);
     assert_ne!(out.status, DeliveryStatus::Delivered);
+    let store = MessageStore::open(&ws).unwrap();
+    let connection = crate::db::schema::open_db(store.db_path()).unwrap();
+    let rows: i64 = connection
+        .query_row("select count(*) from messages", [], |row| row.get(0))
+        .unwrap();
+    assert_eq!(rows, 0, "diagnostics cannot create a fallback message row");
 }
 
 // ════════════════════════════════════════════════════════════════════════
@@ -439,28 +443,30 @@ fn message_not_silently_stuck_accepted_when_coordinator_dead() {
     )
     .unwrap();
 
-    assert!(!out.ok);
-    assert_eq!(out.status, DeliveryStatus::Degraded);
-    assert_eq!(out.message_status.0, "degraded");
+    assert!(out.ok, "durable persistence is the send success boundary");
+    assert_eq!(out.status, DeliveryStatus::Blocked);
+    assert_eq!(out.message_status.0, "queued_coordinator_unavailable");
+    assert!(out.message_id.as_deref().is_some_and(|id| id.starts_with("msg_")));
     assert_eq!(out.reason, Some(DeliveryRefusal::CoordinatorUnavailable));
     assert!(
         out.verification
             .as_deref()
             .is_some_and(|warning| warning.contains("coordinator is not running")),
-        "N38 warning must explain why the message was not queued; out={out:?}"
+        "N38 warning must explain the durable retry blocker; out={out:?}"
     );
     let store = MessageStore::open(&ws).unwrap();
     let conn = crate::db::schema::open_db(store.db_path()).unwrap();
-    let accepted: i64 = conn
+    let blocked: i64 = conn
         .query_row(
-            "select count(*) from messages where status = 'accepted'",
+            "select count(*) from messages where status = 'queued_coordinator_unavailable' \
+             and error = 'coordinator_unavailable' and delivered_at is null",
             [],
             |row| row.get(0),
         )
         .unwrap();
     assert_eq!(
-        accepted, 0,
-        "dead coordinator send must not strand an accepted row"
+        blocked, 1,
+        "dead coordinator send must park exactly one durable, non-delivered row"
     );
     let events = EventLog::new(&ws).tail(20).unwrap();
     assert!(
@@ -470,7 +476,7 @@ fn message_not_silently_stuck_accepted_when_coordinator_dead() {
                 && event
                     .get("message_queued")
                     .and_then(serde_json::Value::as_bool)
-                    == Some(false)
+                    == Some(true)
         }),
         "send.coordinator_unavailable event must be durable; events={events:?}"
     );
@@ -2914,9 +2920,15 @@ fn gate054_rebind_required_status_refuses_leader_delivery_without_cross_server_p
 }
 
 #[test]
-fn gate054_attached_status_still_delivers_when_pane_is_live() {
+fn gate054_attached_status_still_accepts_when_pane_is_live() {
     // Companion negative: prove the new status gate does NOT over-refuse when
     // `status="attached"` and the workspace-canonical socket has the pane.
+    // Injection-case revision: transport submit success is NOT a provider
+    // receipt, so the old `delivered` pin was a false-positive lock
+    // (MUST-10: physical submit is the framework's fact; acceptance is the
+    // provider's). The un-refused path now parks the SAME row in
+    // submitted_pending_acceptance until a provider receipt or retry
+    // schedule advances it.
     let ws = tmp_ws("gate054ok");
     let store = store_for(&ws);
     let log = EventLog::new(&ws);
@@ -2945,7 +2957,16 @@ fn gate054_attached_status_still_delivers_when_pane_is_live() {
         out.ok,
         "0.5.4 gate054: status='attached' with a live pane must not be over-refused: {out:?}"
     );
-    assert_eq!(out.message_status.0, "delivered");
+    assert_eq!(
+        transport.inject_targets().len(),
+        1,
+        "gate054: exactly one physical inject must have happened (MUST-10 anchor)"
+    );
+    assert_eq!(
+        out.message_status.0, "submitted_pending_acceptance",
+        "gate054 (injection-case revision): a successful physical submit without a provider \
+         receipt must park as submitted_pending_acceptance, never claim delivered: {out:?}"
+    );
 }
 
 // ════════════════════════════════════════════════════════════════════════

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

@@ -49,6 +49,7 @@ pub fn notify_result_watchers(
             if idx == 0 {
                 primary_watcher_id = Some(watcher_id.to_string());
                 notices.push(deliver_primary_watcher(
+                    workspace,
                     &conn,
                     &store,
                     event_log,
@@ -112,6 +113,7 @@ fn watcher_matches(
 }
 
 fn deliver_primary_watcher(
+    workspace: &Path,
     conn: &rusqlite::Connection,
     store: &MessageStore,
     event_log: &EventLog,
@@ -178,7 +180,10 @@ fn deliver_primary_watcher(
         );
     }
     let content = format_result_watcher_notification(result);
-    let message_id = store.create_message(
+    let super::PersistResolution::Persisted(persisted) = super::persist::persist_internal_send(
+        workspace,
+        super::InternalSendKind::Watcher,
+        watcher.get("owner_team_id").and_then(|v| v.as_str()),
         result_task,
         watcher
             .get("leader_id")
@@ -188,8 +193,13 @@ fn deliver_primary_watcher(
         &content,
         None,
         false,
-        watcher.get("owner_team_id").and_then(|v| v.as_str()),
-    )?;
+        None,
+        super::InitialDisposition::Accepted,
+    )?
+    else {
+        unreachable!("watcher notifications do not accept caller-supplied ids")
+    };
+    let message_id = persisted.message_id;
     let claim = store.claim_leader_notification_delivery(NotificationClaimParams {
         result_id,
         owner_team_id: watcher.get("owner_team_id").and_then(|v| v.as_str()),

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

@@ -13,6 +13,7 @@ const SENSITIVE_FAMILIES: [&str; 7] = [
     "SECRET",
     "CREDENTIAL",
 ];
+const SENSITIVE_KEYS: [&str; 2] = ["authorization_header", "credential_blob"];
 const STRUCTURAL_KEYS: [&str; 13] = [
     "active_team_key",
     "cohort_key",
@@ -31,7 +32,7 @@ const STRUCTURAL_KEYS: [&str; 13] = [
 
 static SHELL_ASSIGNMENT: LazyLock<Regex> = LazyLock::new(|| {
     Regex::new(
-        r#"(?i)(?P<prefix>^|[\s\[,;('"])(?P<key>[a-z_][a-z0-9_]*)=(?P<value>'[^']*'|"[^"]*"|[^\s,\]\[};)]+)"#,
+        r#"(?i)(?P<prefix>^|[\s\[,;('"])(?P<key>[a-z_][a-z0-9_.]*)=(?P<value>'[^']*'|"[^"]*"|[^\s,\]\[};)]+)"#,
     )
     .expect("shell assignment redaction regex")
 });
@@ -41,6 +42,13 @@ static URL_USERINFO: LazyLock<Regex> = LazyLock::new(|| {
         .expect("URL userinfo redaction regex")
 });
 
+static BEARER_TOKEN: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(
+        r"(?i)(?P<prefix>\bBearer[ \t]+)(?P<token>[A-Za-z0-9][-A-Za-z0-9._~+/=]{14,}[-A-Za-z0-9._~+/=])",
+    )
+    .expect("Bearer token redaction regex")
+});
+
 pub(crate) fn redact_external_value(value: &serde_json::Value) -> serde_json::Value {
     match value {
         Value::Object(object) => Value::Object(
@@ -49,6 +57,8 @@ pub(crate) fn redact_external_value(value: &serde_json::Value) -> serde_json::Va
                 .map(|(key, value)| {
                     let value = if is_sensitive_env_key(key) {
                         Value::String(REDACTED.to_string())
+                    } else if is_argument_array_key(key) {
+                        redact_argument_array(value)
                     } else {
                         redact_external_value(value)
                     };
@@ -62,6 +72,33 @@ pub(crate) fn redact_external_value(value: &serde_json::Value) -> serde_json::Va
     }
 }
 
+fn is_argument_array_key(key: &str) -> bool {
+    key.eq_ignore_ascii_case("argv") || key.eq_ignore_ascii_case("command")
+}
+
+fn redact_argument_array(value: &Value) -> Value {
+    let Value::Array(values) = value else {
+        return redact_external_value(value);
+    };
+    let mut redact_next = false;
+    Value::Array(
+        values
+            .iter()
+            .map(|value| {
+                if redact_next {
+                    redact_next = false;
+                    return Value::String(REDACTED.to_string());
+                }
+                if let Some(flag) = value.as_str().filter(|flag| flag.starts_with('-')) {
+                    let normalized = flag.trim_start_matches('-').replace('-', "_");
+                    redact_next = is_sensitive_env_key(&normalized);
+                }
+                redact_external_value(value)
+            })
+            .collect(),
+    )
+}
+
 pub(crate) fn redact_external_text(text: &str) -> String {
     let assignments = SHELL_ASSIGNMENT.replace_all(text, |captures: &Captures<'_>| {
         let key = captures.name("key").map_or("", |value| value.as_str());
@@ -90,18 +127,28 @@ pub(crate) fn redact_external_text(text: &str) -> String {
         };
         format!("{prefix}{key}={quote}{safe_value}{quote}")
     });
-    URL_USERINFO
+    let urls = URL_USERINFO
         .replace_all(&assignments, "${scheme}[REDACTED]@")
+        .into_owned();
+    BEARER_TOKEN
+        .replace_all(&urls, "${prefix}[REDACTED]")
         .into_owned()
 }
 
 fn is_sensitive_env_key(key: &str) -> bool {
+    let key = key.rsplit('.').next().unwrap_or(key);
     if STRUCTURAL_KEYS
         .iter()
         .any(|structural| key.eq_ignore_ascii_case(structural))
     {
         return false;
     }
+    if SENSITIVE_KEYS
+        .iter()
+        .any(|sensitive| key.eq_ignore_ascii_case(sensitive))
+    {
+        return true;
+    }
     let key = key.to_ascii_uppercase();
     SENSITIVE_FAMILIES
         .iter()
@@ -182,4 +229,27 @@ mod tests {
         assert!(text.contains("https://[REDACTED]@proxy.invalid:8443/path"));
         assert_eq!(twice, once);
     }
+
+    #[test]
+    fn event_log_shapes_are_masked_without_hiding_structural_arguments() {
+        let marker = "synthetic-event-log-marker";
+        let input = json!({
+            "authorization_header": format!("Bearer {marker}"),
+            "credential_blob": marker,
+            "config": format!("mcp_servers.demo.env.OPENAI_API_KEY=\"{marker}\""),
+            "argv": ["provider", "--api-key", marker, "--team-key", "current"],
+            "command": ["provider", "--authorization-header", marker, "--auth-mode", "subscription"],
+        });
+
+        let redacted = redact_external_value(&input);
+
+        assert!(!redacted.to_string().contains(marker));
+        assert_eq!(redacted["authorization_header"], REDACTED);
+        assert_eq!(redacted["credential_blob"], REDACTED);
+        assert_eq!(redacted["argv"][2], REDACTED);
+        assert_eq!(redacted["argv"][4], "current");
+        assert_eq!(redacted["command"][2], REDACTED);
+        assert_eq!(redacted["command"][4], "subscription");
+        assert_eq!(redact_external_value(&redacted), redacted);
+    }
 }

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

@@ -47,7 +47,7 @@ const SESSION_STATE_FIELDS: [&str; 6] = [
 ];
 const LIVE_TOPOLOGY_FIELDS: [&str; 5] =
     ["pane_id", "pane_pid", "window", "spawned_at", "spawn_epoch"];
-const ROSTER_STUB_ALLOWLIST: [&str; 15] = [
+const ROSTER_STUB_ALLOWLIST: [&str; 16] = [
     "agent_id",
     "provider",
     "auth_mode",
@@ -57,6 +57,7 @@ const ROSTER_STUB_ALLOWLIST: [&str; 15] = [
     "profile",
     "_profile_dir",
     "dynamic_role_file",
+    "role_source_ownership",
     "effort",
     "forked_from",
     "managed_mcp_config",

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

@@ -0,0 +1,47 @@
+use super::{reapply_scope, ReapplyScope, StateWriteIntent};
+
+#[test]
+fn mcp_reapply_scope_matches_legacy_helpers() {
+    assert!(
+        reapply_scope(&StateWriteIntent::McpUpdateStateNote {
+            team_key: Some("team-a"),
+        }) == ReapplyScope::Team
+    );
+    assert!(
+        reapply_scope(&StateWriteIntent::McpAssignTask {
+            team_key: Some("team-a"),
+            task_id: "task-a",
+        }) == ReapplyScope::Root
+    );
+}
+
+#[test]
+fn optional_unmigrated_read_preserves_missing_corrupt_and_valid_shapes(
+) -> Result<(), Box<dyn std::error::Error>> {
+    let nonce = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)?
+        .as_nanos();
+    let workspace = std::env::temp_dir().join(format!("state-repository-read-{nonce}"));
+    let repository = super::StateRepository::new(&workspace);
+    assert!(repository
+        .load_workspace_if_exists_without_migrations()?
+        .is_none());
+
+    let path = super::helper_workspace_path(&workspace);
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+    std::fs::write(&path, b"{not-json")?;
+    assert!(matches!(
+        repository.load_workspace_if_exists_without_migrations(),
+        Err(super::StateError::Json(_))
+    ));
+
+    std::fs::write(&path, br#"{"legacy":true}"#)?;
+    assert_eq!(
+        repository.load_workspace_if_exists_without_migrations()?,
+        Some(serde_json::json!({"legacy": true}))
+    );
+    std::fs::remove_dir_all(workspace)?;
+    Ok(())
+}

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

@@ -40,7 +40,8 @@ use super::StateError;
 // `save_team_scoped_state(` tokens that the governance scanner counts.
 #[allow(unused_imports)]
 use super::persist::{
-    load_runtime_state as helper_load_workspace, save_runtime_state as helper_write_root,
+    load_runtime_state as helper_load_workspace,
+    runtime_state_path as helper_workspace_path, save_runtime_state as helper_write_root,
     save_runtime_state_reapplying_after_conflict as helper_write_root_reapply,
     save_runtime_state_with_deleted_agents as helper_write_root_with_deleted_agents,
     save_runtime_state_with_lifecycle_topology_authority as helper_write_root_with_lifecycle_topology_authority,
@@ -79,6 +80,19 @@ impl<'a> StateRepository<'a> {
         helper_load_workspace(self.workspace)
     }
 
+    /// Load the canonical workspace document without running read-time
+    /// migrations. `None` preserves the legacy raw-reader distinction between
+    /// a missing file and a present empty/default document.
+    pub fn load_workspace_if_exists_without_migrations(
+        &self,
+    ) -> Result<Option<Value>, StateError> {
+        if !helper_workspace_path(self.workspace).exists() {
+            return Ok(None);
+        }
+        let text = std::fs::read_to_string(helper_workspace_path(self.workspace))?;
+        serde_json::from_str(&text).map(Some).map_err(StateError::from)
+    }
+
     /// Resolve a team-scoped projection using the existing projection selector.
     /// `team_key = None` selects the ambient team the same way as pre-S1a.
     pub fn load_team(&self, team_key: Option<&str>) -> Result<Value, StateError> {
@@ -171,6 +185,10 @@ pub enum StateWriteIntent<'a> {
         team_key: Option<&'a str>,
         agent_id: &'a str,
     },
+    ForceRecreateRollback {
+        team_key: &'a str,
+        agent_id: &'a str,
+    },
     ClaimLeader {
         team_key: &'a str,
     },
@@ -193,7 +211,7 @@ pub enum StateWriteIntent<'a> {
     /// so future S1b migration can route it deliberately.
     CoordinatorApiErrorRecovery {
         team_key: Option<&'a str>,
-        agent_id: &'a str,
+        agent_id: Option<&'a str>,
     },
     McpAssignTask {
         team_key: Option<&'a str>,
@@ -331,6 +349,16 @@ fn route_direct(
             Some(_) => helper_write_team_scoped_with_deleted_agents(workspace, state, &[agent_id]),
             None => helper_write_root_with_deleted_agents(workspace, state, &[agent_id]),
         },
+        // Force-recreate rollback restores an existing row after the
+        // replacement spawn has advanced its lifecycle tuple. The selected
+        // row is therefore the explicit topology authority.
+        StateWriteIntent::ForceRecreateRollback { agent_id, .. } => {
+            helper_write_team_scoped_with_lifecycle_topology_authority(
+                workspace,
+                state,
+                &[agent_id],
+            )
+        }
         // ClaimLeader -> leader/lease.rs:1625 uses the root helper, and the
         // scoped preserve-claim-fields variant at :1702 uses the team-tombstoned
         // agents helper.
@@ -396,16 +424,14 @@ fn route_direct(
 // Route intents that historically used the `_reapplying_after_conflict`
 // helper family. Behavior stays identical: S1a chooses the same helper the
 // legacy caller would have chosen for a reapply.
-fn route_reapply<F>(
-    workspace: &Path,
-    intent: StateWriteIntent<'_>,
-    state: &Value,
-    reapply: F,
-) -> Result<(), StateError>
-where
-    F: FnOnce(&mut Value),
-{
-    let use_team_scoped = matches!(
+#[derive(Clone, Copy, Eq, PartialEq)]
+enum ReapplyScope {
+    Root,
+    Team,
+}
+
+fn reapply_scope(intent: &StateWriteIntent<'_>) -> ReapplyScope {
+    if matches!(
         intent,
         StateWriteIntent::RestartSessionRepair { .. }
             | StateWriteIntent::MessagingDeliveryState {
@@ -415,14 +441,31 @@ where
                 owner_team_id: Some(_),
             }
             | StateWriteIntent::CoordinatorTick { .. }
-            | StateWriteIntent::McpAssignTask {
+            | StateWriteIntent::McpUpdateStateNote {
                 team_key: Some(_),
-                ..
             }
-    );
-    if use_team_scoped {
+    ) {
+        ReapplyScope::Team
+    } else {
+        ReapplyScope::Root
+    }
+}
+
+fn route_reapply<F>(
+    workspace: &Path,
+    intent: StateWriteIntent<'_>,
+    state: &Value,
+    reapply: F,
+) -> Result<(), StateError>
+where
+    F: FnOnce(&mut Value),
+{
+    if reapply_scope(&intent) == ReapplyScope::Team {
         helper_write_team_scoped_reapply(workspace, state, reapply)
     } else {
         helper_write_root_reapply(workspace, state, reapply)
     }
 }
+
+#[cfg(test)]
+mod tests;

package/package.json

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