@team-agent/installer 0.5.5 → 0.5.6

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.5"
+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.5"
+version = "0.5.6"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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).

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

@@ -21,9 +21,8 @@ use crate::messaging::{self, MessageTarget, SendOptions};
 
 use super::helpers::{
     delivery_outcome_value, ensure_object, enum_value, insert_array, is_worker_recipient,
-    json_dumps_default, latest_task_for_assignee, latest_uncorrelated_delivered_message_for,
-    non_empty_string, normalized_envelope_value, object_fields, requires_ack_for_target,
-    tool_runtime_error,
+    json_dumps_default, latest_reportable_message_for, latest_task_for_assignee, non_empty_string,
+    normalized_envelope_value, object_fields, requires_ack_for_target, tool_runtime_error,
 };
 use super::normalize::{
     compact_tool_result, normalize_report_envelope, normalize_result_status_observed,
@@ -326,9 +325,9 @@ impl TeamOrchestratorTools {
                 //   1. explicit arg
                 //   2. latest nonterminal task assigned to this agent in
                 //      teams.<owner>.tasks (scoped) → top-level tasks
-                //   3. latest delivered direct message to this agent with no
-                //      task id and no result yet (message-scope correlation —
-                //      collect path: is_message_scoped_result)
+                //   3. current/in-flight reportable direct message to this agent
+                //      with no task id and no result yet (message-scope
+                //      correlation — collect path: is_message_scoped_result)
                 //   4. "manual" — truly uncorrelated; collect still rejects
                 let owner_team_id_str = self.owner_team_id.as_ref().map(|t| t.as_str().to_string());
                 let resolved = task_id
@@ -344,7 +343,7 @@ impl TeamOrchestratorTools {
                     })
                     .or_else(|| {
                         self.agent_id.as_ref().and_then(|agent| {
-                            latest_uncorrelated_delivered_message_for(
+                            latest_reportable_message_for(
                                 &self.workspace,
                                 agent.as_str(),
                                 owner_team_id_str.as_deref(),

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

@@ -460,6 +460,14 @@ pub fn deliver_pending_message(
             });
         }
     };
+    record_current_turn_after_inject_if_leader_to_worker_scoped(
+        workspace,
+        &message.sender,
+        &message.recipient,
+        message_id,
+        event_log,
+        canonical_owner_team_id.as_deref(),
+    )?;
     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
@@ -1892,7 +1900,7 @@ pub fn execute_trust_retry(
 }
 
 /// `_record_turn_open_if_leader_to_worker` (`delivery.py:430`):**take-over arm 来自真实投递**
-/// (card §121) —— 仅 leader→worker 注入**成功后**才调 `record_turn_open_after_delivery`,绝不凭空 arm。
+/// (card §121) —— 仅 leader→worker 注入/投递成功后才 arm,绝不凭空 arm。
 pub fn record_turn_open_if_leader_to_worker(
     workspace: &Path,
     state: &serde_json::Value,
@@ -1907,6 +1915,30 @@ pub fn record_turn_open_if_leader_to_worker(
     )
 }
 
+fn record_current_turn_after_inject_if_leader_to_worker_scoped(
+    workspace: &Path,
+    sender: &str,
+    recipient: &str,
+    message_id: &str,
+    event_log: &EventLog,
+    owner_team_id: Option<&str>,
+) -> Result<(), MessagingError> {
+    if !matches!(sender, "leader" | "Leader") || recipient == "leader" {
+        return Ok(());
+    }
+    let message_id = Some(message_id.to_string());
+    let mut state = scoped_state_for_write(workspace, owner_team_id)?;
+    arm_turn_open(&mut state, recipient, &message_id);
+    save_scoped_state_reapplying_after_conflict(workspace, &state, owner_team_id, |latest| {
+        arm_turn_open(latest, recipient, &message_id);
+    })?;
+    event_log.write(
+        "turn_open.armed_after_inject",
+        serde_json::json!({"agent_id": recipient, "message_id": message_id}),
+    )?;
+    Ok(())
+}
+
 fn record_turn_open_if_leader_to_worker_scoped(
     workspace: &Path,
     sender: &str,
@@ -1943,6 +1975,19 @@ fn arm_turn_open(state: &mut serde_json::Value, recipient: &str, message_id: &Op
             serde_json::json!({"armed": true, "node_id": recipient, "turn_id": message_id}),
         );
     }
+    if let Some(agent) = root
+        .get_mut("agents")
+        .and_then(serde_json::Value::as_object_mut)
+        .and_then(|agents| agents.get_mut(recipient))
+        .and_then(serde_json::Value::as_object_mut)
+    {
+        agent.insert(
+            "current_task_id".to_string(),
+            message_id.as_ref().map_or(serde_json::Value::Null, |id| {
+                serde_json::Value::String(id.clone())
+            }),
+        );
+    }
 }
 
 /// `_stamp_first_send_at_if_leader_to_worker` (`delivery.py:380`):首次 leader→worker 投递戳

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

@@ -1575,6 +1575,17 @@ fn deliver_pending_submit_unverified_is_not_saved_by_readback() {
         "0.3.30: positive readback alone must not mark delivered when submit is unverified"
     );
     assert_ne!(out.message_status.0, "delivered");
+    let updated = crate::state::persist::load_runtime_state(&ws).unwrap();
+    assert_eq!(
+        updated.pointer("/coordinator/turn_open/turn_id"),
+        Some(&serde_json::json!(message_id)),
+        "current-turn fact is armed immediately after physical inject succeeds"
+    );
+    assert_eq!(
+        updated.pointer("/agents/w1/current_task_id"),
+        Some(&serde_json::json!(message_id)),
+        "agent current_task_id is armed without marking the message delivered"
+    );
 }
 
 #[test]

package/package.json

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