@martintrojer/murmur 0.1.3 → 0.2.0

package/dist/index.js

@@ -1,48 +1,59 @@
-// src/index.ts
-import { createRequire } from "module";
-
 // src/agents.ts
 import { spawnSync } from "child_process";
 
-// 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");
-}
-function configDir() {
-  return process.env.MURMUR_CONFIG_DIR ?? join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "murmur");
-}
-function dbPath() {
-  return join(stateDir(), "events.db");
+// src/channel.ts
+import { execFile, execFileSync } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var CONTROL_PATH = "~/.ssh/control/%r@%h:%p";
+var CONNECT_TIMEOUT_S = 1;
+var EXEC_TIMEOUT_MS = 3e3;
+var SSH_OPTIONS = [
+  "-o",
+  "BatchMode=yes",
+  "-o",
+  "ControlMaster=no",
+  "-o",
+  `ControlPath=${CONTROL_PATH}`,
+  "-o",
+  `ConnectTimeout=${CONNECT_TIMEOUT_S}`
+];
+var MAX_EXPORT_BYTES = 64 * 1024 * 1024;
+var ssh = {
+  async exec(target, argv) {
+    const { stdout } = await execFileAsync("ssh", [...SSH_OPTIONS, target, ...argv], {
+      encoding: "utf8",
+      timeout: EXEC_TIMEOUT_MS,
+      maxBuffer: MAX_EXPORT_BYTES
+    });
+    return stdout;
+  }
+};
+function hasWarmSocket(target) {
+  try {
+    execFileSync("ssh", [...SSH_OPTIONS, "-O", "check", target], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
 }
 
-// src/identity.ts
-function loadIdentity() {
-  const path = join2(stateDir(), "identity.json");
-  return existsSync(path) ? JSON.parse(readFileSync(path, "utf8")) : null;
+// src/ids.ts
+function asSessionId(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 asWindowId(raw) {
+  return raw;
+}
+function asPaneId(raw) {
+  return raw;
 }
 
 // src/mux.ts
-import { execFileSync } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 function runTmux(args) {
   try {
-    return execFileSync("tmux", args, {
+    return execFileSync2("tmux", args, {
       encoding: "utf8",
       timeout: 3e3,
       stdio: ["ignore", "pipe", "ignore"]
@@ -51,10 +62,20 @@ function runTmux(args) {
     return 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",
@@ -65,82 +86,84 @@ var tmux = {
     const [session, window, sessionName, windowName] = 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
     };
   },
-  // 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"]);
   },
   attach(session, window) {
     runTmux(["switch-client", "-t", session]);
-    runTmux(["select-window", "-t", window]);
+    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;
+  },
+  // 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;
   },
-  selectWindow(window) {
-    runTmux(["select-window", "-t", window]);
+  // 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);
   },
-  // The window a pane belongs to, for a pane murmur has no event for. Clearing
+  newSession(name, command) {
+    return runTmux(["new-session", "-d", "-s", name, command]) !== null;
+  },
+  setSessionOption(session, option, value) {
+    runTmux(["set-option", "-t", exactPaneTarget(session), option, value]);
+  },
+  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];
@@ -176,41 +199,41 @@ function terminalText(value) {
 function shellQuote(value) {
   return `'${value.replaceAll("'", `'\\''`)}'`;
 }
-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 remoteSessionName(peerName) {
+  return `${peerName.replace(/^[@$%=]+/, "")}~`;
 }
-function jumpToAgent(store, agent) {
-  const identity = loadIdentity();
-  if (agent.host_id === identity?.host_id) {
-    const live = tmux.liveWindows();
-    if (live && !live.has(agent.window)) {
-      forgetReplica(store, agent.agent_id, agent.host_id);
+var spawnRunner = (file, args, inherit = false) => {
+  const result = spawnSync(file, args, {
+    encoding: "utf8",
+    timeout: 1e4,
+    ...inherit ? { stdio: "inherit" } : {}
+  });
+  return {
+    status: result.status,
+    stdout: result.stdout ?? "",
+    // spawnSync reports a failure to even start the child in `error`, leaving
+    // status null. Collapsing both here keeps the decision table below reading
+    // as one question rather than two.
+    failed: result.error !== void 0
+  };
+};
+function jumpToAgent(store, agent, mux = tmux, run = spawnRunner) {
+  if (agent.local) {
+    const panes = mux.livePanes();
+    if (panes && !panes.has(agent.pane)) {
+      return {
+        ok: false,
+        reason: "pane_gone",
+        message: `${agentLabel(agent)} is gone -- its pane no longer exists.`
+      };
+    }
+    if (!mux.attach(agent.session, agent.window)) {
       return {
         ok: false,
-        reason: "window_gone",
-        message: `${agentLabel(agent)} is gone -- its window no longer exists. Cleared.`
+        reason: "attach_failed",
+        message: `could not attach to ${agentLabel(agent)} (tmux select-window failed).`
       };
     }
-    tmux.attach(agent.session, agent.window);
     return { ok: true };
   }
   const peer = store.peers().find((candidate) => candidate.host_id === agent.host_id);
@@ -222,330 +245,421 @@ function jumpToAgent(store, agent) {
       message: `No peer configured for host ${agent.host_id.slice(0, 8)}. Try: murmur peer add <target>`
     };
   }
-  const probe = spawnSync(
-    "ssh",
-    ["-o", "BatchMode=yes", target, `tmux list-windows -a -F ${shellQuote("#{window_id}")}`],
-    { encoding: "utf8", timeout: 1e4 }
-  );
+  const probe = run("ssh", [
+    ...SSH_OPTIONS,
+    target,
+    `tmux list-panes -a -F ${shellQuote("#{pane_id}")}`
+  ]);
   if (probe.status !== 0) {
-    const sshFailed = probe.status === 255 || probe.error !== void 0;
+    const sshFailed = probe.status === 255 || probe.failed;
     if (sshFailed) {
       return {
         ok: false,
         reason: "unreachable",
-        message: `cannot reach ${target} over ssh. The collector never prompts for auth, so connect once by hand to warm the connection, then retry.`
+        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 = tmux.windowNamed(name);
-    if (existing) {
-      tmux.selectWindow(existing);
-      return { 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} session.`
+      };
     }
-    spawnSync("tmux", ["new-window", "-n", name, command], { stdio: "ignore" });
-    return { 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: `attached to ${target} in session ${name}, but could not switch to it.`
+    };
   }
-  spawnSync("ssh", ["-t", target, "tmux", "attach", "-t", attachTarget], { stdio: "inherit" });
-  return { ok: true };
+  const attach = run("ssh", ["-t", target, "tmux", "attach", "-t", attachTarget], true);
+  return attach.status === 0 && !attach.failed ? { ok: true } : {
+    ok: false,
+    reason: "attach_failed",
+    message: `ssh attach to ${target} failed.`
+  };
 }
 
-// src/channel.ts
-import { execFile, execFileSync as execFileSync2 } from "child_process";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-var CONTROL_PATH = "~/.ssh/control/%r@%h:%p";
-var CONNECT_TIMEOUT_S = 2;
-var EXEC_TIMEOUT_MS = 1e4;
-var SSH_OPTIONS = [
-  "-o",
-  "BatchMode=yes",
-  "-o",
-  "ControlMaster=no",
-  "-o",
-  `ControlPath=${CONTROL_PATH}`,
-  "-o",
-  `ConnectTimeout=${CONNECT_TIMEOUT_S}`
-];
-var ssh = {
-  async exec(target, argv) {
-    const { stdout } = await execFileAsync("ssh", [...SSH_OPTIONS, target, ...argv], {
-      encoding: "utf8",
-      timeout: EXEC_TIMEOUT_MS
-    });
-    return stdout;
+// src/snapshot.ts
+var SnapshotInvalidError = class extends Error {
+  constructor(path, detail) {
+    super(path === "" ? detail : `${path}: ${detail}`);
+    this.path = path;
+    this.name = "SnapshotInvalidError";
   }
+  path;
 };
-function hasWarmSocket(target) {
-  try {
-    execFileSync2("ssh", [...SSH_OPTIONS, "-O", "check", target], { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
+function fail(path, detail) {
+  throw new SnapshotInvalidError(path, detail);
 }
-
-// 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
-        };
-    }
+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 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);
-  }
-  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: ""
-    });
+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 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()
+function parseSnapshot(input) {
+  let parsed;
+  try {
+    parsed = JSON.parse(input);
+  } catch (error) {
+    fail("", `not JSON (${error instanceof Error ? error.message : String(error)})`);
+  }
+  const top = object(parsed, "", TOP_KEYS);
+  if (top.murmur_snapshot !== 1) {
+    fail("murmur_snapshot", `expected 1, got ${JSON.stringify(top.murmur_snapshot)}`);
+  }
+  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 COLLECT_INTERVAL_MS = 3e4;
-var STALENESS_MS = 2 * COLLECT_INTERVAL_MS;
-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})`
-    );
+// 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 {
-    envelope,
-    events: lines.map((line) => eventFromWire(JSON.parse(line)))
+    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
   };
 }
-async function collect(store, channel, now = Date.now()) {
+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/collector.ts
+var MAX_CONCURRENT_PEERS = 8;
+var COLLECT_DEADLINE_MS = 4e3;
+async function mapSettled(items, limit, task, deadline) {
+  const results = new Array(items.length);
+  let cursor = 0;
+  let expired = false;
+  const stop = deadline?.then(() => {
+    expired = true;
+  });
+  const worker = async () => {
+    while (cursor < items.length && !expired) {
+      const index = cursor++;
+      try {
+        results[index] = { status: "fulfilled", value: await task(items[index]) };
+      } catch (reason) {
+        results[index] = { status: "rejected", reason };
+      }
+    }
+  };
+  const pool = Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+  await (stop ? Promise.race([pool, stop]) : pool);
+  return results;
+}
+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();
+}
+async function collect(store, channel, now = Date.now(), deadline) {
   const results = [];
+  let timer;
   try {
-    for (const peer of store.peers()) {
+    const peers = store.peers();
+    const bounded = deadline ?? new Promise((resolve) => {
+      timer = setTimeout(resolve, COLLECT_DEADLINE_MS);
+      timer.unref?.();
+    });
+    const fetches = await mapSettled(
+      peers,
+      MAX_CONCURRENT_PEERS,
+      async (peer) => parseSnapshot(await channel.exec(peer.target, ["murmur", "export"])),
+      bounded
+    );
+    for (const [index, peer] of peers.entries()) {
+      const fetch = fetches[index];
       try {
-        const output = await channel.exec(peer.target, [
-          "murmur",
-          "export",
-          "--since",
-          String(peer.watermark)
-        ]);
-        const { envelope, events } = parseJsonl(output);
-        const ingested = store.ingest(events);
-        const watermark = events.filter((event) => event.host_id === envelope.host_id).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.
-          tmux_down_at: ingested > 0 ? null : peer.tmux_down_at
-        });
-        store.prune();
-        results.push({ peer: peer.name, ok: true, ingested });
+        if (!fetch) throw new Error("collect deadline passed before this peer answered");
+        if (fetch.status === "rejected") throw fetch.reason;
+        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.reconcileLocal({ panes: tmux.livePanes(), now });
+  } catch {
   }
   return results;
 }
@@ -553,18 +667,8 @@ async function collect(store, channel, now = Date.now()) {
 // src/glance.ts
 import { execFileSync as execFileSync3 } from "child_process";
 var GLANCE_LINES = 40;
-var SSH_OPTIONS2 = [
-  "-o",
-  "BatchMode=yes",
-  "-o",
-  "ControlMaster=no",
-  "-o",
-  "ControlPath=~/.ssh/control/%r@%h:%p",
-  "-o",
-  "ConnectTimeout=2"
-];
 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;
@@ -572,7 +676,7 @@ function glance(store, agent, lines = GLANCE_LINES) {
     return execFileSync3(
       "ssh",
       [
-        ...SSH_OPTIONS2,
+        ...SSH_OPTIONS,
         target,
         "tmux",
         "capture-pane",
@@ -589,329 +693,554 @@ function glance(store, agent, lines = GLANCE_LINES) {
   }
 }
 
+// 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");
+}
+function configDir() {
+  return process.env.MURMUR_CONFIG_DIR ?? join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "murmur");
+}
+function dbPath() {
+  return join(stateDir(), "state.db");
+}
+
+// src/identity.ts
+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) {
+  mkdirSync(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: randomUUID(), display_name: displayName });
+}
+function setDisplayName(displayName) {
+  const existing = loadIdentity();
+  return write(
+    existing ? { host_id: existing.host_id, display_name: displayName } : { host_id: randomUUID(), display_name: displayName }
+  );
+}
+
 // 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 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 tmuxStatus(view) {
+  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, 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, identity, now = Date.now(), channel = ssh) {
+  try {
+    await collect(store, channel, now);
+  } catch {
+  }
+  return status(store, identity, now);
+}
 
 // src/store.ts
-import { rmSync } from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
+import { mkdirSync as mkdirSync2, 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/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/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;
-  }
-  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 toEvent(row) {
+    return false;
+  }
+}
+function toAttention(row) {
+  return {
+    kind: row.kind,
+    message: row.message,
+    source: row.source,
+    requested_at: row.requested_at
+  };
+}
+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);
+  mkdirSync2(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 {
-  }
-  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);
-    }
+  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);
   }
-  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 = randomUUID2();
+      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 = randomUUID2();
+    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);
-    },
-    allEvents() {
-      const rows = database.prepare("SELECT * FROM events ORDER BY ts, host_id, seq").all();
-      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;
     },
-    maxSeq(hostId) {
-      return selectMaxSeq.get(hostId).seq;
+    releaseAgent(release) {
+      return deleteAgentOwned.run(release.agent_id, release.owner_pid).changes === 1;
     },
-    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();
     }
   };
 }
-
-// src/index.ts
-var manifest = createRequire(import.meta.url)("../package.json");
-var VERSION = manifest.version;
 export {
-  COLLECT_INTERVAL_MS,
   DEFAULT_DRIVER,
-  SCHEMA_VERSION,
+  MAX_CONCURRENT_PEERS,
+  NEEDS_HUMAN,
+  RENDER_PRIORITY,
   STALENESS_MS,
-  STORE_VERSION,
-  VERSION,
+  SnapshotInvalidError,
+  MURMUR_VERSION as VERSION,
+  age,
   agentLabel,
   agentLocation,
-  attentionSort,
+  asPaneId,
+  asSessionId,
+  asWindowId,
   collect,
   configDir,
+  createIdentity,
   dbPath,
-  ensureIdentity,
-  eventFromWire,
-  exportJsonl,
-  foldAgent,
-  foldAll,
+  freshness,
   glance,
   hasWarmSocket,
-  isStale,
   jumpToAgent,
   loadIdentity,
   openStore,
+  paneViews,
+  parseSnapshot,
   pidAlive,
+  renderState,
+  setDisplayName,
   shellQuote,
   ssh,
   stateDir,
   status,
-  tmux
+  statusWithCollect,
+  tmux,
+  tmuxStatus,
+  viewSort
 };
 //# sourceMappingURL=index.js.map