@team-agent/installer 0.5.80 → 0.5.82

package/crates/team-agent/src/lifecycle/launch/pi_mcp.rs

@@ -1089,7 +1089,6 @@ fn materialize_pi_plan_with_session(
     })?;
     let (argv, expected_session_id) = if let Some((_session_id, exact_path)) = resume {
         let argv = build_pi_command_argv(PiCommandRequest {
-            executable: &chain.launch_executable,
             extension: &wrapper,
             model: model.as_deref(),
             effort: request.effort,
@@ -1103,7 +1102,6 @@ fn materialize_pi_plan_with_session(
     } else {
         let session_id = new_pi_session_id();
         let argv = build_pi_command_argv(PiCommandRequest {
-            executable: &chain.launch_executable,
             extension: &wrapper,
             model: model.as_deref(),
             effort: request.effort,

package/crates/team-agent/src/lifecycle/tests/communication_mode_runtime_contract_red.rs

@@ -112,7 +112,13 @@ fn t06_selected_templates_project_the_two_signed_communication_boundaries() {
     };
 
     let leader = prompt(CommunicationMode::LeaderCentric);
-    for marker in ["Progress", "blocker", "question"] {
+    for marker in [
+        "Progress",
+        "blocker",
+        "question",
+        "actionable requests or questions",
+        "Do not reply to pure ACKs, greetings, or unchanged status notices",
+    ] {
         assert!(
             leader.contains(marker),
             "T06/leader_centric: official template must retain {marker:?} guidance; prompt={leader:?}"
@@ -120,7 +126,11 @@ fn t06_selected_templates_project_the_two_signed_communication_boundaries() {
     }
 
     let orchestrated = prompt(CommunicationMode::Orchestrated);
-    for marker in ["declared channel", "task-related", "ACK"] {
+    for marker in [
+        "declared channel",
+        "Respond to task-related messages through Team Agent MCP tools.",
+        "A pure ACK, unrelated status, or non-task message does not require a response.",
+    ] {
         assert!(
             orchestrated.contains(marker),
             "T06/orchestrated: official template must state the on-demand channel/response boundary via {marker:?}; prompt={orchestrated:?}"
@@ -159,7 +169,7 @@ fn t07_final_spawn_prompt_does_not_leak_leader_centric_obligations_into_orchestr
 
     for required in [
         "All communication must go through Team Agent MCP tools.",
-        "If blocked or waiting, send_message to the leader. Do not wait silently.",
+        "Do not reply to pure ACKs, greetings, or unchanged status notices",
         "report_result exactly once",
     ] {
         assert!(
@@ -186,7 +196,8 @@ fn t07_final_spawn_prompt_does_not_leak_leader_centric_obligations_into_orchestr
         .expect("T07/leader_centric positive control: missing recorded default spawn");
     for required in [
         "Progress, blockers, questions:",
-        "When you receive a message from the leader or a teammate, you MUST respond",
+        "actionable requests or questions",
+        "Do not reply to pure ACKs, greetings, or unchanged status notices",
     ] {
         assert!(
             default_prompt.contains(required),

package/crates/team-agent/src/lifecycle/tests/pi_catalog_red.rs

@@ -87,7 +87,6 @@ fn argv_has_pair(argv: &[String], flag: &str, value: &str) -> bool {
 
 fn command_for_model(model: &str) -> Vec<String> {
     build_pi_command_argv(PiCommandRequest {
-        executable: Path::new("/verified/pi"),
         extension: Path::new("/workspace/.team/runtime/pi/t1/w1/team-mcp.ts"),
         model: Some(model),
         effort: Some(ProviderEffort::Medium),

package/crates/team-agent/src/lifecycle/tests/pi_command_red.rs

@@ -6,7 +6,6 @@ use crate::provider::adapters::pi::{build_pi_command_argv, PiCommandRequest, PiS
 
 fn request(session: PiSessionSelector<'static>) -> PiCommandRequest<'static> {
     PiCommandRequest {
-        executable: Path::new("/verified/pi"),
         extension: Path::new("/workspace/.team/runtime/pi/team-a/worker-a/team-mcp.ts"),
         model: Some("team-agent/qwen3.8-27b"),
         effort: Some(ProviderEffort::High),
@@ -35,7 +34,6 @@ fn pi_command_omits_unset_model_and_thinking_flags() {
 
 fn leader_request() -> PiCommandRequest<'static> {
     PiCommandRequest {
-        executable: Path::new("/verified/pi"),
         extension: Path::new("/workspace/.team/runtime/pi/current/leader/team-mcp.ts"),
         model: None,
         effort: None,
@@ -56,7 +54,7 @@ fn pi_interactive_leader_argv_preserves_native_session_discovery() {
     assert_eq!(
         argv,
         [
-            "/verified/pi",
+            "pi",
             "-e",
             "/workspace/.team/runtime/pi/current/leader/team-mcp.ts",
             "--append-system-prompt",
@@ -109,7 +107,7 @@ fn pi_command_preserves_direct_pi_defaults_with_only_team_runtime_additions() {
     assert_eq!(
         fresh,
         [
-            "/verified/pi",
+            "pi",
             "-e",
             "/workspace/.team/runtime/pi/team-a/worker-a/team-mcp.ts",
             "--model",
@@ -143,6 +141,7 @@ fn pi_command_preserves_direct_pi_defaults_with_only_team_runtime_additions() {
     assert!(!resume.iter().any(|arg| arg == "--session-id"));
 
     for argv in [&fresh, &resume] {
+        assert_eq!(argv.first().map(String::as_str), Some("pi"));
         for forbidden in [
             "rpc",
             "--mode",

package/crates/team-agent/src/lifecycle/tests/pi_compiler_red.rs

@@ -53,7 +53,6 @@ fn compile_error(result: Result<CompiledRole, ModelError>) -> ModelError {
 
 fn command(tools: &[&str], effort: ProviderEffort, model: &str) -> Result<Vec<String>, String> {
     build_pi_command_argv(PiCommandRequest {
-        executable: Path::new("/verified/pi"),
         extension: Path::new("/workspace/.team/runtime/pi/t1/pi-worker/team-mcp.ts"),
         model: Some(model),
         effort: Some(effort),

package/crates/team-agent/src/lifecycle/tests/pi_executable_mcp_red.rs

@@ -586,6 +586,7 @@ fn pi_materializer_and_worker_routes_body(hermetic: &HermeticTestEnv) {
         !native_paths.sessions.exists(),
         "NativeDefault must not create the Team Agent seat session root"
     );
+    assert_eq!(native.argv.first().map(String::as_str), Some("pi"));
     for forbidden in ["--session-dir", "--cwd", "--workspace", "--session"] {
         assert!(
             !native.argv.iter().any(|arg| arg == forbidden),
@@ -614,6 +615,7 @@ fn pi_materializer_and_worker_routes_body(hermetic: &HermeticTestEnv) {
         isolated.provider_projects_root.as_deref(),
         Some(isolated_paths.sessions.as_path())
     );
+    assert_eq!(isolated.argv.first().map(String::as_str), Some("pi"));
     assert_session_pair(&isolated.argv, &isolated_paths.sessions);
     assert!(!isolated.argv.iter().any(|arg| arg == "--cwd"));
     assert!(!isolated.argv.iter().any(|arg| arg == "--workspace"));
@@ -645,6 +647,7 @@ fn pi_materializer_and_worker_routes_body(hermetic: &HermeticTestEnv) {
         resumed.provider_projects_root.as_deref(),
         Some(isolated_paths.sessions.as_path())
     );
+    assert_eq!(resumed.argv.first().map(String::as_str), Some("pi"));
     assert_session_pair(&resumed.argv, &isolated_paths.sessions);
     assert!(
         resumed
@@ -757,6 +760,7 @@ fn pi_materializer_and_worker_routes_body(hermetic: &HermeticTestEnv) {
                     .any(|arg| arg.as_str() == paths.wrapper.to_string_lossy().as_ref())
             })
             .expect("transport spawn record for worker seat");
+        assert_eq!(record.1.first().map(String::as_str), Some("pi"));
         assert_session_pair(&record.1, &paths.sessions);
         assert!(
             !record
@@ -861,6 +865,7 @@ fn pi_materializer_and_worker_routes_body(hermetic: &HermeticTestEnv) {
         .into_iter()
         .next()
         .expect("restart must reach the worker spawn construction");
+    assert_eq!(restart_record.1.first().map(String::as_str), Some("pi"));
     assert_session_pair(&restart_record.1, &restart_paths.sessions);
     assert!(
         restart_record

package/crates/team-agent/src/lifecycle/tests/pi_session_delivery_red.rs

@@ -54,7 +54,6 @@ fn scan_context(cwd: &Path, root: &Path, id: &str, generation: &str) -> CaptureS
 
 fn resume_argv(path: &Path) -> Result<Vec<String>, ProviderError> {
     build_pi_command_argv(PiCommandRequest {
-        executable: Path::new("/verified/pi"),
         extension: Path::new("/workspace/.team/runtime/pi/team-a/worker-a/team-mcp.ts"),
         model: Some("team-agent/qwen3.8-27b"),
         effort: Some(ProviderEffort::Medium),

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

@@ -28,20 +28,20 @@ use crate::model::permissions::{resolve_permissions, AgentPermissionInput};
 
 const RUNTIME_CONTRACT_SECTION: &str = r#"# Team Agent Teammate Runtime Contract
 
-You are a teammate in a Team Agent runtime. The leader cannot see your terminal
-output. All communication must go through Team Agent MCP tools.
+You are a Team Agent teammate; leader cannot see terminal output.
+All communication must go through Team Agent MCP tools.
 
-## Communication (mandatory)
+## Communication:
 
-- Coordinate with teammate: {send_message}(to='<agent_id>', content='...')
-- Broadcast to all teammates: {send_message}(to='*', content='...')
-- Task complete: {report_result}(summary='...') — call exactly once
+- Teammate: {send_message}(to='<agent_id>', content='...')
+- Broadcast: {send_message}(to='*', content='...')
+- Complete: {report_result}(summary='...') — call exactly once
 
-## Rules
+## Rules:
 
-- Do not pass sender, task_id, or schema_version — the MCP runtime fills them.
-- If blocked or waiting, send_message to the leader. Do not wait silently.
-- On 500/529/rate-limit errors, wait 1-2 minutes before retrying."#;
+- Do not pass sender, task_id, or schema_version — MCP fills them.
+- Do not reply to pure ACKs, greetings, or unchanged status notices (such as "paused" or "waiting"); after reporting a blocker once or completing a task, remain silent until a new actionable instruction arrives.
+- On 500/529/rate limits, retry only after 1-2 minutes."#;
 
 // 0.4.11 trimmed: the runtime contract section above already covers
 // send_message signatures and report_result exactly-once. The output
@@ -363,9 +363,7 @@ fn pi_communication_contract(mode: CommunicationMode) -> String {
 
 - Progress, blockers, questions: mcp({tool:"team_orchestrator_send_message", args:{to:"leader", content:"..."}})
 
-When you receive a message from the leader or a teammate, you MUST respond
-through MCP tools. Writing a reply in your terminal does nothing — the sender
-will never see it."#
+Respond through Team Agent MCP tools only to actionable requests or questions; writing in your terminal does not deliver it."#
             .to_string(),
         CommunicationMode::Orchestrated => mode.runtime_contract("mcp"),
     }
@@ -598,4 +596,40 @@ mod tests {
         assert!(prompt.contains(&slowdown_phrase));
         assert!(prompt.contains("Runtime Developer"));
     }
+
+    #[test]
+    fn all_provider_mode_prompts_share_silence_contract_without_unconditional_replies() {
+        for provider in [Provider::Codex, Provider::Pi] {
+            for mode in CommunicationMode::ALL.iter().copied() {
+                let agent = WorkerCommandAgent {
+                    id: Some("worker".to_string()),
+                    provider,
+                    role: Some("developer".to_string()),
+                    declared_tools: Some(vec!["mcp_team".to_string()]),
+                    system_prompt_inline: Some("worker body".to_string()),
+                    system_prompt_file: None,
+                    output_contract_format: Some("result_envelope_v1".to_string()),
+                    communication_mode: mode,
+                    dangerously_skip_permissions: false,
+                };
+                let prompt = compile_worker_system_prompt(&agent).unwrap();
+                assert!(prompt.contains(
+                    "Do not reply to pure ACKs, greetings, or unchanged status notices (such as \"paused\" or \"waiting\"); after reporting a blocker once or completing a task, remain silent until a new actionable instruction arrives."
+                ));
+                assert!(!prompt.contains("Silence and resumption (mandatory)"));
+                assert!(!prompt.contains("When you receive a message from the leader or a teammate, you MUST respond"));
+                match mode {
+                    CommunicationMode::LeaderCentric => {
+                        assert!(prompt.contains(
+                            "Respond through Team Agent MCP tools only to actionable requests or questions; writing in your terminal does not deliver it."
+                        ));
+                    }
+                    CommunicationMode::Orchestrated => {
+                        assert!(prompt.contains("Respond to task-related messages through Team Agent MCP tools."));
+                        assert!(prompt.contains("A pure ACK, unrelated status, or non-task message does not require a response."));
+                    }
+                }
+            }
+        }
+    }
 }

package/crates/team-agent/src/mcp_server/lifecycle_tools/state_status.rs

@@ -24,14 +24,10 @@ pub(crate) fn update_state(
         }
         Err(err) => return Err(tool_runtime_error(err)),
     };
-    let mut state = selected.state;
-    ensure_object(&mut state);
-    append_note(&mut state, note);
-    crate::state::repository::StateRepository::new(&selected.run_workspace).save_reapplying(
+    let state = crate::state::repository::StateRepository::new(&selected.run_workspace).commit(
         crate::state::repository::StateWriteIntent::McpUpdateStateNote {
             team_key: Some(&selected.team_key),
         },
-        &state,
         |latest| {
             ensure_object(latest);
             append_note(latest, note);
@@ -65,15 +61,10 @@ fn update_state_without_spec(
         crate::state::selector::SelectorMode::RuntimeOnly,
     )
     .map_err(tool_runtime_error)?;
-    let mut state = selected.state;
-    ensure_object(&mut state);
-    seed_legacy_team_key(&mut state, &selected.run_workspace, &selected.team_key);
-    append_note(&mut state, note);
-    crate::state::repository::StateRepository::new(&selected.run_workspace).save_reapplying(
+    let state = crate::state::repository::StateRepository::new(&selected.run_workspace).commit(
         crate::state::repository::StateWriteIntent::McpUpdateStateNote {
             team_key: Some(&selected.team_key),
         },
-        &state,
         |latest| {
             ensure_object(latest);
             seed_legacy_team_key(latest, &selected.run_workspace, &selected.team_key);

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

@@ -142,14 +142,12 @@ impl TeamOrchestratorTools {
             .canonical_owner_team_key()?
             .map(|team| team.as_str().to_string())
             .or_else(|| assignment_team_key(&state));
-        reconcile_assigned_task(&mut state, team_key.as_deref(), &task_value);
         crate::state::repository::StateRepository::new(&self.workspace)
-            .save_reapplying(
+            .commit(
                 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));

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

@@ -287,9 +287,8 @@ fn collect_scoped(
         collected_results.push(summary);
     }
     if state_dirty {
-        crate::state::repository::StateRepository::new(&paths.run_workspace).save_reapplying(
+        state = crate::state::repository::StateRepository::new(&paths.run_workspace).commit(
             crate::state::repository::StateWriteIntent::ResultCollection { owner_team_id },
-            &state,
             |latest| {
                 for (task_id, result_id) in &task_updates {
                     mark_task_done(latest, task_id, result_id);

package/crates/team-agent/src/provider/adapters/pi.rs

@@ -58,7 +58,6 @@ pub(crate) enum PiSessionSelector<'a> {
 }
 
 pub(crate) struct PiCommandRequest<'a> {
-    pub executable: &'a Path,
     pub extension: &'a Path,
     pub model: Option<&'a str>,
     pub effort: Option<ProviderEffort>,
@@ -72,14 +71,13 @@ pub(crate) struct PiCommandRequest<'a> {
 
 /// ---
 /// purpose: 从已验证 semantic request 构造仅追加 Team Agent MCP/提示/session 的 Pi argv
-/// returns: exact ordered fresh/resume argv
+/// returns: exact ordered fresh/resume argv，argv[0] 固定为裸 `pi`
 /// errors: 必需字段、mcp_team 或工具 category 非法时返回 ProviderError
 /// ---
 pub(crate) fn build_pi_command_argv(
     request: PiCommandRequest<'_>,
 ) -> Result<Vec<String>, ProviderError> {
-    if request.executable.as_os_str().is_empty()
-        || request.extension.as_os_str().is_empty()
+    if request.extension.as_os_str().is_empty()
         || request
             .session_dir
             .is_some_and(|session_dir| session_dir.as_os_str().is_empty())
@@ -88,7 +86,7 @@ pub(crate) fn build_pi_command_argv(
         || request.agent_id.trim().is_empty()
     {
         return Err(ProviderError::Command(
-            "Pi command requires executable, extension, prompt, and agent id".to_string(),
+            "Pi command requires extension, prompt, and agent id".to_string(),
         ));
     }
 
@@ -110,8 +108,10 @@ pub(crate) fn build_pi_command_argv(
         ));
     }
 
+    // Executable discovery/preflight belongs to the lifecycle materializer;
+    // the actual command must remain PATH-resolved at spawn time.
     let mut argv = vec![
-        request.executable.to_string_lossy().into_owned(),
+        "pi".to_string(),
         "-e".to_string(),
         request.extension.to_string_lossy().into_owned(),
     ];

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

@@ -591,8 +591,48 @@ fn persist_runtime_state_with_merge_options_and_expected(
     // on-disk latest. Re-strip here so the serialized payload is always
     // canonical-only when a canonical teams.<key>.team_owner is present.
     crate::state::ownership::strip_top_level_ownership_if_canonical_present(&mut migrated);
-    // 字节对拍 Python json.dumps(indent=2, ensure_ascii=False)(无尾换行)。
-    let payload = serde_json::to_string_pretty(&migrated)?;
+    write_state_under_lock(workspace, &path, &migrated)
+}
+
+/// Apply a bounded writer to disk under state-save, without a cache shortcut.
+pub(super) fn update_runtime_state(
+    workspace: &Path,
+    update: impl FnOnce(&Value) -> Result<Value, StateError>,
+) -> Result<Value, StateError> {
+    let path = runtime_state_path(workspace);
+    let _lock = RuntimeLock::acquire(workspace, "state-save", 2.0)?;
+    // Malformed/unreadable state is an error, never an empty store.
+    let mut latest = match std::fs::read_to_string(&path) {
+        Ok(text) => serde_json::from_str(&text)?,
+        Err(error) if error.kind() == io::ErrorKind::NotFound => json!({}),
+        Err(error) => return Err(error.into()),
+    };
+    normalize_agent_session_state(&mut latest);
+    migrate_state_identity(&mut latest, &SystemEnv, workspace)?;
+    let _ = migrate_active_team_key(&mut latest);
+    let mut committed = update(&latest)?;
+    merge_ordinary_state(&mut committed, &latest)?;
+    migrate_state_identity(&mut committed, &SystemEnv, workspace)?;
+    crate::state::ownership::strip_top_level_ownership_if_canonical_present(&mut committed);
+    if committed == latest {
+        cache_set(&path, &committed);
+        return Ok(committed);
+    }
+    write_state_under_lock(workspace, &path, &committed)?;
+    Ok(committed)
+}
+
+/// Reuse ordinary roster, topology, ownership, capture and endpoint guards.
+pub(super) fn merge_ordinary_state(incoming: &mut Value, latest: &Value) -> Result<(), StateError> {
+    apply_persist_merge_contract(
+        incoming, latest, &BTreeSet::new(), None, &BTreeSet::new(),
+        &BTreeSet::new(), &BTreeSet::new(), None, None, None,
+    )
+}
+
+fn write_state_under_lock(workspace: &Path, path: &Path, migrated: &Value) -> Result<(), StateError> {
+    // Shared retry/self-heal/atomic replacement path; caller owns state-save.
+    let payload = serde_json::to_string_pretty(migrated)?;
     let delays = [0.05_f64, 0.2, 0.5];
 
     for attempt in 0..=delays.len() {

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

@@ -775,6 +775,30 @@ pub fn save_team_scoped_state(workspace: &Path, team_state: &Value) -> Result<()
     save_team_scoped_state_with_deleted_agents(workspace, team_state, &[])
 }
 
+/// Materialize a bounded Team update from the lock-held workspace. Siblings
+/// come only from latest; retain the existing primary/legacy projection rules.
+pub(super) fn merge_committed_team(existing: &Value, team_state: &Value, target_key: &str) -> Value {
+    let mut primary = existing.get("session_name").and_then(Value::as_str)
+        .filter(|name| !name.is_empty()).map(|_| team_state_key(existing));
+    if primary.as_deref().is_some_and(|key| key != target_key)
+        && existing.get("session_name") == team_state.get("session_name")
+    {
+        primary = Some(target_key.to_string());
+    }
+    let mut teams = take_object(existing.get("teams"));
+    if teams.is_empty() && primary.as_deref() == Some(target_key) {
+        return compact_team_state(team_state);
+    }
+    teams.insert(target_key.to_string(), compact_team_state(team_state));
+    let mut merged = if primary.is_none() || primary.as_deref() == Some(target_key) {
+        to_object(team_state)
+    } else {
+        to_object(existing)
+    };
+    merged.insert("teams".to_string(), Value::Object(teams));
+    Value::Object(merged)
+}
+
 pub(crate) fn save_team_scoped_state_reapplying_after_conflict<F>(
     workspace: &Path,
     team_state: &Value,

package/crates/team-agent/src/state/repository/tests.rs

@@ -46,3 +46,84 @@ fn optional_unmigrated_read_preserves_missing_corrupt_and_valid_shapes(
     std::fs::remove_dir_all(workspace)?;
     Ok(())
 }
+
+#[test]
+fn coordinator_observations_keep_legacy_identity_and_shape()
+    -> Result<(), Box<dyn std::error::Error>> {
+    let nonce = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)?
+        .as_nanos();
+    let workspace =
+        std::env::temp_dir().join(format!("state-repository-legacy-observation-{nonce}"));
+    let initial = serde_json::json!({
+        "active_team_key": "team",
+        "agents": {"w1": {"agent_id": "w1", "provider": "codex", "status": "running"}}
+    });
+    let path = super::helper_workspace_path(&workspace);
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+    std::fs::write(&path, serde_json::to_vec(&initial)?)?;
+    let repository = super::StateRepository::new(&workspace);
+    let before = repository.load_workspace()?;
+
+    let mut observed = before.clone();
+    observed["coordinator"] = serde_json::json!({
+        "abnormal_exit_watch": {"w1": {"last_error_observation_key": "error-1"}}
+    });
+    repository.commit_observations(
+        StateWriteIntent::CoordinatorTick {
+            team_key: "current",
+        },
+        &before,
+        &observed,
+    )?;
+    let first = repository.load_workspace()?;
+    assert!(
+        first.get("teams").is_none(),
+        "legacy observation must not synthesize teams.current"
+    );
+    assert_eq!(first["active_team_key"], serde_json::json!("team"));
+    assert_eq!(
+        first["coordinator"]["abnormal_exit_watch"]["w1"]["last_error_observation_key"],
+        serde_json::json!("error-1")
+    );
+
+    let mut observed = first.clone();
+    observed["coordinator"]["abnormal_exit_watch"]["w1"]["last_error_observation_key"] =
+        serde_json::json!("error-2");
+    repository.commit_observations(
+        StateWriteIntent::CoordinatorTick {
+            team_key: "current",
+        },
+        &first,
+        &observed,
+    )?;
+    let second = repository.load_workspace()?;
+    assert!(
+        second.get("teams").is_none(),
+        "legacy shape must remain root-only"
+    );
+    assert_eq!(second["active_team_key"], serde_json::json!("team"));
+    assert_eq!(
+        second["coordinator"]["abnormal_exit_watch"]["w1"]["last_error_observation_key"],
+        serde_json::json!("error-2")
+    );
+
+    let mut changed_latest = second.clone();
+    changed_latest["active_team_key"] = serde_json::json!("other");
+    std::fs::write(&path, serde_json::to_vec(&changed_latest)?)?;
+    let err = repository
+        .commit_observations(
+            StateWriteIntent::CoordinatorTick {
+                team_key: "current",
+            },
+            &second,
+            &observed,
+        )
+        .expect_err("identity drift must refuse the stale legacy observation");
+    assert!(matches!(err, super::StateError::SaveConflict(_)));
+
+    std::fs::remove_dir_all(workspace)?;
+    Ok(())
+}