@team-agent/installer 0.5.49 → 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/lifecycle/tests/phase_golden.rs

@@ -259,7 +259,7 @@ fn run_phase_golden(spec: PhaseGolden) -> Value {
         workspace: workspace.clone(),
         team: Some(spec.team_key.to_string()),
         task: None,
-        sender: "leader".to_string(),
+        sender: crate::messaging::TrustedSender::leader(),
         no_ack: true,
         no_wait: true,
         watch_result: false,

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,10 +85,10 @@ 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};
+use crate::messaging::{self, DeliveryOutcome, MessageTarget, SendOptions, TrustedSender};
 
 pub mod helpers;
 pub(crate) mod lifecycle_tools;

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

@@ -155,7 +155,6 @@ fn send_message_worker_recipient_returns_accepted_with_poll_hint() {
         None,
         None,
         None,
-        None,
     );
     match outcome {
         Ok(SendOutcome::WorkerAccepted {
@@ -185,7 +184,6 @@ fn ordinary_send_assign_shape_has_no_recovery_marker() {
             None,
             None,
             None,
-            None,
         )
         .expect("ordinary send ok")
         .to_value();
@@ -240,6 +238,22 @@ fn ordinary_send_assign_shape_has_no_recovery_marker() {
     );
 }
 
+#[test]
+fn send_message_without_framework_identity_fails_closed() {
+    let ws = seed_current_worker_state("missing-sender-identity");
+    let tools = TeamOrchestratorTools::with_identity(&ws, None, Some(TeamKey::new("current")));
+    let error = tools
+        .send_message(
+            &MessageTarget::Single("worker-1".to_string()),
+            "must not be attributed to unknown",
+            None,
+            None,
+            None,
+        )
+        .expect_err("missing framework identity must fail before persistence");
+    assert_eq!(error.reason, ToolErrorReason::McpScopeRefused);
+}
+
 #[test]
 fn recovery_assign_shape_has_structured_marker() {
     let ws = seed_current_worker_state("recovery-marker");
@@ -304,22 +318,17 @@ fn send_message_worker_recipient_surfaces_dead_coordinator_warning() {
             None,
             None,
             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]
@@ -336,7 +345,6 @@ fn send_message_leader_recipient_is_direct_not_accepted() {
             None,
             None,
             None,
-            None,
         )
         .expect("leader send ok");
     assert!(
@@ -435,7 +443,6 @@ fn send_message_cross_team_peer_surfaces_peer_not_in_scope_error() {
             None,
             None,
             None,
-            None,
         )
         .expect_err("out-of-scope peer must be refused");
     assert_eq!(err.reason, ToolErrorReason::PeerNotInScope);

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

@@ -66,6 +66,12 @@
         );
         assert_eq!(send["inputSchema"]["additionalProperties"], json!(false));
         assert_eq!(send["inputSchema"]["required"], json!(["to", "content"]));
+        for internal in ["sender", "task_id", "requires_ack"] {
+            assert!(
+                send["inputSchema"]["properties"].get(internal).is_none(),
+                "{internal} is framework-owned, not caller-supplied"
+            );
+        }
     }
 
     #[test]

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

@@ -17,7 +17,7 @@ use crate::state::persist::{
 };
 
 // ── REUSE: step 11 messaging delegate surface ───────────────────────────────
-use crate::messaging::{self, MessageTarget, SendOptions};
+use crate::messaging::{self, MessageTarget, SendOptions, TrustedSender};
 
 use super::helpers::{
     current_reportable_message_for, delivery_outcome_value, direct_message_attribution_for,
@@ -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);
@@ -140,7 +148,6 @@ impl TeamOrchestratorTools {
             Some(task_id),
             None,
             None,
-            None,
         )?;
         let mut ok = compact_tool_result(&out.to_value())?;
         if recovery {
@@ -155,7 +162,7 @@ impl TeamOrchestratorTools {
     }
 
     /// `send_message` (`tools.py:135-183`): C14/C15/C17 scope resolution.
-    ///   - sender = explicit / `TEAM_AGENT_ID` env / `"unknown"` (no candidate scan).
+    ///   - sender = immutable `TEAM_AGENT_ID` captured when the MCP server starts.
     ///   - `requires_ack` defaults from target (`_requires_ack_for_target`).
     ///   - C23 cross-team pre-refusal ([`Self::refuse_cross_team_peer`]) before any
     ///     runtime call.
@@ -168,7 +175,6 @@ impl TeamOrchestratorTools {
         to: &MessageTarget,
         content: &str,
         task_id: Option<&str>,
-        sender: Option<&str>,
         requires_ack: Option<bool>,
         scope_override: Option<Scope>,
     ) -> Result<SendOutcome, ToolError> {
@@ -183,10 +189,14 @@ impl TeamOrchestratorTools {
         if let Some(err) = self.refuse_cross_team_peer(to, None) {
             return Err(err);
         }
-        let sender = sender
-            .and_then(non_empty_string)
-            .or_else(|| self.agent_id.as_ref().map(AgentId::as_str))
-            .unwrap_or("unknown");
+        let sender = self.agent_id.clone().ok_or_else(|| {
+            ToolError::new(
+                ToolErrorReason::McpScopeRefused,
+                "send_message requires framework-injected TEAM_AGENT_ID",
+                "IdentityError",
+            )
+        })?;
+        let sender = TrustedSender::from_runtime_identity(sender);
         let ack = requires_ack.unwrap_or_else(|| requires_ack_for_target(to));
         // C14/C15/C17 scope audit (#230 I-2/I-6 contract): emit mcp.scope_resolved
         // for every worker-origin send before any routing/delivery — the funnel
@@ -197,7 +207,7 @@ impl TeamOrchestratorTools {
                 "mcp.scope_resolved",
                 serde_json::json!({
                     "tool": "send_message",
-                    "sender": sender,
+                    "sender": sender.as_str(),
                     "owner_team_id": canonical_owner_team.as_ref().map(TeamKey::as_str),
                     "to": match to {
                         MessageTarget::Single(t) => serde_json::Value::String(t.clone()),
@@ -211,9 +221,10 @@ 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: sender.to_string(),
+            sender,
             requires_ack: ack,
             team: canonical_owner_team,
             ..SendOptions::default()

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

@@ -417,21 +417,6 @@ fn tool_properties(tool: McpTool) -> serde_json::Map<String, Value> {
                 string_property("Target agent id, 'leader', or '*' for broadcast."),
             );
             insert_property(&mut properties, "content", string_property("Message body."));
-            insert_property(
-                &mut properties,
-                "task_id",
-                string_property("Optional task id to associate with the message."),
-            );
-            insert_property(
-                &mut properties,
-                "sender",
-                string_property("Optional sender override."),
-            );
-            insert_property(
-                &mut properties,
-                "requires_ack",
-                boolean_property("Whether the recipient should acknowledge delivery."),
-            );
         }
         McpTool::ReportResult => {
             insert_property(
@@ -609,9 +594,8 @@ pub(crate) fn dispatch_tool(
             let outcome = tools.send_message(
                 &target,
                 content,
-                args.get("task_id").and_then(Value::as_str),
-                args.get("sender").and_then(Value::as_str),
-                args.get("requires_ack").and_then(Value::as_bool),
+                None,
+                None,
                 None,
             )?;
             match outcome {

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());
+    }
+}