@martintrojer/murmur 0.1.0

package/dist/cli.js

@@ -0,0 +1,1426 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/cli/clear.ts
+import Database2 from "better-sqlite3";
+
+// 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 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/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/cli/clear.ts
+function clearPane(pane, mux = tmux) {
+  try {
+    if (!pane) return;
+    const window = mux.windowForPane(pane);
+    const identity = loadIdentity();
+    let owner;
+    if (identity) {
+      try {
+        const database = new Database2(dbPath(), { readonly: true, fileMustExist: true });
+        try {
+          owner = database.prepare(
+            `SELECT agent_id, session, window, pane, session_name, window_name,
+                      agent_name, pi_session, workstream, role, cli, driver, state
+                 FROM events
+                WHERE host_id = ? AND agent_id = ?
+                ORDER BY seq DESC
+                LIMIT 1`
+          ).get(identity.host_id, `${identity.host_id}:${pane}`);
+        } finally {
+          database.close();
+        }
+      } catch {
+      }
+    }
+    if (!owner) {
+      if (window) mux.setState(window, null);
+      return;
+    }
+    if (owner.state === "cleared") return;
+    const store = openStore();
+    try {
+      store.append({
+        agent_id: owner.agent_id,
+        session: owner.session,
+        window: owner.window,
+        pane: owner.pane,
+        // Carry the names forward: a `cleared` row that drops them makes the
+        // agent's last event nameless, which is what left "@75" in the picker.
+        session_name: owner.session_name,
+        window_name: owner.window_name,
+        agent_name: owner.agent_name,
+        pi_session: owner.pi_session,
+        workstream: owner.workstream,
+        role: owner.role,
+        cli: owner.cli,
+        driver: owner.driver,
+        kind: "state",
+        state: "cleared",
+        message: "",
+        pid: null,
+        synthetic: false,
+        reason: "",
+        extra: {}
+      });
+    } finally {
+      store.close();
+    }
+    mux.setState(owner.window, null);
+  } catch {
+  }
+}
+function registerClear(program2) {
+  program2.command("clear").description("Clear attention for the agent in a pane").option("--pane <pane-id>", "focused tmux pane id").action((options) => clearPane(options.pane ?? ""));
+}
+
+// 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/cli/collect.ts
+function registerCollect(program2) {
+  program2.command("collect").description("Collect events from configured peers").action(async () => {
+    const store = openStore();
+    try {
+      await collect(store, ssh);
+    } finally {
+      store.close();
+    }
+  });
+}
+
+// src/cli/export.ts
+function registerExport(program2) {
+  program2.command("export").description("Export local events as JSONL").requiredOption("--since <seq>", "export events after this sequence", Number).action((options) => {
+    const store = openStore();
+    try {
+      process.stdout.write(exportJsonl(store, options.since, pidAlive, tmux.liveWindows()));
+    } finally {
+      store.close();
+    }
+  });
+}
+
+// src/cli/init.ts
+function registerInit(program2) {
+  program2.command("init").description("Initialize this node's identity").option("--name <name>", "display name").action((opts) => {
+    const identity = ensureIdentity(opts.name);
+    console.log(`host_id: ${identity.host_id}`);
+    console.log(`display_name: ${identity.display_name}`);
+  });
+}
+
+// src/cli/link.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join3 } from "path";
+import { fileURLToPath } from "url";
+function registerLink(program2) {
+  program2.command("link").description("Install a murmur integration").argument("<target>", "integration to install").action((target) => {
+    if (target !== "pi") throw new Error(`unsupported link target: ${target}`);
+    const destination = join3(
+      process.env.MURMUR_PI_HOME ?? homedir2(),
+      ".pi",
+      "agent",
+      "extensions",
+      "murmur.ts"
+    );
+    mkdirSync2(dirname(destination), { recursive: true });
+    const source = readFileSync2(
+      fileURLToPath(new URL("./extension/murmur-pi.js", import.meta.url)),
+      "utf8"
+    );
+    const storePath = fileURLToPath(new URL("./extension/store.js", import.meta.url));
+    const pinned = source.replace(
+      /"@martintrojer\/murmur\/extension-store"/,
+      JSON.stringify(storePath)
+    );
+    if (pinned === source) {
+      throw new Error("link pi: could not pin the store import; extension build changed");
+    }
+    writeFileSync2(destination, pinned);
+    console.log(destination);
+  });
+}
+
+// src/cli/peer.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+function parseSshHosts(config) {
+  const hosts = [];
+  for (const line of config.split("\n")) {
+    const tokens = line.replace(/#.*$/, "").trim().split(/\s+/);
+    if (tokens[0]?.toLowerCase() !== "host") continue;
+    for (const host of tokens.slice(1)) {
+      if (!/[*?!]/.test(host)) hosts.push(host);
+    }
+  }
+  return hosts;
+}
+function sshHosts() {
+  try {
+    return parseSshHosts(readFileSync3(join4(homedir3(), ".ssh", "config"), "utf8"));
+  } catch {
+    return [];
+  }
+}
+function registerPeer(program2) {
+  const peer = program2.command("peer").description("Manage peers");
+  peer.command("add").description("Add a peer and discover its identity").argument("<name>").argument("[target]").action(async (name, target = name) => {
+    const store = openStore();
+    try {
+      let envelope = null;
+      try {
+        const output = await ssh.exec(target, ["murmur", "export", "--since", "0"]);
+        envelope = JSON.parse(output.trim().split("\n")[0] ?? "");
+      } catch {
+        envelope = null;
+      }
+      if (envelope) {
+        if (envelope.host_id === loadIdentity()?.host_id) {
+          process.stderr.write(`${target} is this node; not adding it as a peer
+`);
+          process.exitCode = 1;
+          return;
+        }
+        const existing = store.peers().find((candidate) => candidate.host_id === envelope.host_id && candidate.name !== name);
+        if (existing) {
+          process.stderr.write(
+            `${target} is already configured as peer "${existing.name}" (${envelope.display_name}); remove it first to rename
+`
+          );
+          process.exitCode = 1;
+          return;
+        }
+      }
+      store.upsertPeer({
+        name,
+        target,
+        host_id: envelope?.host_id ?? null,
+        display_name: envelope?.display_name ?? null
+      });
+      process.stdout.write(
+        envelope ? `Added ${name} (${envelope.display_name})
+` : `Added ${name} (identity pending)
+`
+      );
+    } finally {
+      store.close();
+    }
+  });
+  peer.command("remove").description("Remove a peer").argument("<name>", "peer to remove").action((name) => {
+    const store = openStore();
+    try {
+      if (store.removePeer(name)) process.stdout.write(`Removed ${name}
+`);
+      else {
+        process.stderr.write(`no such peer: ${name}
+`);
+        process.exitCode = 1;
+      }
+    } finally {
+      store.close();
+    }
+  });
+  peer.command("list").description("List configured peers").option("--json", "print JSON").action((options) => {
+    const store = openStore();
+    try {
+      const peers = store.peers();
+      if (options.json) process.stdout.write(`${JSON.stringify(peers)}
+`);
+      else {
+        for (const configured of peers) {
+          process.stdout.write(
+            `${configured.name}	${configured.target}	${configured.display_name ?? "unknown"}
+`
+          );
+        }
+      }
+    } finally {
+      store.close();
+    }
+  });
+  peer.command("discover").description("Check SSH hosts for warm control sockets").action(() => {
+    for (const host of sshHosts()) {
+      process.stdout.write(`${hasWarmSocket(host) ? "[x]" : "[ ]"} ${host}
+`);
+    }
+  });
+}
+
+// src/cli/pick.ts
+import { spawnSync as spawnSync2 } from "child_process";
+
+// src/agents.ts
+import { spawnSync } from "child_process";
+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/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 tmuxStatus(view) {
+  const urgency = ["crashed", "blocked", "done", "working", "idle"];
+  return urgency.filter((state) => view.counts[state] > 0).map((state) => `${state}	${view.counts[state]}
+`).join("");
+}
+function status(store, now = Date.now()) {
+  const identity = loadIdentity();
+  const peers = store.peers();
+  const peersByHost = new Map(
+    peers.flatMap((peer) => peer.host_id === null ? [] : [[peer.host_id, peer]])
+  );
+  const events = store.allEvents();
+  const local = foldAll(
+    events.filter((event) => event.host_id === identity?.host_id),
+    pidAlive
+  );
+  const remote = foldAll(
+    events.filter((event) => event.host_id !== identity?.host_id),
+    () => true
+  );
+  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)
+    }))
+  };
+}
+async function statusWithCollect(store, now = Date.now()) {
+  try {
+    await collect(store, ssh, now);
+  } catch (error) {
+    process.stderr.write(
+      `murmur: status: collect: ${error instanceof Error ? error.message : String(error)}
+`
+    );
+  }
+  return status(store, now);
+}
+
+// src/cli/pick.ts
+var PREVIEW_EVENTS = 8;
+var PREVIEW_MESSAGE_MAX = 300;
+var GLYPH = {
+  crashed: "\u2717",
+  // ✗
+  blocked: "!",
+  done: "\u2713",
+  // ✓
+  working: "\u25B6",
+  // ▶
+  idle: "\xB7"
+  // ·
+};
+var COLOUR = {
+  crashed: "\x1B[31m",
+  blocked: "\x1B[33m",
+  done: "\x1B[36m",
+  working: "\x1B[37m",
+  idle: "\x1B[90m"
+};
+var ANSI_PATTERN = `${String.fromCharCode(27)}\\[[0-9;]*m`;
+var ANSI_ESCAPE = new RegExp(ANSI_PATTERN, "g");
+var ANSI_AT_START = new RegExp(`^${ANSI_PATTERN}`);
+var ANSI_AT_END = new RegExp(`(?:${ANSI_PATTERN})+$`);
+var REMOTE = "\x1B[36m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var URGENCY = ["crashed", "blocked", "done", "working", "idle"];
+var COLUMNS = {
+  glyph: 3,
+  // marker + state glyph
+  state: 8,
+  name: 30,
+  stream: 13,
+  streamWide: 18,
+  // when no host column is shown
+  host: 14
+};
+function headerRow(showHost) {
+  return [
+    " ".repeat(COLUMNS.glyph),
+    pad("state", COLUMNS.state),
+    pad("agent", COLUMNS.name),
+    pad("workstream", showHost ? COLUMNS.stream : COLUMNS.streamWide),
+    showHost ? pad("host", COLUMNS.host) : "",
+    "age / flags"
+  ].filter(Boolean).join(" ");
+}
+var FILTER_KEYS = [
+  ["ctrl-a", ""],
+  ["ctrl-x", "crashed"],
+  ["ctrl-b", "blocked"],
+  ["ctrl-d", "done"],
+  ["ctrl-w", "working"]
+];
+function timestamp(ts) {
+  return new Date(ts).toLocaleTimeString([], {
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+}
+function age(ms) {
+  if (ms === null || ms < 6e4) return "";
+  if (ms < 36e5) return `${Math.floor(ms / 6e4)}m`;
+  if (ms < 864e5) return `${Math.floor(ms / 36e5)}h`;
+  return `${Math.floor(ms / 864e5)}d`;
+}
+function pad(value, width) {
+  const visible = [...value.replace(ANSI_ESCAPE, "")].length;
+  if (visible <= width) return value + " ".repeat(width - visible);
+  const budget = Math.max(0, width - 1);
+  let out = "";
+  let shown = 0;
+  let index = 0;
+  while (index < value.length && shown < budget) {
+    const sequence = ANSI_AT_START.exec(value.slice(index));
+    if (sequence) {
+      out += sequence[0];
+      index += sequence[0].length;
+      continue;
+    }
+    out += value[index];
+    index += 1;
+    shown += 1;
+  }
+  const tail = value.slice(index).match(ANSI_AT_END);
+  return `${out}\u2026${tail?.[0] ?? ""}${" ".repeat(Math.max(0, width - budget - 1))}`;
+}
+function pickerRow(agent, showHost, current, local = true) {
+  const state = agent.state ?? "idle";
+  const colour = COLOUR[state] ?? "";
+  const glyph = GLYPH[state] ?? "?";
+  const marker = current ? `${BOLD}\u25C6${RESET}` : " ";
+  const name = agent.agent_name ?? agent.pi_session ?? agentLabel(agent);
+  const host = showHost ? local ? `${DIM}  here${RESET}` : `${REMOTE}\u2192 ${terminalText(agent.host)}${RESET}` : "";
+  const workstream = agent.workstream ? `${DIM}${terminalText(agent.workstream)}${RESET}` : "";
+  const flags = [
+    agent.driver === "orchestrated" ? "crew" : "",
+    agent.stale ? "unreachable" : "",
+    // A jump already proved this one dead. Say so plainly rather than leaving
+    // the row looking merely old, and sort it last.
+    agent.tmux_down ? "no tmux" : "",
+    age(agent.event_age_ms)
+  ].filter(Boolean).join(" ");
+  const label = [
+    `${marker} ${colour}${glyph}${RESET}`,
+    `${colour}${pad(state, COLUMNS.state)}${RESET}`,
+    pad(`${BOLD}${terminalText(name)}${RESET}`, COLUMNS.name),
+    pad(workstream, showHost ? COLUMNS.stream : COLUMNS.streamWide),
+    showHost ? pad(host, COLUMNS.host) : "",
+    flags ? `${DIM}${flags}${RESET}` : ""
+  ].filter(Boolean).join(" ");
+  return `${agent.agent_id}	${label}`;
+}
+function previewText(store, agent) {
+  const state = agent.state ?? "idle";
+  const colour = COLOUR[state] ?? "";
+  const head = [
+    `${colour}${GLYPH[state] ?? "?"} ${state}${RESET}  ${BOLD}${agent.agent_name ? terminalText(agent.agent_name) : agentLabel(agent)}${RESET}`,
+    // Says where, and whether "where" is this machine. The glance below is a
+    // local capture-pane or an ssh depending on this one fact, so it belongs in
+    // the header rather than being inferred from a hostname.
+    agent.host_id === loadIdentity()?.host_id ? `${DIM}here  ${agentLocation(agent)}${RESET}` : `${REMOTE}\u2192 ${terminalText(agent.host)}${RESET}  ${DIM}${agentLocation(agent)}${RESET}`
+  ];
+  const facts = [
+    agent.workstream ? `stream   ${terminalText(agent.workstream)}` : "",
+    agent.role ? `role     ${terminalText(agent.role)}` : "",
+    agent.pi_session ? `session  ${terminalText(agent.pi_session)}` : "",
+    agent.driver === "orchestrated" ? "driver   orchestrated (crew)" : "",
+    agent.stale ? `fetched  ${age(agent.age_ms)} ago` : ""
+  ].filter(Boolean);
+  const pane = glance(store, agent);
+  const live = pane?.trimEnd() ? [`${DIM}\u2500\u2500 pane \u2500\u2500${RESET}`, pane.trimEnd()] : [`${DIM}\u2500\u2500 pane \u2500\u2500${RESET}`, `${DIM}unavailable (host unreachable, or pane gone)${RESET}`];
+  const events = store.allEvents().filter((event) => event.agent_id === agent.agent_id).slice(-PREVIEW_EVENTS);
+  const history = events.length ? events.map((event) => {
+    let message = terminalText(event.message);
+    if (message.length > PREVIEW_MESSAGE_MAX) {
+      message = `${message.slice(0, PREVIEW_MESSAGE_MAX)}\u2026`;
+    }
+    const detail = message && message !== event.state ? `  ${message}` : "";
+    return `${DIM}${timestamp(event.ts)}${RESET}  ${terminalText(event.state).padEnd(8)}${detail}`;
+  }) : [`${DIM}no recorded events${RESET}`];
+  return [...head, "", ...facts, "", ...live, "", `${DIM}\u2500\u2500 history \u2500\u2500${RESET}`, ...history].join(
+    "\n"
+  );
+}
+function runPreview(store, agentId) {
+  const agent = status(store).agents.find((candidate) => candidate.agent_id === agentId);
+  if (!agent) return;
+  process.stdout.write(`${previewText(store, agent)}
+`);
+}
+async function runPick(store, options = {}) {
+  const identity = loadIdentity();
+  const view = await statusWithCollect(store);
+  const agents = view.agents.filter((agent2) => options.all || agent2.driver === "human");
+  const hidden = view.agents.length - agents.length;
+  if (agents.length === 0) {
+    process.stdout.write(
+      hidden ? `No human agents  (+${hidden} crew \u2014 rerun with --all)
+` : "No agents\n"
+    );
+    return;
+  }
+  const showHost = agents.some((agent2) => agent2.host_id !== identity?.host_id);
+  const currentPane = process.env.TMUX_PANE ?? "";
+  const input = agents.map(
+    (agent2) => pickerRow(agent2, showHost, agent2.pane === currentPane, agent2.host_id === identity?.host_id)
+  ).join("\n");
+  const counts = /* @__PURE__ */ new Map();
+  for (const agent2 of agents) {
+    const state = agent2.state ?? "idle";
+    counts.set(state, (counts.get(state) ?? 0) + 1);
+  }
+  const prompt = URGENCY.filter((state) => counts.get(state)).map((state) => `${COLOUR[state]}${GLYPH[state]}${counts.get(state)}${RESET}`).join(" ");
+  const self = process.argv[1] ?? "murmur";
+  const width = process.stdout.columns ?? 0;
+  const previewLayout = width > 0 && width < 150 ? "bottom:60%,border-top,wrap" : "right:58%,border-left,wrap";
+  const preview = `${process.execPath} ${self} pick --preview {1}`;
+  const filterBinds = FILTER_KEYS.flatMap(([key, state]) => [
+    "--bind",
+    state ? `${key}:change-query(${state})` : `${key}:change-query()`
+  ]);
+  const result = spawnSync2(
+    "fzf",
+    [
+      "--delimiter",
+      "	",
+      "--with-nth",
+      "2..",
+      "--ansi",
+      "--no-sort",
+      "--layout",
+      "reverse",
+      "--border",
+      "--info",
+      "inline",
+      "--prompt",
+      `${prompt}${prompt ? "  " : ""}`,
+      "--header",
+      [
+        `enter jump   ctrl-r refresh   ctrl-p preview   filter: ${FILTER_KEYS.map(
+          ([key, state]) => `${key.replace("ctrl-", "^")} ${state || "all"}`
+        ).join(" ")}`,
+        hidden ? `${hidden} crew hidden (--all)` : "",
+        headerRow(showHost)
+      ].filter(Boolean).join("\n"),
+      "--preview",
+      preview,
+      // Narrow terminals cannot show both the columns and a 58% preview, and
+      // the columns are the point of the list. ctrl-p cycles right / bottom /
+      // hidden, so every column is reachable on a small viewport without
+      // giving up the glance entirely.
+      "--preview-window",
+      previewLayout,
+      "--bind",
+      "ctrl-p:change-preview-window(bottom:60%,border-top,wrap|hidden|right:58%,border-left,wrap)",
+      "--bind",
+      `ctrl-r:reload(${process.execPath} ${self} pick --rows${options.all ? " --all" : ""})`,
+      ...filterBinds,
+      "--no-select-1",
+      "--no-exit-0"
+    ],
+    {
+      input,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "inherit"],
+      // FZF_DEFAULT_OPTS can carry a conflicting layout or bindings from the
+      // user's shell; the old picker stripped it for the same reason.
+      env: Object.fromEntries(
+        Object.entries(process.env).filter(([key]) => !key.startsWith("FZF_DEFAULT_OPTS"))
+      )
+    }
+  );
+  const selected = result.stdout?.trim().split("	")[0];
+  if (!selected) return;
+  const agent = agents.find((candidate) => candidate.agent_id === selected);
+  if (!agent) return;
+  const jump = jumpToAgent(store, agent);
+  if (!jump.ok) {
+    process.stderr.write(`${jump.message}
+`);
+    process.exitCode = 1;
+  }
+}
+async function runRows(store, options = {}) {
+  const identity = loadIdentity();
+  const view = await statusWithCollect(store);
+  const agents = view.agents.filter((agent) => options.all || agent.driver === "human");
+  const showHost = agents.some((agent) => agent.host_id !== identity?.host_id);
+  const currentPane = process.env.TMUX_PANE ?? "";
+  for (const agent of agents) {
+    process.stdout.write(
+      `${pickerRow(agent, showHost, agent.pane === currentPane, agent.host_id === identity?.host_id)}
+`
+    );
+  }
+}
+function registerPick(program2) {
+  program2.command("pick").description("Pick an agent and jump to it").option("--all", "include orchestrated agents").option("--preview <agent-id>", "render the preview pane for one agent (internal)").option("--rows", "print picker rows only (internal, for reload)").action(async (options) => {
+    const store = openStore();
+    try {
+      if (options.preview) runPreview(store, options.preview);
+      else if (options.rows) await runRows(store, options);
+      else await runPick(store, options);
+    } finally {
+      store.close();
+    }
+  });
+}
+
+// src/cli/status.ts
+function registerStatus(program2) {
+  program2.command("status").description("Show folded agent status").option("--json", "print JSON").action(async (options) => {
+    const store = openStore();
+    try {
+      const view = await statusWithCollect(store);
+      process.stdout.write(
+        options.json ? `${JSON.stringify(view, null, 2)}
+` : tmuxStatus(view)
+      );
+    } finally {
+      store.close();
+    }
+  });
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+
+// src/cli.ts
+var program = new Command();
+program.name("murmur").description("Agent state across every machine, in one view.").version(VERSION);
+registerInit(program);
+registerLink(program);
+registerExport(program);
+registerCollect(program);
+registerClear(program);
+registerPeer(program);
+registerStatus(program);
+registerPick(program);
+program.parse();
+//# sourceMappingURL=cli.js.map