@martintrojer/murmur 0.1.4 → 0.2.1

package/dist/cli.js

@@ -3,35 +3,15 @@
 // src/cli.ts
 import { Command } from "commander";
 
-// src/identity.ts
-import { randomUUID } from "crypto";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { hostname } from "os";
-import { join as join2 } from "path";
-
-// src/paths.ts
-import { homedir } from "os";
-import { join } from "path";
-function stateDir() {
-  return process.env.MURMUR_STATE_DIR ?? join(process.env.XDG_STATE_HOME ?? join(homedir(), ".local", "state"), "murmur");
+// src/ids.ts
+function asSessionId(raw) {
+  return raw;
 }
-function dbPath() {
-  return join(stateDir(), "events.db");
-}
-
-// src/identity.ts
-function loadIdentity() {
-  const path = join2(stateDir(), "identity.json");
-  return existsSync(path) ? JSON.parse(readFileSync(path, "utf8")) : null;
+function asWindowId(raw) {
+  return raw;
 }
-function ensureIdentity(displayName = hostname()) {
-  const existing = loadIdentity();
-  if (existing) return existing;
-  const identity = { host_id: randomUUID(), display_name: displayName };
-  mkdirSync(stateDir(), { recursive: true });
-  writeFileSync(join2(stateDir(), "identity.json"), `${JSON.stringify(identity, null, 2)}
-`);
-  return identity;
+function asPaneId(raw) {
+  return raw;
 }
 
 // src/mux.ts
@@ -47,52 +27,59 @@ function runTmux(args) {
     return null;
   }
 }
+function chosenWindowName(name, autoRename) {
+  if (autoRename === "1") return null;
+  return name || null;
+}
+function exactSession(session) {
+  return `=${session}`;
+}
+function exactPaneTarget(session) {
+  return `=${session}:`;
+}
+function tmuxBadgeState(state) {
+  return state === "running" ? "working" : state;
+}
 var tmux = {
   currentWindow() {
-    const pane = process.env.TMUX_PANE;
-    if (!pane) return null;
+    const raw = process.env.TMUX_PANE;
+    if (!raw) return null;
+    const pane = asPaneId(raw);
     const fields = runTmux([
       "display-message",
       "-t",
       pane,
       "-p",
-      "#{session_id}	#{window_id}	#{session_name}	#{window_name}"
+      "#{session_id}	#{window_id}	#{session_name}	#{window_name}	#{?automatic-rename,1,0}"
     ]);
-    const [session, window, sessionName, windowName] = fields?.split("	") ?? [];
+    const [session, window, sessionName, windowName, autoRename] = fields?.split("	") ?? [];
     if (!session || !window) return null;
     return {
-      session,
-      window,
+      session: asSessionId(session),
+      window: asWindowId(window),
       pane,
       session_name: sessionName || null,
-      window_name: windowName || null
+      window_name: chosenWindowName(windowName, autoRename)
     };
   },
-  // Which of this host's windows still exist. Only the authoring node can
-  // answer this, which is why the check runs on export rather than on the
-  // reader: a peer holding a `blocked` row for a window that died has nothing
-  // to supersede it, and the agent stays in every HUD forever.
-  //
-  // null means "could not tell" (no tmux server, tmux missing) and is
-  // deliberately distinct from an empty set, which means "tmux answered, and
-  // there are no windows". Treating the first as the second would clear every
-  // agent on the host the moment tmux was unreachable.
+  // Which of this host's PANES still exist. The only liveness question tmux is
+  // ever asked, and the one that matches how an agent is addressed: a pane keeps
+  // its id when it moves between windows, so a recorded window id can be gone
+  // while the agent is very much alive.
   //
-  // Unlike currentWindow, this deliberately asks tmux rather than reading the
-  // environment, and it is right to: "which windows exist on this host" is a
-  // server-wide question with one answer, and export runs over ssh with no
-  // pane of its own. currentWindow asks "which pane am I in", which only
-  // $TMUX_PANE can answer.
-  liveWindows() {
-    const out = runTmux(["list-windows", "-a", "-F", "#{window_id}"]);
+  // null means tmux could not answer; an empty set means it did and there are
+  // none. Conflating the two would delete every agent on the host the moment
+  // tmux was briefly unreachable.
+  livePanes() {
+    const out = runTmux(["list-panes", "-a", "-F", "#{pane_id}"]);
     if (out === null) return null;
-    return new Set(out.split("\n").filter(Boolean));
+    return new Set(out.split("\n").filter(Boolean).map(asPaneId));
   },
-  setState(window, state) {
+  setWindowBadge(window, state) {
     if (state === null) {
       runTmux(["set-window-option", "-qu", "-t", window, "@agent_state"]);
     } else {
-      runTmux(["set-window-option", "-q", "-t", window, "@agent_state", state]);
+      runTmux(["set-window-option", "-q", "-t", window, "@agent_state", tmuxBadgeState(state)]);
       runTmux(["set-window-option", "-q", "-t", window, "@pane_agent", "1"]);
     }
     runTmux(["refresh-client", "-S"]);
@@ -101,45 +88,51 @@ var tmux = {
     runTmux(["switch-client", "-t", session]);
     return runTmux(["select-window", "-t", window]) !== null;
   },
-  // Window ids are what the log stores, because they are stable; names are
-  // what a human recognises in a picker. Names are live tmux state, not
-  // history, so they are resolved at render time rather than recorded.
-  windowNames() {
-    const out = runTmux(["list-windows", "-a", "-F", "#{window_id}	#{window_name}"]);
-    const names = /* @__PURE__ */ new Map();
-    for (const line of out?.split("\n") ?? []) {
-      const [id, name] = line.split("	");
-      if (id && name) names.set(id, name);
-    }
-    return names;
-  },
-  // First window carrying this exact name, or null. Used to reuse a per-host
-  // ssh window instead of opening another one.
   // Sibling panes, for deciding whether an unowned pane may clear the window's
   // badge. A window holding an agent and a shell must not lose the badge when
   // you focus the shell.
   panesInWindow(window) {
     const out = runTmux(["list-panes", "-t", window, "-F", "#{pane_id}"]);
-    return out?.split("\n").filter(Boolean) ?? [];
+    return out?.split("\n").filter(Boolean).map(asPaneId) ?? [];
   },
-  windowNamed(name) {
-    const out = runTmux(["list-windows", "-a", "-F", "#{window_id}	#{window_name}"]);
-    for (const line of out?.split("\n") ?? []) {
-      const [id, windowName] = line.split("	");
-      if (id && windowName === name) return id;
-    }
-    return null;
+  // Which client to send home when the remote attach exits. `switch-client`
+  // with no -c moves whichever client tmux considers current, and `murmur pick`
+  // usually runs in a popup -- a client of its own, which dies with the popup.
+  // Naming the real client is what lets the return outlive the picker.
+  clientName() {
+    return runTmux(["display-message", "-p", "#{client_name}"]) || null;
   },
-  selectWindow(window) {
-    return runTmux(["select-window", "-t", window]) !== null;
+  // Where the jump started, as a switch-client target. Window-level, not just
+  // the session: coming back to the right session but the wrong window is
+  // still the wrong place. The window id is stable where its index is not,
+  // since renumber-windows renumbers on every close.
+  currentTarget() {
+    return runTmux(["display-message", "-p", "#{session_name}:#{window_id}"]) || null;
+  },
+  // Whether a wrapper session for this host already exists. Deliberately not
+  // returning an id: a session is addressed by name, so a `#{session_id}` would
+  // only have to be turned back into one.
+  sessionNamed(name) {
+    const out = runTmux(["list-sessions", "-F", "#{session_name}"]);
+    if (out === null) return false;
+    return out.split("\n").includes(name);
+  },
+  newSession(name, command) {
+    return runTmux(["new-session", "-d", "-s", name, command]) !== null;
   },
-  newWindow(name, command) {
-    return runTmux(["new-window", "-n", name, command]) !== null;
+  setSessionOption(session, option, value) {
+    runTmux(["set-option", "-t", exactPaneTarget(session), option, value]);
   },
-  // The window a pane belongs to, for a pane murmur has no event for. Clearing
+  switchClient(client, session) {
+    const target = exactSession(session);
+    const args = client ? ["switch-client", "-c", client, "-t", target] : ["switch-client", "-t", target];
+    return runTmux(args) !== null;
+  },
+  // The window a pane belongs to, for a pane murmur holds no row for. Clearing
   // a badge is a tmux operation and does not require murmur to own the pane.
   windowForPane(pane) {
-    return runTmux(["display-message", "-t", pane, "-p", "#{window_id}"]) || null;
+    const out = runTmux(["display-message", "-t", pane, "-p", "#{window_id}"]);
+    return out ? asWindowId(out) : null;
   },
   capture(pane, lines) {
     const args = ["capture-pane", "-p", "-t", pane];
@@ -157,229 +150,527 @@ function pidAlive(pid) {
 }
 
 // src/store.ts
-import { rmSync } from "fs";
+import { randomUUID } from "crypto";
+import { mkdirSync, rmSync } from "fs";
+import { dirname } from "path";
 import Database from "better-sqlite3";
-var DEFAULT_RETENTION_MS = 7 * 864e5;
-var STORE_VERSION = 2;
-function resetIfStale(path) {
-  let salvaged = [];
+
+// src/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+function stateDir() {
+  return process.env.MURMUR_STATE_DIR ?? join(process.env.XDG_STATE_HOME ?? join(homedir(), ".local", "state"), "murmur");
+}
+function dbPath() {
+  return join(stateDir(), "state.db");
+}
+
+// src/version.ts
+import { createRequire } from "module";
+function readVersion() {
+  const require2 = createRequire(import.meta.url);
+  for (const candidate of ["../package.json", "../../package.json"]) {
+    try {
+      return require2(candidate).version;
+    } catch {
+    }
+  }
+  throw new Error("cannot locate package.json to read the murmur version");
+}
+var MURMUR_VERSION = readVersion();
+
+// src/types.ts
+var DEFAULT_DRIVER = "human";
+
+// src/view.ts
+var RENDER_PRIORITY = [
+  "crashed",
+  "blocked",
+  "done",
+  "running",
+  "idle"
+];
+var NEEDS_HUMAN = ["blocked", "crashed"];
+var STALENESS_MS = 6e4;
+function age(ms) {
+  if (ms === null || ms < 6e4) return "";
+  if (ms < 36e5) return `${Math.floor(ms / 6e4)}m`;
+  if (ms < 864e5) return `${Math.floor(ms / 36e5)}h`;
+  return `${Math.floor(ms / 864e5)}d`;
+}
+function freshness(fetchedAt, now, thresholdMs = STALENESS_MS) {
+  return fetchedAt !== null && now - fetchedAt <= thresholdMs ? "fresh" : "stale";
+}
+function renderState(view) {
+  for (const kind of ["crashed", "blocked", "done"]) {
+    if (view.attention.includes(kind)) return kind;
+  }
+  return view.activity === "running" ? "running" : "idle";
+}
+function newestAttention(pane) {
+  let newest = null;
+  for (const entry of pane.attention) {
+    if (newest === null || entry.requested_at > newest) newest = entry.requested_at;
+  }
+  return newest;
+}
+function paneView(pane, source) {
+  const agent = pane.agent;
+  return {
+    host_id: source.host_id,
+    host: source.host,
+    local: source.local,
+    pane: pane.pane,
+    session: pane.session,
+    window: pane.window,
+    session_name: pane.session_name,
+    window_name: pane.window_name,
+    activity: agent?.activity ?? null,
+    attention: pane.attention.map((entry) => entry.kind),
+    freshness: source.freshness,
+    agent_id: agent?.agent_id ?? null,
+    agent_name: agent?.agent_name ?? null,
+    pi_session: agent?.pi_session ?? null,
+    workstream: agent?.workstream ?? null,
+    role: agent?.role ?? null,
+    cli: agent?.cli ?? null,
+    driver: agent?.driver ?? DEFAULT_DRIVER,
+    updated_at: agent?.updated_at ?? newestAttention(pane),
+    snapshot_at: source.snapshot_at,
+    fetched_at: source.fetched_at
+  };
+}
+function paneViews(store, identity, now = Date.now()) {
+  const views = store.localPanes().map(
+    (pane) => paneView(pane, {
+      host_id: identity.host_id,
+      host: identity.display_name,
+      local: true,
+      // Local panes are always fresh: we are the node that authored them.
+      freshness: "fresh",
+      snapshot_at: null,
+      fetched_at: null
+    })
+  );
+  for (const peer of store.peers()) {
+    const snapshot = peer.snapshot;
+    if (!snapshot) continue;
+    const source = {
+      host_id: snapshot.host_id,
+      // The name the human typed, not the machine's self-reported hostname: a
+      // peer added as `linuxpc` can report a container id, which appears
+      // nowhere else in the tool and cannot be typed at `peer remove`.
+      host: peer.name,
+      local: false,
+      freshness: freshness(peer.fetched_at, now),
+      snapshot_at: peer.snapshot_at,
+      fetched_at: peer.fetched_at
+    };
+    for (const pane of snapshot.panes) views.push(paneView(pane, source));
+  }
+  return views;
+}
+var ORDER = new Map(RENDER_PRIORITY.map((state, index) => [state, index]));
+function viewSort(views) {
+  return [...views].sort((left, right) => {
+    const byState = (ORDER.get(renderState(left)) ?? 99) - (ORDER.get(renderState(right)) ?? 99);
+    if (byState !== 0) return byState;
+    const byAge = (right.updated_at ?? 0) - (left.updated_at ?? 0);
+    if (byAge !== 0) return byAge;
+    const byHost = left.host.localeCompare(right.host);
+    return byHost !== 0 ? byHost : left.pane.localeCompare(right.pane);
+  });
+}
+
+// src/store.ts
+var SCHEMA_USER_VERSION = 3;
+var SCHEMA = `
+  CREATE TABLE agents (
+    agent_id     TEXT    NOT NULL PRIMARY KEY,
+    pane         TEXT    NOT NULL UNIQUE,
+    owner_pid    INTEGER NOT NULL CHECK (owner_pid > 0),
+    activity     TEXT    NOT NULL CHECK (activity IN ('running', 'stopped')),
+    session      TEXT    NOT NULL,
+    window       TEXT    NOT NULL,
+    session_name TEXT,
+    window_name  TEXT,
+    agent_name   TEXT,
+    pi_session   TEXT,
+    workstream   TEXT,
+    role         TEXT,
+    cli          TEXT    NOT NULL,
+    driver       TEXT    NOT NULL CHECK (driver IN ('human', 'orchestrated')),
+    claimed_at   INTEGER NOT NULL,
+    updated_at   INTEGER NOT NULL
+  ) STRICT;
+
+  CREATE TABLE attention (
+    pane         TEXT    NOT NULL,
+    kind         TEXT    NOT NULL CHECK (kind IN ('done', 'blocked', 'crashed')),
+    message      TEXT    NOT NULL,
+    source       TEXT    NOT NULL,
+    session      TEXT    NOT NULL,
+    window       TEXT    NOT NULL,
+    session_name TEXT,
+    window_name  TEXT,
+    requested_at INTEGER NOT NULL,
+    PRIMARY KEY (pane, kind)
+  ) STRICT;
+
+  CREATE TABLE peers (
+    name             TEXT NOT NULL PRIMARY KEY,
+    target           TEXT NOT NULL,
+    host_id          TEXT,
+    display_name     TEXT,
+    snapshot         TEXT,
+    snapshot_at      INTEGER,
+    fetched_at       INTEGER,
+    last_attempt_at  INTEGER,
+    last_error       TEXT,
+    murmur_version   TEXT,
+    snapshot_version INTEGER
+  ) STRICT;
+`;
+function salvagePeers(path) {
   try {
     const existing = new Database(path, { fileMustExist: true });
-    const version = existing.pragma("user_version", { simple: true }) ?? 0;
-    if (version === STORE_VERSION) {
+    try {
+      const version = existing.pragma("user_version", { simple: true }) ?? 0;
+      if (version === SCHEMA_USER_VERSION) return [];
+      return existing.prepare("SELECT name, target FROM peers").all();
+    } catch {
+      return [];
+    } finally {
       existing.close();
-      return salvaged;
     }
+  } catch {
+    return [];
+  }
+}
+function needsReset(path) {
+  try {
+    const existing = new Database(path, { fileMustExist: true });
     try {
-      salvaged = existing.prepare("SELECT name, target, host_id, display_name FROM peers").all();
-    } catch {
+      return (existing.pragma("user_version", { simple: true }) ?? 0) !== SCHEMA_USER_VERSION;
+    } finally {
+      existing.close();
     }
-    existing.close();
   } catch {
-    return salvaged;
+    return false;
   }
-  for (const suffix of ["", "-wal", "-shm"]) rmSync(`${path}${suffix}`, { force: true });
-  return salvaged;
 }
-function eventValues(event) {
-  return [
-    event.host_id,
-    event.seq,
-    event.ts,
-    event.agent_id,
-    event.session,
-    event.window,
-    event.pane,
-    event.session_name,
-    event.window_name,
-    event.agent_name,
-    event.pi_session,
-    event.workstream,
-    event.role,
-    event.cli,
-    event.driver,
-    event.kind,
-    event.state,
-    event.message,
-    event.pid,
-    Number(event.synthetic),
-    event.reason,
-    JSON.stringify(event.extra)
-  ];
+function toAttention(row) {
+  return {
+    kind: row.kind,
+    message: row.message,
+    source: row.source,
+    requested_at: row.requested_at
+  };
 }
-function toEvent(row) {
+function toAgent(row) {
   return {
-    ...row,
+    agent_id: row.agent_id,
+    activity: row.activity,
+    agent_name: row.agent_name,
+    pi_session: row.pi_session,
+    workstream: row.workstream,
+    role: row.role,
+    cli: row.cli,
     driver: row.driver,
-    synthetic: row.synthetic === 1,
-    extra: JSON.parse(row.extra)
+    claimed_at: row.claimed_at,
+    updated_at: row.updated_at
   };
 }
+var PRIORITY = new Map(RENDER_PRIORITY.map((kind, index) => [kind, index]));
+function attentionOrder(left, right) {
+  return (PRIORITY.get(left.kind) ?? 99) - (PRIORITY.get(right.kind) ?? 99);
+}
 function openStore() {
-  const identity = ensureIdentity();
   const path = dbPath();
-  const salvagedPeers = resetIfStale(path);
+  mkdirSync(dirname(path), { recursive: true });
+  const salvaged = salvagePeers(path);
+  if (needsReset(path)) {
+    for (const suffix of ["", "-wal", "-shm"]) rmSync(`${path}${suffix}`, { force: true });
+  }
   const database = new Database(path);
   database.pragma("journal_mode = WAL");
-  database.pragma(`user_version = ${STORE_VERSION}`);
-  database.exec(`
-    CREATE TABLE IF NOT EXISTS events (
-      host_id TEXT NOT NULL,
-      seq INTEGER NOT NULL,
-      ts INTEGER NOT NULL,
-      agent_id TEXT NOT NULL,
-      session TEXT NOT NULL,
-      window TEXT NOT NULL,
-      pane TEXT NOT NULL,
-      session_name TEXT,
-      window_name TEXT,
-      agent_name TEXT,
-      pi_session TEXT,
-      workstream TEXT,
-      role TEXT,
-      cli TEXT,
-      driver TEXT,
-      kind TEXT NOT NULL,
-      state TEXT NOT NULL,
-      message TEXT NOT NULL,
-      pid INTEGER,
-      synthetic INTEGER NOT NULL,
-      reason TEXT NOT NULL,
-      extra TEXT NOT NULL,
-      PRIMARY KEY (host_id, seq)
-    );
-    CREATE INDEX IF NOT EXISTS events_agent_seq ON events (agent_id, seq);
-    CREATE TABLE IF NOT EXISTS peers (
-      name TEXT PRIMARY KEY,
-      target TEXT NOT NULL,
-      host_id TEXT,
-      display_name TEXT,
-      watermark INTEGER NOT NULL,
-      fetched_at INTEGER,
-      -- When a jump last proved this peer's tmux was not answering. Reader
-      -- state, not an event: this node cannot author facts about another
-      -- node's agents, and a jump is a local observation, not something the
-      -- peer said. Cleared by the next successful collect.
-      tmux_down_at INTEGER
-    );
-  `);
-  try {
-    database.exec("ALTER TABLE peers ADD COLUMN tmux_down_at INTEGER");
-  } catch {
+  database.pragma("busy_timeout = 5000");
+  const version = database.pragma("user_version", { simple: true }) ?? 0;
+  if (version !== SCHEMA_USER_VERSION) {
+    database.exec(SCHEMA);
+    database.pragma(`user_version = ${SCHEMA_USER_VERSION}`);
+    const restore = database.prepare("INSERT OR IGNORE INTO peers (name, target) VALUES (?, ?)");
+    for (const peer of salvaged) restore.run(peer.name, peer.target);
   }
-  if (salvagedPeers.length > 0) {
-    const restore = database.prepare(
-      `INSERT OR IGNORE INTO peers (name, target, host_id, display_name, watermark, fetched_at)
-       VALUES (?, ?, ?, ?, 0, NULL)`
-    );
-    for (const peer of salvagedPeers) {
-      restore.run(peer.name, peer.target, peer.host_id ?? null, peer.display_name ?? null);
-    }
-  }
-  const eventColumns = `
-      host_id, seq, ts, agent_id, session, window, pane,
-      session_name, window_name, agent_name, pi_session,
-      workstream, role, cli, driver, kind, state, message, pid,
-      synthetic, reason, extra`;
-  const eventPlaceholders = new Array(22).fill("?").join(", ");
-  const insertEvent = database.prepare(
-    `INSERT INTO events (${eventColumns}) VALUES (${eventPlaceholders})`
-  );
-  const ingestEvent = database.prepare(
-    `INSERT OR IGNORE INTO events (${eventColumns}) VALUES (${eventPlaceholders})`
+  const selectAgentByPane = database.prepare("SELECT * FROM agents WHERE pane = ?");
+  const insertAgent = database.prepare(`
+    INSERT INTO agents (agent_id, pane, owner_pid, activity, session, window,
+                        session_name, window_name, agent_name, pi_session,
+                        workstream, role, cli, driver, claimed_at, updated_at)
+    VALUES (@agent_id, @pane, @owner_pid, @activity, @session, @window,
+            @session_name, @window_name, @agent_name, @pi_session,
+            @workstream, @role, @cli, @driver, @claimed_at, @updated_at)
+  `);
+  const retainAgent = database.prepare(`
+    UPDATE agents
+       SET session = @session, window = @window, session_name = @session_name,
+           window_name = @window_name, agent_name = @agent_name,
+           pi_session = @pi_session, workstream = @workstream, role = @role,
+           cli = @cli, driver = @driver, updated_at = @updated_at
+     WHERE agent_id = @agent_id
+  `);
+  const deleteAgentByPane = database.prepare("DELETE FROM agents WHERE pane = ?");
+  const deleteAttentionForPane = database.prepare("DELETE FROM attention WHERE pane = ?");
+  const updateActivity = database.prepare(`
+    UPDATE agents
+       SET activity = @activity, session = @session, window = @window,
+           session_name = @session_name, window_name = @window_name,
+           updated_at = @updated_at
+     WHERE agent_id = @agent_id AND owner_pid = @owner_pid
+  `);
+  const deleteAgentOwned = database.prepare(
+    "DELETE FROM agents WHERE agent_id = ? AND owner_pid = ?"
   );
-  const selectMaxSeq = database.prepare(
-    "SELECT COALESCE(MAX(seq), 0) AS seq FROM events WHERE host_id = ?"
+  const upsertAttention = database.prepare(`
+    INSERT INTO attention (pane, kind, message, source, session, window,
+                           session_name, window_name, requested_at)
+    VALUES (@pane, @kind, @message, @source, @session, @window,
+            @session_name, @window_name, @requested_at)
+    ON CONFLICT (pane, kind) DO UPDATE SET
+      message = excluded.message,
+      source = excluded.source,
+      session = excluded.session,
+      window = excluded.window,
+      session_name = excluded.session_name,
+      window_name = excluded.window_name
+  `);
+  const selectAgents = database.prepare("SELECT * FROM agents");
+  const selectAttention = database.prepare("SELECT * FROM attention");
+  const setActivityByPane = database.prepare(
+    "UPDATE agents SET activity = ?, updated_at = ? WHERE pane = ?"
   );
-  const append = database.transaction((event) => {
-    const row = selectMaxSeq.get(identity.host_id);
-    const stored = {
-      ...event,
-      host_id: identity.host_id,
-      seq: row.seq + 1,
-      ts: event.ts ?? Date.now(),
-      session_name: event.session_name ?? null,
-      window_name: event.window_name ?? null,
-      agent_name: event.agent_name ?? null,
-      pi_session: event.pi_session ?? null
+  const claimAgent = database.transaction((claim) => {
+    const now = claim.now ?? Date.now();
+    const isAlive = claim.isAlive ?? pidAlive;
+    const { location, meta, owner_pid } = claim;
+    const incumbent = selectAgentByPane.get(location.pane);
+    const values = {
+      pane: location.pane,
+      owner_pid,
+      session: location.session,
+      window: location.window,
+      session_name: location.session_name,
+      window_name: location.window_name,
+      agent_name: meta.agent_name,
+      pi_session: meta.pi_session,
+      workstream: meta.workstream,
+      role: meta.role,
+      cli: meta.cli,
+      driver: meta.driver,
+      updated_at: now
     };
-    insertEvent.run(...eventValues(stored));
-    return stored;
-  });
-  const ingest = database.transaction((events) => {
-    let inserted = 0;
-    for (const event of events) inserted += ingestEvent.run(...eventValues(event)).changes;
-    return inserted;
+    if (!incumbent) {
+      const agentId2 = randomUUID();
+      insertAgent.run({ ...values, agent_id: agentId2, activity: "stopped", claimed_at: now });
+      return { outcome: "claimed", agent_id: agentId2 };
+    }
+    if (incumbent.owner_pid === owner_pid) {
+      retainAgent.run({ ...values, agent_id: incumbent.agent_id });
+      return { outcome: "retained", agent_id: incumbent.agent_id };
+    }
+    if (isAlive(incumbent.owner_pid)) {
+      return { outcome: "refused", held_by_pid: incumbent.owner_pid };
+    }
+    deleteAgentByPane.run(location.pane);
+    deleteAttentionForPane.run(location.pane);
+    const agentId = randomUUID();
+    insertAgent.run({ ...values, agent_id: agentId, activity: "stopped", claimed_at: now });
+    return { outcome: "replaced", agent_id: agentId, previous_agent_id: incumbent.agent_id };
+  }).immediate;
+  const reconcileLocal = database.transaction((world) => {
+    const summary = { crashed: [], removed: [], attention_removed: [] };
+    if (world.panes === null) return summary;
+    const live = world.panes;
+    const isAlive = world.isAlive ?? pidAlive;
+    const now = world.now ?? Date.now();
+    const alreadyCrashed = new Set(
+      selectAttention.all().filter((row) => row.kind === "crashed").map((row) => row.pane)
+    );
+    for (const row of selectAgents.all()) {
+      const pane = asPaneId(row.pane);
+      if (!live.has(pane)) {
+        deleteAgentByPane.run(row.pane);
+        deleteAttentionForPane.run(row.pane);
+        summary.removed.push(pane);
+        continue;
+      }
+      if (isAlive(row.owner_pid)) continue;
+      if (row.activity === "running") {
+        setActivityByPane.run("stopped", now, row.pane);
+        upsertAttention.run({
+          pane: row.pane,
+          kind: "crashed",
+          message: "",
+          source: "murmur",
+          session: row.session,
+          window: row.window,
+          session_name: row.session_name,
+          window_name: row.window_name,
+          requested_at: now
+        });
+        summary.crashed.push(pane);
+      } else if (!alreadyCrashed.has(row.pane)) {
+        deleteAgentByPane.run(row.pane);
+        summary.removed.push(pane);
+      }
+    }
+    for (const row of selectAttention.all()) {
+      const pane = asPaneId(row.pane);
+      if (live.has(pane)) continue;
+      deleteAttentionForPane.run(row.pane);
+      if (!summary.attention_removed.includes(pane)) summary.attention_removed.push(pane);
+    }
+    return summary;
+  }).immediate;
+  const readLocalPanes = database.transaction(() => {
+    const agents = selectAgents.all();
+    const attention = selectAttention.all();
+    const panes = /* @__PURE__ */ new Map();
+    const locate = (row) => {
+      const existing = panes.get(row.pane);
+      if (existing) return existing;
+      const created = {
+        pane: asPaneId(row.pane),
+        session: asSessionId(row.session),
+        window: asWindowId(row.window),
+        session_name: row.session_name,
+        window_name: row.window_name,
+        agent: null,
+        attention: []
+      };
+      panes.set(row.pane, created);
+      return created;
+    };
+    for (const row of agents) locate(row).agent = toAgent(row);
+    for (const row of attention) locate(row).attention.push(toAttention(row));
+    for (const pane of panes.values()) pane.attention.sort(attentionOrder);
+    return [...panes.values()].sort((left, right) => left.pane.localeCompare(right.pane));
   });
+  function peerRecord(row) {
+    let snapshot = null;
+    if (row.snapshot !== null) {
+      try {
+        snapshot = JSON.parse(row.snapshot);
+      } catch {
+        snapshot = null;
+      }
+    }
+    return {
+      name: row.name,
+      target: row.target,
+      host_id: row.host_id,
+      display_name: row.display_name,
+      snapshot,
+      snapshot_at: row.snapshot_at,
+      fetched_at: row.fetched_at,
+      last_attempt_at: row.last_attempt_at,
+      last_error: row.last_error,
+      murmur_version: row.murmur_version,
+      snapshot_version: row.snapshot_version
+    };
+  }
   return {
-    append,
-    ingest,
-    eventsSince(hostId, seq) {
-      const rows = database.prepare("SELECT * FROM events WHERE host_id = ? AND seq > ? ORDER BY seq").all(hostId, seq);
-      return rows.map(toEvent);
+    claimAgent,
+    reconcileLocal,
+    setActivity(update) {
+      return updateActivity.run({
+        activity: update.activity,
+        session: update.location.session,
+        window: update.location.window,
+        session_name: update.location.session_name,
+        window_name: update.location.window_name,
+        updated_at: update.now ?? Date.now(),
+        agent_id: update.agent_id,
+        owner_pid: update.owner_pid
+      }).changes === 1;
     },
-    allEvents() {
-      const rows = database.prepare("SELECT * FROM events ORDER BY ts, host_id, seq").all();
-      return rows.map(toEvent);
+    releaseAgent(release) {
+      return deleteAgentOwned.run(release.agent_id, release.owner_pid).changes === 1;
     },
-    latestForAgent(hostId, agentId) {
-      const row = database.prepare(
-        `SELECT * FROM events
-            WHERE host_id = ? AND agent_id = ?
-            ORDER BY seq DESC LIMIT 1`
-      ).get(hostId, agentId);
-      return row ? toEvent(row) : null;
-    },
-    maxSeq(hostId) {
-      return selectMaxSeq.get(hostId).seq;
-    },
-    prune(horizonMs = Number(process.env.MURMUR_RETENTION_MS ?? DEFAULT_RETENTION_MS)) {
-      return database.prepare(`
-          DELETE FROM events
-           WHERE ts < ?
-             AND (host_id, seq) NOT IN (
-               SELECT host_id, seq FROM (
-                 SELECT host_id, seq,
-                        ROW_NUMBER() OVER (PARTITION BY agent_id ORDER BY ts DESC, seq DESC) rn
-                   FROM events
-               ) WHERE rn = 1
-             )
-        `).run(Date.now() - horizonMs).changes;
+    requestAttention(request) {
+      upsertAttention.run({
+        pane: request.location.pane,
+        kind: request.kind,
+        message: request.message,
+        source: request.source,
+        session: request.location.session,
+        window: request.location.window,
+        session_name: request.location.session_name,
+        window_name: request.location.window_name,
+        requested_at: request.now ?? Date.now()
+      });
     },
-    peers() {
-      return database.prepare("SELECT * FROM peers ORDER BY name").all();
+    acknowledgePane(pane) {
+      return deleteAttentionForPane.run(pane).changes;
     },
-    forgetAgent(agentId) {
-      return database.prepare("DELETE FROM events WHERE agent_id = ?").run(agentId).changes;
+    localPanes() {
+      return readLocalPanes();
     },
-    forgetHost(hostId) {
-      return database.prepare("DELETE FROM events WHERE host_id = ?").run(hostId).changes;
+    buildLocalSnapshot(identity, world) {
+      reconcileLocal(world);
+      return {
+        murmur_snapshot: 1,
+        host_id: identity.host_id,
+        display_name: identity.display_name,
+        murmur_version: MURMUR_VERSION,
+        generated_at: world.now ?? Date.now(),
+        // Rule 3: a pane with no agent and no attention must not be published.
+        // A no-op against today's `readLocalPanes`, which builds a pane entry
+        // only from a row and so cannot produce an empty one -- kept because the
+        // rule belongs to the DOCUMENT, and the validator rejects such an entry
+        // outright. Without it, one narrowing of the local read would make this
+        // node reachable-but-broken on every peer that collects it, and the
+        // symptom would show up on the other machines.
+        panes: readLocalPanes().filter((pane) => pane.agent !== null || pane.attention.length > 0)
+      };
     },
-    upsertPeer(peer) {
-      const current = database.prepare("SELECT * FROM peers WHERE name = ?").get(peer.name);
-      database.prepare(`
-          INSERT INTO peers (name, target, host_id, display_name, watermark, fetched_at, tmux_down_at)
-          VALUES (?, ?, ?, ?, ?, ?, ?)
-          ON CONFLICT(name) DO UPDATE SET
-            target = excluded.target,
-            host_id = excluded.host_id,
-            display_name = excluded.display_name,
-            watermark = excluded.watermark,
-            fetched_at = excluded.fetched_at,
-            tmux_down_at = excluded.tmux_down_at
-        `).run(
-        peer.name,
-        peer.target,
-        peer.host_id !== void 0 ? peer.host_id : current?.host_id ?? null,
-        peer.display_name !== void 0 ? peer.display_name : current?.display_name ?? null,
-        peer.watermark !== void 0 ? peer.watermark : current?.watermark ?? 0,
-        peer.fetched_at !== void 0 ? peer.fetched_at : current?.fetched_at ?? null,
-        peer.tmux_down_at !== void 0 ? peer.tmux_down_at : current?.tmux_down_at ?? null
+    peers() {
+      return database.prepare("SELECT * FROM peers ORDER BY name").all().map(
+        peerRecord
       );
     },
+    addPeer(name, target) {
+      database.prepare(
+        `INSERT INTO peers (name, target) VALUES (?, ?)
+           ON CONFLICT(name) DO UPDATE SET target = excluded.target`
+      ).run(name, target);
+    },
     removePeer(name) {
       return database.prepare("DELETE FROM peers WHERE name = ?").run(name).changes > 0;
     },
+    replacePeerSnapshot(name, fetch) {
+      if (!fetch.ok) {
+        database.prepare("UPDATE peers SET last_attempt_at = ?, last_error = ? WHERE name = ?").run(fetch.at, fetch.error, name);
+        return;
+      }
+      database.prepare(
+        `UPDATE peers
+              SET snapshot = ?, snapshot_at = ?, fetched_at = ?, last_attempt_at = ?,
+                  last_error = NULL, host_id = ?, display_name = ?,
+                  murmur_version = ?, snapshot_version = ?
+            WHERE name = ?`
+      ).run(
+        JSON.stringify(fetch.snapshot),
+        fetch.snapshot.generated_at,
+        fetch.at,
+        fetch.at,
+        fetch.snapshot.host_id,
+        fetch.snapshot.display_name,
+        fetch.snapshot.murmur_version,
+        fetch.snapshot.murmur_snapshot,
+        name
+      );
+    },
     close() {
       database.close();
     }
@@ -387,72 +678,32 @@ function openStore() {
 }
 
 // src/cli/clear.ts
-function windowHasAgent(window, focused, hostId, mux, store) {
-  if (!hostId) return false;
-  const siblings = mux.panesInWindow(window).filter((candidate) => candidate !== focused);
-  if (siblings.length === 0) return false;
-  if (!store) return false;
-  try {
-    for (const sibling of siblings) {
-      const latest = store.latestForAgent(hostId, `${hostId}:${sibling}`);
-      if (latest && latest.state !== "cleared") return true;
-    }
-    return false;
-  } catch {
-    return true;
-  }
+function windowBadge(window, mux, store) {
+  const panes = new Set(mux.panesInWindow(window));
+  const states = store.localPanes().filter((pane) => panes.has(pane.pane)).map(
+    (pane) => renderState({
+      activity: pane.agent?.activity ?? null,
+      attention: pane.attention.map((entry) => entry.kind)
+    })
+  );
+  return RENDER_PRIORITY.find((state) => state !== "idle" && states.includes(state)) ?? null;
 }
-function clearPane(pane, mux = tmux) {
+function clearPane(raw, mux = tmux) {
   let store;
   try {
-    if (!pane) return;
+    if (!raw) return;
+    const pane = asPaneId(raw);
     const window = mux.windowForPane(pane);
-    const identity = loadIdentity();
-    let owner;
-    if (identity) {
-      try {
-        store = openStore();
-        owner = store.latestForAgent(identity.host_id, `${identity.host_id}:${pane}`) ?? void 0;
-      } catch {
-      }
-    }
-    if (!owner) {
-      if (window && !windowHasAgent(window, pane, identity?.host_id, mux, store)) {
-        mux.setState(window, null);
-      }
-      return;
-    }
-    if (owner.state === "cleared") {
-      mux.setState(owner.window, null);
-      return;
+    try {
+      store = openStore();
+      store.acknowledgePane(pane);
+    } catch {
     }
+    if (!window) return;
     try {
-      store?.append({
-        agent_id: owner.agent_id,
-        session: owner.session,
-        window: owner.window,
-        pane: owner.pane,
-        // Carry the names forward: a `cleared` row that drops them makes the
-        // agent's last event nameless, which is what left "@75" in the picker.
-        session_name: owner.session_name,
-        window_name: owner.window_name,
-        agent_name: owner.agent_name,
-        pi_session: owner.pi_session,
-        workstream: owner.workstream,
-        role: owner.role,
-        cli: owner.cli,
-        driver: owner.driver,
-        kind: "state",
-        state: "cleared",
-        message: "",
-        pid: null,
-        synthetic: false,
-        reason: "",
-        extra: {}
-      });
+      mux.setWindowBadge(window, store ? windowBadge(window, mux, store) : null);
     } catch {
     }
-    mux.setState(owner.window, null);
   } catch {
   } finally {
     try {
@@ -462,7 +713,7 @@ function clearPane(pane, mux = tmux) {
   }
 }
 function registerClear(program2) {
-  program2.command("clear").description("Clear attention for the agent in a pane").option("--pane <pane-id>", "focused tmux pane id").action((options) => clearPane(options.pane ?? ""));
+  program2.command("clear").description("Acknowledge attention for a pane").option("--pane <pane-id>", "focused tmux pane id").action((options) => clearPane(options.pane ?? ""));
 }
 
 // src/channel.ts
@@ -502,193 +753,166 @@ function hasWarmSocket(target) {
   }
 }
 
-// src/types.ts
-var DEFAULT_DRIVER = "human";
-
-// src/fold.ts
-function foldAgent(events, isAlive) {
-  for (let index = events.length - 1; index >= 0; index -= 1) {
-    const event = events[index];
-    if (!event) continue;
-    switch (event.state) {
-      case "blocked":
-      case "done":
-      case "crashed":
-        return { state: event.state, event };
-      case "cleared":
-        return { state: null, event: null };
-      case "working":
-        return {
-          state: event.pid !== null && event.pid > 0 && isAlive(event.pid) ? "working" : "crashed",
-          event
-        };
-    }
+// src/snapshot.ts
+var SnapshotInvalidError = class extends Error {
+  constructor(path, detail) {
+    super(path === "" ? detail : `${path}: ${detail}`);
+    this.path = path;
+    this.name = "SnapshotInvalidError";
+  }
+  path;
+};
+function fail(path, detail) {
+  throw new SnapshotInvalidError(path, detail);
+}
+function object(value, path, keys) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    fail(path, "expected an object");
   }
-  return { state: null, event: null };
-}
-function foldAll(events, isAlive) {
-  const byAgent = /* @__PURE__ */ new Map();
-  for (const event of events) {
-    const agentEvents = byAgent.get(event.agent_id);
-    if (agentEvents) agentEvents.push(event);
-    else byAgent.set(event.agent_id, [event]);
+  const record = value;
+  for (const key of keys) if (!(key in record)) fail(path, `missing key ${key}`);
+  for (const key of Object.keys(record)) {
+    if (!keys.includes(key)) fail(path, `unknown key ${key}`);
   }
-  return [...byAgent.values()].map((agentEvents) => {
-    const folded = foldAgent(agentEvents, isAlive);
-    const source = folded.event ?? agentEvents[agentEvents.length - 1];
-    if (!source) throw new Error("agent event group cannot be empty");
-    return {
-      agent_id: source.agent_id,
-      host_id: source.host_id,
-      state: folded.state,
-      event: folded.event,
-      workstream: source.workstream,
-      role: source.role,
-      cli: source.cli,
-      driver: source.driver ?? DEFAULT_DRIVER,
-      session: source.session,
-      window: source.window,
-      pane: source.pane,
-      session_name: source.session_name,
-      window_name: source.window_name,
-      agent_name: source.agent_name,
-      pi_session: source.pi_session,
-      fetched_at: null
-    };
-  });
+  return record;
 }
-var ATTENTION_ORDER = {
-  blocked: 0,
-  done: 1,
-  crashed: 2,
-  working: 3,
-  cleared: 4
-};
-function attentionSort(views) {
-  return [...views].sort((left, right) => {
-    const stateOrder = (left.state === null ? 4 : ATTENTION_ORDER[left.state]) - (right.state === null ? 4 : ATTENTION_ORDER[right.state]);
-    if (stateOrder !== 0) return stateOrder;
-    return (right.event?.ts ?? 0) - (left.event?.ts ?? 0);
-  });
+function text(value, path) {
+  if (typeof value !== "string" || value === "") fail(path, "expected a non-empty string");
+  return value;
 }
-function isStale(fetchedAt, now, thresholdMs = 6e4) {
-  return fetchedAt !== null && now - fetchedAt > thresholdMs;
+function textOrNull(value, path) {
+  if (value === null) return null;
+  if (typeof value !== "string") fail(path, "expected a string or null");
+  return value;
 }
-
-// src/export.ts
-var SCHEMA_VERSION = 2;
-var EVENT_FIELDS = /* @__PURE__ */ new Set([
+function anyText(value, path) {
+  if (typeof value !== "string") fail(path, "expected a string");
+  return value;
+}
+function timestamp(value, path) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    fail(path, "expected a non-negative integer");
+  }
+  return value;
+}
+function member(value, path, allowed) {
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    fail(path, `expected one of ${allowed.join(", ")}`);
+  }
+  return value;
+}
+var ACTIVITIES = ["running", "stopped"];
+var DRIVERS = ["human", "orchestrated"];
+var KINDS = ["done", "blocked", "crashed"];
+var TOP_KEYS = [
+  "murmur_snapshot",
   "host_id",
-  "seq",
-  "ts",
-  "agent_id",
+  "display_name",
+  "murmur_version",
+  "generated_at",
+  "panes"
+];
+var PANE_KEYS = [
+  "pane",
   "session",
   "window",
-  "pane",
   "session_name",
   "window_name",
+  "agent",
+  "attention"
+];
+var AGENT_KEYS = [
+  "agent_id",
+  "activity",
   "agent_name",
   "pi_session",
   "workstream",
   "role",
   "cli",
   "driver",
-  "kind",
-  "state",
-  "message",
-  "pid",
-  "synthetic",
-  "reason"
-]);
-function eventToWire(event) {
-  const { extra, ...known } = event;
-  return { ...extra, ...known };
-}
-function eventFromWire(wire) {
-  const extra = Object.fromEntries(Object.entries(wire).filter(([key]) => !EVENT_FIELDS.has(key)));
+  "claimed_at",
+  "updated_at"
+];
+var ATTENTION_KEYS = ["kind", "message", "source", "requested_at"];
+function parseAgent(value, path) {
+  if (value === null) return null;
+  const row = object(value, path, AGENT_KEYS);
   return {
-    host_id: wire.host_id,
-    seq: wire.seq,
-    ts: wire.ts,
-    agent_id: wire.agent_id,
-    session: wire.session,
-    window: wire.window,
-    pane: wire.pane,
-    session_name: wire.session_name ?? null,
-    window_name: wire.window_name ?? null,
-    agent_name: wire.agent_name ?? null,
-    pi_session: wire.pi_session ?? null,
-    workstream: wire.workstream ?? null,
-    role: wire.role ?? null,
-    cli: wire.cli ?? null,
-    driver: wire.driver ?? null,
-    kind: wire.kind,
-    state: wire.state,
-    message: wire.message,
-    pid: wire.pid ?? null,
-    synthetic: wire.synthetic,
-    reason: wire.reason,
-    extra
+    agent_id: text(row.agent_id, `${path}.agent_id`),
+    activity: member(row.activity, `${path}.activity`, ACTIVITIES),
+    agent_name: textOrNull(row.agent_name, `${path}.agent_name`),
+    pi_session: textOrNull(row.pi_session, `${path}.pi_session`),
+    workstream: textOrNull(row.workstream, `${path}.workstream`),
+    role: textOrNull(row.role, `${path}.role`),
+    cli: text(row.cli, `${path}.cli`),
+    driver: member(row.driver, `${path}.driver`, DRIVERS),
+    claimed_at: timestamp(row.claimed_at, `${path}.claimed_at`),
+    updated_at: timestamp(row.updated_at, `${path}.updated_at`)
   };
 }
-function synthesizeCrashes(store, hostId, isAlive) {
-  const byAgent = /* @__PURE__ */ new Map();
-  for (const event of store.allEvents()) {
-    if (event.host_id !== hostId) continue;
-    const events = byAgent.get(event.agent_id);
-    if (events) events.push(event);
-    else byAgent.set(event.agent_id, [event]);
-  }
-  for (const events of byAgent.values()) {
-    events.sort((left, right) => left.seq - right.seq);
-    const newest = events.at(-1);
-    if (newest && newest.state === "working" && !newest.synthetic && foldAgent(events, isAlive).state === "crashed") {
-      const { host_id: _hostId, seq: _seq, ts: _ts, ...event } = newest;
-      store.append({ ...event, state: "crashed", synthetic: true, reason: "pid_gone" });
-    }
+function parseAttention(value, path) {
+  if (!Array.isArray(value)) fail(path, "expected an array");
+  const seen = /* @__PURE__ */ new Set();
+  return value.map((entry, index) => {
+    const at = `${path}[${index}]`;
+    const row = object(entry, at, ATTENTION_KEYS);
+    const kind = member(row.kind, `${at}.kind`, KINDS);
+    if (seen.has(kind)) fail(`${at}.kind`, `duplicate kind ${kind} for this pane`);
+    seen.add(kind);
+    return {
+      kind,
+      message: anyText(row.message, `${at}.message`),
+      source: anyText(row.source, `${at}.source`),
+      requested_at: timestamp(row.requested_at, `${at}.requested_at`)
+    };
+  });
+}
+function parsePane(value, path) {
+  const row = object(value, path, PANE_KEYS);
+  const agent = parseAgent(row.agent, `${path}.agent`);
+  const attention = parseAttention(row.attention, `${path}.attention`);
+  if (agent === null && attention.length === 0) {
+    fail(path, "a pane with no agent and no attention must not be emitted");
   }
+  return {
+    pane: asPaneId(text(row.pane, `${path}.pane`)),
+    session: asSessionId(text(row.session, `${path}.session`)),
+    window: asWindowId(text(row.window, `${path}.window`)),
+    session_name: textOrNull(row.session_name, `${path}.session_name`),
+    window_name: textOrNull(row.window_name, `${path}.window_name`),
+    agent,
+    attention
+  };
 }
-function clearDeadWindows(store, hostId, live) {
-  if (live === null) return;
-  const newest = /* @__PURE__ */ new Map();
-  for (const event of store.allEvents()) {
-    if (event.host_id !== hostId) continue;
-    const previous = newest.get(event.agent_id);
-    if (!previous || event.seq > previous.seq) newest.set(event.agent_id, event);
+function parseSnapshot(input) {
+  let parsed;
+  try {
+    parsed = JSON.parse(input);
+  } catch (error) {
+    fail("", `not JSON (${error instanceof Error ? error.message : String(error)})`);
   }
-  for (const event of newest.values()) {
-    if (event.state === "cleared") continue;
-    if (live.has(event.window)) continue;
-    const { host_id: _hostId, seq: _seq, ts: _ts, ...rest } = event;
-    store.append({
-      ...rest,
-      state: "cleared",
-      synthetic: true,
-      reason: "window_gone",
-      message: ""
-    });
+  const top = object(parsed, "", TOP_KEYS);
+  if (top.murmur_snapshot !== 1) {
+    fail("murmur_snapshot", `expected 1, got ${JSON.stringify(top.murmur_snapshot)}`);
   }
-}
-function exportJsonl(store, since, isAlive, live) {
-  const identity = ensureIdentity();
-  synthesizeCrashes(store, identity.host_id, isAlive);
-  if (live !== void 0) clearDeadWindows(store, identity.host_id, live);
-  const envelope = {
-    schema_version: SCHEMA_VERSION,
-    host_id: identity.host_id,
-    display_name: identity.display_name,
-    exported_at: Date.now()
+  if (!Array.isArray(top.panes)) fail("panes", "expected an array");
+  const panes = top.panes.map((entry, index) => parsePane(entry, `panes[${index}]`));
+  const seen = /* @__PURE__ */ new Set();
+  for (const pane of panes) {
+    if (seen.has(pane.pane)) fail("panes", `duplicate pane ${pane.pane}`);
+    seen.add(pane.pane);
+  }
+  return {
+    murmur_snapshot: 1,
+    host_id: text(top.host_id, "host_id"),
+    display_name: text(top.display_name, "display_name"),
+    murmur_version: text(top.murmur_version, "murmur_version"),
+    generated_at: timestamp(top.generated_at, "generated_at"),
+    panes
   };
-  const lines = [
-    JSON.stringify(envelope),
-    ...store.eventsSince(identity.host_id, since).map((event) => JSON.stringify(eventToWire(event)))
-  ];
-  return `${lines.join("\n")}
-`;
 }
 
 // src/collector.ts
-var STALENESS_MS = 6e4;
 var MAX_CONCURRENT_PEERS = 8;
 var COLLECT_DEADLINE_MS = 4e3;
 async function mapSettled(items, limit, task, deadline) {
@@ -712,20 +936,30 @@ async function mapSettled(items, limit, task, deadline) {
   await (stop ? Promise.race([pool, stop]) : pool);
   return results;
 }
-function parseJsonl(output) {
-  const lines = output.trim().split("\n");
-  const envelope = JSON.parse(lines.shift() ?? "");
-  if (envelope.schema_version > SCHEMA_VERSION) {
-    throw new Error(
-      `unsupported schema version ${envelope.schema_version} (supports ${SCHEMA_VERSION})`
-    );
+function isUnreachable(message) {
+  return /Host is down|No route to host|Connection refused|Connection timed out|Connection closed|Operation timed out|Network is unreachable|Name or service not known|Could not resolve hostname|timed out after/i.test(
+    message
+  ) || /\bssh:/.test(message);
+}
+function stripInvocation(message) {
+  const firstLine = message.indexOf("\n");
+  if (firstLine === -1 || !message.startsWith("Command failed:")) return message;
+  const rest = message.slice(firstLine + 1).trim();
+  return rest === "" ? message : rest;
+}
+function normalizeFailure(message) {
+  return stripInvocation(message).replace(/\s+/g, " ").trim();
+}
+function describeFailure(peer, message) {
+  const collapsed = normalizeFailure(message);
+  if (isUnreachable(collapsed)) {
+    const reason = /ssh: (?:connect to host \S+ port \d+: )?(.+?)(?: \(|$)/i.exec(collapsed);
+    return `${peer}: unreachable (${(reason?.[1] ?? "ssh failed").trim()})`;
   }
-  return {
-    envelope,
-    events: lines.map((line) => eventFromWire(JSON.parse(line)))
-  };
+  const detail = collapsed.length > 160 ? `${collapsed.slice(0, 157)}...` : collapsed;
+  return `${peer}: ${detail}`;
 }
-async function collect(store, channel, now = Date.now(), deadline) {
+async function collect(store, channel, now = Date.now(), deadline, mux = tmux) {
   const results = [];
   let timer;
   try {
@@ -737,9 +971,7 @@ async function collect(store, channel, now = Date.now(), deadline) {
     const fetches = await mapSettled(
       peers,
       MAX_CONCURRENT_PEERS,
-      async (peer) => parseJsonl(
-        await channel.exec(peer.target, ["murmur", "export", "--since", String(peer.watermark)])
-      ),
+      async (peer) => parseSnapshot(await channel.exec(peer.target, ["murmur", "export"])),
       bounded
     );
     for (const [index, peer] of peers.entries()) {
@@ -747,68 +979,98 @@ async function collect(store, channel, now = Date.now(), deadline) {
       try {
         if (!fetch) throw new Error("collect deadline passed before this peer answered");
         if (fetch.status === "rejected") throw fetch.reason;
-        const { envelope, events } = fetch.value;
-        const ingested = store.ingest(events);
-        const origin = events.filter((event) => event.host_id === envelope.host_id);
-        const watermark = origin.reduce(
-          (highest, event) => Math.max(highest, event.seq),
-          peer.watermark
-        );
-        store.upsertPeer({
-          name: peer.name,
-          target: peer.target,
-          host_id: envelope.host_id,
-          display_name: envelope.display_name,
-          watermark,
-          fetched_at: now,
-          // New events mean the node is authoring again, so whatever a jump
-          // observed about its tmux is out of date. Only clear on actual new
-          // events: an export that returns nothing proves the binary ran, not
-          // that tmux is back, which is the distinction that let a dead host
-          // look healthy for three hours.
-          //
-          // Keyed on the watermark advancing, not on ingest's insert count.
-          // Two reasons the count was wrong. Ingest is INSERT OR IGNORE, so a
-          // retry after a partial apply re-sees the same events and reports
-          // zero -- leaving a recovered host marked down until it happened to
-          // author again. And the count includes rows from other origins that
-          // this peer merely relayed, which say nothing about whether this
-          // peer's tmux is back.
-          tmux_down_at: watermark > peer.watermark ? null : peer.tmux_down_at
-        });
-        results.push({ peer: peer.name, ok: true, ingested });
+        store.replacePeerSnapshot(peer.name, { ok: true, snapshot: fetch.value, at: now });
+        results.push({ peer: peer.name, ok: true, panes: fetch.value.panes.length });
       } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        process.stderr.write(`murmur: collect: peer ${peer.name}: ${message}
-`);
-        results.push({ peer: peer.name, ok: false, ingested: 0, error: message });
+        const message = normalizeFailure(error instanceof Error ? error.message : String(error));
+        store.replacePeerSnapshot(peer.name, { ok: false, error: message, at: now });
+        results.push({
+          peer: peer.name,
+          ok: false,
+          panes: 0,
+          error: message,
+          // A peer that answered with a bad document is reachable but broken,
+          // and must be visibly so rather than silently stale.
+          unreachable: error instanceof SnapshotInvalidError ? false : isUnreachable(normalizeFailure(message))
+        });
       }
     }
   } catch (error) {
-    process.stderr.write(
-      `murmur: collect: ${error instanceof Error ? error.message : String(error)}
-`
-    );
+    results.push({
+      peer: "",
+      ok: false,
+      panes: 0,
+      error: error instanceof Error ? error.message : String(error)
+    });
   } finally {
     clearTimeout(timer);
   }
   try {
-    store.prune();
-  } catch (error) {
-    process.stderr.write(
-      `murmur: collect: prune: ${error instanceof Error ? error.message : String(error)}
-`
-    );
+    store.reconcileLocal({ panes: mux.livePanes(), now });
+  } catch {
   }
   return results;
 }
 
+// src/identity.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync, mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "fs";
+import { hostname } from "os";
+import { join as join2 } from "path";
+function identityPath() {
+  return join2(stateDir(), "identity.json");
+}
+var cache = null;
+function loadIdentity() {
+  const path = identityPath();
+  if (cache?.path === path) return cache.identity;
+  const identity = existsSync(path) ? JSON.parse(readFileSync(path, "utf8")) : null;
+  cache = { path, identity };
+  return identity;
+}
+function write(identity) {
+  mkdirSync2(stateDir(), { recursive: true });
+  writeFileSync(identityPath(), `${JSON.stringify(identity, null, 2)}
+`);
+  cache = { path: identityPath(), identity };
+  return identity;
+}
+function createIdentity(displayName = hostname()) {
+  if (loadIdentity()) throw new Error(`identity already exists: ${identityPath()}`);
+  return write({ host_id: randomUUID2(), display_name: displayName });
+}
+function setDisplayName(displayName) {
+  const existing = loadIdentity();
+  return write(
+    existing ? { host_id: existing.host_id, display_name: displayName } : { host_id: randomUUID2(), display_name: displayName }
+  );
+}
+
+// src/cli/identity-guard.ts
+function requireIdentity() {
+  const identity = loadIdentity();
+  if (identity) return identity;
+  process.stderr.write("murmur is not initialised on this node; run: murmur init\n");
+  process.exitCode = 1;
+  return null;
+}
+
 // src/cli/collect.ts
 function registerCollect(program2) {
-  program2.command("collect").description("Collect events from configured peers").action(async () => {
+  program2.command("collect").description("Fetch each peer's snapshot").option("-q, --quiet", "report nothing, not even unreachable peers").action(async (options) => {
+    if (!requireIdentity()) return;
     const store = openStore();
     try {
-      await collect(store, ssh);
+      const results = await collect(store, ssh);
+      if (options.quiet) return;
+      for (const result of results) {
+        if (result.ok || !result.error) continue;
+        process.stderr.write(`murmur: ${describeFailure(result.peer, result.error)}
+`);
+      }
+      if (results.some((result) => !result.ok && !result.unreachable)) {
+        process.exitCode = 1;
+      }
     } finally {
       store.close();
     }
@@ -817,10 +1079,14 @@ function registerCollect(program2) {
 
 // src/cli/export.ts
 function registerExport(program2) {
-  program2.command("export").description("Export local events as JSONL").requiredOption("--since <seq>", "export events after this sequence", Number).action((options) => {
+  program2.command("export").description("Print this node's current-state snapshot").action(() => {
+    const identity = requireIdentity();
+    if (!identity) return;
     const store = openStore();
     try {
-      process.stdout.write(exportJsonl(store, options.since, pidAlive, tmux.liveWindows()));
+      const snapshot = store.buildLocalSnapshot(identity, { panes: tmux.livePanes() });
+      process.stdout.write(`${JSON.stringify(snapshot)}
+`);
     } finally {
       store.close();
     }
@@ -830,19 +1096,46 @@ function registerExport(program2) {
 // src/cli/init.ts
 function registerInit(program2) {
   program2.command("init").description("Initialize this node's identity").option("--name <name>", "display name").action((opts) => {
-    const identity = ensureIdentity(opts.name);
+    const existing = loadIdentity();
+    const identity = existing ? opts.name ? setDisplayName(opts.name) : existing : createIdentity(opts.name);
     console.log(`host_id: ${identity.host_id}`);
     console.log(`display_name: ${identity.display_name}`);
   });
 }
 
 // src/cli/link.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir2 } from "os";
-import { dirname, join as join3 } from "path";
+import { dirname as dirname2, join as join3 } from "path";
 import { fileURLToPath } from "url";
+var SHIM_MARKER = "// murmur:shim";
+function shim(entry, storePath) {
+  return `${SHIM_MARKER}
+// Generated by \`murmur link pi\`. Do not edit.
+//
+// A re-export, not a copy: the extension code lives in the murmur install, so
+// upgrading murmur upgrades the extension with no reinstall step. Re-run
+// \`murmur link pi\` only if the install path itself moves.
+//
+// The store path is set here rather than resolved by the extension. A bare
+// specifier cannot resolve from ~/.pi/agent/extensions, and the failure is
+// silent: the import throws, the extension swallows it, and every state report
+// is dropped while the tmux badge still paints.
+//
+// A dynamic import, not \`export ... from\`: ESM hoists static re-exports above
+// this assignment, so the extension loaded before the variable was set and read
+// undefined. Verified -- the static form printed \`undefined\` in the target.
+process.env.MURMUR_STORE_MODULE ??= ${JSON.stringify(storePath)};
+
+const { default: extension } = await import(${JSON.stringify(entry)});
+export default extension;
+`;
+}
 function registerLink(program2) {
-  program2.command("link").description("Install a murmur integration").argument("<target>", "integration to install").action((target) => {
+  program2.command("link").description("Install a murmur integration").argument("<target>", "integration to install").option(
+    "--copy",
+    "inline the extension instead of re-exporting it (pins to this version; needs re-linking after an upgrade)"
+  ).action((target, options) => {
     if (target !== "pi") throw new Error(`unsupported link target: ${target}`);
     const destination = join3(
       process.env.MURMUR_PI_HOME ?? homedir2(),
@@ -851,12 +1144,32 @@ function registerLink(program2) {
       "extensions",
       "murmur.ts"
     );
-    mkdirSync2(dirname(destination), { recursive: true });
-    const source = readFileSync2(
-      fileURLToPath(new URL("./extension/murmur-pi.js", import.meta.url)),
-      "utf8"
-    );
+    mkdirSync3(dirname2(destination), { recursive: true });
+    const entry = fileURLToPath(new URL("./extension/murmur-pi.js", import.meta.url));
     const storePath = fileURLToPath(new URL("./extension/store.js", import.meta.url));
+    const identityMissing = loadIdentity() === null;
+    if (!options.copy) {
+      let replacedCopy = false;
+      try {
+        const existing = readFileSync2(destination, "utf8");
+        replacedCopy = !existing.includes(SHIM_MARKER);
+      } catch {
+      }
+      writeFileSync2(destination, shim(entry, storePath));
+      console.log(destination);
+      if (replacedCopy) {
+        console.log(
+          "Replaced an inlined copy from an older murmur. That copy was pinned to the version that wrote it, so it had stopped picking up fixes; running agents keep the old code until they restart."
+        );
+      }
+      if (identityMissing) {
+        console.log(
+          "This node has no identity yet, so the extension will record nothing. Run: murmur init"
+        );
+      }
+      return;
+    }
+    const source = readFileSync2(entry, "utf8");
     const pinned = source.replace(
       /"@martintrojer\/murmur\/extension-store"/,
       JSON.stringify(storePath)
@@ -866,6 +1179,107 @@ function registerLink(program2) {
     }
     writeFileSync2(destination, pinned);
     console.log(destination);
+    if (identityMissing) {
+      console.log(
+        "This node has no identity yet, so the extension will record nothing. Run: murmur init"
+      );
+    }
+  });
+}
+
+// src/cli/notify.ts
+function notifyFields(input, payload = {}) {
+  const field = (key, flag) => {
+    if (flag) return clean(flag);
+    const value = payload[key];
+    return typeof value === "string" ? clean(value) : "";
+  };
+  const source = field("source", input.source) || "agent";
+  const title = field("title", input.title);
+  const eventType = field("type", input.eventType);
+  const message = field("message", input.message) || title || eventType || "attention";
+  return { source, message };
+}
+function clean(value) {
+  const flattened = [...value].map((character) => {
+    const code = character.charCodeAt(0);
+    const control = code < 32 || code === 127 || code >= 128 && code <= 159;
+    return control ? " " : character;
+  }).join("");
+  return flattened.replace(/\s+/g, " ").trim();
+}
+function parsePayload(raw) {
+  if (!raw.trim()) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function runNotify(store, input, payload = {}, mux = tmux) {
+  const location = resolveLocation(input.pane, mux);
+  if (!location) return false;
+  const { source, message } = notifyFields(input, payload);
+  store.requestAttention({
+    kind: "blocked",
+    location,
+    message,
+    // The harness name goes here, not in `driver`. `driver` answers "who is
+    // waiting on this agent" -- a human, or a supervisor consuming the result --
+    // and a codex agent driven by a human is `human` on exactly that question.
+    // `source` answers "who asked", which is the free-text field a new harness
+    // needs no schema change for.
+    source
+  });
+  mux.setWindowBadge(location.window, "blocked");
+  return true;
+}
+function resolveLocation(pane, mux) {
+  const here = mux.currentWindow();
+  if (!pane) return here;
+  const target = asPaneId(pane);
+  if (here && here.pane === target) return here;
+  if (here && mux.panesInWindow(here.window).includes(target)) {
+    return { ...here, pane: target };
+  }
+  return null;
+}
+function registerNotify(program2) {
+  program2.command("notify").description("Record an attention request for a harness that cannot report itself").option("--source <name>", "harness name, e.g. codex or opencode").option("--event-type <type>", "why attention is wanted").option("--title <title>", "harness display title").option("--message <message>", "the text to show").option("--pane <pane>", "pane to notify about (default: $TMUX_PANE)").action(
+    async (options) => {
+      const payload = parsePayload(await readStdin());
+      const store = openStore();
+      try {
+        runNotify(store, options, payload);
+      } finally {
+        store.close();
+      }
+    }
+  );
+}
+var STDIN_DEADLINE_MS = 250;
+async function readStdin() {
+  if (process.stdin.isTTY) return "";
+  const chunks = [];
+  return new Promise((resolve) => {
+    const onData = (chunk) => chunks.push(chunk);
+    const done = () => {
+      process.stdin.off("data", onData);
+      process.stdin.unref?.();
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    };
+    const timer = setTimeout(done, STDIN_DEADLINE_MS);
+    timer.unref?.();
+    process.stdin.on("data", onData);
+    process.stdin.once("end", () => {
+      clearTimeout(timer);
+      done();
+    });
+    process.stdin.once("error", () => {
+      clearTimeout(timer);
+      done();
+    });
   });
 }
 
@@ -873,6 +1287,7 @@ function registerLink(program2) {
 import { readFileSync as readFileSync3 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join4 } from "path";
+var SNAPSHOT_VERSION = 1;
 function parseSshHosts(config) {
   const hosts = [];
   for (const line of config.split("\n")) {
@@ -891,6 +1306,22 @@ function sshHosts() {
     return [];
   }
 }
+function lastSeen(fetchedAt, now) {
+  if (fetchedAt === null) return "never";
+  if (freshness(fetchedAt, now, STALENESS_MS) === "fresh") return "just now";
+  return `${age(now - fetchedAt)} ago`;
+}
+function versionCell(peer, ours = SNAPSHOT_VERSION) {
+  if (peer.murmur_version === null && peer.snapshot_version === null) {
+    return { text: "unknown", incompatible: false };
+  }
+  const version = peer.murmur_version ?? "unreported";
+  const incompatible = peer.snapshot_version !== null && peer.snapshot_version !== ours;
+  return {
+    text: incompatible ? `${version} (snapshot ${peer.snapshot_version} \u2260 ${ours})` : version,
+    incompatible
+  };
+}
 function formatTable(rows) {
   const widths = [];
   for (const row of rows) {
@@ -904,17 +1335,17 @@ function formatTable(rows) {
 `).join("");
 }
 function peerAddDecision(input) {
-  const { name, target, envelope, selfHostId, peers } = input;
-  if (!envelope) return null;
-  if (envelope.host_id === selfHostId) {
+  const { name, target, snapshot, selfHostId, peers } = input;
+  if (!snapshot) return null;
+  if (snapshot.host_id === selfHostId) {
     return `${target} is this node; not adding it as a peer
 `;
   }
   const existing = peers.find(
-    (candidate) => candidate.host_id === envelope.host_id && candidate.name !== name
+    (candidate) => candidate.host_id === snapshot.host_id && candidate.name !== name
   );
   if (existing) {
-    return `${target} is already configured as peer "${existing.name}" (${envelope.display_name}); remove it first to rename
+    return `${target} is already configured as peer "${existing.name}" (${snapshot.display_name}); remove it first to rename
 `;
   }
   return null;
@@ -924,17 +1355,16 @@ function registerPeer(program2) {
   peer.command("add").description("Add a peer and discover its identity").argument("<name>").argument("[target]").action(async (name, target = name) => {
     const store = openStore();
     try {
-      let envelope = null;
+      let snapshot = null;
       try {
-        const output = await ssh.exec(target, ["murmur", "export", "--since", "0"]);
-        envelope = JSON.parse(output.trim().split("\n")[0] ?? "");
+        snapshot = parseSnapshot(await ssh.exec(target, ["murmur", "export"]));
       } catch {
-        envelope = null;
+        snapshot = null;
       }
       const refusal = peerAddDecision({
         name,
         target,
-        envelope,
+        snapshot,
         selfHostId: loadIdentity()?.host_id ?? null,
         peers: store.peers()
       });
@@ -943,14 +1373,12 @@ function registerPeer(program2) {
         process.exitCode = 1;
         return;
       }
-      store.upsertPeer({
-        name,
-        target,
-        host_id: envelope?.host_id ?? null,
-        display_name: envelope?.display_name ?? null
-      });
+      store.addPeer(name, target);
+      if (snapshot) {
+        store.replacePeerSnapshot(name, { ok: true, snapshot, at: Date.now() });
+      }
       process.stdout.write(
-        envelope ? `Added ${name} (${envelope.display_name})
+        snapshot ? `Added ${name} (${snapshot.display_name})
 ` : `Added ${name} (identity pending)
 `
       );
@@ -972,40 +1400,111 @@ function registerPeer(program2) {
       store.close();
     }
   });
-  peer.command("list").description("List configured peers").option("--json", "print JSON").action((options) => {
+  peer.command("list").description("List peers; --all adds SSH hosts that could become peers").option("--json", "print JSON").option("-a, --all", "also show SSH hosts that are not peers yet").action((options) => {
     const store = openStore();
     try {
       const peers = store.peers();
+      const configured = new Map(peers.map((entry) => [entry.target, entry]));
+      const discovered = options.all ? sshHosts().filter((host) => !configured.has(host)) : [];
+      const now = Date.now();
+      const rows = [...configured.keys(), ...discovered].map((target) => {
+        const entry = configured.get(target);
+        return {
+          // The handle other commands take: a peer's name, or for a host that
+          // is not one yet, the ssh host `peer add` wants.
+          name: entry?.name ?? target,
+          target,
+          peer: entry !== void 0,
+          // What the node called itself. Shown, never typed: it can be a
+          // container id.
+          hostname: entry?.display_name ?? null,
+          // Being a peer is not the same as being reachable, and the old
+          // output said only the first. A node asleep for twelve hours read
+          // exactly like one polled a second ago.
+          last_seen: entry === void 0 ? null : lastSeen(entry.fetched_at, now),
+          // A warm ControlMaster socket makes a collect ~10ms instead of
+          // ~170ms, and is the only path that works on a host demanding a
+          // hardware-token touch per connection. A speed hint, never a
+          // requirement -- which is why the old bare `[x]` / `[ ]` was
+          // unreadable: it never said what was being checked.
+          //
+          // Safe for every row: `ssh -O check` talks to a local socket and
+          // never dials, so a host that is down or does not exist answers in
+          // ~16ms. Measured.
+          ssh: hasWarmSocket(target) ? "warm" : "cold",
+          // What it is running, or undefined when nothing is known -- either
+          // because the host is not a peer yet, or because it is a peer that
+          // has never answered. Undefined is what drops the column, so the
+          // test is "has anything told us", not "is this configured": a fleet
+          // of asleep peers must not buy a column of "unknown".
+          version: entry === void 0 || entry.murmur_version === null && entry.snapshot_version === null ? void 0 : versionCell(entry),
+          // Named where it can be acted on: a peer that answered with a bad
+          // document is reachable but broken, which is an operator task and
+          // reads nothing like a sleeping laptop.
+          error: entry?.last_error ?? null
+        };
+      });
       if (options.json) {
-        process.stdout.write(`${JSON.stringify(peers)}
+        process.stdout.write(`${JSON.stringify(rows)}
 `);
         return;
       }
-      if (peers.length === 0) {
-        process.stdout.write("no peers configured\n");
+      if (rows.length === 0) {
+        process.stdout.write(
+          options.all ? "no peers configured, and no hosts in ~/.ssh/config\n" : "no peers configured. See what could be added with: murmur peer list --all\n"
+        );
         return;
       }
-      const rows = [
-        // HOSTNAME, not HOST: this is what the node reported about itself,
-        // which is not the handle any other command takes. NAME is.
-        ["NAME", "TARGET", "HOSTNAME"],
-        ...peers.map((configured) => [
-          configured.name,
-          configured.target,
-          configured.display_name ?? "unknown"
+      const showPeerColumn = rows.some((row) => !row.peer);
+      const showVersionColumn = rows.some((row) => row.version !== void 0);
+      process.stdout.write(
+        formatTable([
+          [
+            "NAME",
+            "TARGET",
+            ...showPeerColumn ? ["PEER"] : [],
+            "HOSTNAME",
+            ...showVersionColumn ? ["VERSION"] : [],
+            "LAST SEEN",
+            "SSH"
+          ],
+          ...rows.map((row) => [
+            row.name,
+            row.target,
+            ...showPeerColumn ? [row.peer ? "yes" : "-"] : [],
+            row.hostname ?? "unknown",
+            ...showVersionColumn ? [row.version?.text ?? "-"] : [],
+            row.last_seen ?? "-",
+            row.ssh
+          ])
         ])
-      ];
-      process.stdout.write(formatTable(rows));
+      );
+      const incompatible = rows.filter((row) => row.version?.incompatible);
+      if (incompatible.length > 0) {
+        process.stdout.write(
+          `
+${incompatible.length} peer${incompatible.length === 1 ? "" : "s"} speak an incompatible snapshot version; state will not sync until murmur versions match: ${incompatible.map((row) => row.name).join(", ")}
+`
+        );
+      }
+      const broken = rows.filter((row) => row.error);
+      for (const row of broken) {
+        process.stdout.write(`
+${row.name}: last attempt failed -- ${row.error}
+`);
+      }
+      const addable = rows.filter((row) => !row.peer).length;
+      if (addable > 0) {
+        process.stdout.write(
+          `
+${addable} host${addable === 1 ? "" : "s"} not yet a peer. Add one with: murmur peer add <name>
+`
+        );
+      }
     } finally {
       store.close();
     }
   });
-  peer.command("discover").description("Check SSH hosts for warm control sockets").action(() => {
-    for (const host of sshHosts()) {
-      process.stdout.write(`${hasWarmSocket(host) ? "[x]" : "[ ]"} ${host}
-`);
-    }
-  });
 }
 
 // src/cli/pick.ts
@@ -1031,6 +1530,9 @@ function terminalText(value) {
 function shellQuote(value) {
   return `'${value.replaceAll("'", `'\\''`)}'`;
 }
+function remoteSessionName(peerName) {
+  return `${peerName.replace(/^[@$%=]+/, "")}~`;
+}
 var spawnRunner = (file, args, inherit = false) => {
   const result = spawnSync(file, args, {
     encoding: "utf8",
@@ -1046,48 +1548,14 @@ var spawnRunner = (file, args, inherit = false) => {
     failed: result.error !== void 0
   };
 };
-function forgetHostReplica(store, hostId) {
-  try {
-    const peer = store.peers().find((candidate) => candidate.host_id === hostId);
-    store.forgetHost(hostId);
-    if (peer) {
-      store.upsertPeer({
-        name: peer.name,
-        target: peer.target,
-        tmux_down_at: Date.now()
-      });
-    }
-  } catch {
-  }
-}
-function forgetReplica(store, agentId, hostId) {
-  try {
-    store.forgetAgent(agentId);
-    const peer = store.peers().find((candidate) => candidate.host_id === hostId);
-    if (peer) store.upsertPeer({ name: peer.name, target: peer.target, watermark: 0 });
-  } catch {
-  }
-}
-function forgetOneAgent(store, agent, mux = tmux) {
-  const identity = loadIdentity();
-  if (agent.host_id === identity?.host_id) {
-    try {
-      mux.setState(agent.window, null);
-    } catch {
-    }
-  }
-  forgetReplica(store, agent.agent_id, agent.host_id);
-}
 function jumpToAgent(store, agent, mux = tmux, run = spawnRunner) {
-  const identity = loadIdentity();
-  if (agent.host_id === identity?.host_id) {
-    const live = mux.liveWindows();
-    if (live && !live.has(agent.window)) {
-      forgetReplica(store, agent.agent_id, agent.host_id);
+  if (agent.local) {
+    const panes = mux.livePanes();
+    if (panes && !panes.has(agent.pane)) {
       return {
         ok: false,
-        reason: "window_gone",
-        message: `${agentLabel(agent)} is gone -- its window no longer exists. Cleared.`
+        reason: "pane_gone",
+        message: `${agentLabel(agent)} is gone -- its pane no longer exists.`
       };
     }
     if (!mux.attach(agent.session, agent.window)) {
@@ -1111,7 +1579,7 @@ function jumpToAgent(store, agent, mux = tmux, run = spawnRunner) {
   const probe = run("ssh", [
     ...SSH_OPTIONS,
     target,
-    `tmux list-windows -a -F ${shellQuote("#{window_id}")}`
+    `tmux list-panes -a -F ${shellQuote("#{pane_id}")}`
   ]);
   if (probe.status !== 0) {
     const sshFailed = probe.status === 255 || probe.failed;
@@ -1122,38 +1590,48 @@ function jumpToAgent(store, agent, mux = tmux, run = spawnRunner) {
         message: `cannot reach ${target} over ssh. Nothing here ever prompts for auth, so check the host is awake and reachable, or connect once by hand to see the real error.`
       };
     }
-    forgetHostReplica(store, agent.host_id);
     return {
       ok: false,
       reason: "no_tmux",
-      message: `${target} has no tmux server running, so its agents are gone. Removed them; they will come back when it reports again.`
+      message: `${target} has no tmux server running, so its agents are gone. They will disappear on the next collect.`
     };
   }
-  const remoteWindows = new Set(probe.stdout.split("\n").filter(Boolean));
-  if (!remoteWindows.has(agent.window)) {
-    forgetReplica(store, agent.agent_id, agent.host_id);
+  const remotePanes = new Set(probe.stdout.split("\n").filter(Boolean).map(asPaneId));
+  if (!remotePanes.has(agent.pane)) {
     return {
       ok: false,
-      reason: "window_gone",
-      message: `${agentLabel(agent)} is gone -- ${target} no longer has that window. Cleared.`
+      reason: "pane_gone",
+      message: `${agentLabel(agent)} is gone -- ${target} no longer has that pane.`
     };
   }
   const attachTarget = shellQuote(`${agent.session}:${agent.window}`);
   if (process.env.TMUX) {
-    const command = `ssh -t ${shellQuote(target)} tmux attach -t ${shellQuote(attachTarget)}`;
-    const name = `@${peer?.name ?? target}`;
-    const existing = mux.windowNamed(name);
-    if (existing) {
-      return mux.selectWindow(existing) ? { ok: true } : {
+    const client = mux.clientName();
+    const origin = mux.currentTarget();
+    const name = remoteSessionName(peer?.name ?? target);
+    if (mux.sessionNamed(name)) {
+      return mux.switchClient(client, name) ? { ok: true } : {
         ok: false,
         reason: "attach_failed",
-        message: `could not switch to the existing ${name} window.`
+        message: `could not switch to the existing ${name} session.`
       };
     }
-    return mux.newWindow(name, command) ? { ok: true } : {
+    const attach2 = `ssh -t ${shellQuote(target)} tmux attach -t ${shellQuote(attachTarget)}`;
+    const restore = origin ? `; tmux switch-client ${client ? `-c ${shellQuote(client)} ` : ""}-t ${shellQuote(`=${origin}`)}` : "";
+    if (!mux.newSession(name, `${attach2}${restore}`)) {
+      return {
+        ok: false,
+        reason: "attach_failed",
+        message: `could not open a session to attach to ${target}.`
+      };
+    }
+    mux.setSessionOption(name, "status", "off");
+    mux.setSessionOption(name, "prefix", "None");
+    mux.setSessionOption(name, "detach-on-destroy", "previous");
+    return mux.switchClient(client, name) ? { ok: true } : {
       ok: false,
       reason: "attach_failed",
-      message: `could not open a window to attach to ${target}.`
+      message: `attached to ${target} in session ${name}, but could not switch to it.`
     };
   }
   const attach = run("ssh", ["-t", target, "tmux", "attach", "-t", attachTarget], true);
@@ -1168,7 +1646,7 @@ function jumpToAgent(store, agent, mux = tmux, run = spawnRunner) {
 import { execFileSync as execFileSync3 } from "child_process";
 var GLANCE_LINES = 40;
 function glance(store, agent, lines = GLANCE_LINES) {
-  if (agent.host_id === loadIdentity()?.host_id) return tmux.capture(agent.pane, lines);
+  if (agent.local) return tmux.capture(agent.pane, lines);
   const peer = store.peers().find((candidate) => candidate.host_id === agent.host_id);
   const target = peer?.target ?? peer?.name;
   if (!target) return null;
@@ -1195,91 +1673,60 @@ function glance(store, agent, lines = GLANCE_LINES) {
 
 // src/status.ts
 function emptyCounts() {
-  return { working: 0, blocked: 0, done: 0, crashed: 0, idle: 0 };
+  const counts = {};
+  for (const state of RENDER_PRIORITY) counts[state] = 0;
+  return counts;
 }
 function tmuxStatus(view) {
-  const urgency = ["crashed", "blocked", "done", "working", "idle"];
-  return urgency.filter((state) => view.counts[state] > 0).map((state) => `${state}	${view.counts[state]}
+  const needsHuman = new Set(NEEDS_HUMAN);
+  const total = (state) => view.counts[state] + (needsHuman.has(state) ? view.orchestrated_counts[state] : 0);
+  return RENDER_PRIORITY.filter((state) => total(state) > 0).map((state) => `${state === "running" ? "working" : state}	${total(state)}
 `).join("");
 }
-function status(store, now = Date.now()) {
-  const identity = loadIdentity();
-  const peers = store.peers();
-  const peersByHost = new Map(
-    peers.flatMap((peer) => peer.host_id === null ? [] : [[peer.host_id, peer]])
-  );
-  const events = store.allEvents();
-  const local = foldAll(
-    events.filter((event) => event.host_id === identity?.host_id),
-    pidAlive
-  );
-  const remote = foldAll(
-    events.filter((event) => event.host_id !== identity?.host_id),
-    () => true
-  );
+function status(store, identity, now = Date.now()) {
   const counts = emptyCounts();
   const orchestratedCounts = emptyCounts();
-  const agents = attentionSort([...local, ...remote]).map((agent) => {
-    const peer = peersByHost.get(agent.host_id);
-    const fetchedAt = peer?.fetched_at ?? null;
-    const state = agent.state === null || agent.state === "cleared" ? "idle" : agent.state;
-    const target = agent.driver === "human" ? counts : orchestratedCounts;
-    target[state] += 1;
-    return {
-      ...agent,
-      fetched_at: fetchedAt,
-      // Replica freshness: how long since we last reached the peer. Local rows
-      // have no fetched_at and are never stale.
-      stale: isStale(fetchedAt, now, STALENESS_MS),
-      age_ms: fetchedAt === null ? null : now - fetchedAt,
-      // Information age: how long since the agent itself said anything. This
-      // is the number a human means by "how stale is that row". A successful
-      // fetch of a three-hour-old event resets age_ms to zero but leaves this
-      // at three hours, which is why they cannot be the same field.
-      event_age_ms: agent.event === null ? null : Math.max(0, now - agent.event.ts),
-      // A jump proved this host's tmux was down and nothing has authored since.
-      // Stronger than staleness: the host answers, its agents are just gone.
-      tmux_down: peer?.tmux_down_at != null,
-      // The name the human typed, not the machine's self-reported hostname. A
-      // peer added as `linuxpc` reported `18c04d69b860` (a container hostname)
-      // and that is what the picker showed — a string that appears nowhere
-      // else in the tool and cannot be typed at `peer remove` or searched for.
-      // Only the local node, which has no peer row, falls back to its own
-      // discovered display_name.
-      host: peer?.name ?? (agent.host_id === identity?.host_id ? identity.display_name : agent.host_id)
-    };
-  });
+  const panes = viewSort(paneViews(store, identity, now));
+  for (const pane of panes) {
+    const target = pane.driver === "human" ? counts : orchestratedCounts;
+    target[renderState(pane)] += 1;
+  }
   return {
     counts,
     orchestrated_counts: orchestratedCounts,
-    agents,
-    peers: peers.map((peer) => ({
+    panes,
+    peers: store.peers().map((peer) => ({
       name: peer.name,
       display_name: peer.display_name,
       fetched_at: peer.fetched_at,
-      // A peer we have never reached is stale, not fresh. `isStale` reads a
-      // null `fetched_at` as "local, therefore never stale", which is right
-      // for an agent row but backwards for a peer: null there means the very
-      // first collect has not succeeded yet. Left to `isStale`, an
-      // unreachable host you just added would render as up to date.
-      stale: peer.fetched_at === null || isStale(peer.fetched_at, now, STALENESS_MS)
+      // Their clock and ours, separately: a peer polled a second ago can be
+      // serving a three-hour-old fact, and one number cannot say both.
+      snapshot_at: peer.snapshot_at,
+      last_error: peer.last_error,
+      // The view's verdict, not a second threshold spelled the same way. A
+      // peer we have never reached is stale rather than fresh -- null
+      // `fetched_at` means the first collect has not succeeded yet -- and
+      // `freshness` is the one place that decides, so this list and the panes
+      // the peer contributes cannot disagree about the same host.
+      stale: freshness(peer.fetched_at, now) === "stale"
     }))
   };
 }
-async function statusWithCollect(store, now = Date.now(), channel = ssh) {
+async function statusWithCollect(store, identity, now = Date.now(), channel = ssh, mux = tmux) {
   try {
-    await collect(store, channel, now);
-  } catch (error) {
-    process.stderr.write(
-      `murmur: status: collect: ${error instanceof Error ? error.message : String(error)}
-`
-    );
+    await collect(store, channel, now, void 0, mux);
+  } catch {
   }
-  return status(store, now);
+  return status(store, identity, now);
 }
 
 // src/cli/pick.ts
-var PREVIEW_EVENTS = 8;
+var spawnFzf = (args, input, env) => spawnSync2("fzf", args, {
+  input,
+  encoding: "utf8",
+  stdio: ["pipe", "pipe", "inherit"],
+  env
+}).stdout ?? "";
 var PREVIEW_MESSAGE_MAX = 300;
 var GLYPH = {
   crashed: "\u2717",
@@ -1287,7 +1734,7 @@ var GLYPH = {
   blocked: "!",
   done: "\u2713",
   // ✓
-  working: "\u25B6",
+  running: "\u25B6",
   // ▶
   idle: "\xB7"
   // ·
@@ -1296,7 +1743,7 @@ var COLOUR = {
   crashed: "\x1B[31m",
   blocked: "\x1B[33m",
   done: "\x1B[36m",
-  working: "\x1B[37m",
+  running: "\x1B[37m",
   idle: "\x1B[90m"
 };
 var ANSI_PATTERN = `${String.fromCharCode(27)}\\[[0-9;]*m`;
@@ -1307,7 +1754,10 @@ var REMOTE = "\x1B[36m";
 var BOLD = "\x1B[1m";
 var DIM = "\x1B[2m";
 var RESET = "\x1B[0m";
-var URGENCY = ["crashed", "blocked", "done", "working", "idle"];
+var CREW_MARK = "crew ";
+function isVisible(agent) {
+  return agent.driver === "human" || NEEDS_HUMAN.some((kind) => agent.attention.includes(kind));
+}
 var COLUMNS = {
   glyph: 3,
   // marker + state glyph
@@ -1329,25 +1779,23 @@ function headerRow(showHost) {
   ].filter(Boolean).join(" ");
 }
 var FILTER_KEYS = [
-  ["ctrl-a", ""],
+  ["alt-x", "crashed"],
+  ["alt-b", "blocked"],
+  ["alt-d", "done"],
+  ["alt-w", "running"]
+];
+var FILTER_ALIASES = [
   ["ctrl-x", "crashed"],
-  ["ctrl-b", "blocked"],
   ["ctrl-d", "done"],
-  ["ctrl-w", "working"]
+  ["ctrl-w", "running"]
 ];
-function timestamp(ts) {
+function timestamp2(ts) {
   return new Date(ts).toLocaleTimeString([], {
     hour: "2-digit",
     minute: "2-digit",
     second: "2-digit"
   });
 }
-function age(ms) {
-  if (ms === null || ms < 6e4) return "";
-  if (ms < 36e5) return `${Math.floor(ms / 6e4)}m`;
-  if (ms < 864e5) return `${Math.floor(ms / 36e5)}h`;
-  return `${Math.floor(ms / 864e5)}d`;
-}
 function pad(value, width) {
   const visible = [...value.replace(ANSI_ESCAPE, "")].length;
   if (visible <= width) return value + " ".repeat(width - visible);
@@ -1372,22 +1820,25 @@ function pad(value, width) {
 function isPopup(env) {
   return Boolean(env.TMUX) && !env.TMUX_PANE;
 }
-function pickerRow(agent, showHost, current, local = true) {
-  const state = agent.state ?? "idle";
+function pickerRow(agent, showHost, current, local = agent.local) {
+  const state = renderState(agent);
   const colour = COLOUR[state] ?? "";
   const glyph = GLYPH[state] ?? "?";
   const marker = current ? `${BOLD}\u25C6${RESET}` : " ";
   const name = agent.agent_name ?? agent.pi_session ?? agentLabel(agent);
   const host = showHost ? local ? `${DIM}  here${RESET}` : `${REMOTE}\u2192 ${terminalText(agent.host)}${RESET}` : "";
   const group = agent.workstream ?? agent.session_name;
-  const workstream = group ? `${DIM}${terminalText(group)}${RESET}` : "";
+  const workstream = group && group !== name ? `${DIM}${terminalText(group)}${RESET}` : "";
+  const extra = agent.attention.filter((kind) => kind !== state);
   const flags = [
     agent.driver === "orchestrated" ? "crew" : "",
-    agent.stale ? "unreachable" : "",
-    // A jump already proved this one dead. Say so plainly rather than leaving
-    // the row looking merely old, and sort it last.
-    agent.tmux_down ? "no tmux" : "",
-    age(agent.event_age_ms)
+    // Freshness is a property of the NODE, and it is stated explicitly rather
+    // than inferred from an age: a stale node keeps its last-known fields, and
+    // the reader has to be told those fields are old.
+    agent.freshness === "stale" ? "stale host" : "",
+    ...extra,
+    agent.activity === "running" && state !== "running" ? "running" : "",
+    age(agent.updated_at === null ? null : Date.now() - agent.updated_at)
   ].filter(Boolean).join(" ");
   const label = [
     `${marker} ${colour}${glyph}${RESET}`,
@@ -1397,51 +1848,62 @@ function pickerRow(agent, showHost, current, local = true) {
     showHost ? pad(host, COLUMNS.host) : "",
     flags ? `${DIM}${flags}${RESET}` : ""
   ].filter(Boolean).join(" ");
-  return `${agent.agent_id}	${label}`;
+  return `${agent.host_id}	${agent.pane}	${label}`;
 }
 function previewText(store, agent) {
-  const state = agent.state ?? "idle";
+  const state = renderState(agent);
   const colour = COLOUR[state] ?? "";
   const head = [
     `${colour}${GLYPH[state] ?? "?"} ${state}${RESET}  ${BOLD}${agent.agent_name ? terminalText(agent.agent_name) : agentLabel(agent)}${RESET}`,
     // Says where, and whether "where" is this machine. The glance below is a
     // local capture-pane or an ssh depending on this one fact, so it belongs in
     // the header rather than being inferred from a hostname.
-    agent.host_id === loadIdentity()?.host_id ? `${DIM}here  ${agentLocation(agent)}${RESET}` : `${REMOTE}\u2192 ${terminalText(agent.host)}${RESET}  ${DIM}${agentLocation(agent)}${RESET}`
+    agent.local ? `${DIM}here  ${agentLocation(agent)}${RESET}` : `${REMOTE}\u2192 ${terminalText(agent.host)}${RESET}  ${DIM}${agentLocation(agent)}${RESET}`
   ];
   const facts = [
+    `activity ${agent.activity ?? "none (attention only)"}`,
+    agent.attention.length ? `wants    ${agent.attention.join(", ")}` : "",
     agent.workstream ? `stream   ${terminalText(agent.workstream)}` : "",
     agent.role ? `role     ${terminalText(agent.role)}` : "",
     agent.pi_session ? `session  ${terminalText(agent.pi_session)}` : "",
+    agent.cli ? `cli      ${terminalText(agent.cli)}` : "",
     agent.driver === "orchestrated" ? "driver   orchestrated (crew)" : "",
-    agent.stale ? `fetched  ${age(agent.age_ms)} ago` : ""
+    // Two ages, never one. A node polled a second ago can be serving a
+    // three-hour-old fact, and collapsing them is how that read as fresh.
+    agent.updated_at === null ? "" : `said     ${timestamp2(agent.updated_at)}`,
+    agent.local ? "" : `fetched  ${agent.fetched_at === null ? "never" : timestamp2(agent.fetched_at)}`,
+    agent.freshness === "stale" ? `${DIM}host is stale: fields below are last-known${RESET}` : ""
   ].filter(Boolean);
   const pane = glance(store, agent);
-  const live = pane?.trimEnd() ? [`${DIM}\u2500\u2500 pane \u2500\u2500${RESET}`, pane.trimEnd()] : [`${DIM}\u2500\u2500 pane \u2500\u2500${RESET}`, `${DIM}unavailable (host unreachable, or pane gone)${RESET}`];
-  const events = store.allEvents().filter((event) => event.agent_id === agent.agent_id).slice(-PREVIEW_EVENTS);
-  const history = events.length ? events.map((event) => {
-    let message = terminalText(event.message);
-    if (message.length > PREVIEW_MESSAGE_MAX) {
-      message = `${message.slice(0, PREVIEW_MESSAGE_MAX)}\u2026`;
-    }
-    const detail = message && message !== event.state ? `  ${message}` : "";
-    return `${DIM}${timestamp(event.ts)}${RESET}  ${terminalText(event.state).padEnd(8)}${detail}`;
-  }) : [`${DIM}no recorded events${RESET}`];
-  return [...head, "", ...facts, "", ...live, "", `${DIM}\u2500\u2500 history \u2500\u2500${RESET}`, ...history].join(
-    "\n"
-  );
+  const live = pane?.trimEnd() ? [
+    `${DIM}\u2500\u2500 pane \u2500\u2500${RESET}`,
+    pane.trimEnd().slice(-PREVIEW_MESSAGE_MAX * 20)
+  ] : [
+    `${DIM}\u2500\u2500 pane \u2500\u2500${RESET}`,
+    `${DIM}unavailable (host unreachable, or pane gone)${RESET}`
+  ];
+  return [...head, "", ...facts, "", ...live].join("\n");
 }
-function runPreview(store, agentId) {
-  const agent = status(store).agents.find((candidate) => candidate.agent_id === agentId);
-  if (!agent) return;
-  process.stdout.write(`${previewText(store, agent)}
-`);
+function runPreview(store, paneId, hostId) {
+  const identity = requireIdentity();
+  if (!identity) return;
+  const agent = status(store, identity).panes.find(
+    (candidate) => candidate.pane === paneId && (hostId === void 0 || candidate.host_id === hostId)
+  );
+  process.stdout.write(
+    agent ? `${previewText(store, agent)}
+` : `${DIM}${paneId} is no longer here.${RESET}
+`
+  );
 }
-async function runPick(store, options = {}) {
-  const identity = loadIdentity();
-  const view = await statusWithCollect(store);
-  const agents = view.agents.filter((agent2) => options.all || agent2.driver === "human");
-  const hidden = view.agents.length - agents.length;
+async function runPick(store, options = {}, deps = {}) {
+  const fzf = deps.fzf ?? spawnFzf;
+  const jumpTo = deps.jump ?? jumpToAgent;
+  const identity = requireIdentity();
+  if (!identity) return;
+  const view = await statusWithCollect(store, identity, Date.now(), ssh, deps.mux ?? tmux);
+  const agents = view.panes.filter((agent2) => options.all || isVisible(agent2));
+  const hidden = view.panes.length - agents.length;
   if (agents.length === 0) {
     process.stdout.write(
       hidden ? `No human agents  (+${hidden} crew \u2014 rerun with --all)
@@ -1449,34 +1911,35 @@ async function runPick(store, options = {}) {
     );
     return;
   }
-  const showHost = agents.some((agent2) => agent2.host_id !== identity?.host_id);
+  const showHost = agents.some((agent2) => !agent2.local);
   const currentPane = process.env.TMUX_PANE ?? "";
-  const input = agents.map(
-    (agent2) => pickerRow(agent2, showHost, agent2.pane === currentPane, agent2.host_id === identity?.host_id)
-  ).join("\n");
+  const input = agents.map((agent2) => pickerRow(agent2, showHost, agent2.pane === currentPane)).join("\n");
   const counts = /* @__PURE__ */ new Map();
   for (const agent2 of agents) {
-    const state = agent2.state ?? "idle";
+    const state = renderState(agent2);
     counts.set(state, (counts.get(state) ?? 0) + 1);
   }
-  const prompt = URGENCY.filter((state) => counts.get(state)).map((state) => `${COLOUR[state]}${GLYPH[state]}${counts.get(state)}${RESET}`).join(" ");
+  const prompt = RENDER_PRIORITY.filter((state) => counts.get(state)).map((state) => `${COLOUR[state]}${GLYPH[state]}${counts.get(state)}${RESET}`).join(" ");
+  const basePrompt = `${prompt}${prompt ? "  " : ""}`;
   const self = process.argv[1] ?? "murmur";
   const allFlag = options.all ? " --all" : "";
   const inPopup = isPopup(process.env);
   const width = process.stdout.columns ?? 0;
   const previewLayout = width > 0 && width < 150 ? "bottom:60%,border-top,wrap" : "right:58%,border-left,wrap";
-  const preview = `${process.execPath} ${self} pick --preview {1}`;
-  const filterBinds = FILTER_KEYS.flatMap(([key, state]) => [
+  const preview = `${process.execPath} ${self} pick --preview {2} --host {1}`;
+  const filterBinds = [
+    ...FILTER_KEYS.map(([key, query]) => [key, query]),
+    ...FILTER_ALIASES
+  ].flatMap(([key, query]) => [
     "--bind",
-    state ? `${key}:change-query(${state})` : `${key}:change-query()`
+    query ? `${key}:change-query(${query})` : `${key}:change-query()`
   ]);
-  const result = spawnSync2(
-    "fzf",
+  const stdout = fzf(
     [
       "--delimiter",
       "	",
       "--with-nth",
-      "2..",
+      "3..",
       "--ansi",
       // Literal substring matching, and matching only the visible columns.
       // Default fuzzy scatters query characters across the row: `re` matched
@@ -1487,7 +1950,7 @@ async function runPick(store, options = {}) {
       "--exact",
       // `begin` ranks earlier match positions higher, so `scratch` puts the
       // scratch workstream above a row that merely mentions it. `index` is the
-      // empty-query fallback and preserves the attention order the fold
+      // empty-query fallback and preserves the attention order `viewSort`
       // produced, which is the whole point of the list.
       "--tiebreak",
       "begin,index",
@@ -1505,13 +1968,21 @@ async function runPick(store, options = {}) {
       "--info",
       "inline",
       "--prompt",
-      `${prompt}${prompt ? "  " : ""}`,
+      `${options.all ? CREW_MARK : ""}${basePrompt}`,
       "--header",
       [
-        `enter jump   ^r refresh   ^p preview   del forget   filter: ${FILTER_KEYS.map(
-          ([key, state]) => `${key.replace("ctrl-", "^")} ${state || "all"}`
-        ).join(" ")}`,
-        hidden ? `${hidden} crew hidden (--all)` : "",
+        // No `del forget`. There is no replica to evict: a reader holds one
+        // snapshot per peer, and the next fetch replaces it whole -- so a delete
+        // key could only remove a row the next collect would put straight back,
+        // while looking like it had done something.
+        `enter jump   ^r refresh   ^p preview   ^u clear`,
+        // "toggle crew", not "show crew": the header is built once and the
+        // binding flips per keypress, so a directional label would be wrong
+        // half the time. The prompt's `crew` marker says which way it is
+        // currently set.
+        `filter: ${FILTER_KEYS.map(([key, query]) => `${key.replace("alt-", "M-")} ${query}`).join(
+          " "
+        )}   M-a toggle crew`,
         headerRow(showHost)
       ].filter(Boolean).join("\n"),
       "--preview",
@@ -1526,83 +1997,89 @@ async function runPick(store, options = {}) {
       "ctrl-p:change-preview-window(bottom:60%,border-top,wrap|hidden|right:58%,border-left,wrap)",
       "--bind",
       `ctrl-r:reload(${process.execPath} ${self} pick --rows${allFlag})`,
-      // Manual dismissal for a row nothing else will clear.
+      // M-a toggles the POPULATION, which is what "all" means everywhere else in
+      // murmur: the --all flag, and the "crew hidden (--all)" notice.
+      //
+      // It used to be the "clear the filter" key, labelled "all", which is the
+      // collision that made it look broken: pressing it emptied the query
+      // instead of revealing the hidden crew rows named two lines below, and
+      // nothing said why. One word, two meanings, and the wrong one bound to
+      // the key people reach for. Clearing is fzf's own ctrl-u, which needed no
+      // binding at all.
       //
-      // The delete key, not a ctrl chord. ctrl-shift-d does not exist -- a
-      // terminal sends the same bytes as ctrl-d -- and ctrl-alt-d, while it
-      // does dispatch distinctly, sits one modifier away from ctrl-d in a
-      // header that lists both. One is a filter and the other destroys a row,
-      // so a near-miss is a deleted agent. `delete` is the key that already
-      // means remove this, and it collides with no filter letter.
+      // `transform` rather than a fixed reload, because a bind string is built
+      // once at launch and cannot know it has already fired: binding
+      // `--rows --all` meant the second press re-ran the same thing and the
+      // toggle only worked one way. transform runs a shell snippet per
+      // keypress, so it can branch on the current state.
+      //
+      // The state lives in the prompt, which is the only mutable string fzf
+      // exposes to a binding. CREW_MARK is carried at the front of it: visible
+      // as a label, and readable back through $FZF_PROMPT.
       "--bind",
-      `delete:reload(${process.execPath} ${self} pick --forget {1}${allFlag})`,
+      `alt-a:transform:[[ $FZF_PROMPT == "${CREW_MARK}"* ]] && echo "reload(${process.execPath} ${self} pick --rows)+change-prompt(${basePrompt})" || echo "reload(${process.execPath} ${self} pick --rows --all)+change-prompt(${CREW_MARK}${basePrompt})"`,
       ...filterBinds,
       "--no-select-1",
       "--no-exit-0"
     ],
-    {
-      input,
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "inherit"],
-      // FZF_DEFAULT_OPTS can carry a conflicting layout or bindings from the
-      // user's shell; the old picker stripped it for the same reason.
-      env: Object.fromEntries(
-        Object.entries(process.env).filter(([key]) => !key.startsWith("FZF_DEFAULT_OPTS"))
-      )
-    }
+    input,
+    // FZF_DEFAULT_OPTS can carry a conflicting layout or bindings from the
+    // user's shell; the old picker stripped it for the same reason.
+    Object.fromEntries(
+      Object.entries(process.env).filter(([key]) => !key.startsWith("FZF_DEFAULT_OPTS"))
+    )
   );
-  const selected = result.stdout?.trim().split("	")[0];
+  const [selectedHost, selected] = stdout.trim().split("	");
   if (!selected) return;
-  const agent = agents.find((candidate) => candidate.agent_id === selected);
-  if (!agent) return;
-  const jump = jumpToAgent(store, agent);
+  const agent = view.panes.find(
+    (candidate) => candidate.pane === selected && candidate.host_id === selectedHost
+  );
+  if (!agent) {
+    process.stderr.write(`${selected} is no longer here.
+`);
+    process.exitCode = 1;
+    return;
+  }
+  const jump = jumpTo(store, agent);
   if (!jump.ok) {
     process.stderr.write(`${jump.message}
 `);
     process.exitCode = 1;
   }
 }
-async function runForget(store, agentId, options = {}) {
-  const view = status(store);
-  const agent = view.agents.find((candidate) => candidate.agent_id === agentId);
-  if (agent) forgetOneAgent(store, agent);
-  await runRows(store, options);
-}
 async function runRows(store, options = {}) {
-  const identity = loadIdentity();
-  const view = await statusWithCollect(store);
-  const agents = view.agents.filter((agent) => options.all || agent.driver === "human");
-  const showHost = agents.some((agent) => agent.host_id !== identity?.host_id);
+  const identity = requireIdentity();
+  if (!identity) return;
+  const view = await statusWithCollect(store, identity);
+  const agents = view.panes.filter((agent) => options.all || isVisible(agent));
+  const showHost = agents.some((agent) => !agent.local);
   const currentPane = process.env.TMUX_PANE ?? "";
   for (const agent of agents) {
-    process.stdout.write(
-      `${pickerRow(agent, showHost, agent.pane === currentPane, agent.host_id === identity?.host_id)}
-`
-    );
+    process.stdout.write(`${pickerRow(agent, showHost, agent.pane === currentPane)}
+`);
   }
 }
 function registerPick(program2) {
-  program2.command("pick").description("Pick an agent and jump to it").option("--all", "include orchestrated agents").option("--preview <agent-id>", "render the preview pane for one agent (internal)").option("--rows", "print picker rows only (internal, for reload)").option("--forget <agent-id>", "drop one agent, then print rows (internal)").action(
-    async (options) => {
-      const store = openStore();
-      try {
-        if (options.preview) runPreview(store, options.preview);
-        else if (options.forget) await runForget(store, options.forget, options);
-        else if (options.rows) await runRows(store, options);
-        else await runPick(store, options);
-      } finally {
-        store.close();
-      }
+  program2.command("pick").description("Pick an agent and jump to it").option("--all", "include orchestrated agents").option("--preview <pane>", "render the preview pane for one pane (internal)").option("--host <host-id>", "host of the pane being previewed (internal)").option("--rows", "print picker rows only (internal, for reload)").action(async (options) => {
+    const store = openStore();
+    try {
+      if (options.preview) runPreview(store, options.preview, options.host);
+      else if (options.rows) await runRows(store, options);
+      else await runPick(store, options);
+    } finally {
+      store.close();
     }
-  );
+  });
 }
 
 // src/cli/status.ts
 function registerStatus(program2) {
-  program2.command("status").description("Show folded agent status").option("--json", "print JSON").action(async (options) => {
+  program2.command("status").description("Show current agent status").option("--json", "print JSON").action(async (options) => {
+    const identity = requireIdentity();
+    if (!identity) return;
     const store = openStore();
     try {
-      const view = await statusWithCollect(store);
+      const view = await statusWithCollect(store, identity);
       process.stdout.write(
         options.json ? `${JSON.stringify(view, null, 2)}
 ` : tmuxStatus(view)
@@ -1613,19 +2090,15 @@ function registerStatus(program2) {
   });
 }
 
-// src/index.ts
-import { createRequire } from "module";
-var manifest = createRequire(import.meta.url)("../package.json");
-var VERSION = manifest.version;
-
 // src/cli.ts
 var program = new Command();
-program.name("murmur").description("Agent state across every machine, in one view.").version(VERSION);
+program.name("murmur").description("Agent state across every machine, in one view.").version(MURMUR_VERSION);
 registerInit(program);
 registerLink(program);
 registerExport(program);
 registerCollect(program);
 registerClear(program);
+registerNotify(program);
 registerPeer(program);
 registerStatus(program);
 registerPick(program);