@team-agent/installer 0.5.80 → 0.5.81

package/Cargo.lock

@@ -581,7 +581,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.80"
+version = "0.5.81"
 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.81"
 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/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,
                 )
             }

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

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

@@ -1,5 +1,7 @@
 //!
-//! StateRepository facade.
+//! StateRepository facade. Task/note commits apply bounded mutations under the
+//! existing state-save lock; coordinator commits carry only observation deltas.
+//! Other writer clusters retain their legacy dispatch below.
 //!
 //! Ref:
 //! - `.team/artifacts/s1a-state-repository-design.md` (skeleton)
@@ -142,8 +144,152 @@ impl<'a> StateRepository<'a> {
     where
         F: FnOnce(&mut Value),
     {
+        #[cfg(test)]
+        test_support::before_commit();
         route_reapply(self.workspace, intent, state, reapply)
     }
+
+    /// Commit a task/note delta once against latest under state-save. Return
+    /// the committed Team view for callers that produce Markdown afterwards.
+    pub fn commit<F>(&self, intent: StateWriteIntent<'_>, update: F) -> Result<Value, StateError>
+    where
+        F: FnOnce(&mut Value),
+    {
+        #[cfg(test)]
+        test_support::before_commit();
+        let team_key = match intent {
+            // Assignment's existing reconcile helper updates the root task
+            // array and the explicit Team array independently (legacy parity).
+            StateWriteIntent::McpAssignTask { .. } => None,
+            StateWriteIntent::McpUpdateStateNote { team_key } => team_key,
+            StateWriteIntent::ResultCollection { owner_team_id } => owner_team_id,
+            _ => return Err(StateError::SaveFailed("intent does not accept a task/note delta".into())),
+        };
+        let committed = super::persist::update_runtime_state(self.workspace, |latest| {
+            let mut selected = bounded_team_view(latest, team_key)?;
+            update(&mut selected);
+            Ok(match team_key {
+                Some(key) => super::projection::merge_committed_team(latest, &selected, key),
+                None => selected,
+            })
+        })?;
+        bounded_team_view(&committed, team_key)
+    }
+
+    /// Fence the sampled incarnation with the existing persist guards, then
+    /// commit only this tick's agent observations and coordinator bookkeeping.
+    pub fn commit_observations(
+        &self,
+        intent: StateWriteIntent<'_>,
+        before: &Value,
+        observed: &Value,
+    ) -> Result<(), StateError> {
+        let StateWriteIntent::CoordinatorTick { team_key } = intent else {
+            return Err(StateError::SaveFailed("intent does not accept observations".into()));
+        };
+        let sampled_legacy =
+            legacy_single_team_state(before) && legacy_single_team_state(observed);
+        let sampled_identity = legacy_team_identity(before);
+        super::persist::update_runtime_state(self.workspace, |latest| {
+            if sampled_legacy {
+                if sampled_identity != legacy_team_identity(observed)
+                    || !legacy_single_team_state(latest)
+                    || sampled_identity != legacy_team_identity(latest)
+                {
+                    return Err(StateError::SaveConflict(
+                        "legacy coordinator observation scope changed before commit".to_string(),
+                    ));
+                }
+                let mut checked = observed.clone();
+                super::persist::merge_ordinary_state(&mut checked, latest)?;
+                if !legacy_single_team_state(&checked)
+                    || sampled_identity != legacy_team_identity(&checked)
+                {
+                    return Err(StateError::SaveConflict(
+                        "legacy coordinator observation scope changed during validation"
+                            .to_string(),
+                    ));
+                }
+                let mut selected = latest.clone();
+                for field in ["agents", "coordinator"] {
+                    if before[field] != checked[field] {
+                        apply_observation_delta(
+                            &before[field],
+                            &checked[field],
+                            &mut selected[field],
+                        );
+                    }
+                }
+                return Ok(selected);
+            }
+            let mut checked = super::projection::merge_committed_team(latest, observed, team_key);
+            super::persist::merge_ordinary_state(&mut checked, latest)?;
+            let checked = bounded_team_view(&checked, Some(team_key))?;
+            let mut selected = bounded_team_view(latest, Some(team_key))?;
+            for field in ["agents", "coordinator"] {
+                if before[field] != checked[field] {
+                    apply_observation_delta(&before[field], &checked[field], &mut selected[field]);
+                }
+            }
+            Ok(super::projection::merge_committed_team(latest, &selected, team_key))
+        })?;
+        Ok(())
+    }
+}
+
+fn legacy_single_team_state(state: &Value) -> bool {
+    match state.get("teams") {
+        None => true,
+        Some(Value::Object(teams)) => teams.is_empty(),
+        Some(_) => false,
+    }
+}
+
+fn legacy_team_identity(state: &Value) -> [Option<String>; 5] {
+    [
+        "active_team_key",
+        "team_key",
+        "session_name",
+        "team_dir",
+        "spec_path",
+    ]
+    .map(|field| {
+        state
+            .get(field)
+            .and_then(Value::as_str)
+            .filter(|value| !value.is_empty())
+            .map(str::to_string)
+    })
+}
+
+fn bounded_team_view(state: &Value, team_key: Option<&str>) -> Result<Value, StateError> {
+    let Some(key) = team_key else { return Ok(state.clone()); };
+    if state.get("teams").and_then(Value::as_object).is_some_and(|teams| teams.contains_key(key)) {
+        return Ok(super::projection::project_top_level_view(state, key));
+    }
+    if state.get("teams").and_then(Value::as_object).is_some_and(|teams| !teams.is_empty()) {
+        return Err(StateError::TeamSelect(format!("team no longer exists: {key}")));
+    }
+    Ok(state.clone())
+}
+
+// Diffing is limited to the two observation blocks above, never a whole-state
+// merge. Equal fields retain a concurrent writer's value; removed fields clear.
+fn apply_observation_delta(before: &Value, observed: &Value, latest: &mut Value) {
+    if before == observed { return; }
+    if let Some(observed) = observed.as_object() {
+        if !latest.is_object() { *latest = serde_json::json!({}); }
+        if let Some(before) = before.as_object() {
+            for key in before.keys().filter(|key| !observed.contains_key(*key)) {
+                if let Some(latest) = latest.as_object_mut() { latest.remove(key); }
+            }
+        }
+        for (key, value) in observed {
+            apply_observation_delta(&before[key], value, &mut latest[key]);
+        }
+    } else {
+        *latest = observed.clone();
+    }
 }
 
 /// Closed semantic catalog of workspace state writes. Every allowlisted
@@ -555,6 +701,11 @@ fn route_reapply<F>(
 where
     F: FnOnce(&mut Value),
 {
+    if matches!(&intent, StateWriteIntent::McpAssignTask { .. }
+        | StateWriteIntent::McpUpdateStateNote { .. } | StateWriteIntent::ResultCollection { .. })
+    {
+        return StateRepository::new(workspace).commit(intent, reapply).map(|_| ());
+    }
     if reapply_scope(&intent) == ReapplyScope::Team {
         helper_write_team_scoped_reapply(workspace, state, reapply)
     } else {
@@ -564,3 +715,20 @@ where
 
 #[cfg(test)]
 mod tests;
+
+#[cfg(test)]
+pub(crate) mod test_support {
+    thread_local! {
+        static BEFORE_COMMIT: std::cell::RefCell<Option<Box<dyn FnOnce()>>> = const {
+            std::cell::RefCell::new(None)
+        };
+    }
+
+    pub(crate) fn set_before_commit(hook: impl FnOnce() + 'static) {
+        BEFORE_COMMIT.with(|slot| *slot.borrow_mut() = Some(Box::new(hook)));
+    }
+
+    pub(super) fn before_commit() {
+        if let Some(hook) = BEFORE_COMMIT.with(|slot| slot.borrow_mut().take()) { hook(); }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.80",
+  "version": "0.5.81",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.5.80",
-    "@team-agent/cli-darwin-x64": "0.5.80",
-    "@team-agent/cli-linux-x64": "0.5.80"
+    "@team-agent/cli-darwin-arm64": "0.5.81",
+    "@team-agent/cli-darwin-x64": "0.5.81",
+    "@team-agent/cli-linux-x64": "0.5.81"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",