chord-cli 0.1.0 → 0.1.1

package/src/cli.ts

@@ -1,234 +0,0 @@
-#!/usr/bin/env node
-// chord <claude|codex> [--name <agent>] [tool args...]   launch an agent in its own workspace
-// chord ls [--all]                                        agents and file claims, this project or all
-// chord messages [agent] [-n N]                           message history
-// chord events [agent] [-n N]                             claim, release, merge and conflict history
-// chord stop <agent>                                      quit an agent once it is idle
-// chord clean [--force] [agent...]                        remove offline agents' workspaces, worktrees and branches
-import { execFileSync } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-import { createInterface } from 'node:readline/promises';
-import { fileURLToPath } from 'node:url';
-import { clean } from './clean.ts';
-import * as db from './db.ts';
-import { mergeUserSettings, prepare } from './launch.ts';
-import { NeedsRestructure, knownProjects, resolveProject, restructure, restructureBlocker, validateRepoName } from './project.ts';
-import { resolveCommand, run } from './pty.ts';
-import { disabledCodexHooks, pretrustClaude } from './trust.ts';
-import type { Tool } from './hooks.ts';
-
-const USAGE = 'usage: chord <claude|codex> [--name <agent>] [tool args...]\n       chord ls [--all]\n       chord messages [agent] [-n N]\n       chord events [agent] [-n N]\n       chord stop <agent>\n       chord clean [--force] [agent...]\n';
-
-const gitOut = (cwd: string, ...args: string[]): string | undefined => {
-  try { return execFileSync('git', args, { cwd, encoding: 'utf8', env: db.gitEnv(), stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return undefined; }
-};
-
-/** "12s", "3m", "2h", "5d": how long ago. */
-export function ago(ms: number): string {
-  const s = Math.max(0, Math.round(ms / 1000));
-  return s < 60 ? `${s}s` : s < 3600 ? `${Math.floor(s / 60)}m` : s < 86400 ? `${Math.floor(s / 3600)}h` : `${Math.floor(s / 86400)}d`;
-}
-
-/** Local time of day, with the date in front when it is not today. */
-export function when(t: number, now = Date.now()): string {
-  const d = new Date(t), pad = (n: number) => String(n).padStart(2, '0');
-  const time = `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
-  return d.toDateString() === new Date(now).toDateString() ? time : `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${time}`;
-}
-
-/** Agents (with unread messages, time since the last sign of life, commits on their branch not yet on main) and
- *  claims. `repo` is the main checkout; without it the branch column shows "?". */
-export function ls(d: ReturnType<typeof db.openDb>, repo?: string, now = Date.now()): string {
-  db.sweep(d);
-  const agents = db.listAgents(d);
-  const claims = db.allClaims(d);
-  const main = repo ? gitOut(repo, 'rev-parse', '--abbrev-ref', 'HEAD') : undefined;
-  const ahead = (name: string) => { if (!repo || !main) return '?'; const n = gitOut(repo, 'rev-list', '--count', `${main}..chord/${name}`); return n === undefined ? '-' : `+${n}`; };
-  const unread = (name: string) => (d.prepare('select count(*) c from messages where recipient = ? and read_at is null').get(name) as { c: number }).c;
-  const row = (a: db.Agent) => [a.name.padEnd(28), a.tool.padEnd(7), a.status.padEnd(8), String(unread(a.name)).padEnd(6), ago(now - (a.heartbeat_at ?? a.updated_at)).padEnd(7), ahead(a.name).padEnd(6), `${a.task ?? '-'}${a.scope ? ` [${a.scope}]` : ''}`].join(' ');
-  const header = ['agent'.padEnd(28), 'tool'.padEnd(7), 'status'.padEnd(8), 'unread', 'active'.padEnd(7), 'branch', 'task'].join(' ');
-  const out = agents.length ? [header, ...agents.map(row)] : ['no agents'];
-  out.push('', ...(claims.length ? claims.map(c => `${c.file.padEnd(40)} ${c.agent.padEnd(28)} ${c.kind.padEnd(7)} ${c.intent}`) : ['no claims']));
-  return out.join('\n') + '\n';
-}
-export function lsAll(): string {
-  const projects = knownProjects();
-  if (!projects.length) return 'no chord projects on this machine yet\n';
-  const repoOf = (dir?: string) => { try { return dir ? resolveProject(dir).repo : undefined; } catch { return undefined; } };
-  return projects.map(p => {
-    try { return `== ${p.dir ?? p.stateDir}\n${ls(db.openDb(p.dbFile), repoOf(p.dir ?? undefined))}`; } catch (e) { return `== ${p.dir ?? p.stateDir}\n(unreadable: ${(e as Error).message})\n`; }
-  }).join('\n');
-}
-
-/** chord messages [agent] [-n N]: the latest messages, oldest first, one line each. */
-export function messages(d: ReturnType<typeof db.openDb>, agent?: string, limit = 50, now = Date.now()): string {
-  const ms = db.listMessages(d, agent, limit);
-  if (!ms.length) return agent ? `no messages to or from ${agent}\n` : 'no messages\n';
-  const oneLine = (s: string) => s.replace(/\s+/g, ' ').trim();
-  return ms.map(m => `${when(m.created_at, now)} ${m.sender} -> ${m.recipient}${m.kind !== 'message' ? ` [${m.kind}]` : ''}${m.read_at ? '' : ' (unread)'}: ${oneLine(m.body)}`).join('\n') + '\n';
-}
-
-/** chord events [agent] [-n N]: claims, releases, merges and conflicts, oldest first. */
-export function events(d: ReturnType<typeof db.openDb>, agent?: string, limit = 50, now = Date.now()): string {
-  const es = db.listEvents(d, agent, limit);
-  if (!es.length) return agent ? `no events for ${agent}\n` : 'no events\n';
-  return es.map(e => `${when(e.at, now)} ${e.agent.padEnd(28)} ${e.kind.padEnd(8)} ${[e.file, e.detail].filter(Boolean).join(' ')}`).join('\n') + '\n';
-}
-
-/** chord stop <agent>: the wrapper quits the tool once the agent is idle and nothing is typed. */
-export function stop(d: ReturnType<typeof db.openDb>, name: string): string {
-  if (db.requestStop(d, name)) return `stop requested: ${name} will quit when its current turn ends and its input box is empty\n`;
-  throw new Error(db.getAgent(d, name) ? `${name} is already offline` : `no such agent: ${name}`);
-}
-
-/** [agent] and -n N for the history commands. */
-export function listArgs(rest: string[]): { agent?: string; limit: number } {
-  let agent: string | undefined, limit = 50;
-  for (let i = 0; i < rest.length; i++) {
-    if (rest[i] === '-n') { limit = Number(rest[++i]); if (!Number.isInteger(limit) || limit <= 0) throw new Error('-n needs a positive number'); }
-    else if (rest[i].startsWith('-')) throw new Error(`unknown option ${rest[i]}`);
-    else if (agent) throw new Error('give at most one agent name');
-    else agent = rest[i];
-  }
-  return { agent, limit };
-}
-
-/** `--name <x>` or `--name=<x>` anywhere before the tool's own arguments. */
-/** The user's own `--settings <json|file>` for Claude, removed from the tool arguments: passed through as is it would
- *  replace chord's --settings wholesale and switch the hooks off, so chord folds it under its own instead. */
-export function takeSettings(rest: string[]): Record<string, any> | undefined {
-  let raw: string | undefined;
-  for (let i = 0; i < rest.length; i++) {
-    const a = rest[i];
-    if (a === '--settings') { raw = rest[i + 1]; if (raw === undefined || raw.startsWith('-')) throw new Error('--settings needs a value'); rest.splice(i, 2); break; }
-    if (a.startsWith('--settings=')) { raw = a.slice(11); rest.splice(i, 1); break; }
-  }
-  if (raw === undefined) return undefined;
-  const text = fs.existsSync(raw) ? fs.readFileSync(raw, 'utf8') : raw;
-  let parsed: unknown;
-  try { parsed = JSON.parse(text); } catch { throw new Error(`--settings must be a JSON object or a path to a JSON file: ${raw}`); }
-  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) throw new Error('--settings must be a JSON object');
-  return parsed as Record<string, any>;
-}
-
-/** Tool flags that would silently disable chord's hooks or MCP server: refused rather than launched half-working. */
-export function refuseHookKillers(tool: Tool, rest: string[]): void {
-  if (tool === 'claude') {
-    for (const flag of ['--bare', '--safe-mode', '--disable-all-hooks']) if (rest.includes(flag)) throw new Error(`${flag} switches off the hooks chord relies on; run plain claude for that`);
-  } else {
-    for (let i = 0; i < rest.length; i++) {
-      const v = rest[i] === '-c' || rest[i] === '--config' ? rest[i + 1] ?? '' : rest[i].startsWith('--config=') ? rest[i].slice(9) : '';
-      if (/^(hooks\b|mcp_servers\.chord\b)/.test(v)) throw new Error(`"-c ${v}" would replace chord's own hooks or MCP server; chord sets these itself`);
-      // Codex's Windows sandbox runs commands as a restricted user that cannot start chord's hooks (nor reach the
-      // state under the user's profile), so claims would go unchecked; refused rather than run half-working
-      const sandbox = rest[i] === '-s' || rest[i] === '--sandbox' ? rest[i + 1] ?? '' : rest[i].startsWith('--sandbox=') ? rest[i].slice(10) : /^sandbox_mode\s*=\s*"?([\w-]+)/.exec(v)?.[1] ?? '';
-      if (process.platform === 'win32' && sandbox && sandbox !== 'danger-full-access') throw new Error(`Codex's "${sandbox}" sandbox cannot run chord's hooks on Windows (the sandboxed user cannot start them), so file claims would not be checked; run without -s, or with -s danger-full-access`);
-    }
-  }
-}
-
-export function takeName(rest: string[]): string | undefined {
-  for (let i = 0; i < rest.length; i++) {
-    const a = rest[i];
-    if (a === '--name') {
-      const v = rest[i + 1];
-      if (!v || v.startsWith('-')) throw new Error('--name needs a value');
-      rest.splice(i, 2); return v;
-    }
-    if (a.startsWith('--name=')) { rest.splice(i, 1); const v = a.slice(7); if (!v) throw new Error('--name needs a value'); return v; }
-  }
-  return undefined;
-}
-
-/** The folder is a repository root: offer to move it into a child directory so it fits the project layout.
- *  Throws with guidance when that is impossible or declined. */
-async function offerRestructure(e: NeedsRestructure): Promise<void> {
-  const example = path.join(e.dir, e.suggestedName);
-  const blocker = restructureBlocker(e.dir);
-  if (blocker) throw new Error(`${e.message}; ${blocker}`);
-  if (!process.stdin.isTTY) throw new Error(`${e.message}. Move it into a subfolder (e.g. ${example}) and run chord in ${e.dir} again`);
-  const rl = createInterface({ input: process.stdin, output: process.stderr });
-  try {
-    process.stderr.write(`chord: ${e.dir} is itself a git repository.\n` +
-      `A chord project is a folder that contains the repository as a subfolder, next to chord's own working directory.\n` +
-      `Move everything in ${e.dir} into ${example}${path.sep} ? Open editors, other terminals' current directory and absolute paths in IDE settings will need updating.\n`);
-    for (let attempt = 0; attempt < 3; attempt++) {
-      const answer = (await rl.question(`[Y/n/other name] (${e.suggestedName}): `)).trim();
-      if (/^n(o)?$/i.test(answer)) throw new Error('not moved; move the repository into a subfolder yourself and run chord in the parent folder');
-      const name = answer === '' || /^y(es)?$/i.test(answer) ? e.suggestedName : answer;
-      const invalid = validateRepoName(name) ?? (fs.existsSync(path.join(e.dir, name)) ? `${name} already exists` : null);
-      if (invalid) { process.stderr.write(`chord: ${invalid}; try another name\n`); continue; }
-      const target = restructure(e.dir, name);
-      process.stderr.write(`chord: moved the repository to ${target}\n`);
-      return;
-    }
-    throw new Error('no usable name given; nothing was moved');
-  } finally { rl.close(); }
-}
-
-async function main(argv: string[]): Promise<number> {
-  const [cmd, ...rest] = argv;
-  if (cmd === 'ls') {
-    if (rest.includes('--all')) { process.stdout.write(lsAll()); return 0; }
-    let project;
-    try { project = resolveProject(process.cwd()); } catch (e) {
-      if (e instanceof NeedsRestructure) throw new Error(`${e.message}; run \`chord claude\` or \`chord codex\` here to set the project up, or \`chord ls --all\` for every project`);
-      throw new Error(`${(e as Error).message}; use \`chord ls --all\` for every project on this machine`);
-    }
-    const file = db.dbPath(project.stateDir);
-    if (!fs.existsSync(file)) { process.stdout.write(`no agents have run in ${project.dir} yet\n`); return 0; }
-    process.stdout.write(ls(db.openDb(file), project.repo));
-    return 0;
-  }
-  if (cmd === 'messages' || cmd === 'events' || cmd === 'stop') {
-    const project = resolveProject(process.cwd());
-    const file = db.dbPath(project.stateDir);
-    if (!fs.existsSync(file)) { process.stdout.write(`no agents have run in ${project.dir} yet\n`); return 0; }
-    const d = db.openDb(file);
-    if (cmd === 'stop') { if (rest.length !== 1) { process.stderr.write(USAGE); return 2; } process.stdout.write(stop(d, rest[0])); return 0; }
-    const { agent, limit } = listArgs(rest);
-    process.stdout.write(cmd === 'messages' ? messages(d, agent, limit) : events(d, agent, limit));
-    return 0;
-  }
-  if (cmd === 'clean') {
-    const project = resolveProject(process.cwd());
-    const file = db.dbPath(project.stateDir);
-    if (!fs.existsSync(file)) { process.stdout.write(`no agents have run in ${project.dir} yet\n`); return 0; }
-    const force = rest.includes('--force');
-    const r = clean(project, db.openDb(file), rest.filter(a => a !== '--force'), force);
-    for (const n of r.removed) process.stdout.write(`removed ${n}\n`);
-    for (const k of r.kept) process.stdout.write(`kept ${k.name}: ${k.why}\n`);
-    if (!r.removed.length && !r.kept.length) process.stdout.write('nothing to clean\n');
-    return 0;
-  }
-  if (cmd !== 'claude' && cmd !== 'codex') { process.stderr.write(USAGE); return 2; }
-  const name = takeName(rest);
-  const userSettings = cmd === 'claude' ? takeSettings(rest) : undefined;
-  refuseHookKillers(cmd as Tool, rest);
-  resolveCommand(cmd); // fail before creating a workspace when the tool is not installed
-  let launch;
-  try {
-    launch = prepare(cmd as Tool, process.cwd(), name);
-  } catch (e) {
-    if (!(e instanceof NeedsRestructure)) throw e;
-    await offerRestructure(e);
-    launch = prepare(cmd as Tool, process.cwd(), name);
-  }
-  process.stderr.write(`chord: agent ${launch.name} in ${launch.cwd}\n`);
-  if (userSettings) launch.args = mergeUserSettings(launch.args, userSettings);
-  if (cmd === 'claude') { // otherwise every new workspace asks "do you trust this folder?"; a failure here only brings that dialogue back
-    try { pretrustClaude(launch.cwd); } catch (e) { process.stderr.write(`chord: could not record the workspace as trusted in ~/.claude.json (${(e as Error).message}); Claude may ask you to trust the folder\n`); }
-  }
-  if (cmd === 'codex') {
-    const off = disabledCodexHooks();
-    if (off.length) process.stderr.write(`chord: Codex has chord's ${off.join(', ')} hook(s) switched off in ~/.codex/config.toml, so the matching chord features will not work. Remove the "enabled = false" line(s) under the [hooks.state.'...<session-flags>...'] tables to switch them back on.\n`);
-  }
-  return run(cmd as Tool, launch, rest);
-}
-
-// run only as the entry point (argv[1] may be a symlink such as an npm bin link)
-const isMain = (() => { try { return fs.realpathSync.native(process.argv[1] ?? '') === fs.realpathSync.native(fileURLToPath(import.meta.url)); } catch { return false; } })();
-if (isMain) {
-  main(process.argv.slice(2)).then(code => process.exit(code), e => { process.stderr.write(`chord: ${(e as Error).message}\n`); process.exit(1); });
-}

package/src/db.ts

@@ -1,331 +0,0 @@
-import { DatabaseSync } from 'node:sqlite';
-import { execFileSync } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-
-export type Status = 'busy' | 'idle' | 'offline';
-
-export interface Agent {
-  name: string;
-  tool: string;
-  pid: number;
-  cwd: string;      // the agent's working directory (its workspace W)
-  worktree: string; // the repository worktree inside W, used by finish
-  task: string | null;
-  scope: string | null;
-  status: Status;
-  started_at: number;
-  updated_at: number;
-  heartbeat_at: number | null; // refreshed by the wrapper; null for agents without one (tests)
-  stop_requested_at: number | null; // set by `chord stop`; the wrapper quits the tool once the agent is idle
-}
-
-export interface Claim {
-  rid: number;      // rowid: orders claims created in the same millisecond
-  agent: string;
-  file: string;
-  intent: string;
-  kind: string;
-  symbols: string | null;
-  created_at: number;
-  asked_at: number | null;
-}
-
-export type MessageKind = 'message' | 'notice';
-
-export interface Message {
-  id: number;
-  sender: string;
-  recipient: string;
-  kind: MessageKind; // notices (e.g. "X merged into main") never count as replies
-  body: string;
-  created_at: number;
-  read_at: number | null;
-}
-
-/** process.env without the GIT_* variables that would make git look at some other repository. */
-export function gitEnv(): NodeJS.ProcessEnv {
-  const env: NodeJS.ProcessEnv = {};
-  for (const [k, v] of Object.entries(process.env)) if (!/^GIT_(DIR|WORK_TREE|INDEX_FILE|COMMON_DIR|OBJECT_DIRECTORY|NAMESPACE|CEILING_DIRECTORIES|ALTERNATE_OBJECT_DIRECTORIES)$/.test(k)) env[k] = v;
-  return env;
-}
-
-const commonDir = (cwd: string) => path.resolve(cwd, execFileSync('git', ['rev-parse', '--git-common-dir'], { cwd, encoding: 'utf8', env: gitEnv() }).trim());
-
-/** Root of the main checkout, even when run from inside a linked worktree. */
-export const mainRoot = (cwd: string) => path.dirname(commonDir(cwd));
-
-/** chord.db lives in the project's state directory under ~/.chord; CHORD_DB carries its path to hooks and servers. */
-export const dbPath = (stateDir: string) => path.join(stateDir, 'chord.db');
-
-/** Lock file that serialises finish() across agents: git cannot run two merges in one checkout at once. */
-export const finishLockPath = (dbFile = process.env.CHORD_DB ?? '') => path.join(path.dirname(dbFile), 'finish.lock');
-
-/** Windows and macOS file systems are case-insensitive: Src/a.ts and src/a.ts are one file, so one claim key. */
-const FILE_COLLATION = process.platform === 'linux' ? '' : 'collate nocase';
-
-export function openDb(file: string): DatabaseSync {
-  // the busy timeout must be in force before the first statement: switching to WAL below does not wait otherwise,
-  // and several agents starting at once on a new database all hit it together
-  const db = new DatabaseSync(file, { timeout: 5000 });
-  db.exec(`
-    pragma journal_mode = wal;
-    pragma busy_timeout = 5000;
-    pragma foreign_keys = on;
-    create table if not exists agents (
-      name       text primary key,
-      tool       text not null,
-      pid        integer not null,
-      cwd        text not null,
-      worktree   text not null,
-      task       text,
-      scope      text,
-      status     text not null default 'busy',
-      started_at integer not null,
-      updated_at integer not null,
-      heartbeat_at integer,
-      stop_requested_at integer
-    );
-    create table if not exists claims (
-      agent    text not null references agents(name),
-      file     text not null ${FILE_COLLATION},
-      intent   text not null,
-      kind     text not null,
-      symbols    text,
-      created_at integer not null,
-      asked_at   integer,
-      primary key (agent, file)
-    );
-    create table if not exists messages (
-      id         integer primary key autoincrement,
-      sender     text not null,
-      recipient  text not null,
-      kind       text not null default 'message',
-      body       text not null,
-      created_at integer not null,
-      read_at    integer
-    );
-    create table if not exists events (
-      id     integer primary key autoincrement,
-      at     integer not null,
-      agent  text not null,
-      kind   text not null,
-      file   text,
-      detail text
-    );
-  `);
-  migrate(db);
-  return db;
-}
-
-/** Bump when the schema changes and add a step below; `pragma user_version` records what a database has. A database
- *  from before versioning reads as 0 and gets every step, each of which checks what is actually there. */
-const SCHEMA_VERSION = 2;
-
-function migrate(db: DatabaseSync): void {
-  const v = (db.prepare('pragma user_version').get() as { user_version: number }).user_version;
-  if (v >= SCHEMA_VERSION) return;
-  const agentCols = () => (db.prepare('pragma table_info(agents)').all() as { name: string }[]).map(c => c.name);
-  if (v < 1 && !agentCols().includes('heartbeat_at')) db.exec('alter table agents add column heartbeat_at integer'); // 2026-10-17
-  if (v < 2 && !agentCols().includes('stop_requested_at')) db.exec('alter table agents add column stop_requested_at integer'); // 2026-10-17; the events table is created above
-  db.exec(`pragma user_version = ${SCHEMA_VERSION}`);
-}
-
-// agents
-
-export function addAgent(db: DatabaseSync, a: { name: string; tool: string; pid: number; cwd: string; worktree?: string; heartbeat?: boolean }): void {
-  const now = Date.now();
-  db.prepare(
-    `insert into agents (name, tool, pid, cwd, worktree, status, started_at, updated_at, heartbeat_at)
-     values (?, ?, ?, ?, ?, 'busy', ?, ?, ?)
-     on conflict(name) do update set tool = excluded.tool, pid = excluded.pid, cwd = excluded.cwd, worktree = excluded.worktree,
-       status = 'busy', task = null, scope = null, started_at = excluded.started_at, updated_at = excluded.updated_at, heartbeat_at = excluded.heartbeat_at,
-       stop_requested_at = null`,
-  ).run(a.name, a.tool, a.pid, a.cwd, a.worktree ?? a.cwd, now, now, a.heartbeat ? now : null);
-  // a relaunch under the same name must not inherit messages meant for the previous session
-  db.prepare('delete from messages where recipient = ? and read_at is null').run(a.name);
-}
-
-/** Forget an agent entirely: its claims and every message it sent or received. */
-export function removeAgent(db: DatabaseSync, name: string): void {
-  db.prepare('delete from claims where agent = ?').run(name);
-  db.prepare('delete from messages where sender = ? or recipient = ?').run(name, name);
-  db.prepare('delete from agents where name = ?').run(name);
-}
-
-export function setTask(db: DatabaseSync, name: string, task: string, scope: string | null): void {
-  db.prepare('update agents set task = ?, scope = ?, updated_at = ? where name = ?').run(task, scope, Date.now(), name);
-}
-
-/** Offline is sticky here: a hook that outlives its killed agent must not revive it. Only the wrapper does, through
- *  addAgent (relaunch) or heartbeat. */
-export function setStatus(db: DatabaseSync, name: string, status: Status): void {
-  db.prepare(`update agents set status = ?, updated_at = ? where name = ? and status != 'offline'`).run(status, Date.now(), name);
-}
-
-export function getAgent(db: DatabaseSync, name: string): Agent | undefined {
-  return db.prepare('select * from agents where name = ?').get(name) as Agent | undefined;
-}
-
-export function listAgents(db: DatabaseSync): Agent[] {
-  return db.prepare('select * from agents order by started_at').all() as unknown as Agent[];
-}
-
-function pidAlive(pid: number): boolean {
-  try { process.kill(pid, 0); return true; } catch (e) {
-    // EPERM: the process exists but we may not open it (e.g. from inside a sandbox). Only ESRCH means gone.
-    const code = (e as NodeJS.ErrnoException).code;
-    if (code !== 'EPERM') log(`pid ${pid} judged dead: ${code}`);
-    return code === 'EPERM';
-  }
-}
-
-/** Append a line to chord.db.log next to the database, when CHORD_DB is known. Silent otherwise. */
-export function log(line: string): void {
-  if (!process.env.CHORD_DB) return;
-  try { fs.appendFileSync(process.env.CHORD_DB + '.log', `${new Date().toISOString()} [${process.env.CHORD_AGENT_ID ?? '-'}/${process.pid}] ${line}
-`); } catch { /* best effort */ }
-}
-
-/** The wrapper refreshes this every second; an agent whose heartbeat is this old is dead even if its pid is taken again. */
-export const HEARTBEAT_STALE_MS = 30_000;
-
-/** The wrapper is the one process that knows the agent is alive, so its heartbeat also revives an agent a sweep
- *  marked offline (a machine asleep for over 30 s looks dead to the first sweep after waking). Claims are gone by
- *  then; the agent claims again when it next writes. */
-export function heartbeat(db: DatabaseSync, name: string): void {
-  // revived as busy, the safe direction: a wake-up or a stop must not be typed into an agent that was in fact
-  // working all along; the next Stop, idle report or idle_prompt makes it idle again
-  db.prepare(`update agents set heartbeat_at = ?, status = case when status = 'offline' then 'busy' else status end where name = ?`).run(Date.now(), name);
-}
-
-/** Mark agents whose process is gone as offline and drop their claims. Returns the names swept. A missing
- *  process or a stale heartbeat both count: Windows reuses pids quickly, so the pid alone can lie. */
-export function sweep(db: DatabaseSync, alive: (pid: number) => boolean = pidAlive, now = Date.now()): string[] {
-  const online = listAgents(db).filter(a => a.status !== 'offline');
-  // Every heartbeat stale at once means the machine was asleep, not that everyone died: judge by pid alone then.
-  // ponytail: a lone dead agent whose pid was reused is therefore missed until a second agent comes online.
-  const beating = online.filter(a => a.heartbeat_at !== null);
-  const stale = (a: Agent) => a.heartbeat_at !== null && now - a.heartbeat_at > HEARTBEAT_STALE_MS;
-  const slept = beating.length > 0 && beating.every(stale);
-  if (slept) log('sweep: every heartbeat is stale, the machine was probably asleep; judging by pid only');
-  const dead = online.filter(a => !alive(a.pid) || (!slept && stale(a))).map(a => a.name);
-  for (const name of dead) {
-    log(`sweep: ${name} marked offline, claims released`);
-    setStatus(db, name, 'offline');
-    releaseAll(db, name, 'swept');
-  }
-  return dead;
-}
-
-// claims
-
-export function addClaim(db: DatabaseSync, c: { agent: string; file: string; intent: string; kind: string; symbols?: string | null }): void {
-  db.prepare(
-    `insert into claims (agent, file, intent, kind, symbols, created_at) values (?, ?, ?, ?, ?, ?)
-     on conflict(agent, file) do update set intent = excluded.intent, kind = excluded.kind, symbols = excluded.symbols`,
-  ).run(c.agent, c.file, c.intent, c.kind, c.symbols ?? null, Date.now());
-  addEvent(db, c.agent, 'claim', c.file, `${c.kind}: ${c.intent}`);
-}
-
-export function setAskedAt(db: DatabaseSync, agent: string, file: string, at: number): void {
-  db.prepare('update claims set asked_at = ? where agent = ? and file = ?').run(at, agent, file);
-}
-
-export function removeClaim(db: DatabaseSync, agent: string, file: string): void {
-  const gone = db.prepare('delete from claims where agent = ? and file = ?').run(agent, file).changes;
-  if (gone) addEvent(db, agent, 'release', file, 'released');
-}
-
-/** `why` is what the events log shows: released (by the agent), finish, swept, offline, exit. */
-export function releaseAll(db: DatabaseSync, agent: string, why = 'released'): void {
-  const files = (db.prepare('select file from claims where agent = ? order by file').all(agent) as { file: string }[]).map(r => r.file);
-  db.prepare('delete from claims where agent = ?').run(agent);
-  for (const f of files) addEvent(db, agent, 'release', f, why);
-}
-
-export type EventKind = 'claim' | 'release' | 'merge' | 'conflict' | 'merge-failed';
-export interface Event { id: number; at: number; agent: string; kind: EventKind; file: string | null; detail: string | null }
-
-/** Append-only history of claims, releases and merges, for `chord events`. */
-export function addEvent(db: DatabaseSync, agent: string, kind: EventKind, file: string | null, detail: string | null): void {
-  db.prepare('insert into events (at, agent, kind, file, detail) values (?, ?, ?, ?, ?)').run(Date.now(), agent, kind, file, detail);
-}
-
-/** The latest `limit` events (oldest first), for one agent or all. */
-export function listEvents(db: DatabaseSync, agent?: string, limit = 50): Event[] {
-  const rows = agent
-    ? db.prepare('select * from events where agent = ? order by id desc limit ?').all(agent, limit)
-    : db.prepare('select * from events order by id desc limit ?').all(limit);
-  return (rows as unknown as Event[]).reverse();
-}
-
-/** The latest `limit` messages (oldest first), all or those sent or received by one agent. */
-export function listMessages(db: DatabaseSync, agent?: string, limit = 50): Message[] {
-  const rows = agent
-    ? db.prepare('select * from messages where sender = ? or recipient = ? order by id desc limit ?').all(agent, agent, limit)
-    : db.prepare('select * from messages order by id desc limit ?').all(limit);
-  return (rows as unknown as Message[]).reverse();
-}
-
-/** `chord stop`: ask the wrapper to quit the tool once the agent is idle. Returns false for an unknown or offline agent. */
-export function requestStop(db: DatabaseSync, name: string): boolean {
-  return db.prepare(`update agents set stop_requested_at = ? where name = ? and status != 'offline'`).run(Date.now(), name).changes > 0;
-}
-
-export function claimsFor(db: DatabaseSync, file: string): Claim[] {
-  return db.prepare('select rowid as rid, * from claims where file = ?').all(file) as unknown as Claim[];
-}
-
-export function claimsBy(db: DatabaseSync, agent: string): Claim[] {
-  return db.prepare('select rowid as rid, * from claims where agent = ? order by file').all(agent) as unknown as Claim[];
-}
-
-export function allClaims(db: DatabaseSync): Claim[] {
-  return db.prepare('select rowid as rid, * from claims order by file, agent').all() as unknown as Claim[];
-}
-
-// messages
-
-export function send(db: DatabaseSync, sender: string, recipients: string[], body: string, kind: MessageKind = 'message'): void {
-  const now = Date.now();
-  const ins = db.prepare('insert into messages (sender, recipient, kind, body, created_at) values (?, ?, ?, ?, ?)');
-  for (const r of recipients) ins.run(sender, r, kind, body, now);
-}
-
-/** Roughly what a hook may attach without the tool truncating it (Codex caps additionalContext near 2500 tokens). */
-export const DELIVERY_BUDGET_CHARS = 6000;
-
-/** Unread messages for `recipient`, oldest first, marked read as they are returned. Stops after `budget`
- *  characters (always at least one message) so a flood is delivered in several rounds instead of truncated. */
-export function takeUnread(db: DatabaseSync, recipient: string, budget = DELIVERY_BUDGET_CHARS): Message[] {
-  // one transaction: parallel tool calls run several PostToolUse hooks at once, and each must get different messages
-  db.exec('begin immediate');
-  try {
-    const rows = db.prepare('select * from messages where recipient = ? and read_at is null order by id').all(recipient) as unknown as Message[];
-    const out: Message[] = [];
-    let used = 0;
-    for (const m of rows) { if (out.length && used + m.body.length > budget) break; out.push(m); used += m.body.length; }
-    if (out.length) {
-      db.prepare(`update messages set read_at = ? where recipient = ? and read_at is null and id <= ?`).run(Date.now(), recipient, out[out.length - 1].id);
-    }
-    db.exec('commit');
-    return out;
-  } catch (e) { db.exec('rollback'); throw e; }
-}
-
-/** Whether a message (not a notice) is waiting: only messages wake an idle agent; notices ride along with the next hook. */
-export function hasUnread(db: DatabaseSync, recipient: string): boolean {
-  return !!db.prepare(`select 1 from messages where recipient = ? and read_at is null and kind = 'message' limit 1`).get(recipient);
-}
-
-/** Has `sender` sent `recipient` a real message (not a notice) at or after `since`? */
-export function repliedSince(db: DatabaseSync, sender: string, recipient: string, since: number): boolean {
-  return firstMessageAt(db, sender, recipient, since) !== null;
-}
-
-/** When `sender` first messaged `recipient` at or after `since`; null if never. Notices do not count. */
-export function firstMessageAt(db: DatabaseSync, sender: string, recipient: string, since: number): number | null {
-  const row = db.prepare("select min(created_at) t from messages where sender = ? and recipient = ? and kind = 'message' and created_at >= ?").get(sender, recipient, since) as { t: number | null };
-  return row?.t ?? null;
-}