@martintrojer/murmur 0.1.0

package/dist/index.js

@@ -0,0 +1,894 @@
+// 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/identity.ts
+function loadIdentity() {
+  const path = join2(stateDir(), "identity.json");
+  return existsSync(path) ? JSON.parse(readFileSync(path, "utf8")) : null;
+}
+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;
+}
+
+// src/mux.ts
+import { execFileSync } from "child_process";
+function runTmux(args) {
+  try {
+    return execFileSync("tmux", args, {
+      encoding: "utf8",
+      timeout: 3e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+var tmux = {
+  currentWindow() {
+    const pane = process.env.TMUX_PANE ?? runTmux(["display-message", "-p", "#{pane_id}"]);
+    if (!pane) return null;
+    const fields = runTmux([
+      "display-message",
+      "-t",
+      pane,
+      "-p",
+      "#{session_id}	#{window_id}	#{session_name}	#{window_name}"
+    ]);
+    const [session, window, sessionName, windowName] = fields?.split("	") ?? [];
+    if (!session || !window) return null;
+    return {
+      session,
+      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.
+  liveWindows() {
+    const out = runTmux(["list-windows", "-a", "-F", "#{window_id}"]);
+    if (out === null) return null;
+    return new Set(out.split("\n").filter(Boolean));
+  },
+  setState(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, "@pane_agent", "1"]);
+    }
+    runTmux(["refresh-client", "-S"]);
+  },
+  attach(session, window) {
+    runTmux(["switch-client", "-t", session]);
+    runTmux(["select-window", "-t", window]);
+  },
+  // 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.
+  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;
+  },
+  selectWindow(window) {
+    runTmux(["select-window", "-t", window]);
+  },
+  // The window a pane belongs to, for a pane murmur has no event 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;
+  },
+  capture(pane, lines) {
+    const args = ["capture-pane", "-p", "-t", pane];
+    if (lines !== void 0) args.push("-S", `-${lines}`);
+    return runTmux(args);
+  }
+};
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+
+// src/agents.ts
+function agentLabel(agent) {
+  const name = agent.agent_name ?? agent.pi_session ?? agent.window_name ?? agent.session_name;
+  return terminalText(name ?? agent.window);
+}
+function agentLocation(agent) {
+  const session = agent.session_name ?? agent.session;
+  const window = agent.window_name ?? agent.window;
+  return terminalText(session === window ? session : `${session}:${window}`);
+}
+function terminalText(value) {
+  return [...value].map((character) => {
+    const code = character.charCodeAt(0);
+    return code < 32 || code === 127 || code >= 128 && code <= 159 ? "\uFFFD" : character;
+  }).join("");
+}
+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 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);
+      return {
+        ok: false,
+        reason: "window_gone",
+        message: `${agentLabel(agent)} is gone -- its window no longer exists. Cleared.`
+      };
+    }
+    tmux.attach(agent.session, agent.window);
+    return { ok: true };
+  }
+  const peer = store.peers().find((candidate) => candidate.host_id === agent.host_id);
+  const target = peer?.target ?? peer?.name;
+  if (!target) {
+    return {
+      ok: false,
+      reason: "no_peer",
+      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 }
+  );
+  if (probe.status !== 0) {
+    const sshFailed = probe.status === 255 || probe.error !== void 0;
+    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.`
+      };
+    }
+    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.`
+    };
+  }
+  const remoteWindows = new Set((probe.stdout ?? "").split("\n").filter(Boolean));
+  if (!remoteWindows.has(agent.window)) {
+    forgetReplica(store, agent.agent_id, agent.host_id);
+    return {
+      ok: false,
+      reason: "window_gone",
+      message: `${agentLabel(agent)} is gone -- ${target} no longer has that window. Cleared.`
+    };
+  }
+  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?.display_name ?? target}`;
+    const existing = tmux.windowNamed(name);
+    if (existing) {
+      tmux.selectWindow(existing);
+      return { ok: true };
+    }
+    spawnSync("tmux", ["new-window", "-n", name, command], { stdio: "ignore" });
+    return { ok: true };
+  }
+  spawnSync("ssh", ["-t", target, "tmux", "attach", "-t", attachTarget], { stdio: "inherit" });
+  return { ok: true };
+}
+
+// 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;
+  }
+};
+function hasWarmSocket(target) {
+  try {
+    execFileSync2("ssh", [...SSH_OPTIONS, "-O", "check", target], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// 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
+        };
+    }
+  }
+  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]);
+  }
+  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
+    };
+  });
+}
+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 isStale(fetchedAt, now, thresholdMs = 6e4) {
+  return fetchedAt !== null && now - fetchedAt > thresholdMs;
+}
+
+// src/export.ts
+var SCHEMA_VERSION = 2;
+var EVENT_FIELDS = /* @__PURE__ */ new Set([
+  "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"
+]);
+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)));
+  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
+  };
+}
+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 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 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()
+  };
+  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})`
+    );
+  }
+  return {
+    envelope,
+    events: lines.map((line) => eventFromWire(JSON.parse(line)))
+  };
+}
+async function collect(store, channel, now = Date.now()) {
+  const results = [];
+  try {
+    for (const peer of store.peers()) {
+      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 });
+      } 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 });
+      }
+    }
+  } catch (error) {
+    process.stderr.write(
+      `murmur: collect: ${error instanceof Error ? error.message : String(error)}
+`
+    );
+  }
+  return results;
+}
+
+// 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);
+  const peer = store.peers().find((candidate) => candidate.host_id === agent.host_id);
+  const target = peer?.target ?? peer?.name;
+  if (!target) return null;
+  try {
+    return execFileSync3(
+      "ssh",
+      [
+        ...SSH_OPTIONS2,
+        target,
+        "tmux",
+        "capture-pane",
+        "-p",
+        "-t",
+        `'${agent.pane}'`,
+        "-S",
+        `-${lines}`
+      ],
+      { encoding: "utf8", timeout: 3e3, stdio: ["ignore", "pipe", "ignore"] }
+    );
+  } catch {
+    return null;
+  }
+}
+
+// src/status.ts
+function emptyCounts() {
+  return { working: 0, blocked: 0, done: 0, crashed: 0, idle: 0 };
+}
+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
+  );
+  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,
+      host: peer?.display_name ?? peer?.name ?? (agent.host_id === identity?.host_id ? identity.display_name : agent.host_id)
+    };
+  });
+  return {
+    counts,
+    orchestrated_counts: orchestratedCounts,
+    agents,
+    peers: 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)
+    }))
+  };
+}
+
+// src/store.ts
+import { rmSync } from "fs";
+import Database from "better-sqlite3";
+var DEFAULT_RETENTION_MS = 7 * 864e5;
+var STORE_VERSION = 2;
+function resetIfStale(path) {
+  let salvaged = [];
+  try {
+    const existing = new Database(path, { fileMustExist: true });
+    const version = existing.pragma("user_version", { simple: true }) ?? 0;
+    if (version === STORE_VERSION) {
+      existing.close();
+      return salvaged;
+    }
+    try {
+      salvaged = existing.prepare("SELECT name, target, host_id, display_name FROM peers").all();
+    } catch {
+    }
+    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 {
+    ...row,
+    driver: row.driver,
+    synthetic: row.synthetic === 1,
+    extra: JSON.parse(row.extra)
+  };
+}
+function openStore() {
+  const identity = ensureIdentity();
+  const path = dbPath();
+  const salvagedPeers = resetIfStale(path);
+  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);
+    }
+  }
+  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 selectMaxSeq = database.prepare(
+    "SELECT COALESCE(MAX(seq), 0) AS seq FROM events WHERE host_id = ?"
+  );
+  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
+    };
+    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;
+  });
+  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);
+    },
+    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;
+    },
+    peers() {
+      return database.prepare("SELECT * FROM peers ORDER BY name").all();
+    },
+    forgetAgent(agentId) {
+      return database.prepare("DELETE FROM events WHERE agent_id = ?").run(agentId).changes;
+    },
+    forgetHost(hostId) {
+      return database.prepare("DELETE FROM events WHERE host_id = ?").run(hostId).changes;
+    },
+    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
+      );
+    },
+    removePeer(name) {
+      return database.prepare("DELETE FROM peers WHERE name = ?").run(name).changes > 0;
+    },
+    close() {
+      database.close();
+    }
+  };
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+export {
+  COLLECT_INTERVAL_MS,
+  DEFAULT_DRIVER,
+  SCHEMA_VERSION,
+  STALENESS_MS,
+  STORE_VERSION,
+  VERSION,
+  agentLabel,
+  agentLocation,
+  attentionSort,
+  collect,
+  configDir,
+  dbPath,
+  ensureIdentity,
+  eventFromWire,
+  exportJsonl,
+  foldAgent,
+  foldAll,
+  glance,
+  hasWarmSocket,
+  isStale,
+  jumpToAgent,
+  loadIdentity,
+  openStore,
+  pidAlive,
+  shellQuote,
+  ssh,
+  stateDir,
+  status,
+  tmux
+};
+//# sourceMappingURL=index.js.map