@team-agent/installer 0.5.24 → 0.5.25

package/Cargo.lock

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

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

@@ -171,10 +171,23 @@ pub(crate) fn diagnose_runtime_for_workspace(
     backend: &dyn Transport,
 ) -> (Value, Value) {
     let (mut issues, mut repairs) = diagnose_runtime(state, backend);
+    append_legacy_snapshot_issue(workspace, state, &mut issues);
     append_coordinator_health_issue(workspace, state, &mut issues, &mut repairs);
     (issues, repairs)
 }
 
+fn append_legacy_snapshot_issue(workspace: &std::path::Path, state: &Value, issues: &mut Value) {
+    let Ok(Some(details)) = crate::leader::detect_dual_state_divergence(workspace, state) else {
+        return;
+    };
+    if let Some(items) = issues.as_array_mut() {
+        items.push(json!({
+            "id": "legacy_snapshot_stale",
+            "details": details,
+        }));
+    }
+}
+
 fn append_coordinator_health_issue(
     workspace: &std::path::Path,
     state: &Value,

package/crates/team-agent/src/leader/lease.rs

@@ -1780,10 +1780,13 @@ pub fn detect_dual_state_divergence( // B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ: diag
         .or_else(|| get_path_u64(state, &["leader_receiver", "owner_epoch"]));
     let team_epoch = get_path_u64(&snap, &["team_owner", "owner_epoch"])
         .or_else(|| get_path_u64(&snap, &["leader_receiver", "owner_epoch"]));
+    let workspace_agent_bindings = agent_binding_summary(state);
+    let team_agent_bindings = agent_binding_summary(&snap);
     let diverged = workspace_owner_pane != team_owner_pane
         || workspace_owner_uuid != team_owner_uuid
         || workspace_receiver_pane != team_receiver_pane
-        || workspace_epoch != team_epoch;
+        || workspace_epoch != team_epoch
+        || workspace_agent_bindings != team_agent_bindings;
     if !diverged {
         return Ok(None);
     }
@@ -1796,10 +1799,38 @@ pub fn detect_dual_state_divergence( // B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ: diag
         "team_receiver_pane": team_receiver_pane,
         "workspace_owner_epoch": workspace_epoch,
         "team_owner_epoch": team_epoch,
+        "workspace_agent_bindings": workspace_agent_bindings,
+        "team_agent_bindings": team_agent_bindings,
         "_legacy_snapshot_stale": true,
     })))
 }
 
+fn agent_binding_summary(state: &Value) -> Value {
+    let mut out = serde_json::Map::new();
+    let Some(agents) = state.get("agents").and_then(Value::as_object) else {
+        return Value::Object(out);
+    };
+    for (agent_id, agent) in agents {
+        let mut binding = serde_json::Map::new();
+        for key in [
+            "pane_id",
+            "pane_pid",
+            "tmux_endpoint",
+            "tmux_socket",
+            "window",
+            "window_name",
+        ] {
+            if let Some(value) = agent.get(key) {
+                binding.insert(key.to_string(), value.clone());
+            }
+        }
+        if !binding.is_empty() {
+            out.insert(agent_id.clone(), Value::Object(binding));
+        }
+    }
+    Value::Object(out)
+}
+
 fn readable_team_snapshot_path(workspace: &Path, session_name: &str) -> PathBuf { // B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ: diagnostic-only path resolver.
     let safe_path = crate::lifecycle::helpers::team_snapshot_path(workspace, session_name); // B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ: reuses helpers safe legacy path.
     if safe_path.exists() {

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

@@ -238,6 +238,9 @@ pub fn compact_tool_result(result: &Value) -> ToolResult {
             "durably_stored",
             "result_id",
             "task_id",
+            "attributed_message_id",
+            "attribution_scope",
+            "task_id_source",
             "agent_id",
             "new_agent_id",
             "source_agent_id",

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

@@ -20,10 +20,10 @@ use crate::state::persist::{
 use crate::messaging::{self, MessageTarget, SendOptions};
 
 use super::helpers::{
-    delivery_outcome_value, direct_message_attribution_for, ensure_object, enum_value,
-    insert_array, is_worker_recipient, json_dumps_default, latest_task_for_assignee,
-    non_empty_string, normalized_envelope_value, object_fields, requires_ack_for_target,
-    tool_runtime_error, DirectMessageAttribution,
+    current_reportable_message_for, delivery_outcome_value, direct_message_attribution_for,
+    ensure_object, enum_value, insert_array, is_worker_recipient, json_dumps_default,
+    latest_task_for_assignee, non_empty_string, normalized_envelope_value, object_fields,
+    requires_ack_for_target, tool_runtime_error, DirectMessageAttribution,
 };
 use super::normalize::{
     compact_tool_result, normalize_report_envelope, normalize_result_status_observed,
@@ -341,45 +341,76 @@ impl TeamOrchestratorTools {
                 //      only when no newer failed/refused/blocked direct turn blocks fallback
                 //   5. "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 mut attributed_message_id = None;
+                let mut attribution_scope = None;
+                let mut task_id_source = None;
                 let resolved = if let Some(task_id) = task_id {
                     task_id.to_string()
                 } else if let Some(agent) = self.agent_id.as_ref() {
-                    match direct_message_attribution_for(
+                    if let Some(message_id) = current_reportable_message_for(
                         &self.workspace,
                         agent.as_str(),
                         owner_team_id_str.as_deref(),
                     ) {
-                        DirectMessageAttribution::Reportable(message_id) => message_id,
-                        DirectMessageAttribution::BlockedByNewer {
-                            message_id,
-                            status,
-                            error,
-                        } => {
-                            push_report_warning(
-                                obj,
-                                serde_json::json!({
-                                    "code": "result_attribution_blocked_by_newer_direct_message",
-                                    "field": "task_id",
-                                    "severity": "warning",
-                                    "advisory": true,
-                                    "message_id": message_id,
-                                    "message_status": status,
-                                    "message_error": error,
-                                }),
-                            );
-                            "manual".to_string()
-                        }
-                        DirectMessageAttribution::None => latest_task_for_assignee(
+                        attributed_message_id = Some(message_id.clone());
+                        attribution_scope = Some("message");
+                        task_id_source = Some("current_turn_message");
+                        message_id
+                    } else {
+                        match direct_message_attribution_for(
                             &self.workspace,
                             agent.as_str(),
                             owner_team_id_str.as_deref(),
-                        )
-                        .unwrap_or_else(|| "manual".to_string()),
+                        ) {
+                            DirectMessageAttribution::Reportable(message_id) => {
+                                attributed_message_id = Some(message_id.clone());
+                                attribution_scope = Some("message");
+                                task_id_source = Some("direct_message");
+                                message_id
+                            }
+                            DirectMessageAttribution::BlockedByNewer {
+                                message_id,
+                                status,
+                                error,
+                            } => {
+                                push_report_warning(
+                                    obj,
+                                    serde_json::json!({
+                                        "code": "result_attribution_blocked_by_newer_direct_message",
+                                        "field": "task_id",
+                                        "severity": "warning",
+                                        "advisory": true,
+                                        "message_id": message_id,
+                                        "message_status": status,
+                                        "message_error": error,
+                                    }),
+                                );
+                                "manual".to_string()
+                            }
+                            DirectMessageAttribution::None => latest_task_for_assignee(
+                                &self.workspace,
+                                agent.as_str(),
+                                owner_team_id_str.as_deref(),
+                            )
+                            .unwrap_or_else(|| "manual".to_string()),
+                        }
                     }
                 } else {
                     "manual".to_string()
                 };
                 obj.insert("task_id".to_string(), Value::String(resolved));
+                if let Some(message_id) = attributed_message_id {
+                    obj.entry("attributed_message_id")
+                        .or_insert(Value::String(message_id));
+                }
+                if let Some(scope) = attribution_scope {
+                    obj.entry("attribution_scope")
+                        .or_insert(Value::String(scope.to_string()));
+                }
+                if let Some(source) = task_id_source {
+                    obj.entry("task_id_source")
+                        .or_insert(Value::String(source.to_string()));
+                }
             }
             if !obj.contains_key("agent_id") {
                 let resolved = agent_id
@@ -419,6 +450,7 @@ impl TeamOrchestratorTools {
         let normalized = normalize_report_envelope(&base);
         let warnings = report_result_integrity_warnings(&base, &normalized);
         let mut env_value = normalized_envelope_value(&normalized);
+        copy_report_attribution_fields(&base, &mut env_value);
         if !warnings.is_empty() {
             if let Some(obj) = env_value.as_object_mut() {
                 obj.insert("warnings".to_string(), Value::Array(warnings));
@@ -985,6 +1017,24 @@ fn merge_object_fields(existing: &mut Value, incoming: &Value) {
     }
 }
 
+fn copy_report_attribution_fields(source: &Value, target: &mut Value) {
+    let Some(src) = source.as_object() else {
+        return;
+    };
+    let Some(dst) = target.as_object_mut() else {
+        return;
+    };
+    for key in [
+        "attributed_message_id",
+        "attribution_scope",
+        "task_id_source",
+    ] {
+        if let Some(value) = src.get(key) {
+            dst.entry(key.to_string()).or_insert(value.clone());
+        }
+    }
+}
+
 fn push_report_warning(obj: &mut serde_json::Map<String, Value>, warning: Value) {
     let Some(code) = warning.get("code").and_then(Value::as_str) else {
         return;

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

@@ -697,6 +697,7 @@ fn report_result_for_owner_team_inner(
             "task_id".to_string(),
             serde_json::Value::String(task_id.to_string()),
         );
+        copy_report_attribution_fields(envelope, &mut out);
         out.insert(
             "agent_id".to_string(),
             serde_json::Value::String(agent_id.to_string()),
@@ -927,6 +928,7 @@ fn report_result_for_owner_team_inner(
         "task_id".to_string(),
         serde_json::Value::String(task_id.to_string()),
     );
+    copy_report_attribution_fields(envelope, &mut out);
     out.insert(
         "agent_id".to_string(),
         serde_json::Value::String(agent_id.to_string()),
@@ -968,6 +970,21 @@ fn report_result_for_owner_team_inner(
     Ok(serde_json::Value::Object(out))
 }
 
+fn copy_report_attribution_fields(
+    envelope: &serde_json::Value,
+    out: &mut serde_json::Map<String, serde_json::Value>,
+) {
+    for key in [
+        "attributed_message_id",
+        "attribution_scope",
+        "task_id_source",
+    ] {
+        if let Some(value) = envelope.get(key) {
+            out.insert(key.to_string(), value.clone());
+        }
+    }
+}
+
 fn fallback_primary_error_text(cli_primary_error: Option<&str>, observed: String) -> String {
     match cli_primary_error.filter(|error| !error.trim().is_empty()) {
         Some(error) => format!("{error}; {observed}"),

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

@@ -5,7 +5,7 @@
 //! paths or behaviour. It introduces a shared vocabulary that Stage 2 (owner
 //! repository), Stage 5 (per-team runtime state), and Stage 6 (per-team
 //! coordinator) will all consume, so that no later stage has to hand-build
-//! `.team/runtime/<team_key>/...` paths or guess the canonical team_key from
+//! `.team/runtime/teams/<team_key>/...` paths or guess the canonical team_key from
 //! a display name.
 //!
 //! Canonical rules:
@@ -15,10 +15,10 @@
 //! - For the foundation slice, `TeamScope::new(team_key)` accepts whatever
 //!   the caller already resolved (state/selector + state/persist already do
 //!   this work). Slug/hash promotion to global uniqueness lands in Stage 5.
-//! - `TeamRuntimePaths` is the SINGLE place where the
-//!   `.team/runtime/<team_key>/` layout is constructed. Anywhere downstream
-//!   code today hand-joins `runtime_dir(ws).join(team_key).join(...)` it
-//!   should migrate to call a method on `TeamRuntimePaths` in a later stage.
+//! - `TeamRuntimePaths` is the SINGLE place where the future B3
+//!   `.team/runtime/teams/<team_key>/` layout is constructed. Anywhere
+//!   downstream code today hand-joins runtime team paths should migrate to
+//!   call a method on `TeamRuntimePaths` in a later stage.
 //!
 //! Single-team behaviour: unchanged. The foundation does not move data, does
 //! not introduce new files, and is invoked by zero existing call sites yet.
@@ -72,15 +72,15 @@ impl TeamScope {
     }
 }
 
-/// Single source of `.team/runtime/<team_key>/...` path construction.
+/// Single source of future B3 `.team/runtime/teams/<team_key>/...` path construction.
 ///
 /// Stage 2 (owner repository), Stage 5 (per-team state), Stage 6 (per-team
 /// coordinator), and Stage 7 (per-team tmux socket) will all migrate from
 /// hand-built paths to `TeamRuntimePaths`. Today nothing reads from these
 /// methods yet — the foundation just owns the layout decision so when later
-/// stages start writing `.team/runtime/<team_key>/state.json` (Stage 5) or
-/// `.team/runtime/<team_key>/coordinator.pid` (Stage 6), there is exactly
-/// one place to change the layout.
+/// stages start writing `.team/runtime/teams/<team_key>/state.json` (Stage 5)
+/// or `.team/runtime/teams/<team_key>/coordinator.pid` (Stage 6), there is
+/// exactly one place to change the layout.
 #[derive(Debug, Clone)]
 pub struct TeamRuntimePaths {
     workspace: PathBuf,
@@ -110,34 +110,36 @@ impl TeamRuntimePaths {
         &self.team_key
     }
 
-    /// `.team/runtime/<team_key>/` — the team's runtime directory. Today this
-    /// already exists (runtime_spec lives under it). Stage 5 will start
-    /// writing `state.json` here too.
+    /// `.team/runtime/teams/<team_key>/` — the team's future B3 runtime
+    /// directory. It is not used as product authority until the B3 migration;
+    /// current callers must keep using `runtime_state_path`.
     pub fn team_dir(&self) -> PathBuf {
-        runtime_dir(&self.workspace).join(&self.team_key)
+        runtime_dir(&self.workspace)
+            .join("teams")
+            .join(&self.team_key)
     }
 
-    /// `.team/runtime/<team_key>/team.spec.yaml` — runtime spec. Mirrors the
-    /// existing `runtime_spec_path` helper; provided here so downstream
-    /// callers don't need to import two layout APIs.
+    /// Transitional runtime spec path. Mirrors the existing
+    /// `runtime_spec_path` helper while specs remain at
+    /// `.team/runtime/<team_key>/team.spec.yaml`.
     pub fn spec_path(&self) -> PathBuf {
         runtime_spec_path(&self.workspace, &self.team_key)
     }
 
-    /// `.team/runtime/<team_key>/state.json` — the canonical per-team state
-    /// path that Stage 5 will start writing. Not used by Stage 0 product
-    /// code; callers must continue using `runtime_state_path` until Stage 5
+    /// `.team/runtime/teams/<team_key>/state.json` — the canonical per-team
+    /// state path that B3 will start writing. Not used by current product
+    /// code; callers must continue using `runtime_state_path` until B3
     /// migrates the truth source.
     pub fn state_path(&self) -> PathBuf {
         self.team_dir().join("state.json")
     }
 
-    /// `.team/runtime/<team_key>/coordinator.pid` — Stage 6 sidecar location.
+    /// `.team/runtime/teams/<team_key>/coordinator.pid` — future sidecar location.
     pub fn coordinator_pid_path(&self) -> PathBuf {
         self.team_dir().join("coordinator.pid")
     }
 
-    /// `.team/runtime/<team_key>/coordinator.log` — Stage 6 sidecar location.
+    /// `.team/runtime/teams/<team_key>/coordinator.log` — future sidecar location.
     pub fn coordinator_log_path(&self) -> PathBuf {
         self.team_dir().join("coordinator.log")
     }
@@ -240,23 +242,20 @@ mod tests {
     }
 
     #[test]
-    fn team_runtime_paths_layout_matches_existing_runtime_dir_layout() {
+    fn team_runtime_paths_layout_preannounces_b3_state_dir() {
         let paths = TeamRuntimePaths::new(PathBuf::from("/ws/proj"), "alpha");
-        assert_eq!(
-            paths.team_dir(),
-            PathBuf::from("/ws/proj/.team/runtime/alpha")
-        );
+        let b3_team_dir = PathBuf::from("/ws/proj/.team/runtime")
+            .join("teams")
+            .join("alpha");
+        assert_eq!(paths.team_dir(), b3_team_dir);
         assert_eq!(
             paths.spec_path(),
             PathBuf::from("/ws/proj/.team/runtime/alpha/team.spec.yaml")
         );
-        assert_eq!(
-            paths.state_path(),
-            PathBuf::from("/ws/proj/.team/runtime/alpha/state.json")
-        );
+        assert_eq!(paths.state_path(), b3_team_dir.join("state.json"));
         assert_eq!(
             paths.coordinator_pid_path(),
-            PathBuf::from("/ws/proj/.team/runtime/alpha/coordinator.pid")
+            b3_team_dir.join("coordinator.pid")
         );
     }
 

package/package.json

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