@team-agent/installer 0.5.50 → 0.5.51

package/crates/team-agent/src/lifecycle/tests/launch_spawn.rs

@@ -3,6 +3,29 @@ use crate::transport::test_support::OfflineTransport;
 use serde_json::json;
 use serial_test::serial;
 
+fn launch_source() -> String {
+    let src = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("src/lifecycle");
+    let mut files = vec![src.join("launch.rs")];
+    let mut siblings = std::fs::read_dir(src.join("launch"))
+        .expect("read launch module directory")
+        .map(|entry| entry.expect("read launch module entry").path())
+        .filter(|path| path.extension().and_then(|ext| ext.to_str()) == Some("rs"))
+        .collect::<Vec<_>>();
+    siblings.sort();
+    files.extend(siblings);
+
+    files
+        .into_iter()
+        .map(|path| {
+            format!(
+                "\n// @source {}\n{}",
+                path.strip_prefix(&src).unwrap().display(),
+                std::fs::read_to_string(&path).expect("read launch source")
+            )
+        })
+        .collect()
+}
+
 #[allow(dead_code)]
 struct HermeticTestEnv;
 
@@ -968,7 +991,7 @@ fn e5_add_agent_resolves_team_dir_to_role_dir_when_runtime_spec_exists() {
 // never write team.spec.yaml into the user team_dir/agents_dir. Pins the spec-demote invariant.
 #[test]
 fn e5_guard_g1_writers_use_runtime_spec_path_not_user_dir() {
-    let source = include_str!("../launch.rs");
+    let source = launch_source();
     let runtime_writes = source.matches("runtime_spec_path(").count();
     assert!(
         runtime_writes >= 2,
@@ -989,7 +1012,7 @@ fn e5_guard_g1_writers_use_runtime_spec_path_not_user_dir() {
 // Pins the Bug1 fix: no `fs::copy` of a role file + no `materialize_added_role_file` reborn.
 #[test]
 fn e5_guard_g2_no_copy_role_into_platform_dir() {
-    let source = include_str!("../launch.rs");
+    let source = launch_source();
     assert!(
         !source.contains("materialize_added_role_file"),
         "G2: materialize_added_role_file (role copy anti-pattern) must stay deleted"
@@ -3117,6 +3140,36 @@ fn quick_start_running_agent_state_shape_after_spawn_is_golden() {
     assert_eq!(spawn_event["spawned_at"], json!(FIXED_SPAWNED_AT));
     assert_eq!(spawn_event["source"], json!("launch"));
     assert_eq!(spawn_event["spawn_epoch"], json!(0));
+    let actual_keys = spawn_event
+        .as_object()
+        .expect("spawn event object")
+        .keys()
+        .map(String::as_str)
+        .collect::<std::collections::BTreeSet<_>>();
+    let expected_keys = [
+        "agent_id",
+        "argv",
+        "env_overlay_keys",
+        "env_unset",
+        "event",
+        "expected_session_id",
+        "provider",
+        "session_id_in_argv",
+        "source",
+        "spawn_cwd",
+        "spawn_epoch",
+        "spawned_at",
+        "tmux_endpoint",
+        "tmux_endpoint_source",
+        "tmux_start_mode",
+        "ts",
+    ]
+    .into_iter()
+    .collect::<std::collections::BTreeSet<_>>();
+    assert_eq!(
+        actual_keys, expected_keys,
+        "spawn event schema must be canonical"
+    );
 }
 
 // Stage B2 — golden launch/core.py:171-173 writes paused workers as exactly

package/crates/team-agent/src/lifecycle/tests/lifecycle_lock.rs

@@ -233,7 +233,7 @@ fn r2_lifecycle_lock_exists_precondition() {
         "remove rollback runs while remove-agent holds the lifecycle lock; it must use lock-free start_agent_at_paths"
     );
 
-    let launch = read_src("lifecycle/launch.rs");
+    let launch = launch_source();
     assert_public_operation(&launch, "add-agent");
     assert_public_operation(&launch, "fork-agent");
     assert_body_is_unlocked(&launch, "fn add_agent_with_transport_at_paths");
@@ -279,6 +279,29 @@ fn read_src(path: &str) -> String {
     std::fs::read_to_string(manifest_src().join(path)).unwrap()
 }
 
+fn launch_source() -> String {
+    let src = manifest_src().join("lifecycle");
+    let mut files = vec![src.join("launch.rs")];
+    let mut siblings = std::fs::read_dir(src.join("launch"))
+        .expect("read launch module directory")
+        .map(|entry| entry.expect("read launch module entry").path())
+        .filter(|path| path.extension().and_then(|ext| ext.to_str()) == Some("rs"))
+        .collect::<Vec<_>>();
+    siblings.sort();
+    files.extend(siblings);
+
+    files
+        .into_iter()
+        .map(|path| {
+            format!(
+                "\n// @source {}\n{}",
+                path.strip_prefix(&src).unwrap().display(),
+                std::fs::read_to_string(&path).expect("read launch source")
+            )
+        })
+        .collect()
+}
+
 fn source_files(root: &Path) -> Vec<PathBuf> {
     let mut out = Vec::new();
     collect_rs_files(root, &mut out);

package/crates/team-agent/src/mcp_server/lifecycle_tools/agent_ops.rs

@@ -252,12 +252,28 @@ fn state_spec_workspace_from_entry(state: &Value) -> Option<PathBuf> {
 
 fn load_local_runtime_state(workspace: &Path) -> Result<Value, super::super::ToolError> {
     let path = crate::state::persist::runtime_state_path(workspace);
-    let text = std::fs::read_to_string(&path).map_err(|e| {
-        tool_runtime_error(format!("read local runtime state {}: {e}", path.display()))
-    })?;
-    serde_json::from_str(&text).map_err(|e| {
-        tool_runtime_error(format!("parse local runtime state {}: {e}", path.display()))
-    })
+    match crate::state::repository::StateRepository::new(workspace)
+        .load_workspace_if_exists_without_migrations()
+    {
+        Ok(Some(state)) => Ok(state),
+        Ok(None) => Err(tool_runtime_error(format!(
+            "read local runtime state {}: {}",
+            path.display(),
+            std::io::Error::from(std::io::ErrorKind::NotFound)
+        ))),
+        Err(crate::state::StateError::Json(error)) => Err(tool_runtime_error(format!(
+            "parse local runtime state {}: {error}",
+            path.display()
+        ))),
+        Err(crate::state::StateError::Io(error)) => Err(tool_runtime_error(format!(
+            "read local runtime state {}: {error}",
+            path.display()
+        ))),
+        Err(error) => Err(tool_runtime_error(format!(
+            "read local runtime state {}: {error}",
+            path.display()
+        ))),
+    }
 }
 
 fn materialize_mcp_lifecycle_spec(
@@ -416,7 +432,14 @@ fn prepare_selected_team_state(
             }
         }
     }
-    crate::state::persist::save_runtime_state(workspace, state).map_err(|e| {
+    crate::state::repository::StateRepository::new(workspace)
+        .save(
+            crate::state::repository::StateWriteIntent::McpLifecycleAgentOps {
+                team_key: Some(team),
+            },
+            state,
+        )
+        .map_err(|e| {
         tool_runtime_error(format!(
             "save MCP lifecycle scoped state {}: {e}",
             workspace.display()

package/crates/team-agent/src/mcp_server/lifecycle_tools/state_status.rs

@@ -26,8 +26,10 @@ pub(crate) fn update_state(
     let mut state = selected.state;
     ensure_object(&mut state);
     append_note(&mut state, note);
-    crate::state::projection::save_team_scoped_state_reapplying_after_conflict(
-        &selected.run_workspace,
+    crate::state::repository::StateRepository::new(&selected.run_workspace).save_reapplying(
+        crate::state::repository::StateWriteIntent::McpUpdateStateNote {
+            team_key: Some(&selected.team_key),
+        },
         &state,
         |latest| {
             ensure_object(latest);
@@ -66,8 +68,10 @@ fn update_state_without_spec(
     ensure_object(&mut state);
     seed_legacy_team_key(&mut state, &selected.run_workspace, &selected.team_key);
     append_note(&mut state, note);
-    crate::state::projection::save_team_scoped_state_reapplying_after_conflict(
-        &selected.run_workspace,
+    crate::state::repository::StateRepository::new(&selected.run_workspace).save_reapplying(
+        crate::state::repository::StateWriteIntent::McpUpdateStateNote {
+            team_key: Some(&selected.team_key),
+        },
         &state,
         |latest| {
             ensure_object(latest);

package/crates/team-agent/src/mcp_server/mod.rs

@@ -85,7 +85,7 @@ use crate::event_log::EventLog;
 use crate::message_store::MessageStore;
 
 // ── REUSE: step 5 state persist / projection ────────────────────────────────
-use crate::state::persist::{load_runtime_state, save_runtime_state};
+use crate::state::persist::load_runtime_state;
 
 // ── REUSE: step 11 messaging delegate surface ───────────────────────────────
 use crate::messaging::{self, DeliveryOutcome, MessageTarget, SendOptions, TrustedSender};

package/crates/team-agent/src/mcp_server/tests/send.rs

@@ -319,20 +319,16 @@ fn send_message_worker_recipient_surfaces_dead_coordinator_warning() {
             None,
             None,
         )
-        .expect("send returns degraded warning, not an MCP error");
+        .expect("send persists a durable blocker, not an MCP error");
     let v = outcome.to_value();
-    assert_eq!(v.get("status"), Some(&json!("degraded")));
-    assert_eq!(v.get("reason"), Some(&json!("coordinator_unavailable")));
+    assert_eq!(v.get("status"), Some(&json!("accepted")));
     assert!(
-        v.get("warning")
+        v.get("message_id")
             .and_then(Value::as_str)
-            .is_some_and(|warning| warning.contains("message was not queued")),
-        "warning must explain the accepted-row avoidance; value={v}"
-    );
-    assert!(
-        v.get("delivery_pending").is_none(),
-        "dead coordinator must not return the old accepted async envelope"
+            .is_some_and(|id| id.starts_with("msg_")),
+        "worker MCP send must expose the durable row id; value={v}"
     );
+    assert_eq!(v.get("delivery_pending"), Some(&json!(true)));
 }
 
 #[test]

package/crates/team-agent/src/mcp_server/tools.rs

@@ -126,11 +126,19 @@ impl TeamOrchestratorTools {
             .map(|team| team.as_str().to_string())
             .or_else(|| assignment_team_key(&state));
         reconcile_assigned_task(&mut state, team_key.as_deref(), &task_value);
-        save_runtime_state_reapplying_after_conflict(&self.workspace, &state, |latest| {
-            ensure_object(latest);
-            let latest_team_key = team_key.clone().or_else(|| assignment_team_key(latest));
-            reconcile_assigned_task(latest, latest_team_key.as_deref(), &task_value);
-        })
+        crate::state::repository::StateRepository::new(&self.workspace)
+            .save_reapplying(
+                crate::state::repository::StateWriteIntent::McpAssignTask {
+                    team_key: team_key.as_deref(),
+                    task_id,
+                },
+                &state,
+                |latest| {
+                    ensure_object(latest);
+                    let latest_team_key = team_key.clone().or_else(|| assignment_team_key(latest));
+                    reconcile_assigned_task(latest, latest_team_key.as_deref(), &task_value);
+                },
+            )
         .map_err(tool_runtime_error)?;
 
         let content = assignment_message(task, message);
@@ -213,6 +221,7 @@ impl TeamOrchestratorTools {
             )
             .map_err(tool_runtime_error)?;
         let opts = SendOptions {
+            origin: crate::messaging::SendOrigin::Mcp,
             task_id: task_id.map(TaskId::new),
             route_task_id: true,
             sender,

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

@@ -80,8 +80,10 @@ pub fn detect_idle_fallbacks(
     let suppression_snapshots =
         idle_fallback_suppression_snapshots(&next_state, store, &team, &idle_workers)?;
     register_idle_fallback_suppression(&mut next_state, &team, &now, &suppression_snapshots);
-    crate::state::persist::save_runtime_state_reapplying_after_conflict(
-        workspace,
+    crate::state::repository::StateRepository::new(workspace).save_reapplying(
+        crate::state::repository::StateWriteIntent::MessagingTurnArm {
+            owner_team_id: Some(&team),
+        },
         &next_state,
         |latest| {
             register_idle_fallback_suppression(latest, &team, &now, &suppression_snapshots);

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

@@ -0,0 +1,86 @@
+//! Pure logical-address grammar shared by public entry-point adapters.
+
+use std::path::PathBuf;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct LogicalAddress {
+    pub workspace: Option<PathBuf>,
+    pub target: LogicalAddressTarget,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum LogicalAddressTarget {
+    Worker(String),
+    TeamEntity { team: String, entity: String },
+    SessionWindow { session: String, window: String },
+}
+
+pub fn parse_logical_address(raw_name: &str) -> Result<LogicalAddress, &'static str> {
+    let raw = raw_name.trim();
+    if raw.is_empty() {
+        return Err("name is empty");
+    }
+    let (workspace, name) = if let Some((workspace, rest)) = raw.split_once("::") {
+        if workspace.trim().is_empty() || rest.trim().is_empty() {
+            return Err("workspace-qualified name must include workspace and target");
+        }
+        (Some(PathBuf::from(workspace)), rest.trim())
+    } else {
+        (None, raw)
+    };
+    if name.contains("//") {
+        return Err("name contains an empty path segment");
+    }
+    let target = if name.contains('/') {
+        let parts = name.split('/').collect::<Vec<_>>();
+        if parts.len() != 2 || !valid_component(parts[0]) || !valid_component(parts[1]) {
+            return Err("expected <team>/<agent> or <team>/leader");
+        }
+        LogicalAddressTarget::TeamEntity {
+            team: parts[0].to_string(),
+            entity: parts[1].to_string(),
+        }
+    } else if name.contains(':') {
+        let parts = name.split(':').collect::<Vec<_>>();
+        if parts.len() != 2 || parts[0].trim().is_empty() || parts[1].trim().is_empty() {
+            return Err("expected <session>:<window>");
+        }
+        LogicalAddressTarget::SessionWindow {
+            session: parts[0].to_string(),
+            window: parts[1].to_string(),
+        }
+    } else {
+        if !valid_component(name) {
+            return Err("expected a non-empty agent id");
+        }
+        LogicalAddressTarget::Worker(name.to_string())
+    };
+    Ok(LogicalAddress { workspace, target })
+}
+
+fn valid_component(raw: &str) -> bool {
+    !raw.trim().is_empty()
+        && !raw.contains(char::is_whitespace)
+        && !raw.contains('/')
+        && !raw.contains(':')
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_canonical_send_grammar_without_runtime_state() {
+        assert_eq!(
+            parse_logical_address("/tmp/ws::team/w1").unwrap(),
+            LogicalAddress {
+                workspace: Some(PathBuf::from("/tmp/ws")),
+                target: LogicalAddressTarget::TeamEntity {
+                    team: "team".into(),
+                    entity: "w1".into(),
+                },
+            }
+        );
+        assert!(parse_logical_address("team//w1").is_err());
+    }
+}

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

@@ -45,20 +45,28 @@ pub fn deliver_stored_message(
 ) -> Result<DeliveryOutcome, MessagingError> {
     let _ = (wait_visible, timeout);
     let recipient = target.unwrap_or("leader");
-    let store = MessageStore::open(workspace)?;
-    let message_id = store.create_message(
+    let super::PersistResolution::Persisted(persisted) = super::persist::persist_internal_send(
+        workspace,
+        super::InternalSendKind::Delivery,
+        team.map(TeamKey::as_str),
         task_id.map(crate::model::ids::TaskId::as_str),
         sender,
         recipient,
         content,
         None,
         requires_ack,
-        team.map(TeamKey::as_str),
-    )?;
+        None,
+        super::InitialDisposition::Accepted,
+    )?
+    else {
+        unreachable!("internal delivery does not accept caller-supplied ids")
+    };
+    let message_status = persisted.row_status.as_str().to_string();
+    let message_id = persisted.message_id;
     Ok(DeliveryOutcome {
         ok: true,
         status: DeliveryStatus::Queued,
-        message_status: MessageStatusShadow("accepted".to_string()),
+        message_status: MessageStatusShadow(message_status),
         message_id: Some(message_id),
         verification: None,
         stage: None,
@@ -67,6 +75,17 @@ pub fn deliver_stored_message(
     })
 }
 
+pub fn deliver_persisted_message(
+    workspace: &Path,
+    transport: &dyn Transport,
+    message_id: &str,
+    event_log: &EventLog,
+    state: &serde_json::Value,
+) -> Result<DeliveryOutcome, MessagingError> {
+    let store = MessageStore::open(workspace)?;
+    deliver_pending_message(workspace, &store, transport, message_id, event_log, state)
+}
+
 // ===========================================================================
 // delivery.py — 单条 tmux 注入投递 + trust 有界重试 + turn-open arm (card §16)
 // ===========================================================================
@@ -200,6 +219,22 @@ pub fn deliver_pending_message(
         }
         _ => state,
     };
+    if message.recipient == "leader" && message.status == "submitted_pending_acceptance" {
+        return observe_pending_leader_acceptance(store, event_log, state, message_id);
+    }
+    if message.recipient == "leader" && message.status == "queued_until_leader_attach" {
+        if leader_receiver_status(state) != Some("attached") {
+            return Ok(leader_acceptance_pending_outcome(
+                message_id,
+                "queued_until_leader_attach",
+            ));
+        }
+        store.mark(message_id, "accepted", None)?;
+        event_log.write(
+            "leader_receiver.mailbox_requeued",
+            serde_json::json!({"message_id": message_id}),
+        )?;
+    }
     let attempt = if store.claim_for_delivery(message_id)? {
         message.delivery_attempts.saturating_add(1)
     } else if message.status == "target_resolved" && message.error.is_some() {
@@ -524,14 +559,10 @@ pub fn deliver_pending_message(
     }
     let submit_verified = inject_submit_verified(&inject_report);
     let readback_verified = pane_readback_verified(&inject_report);
-    // Leader pane: inject success is delivery proof. Worker pane: post-submit
-    // evidence is the delivery proof; stale Phase-1 readback must not veto it
-    // and cannot independently prove the current Enter submitted.
-    let verified = if is_leader_recipient {
-        true
-    } else {
-        submit_verified
-    };
+    // A successful tmux command is never provider-acceptance proof. Leader and
+    // worker delivery both require post-submit evidence; leader additionally
+    // waits for its authoritative provider transcript below.
+    let verified = submit_verified;
     if !verified {
         let reason = if !readback_verified {
             "pane_readback_unverified:capture_missing_token".to_string()
@@ -658,7 +689,26 @@ pub fn deliver_pending_message(
             });
         }
     }
-    store.mark(message_id, "delivered", None)?;
+    if is_leader_recipient {
+        store.record_delivery_submission(message_id, readback_verified)?;
+        if !leader_transcript_has_token(state, message_id) {
+            store.mark(message_id, "submitted_pending_acceptance", None)?;
+            event_log.write(
+                "leader_receiver.acceptance_pending",
+                serde_json::json!({
+                    "message_id": message_id,
+                    "reason": "provider_receipt_not_observed",
+                }),
+            )?;
+            return Ok(leader_acceptance_pending_outcome(
+                message_id,
+                "submitted_pending_acceptance",
+            ));
+        }
+        store.mark_delivered_with_receipt(message_id)?;
+    } else {
+        store.mark(message_id, "delivered", None)?;
+    }
     let mut delivered_event = serde_json::json!({"message_id": message_id});
     if let Some(metadata) = resolved.metadata.as_ref() {
         append_target_metadata(&mut delivered_event, metadata);
@@ -908,7 +958,8 @@ fn deliver_leader_via_app_server(
     );
     match crate::codex_app_server::submit_to_bound_thread(&binding, message_id, &rendered) {
         Ok(submit) => {
-            store.mark(message_id, "delivered", None)?;
+            store.record_delivery_submission(message_id, true)?;
+            store.mark_delivered_with_receipt(message_id)?;
             event_log.write(
                 "message.delivered",
                 serde_json::json!({"message_id": message_id}),
@@ -1800,10 +1851,16 @@ pub fn deliver_pending_messages(
         let conn = crate::db::schema::open_db(store.db_path())?;
         let mut stmt = conn.prepare(
             "select message_id from messages
-             where status in ('pending', 'accepted', 'target_resolved')
+             where status in (
+                 'pending', 'accepted', 'target_resolved',
+                 'submitted_pending_acceptance', 'queued_until_leader_attach', ?1
+             )
              order by created_at, message_id",
         )?;
-        let rows = stmt.query_map([], |row| row.get::<_, String>(0))?;
+        let rows = stmt.query_map(
+            [crate::message_store::MessageRowStatus::QueuedCoordinatorUnavailable.as_str()],
+            |row| row.get::<_, String>(0),
+        )?;
         rows.collect::<Result<Vec<_>, _>>()?
     };
     let mut delivered = Vec::new();
@@ -1874,7 +1931,7 @@ pub fn deliver_pending_messages(
                 continue;
             }
         };
-        if outcome.ok {
+        if matches!(outcome.status, DeliveryStatus::Delivered) {
             delivered.push(message_id);
         }
     }
@@ -2017,6 +2074,73 @@ fn recipient_is_busy(state: &serde_json::Value, recipient: &str) -> bool {
         == Some("busy")
 }
 
+fn leader_rollout_path(state: &serde_json::Value) -> Option<std::path::PathBuf> {
+    state
+        .get("leader")
+        .and_then(|leader| leader.get("rollout_path"))
+        .and_then(serde_json::Value::as_str)
+        .or_else(|| {
+            leader_receiver_value(state)
+                .and_then(|receiver| receiver.get("rollout_path"))
+                .and_then(serde_json::Value::as_str)
+        })
+        .filter(|path| !path.is_empty())
+        .map(std::path::PathBuf::from)
+}
+
+pub(crate) fn leader_transcript_has_token(state: &serde_json::Value, message_id: &str) -> bool {
+    let Some(path) = leader_rollout_path(state) else {
+        return false;
+    };
+    rollout_tail_contains(
+        &path,
+        &format!("[team-agent-token:{message_id}]"),
+        64 * 1024,
+    )
+}
+
+fn leader_acceptance_pending_outcome(message_id: &str, status: &str) -> DeliveryOutcome {
+    DeliveryOutcome {
+        ok: true,
+        status: DeliveryStatus::RetryScheduled,
+        message_status: MessageStatusShadow(status.to_string()),
+        message_id: Some(message_id.to_string()),
+        verification: Some("provider_receipt_not_observed".to_string()),
+        stage: Some(DeliveryStage::Submit),
+        reason: None,
+        channel: Some("leader_acceptance_pending".to_string()),
+    }
+}
+
+fn observe_pending_leader_acceptance(
+    store: &MessageStore,
+    event_log: &EventLog,
+    state: &serde_json::Value,
+    message_id: &str,
+) -> Result<DeliveryOutcome, MessagingError> {
+    if !leader_transcript_has_token(state, message_id) {
+        return Ok(leader_acceptance_pending_outcome(
+            message_id,
+            "submitted_pending_acceptance",
+        ));
+    }
+    store.mark_delivered_with_receipt(message_id)?;
+    event_log.write(
+        "message.delivered",
+        serde_json::json!({"message_id": message_id}),
+    )?;
+    Ok(DeliveryOutcome {
+        ok: true,
+        status: DeliveryStatus::Delivered,
+        message_status: MessageStatusShadow("delivered".to_string()),
+        message_id: Some(message_id.to_string()),
+        verification: Some("provider_transcript_receipt".to_string()),
+        stage: None,
+        reason: None,
+        channel: Some("leader_receiver".to_string()),
+    })
+}
+
 /// `_handle_trust_retry_needed` (`delivery.py:221`):trust 应答失败时调度有界退避重试
 /// (`attempt < MAX` → schedule;`>= MAX` → 终态 mark failed + `trust_auto_answer_exhausted`)。
 pub fn handle_trust_retry_needed(
@@ -2341,8 +2465,10 @@ fn save_scoped_state(
     state: &serde_json::Value,
     owner_team_id: Option<&str>,
 ) -> Result<(), MessagingError> {
-    if owner_team_id.filter(|team| !team.is_empty()).is_some() {
-        if state
+    let scoped_owner_team_id = owner_team_id
+        .filter(|team| !team.is_empty())
+        .filter(|_| {
+            state
             .get("teams")
             .and_then(serde_json::Value::as_object)
             .is_some_and(|teams| {
@@ -2354,14 +2480,13 @@ fn save_scoped_state(
                     })
                     .is_some_and(|team| teams.contains_key(&team))
             })
-        {
-            crate::state::projection::save_team_scoped_state(workspace, state)?;
-        } else {
-            crate::state::persist::save_runtime_state(workspace, state)?;
-        }
-    } else {
-        crate::state::persist::save_runtime_state(workspace, state)?;
-    }
+        });
+    crate::state::repository::StateRepository::new(workspace).save(
+        crate::state::repository::StateWriteIntent::MessagingDeliveryState {
+            owner_team_id: scoped_owner_team_id,
+        },
+        state,
+    )?;
     Ok(())
 }
 
@@ -2374,8 +2499,10 @@ fn save_scoped_state_reapplying_after_conflict<F>(
 where
     F: FnOnce(&mut serde_json::Value),
 {
-    if owner_team_id.filter(|team| !team.is_empty()).is_some()
-        && state
+    let scoped_owner_team_id = owner_team_id
+        .filter(|team| !team.is_empty())
+        .filter(|_| {
+            state
             .get("teams")
             .and_then(serde_json::Value::as_object)
             .is_some_and(|teams| {
@@ -2387,15 +2514,14 @@ where
                     })
                     .is_some_and(|team| teams.contains_key(&team))
             })
-    {
-        crate::state::projection::save_team_scoped_state_reapplying_after_conflict(
-            workspace, state, reapply,
-        )?;
-    } else {
-        crate::state::persist::save_runtime_state_reapplying_after_conflict(
-            workspace, state, reapply,
-        )?;
-    }
+        });
+    crate::state::repository::StateRepository::new(workspace).save_reapplying(
+        crate::state::repository::StateWriteIntent::MessagingDeliveryState {
+            owner_team_id: scoped_owner_team_id,
+        },
+        state,
+        reapply,
+    )?;
     Ok(())
 }