@team-agent/installer 0.5.111 → 0.5.112

package/crates/team-agent/src/messaging/tests/runtime.rs

@@ -1090,52 +1090,6 @@ fn collect_rejects_message_scoped_result_without_matching_recipient() {
     );
 }
 
-#[test]
-fn allow_peer_talk_records_bidirectional_allowlist_and_event() {
-    let ws = tmp_ws("allowpeer");
-    let out = allow_peer_talk(&ws, "alice", "bob").unwrap();
-    assert_eq!(out.get("ok").and_then(|v| v.as_bool()), Some(true));
-    assert_eq!(out.get("a").and_then(|v| v.as_str()), Some("alice"));
-    assert_eq!(out.get("b").and_then(|v| v.as_str()), Some("bob"));
-    assert_eq!(
-        out.get("status").and_then(|v| v.as_str()),
-        Some("compat_noop")
-    );
-    assert_eq!(
-        out.get("reason").and_then(|v| v.as_str()),
-        Some("team_scoped_peer_messages_enabled")
-    );
-
-    let store = store_for(&ws);
-    let conn = seed_conn(&store);
-    let rows = conn
-        .prepare("select a, b from peer_allowlist order by a, b")
-        .unwrap()
-        .query_map([], |row| {
-            Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
-        })
-        .unwrap()
-        .collect::<Result<Vec<_>, _>>()
-        .unwrap();
-    assert_eq!(
-        rows,
-        vec![
-            ("alice".to_string(), "bob".to_string()),
-            ("bob".to_string(), "alice".to_string()),
-        ]
-    );
-
-    let events = EventLog::new(&ws).tail(10).unwrap();
-    let event = events
-        .iter()
-        .find(|event| {
-            event.get("event").and_then(|v| v.as_str()) == Some("communication.peer_allowed")
-        })
-        .expect("communication.peer_allowed event");
-    assert_eq!(event.get("a").and_then(|v| v.as_str()), Some("alice"));
-    assert_eq!(event.get("b").and_then(|v| v.as_str()), Some("bob"));
-}
-
 // ════════════════════════════════════════════════════════════════════════
 // GROUP R — run_comms_selftest: §84 / MUST-NOT-13 zero-provider-SDK gate.
 // diagnose/comms.py:21-47. The whole point: assert zero provider client calls.

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

@@ -527,7 +527,6 @@ pub enum StateWriteIntent<'a> {
     TaskRepair {
         team_key: Option<&'a str>,
     },
-    FakeE2eSeed,
     SelfMigration,
 }
 
@@ -743,10 +742,7 @@ fn route_direct(
         },
         // TaskRepair -> `save_team_scoped_state` (cli/adapters.rs:675).
         StateWriteIntent::TaskRepair { .. } => helper_write_team_scoped(workspace, state),
-        // FakeE2eSeed / SelfMigration are diagnostic seams. The current
-        // callsites live at cli/adapters.rs:1035/1070 and
-        // state/persist.rs:1127; S1a routes them to the root helper.
-        StateWriteIntent::FakeE2eSeed => helper_write_root(workspace, state),
+        // SelfMigration persists through the root helper.
         StateWriteIntent::SelfMigration => helper_write_root(workspace, state),
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.111",
+  "version": "0.5.112",
   "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.111",
-    "@team-agent/cli-darwin-x64": "0.5.111",
-    "@team-agent/cli-linux-x64": "0.5.111"
+    "@team-agent/cli-darwin-arm64": "0.5.112",
+    "@team-agent/cli-darwin-x64": "0.5.112",
+    "@team-agent/cli-linux-x64": "0.5.112"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",

package/templates/team_state.md

@@ -29,4 +29,4 @@ Pending.
 
 ## Next Step
 
-- Run `team-agent validate team.spec.yaml`, review permissions, then run `team-agent launch team.spec.yaml --yes`.
+- Review role files and permissions, then run `team-agent quick-start`; use `team-agent doctor` to diagnose the team.

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

@@ -1,164 +0,0 @@
-use super::*;
-
-// =============================================================================
-// P0-1 LANE — `allow-peer-talk` byte-lock (was ZERO-test; a SHIPPED compat-noop).
-//
-// golden: cli/commands.py:422 -> messaging/leader.py:25 allow_peer_talk(ws,a,b)
-//   -> message_store/core.py:326 allow_peer (INSERT OR IGNORE BOTH (a,b) & (b,a))
-//   + events.py:27-35 EventLog.write (sort_keys=True -> .team/logs/events.jsonl).
-//
-// Golden bytes captured live (PYTHONPATH=.../src python3 /tmp/probe_app*.py):
-//   return (insertion order):  {"ok":true,"a":..,"b":..,"status":"compat_noop",
-//                               "reason":"team_scoped_peer_messages_enabled"}
-//   return (--json sort_keys):  keys a,b,ok,reason,status
-//   event line (sort_keys):     {"a":..,"b":..,"event":"communication.peer_allowed","ts":..}
-//   idempotent:                 2nd call -> identical return + a SECOND event line
-//                               (event fires per-call; DB rows are insert-or-ignore)
-//   unknown/undeclared agents:  NO validation -> ok:true compat_noop, exit 0
-//
-// Rust impl: messaging/peers.rs:11 + message_store.rs:251 + adapters.rs:173.
-// serde_json `preserve_order` is ON (Cargo.toml:24) so the default (human) output
-// iterates dict keys in golden insertion order. These tests LOCK the contract so a
-// porter/refactor cannot silently drift this live verb.
-// =============================================================================
-
-fn app_out(r: CmdResult) -> serde_json::Value {
-    match r.output {
-        CmdOutput::Json(v) => v,
-        _ => panic!("allow-peer-talk must emit a Json CmdOutput"),
-    }
-}
-
-fn app_events(ws: &std::path::Path) -> Vec<String> {
-    std::fs::read_to_string(ws.join(".team").join("logs").join("events.jsonl"))
-        .unwrap_or_default()
-        .lines()
-        .map(str::to_string)
-        .collect()
-}
-
-fn app_call(ws: &std::path::Path, a: &str, b: &str) -> CmdResult {
-    cmd_allow_peer_talk(&AllowPeerTalkArgs {
-        a: a.to_string(),
-        b: b.to_string(),
-        workspace: ws.to_path_buf(),
-        json: false,
-        team: None,
-    })
-    .expect("allow-peer-talk is a compat-noop and must not error")
-}
-
-// ── return dict: exact compat_noop shape + golden insertion order (drives human emit) ──
-#[test]
-fn allow_peer_talk_output_byte_locks_golden_compat_noop() {
-    let ws = tmp_workspace();
-    let v = app_out(app_call(&ws, "alpha", "bravo"));
-    assert_eq!(
-        v,
-        json!({
-            "ok": true,
-            "a": "alpha",
-            "b": "bravo",
-            "status": "compat_noop",
-            "reason": "team_scoped_peer_messages_enabled"
-        }),
-        "golden leader.py:28 return dict (key set + values); got {v:?}"
-    );
-    let order: Vec<&str> = v
-        .as_object()
-        .expect("object")
-        .keys()
-        .map(String::as_str)
-        .collect();
-    assert_eq!(
-        order,
-        vec!["ok", "a", "b", "status", "reason"],
-        "golden dict insertion order ok,a,b,status,reason drives the default human emit key order \
-         (helpers.py:16-19); got {order:?}"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-// ── event: exactly one `communication.peer_allowed` line, sort_keys byte form, payload {a,b} ──
-#[test]
-fn allow_peer_talk_event_byte_locks_golden_line() {
-    let ws = tmp_workspace();
-    let _ = app_call(&ws, "alpha", "bravo");
-    let lines = app_events(&ws);
-    assert_eq!(lines.len(), 1, "exactly one event per call; got {lines:?}");
-    let v: serde_json::Value = serde_json::from_str(&lines[0]).expect("event line must be json");
-    let ts = v["ts"].as_str().expect("event has string ts").to_string();
-    let expected = format!(
-        "{{\"a\": \"alpha\", \"b\": \"bravo\", \"event\": \"communication.peer_allowed\", \"ts\": \"{ts}\"}}"
-    );
-    assert_eq!(
-        lines[0], expected,
-        "golden events.py:35 json.dumps(...,sort_keys=True) line: sorted keys a,b,event,ts with \
-         Python `, `/`: ` spacing; got {}",
-        lines[0]
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-// ── idempotency: identical return, event fires on EVERY call (rows are insert-or-ignore) ──
-#[test]
-fn allow_peer_talk_is_idempotent_and_fires_event_per_call() {
-    let ws = tmp_workspace();
-    let v1 = app_out(app_call(&ws, "alpha", "bravo"));
-    let v2 = app_out(app_call(&ws, "alpha", "bravo")); // duplicate pair
-    assert_eq!(
-        v1, v2,
-        "repeated allow returns identical compat_noop output"
-    );
-    let lines = app_events(&ws);
-    assert_eq!(
-        lines.len(),
-        2,
-        "golden fires communication.peer_allowed on EVERY call (event NOT deduped; only DB rows \
-         are insert-or-ignore); got {lines:?}"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-// ── permissive: undeclared/unknown agents still succeed (golden has NO validation path) ──
-#[test]
-fn allow_peer_talk_unknown_agents_succeed_no_validation() {
-    let ws = tmp_workspace(); // no state.json / no spec: agents never declared
-    let r = app_call(&ws, "ghost", "phantom-x");
-    assert_eq!(
-        r.exit,
-        ExitCode::Ok,
-        "golden leader.py:25-28 never validates agent ids -> no error, exit 0"
-    );
-    let v = app_out(r);
-    assert_eq!(
-        v,
-        json!({
-            "ok": true,
-            "a": "ghost",
-            "b": "phantom-x",
-            "status": "compat_noop",
-            "reason": "team_scoped_peer_messages_enabled"
-        }),
-        "unknown agents still get compat_noop (no unknown-agent error string/exit); got {v:?}"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-#[test]
-fn allow_peer_talk_explicit_team_is_rejected_until_backend_is_scoped() {
-    let ws = tmp_workspace();
-    let err = cmd_allow_peer_talk(&AllowPeerTalkArgs {
-        a: "alpha".to_string(),
-        b: "bravo".to_string(),
-        workspace: ws.clone(),
-        json: true,
-        team: Some("current".to_string()),
-    })
-    .expect_err("explicit --team must not silently write the global peer allowlist");
-    assert!(
-        err.to_string().contains("not supported yet"),
-        "allow-peer-talk --team must be an explicit refusal until backend supports scoped writes; got {err}"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}

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

@@ -1,195 +0,0 @@
-use super::*;
-
-const VALIDATE_SPEC_TEMPLATE: &str = r#"version: 1
-team:
-  name: "fake-e2e"
-  mode: "supervisor_worker"
-  objective: "Exercise validate."
-  workspace: "__WS__"
-leader:
-  id: "leader"
-  role: "leader"
-  provider: "fake"
-  model: null
-  tools:
-    - "fs_read"
-    - "fs_list"
-    - "mcp_team"
-  context_policy:
-    keep_user_thread: true
-    receive_worker_outputs: "structured_only"
-    max_worker_result_tokens: 2000
-agents:
-  - id: "fake_impl"
-    role: "implementation_engineer"
-    provider: "fake"
-    model: null
-    working_directory: "__WS__"
-    system_prompt:
-      inline: "Handle fake implementation tasks."
-      file: null
-    tools:
-      - "fs_read"
-      - "fs_write"
-      - "fs_list"
-      - "execute_bash"
-      - "git_diff"
-      - "mcp_team"
-      - "provider_builtin"
-    dangerously_skip_permissions: false
-    preferred_for:
-      - "implementation"
-    avoid_for: []
-    output_contract:
-      format: "result_envelope_v1"
-      required_fields:
-        - "task_id"
-        - "status"
-        - "summary"
-        - "artifacts"
-routing:
-  default_assignee: "leader"
-  rules:
-    - id: "implementation-to-fake"
-      match:
-        type:
-          - "implementation"
-      assign_to: "fake_impl"
-      priority: 10
-communication:
-  protocol: "mcp_inbox"
-  topology: "leader_centered"
-  worker_to_worker: true
-  ack_timeout_sec: 2
-  result_format: "result_envelope_v1"
-  message_store:
-    sqlite: ".team/runtime/team.db"
-    mirror_files: ".team/messages"
-runtime:
-  backend: "tmux"
-  session_name: "team-agent-fake-e2e"
-  auto_launch: true
-  require_user_approval_before_launch: false
-  max_active_agents: 1
-  startup_order:
-    - "fake_impl"
-context:
-  state_file: "team_state.md"
-  artifact_dir: ".team/artifacts"
-  log_dir: ".team/logs"
-  summarization:
-    worker_full_logs: "retain_outside_leader_context"
-    state_update: "after_each_result"
-tasks:
-  - id: "task_impl"
-    title: "Fake implementation"
-    type: "implementation"
-    assignee: null
-    deps: []
-    acceptance:
-      - "fake result collected"
-    status: "pending"
-"#;
-
-fn write_validate_spec(
-    ws: &std::path::Path,
-    file_name: &str,
-    provider: &str,
-) -> std::path::PathBuf {
-    let spec = VALIDATE_SPEC_TEMPLATE
-        .replace("__WS__", &ws.to_string_lossy())
-        .replacen(
-            "provider: \"fake\"",
-            &format!("provider: \"{provider}\""),
-            1,
-        );
-    let path = ws.join(file_name);
-    std::fs::write(&path, spec).unwrap();
-    path
-}
-
-// Golden source:
-// - cli/parser.py:120-123 registers `validate [spec=team.spec.yaml] --json`.
-// - cli/commands.py:38-39 delegates to `runtime.validate_file(Path(args.spec).resolve())`.
-// - launch/bootstrap.py:30-43: file specs return `{ok: True, workspace: str(workspace), team: name}`.
-// - cli/helpers.py:12-16 JSON emits `json.dumps(..., indent=2, ensure_ascii=False, sort_keys=True)`.
-//
-// Golden probe:
-//   PYTHONPATH=/Users/alauda/Documents/code/team-agent-public/src python3 /tmp/probe_validate_cli.py
-//   valid file --json rc=0 stdout:
-//   {
-//     "ok": true,
-//     "team": "fake-e2e",
-//     "workspace": "<ws>"
-//   }
-#[test]
-fn validate_valid_spec_file_json_byte_shape() {
-    let ws = tmp_workspace();
-    let spec_path = write_validate_spec(&ws, "team.spec.yaml", "fake");
-
-    let result = cmd_validate(&ValidateArgs {
-        spec: spec_path.clone(),
-        json: true,
-    })
-    .expect("valid spec must return an ok CmdResult");
-
-    assert_eq!(result.exit, ExitCode::Ok);
-    assert_eq!(
-        emit(&result.output, true).unwrap(),
-        format!(
-            "{{\n  \"ok\": true,\n  \"team\": \"fake-e2e\",\n  \"workspace\": \"{}\"\n}}",
-            ws.to_string_lossy()
-        ),
-        "validate --json must match Python sort_keys+indent bytes for a valid file spec",
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-// Golden source:
-// - spec.py:85-91 accumulates validation messages and raises
-//   `team.spec.yaml validation failed:\n- ...`.
-// - spec.py semantic provider check emits `/leader/provider: unknown provider 'bogus'`.
-// - cli/helpers.py:137-155 error payload insertion order is `ok,error,action,log`.
-// - cli/helpers.py:128-131 prints compact JSON, not pretty/sorted JSON, for `--json` errors.
-#[test]
-fn validate_invalid_spec_json_error_envelope_byte_shape() {
-    let ws = tmp_workspace();
-    let spec_path = write_validate_spec(&ws, "bad.spec.yaml", "bogus");
-
-    let err = cmd_validate(&ValidateArgs {
-        spec: spec_path,
-        json: true,
-    })
-    .expect_err("invalid spec must surface a CLI/runtime validation error");
-
-    assert_eq!(
-        err.to_string(),
-        "team.spec.yaml validation failed:\n- /leader/provider: unknown provider 'bogus'",
-    );
-    let payload = err.to_payload(&ws.join(".team/logs/cli-error-123.log"), "validate");
-    assert_eq!(
-        serde_json::to_string(&payload).unwrap(),
-        format!(
-            "{{\"ok\":false,\"error\":\"team.spec.yaml validation failed:\\n- /leader/provider: unknown provider 'bogus'\",\"action\":\"run `team-agent doctor` or inspect the log path shown here\",\"log\":\"{}\"}}",
-            ws.join(".team/logs/cli-error-123.log").to_string_lossy()
-        ),
-        "validate --json errors must match Python compact error envelope key order and text",
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-// Golden source:
-// - cli/parser.py:120-123 default spec argument is `team.spec.yaml`.
-// Current Rust dispatch has no `validate` arm; this must be RED until the porter routes it.
-#[test]
-fn dispatch_routes_validate_default_spec() {
-    let ws = tmp_workspace();
-    let _spec_path = write_validate_spec(&ws, "team.spec.yaml", "fake");
-    let code = run(&["validate".to_string(), "--json".to_string()], &ws);
-    assert_eq!(
-        code,
-        ExitCode::Ok,
-        "`validate --json` must route and exit 0 for default team.spec.yaml"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}

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

@@ -1,223 +0,0 @@
-use super::*;
-
-// ═════════════════════════════════════════════════════════════════════════
-// GROUP G — watch render_event_line (watch.py:46) — golden text — RED
-//   exact strings captured via PYTHONPATH probe against v0.2.11.
-// ═════════════════════════════════════════════════════════════════════════
-
-#[test]
-fn render_result_received_collapses_whitespace_and_defaults() {
-    // watch.py:48-49 + _result_line — "result_received: <agent|-> -> <clean summary>".
-    let e = serde_json::json!({"event": "result_received", "agent_id": "w1", "summary": "did   the\nthing"});
-    assert_eq!(
-        render_event_line(&e),
-        Some("result_received: w1 -> did the thing".to_string())
-    );
-    // missing agent + summary → both '-'.
-    let bare = serde_json::json!({"event": "result_received"});
-    assert_eq!(
-        render_event_line(&bare),
-        Some("result_received: - -> -".to_string())
-    );
-}
-
-#[test]
-fn render_injected_and_submitted_share_prefix_and_truncate_message_id() {
-    // watch.py:50-51 — both render as "leader_receiver.injected"; message_id truncated to 12.
-    let inj = serde_json::json!({"event": "leader_receiver.injected", "message_id": "abcdef0123456789", "recipient": "w2"});
-    assert_eq!(
-        render_event_line(&inj),
-        Some("leader_receiver.injected: abcdef012345 -> w2".to_string())
-    );
-    // submitted uses same label, msg_id fallback, `to` recipient fallback.
-    let sub = serde_json::json!({"event": "leader_receiver.submitted", "msg_id": "xy", "to": "w3"});
-    assert_eq!(
-        render_event_line(&sub),
-        Some("leader_receiver.injected: xy -> w3".to_string())
-    );
-}
-
-#[test]
-fn render_send_failed_uses_reason_then_error_fallback() {
-    // watch.py:52-53 — reason || error || '-', recipient || to || target || '-', whitespace-cleaned.
-    let with_reason =
-        serde_json::json!({"event": "send.failed", "recipient": "w4", "reason": "  pane   gone  "});
-    assert_eq!(
-        render_event_line(&with_reason),
-        Some("send.failed: w4 reason=pane gone".to_string())
-    );
-    let with_error = serde_json::json!({"event": "send.failed", "target": "w5", "error": "boom"});
-    assert_eq!(
-        render_event_line(&with_error),
-        Some("send.failed: w5 reason=boom".to_string())
-    );
-}
-
-#[test]
-fn render_rebind_required_uses_pane_and_reason_fallbacks() {
-    // watch.py:54-57 — old_pane_id || pane_id || target || '-'; reason || rediscovery_status || '-'.
-    let e = serde_json::json!({"event": "leader_receiver.rebind_required", "old_pane_id": "%9", "reason": "lost"});
-    assert_eq!(
-        render_event_line(&e),
-        Some("leader_receiver.rebind_required: pane=%9 reason=lost".to_string())
-    );
-    let no_reason =
-        serde_json::json!({"event": "leader_receiver.rebind_required", "pane_id": "%7"});
-    assert_eq!(
-        render_event_line(&no_reason),
-        Some("leader_receiver.rebind_required: pane=%7 reason=-".to_string())
-    );
-}
-
-#[test]
-fn render_api_error_defaults_unknown_class_and_dash() {
-    // watch.py:58-62 — error_class || "Unknown"; provider || '-'; snippet || '-' cleaned.
-    let error_class = ["Over", "loaded"].concat();
-    let code = (500 + 29).to_string();
-    let e = serde_json::json!({"event": "leader.api_error", "error_class": error_class, "provider": "claude_code", "matched_pattern_snippet": format!("{code}  too  many")});
-    assert_eq!(
-        render_event_line(&e),
-        Some(format!(
-            "leader.api_error: {} provider=claude_code snippet={} too many",
-            ["Over", "loaded"].concat(),
-            code
-        ))
-    );
-    let bare = serde_json::json!({"event": "leader.api_error"});
-    assert_eq!(
-        render_event_line(&bare),
-        Some("leader.api_error: Unknown provider=- snippet=-".to_string())
-    );
-}
-
-#[test]
-fn render_non_renderable_events_return_none() {
-    // watch.py:63 — coordinator.* / unknown events → None.
-    assert_eq!(
-        render_event_line(&serde_json::json!({"event": "coordinator.boot"})),
-        None
-    );
-    assert_eq!(
-        render_event_line(&serde_json::json!({"event": "unknown.thing"})),
-        None
-    );
-}
-
-// ═════════════════════════════════════════════════════════════════════════
-// GROUP H — WatchCursor rotation invariants (watch.py:66-97) — RED via collect_watch_lines
-// ═════════════════════════════════════════════════════════════════════════
-
-#[test]
-fn watch_cursor_default_is_uninitialized() {
-    let c = WatchCursor::default();
-    assert_eq!(c.event_offset, 0);
-    assert!(!c.initialized);
-    assert!(c.archive_signature.is_none());
-    assert!(c.seen_result_ids.is_empty());
-}
-
-/// seed a workspace with an `events.jsonl` (+ optional archived `events.jsonl.1`).
-/// Returns the resolved `WorkspacePath`. The events file holds one renderable
-/// `result_received` line so `collect_watch_lines` has observable non-marker output.
-fn seed_watch_workspace(event_summary: &str, archive_bytes: Option<&[u8]>) -> WorkspacePath {
-    let dir = std::env::temp_dir().join(format!(
-        "team-agent-watch-rotate-{}-{}",
-        std::process::id(),
-        std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_nanos()
-    ));
-    let logs = crate::model::paths::logs_dir(&dir);
-    std::fs::create_dir_all(&logs).unwrap();
-    let line =
-        serde_json::json!({"event": "result_received", "agent_id": "w1", "summary": event_summary});
-    std::fs::write(
-        logs.join("events.jsonl"),
-        format!("{}\n", serde_json::to_string(&line).unwrap()),
-    )
-    .unwrap();
-    if let Some(bytes) = archive_bytes {
-        std::fs::write(logs.join("events.jsonl.1"), bytes).unwrap();
-    }
-    // MessageStore::open creates the schema so collect_watch_lines' result tail works.
-    let _ = MessageStore::open(&dir).unwrap();
-    WorkspacePath::new(dir)
-}
-
-#[test]
-fn watch_rotation_emits_marker_once_resets_offset_and_does_not_replay() {
-    // watch/__init__.py:66-97 — archive_signature change OR offset>size => ROTATION_MARKER
-    // (once), event_offset reset to 0, archived segment NOT replayed (only the current
-    // events.jsonl is read from the new offset forward). The doc-comment invariant
-    // (coordinator.rs lines 42-43 / 532-533) is now ASSERTED, not commented.
-    let ws = seed_watch_workspace("first segment", None);
-    let store = MessageStore::open(ws.as_path()).unwrap();
-    let mut cursor = WatchCursor::default();
-
-    // First call: initializes the cursor (no marker even though no archive yet),
-    // renders the seeded result line, advances offset past EOF.
-    let first = collect_watch_lines(&ws, &mut cursor, &store, None).unwrap();
-    assert!(cursor.initialized, "first call initializes the cursor");
-    assert!(
-        !first.iter().any(|l| l == ROTATION_MARKER),
-        "no rotation marker on first/initializing call"
-    );
-    assert!(
-        first.iter().any(|l| l.contains("first segment")),
-        "first segment line is rendered exactly once"
-    );
-    let offset_after_first = cursor.event_offset;
-    assert!(
-        offset_after_first > 0,
-        "offset advanced past the consumed segment"
-    );
-
-    // Simulate rotation: an archive segment now appears (archive_signature changes from
-    // None -> Some), and the live events.jsonl is replaced with a fresh, SHORTER file
-    // whose new content must NOT include the archived "first segment".
-    let logs = crate::model::paths::logs_dir(ws.as_path());
-    std::fs::write(
-        logs.join("events.jsonl.1"),
-        b"archived old bytes that must never replay\n",
-    )
-    .unwrap();
-    let fresh = serde_json::json!({"event": "result_received", "agent_id": "w1", "summary": "post rotation"});
-    std::fs::write(
-        logs.join("events.jsonl"),
-        format!("{}\n", serde_json::to_string(&fresh).unwrap()),
-    )
-    .unwrap();
-
-    let second = collect_watch_lines(&ws, &mut cursor, &store, None).unwrap();
-    let marker_count = second.iter().filter(|l| **l == ROTATION_MARKER).count();
-    assert_eq!(
-        marker_count, 1,
-        "ROTATION_MARKER emitted exactly once on rotation"
-    );
-    assert!(
-        !second.iter().any(|l| l.contains("first segment")),
-        "archived segment is NOT replayed"
-    );
-    assert!(
-        !second
-            .iter()
-            .any(|l| l.contains("old bytes that must never replay")),
-        "archive file contents are NEVER read/replayed"
-    );
-    assert!(
-        second.iter().any(|l| l.contains("post rotation")),
-        "post-rotation live segment IS rendered (read from reset offset forward)"
-    );
-    // offset was reset to 0 by the rotation branch, then re-advanced over the fresh
-    // (shorter) file — so it must be < the pre-rotation offset, proving the reset.
-    assert!(
-        cursor.event_offset <= offset_after_first,
-        "event_offset reset on rotation (re-advanced over the shorter fresh file)"
-    );
-    assert_eq!(
-        cursor.archive_signature.map(|(sz, _)| sz),
-        Some(b"archived old bytes that must never replay\n".len() as u64),
-        "archive_signature updated to the new archived segment's (size, mtime_ns)"
-    );
-}