@team-agent/installer 0.5.80 → 0.5.82

package/Cargo.lock

@@ -581,7 +581,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.80"
+version = "0.5.82"
 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.80"
+version = "0.5.82"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/cli/status_port/brief.rs

@@ -294,24 +294,39 @@ fn display_optional(value: &Value) -> String {
 }
 
 fn registered_nodes(state: &Value, selected: Option<&str>) -> Vec<RegisteredNode> {
-    let agents = state
-        .get("agents")
-        .and_then(Value::as_object)
-        .or_else(|| {
-            let key = state.get("active_team_key").and_then(Value::as_str)?;
-            state
-                .get("teams")
-                .and_then(|teams| teams.get(key))
-                .and_then(|team| team.get("agents"))
-                .and_then(Value::as_object)
-        });
+    // A projected state can still carry stale top-level agents. Once the
+    // selector identified a canonical team entry, that entry is authoritative;
+    // an empty/missing nested roster must not fall back to the stale projection.
+    let canonical_team = state
+        .get("active_team_key")
+        .and_then(Value::as_str)
+        .and_then(|key| state.get("teams").and_then(|teams| teams.get(key)));
+    let (agents, lifecycle, defaults) = match canonical_team {
+        Some(team) => (
+            team.get("agents").and_then(Value::as_object),
+            team.get("agent_lifecycle").and_then(Value::as_object),
+            team,
+        ),
+        None => (
+            state.get("agents").and_then(Value::as_object),
+            state.get("agent_lifecycle").and_then(Value::as_object),
+            state,
+        ),
+    };
     let Some(agents) = agents else {
         return Vec::new();
     };
     agents
         .iter()
         .filter(|(name, _)| selected.is_none_or(|selected| selected == name.as_str()))
-        .map(|(name, value)| registered_node(name, value, state))
+        .filter(|(name, _)| {
+            !lifecycle
+                .and_then(|entries| entries.get(*name))
+                .and_then(|entry| entry.get("state"))
+                .and_then(Value::as_str)
+                .is_some_and(|state| state == "retired")
+        })
+        .map(|(name, value)| registered_node(name, value, defaults))
         .collect()
 }
 
@@ -803,7 +818,7 @@ fn parse_probe(bytes: &[u8], requested_endpoint: &str) -> Result<ProbeResult, ()
         .and_then(Value::as_array)
         .ok_or(())?
         .iter()
-        .filter_map(parse_probe_node)
+        .filter_map(|node| parse_probe_node(node, report_socket))
         .collect();
     Ok(ProbeResult { nodes })
 }
@@ -818,9 +833,12 @@ fn probe_has_error(value: &Value) -> bool {
     }
 }
 
-fn parse_probe_node(value: &Value) -> Option<ProbeNode> {
+fn parse_probe_node(value: &Value, report_socket: &str) -> Option<ProbeNode> {
     Some(ProbeNode {
-        socket: non_empty(value, "socket")?,
+        // The accepted producer binds the socket once at the report envelope
+        // and omits the redundant per-node field. An explicit node socket is
+        // still preserved for strict mismatch rejection below.
+        socket: non_empty(value, "socket").unwrap_or_else(|| report_socket.to_string()),
         session: non_empty(value, "session")?,
         window: non_empty(value, "window_name")?,
         pane: non_empty(value, "pane_id")?,
@@ -926,7 +944,13 @@ fn match_result<'a>(
 fn matches_registered(node: &RegisteredNode, observed: &ProbeNode) -> bool {
     node.endpoint.as_deref() == Some(observed.socket.as_str())
         && node.session.as_deref() == Some(observed.session.as_str())
-        && node.window.as_deref() == Some(observed.window.as_str())
+        // Older registrations may not persist a window. The endpoint,
+        // session, and pane tuple remains the narrow compatibility key; a
+        // present window is still an exact constraint.
+        && node
+            .window
+            .as_deref()
+            .is_none_or(|window| window == observed.window)
         && node.pane.as_deref() == Some(observed.pane.as_str())
 }
 

package/crates/team-agent/src/cli/tests/status_brief.rs

@@ -685,6 +685,205 @@ fn cmd_status_multi_endpoint_uses_total_budget() {
     let _ = std::fs::remove_dir_all(&ws);
 }
 
+#[cfg(unix)]
+#[test]
+#[serial(status_brief)]
+fn cmd_status_uses_canonical_roster_and_filters_same_team_retired_tombstones() {
+    let ws = brief_workspace("canonical-roster");
+    let mut stale = serde_json::Map::new();
+    for index in 0..220 {
+        stale.insert(
+            format!("stale-{index}"),
+            production_agent(&format!("stale-{index}"), &format!("%{index}")),
+        );
+    }
+    let mut stopped = production_agent("stopped", "%9");
+    stopped["status"] = json!("stopped");
+    let state = json!({
+        "session_name": "team-demo",
+        "tmux_endpoint": "/tmp/ta-status-brief.sock",
+        "tmux_socket": "/tmp/ta-status-brief.sock",
+        "active_team_key": "demo",
+        "agents": stale,
+        "teams": {
+            "demo": {
+                "status": "alive",
+                "session_name": "team-demo",
+                "tmux_endpoint": "/tmp/ta-status-brief.sock",
+                "agents": {
+                    "live": production_agent("live", "%7"),
+                    "retired": production_agent("retired", "%8"),
+                    "stopped": stopped
+                },
+                "agent_lifecycle": {
+                    "retired": {"state": "retired"}
+                }
+            },
+            "sibling": {
+                "status": "alive",
+                "agent_lifecycle": {"live": {"state": "retired"}}
+            }
+        }
+    });
+    write_state(&ws, &state);
+    let bin = write_nodeprobe(
+        &ws.join("probe"),
+        "printf '%s\\n' '{\"schema_version\":1,\"socket\":\"/tmp/ta-status-brief.sock\",\"nodes\":[]}'\n",
+    );
+    let nodes = status_port::with_test_nodeprobe(bin, || {
+        json_nodes(cmd_status(&status_args(&ws, true, None, Some("demo"))).expect("status"))
+    });
+    let mut names = nodes
+        .iter()
+        .filter_map(|node| node["name"].as_str())
+        .collect::<Vec<_>>();
+    names.sort_unstable();
+    assert_eq!(names, vec!["live", "stopped"]);
+    assert_eq!(
+        nodes
+            .iter()
+            .find(|node| node["name"] == "stopped")
+            .and_then(|node| node["runtime_status"].as_str()),
+        Some("stopped")
+    );
+    let err = cmd_status(&status_args(&ws, true, Some("retired"), Some("demo"))).unwrap_err();
+    assert!(err.to_string().contains("unknown agent id: retired"), "{err}");
+
+    let empty = brief_workspace("canonical-empty");
+    write_state(
+        &empty,
+        &json!({
+            "active_team_key": "demo",
+            "agents": {"stale": production_agent("stale", "%1")},
+            "teams": {
+                "demo": {
+                    "status": "alive",
+                    "agents": {},
+                    "agent_lifecycle": {}
+                }
+            }
+        }),
+    );
+    assert!(json_nodes(cmd_status(&status_args(&empty, true, None, None)).expect("status")).is_empty());
+    let _ = std::fs::remove_dir_all(&ws);
+    let _ = std::fs::remove_dir_all(&empty);
+}
+
+#[cfg(unix)]
+#[test]
+#[serial(status_brief)]
+fn cmd_status_allows_only_missing_window_compatibility_match() {
+    let ws = brief_workspace("missing-window");
+    let mut agent = production_agent("worker", "%7");
+    agent.as_object_mut().unwrap().remove("window");
+    agent.as_object_mut().unwrap().remove("layout_window");
+    agent
+        .get_mut("display")
+        .and_then(Value::as_object_mut)
+        .unwrap()
+        .remove("window");
+    write_state(
+        &ws,
+        &production_state(json!({"worker": agent})),
+    );
+    let report = producer_report(
+        "/tmp/ta-status-brief.sock",
+        "observed-window",
+        "%7",
+        "pi_activity_channel",
+    );
+    let bin = write_nodeprobe(&ws.join("probe"), &format!("cat <<'EOF'\n{report}\nEOF\n"));
+    let nodes = status_port::with_test_nodeprobe(bin, || {
+        json_nodes(cmd_status(&status_args(&ws, true, None, None)).expect("status"))
+    });
+    assert_eq!(nodes[0]["runtime_status"], "running");
+    assert_eq!(nodes[0]["activity"], "idle");
+    assert_eq!(
+        nodes[0]["tmux_command"],
+        "tmux -S '/tmp/ta-status-brief.sock' attach -t 'team-demo:observed-window.%7'"
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+
+    let conflict = brief_workspace("present-window-conflict");
+    write_state(
+        &conflict,
+        &production_state(json!({"worker": production_agent("worker", "%7")})),
+    );
+    let report = producer_report(
+        "/tmp/ta-status-brief.sock",
+        "different-window",
+        "%7",
+        "pi_activity_channel",
+    );
+    let bin = write_nodeprobe(&conflict.join("probe"), &format!("cat <<'EOF'\n{report}\nEOF\n"));
+    let nodes = status_port::with_test_nodeprobe(bin, || {
+        json_nodes(cmd_status(&status_args(&conflict, true, None, None)).expect("status"))
+    });
+    assert_eq!(nodes[0]["runtime_status"], "unknown");
+    assert!(nodes[0]["tmux_command"].is_null());
+    let _ = std::fs::remove_dir_all(&conflict);
+}
+
+#[cfg(unix)]
+#[test]
+#[serial(status_brief)]
+fn cmd_status_accepts_envelope_bound_node_socket_but_rejects_explicit_mismatch() {
+    let ws = brief_workspace("envelope-node-socket");
+    write_state(
+        &ws,
+        &production_state(json!({"worker": production_agent("worker", "%7")})),
+    );
+    let mut report: Value =
+        serde_json::from_str(&producer_report(
+            "/tmp/ta-status-brief.sock",
+            "worker",
+            "%7",
+            "pi_activity_channel",
+        ))
+        .unwrap();
+    report["nodes"][0].as_object_mut().unwrap().remove("socket");
+    let report = serde_json::to_string(&report).unwrap();
+    let bin = write_nodeprobe(&ws.join("probe"), &format!("cat <<'EOF'\n{report}\nEOF\n"));
+    let nodes = status_port::with_test_nodeprobe(bin, || {
+        json_nodes(cmd_status(&status_args(&ws, true, None, None)).expect("status"))
+    });
+    assert_eq!(nodes[0]["runtime_status"], "running");
+    assert_eq!(nodes[0]["activity"], "idle");
+    assert_eq!(nodes[0]["health"], "normal");
+    assert_eq!(nodes[0]["session_name"], "pi-session");
+    assert_eq!(
+        nodes[0]["tmux_command"],
+        "tmux -S '/tmp/ta-status-brief.sock' attach -t 'team-demo:worker.%7'"
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+
+    let mismatch = brief_workspace("explicit-node-socket-mismatch");
+    write_state(
+        &mismatch,
+        &production_state(json!({"worker": production_agent("worker", "%7")})),
+    );
+    let mut report: Value =
+        serde_json::from_str(&producer_report(
+            "/tmp/ta-status-brief.sock",
+            "worker",
+            "%7",
+            "pi_activity_channel",
+        ))
+        .unwrap();
+    report["nodes"][0]["socket"] = json!("/tmp/other.sock");
+    let report = serde_json::to_string(&report).unwrap();
+    let bin = write_nodeprobe(
+        &mismatch.join("probe"),
+        &format!("cat <<'EOF'\n{report}\nEOF\n"),
+    );
+    let nodes = status_port::with_test_nodeprobe(bin, || {
+        json_nodes(cmd_status(&status_args(&mismatch, true, None, None)).expect("status"))
+    });
+    assert_eq!(nodes[0]["runtime_status"], "unknown");
+    assert!(nodes[0]["tmux_command"].is_null());
+    let _ = std::fs::remove_dir_all(&mismatch);
+}
+
 #[cfg(unix)]
 fn pid_alive(pid: u32) -> bool {
     unsafe { libc::kill(pid as i32, 0) == 0 }

package/crates/team-agent/src/communication_mode/mod.rs

@@ -12,9 +12,9 @@ const LEADER_CENTRIC_RUNTIME_CONTRACT: &str = r#"# Team Agent communication cont
 
 - Progress, blockers, questions: {send_message}(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.
+
+"#;
 
 const ORCHESTRATED_RUNTIME_CONTRACT: &str = r#"# Team Agent communication contract: orchestrated
 

package/crates/team-agent/src/coordinator/tests/mod.rs

@@ -282,6 +282,7 @@ fn read_event_log_dir(dir: &std::path::Path) -> Vec<serde_json::Value> {
 }
 
 mod a0_lostupdate;
+mod s3_bounded;
 mod abnormal;
 mod api_error_recovery;
 mod basics;

package/crates/team-agent/src/coordinator/tests/s3_bounded.rs

@@ -0,0 +1,239 @@
+use super::*;
+use serde_json::json;
+use std::io::{BufRead, Write};
+use std::path::{Path, PathBuf};
+use std::process::{Child, Command, Stdio};
+use crate::state::repository::{StateRepository, StateWriteIntent};
+
+const WORKER: &str = "coordinator::tests::s3_bounded::s3_process_worker";
+
+fn isolated(name: &str, check: impl FnOnce(&Path)) {
+    if std::env::var("TA_S3_CASE").as_deref() == Ok(name) {
+        check(&std::env::current_dir().unwrap());
+        return;
+    }
+    let dir = std::env::temp_dir().join(format!("ta-s3-{name}-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let output = Command::new(std::env::current_exe().unwrap())
+        .args(["--exact", &format!("coordinator::tests::s3_bounded::{name}"), "--nocapture"])
+        .env_clear().env("HOME", dir.join("home")).env("TA_S3_CASE", name)
+        .current_dir(&dir).output().unwrap();
+    print!("{}", String::from_utf8_lossy(&output.stdout));
+    assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
+    std::fs::remove_dir_all(dir).unwrap();
+}
+
+fn disk(dir: &Path) -> Value {
+    serde_json::from_str(&std::fs::read_to_string(crate::state::persist::runtime_state_path(dir)).unwrap()).unwrap()
+}
+
+fn seed(dir: &Path, legacy: bool) {
+    std::fs::create_dir_all(dir).unwrap();
+    let team = |key: &str| {
+        let spec = dir.join(".team/runtime").join(key).join("team.spec.yaml");
+        std::fs::create_dir_all(spec.parent().unwrap()).unwrap();
+        std::fs::write(&spec, format!("name: {key}\nagents: []\ntasks: []\n")).unwrap();
+        json!({
+            "session_name": key, "team_dir": dir.join(".team").join(key), "spec_path": spec,
+            "agents": {"w1": {"agent_id": "w1", "provider": "fake", "status": "running",
+                "window": "w1", "pane_id": "%11", "spawn_epoch": 1,
+                "session_id": "fixture-session", "startup_prompts": "handled"}},
+            "tasks": [{"id": "original", "title": "Original task", "assignee": "w1", "status": "pending"}],
+            "notes": ["original note"]
+        })
+    };
+    let mut state = team("T1");
+    state["active_team_key"] = json!("T1");
+    if !legacy { state["teams"] = json!({"T1": state.clone(), "T2": team("T2")}); }
+    crate::state::persist::save_runtime_state(dir, &state).unwrap();
+    MessageStore::open(dir).unwrap();
+    std::fs::write(dir.join("result.json"), json!({
+        "schema_version": "result_envelope_v1", "result_id": "result-original",
+        "task_id": "original", "agent_id": "w1", "status": "success", "summary": "done",
+        "artifacts": [], "changes": [], "tests": [], "risks": [], "next_actions": []
+    }).to_string()).unwrap();
+}
+
+fn task(id: &str) -> Value { json!({"id": id, "title": id, "assignee": "w1"}) }
+
+fn start_writer(dir: &Path, action: &str, team: Option<&str>, payload: Value, pause: bool) -> Child {
+    let mut child = Command::new(std::env::current_exe().unwrap())
+        .args(["--exact", WORKER, "--ignored", "--nocapture"])
+        .env_clear().env("HOME", dir.join("home"))
+        .env("TA_S3_ACTION", action).env("TA_S3_TEAM", team.unwrap_or(""))
+        .env("TA_S3_PAYLOAD", payload.to_string()).env("TA_S3_PAUSE", if pause { "1" } else { "0" })
+        .current_dir(dir).stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped())
+        .spawn().unwrap();
+    if pause {
+        let mut reader = std::io::BufReader::new(child.stdout.take().unwrap());
+        loop {
+            let mut line = String::new();
+            assert!(reader.read_line(&mut line).unwrap() > 0, "writer exited before barrier");
+            print!("{line}");
+            if line.contains("S3_READY") { break; }
+        }
+        child.stdout = Some(reader.into_inner());
+    }
+    child
+}
+
+fn finish(mut child: Child, paused: bool) {
+    if paused { child.stdin.take().unwrap().write_all(b"commit\n").unwrap(); }
+    let output = child.wait_with_output().unwrap();
+    print!("{}", String::from_utf8_lossy(&output.stdout));
+    assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
+}
+
+fn write(dir: &Path, action: &str, team: Option<&str>, payload: Value) {
+    finish(start_writer(dir, action, team, payload, false), false);
+}
+
+#[test]
+#[ignore = "hermetic subprocess entry; parent contracts invoke this exact test"]
+fn s3_process_worker() {
+    let dir = std::env::current_dir().unwrap();
+    let action = std::env::var("TA_S3_ACTION").unwrap();
+    let team = std::env::var("TA_S3_TEAM").unwrap();
+    let team = (!team.is_empty()).then_some(team.as_str());
+    let payload: Value = serde_json::from_str(&std::env::var("TA_S3_PAYLOAD").unwrap()).unwrap();
+    if std::env::var("TA_S3_PAUSE").as_deref() == Ok("1") {
+        crate::state::repository::test_support::set_before_commit(|| {
+            println!("S3_READY");
+            std::io::stdout().flush().unwrap();
+            let mut line = String::new();
+            std::io::stdin().read_line(&mut line).unwrap();
+            assert_eq!(line.trim(), "commit");
+        });
+    }
+    let tools = crate::mcp_server::TeamOrchestratorTools::with_identity(
+        &dir, Some(crate::model::ids::AgentId::new("leader")), team.map(crate::model::ids::TeamKey::new),
+    );
+    match action.as_str() {
+        "assign" => { tools.assign_task(&payload, Some("bounded contract")).unwrap(); }
+        "note" => { println!("S3 note={:?}", tools.update_state(payload.as_str().unwrap()).unwrap()); }
+        "collect" => {
+            let output = crate::messaging::results::collect_for_team(&dir, Some(&dir.join("result.json")), false, team).unwrap();
+            assert_eq!(output["ok"], true);
+            println!("S3 collect={output}");
+        }
+        "sibling" => {
+            let mut state = StateRepository::new(&dir).load_workspace().unwrap();
+            state["teams"]["T3"] = json!({"session_name": "T3", "tasks": [task("third")], "notes": ["third"]});
+            StateRepository::new(&dir).save(StateWriteIntent::LaunchTeam { team_key: "T3" }, &state).unwrap();
+        }
+        "topology" => {
+            let mut state = StateRepository::new(&dir).load_team(Some("T1")).unwrap();
+            state["agents"]["w1"]["pane_id"] = json!("%22");
+            state["agents"]["w1"]["spawn_epoch"] = json!(2);
+            // A concurrent restart owns topology for this agent. StartAgent's
+            // add-only tail intentionally carries no existing-agent authority.
+            StateRepository::new(&dir).save(StateWriteIntent::RestartTeam {
+                team_key: "T1", topology_authority_agent_ids: &["w1"],
+                skip_capture_backfill_agent_ids: &[],
+            }, &state).unwrap();
+            assert_eq!(disk(&dir)["teams"]["T1"]["agents"]["w1"]["pane_id"], "%22");
+        }
+        _ => panic!("unexpected test action"),
+    }
+    println!("S3_COMMITTED {action}");
+}
+
+fn coordinator(dir: &Path, hook: SaveHook) -> Coordinator {
+    let transport = OfflineTransport::new().with_session_present(true)
+        .with_windows(vec![WindowName::new("live-peer")]);
+    Coordinator::for_test(WorkspacePath::new(dir.to_path_buf()),
+        Box::new(MockRegistry::new(&[], &[])), Box::new(transport), None, None)
+        .with_before_save_hook(hook)
+}
+
+#[test]
+fn s3_tick_preserves_tasks_notes_and_siblings() {
+    isolated("s3_tick_preserves_tasks_notes_and_siblings", |dir| {
+        seed(dir, false);
+        let hook: SaveHook = Box::new(|ws, observed| {
+            assert_eq!(observed["agents"]["w1"]["worker_state"], "DEAD", "tick must produce a real observation delta");
+            write(ws.as_path(), "assign", Some("T1"), task("new-task"));
+            write(ws.as_path(), "note", Some("T1"), json!("concurrent note"));
+            write(ws.as_path(), "collect", Some("T1"), Value::Null);
+            write(ws.as_path(), "note", Some("T2"), json!("sibling note"));
+            write(ws.as_path(), "sibling", None, Value::Null);
+            let latest = disk(ws.as_path());
+            assert_eq!(latest["teams"]["T1"]["agents"]["w1"]["pane_id"], observed["agents"]["w1"]["pane_id"]);
+            println!("S3 before tick save topology unchanged; committed business={}", latest["teams"]);
+            Ok(())
+        });
+        let report = coordinator(dir, hook).tick().unwrap();
+        assert!(report.ok, "tick must save its observation: {report:?}");
+        let state = disk(dir);
+        let team = &state["teams"]["T1"];
+        assert_eq!(team["tasks"][0]["accepted_result_id"], "result-original");
+        assert!(team["tasks"].as_array().unwrap().iter().any(|row| row["id"] == "new-task"));
+        assert_eq!(team["notes"], json!(["original note", "concurrent note"]));
+        assert_eq!(team["agents"]["w1"]["worker_state"], "DEAD");
+        assert_eq!(state["teams"]["T2"]["notes"], json!(["original note", "sibling note"]));
+        assert_eq!(state["teams"]["T3"]["notes"], json!(["third"]));
+        assert_eq!(state["tasks"], team["tasks"]);
+        assert_eq!(StateRepository::new(dir).load_team(Some("T1")).unwrap()["tasks"], team["tasks"]);
+        println!("S3 after tick save={state}");
+    });
+}
+
+#[test]
+fn s3_business_writers_commit_once_on_latest() {
+    isolated("s3_business_writers_commit_once_on_latest", |root| {
+        for (i, (left, right)) in [
+            (("assign", task("left")), ("assign", task("right"))),
+            (("note", json!("same note")), ("note", json!("same note"))),
+            (("note", json!("same note")), ("assign", task("right"))),
+            (("collect", Value::Null), ("assign", task("right"))),
+            (("collect", Value::Null), ("note", json!("same note"))),
+        ].into_iter().enumerate() {
+            let dir = root.join(i.to_string());
+            seed(&dir, false);
+            let waiting = start_writer(&dir, left.0, Some("T1"), left.1, true);
+            write(&dir, right.0, Some("T1"), right.1);
+            finish(waiting, true);
+            let state = disk(&dir);
+            let team = &state["teams"]["T1"];
+            if left.0 == "assign" { assert!(team["tasks"].as_array().unwrap().iter().any(|task| task["id"] == "left")); }
+            if right.0 == "assign" { assert!(team["tasks"].as_array().unwrap().iter().any(|task| task["id"] == "right")); }
+            if left.0 == "collect" { assert_eq!(team["tasks"][0]["accepted_result_id"], "result-original"); }
+            let notes = usize::from(left.0 == "note") + usize::from(right.0 == "note");
+            assert_eq!(team["notes"].as_array().unwrap().len(), 1 + notes);
+            if left.0 == "note" && right.0 == "assign" {
+                let markdown = std::fs::read_to_string(dir.join(".team/runtime/T1/team_state.md")).unwrap();
+                assert!(markdown.contains("right"), "note must render the committed task view: {markdown}");
+            }
+            if left.0 == "collect" {
+                write(&dir, "assign", Some("T1"), json!({"id": "original", "assignee": "w1", "title": "edited"}));
+                assert_eq!(disk(&dir)["teams"]["T1"]["tasks"][0]["accepted_result_id"], "result-original");
+            }
+            println!("S3 pair {i} canonical={team}");
+        }
+    });
+}
+
+#[test]
+fn s3_legacy_note_and_collection_keep_independent_updates() {
+    isolated("s3_legacy_note_and_collection_keep_independent_updates", |dir| {
+        seed(dir, true);
+        let waiting = start_writer(dir, "collect", None, Value::Null, true);
+        write(dir, "note", None, json!("legacy note"));
+        finish(waiting, true);
+        let state = disk(dir);
+        assert_eq!(state["tasks"][0]["accepted_result_id"], "result-original");
+        assert_eq!(state["notes"], json!(["original note", "legacy note"]));
+        assert!(state.get("teams").is_none(), "legacy single Team shape remains valid");
+    });
+}
+
+#[test]
+fn s3_observation_keeps_live_topology_conflict() {
+    isolated("s3_observation_keeps_live_topology_conflict", |dir| {
+        seed(dir, false);
+        let hook: SaveHook = Box::new(|ws, _| { write(ws.as_path(), "topology", Some("T1"), Value::Null); Ok(()) });
+        let report = coordinator(dir, hook).tick().unwrap();
+        assert_eq!(report.reason, Some(TickStopReason::PersistenceDegraded));
+        assert_eq!(disk(dir)["teams"]["T1"]["agents"]["w1"]["pane_id"], "%22");
+    });
+}

package/crates/team-agent/src/coordinator/tick.rs

@@ -193,6 +193,8 @@ pub struct Coordinator {
     /// bug-084 save 注入钩。`None` ⇔ 真实 `state::save_runtime_state`。
     #[allow(dead_code)]
     save_hook: Option<SaveHook>,
+    #[cfg(test)]
+    before_save_hook: Option<SaveHook>,
     /// tick 副作用 ORDER 探针。`None` ⇔ 不记录(生产)。
     #[allow(dead_code)]
     order_recorder: Option<OrderRecorder>,
@@ -219,6 +221,8 @@ impl Coordinator {
             transport,
             daemon_team_key: None,
             save_hook: None,
+            #[cfg(test)]
+            before_save_hook: None,
             order_recorder: None,
         }
     }
@@ -263,10 +267,18 @@ impl Coordinator {
             transport,
             daemon_team_key: None,
             save_hook,
+            before_save_hook: None,
             order_recorder,
         }
     }
 
+    /// A test barrier before the real repository save; never replaces the save.
+    #[cfg(test)]
+    pub(crate) fn with_before_save_hook(mut self, hook: SaveHook) -> Self {
+        self.before_save_hook = Some(hook);
+        self
+    }
+
     // ── tick 编排(lifecycle.py:250-385)──────────────────────────────────────
 
     /// 单次 tick(`coordinator_tick`,`lifecycle.py:250`)。固定顺序串 step 8-11 原子:
@@ -308,6 +320,7 @@ impl Coordinator {
             self.daemon_team_key.as_deref(),
         )
         .unwrap_or(raw_state);
+        let before_observation = state.clone();
         let store = crate::message_store::MessageStore::open(self.workspace.as_path())?;
         let event_log = EventLog::new(self.workspace.as_path());
         increment_coordinator_tick_iteration_count(&self.workspace);
@@ -487,26 +500,21 @@ impl Coordinator {
         };
 
         self.record_step(TickStepGroup::Persist, "atomic_save");
+        #[cfg(test)]
+        if let Some(hook) = &self.before_save_hook {
+            hook(&self.workspace, &state)?;
+        }
         let saved = match &self.save_hook {
             Some(hook) => hook(&self.workspace, &state),
             None => {
-                // 0.5.42 S1b (s1b-writer-cluster-locate.md §3.2 /
-                // §4.4): the daemon tick's single terminal save
-                // routes through `StateRepository` with the
-                // `CoordinatorTick` intent. Repository dispatch is
-                // byte-identical to the old `save_team_scoped_state`
-                // helper (see `state/repository.rs:CoordinatorTick =>
-                // helper_write_team_scoped`), so persist/merge/lock/
-                // atomic-rename semantics and degraded-mapping stay
-                // unchanged. No cached repository, no extra load, no
-                // retry — the caller still owns the `Value` and
-                // failure still returns `TickReport{PersistenceDegraded}`
-                // via the `saved.is_err()` branch below.
+                // Keep the sampled topology guard, but commit only this tick's
+                // observations onto latest so task/note writers cannot be lost.
                 let team_key = crate::state::projection::team_state_key(&state);
-                crate::state::repository::StateRepository::new(self.workspace.as_path()).save(
+                crate::state::repository::StateRepository::new(self.workspace.as_path()).commit_observations(
                     crate::state::repository::StateWriteIntent::CoordinatorTick {
                         team_key: team_key.as_str(),
                     },
+                    &before_observation,
                     &state,
                 )
             }