diff --git a/Cargo.lock b/Cargo.lock
index 0edb4a43f..39eff5466 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1939,8 +1939,6 @@ dependencies = [
 name = "hive-jobq-wire"
 version = "0.1.0"
 dependencies = [
- "chrono",
- "enumflags2",
  "hive-jobq",
  "serde",
  "serde_json",
diff --git a/docs/4-implementation/agent-state/persistence.md b/docs/4-implementation/agent-state/persistence.md
index 0f7b1f3e5..ecabda264 100644
--- a/docs/4-implementation/agent-state/persistence.md
+++ b/docs/4-implementation/agent-state/persistence.md
@@ -127,7 +127,7 @@ Shape:
 - `needs_login` — set when a turn hits 401 (expired OAuth credentials);
   cleared by `"online"` status (re-auth completed). Drives the
   `needs_login` flag alongside the `claude_has_session` check.
-- `active_model` — the resolved Claude model for the dashboard badge.
+- `active_model` — the resolved Claude model.
 
 The turn loop is the only writer today, but it still goes
 read-modify-write under a shared in-process lock and merges into the
diff --git a/docs/4-implementation/scheduler/coordinator.md b/docs/4-implementation/scheduler/coordinator.md
index 423c39d48..b8d62a81e 100644
--- a/docs/4-implementation/scheduler/coordinator.md
+++ b/docs/4-implementation/scheduler/coordinator.md
@@ -256,7 +256,7 @@ the dashboard renders one recent-builds list and one number bounds it.
 
 ### Wire shape
 
-`RebuildQueueChanged { seq }` (event name kept) — **a bare trigger, no
+`RebuildQueueChanged` (event name kept) — **a bare trigger, no
 payload.** It says _the queue changed_; a client that wants to know how
 re-fetches `GET /api/jobq/graph`.
 
diff --git a/docs/4-implementation/turn-loop/claude-invocation.md b/docs/4-implementation/turn-loop/claude-invocation.md
index 231968fc9..d28766955 100644
--- a/docs/4-implementation/turn-loop/claude-invocation.md
+++ b/docs/4-implementation/turn-loop/claude-invocation.md
@@ -73,9 +73,7 @@ match wins):
 Once a turn completes, the window the model reports
 (`modelUsage.*.contextWindow`) replaces this value.
 
-The effective window drives watermarks; the harness exposes it at
-runtime via `/api/state.context_window_tokens` so the UI can show a
-percentage-of-window ctx badge.
+The effective window drives watermarks; no web endpoint serves it.
 
 **Session identity — a constant title.** Every turn keys on one fixed,
 harness-owned session title (`turn::session_title()`, default
diff --git a/docs/4-implementation/web-ui/agent-page.md b/docs/4-implementation/web-ui/agent-page.md
index cf3b83252..68c415b6b 100644
--- a/docs/4-implementation/web-ui/agent-page.md
+++ b/docs/4-implementation/web-ui/agent-page.md
@@ -99,7 +99,7 @@ at a given viewport width. Two columns:
 
 Values throughout come from `GET /api/state`'s cold-load snapshot,
 kept in sync afterwards by the SSE stream (see Live view below) —
-`context_window_tokens` for the ctx badge tooltip, `qualified_label`
+`qualified_label`
 (the hive-qualified `name@domain` form, used for the browser tab title
 so two tabs from different hives are distinguishable; the header's own
 `◆ <label> ◆` stays short).
@@ -288,15 +288,14 @@ credentials arrive from the swarm secret store.
 
 - `GET /api/state` — cold-load snapshot (`StateSnapshot`) consumed by
   the frontend (`useAgentState.ts`) on page load. Includes `turn_state`,
-  `context_window_tokens`, `qualified_label`,
+  `qualified_label`,
   `model`, `model_source`, `effort`, `effort_source`, `links`, and
   other fields described inline throughout this document. All
   subsequent state updates arrive via SSE.
 - `GET /api/dashboard-state` — lean snapshot of agent-owned fields
   fetched once per running agent by the dashboard's container row to
   get fresh values without relying on hive-c0re's periodic file-reads.
-  Returns `{ status_text?, status_set_at?, ctx_tokens?, context_window_tokens,
-rate_limited, links }`. Only called when the container is running;
+  Returns `{ status_text?, status_set_at?, rate_limited, links }`. Only called when the container is running;
   skipped (muted badges) when stopped. Also accessible via the gateway
   at `/agent/<name>/api/dashboard-state`.
 - `GET /api/todos` — harness-local todos snapshot (loose-ends v2)
diff --git a/docs/4-implementation/web-ui/dashboard.md b/docs/4-implementation/web-ui/dashboard.md
index 53d2ed9fb..574a9e6f1 100644
--- a/docs/4-implementation/web-ui/dashboard.md
+++ b/docs/4-implementation/web-ui/dashboard.md
@@ -60,7 +60,7 @@ active; hash changes don't reload the page.
 container, sorted alphabetically by agent name; every container the
 rescan reports gets a row. Pulsing red banner at the top
 of this section if any two sub-agents hash to the same port
-(`port_conflicts` from `/api/state`): the operator must rename
+(derived client-side from the container ports): the operator must rename
 one of them and rebuild. `lifecycle::{spawn,rebuild}` also
 preflight this and refuse with a clear error message naming the
 conflicting agent.
@@ -117,7 +117,7 @@ pipeline) with an `onUpdate` callback to drive the two things below it
 that the generic view doesn't show. The component owns fetching, cold
 and live: `GET /api/jobq/graph` on mount, and a refetch via the mount
 handle's `.refresh()` on every `rebuild_queue_changed` SSE tick (that
-event is a bare `{ seq }` trigger carrying no queue payload; both
+event is a bare trigger carrying no queue payload; both
 dashboard pages treat the tick as a pure refetch trigger).
 
 Each row is one root graph node (`parent: null`); a multi-step op's
@@ -425,9 +425,8 @@ below — some endpoints aren't in it yet.
 - `POST /api/purge-tombstone/{name}` — wipe a tombstone's state dirs.
 - `POST /api/rebuild-queue/{id}/cancel` — drop a `Queued` entry.
   Refuses `Running` / terminal-state entries (in-flight
-  rebuilds can't be safely interrupted). Always 200; body is
-  `{"cancelled": true}` on a successful flip or
-  `{"cancelled": false}` when the entry wasn't in `Queued` state.
+  rebuilds can't be safely interrupted). Always 200 with an empty body, whether or not
+  the entry was in `Queued` state.
 - `POST /api/agent/{name}/mark-all-read` — ack all pending broker
   messages for `{name}`. Backfills `delivered_at` for rows
   not yet delivered and sets `acked_at = now`. Returns
@@ -436,8 +435,7 @@ below — some endpoints aren't in it yet.
 
 - `GET /api/dashboard/stream` — unified live event channel:
   broker `sent` / `delivered`, plus the mutation events listed
-  below. Each frame carries `seq`.
-  <!-- vale write-good.Passive = YES -->
+  below. <!-- vale write-good.Passive = YES -->
 
 ## Dashboard event channel
 
@@ -463,12 +461,12 @@ payload):
   `crash_watch` poll. Client upserts/removes by name and
   reads the pending overlay from `transientsState` since the
   payload doesn't carry it.
-- `rebuild_queue_changed` (seq) — **payload-free trigger**, fired on
+- `rebuild_queue_changed` — **payload-free trigger**, fired on
   every queue mutation (enqueue, state transition, dedup collapse,
   terminal-history trim). Unlike the snapshot events below it ships
   no state at all: the client re-fetches `GET /api/jobq/graph`, which
   is where it reads the queue from cold too.
-- `tombstones_changed` (seq, tombstones: `Vec<TombstoneView>`) —
+- `tombstones_changed` (tombstones: `Vec<TombstoneView>`) —
   full snapshot of destroyed-but-state-kept agents. Emitted on
   destroy, purge, and revive. The K3PT ST4T3 tab subscribes.
 
diff --git a/docs/4-implementation/web-ui/shape.md b/docs/4-implementation/web-ui/shape.md
index 9ae349412..9fc5bd5aa 100644
--- a/docs/4-implementation/web-ui/shape.md
+++ b/docs/4-implementation/web-ui/shape.md
@@ -39,15 +39,12 @@
   XSS-safe by construction the way the text-node `linkify` path is.
   Rendered `<a>`s are rewritten to `target="_blank"`.
 - `GET /api/state` → JSON snapshot the JS app renders into the
-  DOM. Includes a top-level `seq` (the dashboard event channel's
-  high-water mark at the moment the server assembled the snapshot);
-  clients use it to dedupe their buffered SSE traffic against
-  the snapshot (drop frames with `seq <= snapshot.seq`).
+  DOM.
 - `GET /api/dashboard/stream` (dashboard) / `GET /events/stream`
   (per-agent) → `text/event-stream` SSE for live updates. The
   dashboard stream carries broker `Sent` / `Delivered` (mirrored
   by a forwarder task from the broker's intra-process channel)
-  plus mutation events (`transient_set` / `transient_cleared`). Each frame carries a `seq`. The
+  plus mutation events (`transient_set` / `transient_cleared`). The
   agent's matching backfill endpoint is `GET /events/history` (last 2000
   `LiveEvent`s wrapped in `{ seq, events }`).
   **One unified channel**: browsers cap concurrent SSE
diff --git a/docs/5-project/process/conventions.md b/docs/5-project/process/conventions.md
index ed890a5ed..d3b1fd654 100644
--- a/docs/5-project/process/conventions.md
+++ b/docs/5-project/process/conventions.md
@@ -98,8 +98,8 @@ The broker stores the recipient exactly as the agent passed it.
 JSON line-delimited over unix sockets in both directions (host admin
 / manager / agent). SSE streams (`/dashboard/stream` on hive-c0re,
 `/events/stream` on the per-agent web UIs) are `text/event-stream`;
-each frame carries a `seq` field for the snapshot-dedupe dance
-(see `docs/4-implementation/web-ui/shape.md`). Request/response types live in `hive-sh4re`
+the per-agent `/events/stream` frames carry a `seq` field for the
+snapshot-dedupe dance (see `docs/4-implementation/web-ui/shape.md`). Request/response types live in `hive-sh4re`
 — change them in one place. The dashboard event vocabulary lives
 in `hive-c0re::dashboard_events::DashboardEvent`.
 
diff --git a/frontend/packages/agent/src/types.ts b/frontend/packages/agent/src/types.ts
index 6a05a8f1b..415974669 100644
--- a/frontend/packages/agent/src/types.ts
+++ b/frontend/packages/agent/src/types.ts
@@ -8,7 +8,6 @@
 export type InferenceSource = "swarm" | "agent_nix" | "local_file" | "default";
 
 export interface AgentState {
-  seq: number;
   label: string;
   qualified_label: string;
   dashboard_port: number;
@@ -17,7 +16,6 @@ export interface AgentState {
   turn_state_since: number;
   model: string;
   resolved_model: string | null;
-  context_window_tokens: number;
   ctx_usage: TokenUsage | null;
   cost_usage: TokenUsage | null;
   hive_name: string | null;
diff --git a/frontend/packages/dashboard/src/agents.js b/frontend/packages/dashboard/src/agents.js
index 7b4366527..8d0de4c0b 100644
--- a/frontend/packages/dashboard/src/agents.js
+++ b/frontend/packages/dashboard/src/agents.js
@@ -92,7 +92,7 @@ export function syncTransientsFromSnapshot(s) {
     // Snapshot ships `secs` (server-computed); reconstruct an
     // approximate since_unix so the live ticker keeps progressing
     // without surprising jumps when the next snapshot lands.
-    byKind.set(t.kind, t.since_unix ?? nowUnix - (t.secs || 0));
+    byKind.set(t.kind, nowUnix - (t.secs || 0));
   }
 }
 export function applyTransientSet(ev) {
@@ -193,9 +193,8 @@ function buildAgentMenu(c) {
 
 // ─── port conflicts ──────────────────────────────────────────────────────────
 
-// Re-derive port conflicts from the live containers map. Mirrors the
-// server-side `build_port_conflicts` so the banner reacts to event
-// updates instead of waiting for a /api/state refetch.
+// Derive port conflicts from the live containers map, so the banner
+// reacts to event updates without a /api/state refetch.
 function derivePortConflicts(containers) {
   const byPort = new Map();
   for (const c of containers) {
diff --git a/frontend/packages/shared/src/jobq-graph/JobqGraph.tsx b/frontend/packages/shared/src/jobq-graph/JobqGraph.tsx
index af03684f1..736acbb15 100644
--- a/frontend/packages/shared/src/jobq-graph/JobqGraph.tsx
+++ b/frontend/packages/shared/src/jobq-graph/JobqGraph.tsx
@@ -44,12 +44,10 @@ type NodeState =
   | "Cancelled"
   | "Skipped";
 
-type TerminalState = "Done" | "Failed" | "Cancelled" | "Skipped";
-
 // Mirrors `hive_jobq_wire::GraphDep` — externally tagged on `kind`,
 // values are the Rust variant names verbatim.
 type GraphDep =
-  | { kind: "Node"; id: number; accepts: TerminalState[] }
+  | { kind: "Node"; id: number }
   | { kind: "Resource"; name: string; count: number };
 
 interface NodePayload {
diff --git a/hive-agent/src/stats.rs b/hive-agent/src/stats.rs
index d9627b153..7676d027d 100644
--- a/hive-agent/src/stats.rs
+++ b/hive-agent/src/stats.rs
@@ -109,8 +109,6 @@ fn adaptive_bucket_secs(span_secs: i64) -> i64 {
 pub struct Snapshot {
     pub window: &'static str,
     pub bucket_seconds: i64,
-    pub now: i64,
-    pub from: i64,
     /// Total turns in the window.
     pub turn_count: u64,
     /// Time-bucketed trend series, oldest first. Always covers the
@@ -231,8 +229,6 @@ fn empty_snapshot(window: Window) -> Snapshot {
     Snapshot {
         window: window.label(),
         bucket_seconds: window.bucket_secs(),
-        now,
-        from,
         turn_count: 0,
         buckets,
         tool_breakdown: Vec::new(),
@@ -360,8 +356,6 @@ fn snapshot(path: &Path, window: Window) -> Result<Snapshot> {
     Ok(Snapshot {
         window: window.label(),
         bucket_seconds: bucket_secs,
-        now,
-        from,
         turn_count: acc.turn_count,
         buckets,
         tool_breakdown: top_n(acc.tool_totals, 10),
@@ -873,4 +867,32 @@ mod tests {
             Some("cargo")
         );
     }
+
+    /// `GET /api/stats` carries exactly the fields the stats page reads.
+    #[test]
+    fn the_stats_snapshot_serialises_exactly_its_read_fields() {
+        let value = serde_json::to_value(empty_snapshot(Window::Hour)).unwrap();
+        let mut keys: Vec<&str> = value
+            .as_object()
+            .unwrap()
+            .keys()
+            .map(String::as_str)
+            .collect();
+        keys.sort_unstable();
+        assert_eq!(
+            keys,
+            [
+                "bash_breakdown",
+                "bucket_seconds",
+                "buckets",
+                "duration_summary",
+                "models",
+                "result_mix",
+                "tool_breakdown",
+                "turn_count",
+                "wake_mix",
+                "window",
+            ]
+        );
+    }
 }
diff --git a/hive-agent/src/web_ui/actions.rs b/hive-agent/src/web_ui/actions.rs
index 553a15fd8..ab40596fa 100644
--- a/hive-agent/src/web_ui/actions.rs
+++ b/hive-agent/src/web_ui/actions.rs
@@ -6,7 +6,7 @@ use axum::{
     http::StatusCode,
     response::{IntoResponse, Response},
 };
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
 use std::future::Future;
 
 use super::{AppState, SOCKET_FETCH_TIMEOUT, error_response};
@@ -53,9 +53,8 @@ pub(super) struct MarkTodosDoneForm {
 /// `hive-agent-sock`: the todos list is small (single-digit rows most of the
 /// time), so N same-host socket round-trips isn't a real cost, and it keeps
 /// the wire protocol's `Request` enum — already used by the `cancel_loose_end`
-/// MCP tool — unchanged. Unknown/already-acked ids just don't add to the
-/// `acked` count (same "acking twice is not a new action" semantics as the
-/// single-id path); a request with no ids or where every id fails to parse
+/// MCP tool — unchanged. Unknown/already-acked ids succeed too (acking twice is
+/// not a new action); a request with no ids or where every id fails to parse
 /// is rejected as a client error rather than silently acking nothing. An id
 /// whose store call errors or gets no answer fails the request with a 500
 /// naming how many failed. More than [`MAX_MARK_DONE_IDS`] ids is a client
@@ -102,15 +101,14 @@ where
         );
     }
     match settle_mark_done(answers) {
-        Ok(acked) => axum::Json(MarkTodosDoneBody { acked }).into_response(),
+        Ok(()) => StatusCode::OK.into_response(),
         Err(message) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &message),
     }
 }
 
-/// Folds the per-id answers into the acked total, or the operator-facing
-/// failure. `None` is a dial that got no answer; `Response::Err` and any
+/// Folds the per-id answers into success, or the operator-facing failure. `None` is a dial that got no answer; `Response::Err` and any
 /// other variant are failures. `Acked { count: 0 }` is a success.
-fn settle_mark_done(answers: Vec<Option<hive_agent_sock::Response>>) -> Result<u64, String> {
+fn settle_mark_done(answers: Vec<Option<hive_agent_sock::Response>>) -> Result<(), String> {
     let total = answers.len();
     let mut acked = 0u64;
     let mut failed = 0usize;
@@ -133,18 +131,13 @@ fn settle_mark_done(answers: Vec<Option<hive_agent_sock::Response>>) -> Result<u
         }
     }
     match first_error {
-        None => Ok(acked),
+        None => Ok(()),
         Some(error) => Err(format!(
             "mark-done: {failed} of {total} failed ({acked} marked done): {error}"
         )),
     }
 }
 
-#[derive(Serialize)]
-struct MarkTodosDoneBody {
-    acked: u64,
-}
-
 #[cfg(test)]
 mod tests {
     use super::{mark_ids_done, settle_mark_done};
@@ -187,13 +180,13 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn mark_done_handler_answers_200_with_the_acked_total() {
+    async fn mark_done_handler_answers_200_with_an_empty_body() {
         let response = mark_ids_done(vec![1, 2], std::time::Duration::from_secs(3), |_| async {
             Some(hive_agent_sock::Response::Acked { count: 1 })
         })
         .await;
         assert_eq!(response.status(), axum::http::StatusCode::OK);
-        assert_eq!(body_text(response).await, r#"{"acked":2}"#);
+        assert_eq!(body_text(response).await, "");
     }
 
     #[tokio::test(start_paused = true)]
@@ -256,6 +249,6 @@ mod tests {
             Some(hive_agent_sock::Response::Acked { count: 0 }),
             Some(hive_agent_sock::Response::Acked { count: 2 }),
         ];
-        assert_eq!(settle_mark_done(answers).unwrap(), 2);
+        assert!(settle_mark_done(answers).is_ok());
     }
 }
diff --git a/hive-agent/src/web_ui/state.rs b/hive-agent/src/web_ui/state.rs
index f19de4c1c..30d8e9c0a 100644
--- a/hive-agent/src/web_ui/state.rs
+++ b/hive-agent/src/web_ui/state.rs
@@ -9,9 +9,6 @@ use crate::login::LoginState;
 use super::AppState;
 
 pub(super) async fn api_state(State(state): State<AppState>) -> axum::Json<StateSnapshot> {
-    // Capture seq *before* any reads so the dedupe contract is
-    // "events with seq > snapshot.seq are post-snapshot, never missed."
-    let seq = state.bus.current_seq();
     let login = *state.login.lock().unwrap();
     let status = status_of(login, state.bus.is_rate_limited());
     let dashboard_port = std::env::var("HIVE_DASHBOARD_PORT")
@@ -20,7 +17,6 @@ pub(super) async fn api_state(State(state): State<AppState>) -> axum::Json<State
         .unwrap_or(7000);
     let inbox = recent_inbox(&state.socket).await;
     let (turn_state, turn_state_since) = state.bus.state_snapshot();
-    let model = state.bus.model();
     // The alias the operator selected (e.g. "sonnet") vs. what the last
     // turn actually ran on (e.g. "claude-sonnet-4-5-20260805") — mara:
     // "i cannot see if sonnet became claude-sonnet-5 or something else".
@@ -28,12 +24,10 @@ pub(super) async fn api_state(State(state): State<AppState>) -> axum::Json<State
     // resolve from yet); same source `serve_common.rs`'s turn-stats
     // rollup already prefers over the requested alias.
     let resolved_model = state.bus.last_resolved_model();
-    let context_window_tokens = state.bus.effective_context_window(&model);
     let ctx_usage = state.bus.last_ctx_usage();
     let cost_usage = state.bus.last_cost_usage();
     let shown = shown(&state.bus);
     axum::Json(StateSnapshot {
-        seq,
         label: state.label.clone(),
         qualified_label: crate::identity::qualify(&state.label),
         dashboard_port,
@@ -44,7 +38,6 @@ pub(super) async fn api_state(State(state): State<AppState>) -> axum::Json<State
         model: shown.model,
         model_source: state.bus.model_source(),
         resolved_model,
-        context_window_tokens,
         ctx_usage,
         cost_usage,
         links: agent_links(state.gui_vnc_port.is_some()),
@@ -70,19 +63,9 @@ pub(super) async fn api_dashboard_state(
 ) -> axum::Json<DashboardState> {
     let (status_text, status_set_at) = read_own_status();
     let rate_limited = state.bus.is_rate_limited();
-    let model = state.bus.model();
-    let context_window_tokens = state.bus.effective_context_window(&model);
-    // Full context-window size = input + cache-read + cache-creation. Using
-    // raw `input_tokens` here reported only the *uncached* sliver, which is
-    // ~0 once prompt caching kicks in — so every card showed `ctx·0k`. Match
-    // the agent page (which ships the whole `ctx_usage` and sums it) and the
-    // cache-TTL logic in turn.rs, both of which use `context_tokens()`.
-    let ctx_tokens = state.bus.last_ctx_usage().map(|u| u.context_tokens());
     axum::Json(DashboardState {
         status_text,
         status_set_at,
-        ctx_tokens,
-        context_window_tokens,
         rate_limited,
         links: agent_links(state.gui_vnc_port.is_some()),
     })
@@ -90,12 +73,6 @@ pub(super) async fn api_dashboard_state(
 
 #[derive(Serialize)]
 pub(super) struct StateSnapshot {
-    /// Bus seq at the moment this snapshot was assembled. Clients dedupe
-    /// their buffered SSE traffic against this value: events with
-    /// `seq <= snapshot.seq` are already reflected (or pre-date the
-    /// snapshot); `seq > snapshot.seq` is post-snapshot. Reset to 0 on
-    /// harness restart — clients treat reconnect as a fresh world.
-    seq: u64,
     label: String,
     /// Hive-qualified long name (`${label}@${hyperhive.domain}`) when
     /// the host has been configured for a multi-hive swarm; falls back
@@ -126,12 +103,6 @@ pub(super) struct StateSnapshot {
     /// operator picked, which claude itself maps to a specific dated
     /// snapshot. `None` before any turn has completed.
     resolved_model: Option<String>,
-    /// Effective context-window token budget for the current model.
-    /// Primary source: API-reported `modelUsage.*.contextWindow` from
-    /// the last result event (authoritative per-inference active window).
-    /// Falls back to `harness_state::context_window_tokens(model)`.
-    /// Consumers (e.g. dashboard badge) use this to render ctx-usage %.
-    context_window_tokens: u64,
     /// Last-inference token usage from the most recent completed
     /// turn — represents the current context-window size at turn-end.
     /// `null` until the first turn finishes.
@@ -214,14 +185,6 @@ pub(super) struct DashboardState {
     /// `None` when no status is set.
     #[serde(skip_serializing_if = "Option::is_none")]
     status_set_at: Option<i64>,
-    /// Full context-window size from the most recent completed turn
-    /// (`ctx_usage.context_tokens()` = input + cache-read + cache-creation).
-    /// `None` until the first turn finishes. Drives the `ctx·Nk` card badge.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    ctx_tokens: Option<u64>,
-    /// Effective context-window budget for the current model. Same
-    /// derivation as `StateSnapshot::context_window_tokens`.
-    context_window_tokens: u64,
     /// True while the harness is parked after a rate-limit response.
     rate_limited: bool,
     /// Navigation links for the dashboard card's icon strip. This is
@@ -487,4 +450,76 @@ mod tests {
             shown("haiku", None)
         );
     }
+
+    fn sorted_keys(v: &serde_json::Value) -> Vec<&str> {
+        let mut keys: Vec<&str> = v.as_object().unwrap().keys().map(String::as_str).collect();
+        keys.sort_unstable();
+        keys
+    }
+
+    /// `GET /api/state` carries exactly the fields the agent page and stats
+    /// page read; a field added back needs a reader.
+    #[test]
+    fn the_state_snapshot_serialises_exactly_its_read_fields() {
+        let snap = super::StateSnapshot {
+            label: "a".to_owned(),
+            qualified_label: "a".to_owned(),
+            dashboard_port: 7000,
+            status: "online",
+            inbox: Vec::new(),
+            turn_state: crate::events::TurnState::Idle,
+            turn_state_since: 0,
+            model: "haiku".to_owned(),
+            model_source: swarm_wire::agent_inference::Source::Default,
+            resolved_model: None,
+            ctx_usage: None,
+            cost_usage: None,
+            links: Vec::new(),
+            hive_name: None,
+            swarm_name: None,
+            effort: None,
+            effort_source: swarm_wire::agent_inference::Source::Default,
+            paused: false,
+        };
+        let value = serde_json::to_value(&snap).unwrap();
+        assert_eq!(
+            sorted_keys(&value),
+            [
+                "cost_usage",
+                "ctx_usage",
+                "dashboard_port",
+                "effort",
+                "effort_source",
+                "hive_name",
+                "inbox",
+                "label",
+                "links",
+                "model",
+                "model_source",
+                "paused",
+                "qualified_label",
+                "resolved_model",
+                "status",
+                "swarm_name",
+                "turn_state",
+                "turn_state_since",
+            ]
+        );
+    }
+
+    /// `GET /api/dashboard-state` carries exactly what the dashboard card reads.
+    #[test]
+    fn the_dashboard_state_serialises_exactly_its_read_fields() {
+        let state = super::DashboardState {
+            status_text: Some("busy".to_owned()),
+            status_set_at: Some(1),
+            rate_limited: false,
+            links: Vec::new(),
+        };
+        let value = serde_json::to_value(&state).unwrap();
+        assert_eq!(
+            sorted_keys(&value),
+            ["links", "rate_limited", "status_set_at", "status_text"]
+        );
+    }
 }
diff --git a/hive-c0re/src/container_view.rs b/hive-c0re/src/container_view.rs
index 0afe035ef..13520ec8a 100644
--- a/hive-c0re/src/container_view.rs
+++ b/hive-c0re/src/container_view.rs
@@ -7,7 +7,6 @@
 
 use std::path::Path;
 
-use chrono::{DateTime, Utc};
 use serde::Serialize;
 
 use crate::coordinator::Coordinator;
@@ -43,24 +42,6 @@ pub struct ContainerView {
     #[serde(default)]
     pub failed: bool,
     pub needs_login: bool,
-    /// The Claude model the agent's harness is currently using, read from
-    /// `state/hyperhive-harness.json["active_model"]`. `None` when the
-    /// agent has never started a turn or the field is absent. Only
-    /// meaningful when `running` is true; the dashboard skips the badge
-    /// for stopped containers.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub active_model: Option<String>,
-    /// The agent's current free-text status (`set_status`). `None` when
-    /// unset, or when the container isn't running — see
-    /// [`read_agent_status_live`] for why a stopped agent's on-disk
-    /// status is treated as stale rather than surfaced.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub status_text: Option<String>,
-    /// When `status_text` was last set, RFC 3339 UTC on the wire (see
-    /// `hive_sh4re::wire_time`). `None` exactly when `status_text` is
-    /// `None`.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub status_set_at: Option<DateTime<Utc>>,
     /// The agent's turn loop is parked: the container is up and still
     /// serving its web UI / MCP daemons, but it drives no turns and its
     /// inbox messages queue unacked until it resumes. Sourced from the
@@ -95,9 +76,6 @@ impl From<ContainerView> for hive_sh4re::container::AgentStatusRow {
             needs_login: v.needs_login,
             pending_reminders: 0,
             paused: v.paused,
-            active_model: v.active_model,
-            status_text: v.status_text,
-            status_set_at: v.status_set_at,
         }
     }
 }
@@ -173,25 +151,6 @@ pub async fn build_all() -> anyhow::Result<Vec<ContainerView>> {
         let needs_login = running
             && ((!is_api_key && !claude_has_session(&Coordinator::agent_claude_dir(&logical)))
                 || needs_login_sentinel);
-        // Read the active model from the harness state file. Only surfaced
-        // when the container is running — stale model info from a stopped
-        // agent is misleading (the model may change on next boot).
-        let active_model = if running {
-            read_active_model(&logical)
-        } else {
-            None
-        };
-        // Same running-gate as `active_model` just above, and the same
-        // rule `read_agent_status_live` applies for its other callers —
-        // duplicated inline rather than calling that helper because it
-        // would re-derive `running` with its own `lifecycle::is_running`
-        // shell-out when this loop already has it for free.
-        let (status_text, status_set_at) = if running {
-            let (text, set_at) = read_agent_status(&logical);
-            (text, set_at.map(hive_sh4re::wire_time::from_secs))
-        } else {
-            (None, None)
-        };
         let paused = Coordinator::is_paused(&logical);
         out.push(ContainerView {
             port: lifecycle::agent_web_port(logical.as_str()),
@@ -200,9 +159,6 @@ pub async fn build_all() -> anyhow::Result<Vec<ContainerView>> {
             container: c.clone(),
             name: logical.into_string(),
             needs_login,
-            active_model,
-            status_text,
-            status_set_at,
             paused,
         });
     }
@@ -329,21 +285,6 @@ fn status_if_running(
     (text, set_at, true)
 }
 
-/// Read the active Claude model from `hyperhive-harness.json` (the
-/// consolidated harness state file in the agent's state dir). Written by
-/// the harness on startup and on every `apply_model` / `emit_status` call,
-/// so it always reflects the model the agent runs. Returns `None` when the
-/// field is absent or the harness has not yet started a turn.
-fn read_active_model(name: &hive_types::Ident) -> Option<String> {
-    let path = Coordinator::agent_notes_dir(name).join("hyperhive-harness.json");
-    let raw = std::fs::read_to_string(path).ok()?;
-    let v: serde_json::Value = serde_json::from_str(&raw).ok()?;
-    v.get("active_model")
-        .and_then(serde_json::Value::as_str)
-        .filter(|s| !s.is_empty())
-        .map(str::to_owned)
-}
-
 /// Host-side hive + swarm display names, read from the c0re service's
 /// own process env. The hyperhive NixOS module sets these from
 /// `services.hyperhive.deploy.hive-controller.hiveName` + `services.hyperhive.swarm.name`
@@ -366,6 +307,34 @@ pub fn hive_swarm_names() -> (Option<String>, Option<String>) {
 
 #[cfg(test)]
 mod tests {
+    /// The serialised row has exactly the keys the dashboard reads; `container`
+    /// is internal and skipped.
+    #[test]
+    fn the_container_view_serialises_exactly_its_read_fields() {
+        use super::ContainerView;
+        let view = ContainerView {
+            name: "alice".to_owned(),
+            container: "h-alice".to_owned(),
+            port: 7000,
+            running: true,
+            failed: false,
+            needs_login: false,
+            paused: false,
+        };
+        let value = serde_json::to_value(&view).unwrap();
+        let mut keys: Vec<&str> = value
+            .as_object()
+            .unwrap()
+            .keys()
+            .map(String::as_str)
+            .collect();
+        keys.sort_unstable();
+        assert_eq!(
+            keys,
+            ["failed", "name", "needs_login", "paused", "port", "running"]
+        );
+    }
+
     /// The row says nothing of an update being pending or of a deployed commit:
     /// the hive applies a changed declaration on its own, so there is no state
     /// for an operator to act on.
@@ -379,9 +348,6 @@ mod tests {
             running: true,
             failed: false,
             needs_login: false,
-            active_model: None,
-            status_text: None,
-            status_set_at: None,
             paused: false,
         };
         let value = serde_json::to_value(&view).unwrap();
@@ -403,7 +369,6 @@ mod tests {
     #[test]
     fn agent_status_row_carries_every_field_the_row_has_and_drops_the_rest() {
         use super::ContainerView;
-        use chrono::{TimeZone, Utc};
         use hive_sh4re::container::AgentStatusRow;
 
         let view = ContainerView {
@@ -413,9 +378,6 @@ mod tests {
             running: true,
             failed: false,
             needs_login: false,
-            active_model: Some("claude-opus".to_owned()),
-            status_text: Some("shipping".to_owned()),
-            status_set_at: Some(Utc.timestamp_opt(1_700_000_000, 0).unwrap()),
             paused: true,
         };
 
@@ -425,12 +387,6 @@ mod tests {
         assert!(!row.failed);
         assert!(!row.needs_login);
         assert!(row.paused);
-        assert_eq!(row.active_model.as_deref(), Some("claude-opus"));
-        assert_eq!(row.status_text.as_deref(), Some("shipping"));
-        assert_eq!(
-            row.status_set_at,
-            Some(Utc.timestamp_opt(1_700_000_000, 0).unwrap())
-        );
         // No source for reminders on this side (see the `From` impl's doc
         // comment) — always the stub, never left uninitialised.
         assert_eq!(row.pending_reminders, 0);
diff --git a/hive-c0re/src/coordinator.rs b/hive-c0re/src/coordinator.rs
index 22d199e2e..9a4dac522 100644
--- a/hive-c0re/src/coordinator.rs
+++ b/hive-c0re/src/coordinator.rs
@@ -4,7 +4,6 @@
 
 use std::collections::{HashMap, HashSet};
 use std::path::{Path, PathBuf};
-use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
 
 use anyhow::{Context, Result};
@@ -17,8 +16,8 @@ use crate::job_queue::RunningTransient;
 use crate::socket_server::{self, AgentSocket};
 
 /// Capacity of the dashboard event channel. Slow browser subscribers
-/// (idle tab, throttled connection) drop frames past this — that's
-/// fine, the seq dedupe makes a reconnect resync safe.
+/// (idle tab, throttled connection) drop frames past this; the
+/// dashboard refetches `/api/state` on reconnect.
 const DASHBOARD_CHANNEL: usize = 256;
 
 pub struct Coordinator {
@@ -114,11 +113,7 @@ pub struct Coordinator {
     /// stream. Carries broker messages (mirrored from `broker.subscribe`
     /// by the forwarder task in `main.rs`) and dashboard-only mutation
     /// events (container state, rebuild queue, etc.).
-    /// Snapshot endpoints capture `event_seq` before reading state so
-    /// the client can dedupe its buffered live traffic against the
-    /// snapshot.
     dashboard_events: broadcast::Sender<DashboardEvent>,
-    event_seq: AtomicU64,
 
     /// Last container snapshot seen by `rescan_containers_and_emit`,
     /// keyed by `ContainerView.name`. The rescan diffs a fresh
@@ -377,7 +372,6 @@ impl Coordinator {
             updating: Mutex::new(HashSet::new()),
             updating_changed: tokio::sync::Notify::new(),
             dashboard_events,
-            event_seq: AtomicU64::new(0),
 
             last_containers: tokio::sync::Mutex::new(HashMap::new()),
             job_queue: Arc::new(crate::job_queue::JobQueue::new(build_slots)),
@@ -432,9 +426,7 @@ impl Coordinator {
     /// keeps `snapshot` because *that* is still what a client ends up with;
     /// what changed is who serves it.
     pub fn emit_rebuild_queue_snapshot(self: &Arc<Self>) {
-        self.emit_dashboard_event(DashboardEvent::RebuildQueueChanged {
-            seq: self.next_seq(),
-        });
+        self.emit_dashboard_event(DashboardEvent::RebuildQueueChanged);
     }
 
     /// Subscribe to the shutdown watch channel. Background tasks call
@@ -461,24 +453,7 @@ impl Coordinator {
         self.dashboard_events.subscribe()
     }
 
-    /// Stamp the next sequence number. Each emission of a
-    /// `DashboardEvent` should fill its `seq` with `next_seq()` so the
-    /// frame the wire carries is the one the client uses to dedupe.
-    pub fn next_seq(&self) -> u64 {
-        self.event_seq.fetch_add(1, Ordering::SeqCst) + 1
-    }
-
-    /// Current high-water seq. Snapshot endpoints read this *before*
-    /// gathering state so the (snapshot.seq, snapshot) pair satisfies:
-    /// any frame with `seq > snapshot.seq` is post-snapshot. The seq
-    /// captured here may grow during snapshot construction — clients
-    /// may double-apply such events, which renderers must tolerate.
-    pub fn current_seq(&self) -> u64 {
-        self.event_seq.load(Ordering::SeqCst)
-    }
-
-    /// Broadcast a freshly-built `DashboardEvent` (caller fills `seq`
-    /// via `next_seq()`). Returns silently when there are no
+    /// Broadcast a freshly-built `DashboardEvent`. Returns silently when there are no
     /// subscribers — the dashboard channel is best-effort presentation
     /// plumbing, not a delivery guarantee.
     pub fn emit_dashboard_event(&self, event: DashboardEvent) {
@@ -533,16 +508,10 @@ impl Coordinator {
         }
         drop(last);
         for c in changed_or_new {
-            self.emit_dashboard_event(DashboardEvent::ContainerStateChanged {
-                seq: self.next_seq(),
-                container: c,
-            });
+            self.emit_dashboard_event(DashboardEvent::ContainerStateChanged { container: c });
         }
         for name in removed {
-            self.emit_dashboard_event(DashboardEvent::ContainerRemoved {
-                seq: self.next_seq(),
-                name,
-            });
+            self.emit_dashboard_event(DashboardEvent::ContainerRemoved { name });
         }
     }
 
@@ -594,7 +563,6 @@ impl Coordinator {
             .and_then(|d| i64::try_from(d.as_secs()).ok())
             .unwrap_or(0);
         self.emit_dashboard_event(DashboardEvent::TransientSet {
-            seq: self.next_seq(),
             name: name.to_owned(),
             transient_kind: label,
             since_unix,
@@ -623,7 +591,6 @@ impl Coordinator {
             (deliberate_stop, std::time::Instant::now()),
         );
         self.emit_dashboard_event(DashboardEvent::TransientCleared {
-            seq: self.next_seq(),
             name: name.to_owned(),
             transient_kind: label.to_owned(),
         });
diff --git a/hive-c0re/src/dashboard/rebuild_queue.rs b/hive-c0re/src/dashboard/rebuild_queue.rs
index 5f669f84b..b793b569e 100644
--- a/hive-c0re/src/dashboard/rebuild_queue.rs
+++ b/hive-c0re/src/dashboard/rebuild_queue.rs
@@ -2,16 +2,11 @@
 
 use axum::{
     extract::{Path as AxumPath, State},
-    response::{IntoResponse, Response},
+    http::StatusCode,
 };
 
 use super::AppState;
 
-#[derive(serde::Serialize, utoipa::ToSchema)]
-pub(super) struct CancelResultBody {
-    cancelled: bool,
-}
-
 /// Drop still-queued work from the job
 /// queue.
 ///
@@ -23,27 +18,25 @@ pub(super) struct CancelResultBody {
 /// Refuses `Running` / terminal nodes: an
 /// in-flight node owns the agent's nix store + nixos-container update
 /// lock and can't be safely interrupted from the queue side. Always
-/// returns 200; the body is `{"cancelled": true}` on a successful
-/// flip to Cancelled, `{"cancelled": false}` when the DAG was
-/// Running / terminal / gone. On success a fresh `RebuildQueueChanged`
-/// snapshot fires so the state flip surfaces live.
+/// returns 200 with an empty body, whether or not anything was cancelled
+/// (Running / terminal / gone nodes are left alone). On a successful flip to
+/// Cancelled a fresh `RebuildQueueChanged` snapshot fires so the state flip
+/// surfaces live.
 #[utoipa::path(
     post,
     path = "/api/rebuild-queue/{id}/cancel",
     params(("id" = u64, Path, description = "job-queue node id (a DAG's root cancels the group)")),
-    responses((status = 200, description = "whether the DAG was cancelled", body = CancelResultBody)),
+    responses((status = 200, description = "request handled; an empty body, whether or not the node was cancelled")),
     tag = "rebuild_queue"
 )]
 pub(super) async fn post_rebuild_queue_cancel(
     State(state): State<AppState>,
     AxumPath(id): AxumPath<u64>,
-) -> Response {
+) -> StatusCode {
     if state.coord.job_queue.cancel(id) {
         // Any terminal side effect is the DAG's own spared tail node, which the
         // scheduler picks up on its next pass — nothing to fire from here.
         state.coord.emit_rebuild_queue_snapshot();
-        axum::Json(CancelResultBody { cancelled: true }).into_response()
-    } else {
-        axum::Json(CancelResultBody { cancelled: false }).into_response()
     }
+    StatusCode::OK
 }
diff --git a/hive-c0re/src/dashboard/state_snapshot.rs b/hive-c0re/src/dashboard/state_snapshot.rs
index 5fe0e52e7..3e3306f7f 100644
--- a/hive-c0re/src/dashboard/state_snapshot.rs
+++ b/hive-c0re/src/dashboard/state_snapshot.rs
@@ -24,14 +24,6 @@ use super::tombstones::{TombstoneView, build_tombstone_views};
 #[allow(clippy::struct_excessive_bools)]
 #[derive(Serialize)]
 pub(super) struct StateSnapshot {
-    /// Broker seq at the moment this snapshot was assembled. Clients
-    /// dedupe their buffered SSE traffic against this value: any
-    /// `MessageEvent` with `seq <= snapshot.seq` is already reflected in
-    /// the snapshot (or pre-dates it); anything with `seq > snapshot.seq`
-    /// is post-snapshot and should be applied. Set to 0 in the
-    /// pre-emit case (no events ever fired) — clients treat that as
-    /// "apply everything you've buffered".
-    seq: u64,
     hostname: String,
     /// Current rev of the pinned `hyperhive` flake input, resolved the
     /// same way `get_agent_meta`'s per-agent `hyperhive_rev` is (see
@@ -46,15 +38,6 @@ pub(super) struct StateSnapshot {
     /// survive after a destroy-without-purge. The operator can re-spawn
     /// with the same name to resume, or PURG3 to wipe them.
     tombstones: Vec<TombstoneView>,
-    /// Agents whose FNV-1a hashed web UI port collides with at least
-    /// one other. Operator resolves by renaming. The dashboard renders
-    /// a banner at the top listing each cluster.
-    port_conflicts: Vec<PortConflict>,
-
-    /// Whether the hive-forge container is up. When true the dashboard
-    /// links each container's config into the forge's `agent-configs`
-    /// repos.
-    forge_present: bool,
     /// Whether `hive-gateway` is in front of this dashboard. Sourced
     /// from the `HIVE_GATEWAY_ENABLED` env var, which the c0re NixOS
     /// module now always sets (the gateway runs unconditionally
@@ -89,13 +72,6 @@ pub(super) struct StateSnapshot {
     swarm_name: Option<String>,
 }
 
-#[derive(Serialize)]
-struct PortConflict {
-    port: u16,
-    /// All agent names sharing this port (sorted, ≥2 entries).
-    agents: Vec<String>,
-}
-
 #[derive(Serialize)]
 struct TransientView {
     name: String,
@@ -107,8 +83,7 @@ struct TransientView {
 /// Cold-load snapshot of the whole dashboard.
 ///
 /// Includes the roster, tombstones, job queue, and more. Live
-/// clients then follow `/api/dashboard/stream` (SSE) for incremental updates
-/// keyed off `seq`.
+/// clients then follow `/api/dashboard/stream` (SSE) for incremental updates.
 // `StateSnapshot` is a large tree of nested view types (`ContainerView`,
 // `TransientView`, ...) with no `ToSchema` anywhere in that
 // graph; wiring it up is a schema-modelling project of its own, well past
@@ -130,14 +105,6 @@ pub(super) async fn api_state(
         .unwrap_or("localhost");
     let hostname = host.split(':').next().unwrap_or(host).to_owned();
 
-    // Capture the unified dashboard-channel seq *before* any read so the
-    // dedupe contract is "events with seq > snapshot.seq are
-    // post-snapshot, never missed." An event landing during snapshot
-    // construction may be doubly applied (snapshot caught the write +
-    // client also applies the SSE frame) — that's a renderer's problem
-    // to make idempotent, not ours to avoid here.
-    let seq = state.coord.current_seq();
-
     // Refresh the coordinator's cached container snapshot before
     // reading. Cold-load clients then see whatever the latest rescan
     // produced; live clients converge via the matching
@@ -169,18 +136,14 @@ pub(super) async fn api_state(
     let transient_snapshot = state.coord.transient_snapshot();
     let transients = build_transient_views(&containers, &transient_snapshot);
     let tombstones = build_tombstone_views(&containers);
-    let port_conflicts = build_port_conflicts(&containers);
 
     axum::Json(StateSnapshot {
-        seq,
         hostname,
         hyperhive_rev: crate::auto_update::current_flake_rev(&state.coord.hyperhive_flake),
         containers,
         transients,
 
         tombstones,
-        port_conflicts,
-        forge_present: crate::forge::is_present().await,
         gateway_enabled: std::env::var_os("HIVE_GATEWAY_ENABLED").is_some_and(|v| {
             // Accept any truthy string ("1", "true", "yes"): the c0re
             // NixOS module sets the literal "1" (the gateway always runs
@@ -203,29 +166,6 @@ pub(super) async fn api_state(
     })
 }
 
-/// Group containers by their assigned web UI port; clusters with more
-/// than one member are port-hash collisions the operator resolves by
-/// renaming an agent.
-///
-/// Every container's port comes from [`crate::lifecycle::agent_web_port`],
-/// which hashes the name into one range for all of them — so the manager
-/// is a candidate for a collision exactly like any sub-agent.
-fn build_port_conflicts(containers: &[ContainerView]) -> Vec<PortConflict> {
-    let mut by_port: std::collections::BTreeMap<u16, Vec<String>> =
-        std::collections::BTreeMap::new();
-    for c in containers {
-        by_port.entry(c.port).or_default().push(c.name.clone());
-    }
-    by_port
-        .into_iter()
-        .filter(|(_, agents)| agents.len() > 1)
-        .map(|(port, mut agents)| {
-            agents.sort();
-            PortConflict { port, agents }
-        })
-        .collect()
-}
-
 /// Transient state for agents whose container does NOT yet exist
 /// (`Spawning`). Lifecycle ops on existing containers surface as
 /// `ContainerView.pending` inline; this list only catches pre-creation.
@@ -253,8 +193,7 @@ fn build_transient_views(
         .collect();
     // The caller rebuilds this map on every poll, so its iteration order
     // differs between renders and the rows would shuffle under an operator
-    // watching an operation run. Sorted for the same reason
-    // `build_port_conflicts` sorts its clusters.
+    // watching an operation run. Sorted so the order is stable.
     out.sort_by(|a, b| {
         a.name
             .cmp(&b.name)
@@ -355,7 +294,7 @@ pub(super) struct DashboardStreamQuery {
     params(DashboardStreamQuery),
     responses(
         (status = 200, description = "server-sent event stream; each event's \
-            `data` is a JSON-serialised `DashboardEvent` (seq-tagged)",
+            `data` is a JSON-serialised `DashboardEvent`",
             body = String, content_type = "text/event-stream"),
     ),
     tag = "state_snapshot"
@@ -378,8 +317,7 @@ pub(super) async fn dashboard_stream(
         if set.is_empty() { None } else { Some(set) }
     });
     let stream = BroadcastStream::new(rx).filter_map(move |res| {
-        // Drop lagged frames. Browsers reconnect; the seq dedupe on
-        // reconnect skips any frame already reflected in the snapshot.
+        // Drop lagged frames. Browsers reconnect and refetch the snapshot.
         let event = res.ok()?;
         if let Some(filter) = kind_filter.as_ref()
             && !filter.contains(event.kind_tag())
@@ -398,7 +336,7 @@ mod tests {
 
     use chrono::{Duration, Utc};
 
-    use super::{ContainerView, build_port_conflicts, build_transient_views};
+    use super::{ContainerView, build_transient_views};
     use crate::job_queue::RunningTransient;
 
     fn rt(agent: &str, label: &str, age_secs: i64) -> RunningTransient {
@@ -418,6 +356,18 @@ mod tests {
         m
     }
 
+    fn cv(name: &str, port: u16, running: bool) -> ContainerView {
+        ContainerView {
+            name: name.to_owned(),
+            container: format!("h-{name}"),
+            port,
+            running,
+            failed: false,
+            needs_login: false,
+            paused: false,
+        }
+    }
+
     #[test]
     fn an_agent_whose_container_exists_is_not_transient() {
         let snap = snapshot(vec![rt("alice", "spawn", 5)]);
@@ -471,92 +421,44 @@ mod tests {
         assert!(build_transient_views(&[], &snapshot(vec![])).is_empty());
     }
 
-    fn cv(name: &str, port: u16, running: bool) -> ContainerView {
-        ContainerView {
-            name: name.to_owned(),
-            container: format!("h-{name}"),
-            port,
-            running,
-            failed: false,
-            needs_login: false,
-            active_model: None,
-            status_text: None,
-            status_set_at: None,
-            paused: false,
-        }
-    }
-
+    /// The JSON object a cold-loading dashboard receives carries exactly these
+    /// keys; a field added back must be added here, with a reader.
     #[test]
-    fn distinct_ports_produce_no_conflicts() {
-        let cs = [cv("alice", 8101, true), cv("bob", 8102, true)];
-        assert!(build_port_conflicts(&cs).is_empty());
-    }
-
-    #[test]
-    fn a_lone_container_does_not_conflict_with_itself() {
-        assert!(build_port_conflicts(&[cv("alice", 8101, true)]).is_empty());
-    }
-
-    #[test]
-    fn two_agents_on_one_port_are_reported_together() {
-        let cs = [cv("alice", 8101, true), cv("bob", 8101, true)];
-        let got = build_port_conflicts(&cs);
-        assert_eq!(got.len(), 1);
-        assert_eq!(got[0].port, 8101);
-        assert_eq!(got[0].agents, ["alice", "bob"]);
-    }
-
-    /// The manager takes its port from the same hash as everyone else, so
-    /// it collides like any other name. A doc comment here used to claim it
-    /// sat at a fixed 8000 and could not — no such special case exists.
-    #[test]
-    fn the_manager_can_collide_with_a_sub_agent() {
-        let cs = [cv("manager", 8101, true), cv("alice", 8101, true)];
-        let got = build_port_conflicts(&cs);
-        assert_eq!(got.len(), 1);
-        assert_eq!(got[0].agents, ["alice", "manager"]);
-    }
-
-    /// A stopped agent keeps its hashed port, so the clash is real the
-    /// moment it starts. Reporting it while it is down is the point.
-    #[test]
-    fn a_stopped_container_still_claims_its_port() {
-        let cs = [cv("alice", 8101, true), cv("bob", 8101, false)];
-        assert_eq!(build_port_conflicts(&cs).len(), 1);
-    }
-
-    #[test]
-    fn names_are_sorted_within_a_conflict() {
-        let cs = [cv("zoe", 8101, true), cv("adam", 8101, true)];
-        assert_eq!(build_port_conflicts(&cs)[0].agents, ["adam", "zoe"]);
-    }
-
-    #[test]
-    fn more_than_two_agents_land_in_one_cluster() {
-        let cs = [
-            cv("c", 8101, true),
-            cv("a", 8101, true),
-            cv("b", 8101, true),
-        ];
-        let got = build_port_conflicts(&cs);
-        assert_eq!(got.len(), 1, "one cluster, not one row per pair");
-        assert_eq!(got[0].agents, ["a", "b", "c"]);
-    }
-
-    #[test]
-    fn separate_clusters_are_ordered_by_port() {
-        let cs = [
-            cv("d", 8300, true),
-            cv("c", 8300, true),
-            cv("b", 8200, true),
-            cv("a", 8200, true),
-        ];
-        let ports: Vec<u16> = build_port_conflicts(&cs).iter().map(|p| p.port).collect();
-        assert_eq!(ports, [8200, 8300]);
-    }
-
-    #[test]
-    fn no_containers_is_not_a_conflict() {
-        assert!(build_port_conflicts(&[]).is_empty());
+    fn the_state_snapshot_serialises_exactly_its_read_fields() {
+        let snap = super::StateSnapshot {
+            hostname: "h".to_owned(),
+            hyperhive_rev: None,
+            containers: Vec::new(),
+            transients: Vec::new(),
+            tombstones: Vec::new(),
+            gateway_enabled: true,
+            swarm_public_url: None,
+            authelia_public_url: None,
+            hive_name: None,
+            swarm_name: None,
+        };
+        let value = serde_json::to_value(&snap).unwrap();
+        let mut keys: Vec<&str> = value
+            .as_object()
+            .unwrap()
+            .keys()
+            .map(String::as_str)
+            .collect();
+        keys.sort_unstable();
+        assert_eq!(
+            keys,
+            [
+                "authelia_public_url",
+                "containers",
+                "gateway_enabled",
+                "hive_name",
+                "hostname",
+                "hyperhive_rev",
+                "swarm_name",
+                "swarm_public_url",
+                "tombstones",
+                "transients",
+            ]
+        );
     }
 }
diff --git a/hive-c0re/src/dashboard/tombstones.rs b/hive-c0re/src/dashboard/tombstones.rs
index a56f11b9f..376ba6eee 100644
--- a/hive-c0re/src/dashboard/tombstones.rs
+++ b/hive-c0re/src/dashboard/tombstones.rs
@@ -106,7 +106,6 @@ pub(crate) async fn emit_tombstones_snapshot(coord: &Arc<Coordinator>) {
     let containers = coord.containers_snapshot().await;
     let tombstones = build_tombstone_views(&containers);
     coord.emit_dashboard_event(crate::dashboard_events::DashboardEvent::TombstonesChanged {
-        seq: coord.next_seq(),
         tombstones,
     });
 }
diff --git a/hive-c0re/src/dashboard_events.rs b/hive-c0re/src/dashboard_events.rs
index 9218a8045..af896f3f9 100644
--- a/hive-c0re/src/dashboard_events.rs
+++ b/hive-c0re/src/dashboard_events.rs
@@ -1,7 +1,6 @@
 //! Unified dashboard event channel — all near-real-time browser events
-//! flow through `Coordinator.dashboard_events`. Each event carries a
-//! monotonic `seq` for client-side dedupe against `/api/state` snapshots.
-//! Design rationale (single channel, broker forwarder isolation):
+//! flow through `Coordinator.dashboard_events`. Design rationale
+//! (single channel, broker forwarder isolation):
 //! `docs/4-implementation/web-ui/shape.md::One unified channel`.
 
 use serde::Serialize;
@@ -15,7 +14,6 @@ use chrono::{DateTime, Utc};
 pub enum DashboardEvent {
     /// Broker `Sent` event mirrored onto the dashboard channel.
     Sent {
-        seq: u64,
         /// Broker row id. Allows the dashboard to track reply threads.
         id: i64,
         from: String,
@@ -27,7 +25,6 @@ pub enum DashboardEvent {
     },
     /// Broker `Delivered` event mirrored onto the dashboard channel.
     Delivered {
-        seq: u64,
         /// Broker row id. Allows the dashboard to track reply threads.
         id: i64,
         from: String,
@@ -43,7 +40,6 @@ pub enum DashboardEvent {
     /// locally from `since_unix` so a slow rebuild's elapsed time
     /// ticks without polling.
     TransientSet {
-        seq: u64,
         name: String,
         /// What the pill renders. For queue-driven work this is the running
         /// node's own wire tag (`"swap"`, `"create"`, `"stop_for_update"`, …) —
@@ -66,7 +62,6 @@ pub enum DashboardEvent {
     /// holding two open pills for one agent cannot tell which one cleared, and
     /// has to drop both or guess.
     TransientCleared {
-        seq: u64,
         name: String,
         transient_kind: String,
     },
@@ -81,21 +76,18 @@ pub enum DashboardEvent {
     /// last one cached on the coordinator. Mutation sites (lifecycle
     /// endpoints, `actions::destroy`, `crash_watch`'s poll loop)
     /// call the rescan after their work lands.
-    ContainerStateChanged { seq: u64, container: ContainerView },
+    ContainerStateChanged { container: ContainerView },
     /// A container that was in the previous snapshot is gone. Clients
     /// drop the row by name. Fired alongside any
     /// `nixos-container destroy` (operator-driven or otherwise) on the
     /// next rescan.
-    ContainerRemoved { seq: u64, name: String },
+    ContainerRemoved { name: String },
     /// Full snapshot of the tombstones list. Emitted by destroy (with
     /// or without purge) and purge-tombstone. Snapshot
     /// shape (not diff) because the list is tiny (single-digit
     /// typical) and recomputing avoids the add/remove races a
     /// per-row event would have.
-    TombstonesChanged {
-        seq: u64,
-        tombstones: Vec<TombstoneView>,
-    },
+    TombstonesChanged { tombstones: Vec<TombstoneView> },
 
     /// The job queue changed — **a bare trigger, no payload.**
     ///
@@ -110,7 +102,7 @@ pub enum DashboardEvent {
     /// push-on-change is what every other live surface here does
     /// (transients, container state), and a poll loop would be
     /// slower for the same information.
-    RebuildQueueChanged { seq: u64 },
+    RebuildQueueChanged,
 }
 
 impl DashboardEvent {
@@ -135,7 +127,7 @@ impl DashboardEvent {
             DashboardEvent::ContainerRemoved { .. } => "container_removed",
             DashboardEvent::TombstonesChanged { .. } => "tombstones_changed",
 
-            DashboardEvent::RebuildQueueChanged { .. } => "rebuild_queue_changed",
+            DashboardEvent::RebuildQueueChanged => "rebuild_queue_changed",
         }
     }
 }
@@ -163,7 +155,6 @@ mod tests {
     fn kind_tag_matches_serde_kind_field() {
         let samples: Vec<DashboardEvent> = vec![
             DashboardEvent::Sent {
-                seq: 1,
                 id: 1,
                 from: "a".into(),
                 to: "b".into(),
@@ -172,7 +163,6 @@ mod tests {
                 in_reply_to: None,
             },
             DashboardEvent::Delivered {
-                seq: 1,
                 id: 1,
                 from: "a".into(),
                 to: "b".into(),
@@ -181,25 +171,19 @@ mod tests {
                 in_reply_to: None,
             },
             DashboardEvent::TransientSet {
-                seq: 1,
                 name: "x".into(),
                 transient_kind: "rebuilding".into(),
                 since_unix: 0,
             },
             DashboardEvent::TransientCleared {
-                seq: 1,
                 name: "x".into(),
                 transient_kind: "rebuilding".into(),
             },
-            DashboardEvent::ContainerRemoved {
-                seq: 1,
-                name: "x".into(),
-            },
+            DashboardEvent::ContainerRemoved { name: "x".into() },
             DashboardEvent::TombstonesChanged {
-                seq: 1,
                 tombstones: Vec::new(),
             },
-            DashboardEvent::RebuildQueueChanged { seq: 1 },
+            DashboardEvent::RebuildQueueChanged,
         ];
         for ev in samples {
             let v: serde_json::Value = serde_json::to_value(&ev).expect("serialise");
@@ -210,4 +194,40 @@ mod tests {
             assert_eq!(ev.kind_tag(), serde_kind, "kind_tag() drift on {ev:?}");
         }
     }
+
+    /// Every frame is its `kind` tag plus the variant's own fields, nothing else.
+    #[test]
+    fn frames_carry_no_sequence_number() {
+        let removed = serde_json::to_value(DashboardEvent::ContainerRemoved { name: "x".into() })
+            .expect("serialise");
+        let mut keys: Vec<&str> = removed
+            .as_object()
+            .unwrap()
+            .keys()
+            .map(String::as_str)
+            .collect();
+        keys.sort_unstable();
+        assert_eq!(keys, ["kind", "name"]);
+
+        let transient = serde_json::to_value(DashboardEvent::TransientSet {
+            name: "x".into(),
+            transient_kind: "rebuilding".into(),
+            since_unix: 0,
+        })
+        .expect("serialise");
+        let mut keys: Vec<&str> = transient
+            .as_object()
+            .unwrap()
+            .keys()
+            .map(String::as_str)
+            .collect();
+        keys.sort_unstable();
+        assert_eq!(keys, ["kind", "name", "since_unix", "transient_kind"]);
+
+        let trigger = serde_json::to_value(DashboardEvent::RebuildQueueChanged).expect("serialise");
+        assert_eq!(
+            trigger,
+            serde_json::json!({ "kind": "rebuild_queue_changed" })
+        );
+    }
 }
diff --git a/hive-c0re/src/forge/mod.rs b/hive-c0re/src/forge/mod.rs
index d3fc0c6b7..9f0f6b2d3 100644
--- a/hive-c0re/src/forge/mod.rs
+++ b/hive-c0re/src/forge/mod.rs
@@ -13,8 +13,6 @@ use std::sync::OnceLock;
 use anyhow::{Context, Result};
 use url::Url;
 
-const FORGE_CONTAINER: &str = "hive-forge";
-
 /// Base HTTP URL for the local Forgejo instance, from `HIVE_FORGE_URL`
 /// (set unconditionally by the hyperhive NixOS module on the `hive-c0re`
 /// unit, to `http://<forge.domain>`).
@@ -83,17 +81,6 @@ fn basic_auth_header(login: &str, token: &str) -> String {
     format!("Authorization: Basic {basic}")
 }
 
-/// Probe whether `hive-forge` exists as a nixos-container. Cheap —
-/// `nixos-container list` is just a directory scan in /etc. Routed
-/// through hive-priv: `nixos-container` needs root, and hive-c0re runs
-/// unprivileged (privsep).
-pub async fn is_present() -> bool {
-    let Ok(stdout) = crate::priv_client::list_containers().await else {
-        return false;
-    };
-    stdout.lines().any(|l| l.trim() == FORGE_CONTAINER)
-}
-
 #[cfg(test)]
 mod tests {
     use super::git_url_with_base;
diff --git a/hive-c0re/src/main.rs b/hive-c0re/src/main.rs
index 669c7e07d..59ff2eb76 100644
--- a/hive-c0re/src/main.rs
+++ b/hive-c0re/src/main.rs
@@ -374,9 +374,8 @@ async fn cmd_serve(
         });
     }
     // Forward every broker event onto the unified dashboard
-    // channel with a freshly-stamped seq, so the dashboard SSE
-    // sees broker messages + future mutation events on one
-    // stream with one monotonic seq. The broker's intra-process
+    // channel, so the dashboard SSE sees broker messages and
+    // mutation events on one stream. The broker's intra-process
     // channel (used by `recv_blocking_batch`) stays untouched.
     spawn_broker_to_dashboard_forwarder(coord.clone());
     let dash_coord = coord.clone();
@@ -409,7 +408,7 @@ async fn cmd_serve(
 }
 
 /// Re-emit every broker `MessageEvent` onto the dashboard channel as
-/// a `DashboardEvent::Sent` / `Delivered` with a freshly-stamped seq.
+/// a `DashboardEvent::Sent` / `Delivered`.
 /// Background task; runs for the life of the process. On a lagged
 /// broker subscription we just keep going — the dashboard channel is
 /// best-effort presentation plumbing, the broker keeps its own sqlite
@@ -430,7 +429,6 @@ fn spawn_broker_to_dashboard_forwarder(coord: Arc<Coordinator>) {
                     in_reply_to,
                 }) => {
                     coord.emit_dashboard_event(DashboardEvent::Sent {
-                        seq: coord.next_seq(),
                         id,
                         from,
                         to,
@@ -448,7 +446,6 @@ fn spawn_broker_to_dashboard_forwarder(coord: Arc<Coordinator>) {
                     in_reply_to,
                 }) => {
                     coord.emit_dashboard_event(DashboardEvent::Delivered {
-                        seq: coord.next_seq(),
                         id,
                         from,
                         to,
diff --git a/hive-c0re/src/stats/host_stats.rs b/hive-c0re/src/stats/host_stats.rs
index bb47db51b..20929726c 100644
--- a/hive-c0re/src/stats/host_stats.rs
+++ b/hive-c0re/src/stats/host_stats.rs
@@ -343,9 +343,6 @@ mod tests {
             running: true,
             failed: false,
             needs_login,
-            active_model: None,
-            status_text: None,
-            status_set_at: None,
             paused: false,
         }
     }
diff --git a/hive-c0re/src/stores/broker.rs b/hive-c0re/src/stores/broker.rs
index 4cb402218..445ff91ea 100644
--- a/hive-c0re/src/stores/broker.rs
+++ b/hive-c0re/src/stores/broker.rs
@@ -54,9 +54,7 @@ pub struct Delivery {
 
 /// Intra-process broker event. `recv_blocking_batch` listens on the
 /// same channel as the dashboard forwarder; the forwarder re-emits
-/// each event as a `DashboardEvent` with a freshly-stamped seq from
-/// the Coordinator. The broker itself doesn't stamp seqs — that's a
-/// wire concern, not a storage concern.
+/// each event as a `DashboardEvent`.
 #[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "snake_case", tag = "kind")]
 pub enum MessageEvent {
diff --git a/hive-jobq-wire/Cargo.toml b/hive-jobq-wire/Cargo.toml
index eeda67f30..173a3d13e 100644
--- a/hive-jobq-wire/Cargo.toml
+++ b/hive-jobq-wire/Cargo.toml
@@ -8,8 +8,6 @@ readme = "README.md"
 workspace = true
 
 [dependencies]
-chrono = { workspace = true }
-enumflags2 = { workspace = true }
 hive-jobq = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
diff --git a/hive-jobq-wire/src/lib.rs b/hive-jobq-wire/src/lib.rs
index efe093192..5b5878f74 100644
--- a/hive-jobq-wire/src/lib.rs
+++ b/hive-jobq-wire/src/lib.rs
@@ -27,9 +27,7 @@
 //!
 //! [`Node`]: hive_jobq::Node
 
-use chrono::{DateTime, Utc};
-use enumflags2::BitFlags;
-use hive_jobq::{Dep, Graph, NodeId, State, TerminalState};
+use hive_jobq::{Dep, Graph, NodeId, State};
 use serde::{Deserialize, Serialize};
 use utoipa::ToSchema;
 
@@ -73,30 +71,6 @@ impl StateSchema {
     }
 }
 
-/// `OpenAPI` mirror of [`hive_jobq::TerminalState`] — same rationale and same
-/// exhaustive-match guard as [`StateSchema`].
-#[derive(Debug, Clone, Copy, ToSchema)]
-pub enum TerminalStateSchema {
-    Done,
-    Failed,
-    Cancelled,
-    Skipped,
-}
-
-impl TerminalStateSchema {
-    /// The mirror variant for `outcome`. Public for the same reason as
-    /// [`StateSchema::of`].
-    #[must_use]
-    pub fn of(outcome: TerminalState) -> Self {
-        match outcome {
-            TerminalState::Done => Self::Done,
-            TerminalState::Failed => Self::Failed,
-            TerminalState::Cancelled => Self::Cancelled,
-            TerminalState::Skipped => Self::Skipped,
-        }
-    }
-}
-
 /// Node id, carried verbatim from [`hive_jobq::NodeId`]: globally unique across
 /// the whole graph, not per group. Opaque to consumers — they group by
 /// [`GraphNode::parent`] and match dependency edges, nothing more.
@@ -152,16 +126,6 @@ pub struct GraphNode {
     /// What must hold before this node runs. Omitted when empty.
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub deps: Vec<GraphDep>,
-    /// When the node was inserted into the graph. Always present — a node that
-    /// exists was created, so unlike the two below this is not an `Option`.
-    pub created_at: DateTime<Utc>,
-    /// When the node entered `Running`. `None` until it starts; a node that
-    /// never ran keeps `None`.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub started_at: Option<DateTime<Utc>>,
-    /// When the node reached a terminal state. `None` while non-terminal.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub finished_at: Option<DateTime<Utc>>,
     /// Failure reason, set only when this node's *own* logic failed — a node
     /// that rolled up `Failed` from a child carries none of its own.
     #[serde(default, skip_serializing_if = "Option::is_none")]
@@ -237,18 +201,6 @@ pub enum GraphDep {
         /// The node depended on. May name a node the consumer has not been sent
         /// (a filtered view); treat an absent target as satisfied.
         id: WireId,
-        /// **The outcomes that satisfy this edge, as a set** — not a
-        /// strong/weak flag.
-        ///
-        /// A host routinely emits several tails edged on the *same* upstream
-        /// node, distinguished only by which outcomes each accepts (one for
-        /// `Done`, one for `Failed`/`Cancelled`, …). Collapsing this to a
-        /// boolean renders those as identical nodes.
-        ///
-        /// Every accepted outcome is **named**, so a client never shifts bits
-        /// to read an edge.
-        #[schema(value_type = Vec<TerminalStateSchema>)]
-        accepts: Vec<TerminalState>,
     },
     /// Need `count` units of a named resource, per [`WireResource::name`].
     Resource { name: String, count: u32 },
@@ -401,9 +353,6 @@ fn wire_node<N: WireNode, R: WireResource>(node: &hive_jobq::Node<N, R>) -> Grap
         parent: node.parent.map(NodeId::get),
         state: node.state,
         deps: node.deps.iter().map(wire_dep).collect(),
-        created_at: node.created_at,
-        started_at: node.started_at,
-        finished_at: node.finished_at,
         error: node.error.clone(),
         payload: NodePayload {
             label: node.payload.label(),
@@ -414,17 +363,7 @@ fn wire_node<N: WireNode, R: WireResource>(node: &hive_jobq::Node<N, R>) -> Grap
 
 fn wire_dep<R: WireResource>(dep: &Dep<R>) -> GraphDep {
     match dep {
-        Dep::Node { id, when } => GraphDep::Node {
-            id: id.get(),
-            // Every outcome the type knows about, not a hand-listed set: a
-            // variant added to `TerminalState` is then named on the wire
-            // automatically, where a literal array would have silently
-            // dropped it from every edge that accepts it.
-            accepts: BitFlags::<TerminalState>::ALL
-                .iter()
-                .filter(|outcome| when.accepts(*outcome))
-                .collect(),
-        },
+        Dep::Node { id, .. } => GraphDep::Node { id: id.get() },
         Dep::Resource { name, count } => GraphDep::Resource {
             name: name.name(),
             count: *count,
@@ -439,9 +378,8 @@ mod tests {
     use hive_jobq::scheduler::Scheduler;
 
     use super::{
-        ALL_STATES, BitFlags, GraphDep, GraphNode, GraphWire, NodePayload, State, StateSchema,
-        TerminalState, TerminalStateSchema, WireId, WireNode, filter_nodes_by_state, parse_states,
-        state_rollup,
+        ALL_STATES, GraphDep, GraphNode, GraphWire, NodePayload, State, StateSchema, WireId,
+        WireNode, filter_nodes_by_state, parse_states, state_rollup,
     };
 
     /// The mirrors document what the wire actually says — a mirror that
@@ -473,16 +411,6 @@ mod tests {
                 "{state:?} is documented as {documented} but serialises as {on_the_wire}"
             );
         }
-
-        for outcome in BitFlags::<TerminalState>::ALL {
-            let on_the_wire = serde_json::to_string(&outcome).expect("serialises");
-            let documented = format!("{:?}", TerminalStateSchema::of(outcome));
-            assert_eq!(
-                on_the_wire,
-                format!("\"{documented}\""),
-                "{outcome:?} is documented as {documented} but serialises as {on_the_wire}"
-            );
-        }
     }
 
     /// A scheduler over the test payloads, built through the same public API a
@@ -573,12 +501,8 @@ mod tests {
         assert_eq!(wire[0].payload.label, "reconcile");
         assert_eq!(wire[0].payload.data["seen_id"], first.get());
         match &wire[1].deps[..] {
-            [
-                GraphDep::Node { id, accepts },
-                GraphDep::Resource { name, count },
-            ] => {
+            [GraphDep::Node { id }, GraphDep::Resource { name, count }] => {
                 assert_eq!(*id, first.get());
-                assert_eq!(accepts, &vec![TerminalState::Done]);
                 assert_eq!(name, "build-slot", "the host's WireResource::name");
                 assert_eq!(*count, 2);
             }
@@ -592,9 +516,6 @@ mod tests {
             parent,
             state,
             deps,
-            created_at: chrono::DateTime::<chrono::Utc>::default(),
-            started_at: None,
-            finished_at: None,
             error: None,
             payload: NodePayload {
                 label: "reconcile".to_owned(),
@@ -610,10 +531,7 @@ mod tests {
             Some(3),
             State::Running,
             vec![
-                GraphDep::Node {
-                    id: 3,
-                    accepts: vec![TerminalState::Done],
-                },
+                GraphDep::Node { id: 3 },
                 GraphDep::Resource {
                     name: "build-slot".to_owned(),
                     count: 1,
@@ -625,34 +543,27 @@ mod tests {
         assert_eq!(format!("{after:?}"), format!("{before:?}"));
     }
 
+    /// The serialised node carries exactly these keys (`parent`, `deps` and
+    /// `error` are omitted when empty, `payload.data` when null).
     #[test]
-    fn two_tails_on_one_upstream_are_distinguishable_by_their_accepted_set() {
-        // The reason `accepts` is a set and not a strong/weak bool: these two
-        // are the same shape and the same upstream, and *only* the outcome
-        // set tells them apart.
-        let ok_tail = node(
-            10,
-            None,
-            State::Pending,
-            vec![GraphDep::Node {
-                id: 4,
-                accepts: vec![TerminalState::Done],
-            }],
-        );
-        let fail_tail = node(
-            11,
-            None,
-            State::Pending,
-            vec![GraphDep::Node {
-                id: 4,
-                accepts: vec![TerminalState::Failed, TerminalState::Cancelled],
-            }],
-        );
-        let render = |n: &GraphNode| match n.deps.first() {
-            Some(GraphDep::Node { accepts, .. }) => format!("{accepts:?}"),
-            _ => "none".to_owned(),
+    fn a_node_serialises_exactly_its_read_fields() {
+        let full = GraphNode {
+            error: Some("boom".to_owned()),
+            ..node(7, Some(3), State::Failed, vec![GraphDep::Node { id: 3 }])
         };
-        assert_ne!(render(&ok_tail), render(&fail_tail));
+        let value = serde_json::to_value(&full).expect("serialises");
+        let mut keys: Vec<&str> = value
+            .as_object()
+            .unwrap()
+            .keys()
+            .map(String::as_str)
+            .collect();
+        keys.sort_unstable();
+        assert_eq!(keys, ["deps", "error", "id", "parent", "payload", "state"]);
+        assert_eq!(
+            value["deps"][0],
+            serde_json::json!({ "kind": "Node", "id": 3 })
+        );
     }
 
     #[test]
diff --git a/hive-sh4re/src/container.rs b/hive-sh4re/src/container.rs
index 300c640ac..3cc3c8c34 100644
--- a/hive-sh4re/src/container.rs
+++ b/hive-sh4re/src/container.rs
@@ -2,7 +2,6 @@
 //! returns, plus the per-account matrix identity shape surfaced by
 //! `GetAgentMeta`.
 
-use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 
 /// One row in a `HostRequest::AgentStatus` result — the operator-CLI
@@ -46,24 +45,6 @@ pub struct AgentStatusRow {
     /// paused while stopped, and pause survives a restart.
     #[serde(default)]
     pub paused: bool,
-    /// The Claude model the agent's harness is currently using. Mirrors
-    /// `container_view::ContainerView::active_model`: `None` when the
-    /// agent has never started a turn, the field is absent from its
-    /// harness state file, or the container isn't running.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub active_model: Option<String>,
-    /// The agent's current free-text status, set via the `set_status`
-    /// tool. `None` when unset or the container isn't running — a
-    /// stopped agent's on-disk status is a stale snapshot from before
-    /// the stop (same rule `container_view::read_agent_status_live`
-    /// applies for every other reader of this data).
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub status_text: Option<String>,
-    /// When `status_text` was last set, RFC 3339 UTC on the wire (see
-    /// `hive_sh4re::wire_time`). `None` exactly when `status_text` is
-    /// `None`.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub status_set_at: Option<DateTime<Utc>>,
     /// This agent's own web UI, behind the gateway
     /// (`https://<dashboard-domain>/agent/<name>/`) — the same URL the operator
     /// dashboard's "open" action uses. `None` when the dashboard's domain isn't
@@ -93,3 +74,42 @@ pub struct MatrixIdentity {
     /// Homeserver base URL this account is on.
     pub homeserver: String,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::AgentStatusRow;
+
+    /// The roster row carries exactly these keys; a field added back needs a reader.
+    #[test]
+    fn the_agent_status_row_serialises_exactly_its_fields() {
+        let row = AgentStatusRow {
+            name: "alice".to_owned(),
+            running: true,
+            failed: false,
+            needs_login: false,
+            pending_reminders: 0,
+            paused: false,
+            url: Some("https://example.invalid/agent/alice/".to_owned()),
+        };
+        let value = serde_json::to_value(&row).unwrap();
+        let mut keys: Vec<&str> = value
+            .as_object()
+            .unwrap()
+            .keys()
+            .map(String::as_str)
+            .collect();
+        keys.sort_unstable();
+        assert_eq!(
+            keys,
+            [
+                "failed",
+                "name",
+                "needs_login",
+                "paused",
+                "pending_reminders",
+                "running",
+                "url"
+            ]
+        );
+    }
+}
diff --git a/hivectl/src/dag_progress.rs b/hivectl/src/dag_progress.rs
index 4a07695a9..2c2050672 100644
--- a/hivectl/src/dag_progress.rs
+++ b/hivectl/src/dag_progress.rs
@@ -124,8 +124,7 @@ async fn wait_for_nodes_plain(socket: &Path, ids: Vec<u64>) -> Result<()> {
 }
 
 /// TTY progress: a live `indicatif` render — one braille-spinner line per
-/// node (grouped under a per-root header), each with its own elapsed
-/// timer, plus an overall-elapsed footer. A node with more than one
+/// node (grouped under a per-root header), plus an overall-elapsed footer. A node with more than one
 /// dependency (fan-in) gets its own row with an `(after …)` marker rather
 /// than being crammed onto a chain line.
 async fn wait_for_nodes_animated(socket: &Path, ids: Vec<u64>) -> Result<()> {
@@ -149,7 +148,6 @@ async fn wait_for_nodes_animated(socket: &Path, ids: Vec<u64>) -> Result<()> {
     let mut failed: Vec<String> = Vec::new();
 
     while !pending.is_empty() {
-        let now = now_unix();
         let batch: Vec<u64> = pending.iter().copied().collect();
         let resp = crate::client::request(
             socket,
@@ -173,11 +171,10 @@ async fn wait_for_nodes_animated(socket: &Path, ids: Vec<u64>) -> Result<()> {
                 b
             });
             hdr.set_message(format!(
-                "{} {} {} · {}",
+                "{} {} {}",
                 state_glyph(root.state),
                 root.payload.label,
                 node_agents(nodes),
-                fmt_dur(node_elapsed(root, now)),
             ));
             for n in nodes.iter().filter(|n| n.id != root.id) {
                 let key = (id, n.id);
@@ -195,11 +192,11 @@ async fn wait_for_nodes_animated(socket: &Path, ids: Vec<u64>) -> Result<()> {
                     bar.finish_with_message(format!(
                         "  {} {}",
                         state_glyph(n.state),
-                        node_line(nodes, n, now)
+                        node_line(nodes, n)
                     ));
                     node_done.insert(key);
                 } else {
-                    bar.set_message(node_line(nodes, n, now));
+                    bar.set_message(node_line(nodes, n));
                 }
             }
             if root.state.is_terminal() {
@@ -257,24 +254,6 @@ fn node_agents(nodes: &[GraphNode]) -> String {
     seen.join(",")
 }
 
-/// Current unix time in seconds (0 on the impossible pre-epoch error).
-fn now_unix() -> i64 {
-    std::time::SystemTime::now()
-        .duration_since(std::time::UNIX_EPOCH)
-        .ok()
-        .and_then(|d| i64::try_from(d.as_secs()).ok())
-        .unwrap_or(0)
-}
-
-/// Elapsed seconds for a node: `started_at` → `finished_at`/`now` once
-/// it's run; `created_at` → `now` while it's still queued. `GraphNode`
-/// carries no group-level timestamp separate from its own, so a header
-/// line just reads this off whichever node it's summarizing.
-fn node_elapsed(n: &GraphNode, now: i64) -> i64 {
-    let start = n.started_at.unwrap_or(n.created_at);
-    (n.finished_at.map_or(now, |t| t.timestamp()) - start.timestamp()).max(0)
-}
-
 /// Compact duration: `45s` under a minute, else `1m03s`.
 fn fmt_dur(secs: i64) -> String {
     let s = secs.max(0);
@@ -286,11 +265,11 @@ fn fmt_dur(secs: i64) -> String {
 }
 
 /// One animated node line: kind, an `(after …)` marker for a fan-in node
-/// (>1 node-dependency), its elapsed timer, and a truncated error tail.
+/// (>1 node-dependency), and a truncated error tail.
 /// Resource deps (`GraphDep::Resource`) don't name another node, so they're
 /// filtered out of the fan-in count the same way `hive-c0re`'s own
 /// `dag_view` projection already does.
-fn node_line(nodes: &[GraphNode], n: &GraphNode, now: i64) -> String {
+fn node_line(nodes: &[GraphNode], n: &GraphNode) -> String {
     use std::fmt::Write as _;
     let mut s = n.payload.label.clone();
     let dep_ids: Vec<WireId> = n
@@ -311,10 +290,6 @@ fn node_line(nodes: &[GraphNode], n: &GraphNode, now: i64) -> String {
             let _ = write!(s, " (after {})", after.join(", "));
         }
     }
-    let el = node_elapsed(n, now);
-    if el > 0 {
-        let _ = write!(s, " · {}", fmt_dur(el));
-    }
     if let Some(err) = &n.error {
         let short: String = err.chars().take(100).collect();
         let _ = write!(s, " — {short}");
@@ -381,9 +356,6 @@ mod tests {
             parent: None,
             state,
             deps: Vec::new(),
-            created_at: hive_sh4re::wire_time::from_secs(0),
-            started_at: None,
-            finished_at: None,
             error: None,
             payload: NodePayload {
                 label: label.to_owned(),
@@ -398,9 +370,6 @@ mod tests {
             parent: Some(root),
             state,
             deps: Vec::new(),
-            created_at: hive_sh4re::wire_time::from_secs(0),
-            started_at: None,
-            finished_at: None,
             error: None,
             payload: NodePayload {
                 label: label.to_owned(),