@martintrojer/murmur 0.1.0

package/dist/extension/store.js

@@ -0,0 +1,257 @@
+// 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/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();
+    }
+  };
+}
+export {
+  loadIdentity,
+  openStore
+};
+//# sourceMappingURL=store.js.map

package/dist/extension/store.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/identity.ts","../../src/paths.ts","../../src/store.ts"],"sourcesContent":["import { randomUUID } from \"node:crypto\";\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from \"node:fs\";\nimport { hostname } from \"node:os\";\nimport { join } from \"node:path\";\nimport { stateDir } from \"./paths.js\";\n\nexport type NodeIdentity = {\n  host_id: string;\n  display_name: string;\n};\n\nexport function loadIdentity(): NodeIdentity | null {\n  const path = join(stateDir(), \"identity.json\");\n  return existsSync(path) ? JSON.parse(readFileSync(path, \"utf8\")) : null;\n}\n\nexport function ensureIdentity(displayName = hostname()): NodeIdentity {\n  const existing = loadIdentity();\n  if (existing) return existing;\n\n  const identity = { host_id: randomUUID(), display_name: displayName };\n  mkdirSync(stateDir(), { recursive: true });\n  writeFileSync(join(stateDir(), \"identity.json\"), `${JSON.stringify(identity, null, 2)}\\n`);\n  return identity;\n}\n","import { homedir } from \"node:os\";\nimport { join } from \"node:path\";\n\nexport function stateDir(): string {\n  return (\n    process.env.MURMUR_STATE_DIR ??\n    join(process.env.XDG_STATE_HOME ?? join(homedir(), \".local\", \"state\"), \"murmur\")\n  );\n}\n\nexport function configDir(): string {\n  return (\n    process.env.MURMUR_CONFIG_DIR ??\n    join(process.env.XDG_CONFIG_HOME ?? join(homedir(), \".config\"), \"murmur\")\n  );\n}\n\nexport function dbPath(): string {\n  return join(stateDir(), \"events.db\");\n}\n","import { rmSync } from \"node:fs\";\nimport Database from \"better-sqlite3\";\nimport { ensureIdentity } from \"./identity.js\";\nimport { dbPath } from \"./paths.js\";\nimport type { Driver, Event, Peer } from \"./types.js\";\n\nconst DEFAULT_RETENTION_MS = 7 * 86_400_000;\n\n/**\n * Local storage shape. Bump on any change to the events or peers tables.\n *\n * Distinct from `SCHEMA_VERSION` in export.ts, which versions the *wire*: a\n * node can change how it stores events without changing what it sends, and a\n * wire change should not throw away local history.\n */\nexport const STORE_VERSION = 2;\n\n/**\n * Migration strategy: there isn't one. A version mismatch deletes the database\n * and starts again.\n *\n * This is only acceptable because nothing in events.db is authoritative or\n * irreplaceable. It is a bounded-retention observability log: remote events\n * re-sync from their authoring peer on the next collect, local agents re-report\n * on their next state change, and node identity deliberately lives in a\n * separate file. If anything durable is ever added here, this stops being safe\n * and a real migration is required.\n *\n * Peers survive, because they are the one thing a human typed. Watermarks are\n * reset with the events they indexed -- keeping them would skip the events the\n * new database no longer has -- and re-reading a peer from zero is free, since\n * ingest is idempotent.\n */\nfunction resetIfStale(path: string): Peer[] {\n  let salvaged: Peer[] = [];\n  try {\n    const existing = new Database(path, { fileMustExist: true });\n    const version = (existing.pragma(\"user_version\", { simple: true }) as number) ?? 0;\n    if (version === STORE_VERSION) {\n      existing.close();\n      return salvaged;\n    }\n    try {\n      salvaged = existing\n        .prepare(\"SELECT name, target, host_id, display_name FROM peers\")\n        .all() as Peer[];\n    } catch {\n      // Old enough not to have the table, or unreadable. Nothing to save.\n    }\n    existing.close();\n  } catch {\n    // No database yet, or one too broken to open. Either way, recreate.\n    return salvaged;\n  }\n\n  // -wal and -shm must go too: a stale sidecar against a fresh main file is a\n  // documented way to corrupt sqlite.\n  for (const suffix of [\"\", \"-wal\", \"-shm\"]) rmSync(`${path}${suffix}`, { force: true });\n  return salvaged;\n}\n\n// The name fields are optional on the way in: a caller that has no name for a\n// thing should not have to say `null` four times, and a non-tmux harness has\n// none of them. They are non-optional on `Event` itself, so a reader never has\n// to distinguish absent from null.\nexport type NewEvent = Omit<\n  Event,\n  \"host_id\" | \"seq\" | \"ts\" | \"session_name\" | \"window_name\" | \"agent_name\" | \"pi_session\"\n> & {\n  ts?: number;\n  session_name?: string | null;\n  window_name?: string | null;\n  agent_name?: string | null;\n  pi_session?: string | null;\n};\n\ntype EventRow = Omit<Event, \"synthetic\" | \"extra\"> & {\n  synthetic: number;\n  extra: string;\n};\n\nfunction eventValues(event: Event): unknown[] {\n  return [\n    event.host_id,\n    event.seq,\n    event.ts,\n    event.agent_id,\n    event.session,\n    event.window,\n    event.pane,\n    event.session_name,\n    event.window_name,\n    event.agent_name,\n    event.pi_session,\n    event.workstream,\n    event.role,\n    event.cli,\n    event.driver,\n    event.kind,\n    event.state,\n    event.message,\n    event.pid,\n    Number(event.synthetic),\n    event.reason,\n    JSON.stringify(event.extra),\n  ];\n}\n\nfunction toEvent(row: EventRow): Event {\n  return {\n    ...row,\n    driver: row.driver as Driver | null,\n    synthetic: row.synthetic === 1,\n    extra: JSON.parse(row.extra) as Record<string, unknown>,\n  };\n}\n\nexport interface Store {\n  append(event: NewEvent): Event;\n  ingest(events: Event[]): number;\n  eventsSince(hostId: string, seq: number): Event[];\n  allEvents(): Event[];\n  maxSeq(hostId: string): number;\n  prune(horizonMs?: number): number;\n  peers(): Peer[];\n  /**\n   * Drop every event for one agent from this node's replica.\n   *\n   * For a remote agent this is a replica eviction, not a claim about truth: the\n   * authoring node still owns it, and a collect re-reads from the watermark if\n   * it is still alive.\n   */\n  forgetAgent(agentId: string): number;\n  forgetHost(hostId: string): number;\n  upsertPeer(peer: Partial<Peer> & { name: string; target: string }): void;\n  removePeer(name: string): boolean;\n  close(): void;\n}\n\nexport function openStore(): Store {\n  const identity = ensureIdentity();\n  const path = dbPath();\n  const salvagedPeers = resetIfStale(path);\n  const database = new Database(path);\n  database.pragma(\"journal_mode = WAL\");\n  database.pragma(`user_version = ${STORE_VERSION}`);\n  database.exec(`\n    CREATE TABLE IF NOT EXISTS events (\n      host_id TEXT NOT NULL,\n      seq INTEGER NOT NULL,\n      ts INTEGER NOT NULL,\n      agent_id TEXT NOT NULL,\n      session TEXT NOT NULL,\n      window TEXT NOT NULL,\n      pane TEXT NOT NULL,\n      session_name TEXT,\n      window_name TEXT,\n      agent_name TEXT,\n      pi_session TEXT,\n      workstream TEXT,\n      role TEXT,\n      cli TEXT,\n      driver TEXT,\n      kind TEXT NOT NULL,\n      state TEXT NOT NULL,\n      message TEXT NOT NULL,\n      pid INTEGER,\n      synthetic INTEGER NOT NULL,\n      reason TEXT NOT NULL,\n      extra TEXT NOT NULL,\n      PRIMARY KEY (host_id, seq)\n    );\n    CREATE INDEX IF NOT EXISTS events_agent_seq ON events (agent_id, seq);\n    CREATE TABLE IF NOT EXISTS peers (\n      name TEXT PRIMARY KEY,\n      target TEXT NOT NULL,\n      host_id TEXT,\n      display_name TEXT,\n      watermark INTEGER NOT NULL,\n      fetched_at INTEGER,\n      -- When a jump last proved this peer's tmux was not answering. Reader\n      -- state, not an event: this node cannot author facts about another\n      -- node's agents, and a jump is a local observation, not something the\n      -- peer said. Cleared by the next successful collect.\n      tmux_down_at INTEGER\n    );\n  `);\n\n  // Additive migration: an existing peers table predates tmux_down_at.\n  try {\n    database.exec(\"ALTER TABLE peers ADD COLUMN tmux_down_at INTEGER\");\n  } catch {\n    // Already present.\n  }\n\n  // Put back the peers the wipe took, at watermark 0 so the next collect\n  // re-reads each one from the start.\n  if (salvagedPeers.length > 0) {\n    const restore = database.prepare(\n      `INSERT OR IGNORE INTO peers (name, target, host_id, display_name, watermark, fetched_at)\n       VALUES (?, ?, ?, ?, 0, NULL)`,\n    );\n    for (const peer of salvagedPeers) {\n      restore.run(peer.name, peer.target, peer.host_id ?? null, peer.display_name ?? null);\n    }\n  }\n\n  const eventColumns = `\n      host_id, seq, ts, agent_id, session, window, pane,\n      session_name, window_name, agent_name, pi_session,\n      workstream, role, cli, driver, kind, state, message, pid,\n      synthetic, reason, extra`;\n  const eventPlaceholders = new Array(22).fill(\"?\").join(\", \");\n  const insertEvent = database.prepare(\n    `INSERT INTO events (${eventColumns}) VALUES (${eventPlaceholders})`,\n  );\n  const ingestEvent = database.prepare(\n    `INSERT OR IGNORE INTO events (${eventColumns}) VALUES (${eventPlaceholders})`,\n  );\n  const selectMaxSeq = database.prepare(\n    \"SELECT COALESCE(MAX(seq), 0) AS seq FROM events WHERE host_id = ?\",\n  );\n  const append = database.transaction((event: NewEvent): Event => {\n    const row = selectMaxSeq.get(identity.host_id) as { seq: number };\n    const stored: Event = {\n      ...event,\n      host_id: identity.host_id,\n      seq: row.seq + 1,\n      ts: event.ts ?? Date.now(),\n      session_name: event.session_name ?? null,\n      window_name: event.window_name ?? null,\n      agent_name: event.agent_name ?? null,\n      pi_session: event.pi_session ?? null,\n    };\n    insertEvent.run(...eventValues(stored));\n    return stored;\n  });\n  const ingest = database.transaction((events: Event[]): number => {\n    let inserted = 0;\n    for (const event of events) inserted += ingestEvent.run(...eventValues(event)).changes;\n    return inserted;\n  });\n\n  return {\n    append,\n    ingest,\n    eventsSince(hostId, seq) {\n      const rows = database\n        .prepare(\"SELECT * FROM events WHERE host_id = ? AND seq > ? ORDER BY seq\")\n        .all(hostId, seq) as EventRow[];\n      return rows.map(toEvent);\n    },\n    allEvents() {\n      const rows = database\n        .prepare(\"SELECT * FROM events ORDER BY ts, host_id, seq\")\n        .all() as EventRow[];\n      return rows.map(toEvent);\n    },\n    maxSeq(hostId) {\n      return (selectMaxSeq.get(hostId) as { seq: number }).seq;\n    },\n    prune(horizonMs = Number(process.env.MURMUR_RETENTION_MS ?? DEFAULT_RETENTION_MS)) {\n      return database\n        .prepare(`\n          DELETE FROM events\n           WHERE ts < ?\n             AND (host_id, seq) NOT IN (\n               SELECT host_id, seq FROM (\n                 SELECT host_id, seq,\n                        ROW_NUMBER() OVER (PARTITION BY agent_id ORDER BY ts DESC, seq DESC) rn\n                   FROM events\n               ) WHERE rn = 1\n             )\n        `)\n        .run(Date.now() - horizonMs).changes;\n    },\n    peers() {\n      return database.prepare(\"SELECT * FROM peers ORDER BY name\").all() as Peer[];\n    },\n    forgetAgent(agentId) {\n      return database.prepare(\"DELETE FROM events WHERE agent_id = ?\").run(agentId).changes;\n    },\n    forgetHost(hostId) {\n      // Every replicated row for one origin node. Only ever called about a\n      // REMOTE host: the local host's rows are this node's own authorship and\n      // the retention horizon owns them.\n      return database.prepare(\"DELETE FROM events WHERE host_id = ?\").run(hostId).changes;\n    },\n    upsertPeer(peer) {\n      const current = database.prepare(\"SELECT * FROM peers WHERE name = ?\").get(peer.name) as\n        | Peer\n        | undefined;\n      database\n        .prepare(`\n          INSERT INTO peers (name, target, host_id, display_name, watermark, fetched_at, tmux_down_at)\n          VALUES (?, ?, ?, ?, ?, ?, ?)\n          ON CONFLICT(name) DO UPDATE SET\n            target = excluded.target,\n            host_id = excluded.host_id,\n            display_name = excluded.display_name,\n            watermark = excluded.watermark,\n            fetched_at = excluded.fetched_at,\n            tmux_down_at = excluded.tmux_down_at\n        `)\n        .run(\n          peer.name,\n          peer.target,\n          peer.host_id !== undefined ? peer.host_id : (current?.host_id ?? null),\n          peer.display_name !== undefined ? peer.display_name : (current?.display_name ?? null),\n          peer.watermark !== undefined ? peer.watermark : (current?.watermark ?? 0),\n          peer.fetched_at !== undefined ? peer.fetched_at : (current?.fetched_at ?? null),\n          peer.tmux_down_at !== undefined ? peer.tmux_down_at : (current?.tmux_down_at ?? null),\n        );\n    },\n    removePeer(name) {\n      // Drops the peer and its watermark. Replicated events stay: they are\n      // real history authored elsewhere, and the retention horizon already\n      // ages them out. Re-adding the peer re-syncs from zero, which ingest\n      // makes free.\n      return database.prepare(\"DELETE FROM peers WHERE name = ?\").run(name).changes > 0;\n    },\n    close() {\n      database.close();\n    },\n  };\n}\n"],"mappings":"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","names":["join","join"]}

package/dist/index.d.ts

@@ -0,0 +1,216 @@
+type AgentState = "working" | "blocked" | "done" | "crashed" | "cleared";
+type Driver = "human" | "orchestrated";
+declare const DEFAULT_DRIVER: Driver;
+type Event = {
+    host_id: string;
+    seq: number;
+    ts: number;
+    agent_id: string;
+    session: string;
+    window: string;
+    pane: string;
+    session_name: string | null;
+    window_name: string | null;
+    agent_name: string | null;
+    pi_session: string | null;
+    workstream: string | null;
+    role: string | null;
+    cli: string | null;
+    driver: Driver | null;
+    kind: string;
+    state: AgentState | string;
+    message: string;
+    pid: number | null;
+    synthetic: boolean;
+    reason: string;
+    extra: Record<string, unknown>;
+};
+type Peer = {
+    name: string;
+    target: string;
+    host_id: string | null;
+    display_name: string | null;
+    watermark: number;
+    fetched_at: number | null;
+    /** When a jump last found this peer's tmux server down. Null once it answers. */
+    tmux_down_at: number | null;
+};
+
+type LiveCheck = (pid: number) => boolean;
+type AgentView = {
+    agent_id: string;
+    host_id: string;
+    state: AgentState | null;
+    event: Event | null;
+    workstream: string | null;
+    role: string | null;
+    cli: string | null;
+    driver: Driver;
+    session: string;
+    window: string;
+    pane: string;
+    session_name: string | null;
+    window_name: string | null;
+    agent_name: string | null;
+    pi_session: string | null;
+    fetched_at: number | null;
+};
+declare function foldAgent(events: Event[], isAlive: LiveCheck): {
+    state: AgentState | null;
+    event: Event | null;
+};
+declare function foldAll(events: Event[], isAlive: LiveCheck): AgentView[];
+declare function attentionSort(views: AgentView[]): AgentView[];
+declare function isStale(fetchedAt: number | null, now: number, thresholdMs?: number): boolean;
+
+/**
+ * Local storage shape. Bump on any change to the events or peers tables.
+ *
+ * Distinct from `SCHEMA_VERSION` in export.ts, which versions the *wire*: a
+ * node can change how it stores events without changing what it sends, and a
+ * wire change should not throw away local history.
+ */
+declare const STORE_VERSION = 2;
+type NewEvent = Omit<Event, "host_id" | "seq" | "ts" | "session_name" | "window_name" | "agent_name" | "pi_session"> & {
+    ts?: number;
+    session_name?: string | null;
+    window_name?: string | null;
+    agent_name?: string | null;
+    pi_session?: string | null;
+};
+interface Store {
+    append(event: NewEvent): Event;
+    ingest(events: Event[]): number;
+    eventsSince(hostId: string, seq: number): Event[];
+    allEvents(): Event[];
+    maxSeq(hostId: string): number;
+    prune(horizonMs?: number): number;
+    peers(): Peer[];
+    /**
+     * Drop every event for one agent from this node's replica.
+     *
+     * For a remote agent this is a replica eviction, not a claim about truth: the
+     * authoring node still owns it, and a collect re-reads from the watermark if
+     * it is still alive.
+     */
+    forgetAgent(agentId: string): number;
+    forgetHost(hostId: string): number;
+    upsertPeer(peer: Partial<Peer> & {
+        name: string;
+        target: string;
+    }): void;
+    removePeer(name: string): boolean;
+    close(): void;
+}
+declare function openStore(): Store;
+
+type StatusState = "working" | "blocked" | "done" | "crashed" | "idle";
+type Counts = Record<StatusState, number>;
+type Status = {
+    counts: Counts;
+    orchestrated_counts: Counts;
+    agents: (AgentView & {
+        stale: boolean;
+        age_ms: number | null;
+        event_age_ms: number | null;
+        tmux_down: boolean;
+        host: string;
+    })[];
+    peers: {
+        name: string;
+        display_name: string | null;
+        fetched_at: number | null;
+        stale: boolean;
+    }[];
+};
+/**
+ * Fold the current view. Pure with respect to the network: the caller decides
+ * whether to collect first (see `statusWithCollect`).
+ */
+declare function status(store: Store, now?: number): Status;
+
+type Agent = Status["agents"][number];
+/**
+ * The most specific human-readable name an agent has, never a tmux id.
+ *
+ * Four sources, most to least specific: mu's agent name, pi's session name,
+ * the tmux window name, the tmux session name. The old picker showed window
+ * names and that was the thing it did better than raw `$26:@79`; these are all
+ * recorded on the event, so this reads the same for a local and a remote agent.
+ *
+ * Falls back to the window id only when a node recorded no names at all, which
+ * means a pre-names event or a non-tmux harness.
+ */
+declare function agentLabel(agent: Agent): string;
+/**
+ * Where the agent lives, for the second column. Names only -- the ids are what
+ * jumps, not what a human reads.
+ */
+declare function agentLocation(agent: Agent): string;
+declare function shellQuote(value: string): string;
+type JumpResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: "no_peer" | "unreachable" | "no_tmux" | "window_gone";
+    message: string;
+};
+declare function jumpToAgent(store: Store, agent: Agent): JumpResult;
+
+interface Channel {
+    exec(target: string, argv: string[]): Promise<string>;
+}
+declare const ssh: Channel;
+declare function hasWarmSocket(target: string): boolean;
+
+declare const COLLECT_INTERVAL_MS = 30000;
+declare const STALENESS_MS: number;
+type CollectResult = {
+    peer: string;
+    ok: boolean;
+    ingested: number;
+    error?: string;
+};
+declare function collect(store: Store, channel: Channel, now?: number): Promise<CollectResult[]>;
+
+declare const SCHEMA_VERSION = 2;
+declare function eventFromWire(wire: Record<string, unknown>): Event;
+declare function exportJsonl(store: Store, since: number, isAlive: LiveCheck, live?: Set<string> | null): string;
+
+declare function glance(store: Store, agent: Agent, lines?: number): string | null;
+
+type NodeIdentity = {
+    host_id: string;
+    display_name: string;
+};
+declare function loadIdentity(): NodeIdentity | null;
+declare function ensureIdentity(displayName?: string): NodeIdentity;
+
+type Location = {
+    session: string;
+    window: string;
+    pane: string;
+    session_name: string | null;
+    window_name: string | null;
+};
+interface Mux {
+    currentWindow(): Location | null;
+    liveWindows(): Set<string> | null;
+    setState(window: string, state: AgentState | null): void;
+    attach(session: string, window: string): void;
+    windowNames(): Map<string, string>;
+    windowForPane(pane: string): string | null;
+    windowNamed(name: string): string | null;
+    selectWindow(window: string): void;
+    capture(pane: string, lines?: number): string | null;
+}
+declare const tmux: Mux;
+declare function pidAlive(pid: number): boolean;
+
+declare function stateDir(): string;
+declare function configDir(): string;
+declare function dbPath(): string;
+
+declare const VERSION = "0.1.0";
+
+export { type Agent, type AgentState, type AgentView, COLLECT_INTERVAL_MS, type Channel, type CollectResult, DEFAULT_DRIVER, type Driver, type Event, type JumpResult, type LiveCheck, type Mux, type NewEvent, type NodeIdentity, type Peer, SCHEMA_VERSION, STALENESS_MS, STORE_VERSION, type Status, type Store, VERSION, agentLabel, agentLocation, attentionSort, collect, configDir, dbPath, ensureIdentity, eventFromWire, exportJsonl, foldAgent, foldAll, glance, hasWarmSocket, isStale, jumpToAgent, loadIdentity, openStore, pidAlive, shellQuote, ssh, stateDir, status, tmux };