@team-agent/installer 0.5.4 → 0.5.6

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.4"
+version = "0.5.6"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.4"
+version = "0.5.6"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/cli/adapters.rs

@@ -1468,7 +1468,15 @@ fn format_inbox_human(
         for message in messages {
             let sender = message.get("sender").and_then(Value::as_str).unwrap_or("-");
             let content = message.get("content").and_then(Value::as_str).unwrap_or("");
-            lines.push(format!("- {sender}: {content}"));
+            let status = message.get("status").and_then(Value::as_str).unwrap_or("-");
+            let attempts = message
+                .get("delivery_attempts")
+                .and_then(Value::as_i64)
+                .unwrap_or(0);
+            let error = message.get("error").and_then(Value::as_str).unwrap_or("-");
+            lines.push(format!(
+                "- {sender}: {content} [status={status} attempts={attempts} error={error}]"
+            ));
         }
     }
     let pending = uncollected_result_count(workspace, owner_team_id)?;

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

@@ -90,9 +90,12 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
     {
         return Ok(CmdResult::from_json(amb, args.json));
     }
-    let outcome = messaging::send_message(&selected.run_workspace, &target, &content, &opts)?;
-    let mut value = delivery_outcome_json(&outcome, &target, &content, &opts);
+    let mut outcome = messaging::send_message(&selected.run_workspace, &target, &content, &opts)?;
     if opts.watch_result {
+        outcome = observe_initial_delivery_for_watch(&selected, &target, &outcome, &opts)?;
+    }
+    let mut value = delivery_outcome_json(&outcome, &target, &content, &opts);
+    if opts.watch_result && initial_delivery_allows_watch(outcome.status) {
         if let Some(obj) = value.as_object_mut() {
             obj.insert("watch".to_string(), watch_notice_json(&target, &opts));
         }
@@ -575,6 +578,48 @@ fn primary_delivery_succeeded(status: DeliveryStatus) -> bool {
     )
 }
 
+fn initial_delivery_allows_watch(status: DeliveryStatus) -> bool {
+    matches!(
+        status,
+        DeliveryStatus::Delivered | DeliveryStatus::AlreadyDelivered
+    )
+}
+
+fn observe_initial_delivery_for_watch(
+    selected: &crate::state::selector::SelectedTeam,
+    target: &MessageTarget,
+    outcome: &DeliveryOutcome,
+    opts: &SendOptions,
+) -> Result<DeliveryOutcome, CliError> {
+    if !matches!(target, MessageTarget::Single(agent) if !agent.is_empty()) {
+        return Ok(outcome.clone());
+    }
+    if !matches!(outcome.status, DeliveryStatus::Queued) {
+        return Ok(outcome.clone());
+    }
+    let Some(message_id) = outcome.message_id.as_deref() else {
+        return Ok(outcome.clone());
+    };
+    let store = crate::message_store::MessageStore::open(&selected.run_workspace)
+        .map_err(|e| CliError::Runtime(e.to_string()))?;
+    let transport = crate::lifecycle::restart::lifecycle_worker_tmux_backend_for_selected_state(
+        &selected.run_workspace,
+        opts.team.as_ref().map(TeamKey::as_str),
+    )
+    .map_err(|e| CliError::Runtime(e.to_string()))?;
+    let event_log = crate::event_log::EventLog::new(&selected.run_workspace);
+    let state = selected_state_with_active_key(selected);
+    crate::messaging::delivery::deliver_pending_message(
+        &selected.run_workspace,
+        &store,
+        &transport,
+        message_id,
+        &event_log,
+        &state,
+    )
+    .map_err(CliError::from)
+}
+
 fn is_business_reject_text(error: &str) -> bool {
     let lower = error.to_ascii_lowercase();
     [
@@ -668,6 +713,8 @@ fn delivery_outcome_json(
     json!({
         "ok": outcome.ok,
         "status": delivery_status_wire(outcome.status),
+        "delivery_status": api_delivery_status(outcome),
+        "delivered": delivery_proven(outcome.status),
         "target": target_wire,
         "agent_id": first_target(target),
         "content_length_bytes": content.len(),
@@ -681,6 +728,26 @@ fn delivery_outcome_json(
     })
 }
 
+fn api_delivery_status(outcome: &DeliveryOutcome) -> &'static str {
+    if delivery_proven(outcome.status) {
+        return "delivered";
+    }
+    if matches!(outcome.status, DeliveryStatus::Queued) && outcome.message_status.0 == "accepted" {
+        return "pending";
+    }
+    delivery_status_wire(outcome.status)
+}
+
+fn delivery_proven(status: DeliveryStatus) -> bool {
+    matches!(
+        status,
+        DeliveryStatus::Delivered
+            | DeliveryStatus::AlreadyDelivered
+            | DeliveryStatus::BroadcastDelivered
+            | DeliveryStatus::FanoutDelivered
+    )
+}
+
 fn add_send_reminder_if_ok(value: &mut Value) {
     if value.get("ok").and_then(Value::as_bool) != Some(true) {
         return;

package/crates/team-agent/src/cli/status_port.rs

@@ -99,6 +99,7 @@ use rusqlite::params;
             "tasks": tasks,
             "messages": message_counts(&conn, owner_team_id)?,
             "queued_messages": queued_messages(&conn, owner_team_id, 8)?,
+            "pending_leader_notifications": pending_leader_notifications(&conn, owner_team_id, 8)?,
             "results": result_counts(&conn, owner_team_id)?,
             "latest_results": latest_result_summaries(&store, owner_team_id)?,
             "readiness": readiness,
@@ -639,6 +640,67 @@ use rusqlite::params;
         Ok(Value::Array(values))
     }
 
+    /// 0.5.5 gate054 round-2: leader notifications that were refused with
+    /// `rebind_required` (status=failed, error=leader_not_attached) sit as
+    /// failed rows in the store; without a dedicated status field the
+    /// operator sees only `messages.failed=N` and cannot tell that the
+    /// notifications are waiting for a rebind. This field surfaces them
+    /// alongside `queued_messages` so `attach-leader` / `takeover` is
+    /// visibly the fix. Once the pane is rebound the requeue path flips
+    /// each row back to `status=accepted` and it drops out of this list.
+    fn pending_leader_notifications(
+        conn: &rusqlite::Connection,
+        owner_team_id: Option<&str>,
+        limit: usize,
+    ) -> Result<Value, CliError> {
+        let limit = i64::try_from(limit).unwrap_or(i64::MAX);
+        let sql = match owner_team_id {
+            Some(_) => {
+                "select message_id, sender, status, error, created_at, delivery_attempts
+                 from messages
+                 where recipient = 'leader'
+                   and status = 'failed'
+                   and error = 'leader_not_attached'
+                   and owner_team_id = ?1
+                 order by created_at desc
+                 limit ?2"
+            }
+            None => {
+                "select message_id, sender, status, error, created_at, delivery_attempts
+                 from messages
+                 where recipient = 'leader'
+                   and status = 'failed'
+                   and error = 'leader_not_attached'
+                 order by created_at desc
+                 limit ?1"
+            }
+        };
+        let mut stmt = conn
+            .prepare(sql)
+            .map_err(|e| CliError::Runtime(e.to_string()))?;
+        let map_row = |row: &rusqlite::Row<'_>| {
+            Ok(json!({
+                "message_id": row.get::<_, String>(0)?,
+                "sender": row.get::<_, Option<String>>(1)?,
+                "status": row.get::<_, String>(2)?,
+                "error": row.get::<_, Option<String>>(3)?,
+                "created_at": row.get::<_, Option<String>>(4)?,
+                "delivery_attempts": row.get::<_, i64>(5)?,
+                "channel": "rebind_required",
+                "action": "run team-agent attach-leader or team-agent takeover",
+            }))
+        };
+        let rows = match owner_team_id {
+            Some(team) => stmt.query_map(params![team, limit], map_row),
+            None => stmt.query_map(params![limit], map_row),
+        }
+        .map_err(|e| CliError::Runtime(e.to_string()))?;
+        let values = rows
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| CliError::Runtime(e.to_string()))?;
+        Ok(Value::Array(values))
+    }
+
     /// 0.4.x: slim default compact payload — exactly 7 top-level fields.
     /// Diagnostic detail moves to `--detail`. Plan:
     /// /Users/alauda/Documents/code/team-agent-public/.team/artifacts/status-compact-plan.md

package/crates/team-agent/src/cli/tests/status_send.rs

@@ -511,33 +511,26 @@ use super::*;
     }
 
     #[test]
-    fn cmd_send_watch_result_surfaces_registered_notice() {
-        // gate CRITICAL: --watch-result -> SendOptions.watch_result=true -> send_message attaches
-        // result['watch']={status:'registered', watcher_id, task_id, agent_id, notice}
-        // (send.py:322-337). That dict MUST survive verbatim into CmdResult Json output.
+    fn cmd_send_watch_result_does_not_register_before_delivery() {
+        // 0.5.x send contract: --watch-result may only advertise a watcher after
+        // initial worker delivery is physically proven.
         let r = cmd_send(&send_args_fixture()).expect("cmd_send returns CmdResult");
         let v = match r.output {
             CmdOutput::Json(v) => v,
             other => panic!("expected Json, got {other:?}"),
         };
-        let watch = v
-            .get("watch")
-            .expect("watch_result:true MUST attach result['watch'] (send.py:326)");
-        assert_eq!(
-            watch.get("status").and_then(|s| s.as_str()),
-            Some("registered"),
-            "registered-watcher notice status must be exactly 'registered'"
+        assert!(
+            v.get("delivery_status").and_then(|s| s.as_str()).is_some(),
+            "send output must expose delivery_status; got {v}"
         );
-        assert!(watch.get("watcher_id").is_some(), "watch notice carries watcher_id");
         assert_eq!(
-            watch.get("agent_id").and_then(|s| s.as_str()),
-            Some("alice"),
-            "watch notice agent_id == the send target"
+            v.get("delivered").and_then(|s| s.as_bool()),
+            Some(false),
+            "undelivered send outcome must not look delivered"
         );
-        // non-queued notice golden bytes (send.py:335):
-        assert_eq!(
-            watch.get("notice").and_then(|s| s.as_str()),
-            Some("Team Agent will collect the result and notify the leader when this task reports completion.")
+        assert!(
+            !v.as_object().unwrap().contains_key("watch"),
+            "watch_result:true must not attach result['watch'] before delivery; got {v}"
         );
     }
 

package/crates/team-agent/src/lifecycle/restart/agent.rs

@@ -143,6 +143,7 @@ pub(crate) fn start_agent_at_paths(
         if let Ok(spec) = load_team_spec(spec_workspace) {
             write_team_state(spec_workspace, &spec, &state)?;
         }
+        replay_worker_target_missing_messages(workspace, agent_id, &team_key, &state, transport)?;
         let coordinator_started = start_coordinator_for_workspace(workspace)?;
         let target = format!("{}:{window}", session_name.as_str());
         write_start_agent_noop_event(workspace, agent_id, &target, coordinator_started)?;
@@ -282,6 +283,7 @@ pub(crate) fn start_agent_at_paths(
         spawn_session_id,
         tmux_start_mode_for_spawn(&spawn, into_existing_session),
     )?;
+    replay_worker_target_missing_messages(workspace, agent_id, &team_key, &state, transport)?;
     let coordinator_started = start_coordinator_for_workspace(workspace)?;
     Ok(StartAgentOutcome::Running {
         env: AgentActionEnvelope {
@@ -297,6 +299,33 @@ pub(crate) fn start_agent_at_paths(
     })
 }
 
+fn replay_worker_target_missing_messages(
+    workspace: &Path,
+    agent_id: &AgentId,
+    team_key: &str,
+    state: &serde_json::Value,
+    transport: &dyn crate::transport::Transport,
+) -> Result<(), LifecycleError> {
+    let store = crate::message_store::MessageStore::open(workspace)
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    let event_log = crate::event_log::EventLog::new(workspace);
+    let ids = crate::messaging::delivery::requeue_worker_target_missing_messages(
+        workspace,
+        &store,
+        &event_log,
+        agent_id.as_str(),
+        Some(team_key),
+    )
+    .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    if !ids.is_empty() {
+        crate::messaging::delivery::deliver_pending_messages(
+            workspace, state, transport, &event_log,
+        )
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    }
+    Ok(())
+}
+
 fn verify_spawned_pane_matches_target(
     transport: &dyn crate::transport::Transport,
     pane: &crate::transport::PaneId,

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

@@ -3,6 +3,7 @@
 use std::io::Write as _;
 use std::path::Path;
 
+use rusqlite::{params, OptionalExtension};
 use serde::Serialize;
 use serde_json::Value;
 
@@ -274,12 +275,7 @@ fn find_latest_nonterminal_task_for(tasks: &[Value], agent_id: &str) -> Option<S
     None
 }
 
-/// Find the most recent delivered direct message to `agent_id` whose `task_id`
-/// is empty/null AND for which no result row exists yet. Used by
-/// `report_result` as a message-scoped fallback before defaulting to
-/// `"manual"`, so `collect` can correlate via the existing message-scope path
-/// (`messaging::results::is_message_scoped_result`).
-pub(crate) fn latest_uncorrelated_delivered_message_for(
+pub(crate) fn latest_reportable_message_for(
     workspace: &Path,
     agent_id: &str,
     owner_team_id: Option<&str>,
@@ -287,33 +283,147 @@ pub(crate) fn latest_uncorrelated_delivered_message_for(
     use crate::db::message_store::MessageStore;
     let store = MessageStore::open(workspace).ok()?;
     let conn = crate::db::schema::open_db(store.db_path()).ok()?;
-    let sql = match owner_team_id {
-        Some(_) => "select m.message_id from messages m \
-                     where m.recipient = ?1 and m.status = 'delivered' \
-                       and (m.task_id is null or m.task_id = '') \
-                       and m.owner_team_id = ?2 \
-                       and not exists ( \
-                         select 1 from results r \
-                         where r.task_id = m.message_id and r.agent_id = m.recipient \
-                       ) \
-                     order by m.created_at desc limit 1",
-        None => "select m.message_id from messages m \
-                     where m.recipient = ?1 and m.status = 'delivered' \
-                       and (m.task_id is null or m.task_id = '') \
-                       and not exists ( \
-                         select 1 from results r \
-                         where r.task_id = m.message_id and r.agent_id = m.recipient \
-                       ) \
-                     order by m.created_at desc limit 1",
-    };
-    let mut stmt = conn.prepare(sql).ok()?;
-    let id: Option<String> = match owner_team_id {
-        Some(team) => stmt
-            .query_row(rusqlite::params![agent_id, team], |row| row.get::<_, String>(0))
-            .ok(),
-        None => stmt
-            .query_row(rusqlite::params![agent_id], |row| row.get::<_, String>(0))
-            .ok(),
+    current_turn_message_for(workspace, &conn, agent_id, owner_team_id)
+        .or_else(|| latest_reportable_message_from_db(&conn, agent_id, owner_team_id))
+}
+
+fn current_turn_message_for(
+    workspace: &Path,
+    conn: &rusqlite::Connection,
+    agent_id: &str,
+    owner_team_id: Option<&str>,
+) -> Option<String> {
+    let state = report_scope_state(workspace, owner_team_id)?;
+    current_turn_id_from_state(&state, agent_id)
+        .filter(|message_id| message_is_reportable(conn, message_id, agent_id, owner_team_id))
+}
+
+fn report_scope_state(workspace: &Path, owner_team_id: Option<&str>) -> Option<Value> {
+    let state = load_runtime_state(workspace).ok()?;
+    let Some(team) = owner_team_id.filter(|team| !team.is_empty()) else {
+        return Some(state);
     };
-    id
+    let canonical = crate::state::projection::resolve_owner_team_id(&state, team)
+        .canonical_key()
+        .map(str::to_string)
+        .unwrap_or_else(|| team.to_string());
+    if let Some(projected) = state
+        .get("teams")
+        .and_then(Value::as_object)
+        .and_then(|teams| teams.get(&canonical))
+        .cloned()
+    {
+        Some(projected)
+    } else {
+        Some(state)
+    }
+}
+
+fn current_turn_id_from_state(state: &Value, agent_id: &str) -> Option<String> {
+    if let Some(turn) = state.get("coordinator").and_then(|v| v.get("turn_open")) {
+        let armed = turn.get("armed").and_then(Value::as_bool).unwrap_or(false);
+        let node_matches = turn
+            .get("node_id")
+            .and_then(Value::as_str)
+            .is_some_and(|node| node == agent_id);
+        if armed && node_matches {
+            if let Some(turn_id) = turn
+                .get("turn_id")
+                .and_then(Value::as_str)
+                .and_then(non_empty_string)
+            {
+                return Some(turn_id.to_string());
+            }
+        }
+    }
+    state
+        .get("agents")
+        .and_then(|agents| agents.get(agent_id))
+        .and_then(|agent| agent.get("current_task_id"))
+        .and_then(Value::as_str)
+        .and_then(non_empty_string)
+        .map(ToString::to_string)
+}
+
+fn message_is_reportable(
+    conn: &rusqlite::Connection,
+    message_id: &str,
+    agent_id: &str,
+    owner_team_id: Option<&str>,
+) -> bool {
+    conn.query_row(
+        "select 1 from messages m
+         where m.message_id = ?1
+           and m.recipient = ?2
+           and (?3 is null or m.owner_team_id = ?3)
+           and (m.task_id is null or m.task_id = '')
+           and m.status in ('delivered', 'target_resolved', 'submitted', 'injected', 'visible')
+           and (m.status = 'delivered' or m.error is null)
+           and m.created_at >= coalesce((
+             select max(r.created_at) from results r
+             where r.agent_id = m.recipient
+               and (?3 is null or r.owner_team_id = m.owner_team_id)
+           ), '0000')
+           and not exists (
+             select 1 from results r
+             where r.task_id = m.message_id and r.agent_id = m.recipient
+           )
+         limit 1",
+        params![message_id, agent_id, owner_team_id],
+        |_| Ok(()),
+    )
+    .optional()
+    .ok()
+    .flatten()
+    .is_some()
+}
+
+fn latest_reportable_message_from_db(
+    conn: &rusqlite::Connection,
+    agent_id: &str,
+    owner_team_id: Option<&str>,
+) -> Option<String> {
+    let row = conn
+        .query_row(
+            "select m.message_id, m.status, m.error from messages m
+             where m.recipient = ?1
+               and (?2 is null or m.owner_team_id = ?2)
+               and (m.task_id is null or m.task_id = '')
+               and m.created_at >= coalesce((
+                 select max(r.created_at) from results r
+                 where r.agent_id = m.recipient
+                   and (?2 is null or r.owner_team_id = m.owner_team_id)
+               ), '0000')
+               and not exists (
+                 select 1 from results r
+                 where r.task_id = m.message_id and r.agent_id = m.recipient
+               )
+             order by m.created_at desc,
+               case when m.status = 'delivered' then 0 else 1 end
+             limit 1",
+            params![agent_id, owner_team_id],
+            |row| {
+                Ok((
+                    row.get::<_, String>(0)?,
+                    row.get::<_, String>(1)?,
+                    row.get::<_, Option<String>>(2)?,
+                ))
+            },
+        )
+        .optional()
+        .ok()
+        .flatten()?;
+    let (message_id, status, error) = row;
+    if reportable_message_status(&status, error.as_deref()) {
+        Some(message_id)
+    } else {
+        None
+    }
+}
+
+fn reportable_message_status(status: &str, error: Option<&str>) -> bool {
+    matches!(
+        status,
+        "delivered" | "target_resolved" | "submitted" | "injected" | "visible"
+    ) && (status == "delivered" || error.is_none())
 }

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

@@ -99,9 +99,9 @@ pub use wire::*;
 // pub(crate) 子项 (normalize 的 list helpers、wire 的 dispatch_tool 等) 经此再导出,
 // 使 `#[cfg(test)] mod tests` 的 `use super::*` 与跨子模块引用解析不变。
 pub(crate) use helpers::{
-    delivery_outcome_value, ensure_object, enum_value, insert_array, latest_task_for_assignee,
-    non_empty_string, normalize_token, normalized_envelope_value, object_fields, text_field,
-    text_of_value, tool_error_reason_wire, tool_runtime_error,
+    delivery_outcome_value, ensure_object, enum_value, insert_array, latest_reportable_message_for,
+    latest_task_for_assignee, non_empty_string, normalize_token, normalized_envelope_value,
+    object_fields, text_field, text_of_value, tool_error_reason_wire, tool_runtime_error,
 };
 pub(crate) use normalize::{
     normalize_artifacts, normalize_changes, normalize_next_actions, normalize_risks, normalize_tests,

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

@@ -61,6 +61,134 @@
         assert_eq!(env.task_id, TaskId::new("manual"));
     }
 
+    fn seed_report_message(
+        ws: &std::path::Path,
+        message_id: &str,
+        owner_team_id: &str,
+        status: &str,
+        created_at: &str,
+    ) {
+        let store = MessageStore::open(ws).unwrap();
+        let conn = crate::db::schema::open_db(store.db_path()).unwrap();
+        conn.execute(
+            "insert into messages(
+                message_id, owner_team_id, task_id, sender, recipient, reply_to, requires_ack,
+                status, content, artifact_refs, created_at, updated_at, delivered_at,
+                acknowledged_at, error, delivery_attempts
+            ) values (?1, ?2, null, 'leader', 'probe-worker', null, 0,
+                ?3, 'task', '[]', ?4, ?4, case when ?3 = 'delivered' then ?4 else null end,
+                null, null, 0)",
+            rusqlite::params![message_id, owner_team_id, status, created_at],
+        )
+        .unwrap();
+    }
+
+    fn seed_report_result(
+        ws: &std::path::Path,
+        result_id: &str,
+        owner_team_id: &str,
+        task_id: &str,
+        created_at: &str,
+    ) {
+        let store = MessageStore::open(ws).unwrap();
+        let conn = crate::db::schema::open_db(store.db_path()).unwrap();
+        let envelope = json!({
+            "schema_version": "result_envelope_v1",
+            "result_id": result_id,
+            "task_id": task_id,
+            "agent_id": "probe-worker",
+            "status": "success",
+            "summary": "seed",
+            "changes": [], "tests": [], "risks": [], "artifacts": [], "next_actions": []
+        });
+        conn.execute(
+            "insert into results(
+                result_id, owner_team_id, task_id, agent_id, envelope, status, created_at
+            ) values (?1, ?2, ?3, 'probe-worker', ?4, 'success', ?5)",
+            rusqlite::params![result_id, owner_team_id, task_id, envelope.to_string(), created_at],
+        )
+        .unwrap();
+    }
+
+    #[test]
+    fn report_result_prefers_current_inflight_message_over_old_delivered_fallback() {
+        let ws = unique_ws("report-current-message");
+        seed_report_message(
+            &ws,
+            "msg_old",
+            "gate055",
+            "delivered",
+            "2026-07-06T13:24:25.000000+00:00",
+        );
+        seed_report_result(
+            &ws,
+            "res_seed",
+            "gate055",
+            "task_initial",
+            "2026-07-06T13:25:00.000000+00:00",
+        );
+        seed_report_message(
+            &ws,
+            "msg_new",
+            "gate055",
+            "target_resolved",
+            "2026-07-06T13:27:35.000000+00:00",
+        );
+
+        let tools = TeamOrchestratorTools::with_identity(
+            &ws,
+            Some(AgentId::new("probe-worker")),
+            Some(TeamKey::new("gate055")),
+        );
+        let ok = tools.report_result(
+            None, Some("S3_RESTART_TOKEN"), ResultStatus::Success,
+            None, None, None, None, None,
+            None, None,
+        ).expect("report ok");
+        let v = serde_json::to_value(&ok).unwrap();
+        assert_eq!(
+            v.get("task_id"),
+            Some(&json!("msg_new")),
+            "current in-flight message must beat stale delivered fallback"
+        );
+    }
+
+    #[test]
+    fn report_result_does_not_backfill_old_delivered_message_after_latest_result() {
+        let ws = unique_ws("report-no-old-backfill");
+        seed_report_message(
+            &ws,
+            "msg_old",
+            "gate055",
+            "delivered",
+            "2026-07-06T13:24:25.000000+00:00",
+        );
+        seed_report_result(
+            &ws,
+            "res_latest",
+            "gate055",
+            "task_initial",
+            "2026-07-06T13:25:00.000000+00:00",
+        );
+
+        let tools = TeamOrchestratorTools::with_identity(
+            &ws,
+            Some(AgentId::new("probe-worker")),
+            Some(TeamKey::new("gate055")),
+        );
+        let ok = tools.report_result(
+            None, Some("manual follow-up"), ResultStatus::Success,
+            None, None, None, None, None,
+            None, None,
+        ).expect("report ok");
+        let v = serde_json::to_value(&ok).unwrap();
+        assert_eq!(
+            v.get("task_id"),
+            Some(&json!("manual")),
+            "old delivered messages older than latest result must not be reused"
+        );
+    }
+
     // ════════════════════════════════════════════════════════════════════════
     // CONTROL-PLANE: request_human creates a requires_ack leader message → needs_human
     // (tools.py:342-346). sender = explicit > env > "unknown" (never leader).