@team-agent/installer 0.5.50 → 0.5.52

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;
 
@@ -682,6 +705,7 @@ fn spine_add_agent_rejects_duplicate_agent_id() {
 #[test]
 fn e5_add_agent_does_not_copy_role_into_platform_dir_and_injects_into_spec() {
     let team = quick_start_team_dir(QS_VALID_ROLE);
+    seed_canonical_team_identity(&team, "teamdir");
     // External role file OUTSIDE team_dir/agents, with recognizable body content.
     let role = team.parent().unwrap().join("w2-external-role.md");
     let role_body = "---\nname: w2\nrole: Second Worker\nprovider: codex\nmodel: gpt-5.5\nauth_mode: subscription\ntools:\n  - mcp_team\n---\n\nUNIQUE-E5-BUG1-MARKER body for w2.\n";
@@ -968,7 +992,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 +1013,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"
@@ -1131,6 +1155,12 @@ pub(super) fn seed_healthy_coordinator(workspace: &std::path::Path) {
     .unwrap();
 }
 
+fn seed_canonical_team_identity(workspace: &std::path::Path, team_key: &str) {
+    let mut state = crate::state::persist::load_runtime_state(workspace).unwrap();
+    state["active_team_key"] = json!(team_key);
+    crate::state::persist::save_runtime_state(workspace, &state).unwrap();
+}
+
 // RED — quick_start_with_transport must drive the REAL spawn path: launch.dry_run==false, started
 // non-empty (one per compiled agent), and the transport records >=1 spawn carrying that agent's
 // provider build_command. Today the dry_run=true bug -> launch.started empty + ZERO spawns recorded ->
@@ -2240,6 +2270,7 @@ fn add_agent_with_transport_spawns_new_worker_not_stub() {
     let role_file = team.join("worker2-role.md"); // OUTSIDE agents/ -> not a duplicate of an existing agent
     std::fs::write(&role_file, DELEG_ROLE_WORKER2).unwrap();
     seed_healthy_coordinator(&team);
+    seed_canonical_team_identity(&team, "addteam");
     let transport = OfflineTransport::new();
 
     let _result = add_agent_with_transport(
@@ -3117,6 +3148,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
@@ -3278,6 +3339,7 @@ fn add_agent_reachability_gate_returns_error_when_spawn_pane_not_addressable() {
     let role_file = team.join("worker2-role.md");
     std::fs::write(&role_file, DELEG_ROLE_WORKER2).unwrap();
     seed_healthy_coordinator(&team);
+    seed_canonical_team_identity(&team, "reachgate");
 
     // Models "spawn to wrong socket" / "spawn succeeded but pane orphan": the
     // OfflineTransport records the spawn but reports the new pane is NOT
@@ -3337,6 +3399,7 @@ fn add_agent_reachability_gate_passes_when_spawn_pane_addressable() {
     let role_file = team.join("worker2-role.md");
     std::fs::write(&role_file, DELEG_ROLE_WORKER2).unwrap();
     seed_healthy_coordinator(&team);
+    seed_canonical_team_identity(&team, "gatepass");
 
     // Default OfflineTransport: spawned_panes_addressable=true, liveness=Unknown
     // (treated as not-Dead by the gate's fallthrough).
@@ -4096,6 +4159,7 @@ fn e42_re_add_and_remove_agree_on_existence_after_add() {
     let role_file = team.join("newagent.md");
     std::fs::write(&role_file, DELEG_ROLE_WORKER2).unwrap();
     seed_healthy_coordinator(&team);
+    seed_canonical_team_identity(&team, "e42sym");
     let transport = OfflineTransport::new();
     // (1) first add
     let r1 = crate::lifecycle::add_agent_with_transport(
@@ -4152,6 +4216,7 @@ fn e42_add_writes_to_canonical_runtime_spec_and_state_consistently() {
     let role_file = team.join("newagent.md");
     std::fs::write(&role_file, DELEG_ROLE_WORKER2).unwrap();
     seed_healthy_coordinator(&team);
+    seed_canonical_team_identity(&team, "e42proj");
     let transport = OfflineTransport::new();
     let _ = crate::lifecycle::add_agent_with_transport(
         &team,

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/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,7 +85,7 @@ 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, TrustedSender};

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

@@ -319,20 +319,16 @@ fn send_message_worker_recipient_surfaces_dead_coordinator_warning() {
             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]

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

@@ -311,8 +311,25 @@
     // ════════════════════════════════════════════════════════════════════════
     #[test]
     fn update_state_returns_ok_and_state_file_path() {
+        let ws = seed_state_ws(
+            "update-state",
+            &json!({
+                "active_team_key": "teamA",
+                "team_key": "teamA",
+                "session_name": "teamA",
+                "status": "alive",
+                "teams": {
+                    "teamA": {
+                        "team_key": "teamA",
+                        "session_name": "teamA",
+                        "status": "alive",
+                        "agents": {}
+                    }
+                }
+            }),
+        );
         let tools = TeamOrchestratorTools::with_identity(
-            &unique_ws("update-state"),
+            &ws,
             Some(AgentId::new("leader")),
             Some(TeamKey::new("teamA")),
         );

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

@@ -22,12 +22,19 @@ fn keys(v: &Value) -> Vec<String> {
 /// `/tmp/ws`, or they flake under parallel cargo (sqlite "database is locked" / NotFound).
 /// Pure-function / dispatch-shape tests that never touch fs/db keep a dummy fixed path.
 fn unique_ws(tag: &str) -> std::path::PathBuf {
+    use std::io::ErrorKind;
     use std::sync::atomic::{AtomicU64, Ordering};
     static N: AtomicU64 = AtomicU64::new(0);
-    let n = N.fetch_add(1, Ordering::Relaxed);
-    let p = std::env::temp_dir().join(format!("ta-rs-mcp-{tag}-{}-{n}", std::process::id()));
-    std::fs::create_dir_all(&p).unwrap();
-    p
+    loop {
+        let n = N.fetch_add(1, Ordering::Relaxed);
+        let p =
+            std::env::temp_dir().join(format!("ta-rs-mcp-{tag}-{}-{n}", std::process::id()));
+        match std::fs::create_dir(&p) {
+            Ok(()) => return p,
+            Err(error) if error.kind() == ErrorKind::AlreadyExists => {}
+            Err(error) => panic!("create unique workspace {}: {error}", p.display()),
+        }
+    }
 }
 
 include!("tests/normalize.rs");

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

@@ -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);
@@ -213,6 +221,7 @@ 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,

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