diff --git a/docs/4-implementation/agent-state/persistence.md b/docs/4-implementation/agent-state/persistence.md
index 59af116c3..0f7b1f3e5 100644
--- a/docs/4-implementation/agent-state/persistence.md
+++ b/docs/4-implementation/agent-state/persistence.md
@@ -152,13 +152,12 @@ Capturing the full stream (rather than a short tail buffer) matters
 because real eval errors routinely run long — "tried alternatives"
 blocks alone are often 30+ lines — so a truncated tail would cut off
 the actual failure and leave only the host journal holding the
-complete output. With this table the dashboard can surface the entire
-log.
+complete output. This table holds the entire log; no HTTP route serves
+it.
 
 Three indices:
 
-- `(agent, started_at)` — backs the per-agent latest-N lookup used
-  by the agent card chip.
+- `(agent, started_at)` — per-agent lookup by recency.
 - `(status, finished_at)` — backs the retention sweep that runs
   as part of the existing hourly vacuum.
 - `(node_id)` — added by a later migration so a build log row can be
diff --git a/docs/4-implementation/agent-state/roster.md b/docs/4-implementation/agent-state/roster.md
index 347ed0e8e..1329b4b97 100644
--- a/docs/4-implementation/agent-state/roster.md
+++ b/docs/4-implementation/agent-state/roster.md
@@ -101,10 +101,8 @@ state dirs work as for every other agent.
 - **Wire-protocol** — `hive-core-agent-sock`'s unified `Request` enum
   is the same on both socket flavours. Container lifecycle
   ops (kill/start/restart/rebuild) go through the separate host-admin
-  socket `hivectl` speaks. `Wake` (inject a `from: <X>` message straight
-  into the caller's own inbox) is on this socket too, unprivileged on
-  both flavours; matrix, bash and forge don't call it — their
-  notifications push a todo on the harness's in-agent socket (see
+  socket `hivectl` speaks. Matrix, bash and forge wake the agent by pushing a todo on the
+  harness's in-agent socket (see
   [`docs/4-implementation/turn-loop/mcp.md`](../turn-loop/mcp.md#waking-the-agent-from-inside-the-container)).
 - **Storage/mounts** — the `manage_root_agent` permission, which the
   [`ruth` archetype](../../2-handbook/swarm/archetypes.md#the-built-in-archetypes) grants, gets a container
diff --git a/docs/4-implementation/agent-tools/forge-notify.md b/docs/4-implementation/agent-tools/forge-notify.md
index b428cfce6..a0ec0d323 100644
--- a/docs/4-implementation/agent-tools/forge-notify.md
+++ b/docs/4-implementation/agent-tools/forge-notify.md
@@ -8,9 +8,8 @@ Its own long-running per-agent daemon (`hive-forge-notify`, a sibling of
 `hive-bash-daemon` / `hive-matrix-daemon`) — it used
 to be a background task inside the `hive-agent` serve loop. Polls
 `GET /api/v1/notifications?all=false` every 30 seconds (Forgejo's
-unread-only filter), formats each notification as a broker
-`Wake { from: "forge" }` message, and delivers it to the agent's own
-inbox so claude's normal turn loop picks it up.
+unread-only filter), formats each notification as a todo and pushes it to the agent's own
+in-agent socket so claude's normal turn loop picks it up.
 
 The daemon waits about ten minutes for the agent's forge token, then exits 0,
 which its `Restart=on-failure` doesn't restart. A path unit
diff --git a/docs/4-implementation/networking/gateway.md b/docs/4-implementation/networking/gateway.md
index 5d6554260..9601a10e0 100644
--- a/docs/4-implementation/networking/gateway.md
+++ b/docs/4-implementation/networking/gateway.md
@@ -276,7 +276,7 @@ Solution: an `nginx http`-context `map $http_accept $matrix_spa_target { ... }`
 
 hive-c0re serves exactly two prefixes, so the dashboard routes by **path** — deterministic, where a content-type split would let one URL resolve differently by the caller's `Accept` header:
 
-- `location /api/` → hive-c0re (`7000`): all dashboard data, actions, and the two SSE streams (`/api/dashboard/stream`, `/api/build-logs/id/{id}/stream`). `proxy_buffering off` and a 1d read timeout keep the streams live.
+- `location /api/` → hive-c0re (`7000`): all dashboard data, actions, and the SSE stream (`/api/dashboard/stream`). `proxy_buffering off` and a 1d read timeout keep the stream live.
 - `location /health/` → hive-c0re: liveness and readiness.
 - `location /` → the dashboard dist (from the `servedFrontend` nix-store path) with `try_files $uri /index.html`.
 
diff --git a/docs/4-implementation/turn-loop/claude-invocation.md b/docs/4-implementation/turn-loop/claude-invocation.md
index e27ae53ff..231968fc9 100644
--- a/docs/4-implementation/turn-loop/claude-invocation.md
+++ b/docs/4-implementation/turn-loop/claude-invocation.md
@@ -172,12 +172,12 @@ best-effort — a failed checkpoint or `/compact` never fails the turn that
 already succeeded. An ACP agent gets the same policy; how it compacts is in
 [`hive-runtime/README.md`](../../../hive-runtime/README.md#acp-backend-compaction).
 
-The operator can force a compaction any time via `POST /api/compact`. It's
-**deferred**: the handler sets `Bus::request_compact()` and returns
+The agent can force a compaction via its `compact` MCP tool. It's
+**deferred**: the tool sets `Bus::request_compact()` and returns
 immediately; the harness runs the `/compact` at the next turn boundary
 (end of the in-flight turn in `drive_turn`, or — when the agent is idle —
 in `turn::run_pending_compact` on the serve loop's next empty poll). This
-lets `/api/compact` work mid-turn instead of only when idle, without racing
+lets the request work mid-turn instead of only when idle, without racing
 a live claude process.
 
 To disable proactive compaction for a specific agent, use the nix option:
diff --git a/docs/4-implementation/turn-loop/mcp.md b/docs/4-implementation/turn-loop/mcp.md
index 97f578a3f..ded65a9db 100644
--- a/docs/4-implementation/turn-loop/mcp.md
+++ b/docs/4-implementation/turn-loop/mcp.md
@@ -102,12 +102,12 @@ hive_name?, swarm_name?, matrix_accounts? }`. `matrix_accounts` is a
   `{state_dir}/hyperhive-status`. Pass `""` to clear. Not gated by the
   `meta` group — every agent needs to keep its dashboard status chip
   current regardless of which optional groups it holds.
-- `compact` — agent self-service equivalent of the operator dashboard's
-  `/compact` button. No args. Gated server-side on the last completed
+- `compact` — queues a compaction of the current session; the only way to
+  request one. No args. Gated server-side on the last completed
   turn's context usage: refused (with an explanation, no side effect)
   unless usage is above 66% of the effective context window. On a
-  pass, queues the same deferred `compact_pending` flag the dashboard
-  button sets — consumed at the end of the current turn, so it never
+  pass, queues the deferred `compact_pending` flag — consumed at the end
+  of the current turn, so it never
   races a live claude process, and the usual pre-compaction
   notes-checkpoint turn still fires first. Dispatched through the
   in-agent socket (`hive-agent-sock::Request::Compact`), not the
@@ -159,15 +159,6 @@ makes the harness signal its own turn loop, with no hive-c0re
 round-trip. An external MCP server (or any other in-container process)
 can push its own todo the same way — `subsystem` is any string.
 
-The host-served per-agent socket at `/run/hive/mcp.sock` carries a
-lower-level `Wake` request (`hive_core_agent_sock::Request::Wake {
-from, body }` — JSON-line, `{"cmd":"wake","from":"matrix","body":"new dm
-from @alice"}\n`) that drops the body straight into the broker inbox as
-`{from:<label>, to:<agent>, body}`, bypassing the todo layer entirely.
-`hive-c0re` handles it; matrix, bash and forge don't call it. Identity = socket: anything that can connect to
-`/run/hive/mcp.sock` is implicitly trusted to inject one — the
-bind-mount is the agent's own container only.
-
 ## Authoritative state
 
 `hive-agent`'s `events::Bus` carries the current turn-loop state in
@@ -175,7 +166,7 @@ addition to the broadcast channel and the events history. Variants:
 
 - `Idle` — sitting on `Recv` waiting for mail.
 - `Thinking` — `claude --print` is running for a turn.
-- `Compacting` — operator-triggered `/compact` is in flight.
+- `Compacting` — a `/compact` is in flight.
 
 The harness flips state at the relevant transitions
 (`set_state(Thinking)` before `drive_turn`, `set_state(Idle)`
diff --git a/docs/4-implementation/web-ui/agent-page.md b/docs/4-implementation/web-ui/agent-page.md
index 7b93b4df9..cf3b83252 100644
--- a/docs/4-implementation/web-ui/agent-page.md
+++ b/docs/4-implementation/web-ui/agent-page.md
@@ -233,20 +233,19 @@ The state badge's menu carries the actions on the agent's claude:
   credential files, parks the agent in `needs_login`, and preserves
   session history (`~/.claude/projects/`).
 
-`POST /api/compact` sets the deferred `Bus::request_compact()` flag and
+The agent's `compact` MCP tool sets the deferred `Bus::request_compact()` flag and
 returns immediately. The harness runs the `/compact` at the next turn
 boundary (end of the in-flight turn, or `turn::run_pending_compact` when
 idle); output streams into the live panel, which ends with a `/compact done`
-or `/compact failed: …` note. It works mid-turn, not only when idle. Nothing
-on this page calls it now.
+or `/compact failed: …` note. It works mid-turn, not only when idle.
 
 ## Per-agent endpoints
 
 Successful POSTs return 200 (no 303 redirects). Error responses
 use semantic status codes: **400** for missing/malformed input
 (`/api/todos/mark-done` with no todo ids), **500** only for genuine
-server/transport failures. `/compact` never conflicts: it queues
-and runs at the end of the current turn. The matching
+server/transport failures. A queued `/compact` never conflicts: it
+runs at the end of the current turn. The matching
 mutations fire `LiveEvent` variants on the per-agent bus, so the
 client doesn't refetch `/api/state` on submit — the SSE stream
 delivers the new state faster anyway.
@@ -257,11 +256,6 @@ credentials arrive from the swarm secret store.
 
 - `POST /api/cancel` — SIGINT the in-flight claude turn and the
   commands it started. Emits a `LiveEvent::Note`.
-- `POST /api/compact` — run `/compact` on the persistent session
-  (same MCP config + system prompt + allowed tools as a normal
-  turn — only the stdin payload differs). Flips state to
-  `Compacting` via `Bus::set_state`, which emits
-  `TurnStateChanged`.
 - `POST /api/new-session` — arm a one-shot for the next turn to
   drop `--continue`. Emits a `LiveEvent::Note`.
 - `POST /api/logout` — three-step teardown that re-uses the
diff --git a/docs/4-implementation/web-ui/dashboard.md b/docs/4-implementation/web-ui/dashboard.md
index 81420e75f..53d2ed9fb 100644
--- a/docs/4-implementation/web-ui/dashboard.md
+++ b/docs/4-implementation/web-ui/dashboard.md
@@ -69,7 +69,7 @@ conflicting agent.
 
 Passive / rare-interaction state. `kept.js` renders it from the
 `/api/state` snapshot and keeps it live from the `tombstones_changed`
-stream event. (The rebuild queue and build logs are dashboard tabs too —
+stream event. (The rebuild queue is a dashboard tab too —
 see below.)
 
 Per-container CPU, memory and disk load isn't shown in the hive UI. The
@@ -433,27 +433,6 @@ below — some endpoints aren't in it yet.
   not yet delivered and sets `acked_at = now`. Returns
   `{ "marked": N }`. Agent name validated against
   `[a-z0-9_-]`, 1-63 chars; 400 on bad input.
-- `GET /api/build-logs?limit=N` — most-recent build log headers across
-  all agents (`limit` defaults to 30).
-- `GET /api/build-log/{node_id}` and `/api/build-log/{node_id}/raw` — the
-  build log of one job-queue node, as JSON and as `text/plain`.
-- `GET /api/build-logs/{agent}?limit=N` — most-recent build log
-  headers for one agent, newest first. Returns
-  `Vec<BuildLogHeader>` (JSON): `id`, `agent`, `kind`, `cmdline`,
-  `started_at`, `finished_at`, `status` (`"ok"` / `"fail"` /
-  `null` while in-progress). `limit` defaults to 10, server-side
-  cap at 50. Agent name validated (`[a-z0-9_-]`, 1-63 chars).
-- `GET /api/build-logs/id/{id}` — full build log by id. Returns
-  `BuildLogFull` (JSON): all header fields plus `stdout` and
-  `stderr` as plain text (newline-terminated lines, utf-8). HTTP
-  404 when the row is missing (vacuum-reaped or stale id).
-- `GET /api/build-logs/id/{id}/stream` — live SSE stream of
-  stdout+stderr for an in-progress build (newline-delimited JSON
-  frames). The
-  stream closes when the build finishes or errors.
-- `GET /api/build-logs/id/{id}/raw` — raw concatenated
-  stdout+stderr as `text/plain`. Works on both finished and in-progress
-  build logs.
 
 - `GET /api/dashboard/stream` — unified live event channel:
   broker `sent` / `delivered`, plus the mutation events listed
diff --git a/docs/5-project/process/conventions.md b/docs/5-project/process/conventions.md
index a24a3be56..ed890a5ed 100644
--- a/docs/5-project/process/conventions.md
+++ b/docs/5-project/process/conventions.md
@@ -66,24 +66,17 @@ No auth tokens exist on the per-agent unix sockets. The socket
 bind-mount." A sub-agent only sees its own `/run/hive/mcp.sock`;
 hive-c0re owns the host admin socket.
 
-### Wake injection
-
-`hive_core_agent_sock::Request::Wake { from, body }` is the
-wake-event-injection surface on the host-served per-agent socket.
-Recipient is implicit — the agent the socket belongs to — and `from`
-is caller-chosen so the wake prompt can label the source verbatim
-(`"matrix: new message in #general"`, `"forge: PR #42 opened"`, etc.). <!-- lint:allow: example strings, not real tags -->
-`hive-c0re` handles it; matrix, bash and forge don't call it — their
-notifications upsert a todo on the harness's in-agent socket
-(`HIVE_AGENT_SOCKET`), which signals the same turn loop without a
+Matrix, bash and forge wake the agent by upserting a todo on the harness's
+in-agent socket (`HIVE_AGENT_SOCKET`), which signals the turn loop without a
 hive-c0re round-trip. See
 [`docs/4-implementation/turn-loop/mcp.md` § Waking the agent from inside the
 container](../../4-implementation/turn-loop/mcp.md#waking-the-agent-from-inside-the-container).
+The host-served `/run/hive/mcp.sock` has no verb that injects a message into
+the agent's own inbox.
 
-Identity = socket means anything that can connect to
-`/run/hive/mcp.sock` is implicitly trusted to inject wakes. That's
-fine: the bind-mount only exposes the socket inside the agent's own
-container, so the trust boundary is the container's process
+Anything that can connect to `/run/hive/mcp.sock` is implicitly trusted to
+call its verbs. That's fine: the bind-mount only exposes the socket inside the
+agent's own container, so the trust boundary is the container's process
 namespace, not the wire surface.
 
 ## Recipient sentinels
diff --git a/frontend/packages/agent/src/Root.tsx b/frontend/packages/agent/src/Root.tsx
index 50e6a9077..55f888c26 100644
--- a/frontend/packages/agent/src/Root.tsx
+++ b/frontend/packages/agent/src/Root.tsx
@@ -59,7 +59,7 @@ const STATE_TOOLTIPS: Record<string, string> = {
   offline: "harness unreachable or claude not logged in",
   idle: "turn loop running, no claude invocation in flight",
   thinking: "claude is executing the current turn",
-  compacting: "operator-triggered /compact running on the persistent session",
+  compacting: "agent-requested /compact running on the persistent session",
 };
 
 // `total` here matches app.js's `renderOneUsage` exactly: input + both
diff --git a/hive-agent-sock/src/lib.rs b/hive-agent-sock/src/lib.rs
index 4fe5ad897..5a3cd9ed4 100644
--- a/hive-agent-sock/src/lib.rs
+++ b/hive-agent-sock/src/lib.rs
@@ -123,11 +123,11 @@ pub enum Request {
     /// `ReminderRollup` against the broker; now served from the local store).
     ReminderRollup { since_secs: u64 },
     /// Agent self-service request to compact the current session, mirroring
-    /// the operator's `/compact` dashboard button. Gated server-side: only
+    /// the `compact` MCP tool. Gated server-side: only
     /// honoured when the last completed turn's context usage is above 66%
     /// of the effective context window — below that, `Response::Err`
     /// explains why and takes no action. On a pass, queues the same
-    /// deferred `compact_pending` flag the operator's button sets (consumed
+    /// deferred `compact_pending` flag (consumed
     /// at the next turn boundary), so it never races a live claude process.
     /// `wake_prompt`, when set, is driven as a synthetic follow-up turn once
     /// the compaction actually finishes — the dashboard button's own
diff --git a/hive-agent/src/events.rs b/hive-agent/src/events.rs
index 0f0c50774..c32ba8980 100644
--- a/hive-agent/src/events.rs
+++ b/hive-agent/src/events.rs
@@ -251,8 +251,7 @@ pub enum TurnState {
     Idle,
     /// `claude --print` is running for a turn.
     Thinking,
-    /// Operator-triggered `/compact` is running on the persistent
-    /// session.
+    /// A `/compact` is running on the persistent session.
     Compacting,
 }
 
@@ -316,9 +315,8 @@ pub struct Bus {
     /// boundary keeps compaction from racing a live claude process mid-turn.
     /// `Some(request)` when a compact is pending; `request.wake_prompt` is
     /// what to drive as a synthetic follow-up turn once the compaction
-    /// actually completes (`None` = pending but no follow-up wake wanted,
-    /// e.g. the operator dashboard's `/compact` button). `None` = no compact
-    /// pending. Wrapped in [`CompactRequest`] rather than
+    /// actually completes (`None` = pending but no follow-up wake wanted). `None` = no
+    /// compact pending. Wrapped in [`CompactRequest`] rather than
     /// `Option<Option<String>>` (clippy pedantic's `option_option` lint,
     /// and the named field reads clearer at call sites than a bare nested
     /// `Option`) so "pending" and "what to wake with" can never desync.
@@ -491,8 +489,7 @@ impl Bus {
     /// serviced just overwrites `wake_prompt` with the latest ask. `Some
     /// (wake_prompt)` schedules a synthetic follow-up turn (driven with
     /// `wake_prompt` as its body) once the compaction actually completes;
-    /// `None` requests a plain compact with no follow-up wake (the operator
-    /// dashboard's `/compact` button).
+    /// `None` requests a plain compact with no follow-up wake.
     pub fn request_compact(&self, wake_prompt: Option<String>) {
         *self.compact_pending.lock().unwrap() = Some(CompactRequest { wake_prompt });
     }
diff --git a/hive-agent/src/todo_server.rs b/hive-agent/src/todo_server.rs
index c70a139c0..3982f75a9 100644
--- a/hive-agent/src/todo_server.rs
+++ b/hive-agent/src/todo_server.rs
@@ -11,9 +11,8 @@
 //! reminder op then returns `Response::Err`); a reminder *firing* is a
 //! separate path (`reminder_timer`), not driven through this socket.
 //! `Request::Compact` is the odd one out — it doesn't touch any store, just
-//! the harness's [`Bus`] (gate-checked context usage, then the same
-//! deferred `compact_pending` flag the operator dashboard's `/compact`
-//! button sets). No hive-c0re round-trip, no broker long-poll, no marker
+//! the harness's [`Bus`] (gate-checked context usage, then the deferred
+//! `compact_pending` flag). No hive-c0re round-trip, no broker long-poll, no marker
 //! files.
 //!
 //! One request/response line per connection, matching the producers'
@@ -39,8 +38,7 @@ use crate::todos::{Todo, Todos};
 /// Context-usage floor for `Request::Compact`: below this fraction of the
 /// effective context window, an agent-initiated compact is refused (nothing
 /// meaningful to reclaim yet, and it'd just burn a compaction pass on a
-/// near-empty session). Same number a human operator would eyeball off the
-/// dashboard's `ctx·Nk` badge before hitting the `/compact` button.
+/// near-empty session).
 const COMPACT_MIN_USAGE_FRACTION: f64 = 0.66;
 
 /// Pause after a failed `accept`, so a failure that persists (fd exhaustion)
@@ -434,13 +432,10 @@ fn mark_todos_done(store: &Todos, ids: &[i64]) -> Response {
     }
 }
 
-/// `Request::Compact` handler: gate on context usage, then queue the same
-/// deferred `compact_pending` flag the operator's `/compact` button sets.
-/// Mirrors `hive-agent::web_ui::actions::post_compact` but reachable from
-/// the agent's own MCP tool instead of the dashboard, and refuses below
-/// [`COMPACT_MIN_USAGE_FRACTION`] instead of always honouring the request —
-/// an agent can call this speculatively, a human clicking the dashboard
-/// button already made the judgment call. `wake_prompt`, when set, is
+/// `Request::Compact` handler: gate on context usage, then queue the
+/// deferred `compact_pending` flag. Refuses below
+/// [`COMPACT_MIN_USAGE_FRACTION`] because an agent can call this
+/// speculatively. `wake_prompt`, when set, is
 /// forwarded to `Bus::request_compact` so the turn loop drives a synthetic
 /// follow-up turn once the compaction actually finishes.
 fn compact(bus: &Bus, wake_prompt: Option<String>) -> Response {
diff --git a/hive-agent/src/turn.rs b/hive-agent/src/turn.rs
index 7f3ce9b73..1163551ec 100644
--- a/hive-agent/src/turn.rs
+++ b/hive-agent/src/turn.rs
@@ -92,7 +92,7 @@ and end the turn.";
 /// passed here — they live at `/etc/claude-code/managed-settings.json`
 /// and claude auto-discovers them.
 /// Materialised at harness startup; shared between the turn loop and the
-/// operator-driven `/compact` path so both invocations look identical to
+/// `/compact` path so both invocations look identical to
 /// claude (same MCP surface, same allowed tools, same role prompt — only the
 /// stdin payload differs). The MCP config is rewritten before each
 /// invocation ([`TurnFiles::refresh_mcp_config`]), since which servers it
@@ -161,7 +161,7 @@ pub async fn write_system_prompt(socket: &Path, label: &str) -> Result<PathBuf>
 /// One claude turn's outcome: `Ok(compacted)` on success, or a [`TurnError`]
 /// the serve loop must act on. The `compacted` bool is `true` when a
 /// compaction ran this turn (reactively on overflow, or proactively per the
-/// policy — or a successful operator `/compact` at turn end); it's recorded as
+/// policy — or a successful agent-requested `/compact` at turn end); it's recorded as
 /// `result_kind = "compacted"` in turn stats so the stats page can distinguish
 /// those turns. Both `Ok(true)` and `Ok(false)` are ack'd; the error cases
 /// each map to a distinct serve-loop action (see [`emit_turn_end`] and the
@@ -452,8 +452,7 @@ pub async fn drive_turn(
         archive_session(bus, session);
         return Err(TurnError::PromptTooLong);
     }
-    // Operator `/compact` (`POST /api/compact`) or an agent's own `compact`
-    // MCP tool call, deferred to the turn boundary: run it now that the turn
+    // An agent's own `compact` MCP tool call, deferred to the turn boundary: run it now that the turn
     // is done, so it works mid-turn rather than only when the agent is idle.
     // Only on a healthy turn — no point spawning a compaction after a
     // rate-limited / auth-failed / crashed one. `is_ok()` first: `take_compact()`
@@ -485,7 +484,7 @@ pub async fn drive_turn(
 }
 
 /// Emit the `/compact done` / `/compact failed: …` note for a finished
-/// operator or agent `/compact` and return whether it succeeded. Shared by the
+/// agent-requested `/compact` and return whether it succeeded. Shared by the
 /// turn-end path in [`drive_turn`] and the idle path in [`run_pending_compact`].
 fn report_compact<E: std::fmt::Display>(bus: &Bus, result: Result<(), E>) -> bool {
     match result {
@@ -620,7 +619,7 @@ pub fn emit_turn_end(bus: &Bus, outcome: &TurnOutcome) {
     }
 }
 
-/// Service a pending operator `/compact` (`Bus::request_compact`) while the
+/// Service a pending `/compact` (`Bus::request_compact`) while the
 /// agent is idle — the serve loop calls this when a `recv` returns no message,
 /// so a queued `/compact` runs even when no turn is driving. (The in-flight
 /// case is handled at the end of [`drive_turn`].) Resume-only via
diff --git a/hive-agent/src/web_ui/actions.rs b/hive-agent/src/web_ui/actions.rs
index 8aa5daef5..553a15fd8 100644
--- a/hive-agent/src/web_ui/actions.rs
+++ b/hive-agent/src/web_ui/actions.rs
@@ -1,4 +1,4 @@
-//! Operator action POST handlers (cancel, compact, reset, todos mark-done).
+//! Operator action POST handlers (cancel, reset, todos mark-done).
 
 use axum::{
     Form,
@@ -16,22 +16,6 @@ pub(super) async fn post_cancel_turn(State(state): State<AppState>) -> Response
     (axum::http::StatusCode::OK, "ok").into_response()
 }
 
-/// Operator-initiated `/compact`. Deferred: sets the `compact_pending` flag
-/// that `turn::drive_turn` consumes at the end of the current/next turn, so it
-/// works while a turn is in flight (a mid-turn compaction would race the live
-/// claude process) rather than only when the agent is idle. Returns 200
-/// immediately; the compaction stream lands in the live panel when it runs.
-pub(super) async fn post_compact(State(state): State<AppState>) -> Response {
-    // No wake prompt: the operator is watching the dashboard, not waiting on
-    // an inbox message — `request_compact`'s wake-prompt arg exists for the
-    // agent's own `compact` MCP tool (`todo_server.rs::compact`).
-    state.bus.request_compact(None);
-    state.bus.emit(crate::events::LiveEvent::Note {
-        text: "operator: /compact queued — runs at the end of the current turn".into(),
-    });
-    (axum::http::StatusCode::OK, "ok").into_response()
-}
-
 /// Request a session reset. The current session is archived (its backing
 /// `<uuid>.jsonl` renamed out of claude's resolution glob) at the next turn
 /// boundary, so the following turn's `--resume` misses and self-heals into a
diff --git a/hive-agent/src/web_ui/mod.rs b/hive-agent/src/web_ui/mod.rs
index 486ecb879..156098cff 100644
--- a/hive-agent/src/web_ui/mod.rs
+++ b/hive-agent/src/web_ui/mod.rs
@@ -76,7 +76,6 @@ fn routes() -> Router<AppState> {
         .route("/events/stream", get(stream::events_stream))
         .route("/events/history", get(stream::events_history))
         .route("/api/cancel", post(actions::post_cancel_turn))
-        .route("/api/compact", post(actions::post_compact))
         .route("/api/new-session", post(actions::post_new_session))
         .route("/api/logout", post(auth::post_logout))
         .route("/api/todos", get(stats::api_todos))
@@ -532,7 +531,7 @@ mod tests {
     /// either.
     #[test]
     fn neither_model_nor_effort_has_a_route() {
-        let (model, effort, compact) = crate::paths::with_harness_dir(|| {
+        let (model, effort, existing) = crate::paths::with_harness_dir(|| {
             let state = AppState {
                 label: "test".to_owned(),
                 login: Arc::new(Mutex::new(LoginState::Online)),
@@ -550,17 +549,17 @@ mod tests {
                     let effort = app.clone().oneshot(form("/api/effort", "effort=high"));
                     // A route the router does serve, so the 404s above are not
                     // the router refusing everything.
-                    let compact = app.oneshot(form("/api/compact", ""));
+                    let existing = app.oneshot(form("/api/new-session", ""));
                     (
                         model.await.unwrap(),
                         effort.await.unwrap(),
-                        compact.await.unwrap(),
+                        existing.await.unwrap(),
                     )
                 })
         });
         assert_eq!(model.status(), StatusCode::NOT_FOUND);
         assert_eq!(effort.status(), StatusCode::NOT_FOUND);
-        assert_eq!(compact.status(), StatusCode::OK);
+        assert_eq!(existing.status(), StatusCode::OK);
     }
 
     /// Poll `path` until it holds a complete, newline-terminated pid.
diff --git a/hive-c0re/src/coordinator.rs b/hive-c0re/src/coordinator.rs
index cc53be05b..22d199e2e 100644
--- a/hive-c0re/src/coordinator.rs
+++ b/hive-c0re/src/coordinator.rs
@@ -25,9 +25,7 @@ pub struct Coordinator {
     pub broker: Arc<Broker>,
     /// Full build-log capture. `lifecycle::run` `start()`s a row per attempt,
     /// pipes every stdout/stderr line into it, and `finish()`es it on
-    /// child exit. Dashboard reads it via `list_recent_for_agent` /
-    /// `get_full` for the per-card chip + side-panel viewer. See
-    /// `build_logs.rs` for retention.
+    /// child exit. See `build_logs.rs` for retention.
     pub build_logs: Arc<crate::build_logs::BuildLogs>,
     /// Store path of the hyperhive flake source (no fragment). Used to
     /// identify the running revision (`current_flake_rev`).
@@ -1061,7 +1059,7 @@ mod open_tests {
 
         let coord = open(&db);
         let row = coord.build_logs.get_full(id).expect("get").expect("Some");
-        assert_eq!(row.header.status.as_deref(), Some("fail"));
-        assert!(row.header.finished_at.is_some());
+        assert_eq!(row.status.as_deref(), Some("fail"));
+        assert!(row.finished_at.is_some());
     }
 }
diff --git a/hive-c0re/src/dashboard/build_logs.rs b/hive-c0re/src/dashboard/build_logs.rs
deleted file mode 100644
index f202060fa..000000000
--- a/hive-c0re/src/dashboard/build_logs.rs
+++ /dev/null
@@ -1,365 +0,0 @@
-//! Build-log endpoints for the dashboard.
-//!
-//! Header lists (all-agents + per-agent), the full row by id, a `text/plain`
-//! download, and an SSE stream that delivers incremental stdout/stderr while
-//! a build runs (closing once it finishes or the row is vacuum-reaped).
-
-use std::convert::Infallible;
-
-use axum::{
-    extract::{Path as AxumPath, State},
-    http::StatusCode,
-    response::{
-        IntoResponse, Response,
-        sse::{Event, KeepAlive, Sse},
-    },
-};
-use serde::{Deserialize, Serialize};
-use tokio_stream::Stream;
-use tokio_stream::wrappers::ReceiverStream;
-use utoipa::IntoParams;
-
-use super::{AppState, Ident, error_response};
-use crate::build_logs::{BuildLogFull, BuildLogHeader};
-
-#[derive(Deserialize, IntoParams)]
-pub(super) struct BuildLogsAllQuery {
-    /// Max rows to return. Capped at 100. Default 30.
-    #[serde(default)]
-    limit: Option<usize>,
-}
-
-/// Most-recent build log headers across
-/// all agents, newest first.
-///
-/// Same JSON shape as the per-agent endpoint.
-#[utoipa::path(
-    get,
-    path = "/api/build-logs",
-    params(BuildLogsAllQuery),
-    responses(
-        (status = 200, description = "recent build log headers, newest first", body = Vec<BuildLogHeader>),
-        (status = 500, description = "sqlite read failed"),
-    ),
-    tag = "build_logs"
-)]
-pub(super) async fn get_build_logs_all(
-    State(state): State<AppState>,
-    axum::extract::Query(q): axum::extract::Query<BuildLogsAllQuery>,
-) -> Response {
-    let limit = q.limit.unwrap_or(30);
-    match state.coord.build_logs.list_recent_all(limit) {
-        Ok(rows) => axum::Json(rows).into_response(),
-        Err(e) => error_response(&format!("build-logs all: {e:#}")),
-    }
-}
-
-#[derive(Deserialize, IntoParams)]
-pub(super) struct BuildLogsQuery {
-    /// Maximum number of rows to return. Capped server-side at 50
-    /// (see `build_logs::list_recent_for_agent`). Default 10.
-    #[serde(default)]
-    limit: Option<usize>,
-}
-
-/// Most-recent build log
-/// headers for one agent, newest first.
-///
-/// Returns `Vec<BuildLogHeader>` (JSON). Backs the per-agent log chip
-/// in the agent card and the side-panel header list.
-#[utoipa::path(
-    get,
-    path = "/api/build-logs/{agent}",
-    params(
-        ("agent" = String, Path, description = "agent name"),
-        BuildLogsQuery,
-    ),
-    responses(
-        (status = 200, description = "recent build log headers for the agent, newest first", body = Vec<BuildLogHeader>),
-        (status = 400, description = "bad agent name"),
-        (status = 500, description = "sqlite read failed"),
-    ),
-    tag = "build_logs"
-)]
-pub(super) async fn get_build_logs_agent(
-    State(state): State<AppState>,
-    AxumPath(name): AxumPath<String>,
-    axum::extract::Query(q): axum::extract::Query<BuildLogsQuery>,
-) -> Response {
-    let name = match Ident::parse(&name) {
-        Ok(n) => n,
-        Err(reason) => {
-            return (StatusCode::BAD_REQUEST, format!("bad agent name: {reason}")).into_response();
-        }
-    };
-    let limit = q.limit.unwrap_or(10);
-    match state
-        .coord
-        .build_logs
-        .list_recent_for_agent(name.as_str(), limit)
-    {
-        Ok(rows) => axum::Json(rows).into_response(),
-        Err(e) => error_response(&format!("build-logs {name}: {e:#}")),
-    }
-}
-
-/// Full build log row (stdout +
-/// stderr concatenated) by id.
-///
-/// Returns `BuildLogFull` (JSON), or HTTP 404 when the id doesn't
-/// exist (vacuum-reaped, or the operator passed a stale id from a
-/// refresh race).
-#[utoipa::path(
-    get,
-    path = "/api/build-logs/id/{id}",
-    params(("id" = i64, Path, description = "build log row id")),
-    responses(
-        (status = 200, description = "full build log row", body = BuildLogFull),
-        (status = 404, description = "no such build log row"),
-        (status = 500, description = "sqlite read failed"),
-    ),
-    tag = "build_logs"
-)]
-pub(super) async fn get_build_log_full(
-    State(state): State<AppState>,
-    AxumPath(id): AxumPath<i64>,
-) -> Response {
-    match state.coord.build_logs.get_full(id) {
-        Ok(Some(log)) => axum::Json(log).into_response(),
-        Ok(None) => (StatusCode::NOT_FOUND, format!("build log #{id} not found")).into_response(),
-        Err(e) => error_response(&format!("build-log {id}: {e:#}")),
-    }
-}
-
-/// The build log for a **queue node**,
-/// resolved node id → log-row id → full log.
-///
-/// Same `BuildLogFull` JSON (`stdout` / `stderr` + header) as
-/// `get_build_log_full`; HTTP 404 when the node has no linked log (the
-/// client gates the request on the wire node's `build_log_id`, but a vacuum
-/// race can still 404). This is the on-demand live-log-panel fetch,
-/// distinct from the `build_log_id` on the wire — that id is for
-/// deep-linking to the BUILD L0GS tab's full history view, not for
-/// fetching the log content itself.
-#[utoipa::path(
-    get,
-    path = "/api/build-log/{node_id}",
-    params(("node_id" = u64, Path, description = "job-queue node id")),
-    responses(
-        (status = 200, description = "full build log row for the node's linked log", body = BuildLogFull),
-        (status = 404, description = "node has no linked build log, or the log row is gone"),
-        (status = 500, description = "sqlite read failed"),
-    ),
-    tag = "build_logs"
-)]
-pub(super) async fn get_build_log_for_node(
-    State(state): State<AppState>,
-    AxumPath(node_id): AxumPath<u64>,
-) -> Response {
-    match state.coord.build_logs.id_for_node(node_id) {
-        Some(log_id) => get_build_log_full(State(state), AxumPath(log_id)).await,
-        None => (
-            StatusCode::NOT_FOUND,
-            format!("node #{node_id} has no build log"),
-        )
-            .into_response(),
-    }
-}
-
-/// The node's build log as `text/plain`
-/// for download (delegates to `get_build_log_raw` after resolving the node id).
-#[utoipa::path(
-    get,
-    path = "/api/build-log/{node_id}/raw",
-    params(("node_id" = u64, Path, description = "job-queue node id")),
-    responses(
-        (status = 200, description = "build log text for download", body = String, content_type = "text/plain"),
-        (status = 404, description = "node has no linked build log, or the log row is gone"),
-        (status = 500, description = "sqlite read failed"),
-    ),
-    tag = "build_logs"
-)]
-pub(super) async fn get_build_log_raw_for_node(
-    State(state): State<AppState>,
-    AxumPath(node_id): AxumPath<u64>,
-) -> Response {
-    match state.coord.build_logs.id_for_node(node_id) {
-        Some(log_id) => get_build_log_raw(State(state), AxumPath(log_id)).await,
-        None => (
-            StatusCode::NOT_FOUND,
-            format!("node #{node_id} has no build log"),
-        )
-            .into_response(),
-    }
-}
-
-/// JSON frame sent on the `/api/build-logs/id/{id}/stream` SSE channel.
-/// `stdout_append` / `stderr_append` carry only the new bytes since the
-/// last frame; `done = true` means the build finished and the stream
-/// will close after this frame.
-#[derive(Serialize)]
-struct BuildLogFrame {
-    stdout_append: String,
-    stderr_append: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    status: Option<String>,
-    done: bool,
-}
-
-/// SSE stream that delivers
-/// incremental stdout/stderr as a build runs.
-///
-/// The client connects when it opens a running-build panel; the
-/// stream closes automatically once the build finishes (or the row
-/// disappears due to a vacuum). Each frame is a JSON-serialised
-/// `BuildLogFrame`. The first frame always carries the full
-/// accumulated log so far (cursors start at 0); subsequent frames
-/// carry only new bytes. `done: true` on the final frame signals the
-/// browser to close the `EventSource`.
-#[utoipa::path(
-    get,
-    path = "/api/build-logs/id/{id}/stream",
-    params(("id" = i64, Path, description = "build log row id")),
-    responses(
-        (status = 200, description = "server-sent event stream; each event's \
-            `data` is a JSON-serialised `BuildLogFrame` \
-            (stdout_append/stderr_append/status/done)",
-            body = String, content_type = "text/event-stream"),
-    ),
-    tag = "build_logs"
-)]
-pub(super) async fn get_build_log_stream(
-    State(state): State<AppState>,
-    AxumPath(id): AxumPath<i64>,
-) -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
-    let (tx, rx) = tokio::sync::mpsc::channel::<Result<Event, Infallible>>(32);
-    let logs = state.coord.build_logs.clone();
-
-    tokio::spawn(async move {
-        let mut notify_rx = logs.subscribe_notifications();
-        let mut stdout_cursor = 0usize;
-        let mut stderr_cursor = 0usize;
-
-        // ── initial snapshot ──────────────────────────────────────────
-        match logs.get_progress(id, stdout_cursor, stderr_cursor) {
-            Ok(Some(prog)) => {
-                stdout_cursor += prog.stdout_append.len();
-                stderr_cursor += prog.stderr_append.len();
-                let done = prog.finished_at.is_some();
-                if let Ok(json) = serde_json::to_string(&BuildLogFrame {
-                    stdout_append: prog.stdout_append,
-                    stderr_append: prog.stderr_append,
-                    status: prog.status,
-                    done,
-                }) {
-                    let _ = tx.send(Ok(Event::default().data(json))).await;
-                }
-                if done {
-                    return;
-                }
-            }
-            Ok(None) => {
-                // Row missing — send a single error event and exit.
-                let _ = tx
-                    .send(Ok(Event::default()
-                        .event("error")
-                        .data(format!("build log #{id} not found"))))
-                    .await;
-                return;
-            }
-            Err(e) => {
-                let _ = tx
-                    .send(Ok(Event::default()
-                        .event("error")
-                        .data(format!("build log #{id}: {e:#}"))))
-                    .await;
-                return;
-            }
-        }
-
-        // ── live delta loop ───────────────────────────────────────────
-        loop {
-            match notify_rx.recv().await {
-                // Notification for a different build — ignore and wait
-                // for the next one.
-                Ok(notif_id) if notif_id != id => {}
-                Ok(_) => {
-                    match logs.get_progress(id, stdout_cursor, stderr_cursor) {
-                        Ok(Some(prog)) => {
-                            stdout_cursor += prog.stdout_append.len();
-                            stderr_cursor += prog.stderr_append.len();
-                            let done = prog.finished_at.is_some();
-                            if let Ok(json) = serde_json::to_string(&BuildLogFrame {
-                                stdout_append: prog.stdout_append,
-                                stderr_append: prog.stderr_append,
-                                status: prog.status,
-                                done,
-                            }) && tx.send(Ok(Event::default().data(json))).await.is_err()
-                            {
-                                return; // browser disconnected
-                            }
-                            if done {
-                                return;
-                            }
-                        }
-                        Ok(None) | Err(_) => return, // vacuum reaped row / channel closed
-                    }
-                }
-                Err(tokio::sync::broadcast::error::RecvError::Lagged(_)) => {}
-                Err(tokio::sync::broadcast::error::RecvError::Closed) => return,
-            }
-        }
-    });
-
-    Sse::new(ReceiverStream::new(rx)).keep_alive(KeepAlive::default())
-}
-
-/// Full log as `text/plain` for
-/// download.
-///
-/// Stdout and stderr are concatenated with a `--- stderr ---`
-/// separator (same layout the JS side-panel renders). The
-/// `Content-Disposition` header triggers a browser download with a
-/// descriptive filename so the operator can save and share the log.
-#[utoipa::path(
-    get,
-    path = "/api/build-logs/id/{id}/raw",
-    params(("id" = i64, Path, description = "build log row id")),
-    responses(
-        (status = 200, description = "build log text for download", body = String, content_type = "text/plain"),
-        (status = 404, description = "no such build log row"),
-        (status = 500, description = "sqlite read failed"),
-    ),
-    tag = "build_logs"
-)]
-pub(super) async fn get_build_log_raw(
-    State(state): State<AppState>,
-    AxumPath(id): AxumPath<i64>,
-) -> Response {
-    match state.coord.build_logs.get_full(id) {
-        Ok(Some(log)) => {
-            let mut text = log.stdout;
-            if !log.stderr.is_empty() {
-                text.push_str("\n--- stderr ---\n");
-                text.push_str(&log.stderr);
-            }
-            (
-                StatusCode::OK,
-                [
-                    ("content-type", "text/plain; charset=utf-8".to_string()),
-                    (
-                        "content-disposition",
-                        format!(
-                            "attachment; filename=\"build-log-{}-{}.txt\"",
-                            log.header.agent, id
-                        ),
-                    ),
-                ],
-                text,
-            )
-                .into_response()
-        }
-        Ok(None) => (StatusCode::NOT_FOUND, format!("build log #{id} not found")).into_response(),
-        Err(e) => error_response(&format!("build-log {id}: {e:#}")),
-    }
-}
diff --git a/hive-c0re/src/dashboard/mod.rs b/hive-c0re/src/dashboard/mod.rs
index d1985961a..e6a1333e2 100644
--- a/hive-c0re/src/dashboard/mod.rs
+++ b/hive-c0re/src/dashboard/mod.rs
@@ -35,7 +35,6 @@ use crate::lifecycle;
     ),
     tags(
         (name = "health", description = "hive-wide liveness/readiness probes"),
-        (name = "build_logs", description = "build log headers, full rows, and raw text downloads"),
         (name = "lifecycle_ops", description = "agent container lifecycle: rebuild/restart/start/stop/pause/limits"),
 
         (name = "misc_api", description = "mark-all-read, compose, spawn-request"),
@@ -46,7 +45,6 @@ use crate::lifecycle;
 )]
 struct ApiDoc;
 
-mod build_logs;
 // The single validated identifier type — homed in `hive-host-sock` (the crate
 // owning agent-path facts) so every dashboard path-param validates through the
 // same type used to build agent paths. Re-exported so submodules + the socket
@@ -104,12 +102,6 @@ fn app(coord: Arc<Coordinator>) -> axum::Router {
         .routes(routes!(health::get_health_ready))
         .routes(routes!(state_snapshot::api_state))
         .routes(routes!(misc_api::post_mark_all_read))
-        .routes(routes!(build_logs::get_build_logs_all))
-        .routes(routes!(build_logs::get_build_log_for_node))
-        .routes(routes!(build_logs::get_build_log_raw_for_node))
-        .routes(routes!(build_logs::get_build_logs_agent))
-        .routes(routes!(build_logs::get_build_log_full))
-        .routes(routes!(build_logs::get_build_log_raw))
         .routes(routes!(rebuild_queue::post_rebuild_queue_cancel))
         .routes(routes!(lifecycle_ops::post_destroy))
         .routes(routes!(lifecycle_ops::post_kill))
@@ -119,7 +111,6 @@ fn app(coord: Arc<Coordinator>) -> axum::Router {
         .routes(routes!(lifecycle_ops::post_pause))
         .routes(routes!(lifecycle_ops::post_resume))
         .routes(routes!(tombstones::post_purge_tombstone))
-        .routes(routes!(build_logs::get_build_log_stream))
         .routes(routes!(state_snapshot::dashboard_stream))
         .routes(routes!(state_snapshot::jobq_graph))
         .routes(routes!(state_snapshot::jobq_rollup))
@@ -351,12 +342,6 @@ mod router_build_probe {
             .routes(routes!(health::get_health_ready))
             .routes(routes!(state_snapshot::api_state))
             .routes(routes!(misc_api::post_mark_all_read))
-            .routes(routes!(build_logs::get_build_logs_all))
-            .routes(routes!(build_logs::get_build_log_for_node))
-            .routes(routes!(build_logs::get_build_log_raw_for_node))
-            .routes(routes!(build_logs::get_build_logs_agent))
-            .routes(routes!(build_logs::get_build_log_full))
-            .routes(routes!(build_logs::get_build_log_raw))
             .routes(routes!(rebuild_queue::post_rebuild_queue_cancel))
             .routes(routes!(lifecycle_ops::post_destroy))
             .routes(routes!(lifecycle_ops::post_kill))
@@ -366,7 +351,6 @@ mod router_build_probe {
             .routes(routes!(lifecycle_ops::post_pause))
             .routes(routes!(lifecycle_ops::post_resume))
             .routes(routes!(tombstones::post_purge_tombstone))
-            .routes(routes!(build_logs::get_build_log_stream))
             .routes(routes!(state_snapshot::dashboard_stream))
             .routes(routes!(state_snapshot::jobq_graph))
             .routes(routes!(state_snapshot::jobq_rollup));
diff --git a/hive-c0re/src/lifecycle/mod.rs b/hive-c0re/src/lifecycle/mod.rs
index 4bc2d65cd..64dcd013f 100644
--- a/hive-c0re/src/lifecycle/mod.rs
+++ b/hive-c0re/src/lifecycle/mod.rs
@@ -882,8 +882,7 @@ async fn priv_run(kind: &str, name: &str) -> Result<()> {
 }
 
 /// Like `priv_run` but stamps `node_id` onto the build-log row it opens, so
-/// the dashboard can find the log from the queue node (and link to
-/// `/api/build-logs/id/{id}/stream`).
+/// the log can be found from the queue node.
 ///
 /// This used to be a `Fn(i64)` callback that handed the row id *back* to the
 /// queue, which then held it in a side map. The row carries the link itself
diff --git a/hive-c0re/src/server.rs b/hive-c0re/src/server.rs
index b644aad86..137d2bc7b 100644
--- a/hive-c0re/src/server.rs
+++ b/hive-c0re/src/server.rs
@@ -162,7 +162,6 @@ async fn dispatch(req: &HostRequest, coord: Arc<Coordinator>) -> HostResponse {
             HostRequest::QueueNodes { ids } => {
                 HostResponse::nodes(coord.job_queue.node_subtrees(ids))
             }
-            HostRequest::List => HostResponse::list(lifecycle::list().await?),
             // The agents root is ours and not world-traversable, so this
             // question is only answerable on this side of the socket —
             // see the request's doc comment for why the client asks.
@@ -745,6 +744,18 @@ mod tests {
 
     use super::*;
 
+    /// A verb this daemon no longer serves fails to parse (answered with
+    /// `parse error` by the connection loop) while a served verb parses.
+    #[test]
+    fn a_removed_verb_is_a_parse_error_and_a_served_one_parses() {
+        let err =
+            serde_json::from_slice::<HostRequest>(br#"{"cmd":"list"}"#).expect_err("list is gone");
+        assert!(err.to_string().contains("unknown variant `list`"), "{err}");
+        assert!(
+            serde_json::from_slice::<HostRequest>(br#"{"cmd":"subscribe_agent_status"}"#).is_ok()
+        );
+    }
+
     /// A real `Coordinator` over a throwaway sqlite dir; `handle_with` takes
     /// an `Arc<Coordinator>` and `open` touches nothing outside the db path.
     fn coordinator() -> (tempfile::TempDir, Arc<Coordinator>) {
diff --git a/hive-c0re/src/socket_server/mod.rs b/hive-c0re/src/socket_server/mod.rs
index 6b21837ed..7c8b437e1 100644
--- a/hive-c0re/src/socket_server/mod.rs
+++ b/hive-c0re/src/socket_server/mod.rs
@@ -9,7 +9,6 @@ use std::sync::Arc;
 
 use anyhow::{Context, Result};
 use hive_core_agent_sock::{Request, Response};
-use hive_sh4re::inbox::Message;
 use hive_sock_client::{LineDeadlines, RequestLine, read_request_line};
 use tokio::io::{AsyncWriteExt, BufReader};
 use tokio::net::{UnixListener, UnixStream};
@@ -209,7 +208,6 @@ async fn dispatch(
             handle_recv(coord, agent, *wait_seconds).await
         }
         hive_core_agent_sock::Request::Status => handle_status(coord, agent),
-        hive_core_agent_sock::Request::Wake { from, body } => handle_wake(coord, agent, from, body),
         hive_core_agent_sock::Request::Recent { limit } => handle_recent(coord, agent, *limit),
         hive_core_agent_sock::Request::SetStatus { text } => handle_set_status(coord, text),
         hive_core_agent_sock::Request::GetAgentMeta { name } => {
@@ -278,28 +276,6 @@ async fn handle_recv(
     }
 }
 
-/// `Wake` — inject a wake into `agent`'s own inbox. Persisted through
-/// the sqlite broker like any other message so it appears in message history
-/// for post-mortem.
-fn handle_wake(
-    coord: &Arc<Coordinator>,
-    agent: &str,
-    from: &str,
-    body: &str,
-) -> hive_core_agent_sock::Response {
-    match coord.broker.send(&Message {
-        from: hive_sh4re::manager::trusted_sender(from),
-        to: agent.to_owned(),
-        body: body.to_owned(),
-        in_reply_to: None,
-    }) {
-        Ok(()) => hive_core_agent_sock::Response::Ok,
-        Err(e) => hive_core_agent_sock::Response::Err {
-            message: format!("{e:#}"),
-        },
-    }
-}
-
 /// `SetStatus` — validate the status text, then trigger a dashboard
 /// rescan. The harness has already written the status file to its own
 /// `state/` dir (it runs as the agent user), so this only refreshes the
@@ -461,6 +437,16 @@ mod tests {
         (dir, Arc::new(coord))
     }
 
+    /// A verb this daemon no longer serves fails to parse (the connection loop
+    /// answers that with `parse error`, see `serve`) while a served verb parses.
+    #[test]
+    fn a_removed_verb_is_a_parse_error_and_a_served_one_parses() {
+        let removed = br#"{"cmd":"wake","from":"x","body":"y"}"#;
+        let err = serde_json::from_slice::<Request>(removed).expect_err("wake is gone");
+        assert!(err.to_string().contains("unknown variant `wake`"), "{err}");
+        assert!(serde_json::from_slice::<Request>(br#"{"cmd":"status"}"#).is_ok());
+    }
+
     #[tokio::test]
     async fn serve_answers_an_over_long_line_with_an_error_and_closes() {
         let (_dir, coord) = coordinator();
diff --git a/hive-c0re/src/stores/build_logs.rs b/hive-c0re/src/stores/build_logs.rs
index e848b3c79..bd02850c6 100644
--- a/hive-c0re/src/stores/build_logs.rs
+++ b/hive-c0re/src/stores/build_logs.rs
@@ -8,10 +8,8 @@ use std::sync::{Arc, Mutex, OnceLock};
 
 use anyhow::{Context, Result};
 use chrono::Utc;
-use rusqlite::{Connection, OptionalExtension, params};
+use rusqlite::{Connection, params};
 use serde::Serialize;
-use tokio::sync::broadcast;
-use utoipa::ToSchema;
 
 use crate::db::Migration;
 
@@ -103,65 +101,23 @@ pub enum BuildStatus {
     Fail,
 }
 
-/// Header-only row returned by `list_recent_for_agent`. Carries the
-/// metadata the dashboard's agent-card chip needs (status + age +
-/// id-to-open) without the multi-MB stdout/stderr payload.
-#[derive(Debug, Clone, Serialize, ToSchema)]
-pub struct BuildLogHeader {
-    pub id: i64,
+/// A stored row with its captured text, as read back by tests.
+#[cfg(test)]
+#[derive(Debug, Clone)]
+pub struct BuildLogFull {
     pub agent: String,
     pub kind: String,
-    pub cmdline: String,
-    pub started_at: i64,
-    pub finished_at: Option<i64>,
     pub status: Option<String>,
-    /// Elapsed seconds from `started_at` to `finished_at`. `None` while
-    /// the build is still in progress.
-    pub runtime_secs: Option<i64>,
-}
-
-/// Full row with stdout/stderr text inlined. Returned by `get_full`,
-/// backs the side-panel viewer's payload.
-#[derive(Debug, Clone, Serialize, ToSchema)]
-pub struct BuildLogFull {
-    #[serde(flatten)]
-    pub header: BuildLogHeader,
+    pub finished_at: Option<i64>,
     pub stdout: String,
     pub stderr: String,
 }
 
-/// Incremental text returned by `get_progress`. Carries only the new
-/// bytes since the caller's last cursor positions so the SSE stream
-/// handler can send deltas without re-transmitting the full log.
-#[derive(Debug, Clone)]
-pub struct BuildLogProgress {
-    /// New stdout bytes beyond `stdout_cursor`.
-    pub stdout_append: String,
-    /// New stderr bytes beyond `stderr_cursor`.
-    pub stderr_append: String,
-    /// `Some(unix_ts)` once the build is finished.
-    pub finished_at: Option<i64>,
-    /// Terminal status string (`"ok"` / `"fail"`) once finished.
-    pub status: Option<String>,
-}
-
-/// Channel capacity for per-build append notifications. 64 slots is
-/// plenty — the consumer reads fast relative to line-append rate and
-/// any lag means "read now, you have new content" rather than a lost
-/// data line.
-const NOTIFY_CAP: usize = 64;
-
 /// Sqlite-backed build-log store. `Arc<BuildLogs>`-friendly: all
 /// methods take `&self`, internal `Mutex<Connection>` serializes
 /// access.
 pub struct BuildLogs {
     conn: Mutex<Connection>,
-    /// Broadcast channel that fires with the `id` of the row that just
-    /// had a line appended or was finished. The SSE stream handler
-    /// subscribes once per open panel and drives delta reads from this.
-    /// `send()` is non-async and silently drops frames when there are
-    /// no subscribers — safe to call from sync append/finish paths.
-    notify_tx: broadcast::Sender<i64>,
 }
 
 impl BuildLogs {
@@ -171,10 +127,8 @@ impl BuildLogs {
         conn.execute_batch(SCHEMA)
             .context("apply build_logs schema")?;
         crate::db::apply_versioned_migrations(&conn, "build_logs", MIGRATIONS)?;
-        let (notify_tx, _) = broadcast::channel(NOTIFY_CAP);
         Ok(Self {
             conn: Mutex::new(conn),
-            notify_tx,
         })
     }
 
@@ -202,13 +156,6 @@ impl BuildLogs {
         Ok(u64::try_from(closed).unwrap_or(0))
     }
 
-    /// Subscribe to per-build append/finish notifications. Each emitted
-    /// value is the `id` of the row that changed. The SSE stream handler
-    /// calls this once and filters for its target id.
-    pub fn subscribe_notifications(&self) -> broadcast::Receiver<i64> {
-        self.notify_tx.subscribe()
-    }
-
     /// Open a row for a new build attempt. Returns the assigned id
     /// — the caller threads it through `append_stdout` / `append_stderr`
     /// while the child runs and into `finish` once it exits.
@@ -282,14 +229,6 @@ impl BuildLogs {
                 "build_logs: append failed (dropping line)"
             );
         }
-        drop(conn);
-        // Notify SSE stream subscribers — non-blocking, no-op when no
-        // subscribers are watching (e.g. no panel is open). Lagged
-        // receivers (channel full) automatically drop frames; the SSE
-        // handler re-reads the full delta on the next notification it
-        // does receive, so no content is lost, only an intermediate
-        // wake-up is coalesced.
-        let _ = self.notify_tx.send(id);
     }
 
     /// Finalize a build attempt. Sets `finished_at` to now and
@@ -307,133 +246,30 @@ impl BuildLogs {
                 "build_logs: finish failed"
             );
         }
-        drop(conn);
-        // Final notification so the SSE stream handler sees the
-        // finished_at and status, closes the connection cleanly.
-        let _ = self.notify_tx.send(id);
     }
 
-    /// Return incremental log content beyond the given byte cursors.
-    /// Used by the SSE stream handler to compute deltas between polls.
-    ///
-    /// `stdout_cursor` / `stderr_cursor` are byte offsets into the
-    /// stored `stdout` / `stderr` columns from the previous read.
-    /// Slicing is safe because cursors are always derived from prior
-    /// `String::len()` values (valid UTF-8 boundaries).
-    ///
-    /// Returns `None` when the row no longer exists (vacuum reap during
-    /// a long-open panel).
-    pub fn get_progress(
-        &self,
-        id: i64,
-        stdout_cursor: usize,
-        stderr_cursor: usize,
-    ) -> Result<Option<BuildLogProgress>> {
-        let conn = self.conn.lock().unwrap();
-        let mut stmt = conn.prepare(
-            "SELECT stdout, stderr, finished_at, status \
-             FROM build_logs WHERE id = ?1",
-        )?;
-        let row = stmt
-            .query_row(params![id], |r| {
-                Ok((
-                    r.get::<_, String>(0)?,
-                    r.get::<_, String>(1)?,
-                    r.get::<_, Option<i64>>(2)?,
-                    r.get::<_, Option<String>>(3)?,
-                ))
-            })
-            .optional()?;
-        match row {
-            None => Ok(None),
-            Some((stdout, stderr, finished_at, status)) => {
-                let stdout_append = stdout.get(stdout_cursor..).unwrap_or("").to_string();
-                let stderr_append = stderr.get(stderr_cursor..).unwrap_or("").to_string();
-                Ok(Some(BuildLogProgress {
-                    stdout_append,
-                    stderr_append,
-                    finished_at,
-                    status,
-                }))
-            }
-        }
-    }
-
-    /// Return the most recent `limit` rows for `agent`, newest first.
-    /// Headers only (no stdout/stderr blobs) — keeps `/api/state`
-    /// payloads light. Limit is hard-clamped to 50 to bound worst-case
-    /// payload regardless of caller input.
-    pub fn list_recent_for_agent(&self, agent: &str, limit: usize) -> Result<Vec<BuildLogHeader>> {
-        let limit = limit.min(50);
-        let conn = self.conn.lock().unwrap();
-        let mut stmt = conn.prepare(
-            "SELECT id, agent, kind, cmdline, started_at, finished_at, status
-             FROM build_logs
-             WHERE agent = ?1
-             ORDER BY started_at DESC
-             LIMIT ?2",
-        )?;
-        let rows = stmt.query_map(
-            params![agent, i64::try_from(limit).unwrap_or(50)],
-            row_to_header,
-        )?;
-        let mut out = Vec::new();
-        for r in rows {
-            out.push(r?);
-        }
-        Ok(out)
-    }
-
-    /// Return the most recent `limit` rows across all agents, newest first.
-    /// Same header-only shape as `list_recent_for_agent`. Limit clamped to 100.
-    pub fn list_recent_all(&self, limit: usize) -> Result<Vec<BuildLogHeader>> {
-        let limit = limit.min(100);
-        let conn = self.conn.lock().unwrap();
-        let mut stmt = conn.prepare(
-            "SELECT id, agent, kind, cmdline, started_at, finished_at, status
-             FROM build_logs
-             ORDER BY started_at DESC
-             LIMIT ?1",
-        )?;
-        let rows = stmt.query_map(params![i64::try_from(limit).unwrap_or(100)], row_to_header)?;
-        let mut out = Vec::new();
-        for r in rows {
-            out.push(r?);
-        }
-        Ok(out)
-    }
-
-    /// Fetch a single full row (with stdout/stderr text) by id.
-    /// Returns `None` when the id doesn't exist (vacuum sweep already
-    /// reaped it, or the operator passed a stale id from a refresh
-    /// race).
+    /// Read one row back, text included. `None` when the id doesn't exist
+    /// (already vacuumed).
+    #[cfg(test)]
     pub fn get_full(&self, id: i64) -> Result<Option<BuildLogFull>> {
+        use rusqlite::OptionalExtension;
         let conn = self.conn.lock().unwrap();
-        let mut stmt = conn.prepare(
-            "SELECT id, agent, kind, cmdline, started_at, finished_at, status, stdout, stderr
-             FROM build_logs
-             WHERE id = ?1",
-        )?;
-        let row = stmt
-            .query_row(params![id], |r| {
-                let started_at: i64 = r.get(4)?;
-                let finished_at: Option<i64> = r.get(5)?;
-                let runtime_secs = compute_runtime_secs(started_at, finished_at);
-                Ok(BuildLogFull {
-                    header: BuildLogHeader {
-                        id: r.get(0)?,
-                        agent: r.get(1)?,
-                        kind: r.get(2)?,
-                        cmdline: r.get(3)?,
-                        started_at,
-                        finished_at,
-                        status: r.get(6)?,
-                        runtime_secs,
-                    },
-                    stdout: r.get(7)?,
-                    stderr: r.get(8)?,
-                })
-            })
+        let row = conn
+            .query_row(
+                "SELECT agent, kind, finished_at, status, stdout, stderr \
+                 FROM build_logs WHERE id = ?1",
+                params![id],
+                |r| {
+                    Ok(BuildLogFull {
+                        agent: r.get(0)?,
+                        kind: r.get(1)?,
+                        finished_at: r.get(2)?,
+                        status: r.get(3)?,
+                        stdout: r.get(4)?,
+                        stderr: r.get(5)?,
+                    })
+                },
+            )
             .optional()?;
         Ok(row)
     }
@@ -494,26 +330,6 @@ pub fn spawn_vacuum(coord: &Arc<crate::coordinator::Coordinator>) {
     });
 }
 
-fn compute_runtime_secs(started_at: i64, finished_at: Option<i64>) -> Option<i64> {
-    finished_at.map(|f| f - started_at)
-}
-
-fn row_to_header(r: &rusqlite::Row) -> rusqlite::Result<BuildLogHeader> {
-    let started_at: i64 = r.get(4)?;
-    let finished_at: Option<i64> = r.get(5)?;
-    let runtime_secs = compute_runtime_secs(started_at, finished_at);
-    Ok(BuildLogHeader {
-        id: r.get(0)?,
-        agent: r.get(1)?,
-        kind: r.get(2)?,
-        cmdline: r.get(3)?,
-        started_at,
-        finished_at,
-        status: r.get(6)?,
-        runtime_secs,
-    })
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -536,10 +352,10 @@ mod tests {
         db.finish(id, BuildStatus::Fail);
 
         let full = db.get_full(id).expect("get").expect("Some");
-        assert_eq!(full.header.agent, "alice");
-        assert_eq!(full.header.kind, "prebuild");
-        assert_eq!(full.header.status.as_deref(), Some("fail"));
-        assert!(full.header.finished_at.is_some());
+        assert_eq!(full.agent, "alice");
+        assert_eq!(full.kind, "prebuild");
+        assert_eq!(full.status.as_deref(), Some("fail"));
+        assert!(full.finished_at.is_some());
         assert!(full.stdout.contains("/nix/store/abc.drv"));
         assert!(full.stderr.contains("error: line 12"));
         assert!(full.stderr.contains("module.nix:5"));
@@ -565,46 +381,15 @@ mod tests {
         assert_eq!(db.reap_orphans().expect("reap"), 1);
 
         let row = db.get_full(orphan).expect("get").expect("Some");
-        assert_eq!(row.header.status.as_deref(), Some("fail"));
-        assert!(row.header.finished_at.is_some());
+        assert_eq!(row.status.as_deref(), Some("fail"));
+        assert!(row.finished_at.is_some());
         assert!(row.stdout.contains("building"));
         assert!(row.stderr.ends_with(&format!("{ORPHAN_NOTE}\n")));
         let ok = db.get_full(done).expect("get").expect("Some");
-        assert_eq!(ok.header.status.as_deref(), Some("ok"));
+        assert_eq!(ok.status.as_deref(), Some("ok"));
         assert_eq!(db.reap_orphans().expect("reap again"), 0);
     }
 
-    #[test]
-    fn list_recent_orders_newest_first_and_clamps() {
-        let (_d, db) = tmpdb();
-        // Three attempts, two for alice + one for bob. Without sleeping
-        // sqlite's `INTEGER` started_at ties at 1-sec resolution, so we
-        // assert id-ordering (autoincrement) is the tiebreaker — list
-        // sorts by started_at DESC but the ORDER BY still produces the
-        // last-inserted row first when timestamps match.
-        let id_a1 = db.start("alice", "run", "cmd one", None).expect("start");
-        let _id_b = db.start("bob", "run", "cmd two", None).expect("start");
-        let id_a2 = db.start("alice", "run", "cmd three", None).expect("start");
-        db.finish(id_a1, BuildStatus::Ok);
-
-        let alice_rows = db.list_recent_for_agent("alice", 10).expect("list");
-        assert_eq!(alice_rows.len(), 2);
-        // Without distinct started_at values both rows share `now`,
-        // but list_recent already orders by `started_at DESC` then
-        // sqlite's natural insertion-order tiebreak. We rely only on
-        // both IDs being present + correct count + agent isolation.
-        let ids: std::collections::HashSet<i64> = alice_rows.iter().map(|h| h.id).collect();
-        assert!(ids.contains(&id_a1));
-        assert!(ids.contains(&id_a2));
-
-        let bob_rows = db.list_recent_for_agent("bob", 10).expect("list");
-        assert_eq!(bob_rows.len(), 1);
-
-        // Limit clamp at 50.
-        let huge = db.list_recent_for_agent("alice", 999_999).expect("list");
-        assert!(huge.len() <= 50);
-    }
-
     #[test]
     fn get_full_returns_none_for_missing_id() {
         let (_d, db) = tmpdb();
diff --git a/hive-core-agent-sock/src/lib.rs b/hive-core-agent-sock/src/lib.rs
index b2ecc2681..a160a5a89 100644
--- a/hive-core-agent-sock/src/lib.rs
+++ b/hive-core-agent-sock/src/lib.rs
@@ -32,12 +32,6 @@ pub enum Request {
     /// Non-mutating: how many pending messages are addressed to me?
     /// Used by the harness to render a status line after each tool call.
     Status,
-    /// Wake-up event injected from inside the container. Recipient is
-    /// implicit (this agent); `from` is caller-chosen. See
-    /// `docs/5-project/process/conventions.md::Wake injection` for the trust model and
-    /// typical callers. The wake is persisted in the sqlite broker
-    /// like any other message.
-    Wake { from: String, body: String },
     /// Last `limit` messages addressed to this agent, newest-first.
     /// Non-mutating — pulls from the broker without delivering. The
     /// per-agent web UI uses this to render its own inbox section.
diff --git a/hive-forge-notify/src/notify.rs b/hive-forge-notify/src/notify.rs
index 71fffa5d3..e8b8b797f 100644
--- a/hive-forge-notify/src/notify.rs
+++ b/hive-forge-notify/src/notify.rs
@@ -1,8 +1,7 @@
 //! Background Forgejo notification poller. Polls
 //! `GET /notifications?all=false` every 30s, formats each unread
-//! notification as a broker `Wake { from: "forge" }` message, delivers it
-//! to the agent's inbox, and — on a successful delivery — marks the thread
-//! read on forge straight away. The broker inbox is the durable work queue
+//! notification as a todo on the harness's in-agent socket (`UpsertTodo`),
+//! and — on a successful delivery — marks the thread read on forge straight away. The broker inbox is the durable work queue
 //! (each row has its own ack lifecycle), so the forge unread flag no longer
 //! needs to track agent processing: clearing it on delivery keeps forge's
 //! unread set tiny by construction, so a container rebuild's re-scan of
diff --git a/hive-host-sock/src/lib.rs b/hive-host-sock/src/lib.rs
index ae02a3332..8eadac25f 100644
--- a/hive-host-sock/src/lib.rs
+++ b/hive-host-sock/src/lib.rs
@@ -137,8 +137,6 @@ pub enum HostRequest {
     },
     /// Apply pending config to a managed container.
     Rebuild { name: Ident },
-    /// List managed containers.
-    List,
     /// Report whether `name` is a managed agent, i.e. whether it has a
     /// persistent state dir under the agents root. Answered daemon-side
     /// because that root is `0700 hive-core`: a client stat-ing it
diff --git a/hive-runtime/README.md b/hive-runtime/README.md
index a05d096eb..db1e6d853 100644
--- a/hive-runtime/README.md
+++ b/hive-runtime/README.md
@@ -49,8 +49,7 @@ and the next turn starts a new one beside it.
 ## ACP backend: compaction
 
 The same `CompactionPolicy` as the claude backend decides when: after a turn
-past the watermark, or on `compact` (the operator's `/compact`, the agent's
-`compact` tool).
+past the watermark, or when the agent calls its `compact` tool.
 
 - If the agent advertises a `compact` command (`available_commands_update`),
   it is sent as the prompt `/compact` on the same session, as the ACP spec
diff --git a/nix/host-modules/hive-c0re/vhosts.nix b/nix/host-modules/hive-c0re/vhosts.nix
index abc3c1430..20c359179 100644
--- a/nix/host-modules/hive-c0re/vhosts.nix
+++ b/nix/host-modules/hive-c0re/vhosts.nix
@@ -85,8 +85,7 @@ let
       proxyPass = "http://${gatewayCfg.upstreamHost}:${toString gatewayCfg.upstreamPort}";
       proxyWebsockets = true;
       extraConfig = ''
-        # off + 1d keep the SSE streams (/api/dashboard/stream,
-        # /api/build-logs/id/{id}/stream) live.
+        # off + 1d keep the SSE stream (/api/dashboard/stream) live.
         proxy_buffering off;
         proxy_read_timeout 1d;
         ${dashboardAuth}