@team-agent/installer 0.5.50 → 0.5.52

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

@@ -197,27 +197,15 @@ fn collect_scoped(
         collected_results.push(summary);
     }
     if state_dirty {
-        if owner_team_id.is_some() {
-            crate::state::projection::save_team_scoped_state_reapplying_after_conflict(
-                &paths.run_workspace,
-                &state,
-                |latest| {
-                    for (task_id, result_id) in &task_updates {
-                        mark_task_done(latest, task_id, result_id);
-                    }
-                },
-            )?;
-        } else {
-            crate::state::persist::save_runtime_state_reapplying_after_conflict(
-                &paths.run_workspace,
-                &state,
-                |latest| {
-                    for (task_id, result_id) in &task_updates {
-                        mark_task_done(latest, task_id, result_id);
-                    }
-                },
-            )?;
-        }
+        crate::state::repository::StateRepository::new(&paths.run_workspace).save_reapplying(
+            crate::state::repository::StateWriteIntent::ResultCollection { owner_team_id },
+            &state,
+            |latest| {
+                for (task_id, result_id) in &task_updates {
+                    mark_task_done(latest, task_id, result_id);
+                }
+            },
+        )?;
     }
     let counts = result_counts(&conn, owner_team_id)?;
     // results.py:157 — ensure_coordinator=true runs the REAL ensure step; the
@@ -870,7 +858,9 @@ fn report_result_for_owner_team_inner(
             }
         }
         if !outcome.ok {
-            if !report_state_has_app_server_receiver(&delivery_state) {
+            if outcome.channel.as_deref() != Some("leader_acceptance_pending")
+                && !report_state_has_app_server_receiver(&delivery_state)
+            {
                 let fallback_error = primary_error.unwrap_or_else(|| {
                     format!(
                         "leader_notification_primary_failed:{}",
@@ -892,9 +882,11 @@ fn report_result_for_owner_team_inner(
             }
         }
     }
-    let leader_notified = outcome.ok;
-    let notification_status_wire = if outcome.ok {
+    let leader_notified = matches!(outcome.status, crate::messaging::DeliveryStatus::Delivered);
+    let notification_status_wire = if leader_notified {
         "delivered"
+    } else if outcome.channel.as_deref() == Some("leader_acceptance_pending") {
+        "submitted_pending_acceptance"
     } else if outcome.channel.as_deref() == Some("rebind_required")
         || matches!(outcome.status, crate::messaging::DeliveryStatus::Blocked)
     {

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

@@ -256,8 +256,10 @@ pub fn stuck_cancel(
             },
         );
     }
-    crate::state::persist::save_runtime_state_reapplying_after_conflict(
-        workspace,
+    crate::state::repository::StateRepository::new(workspace).save_reapplying(
+        crate::state::repository::StateWriteIntent::SchedulerSuppression {
+            owner_team_id: Some(&team),
+        },
         &state,
         |latest| {
             for kind in &alert_types {

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

@@ -129,18 +129,25 @@ fn run_contract_suite(
         }
     };
 
-    match scratch_store.as_ref().and_then(|store| {
-        store
-            .create_message(
-                None,
-                "doctor",
-                "worker",
-                "comms contract probe",
-                None,
-                false,
-                Some("contract-team"),
-            )
-            .ok()
+    match scratch_store.as_ref().and_then(|_| {
+        match super::persist::persist_internal_send(
+            &scratch,
+            super::InternalSendKind::Selftest,
+            Some("contract-team"),
+            None,
+            "doctor",
+            "worker",
+            "comms contract probe",
+            None,
+            false,
+            None,
+            super::InitialDisposition::Accepted,
+        )
+        .ok()?
+        {
+            super::PersistResolution::Persisted(persisted) => Some(persisted.message_id),
+            super::PersistResolution::Duplicate(_) => None,
+        }
     }) {
         Some(message_id) if message_id.starts_with("msg_") && message_id.len() > 4 => {
             let rendered = format!(

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

@@ -10,7 +10,11 @@ use crate::transport::{PaneId, Transport};
 
 use super::helpers::{status_wire, MessageStatusShadow};
 use super::leader_receiver::{send_to_leader_receiver, send_to_leader_receiver_with_message_id};
-use super::{DeliveryOutcome, DeliveryRefusal, DeliveryStatus, MessagingError};
+use super::{
+    persist_resolved_send, DeliveryBlocker, DeliveryOutcome, DeliveryRefusal, DeliveryStatus,
+    InitialDisposition, LogicalRecipient, MessagingError, PersistResolution, ResolvedSendIntent,
+    SendOrigin,
+};
 
 /// 发件目标:单 target / 广播 `*` / 扇出 list (`send.py:36` `target: str|list[str]|None`)。
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -49,6 +53,7 @@ impl TrustedSender {
 /// `send_message` 选项 (`send.py:36`:Python 大量默认参数 → typed 选项 struct)。
 #[derive(Debug, Clone)]
 pub struct SendOptions {
+    pub origin: SendOrigin,
     pub task_id: Option<TaskId>,
     /// `route_task_id`(golden `send.py:190`,默认 `True`):仅 **routing**(CLI `send --task`)时把
     /// `task_id` 当真任务校验/路由。**投递/fanout/internal/coordinator** 路径传 `false`
@@ -73,6 +78,7 @@ impl Default for SendOptions {
     fn default() -> Self {
         // 默认值对齐 Python 签名 (`send.py:38-40`)。
         Self {
+            origin: SendOrigin::Internal(super::InternalSendKind::Delivery),
             task_id: None,
             route_task_id: true,
             sender: TrustedSender::leader(),
@@ -207,46 +213,47 @@ pub fn send_message(
     }
     let stale_worker_target_missing =
         stale_worker_target_missing_preflight(workspace, &state, recipient)?;
-    if !stale_worker_target_missing {
-        if let Some(outcome) =
-            coordinator_unavailable_outcome(workspace, recipient, opts, &event_log)?
-        {
-            return Ok(outcome);
-        }
+    let coordinator_unavailable = if stale_worker_target_missing {
+        None
+    } else {
+        coordinator_unavailable_outcome(workspace, recipient, opts, &event_log)?
+    };
+    if let Some(gate) = coordinator_unavailable
+        .as_ref()
+        .filter(|gate| !gate.persist)
+    {
+        return Ok(gate.outcome.clone());
     }
-    let store = crate::message_store::MessageStore::open(workspace)?;
-    let task_id = opts.task_id.as_ref().map(|t| t.as_str());
-    let owner_team_id = opts.team.as_ref().map(|t| t.as_str());
-    // CR-015/054 caller-key dedup: if the caller supplied a stable id, an identical
-    // re-send must NOT create a second row — return a Duplicate refusal instead.
-    let message_id = if let Some(requested) = opts.message_id.as_deref() {
-        if store.message_exists(requested)? {
+    let mut intent = ResolvedSendIntent::accepted(
+        opts.origin,
+        workspace,
+        opts.team.clone(),
+        LogicalRecipient::from_resolved(recipient),
+        opts.sender.clone(),
+        opts.task_id.clone(),
+        content,
+        None,
+        opts.requires_ack,
+        opts.message_id.clone(),
+    );
+    if coordinator_unavailable
+        .as_ref()
+        .is_some_and(|gate| gate.persist)
+    {
+        intent.initial_disposition =
+            InitialDisposition::Blocked(DeliveryBlocker::CoordinatorUnavailable);
+    }
+    let persisted = match persist_resolved_send(&intent)? {
+        PersistResolution::Persisted(persisted) => persisted,
+        PersistResolution::Duplicate(message_id) => {
             return Ok(refused_outcome_with_id(
                 DeliveryRefusal::Duplicate,
-                Some(requested.to_string()),
+                Some(message_id),
             ));
         }
-        store.create_message_with_id(
-            requested,
-            task_id,
-            opts.sender.as_str(),
-            recipient,
-            content,
-            None,
-            opts.requires_ack,
-            owner_team_id,
-        )?
-    } else {
-        store.create_message(
-            task_id,
-            opts.sender.as_str(),
-            recipient,
-            content,
-            None,
-            opts.requires_ack,
-            owner_team_id,
-        )?
     };
+    let message_id = persisted.message_id.clone();
+    let store = crate::message_store::MessageStore::open(workspace)?;
     if stale_worker_target_missing {
         return super::delivery::mark_worker_target_missing(
             &store,
@@ -256,10 +263,37 @@ pub fn send_message(
             None,
         );
     }
+    if let Some(CoordinatorUnavailableGate {
+        mut outcome,
+        persist: true,
+    }) = coordinator_unavailable
+    {
+        let Some(blocker) = persisted.blocker else {
+            return Err(MessagingError::Validation(
+                "coordinator-blocked persistence returned no blocker".to_string(),
+            ));
+        };
+        let message_status = persisted.row_status.as_str();
+        event_log.write(
+            "send.message_queued",
+            serde_json::json!({
+                "message_id": message_id,
+                "recipient": recipient,
+                "sender": opts.sender,
+                "message_status": message_status,
+                "blocker": blocker.as_str(),
+            }),
+        )?;
+        outcome.ok = true;
+        outcome.status = DeliveryStatus::Blocked;
+        outcome.message_status = MessageStatusShadow(message_status.to_string());
+        outcome.message_id = Some(message_id);
+        return Ok(outcome);
+    }
     Ok(DeliveryOutcome {
         ok: true,
         status: DeliveryStatus::Queued,
-        message_status: MessageStatusShadow("accepted".to_string()),
+        message_status: MessageStatusShadow(persisted.row_status.as_str().to_string()),
         message_id: Some(message_id),
         verification: None,
         stage: None,
@@ -331,12 +365,17 @@ fn refused_outcome_with_verification(
     }
 }
 
+struct CoordinatorUnavailableGate {
+    outcome: DeliveryOutcome,
+    persist: bool,
+}
+
 fn coordinator_unavailable_outcome(
     workspace: &Path,
     recipient: &str,
     opts: &SendOptions,
     event_log: &EventLog,
-) -> Result<Option<DeliveryOutcome>, MessagingError> {
+) -> Result<Option<CoordinatorUnavailableGate>, MessagingError> {
     let coordinator_workspace = WorkspacePath::new(workspace.to_path_buf());
     let health = crate::coordinator::coordinator_health(&coordinator_workspace);
     if health.ok || matches!(health.status, CoordinatorHealthStatus::Missing) {
@@ -366,9 +405,19 @@ fn coordinator_unavailable_outcome(
         )?;
         return Ok(None);
     }
-    let warning = format!(
-        "coordinator is not running; message was not queued for {recipient}. Run `team-agent diagnose` or restart the team before sending again."
+    let persist = !matches!(
+        health.metadata_mismatch_reason.as_deref(),
+        Some("protocol_version_mismatch" | "message_store_schema_version_mismatch")
     );
+    let warning = if persist {
+        format!(
+            "coordinator is not running; message was queued for {recipient} and will retry. Run `team-agent diagnose` or restart the team."
+        )
+    } else {
+        format!(
+            "coordinator protocol or schema is incompatible; message was not queued for {recipient}. Run `team-agent diagnose` or upgrade the runtime."
+        )
+    };
     event_log.write(
         "send.coordinator_unavailable",
         serde_json::json!({
@@ -377,22 +426,25 @@ fn coordinator_unavailable_outcome(
             "coordinator_status": health.status,
             "coordinator_pid": health.pid.map(|pid| pid.get()),
             "metadata_mismatch_reason": health.metadata_mismatch_reason,
-            "message_queued": false,
+            "message_queued": persist,
             "warning": warning,
             "coordinator_log": crate::coordinator::coordinator_log_path(&coordinator_workspace)
                 .display()
                 .to_string(),
         }),
     )?;
-    Ok(Some(DeliveryOutcome {
-        ok: false,
-        status: DeliveryStatus::Degraded,
-        message_status: MessageStatusShadow("degraded".to_string()),
-        message_id: None,
-        verification: Some(warning),
-        stage: None,
-        reason: Some(DeliveryRefusal::CoordinatorUnavailable),
-        channel: Some("coordinator_unavailable".to_string()),
+    Ok(Some(CoordinatorUnavailableGate {
+        persist,
+        outcome: DeliveryOutcome {
+            ok: false,
+            status: DeliveryStatus::Degraded,
+            message_status: MessageStatusShadow("degraded".to_string()),
+            message_id: None,
+            verification: Some(warning),
+            stage: None,
+            reason: Some(DeliveryRefusal::CoordinatorUnavailable),
+            channel: Some("coordinator_unavailable".to_string()),
+        },
     }))
 }
 

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

@@ -0,0 +1,169 @@
+use super::*;
+use crate::transport::test_support::OfflineTransport;
+use std::path::Path;
+
+fn pane(session: &str, tty: &str) -> PaneInfo {
+    PaneInfo {
+        pane_id: PaneId::new("%7"),
+        session: SessionName::new(session),
+        window_index: Some(0),
+        window_name: Some(WindowName::new("leader")),
+        pane_index: Some(0),
+        tty: Some(tty.to_string()),
+        current_command: Some("codex".to_string()),
+        current_path: None,
+        active: true,
+        pane_pid: Some(77),
+        leader_env: BTreeMap::new(),
+    }
+}
+
+fn receiver(socket: &str) -> serde_json::Value {
+    serde_json::json!({
+        "mode": "direct_tmux",
+        "status": "attached",
+        "pane_id": "%7",
+        "tmux_socket": socket,
+        "session_name": "old-session",
+        "window_name": "leader",
+        "pane_tty": "/dev/old",
+        "fingerprint": "old-session|0|0|/dev/old"
+    })
+}
+
+#[test]
+fn live_direct_channel_accepts_session_and_tty_drift_as_diagnostics() {
+    let socket = "/tmp/team-agent-channel-a";
+    let workspace = Path::new("/tmp/team-agent-workspace-a");
+    let transport = OfflineTransport::new()
+        .with_tmux_endpoint(socket)
+        .with_targets(vec![pane("new-session", "/dev/new")]);
+
+    let LeaderChannelResolution::Live(LiveLeaderChannel::DirectTmux(channel)) =
+        resolve_live_leader_channel(workspace, &receiver(socket), &transport)
+    else {
+        panic!("same socket and pane must remain a live channel");
+    };
+
+    assert_eq!(channel.pane_id, "%7");
+    assert_eq!(channel.tmux_socket.as_deref(), Some(socket));
+    assert_eq!(
+        channel.metadata_drift,
+        vec!["session_name", "pane_tty", "fingerprint"]
+    );
+}
+
+#[test]
+fn legacy_receiver_without_status_still_uses_live_channel_facts() {
+    let socket = "/tmp/team-agent-channel-a";
+    let workspace = Path::new("/tmp/team-agent-workspace-a");
+    let mut receiver = receiver(socket);
+    if let Some(receiver) = receiver.as_object_mut() {
+        receiver.remove("status");
+    }
+    let transport = OfflineTransport::new()
+        .with_tmux_endpoint(socket)
+        .with_targets(vec![pane("new-session", "/dev/new")]);
+
+    assert!(matches!(
+        resolve_live_leader_channel(workspace, &receiver, &transport),
+        LeaderChannelResolution::Live(LiveLeaderChannel::DirectTmux(_))
+    ));
+}
+
+#[test]
+fn explicit_non_attached_status_still_refuses_before_liveness() {
+    let socket = "/tmp/team-agent-channel-a";
+    let workspace = Path::new("/tmp/team-agent-workspace-a");
+    let mut receiver = receiver(socket);
+    receiver["status"] = serde_json::json!("rebind_required");
+    let transport = OfflineTransport::new()
+        .with_tmux_endpoint(socket)
+        .with_targets(vec![pane("new-session", "/dev/new")]);
+
+    assert_eq!(
+        resolve_live_leader_channel(workspace, &receiver, &transport),
+        LeaderChannelResolution::Unbound(LeaderChannelUnbound::ReceiverNotAttached)
+    );
+}
+
+#[test]
+fn legacy_receiver_without_status_still_rejects_a_foreign_workspace() {
+    let socket = "/tmp/team-agent-channel-a";
+    let workspace = Path::new("/tmp/team-agent-workspace-a");
+    let mut receiver = receiver(socket);
+    if let Some(receiver) = receiver.as_object_mut() {
+        receiver.remove("status");
+    }
+    let mut observed = pane("foreign-session", "/dev/foreign");
+    observed.current_path = Some(Path::new("/tmp/team-agent-workspace-b").to_path_buf());
+    let transport = OfflineTransport::new()
+        .with_tmux_endpoint(socket)
+        .with_targets(vec![observed]);
+
+    assert_eq!(
+        resolve_live_leader_channel(workspace, &receiver, &transport),
+        LeaderChannelResolution::Unbound(LeaderChannelUnbound::PaneWorkspaceMismatch)
+    );
+}
+
+#[test]
+fn same_pane_id_on_foreign_socket_is_not_a_live_channel() {
+    let workspace = Path::new("/tmp/team-agent-workspace-a");
+    let transport = OfflineTransport::new()
+        .with_tmux_endpoint("/tmp/team-agent-channel-b")
+        .with_targets(vec![pane("old-session", "/dev/old")]);
+
+    assert_eq!(
+        resolve_live_leader_channel(
+            workspace,
+            &receiver("/tmp/team-agent-channel-a"),
+            &transport,
+        ),
+        LeaderChannelResolution::Unbound(LeaderChannelUnbound::EndpointMismatch)
+    );
+}
+
+#[test]
+fn attached_record_without_live_pane_is_not_a_live_channel() {
+    let socket = "/tmp/team-agent-channel-a";
+    let workspace = Path::new("/tmp/team-agent-workspace-a");
+    let transport = OfflineTransport::new().with_tmux_endpoint(socket);
+
+    assert_eq!(
+        resolve_live_leader_channel(workspace, &receiver(socket), &transport),
+        LeaderChannelResolution::Unbound(LeaderChannelUnbound::PaneNotLive)
+    );
+}
+
+#[test]
+fn live_direct_channel_accepts_a_pane_inside_the_target_workspace() {
+    let socket = "/tmp/team-agent-channel-a";
+    let workspace = Path::new("/tmp/team-agent-workspace-a");
+    let mut observed = pane("new-session", "/dev/new");
+    observed.current_path = Some(workspace.join("nested"));
+    let transport = OfflineTransport::new()
+        .with_tmux_endpoint(socket)
+        .with_targets(vec![observed]);
+
+    assert!(matches!(
+        resolve_live_leader_channel(workspace, &receiver(socket), &transport),
+        LeaderChannelResolution::Live(LiveLeaderChannel::DirectTmux(_))
+    ));
+}
+
+#[test]
+fn same_socket_and_pane_in_a_foreign_workspace_is_not_a_live_leader() {
+    let socket = "/tmp/team-agent-channel-a";
+    let workspace = Path::new("/tmp/team-agent-workspace-a");
+    let mut observed = pane("foreign-session", "/dev/foreign");
+    observed.current_path = Some(Path::new("/tmp/team-agent-workspace-b").to_path_buf());
+    let transport = OfflineTransport::new()
+        .with_tmux_endpoint(socket)
+        .with_targets(vec![observed]);
+
+    assert_eq!(
+        resolve_live_leader_channel(workspace, &receiver(socket), &transport),
+        LeaderChannelResolution::Unbound(LeaderChannelUnbound::PaneWorkspaceMismatch)
+    );
+}