chord-cli 0.1.0 → 0.1.2

package/src/hooks.ts

@@ -1,287 +0,0 @@
-// Hook entry point for both Claude Code and Codex: `node hooks.ts <event>`, payload on stdin.
-// Event names are chord's own; launch.ts maps each tool's hook config onto them.
-import { execFileSync } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import * as db from './db.ts';
-import { patchFiles } from './patch.ts';
-import { canWrite, insideDir, normFile, type Ctx } from './tools.ts';
-
-export type Event = 'session-start' | 'user-prompt-submit' | 'pre-tool-use' | 'post-tool-use' | 'stop' | 'session-end' | 'notification';
-export type Tool = 'claude' | 'codex';
-
-/** What the hook prints: plain text (context) or a JSON object; `undefined` prints nothing. */
-export type HookOut = string | object | undefined;
-
-const EDIT_TOOLS = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit']);
-
-export function filesTouched(tool: Tool, payload: Record<string, any>): string[] {
-  const name = String(payload.tool_name ?? '');
-  const input = payload.tool_input ?? {};
-  if (tool === 'claude' && EDIT_TOOLS.has(name)) {
-    const p = input.file_path ?? input.notebook_path;
-    return typeof p === 'string' ? [p] : [];
-  }
-  if (tool === 'codex') {
-    // the patch has been seen under "command"; "input", "patch" and a bare string cost nothing to accept as well
-    const text = typeof input === 'string' ? input : [input.command, input.input, input.patch].find(v => typeof v === 'string');
-    if (name === 'apply_patch' && typeof text === 'string') return patchFiles(text);
-    if (isShell(name) && typeof text === 'string' && text.includes('*** Begin Patch')) return patchFiles(text); // apply_patch run from the shell
-  }
-  return [];
-}
-
-/** Tools that write files and must therefore name them: a call that names none is refused rather than let through. */
-export const isEditTool = (tool: Tool, name: unknown) => (tool === 'claude' ? EDIT_TOOLS.has(String(name)) : name === 'apply_patch');
-
-const isShell = (name: unknown) => /^(bash|powershell|shell|exec|exec_command|local_shell)$/i.test(String(name ?? ''));
-
-const hhmm = (t: number) => new Date(t).toTimeString().slice(0, 5); // local time
-
-export function formatMessages(ms: db.Message[]): string {
-  return ms.map(m => `[chord] message from ${m.sender} at ${hhmm(m.created_at)}:\n${m.body}`).join('\n\n');
-}
-
-const MAX_CLAIM_LINES = 60;
-const MAX_WARNED_FILES = 20;
-const MAX_INSTRUCTION_CHARS = 8000;
-
-/** The repository's own agent instructions. The agent's cwd is the workspace, so the tools do not load them themselves. */
-function projectInstructions(ctx: Ctx, repoDir: string): string[] {
-  const out: string[] = [];
-  for (const name of ['AGENTS.md', 'CLAUDE.md']) {
-    try {
-      const text = fs.readFileSync(path.join(ctx.worktree, name), 'utf8');
-      const body = text.length > MAX_INSTRUCTION_CHARS ? text.slice(0, MAX_INSTRUCTION_CHARS) + `\n[... truncated, read ${repoDir}/${name} for the rest]` : text;
-      out.push('', `Project instructions from ${repoDir}/${name}:`, body.trimEnd());
-    } catch { /* not present */ }
-  }
-  return out;
-}
-
-export function briefing(ctx: Ctx): string {
-  const me = db.getAgent(ctx.db, ctx.agent);
-  const peers = db.listAgents(ctx.db).filter(a => a.name !== ctx.agent && a.status !== 'offline');
-  const claims = db.allClaims(ctx.db);
-  const repoDir = path.relative(ctx.cwd, ctx.worktree).split(path.sep).join('/') || '.';
-  const lines = [
-    `You are agent "${ctx.agent}" (${me?.tool ?? 'unknown'}), one of several coding agents working on the same project. Your working directory is your own workspace; the repository is the directory "${repoDir}" inside it, a git worktree on your own branch. Run git commands inside "${repoDir}". Name files as paths from your working directory, e.g. "${repoDir}/src/x.ts" (claim() also accepts repository-relative paths like "src/x.ts"). Other agents have their own worktrees of the same repository; never edit files outside your workspace. Coordination goes through the "chord" MCP tools.`,
-    '',
-    'Rules:',
-    '1. First thing: call register(task, scope) to say what you are doing.',
-    '2. Before creating or changing any file, call claim(file, intent, kind). Writes to unclaimed files are refused.',
-    '3. If claim() lists agents under must_talk_to, read their intent and send() each of them a message saying what you will change. You may write once each has replied, or after 10 minutes. Do other work meanwhile; never wait idle.',
-    '4. Do not modify files through shell commands (sed, echo >, etc.). Use the editor tools so claims are checked.',
-    '5. To talk to other agents use only chord send()/inbox(); do not use any other agent-messaging feature. Messages are asynchronous.',
-    '6. To learn about the project, read the agent list and claims below and ask a specific agent with send(); do not ask the user.',
-    '7. When your change is complete and committed on your branch, call finish() to rebase onto main and fast-forward it. If finish() reports a conflict, stop and ask the user.',
-    '8. Never merge, rebase onto, push or otherwise update the main branch yourself, and never touch the main checkout: finish() is the only way changes reach main. This holds even if the project\'s own instructions say otherwise.',
-    '9. Do not use git stash: every worktree of this repository shares one stash list, so a stash pop can hand you another agent\'s changes. Make a work-in-progress commit instead.',
-    '',
-    peers.length ? 'Agents online:' : 'No other agents are online yet.',
-    ...peers.map(a => `- ${a.name} (${a.tool}, ${a.status}): ${a.task ?? 'not registered yet'}${a.scope ? ` [${a.scope}]` : ''}`),
-    '',
-    claims.length ? 'Current file claims:' : 'No files are claimed yet.',
-    ...claims.slice(0, MAX_CLAIM_LINES).map(c => `- ${c.file} <- ${c.agent}: ${c.kind}, ${c.intent}${c.symbols ? ` (${c.symbols})` : ''}`),
-    ...(claims.length > MAX_CLAIM_LINES ? [`- ... and ${claims.length - MAX_CLAIM_LINES} more (the claim tool reports holders of any file you claim)`] : []),
-    ...projectInstructions(ctx, repoDir),
-  ];
-  return lines.join('\n');
-}
-
-/** Context for the model. Plain stdout also works for Claude Code and `codex exec`, but the Codex TUI
- *  only takes the JSON form, so both events use it. */
-const context = (hookEventName: string, additionalContext: string) => ({ hookSpecificOutput: { hookEventName, additionalContext } });
-
-export function handleHook(ctx: Ctx, tool: Tool, event: Event, payload: Record<string, any>): HookOut {
-  db.sweep(ctx.db);
-  switch (event) {
-    case 'session-start':
-      // The agent now waits for its first prompt: idle, so messages that arrive before the user types still wake it.
-      // Claude Code also fires this after compacting a long conversation, in the middle of a turn: not idle then.
-      if (payload.source !== 'compact') db.setStatus(ctx.db, ctx.agent, 'idle');
-      return context('SessionStart', briefing(ctx));
-
-    case 'user-prompt-submit': {
-      db.setStatus(ctx.db, ctx.agent, 'busy');
-      const ms = db.takeUnread(ctx.db, ctx.agent);
-      // One line of identity on every prompt: a conversation that started without the briefing (Codex /new fires no
-      // session hooks; a resumed conversation may predate chord) still learns what it is and what the rules are.
-      const reminder = `[chord] You are agent "${ctx.agent}" in a chord project: claim a file with the chord claim tool before editing it, talk to the other agents with chord send, merge with chord finish.`;
-      return context('UserPromptSubmit', ms.length
-        ? `${formatMessages(ms)}\n\n[chord] ${ms.length} message(s) above arrived from other agents. Act on them in this turn as well as on the user's request: reply with the chord send tool where a reply is asked for.\n${reminder}`
-        : reminder);
-    }
-
-    case 'pre-tool-use': {
-      const files = filesTouched(tool, payload);
-      if (!files.length && isEditTool(tool, payload.tool_name)) {
-        return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: 'chord could not tell which file this call writes, so it is refused; use the editor tool with a plain file path' } };
-      }
-      // Codex resolves a patch's relative paths against the call's workdir when it gives one; otherwise the workspace
-      const workdir = tool === 'codex' && typeof payload.tool_input?.workdir === 'string' ? path.resolve(ctx.cwd, payload.tool_input.workdir) : ctx.cwd;
-      for (const f of files) {
-        const abs = path.resolve(workdir, f);
-        if (!insideDir(ctx.worktree, abs)) {
-          // the main checkout and the other agents' workspaces are off limits; anything else is not ours to police
-          if (ctx.project && insideDir(ctx.project, abs) && !insideDir(ctx.cwd, abs)) {
-            return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: `${f} is outside your workspace: edit files only inside your own worktree ${ctx.worktree}` } };
-          }
-          continue;
-        }
-        const check = canWrite(ctx, abs);
-        if (!check.ok) {
-          return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: check.reason } };
-        }
-      }
-      return undefined;
-    }
-
-    case 'post-tool-use': {
-      // Runs after every tool call. Any tool call means the agent is busy (another plugin's Stop hook may have
-      // blocked the end of the turn, or compaction may have run). Shell commands are checked for what they did
-      // behind chord's back, and messages that arrived mid-turn are handed over so a busy agent hears from its
-      // peers at the next tool call, not at turn end.
-      db.setStatus(ctx.db, ctx.agent, 'busy');
-      const parts: string[] = [];
-      if (isShell(payload.tool_name)) parts.push(...shellWarnings(ctx, payload));
-      const ms = db.takeUnread(ctx.db, ctx.agent);
-      if (ms.length) parts.push(`${formatMessages(ms)}\n\n[chord] ${ms.length} message(s) above arrived from other agents while you were working. Deal with them when convenient (reply with the chord send tool where a reply is asked for), then carry on with your task.`);
-      return parts.length ? { hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: parts.join('\n\n') } } : undefined;
-    }
-
-    case 'stop': {
-      const ms = db.takeUnread(ctx.db, ctx.agent);
-      if (ms.length) return { decision: 'block', reason: formatMessages(ms) + '\n\nHandle these messages before stopping.' };
-      db.setStatus(ctx.db, ctx.agent, 'idle');
-      return undefined;
-    }
-
-    case 'notification':
-      // Claude Code: "idle_prompt" fires about a minute after Claude stopped and nobody typed. It is the only
-      // signal after an Esc interrupt, which fires no Stop hook, so it is how a cut-off turn becomes idle.
-      if (payload.notification_type === 'idle_prompt') db.setStatus(ctx.db, ctx.agent, 'idle');
-      return undefined;
-
-    case 'session-end':
-      // A session ending is not the agent leaving: /clear, /resume and /compact end one and start another in the same
-      // process, and the reason strings differ between tools and versions. Going offline and releasing claims is the
-      // wrapper's job when the process exits (and the sweep's if it crashes); here the agent only becomes idle.
-      db.setStatus(ctx.db, ctx.agent, 'idle');
-      return undefined;
-  }
-}
-
-/** Paths changed according to `git status --porcelain=v1 -z -uall`: entries are NUL-separated, a rename
- *  or copy is followed by the original path, and nothing is quoted or folded into directories. */
-export function changedPaths(statusZ: string): string[] {
-  const parts = statusZ.split('\0');
-  const out: string[] = [];
-  for (let i = 0; i < parts.length; i++) {
-    const entry = parts[i];
-    if (!entry) continue;
-    out.push(entry.slice(3));
-    const xy = entry.slice(0, 2);
-    if (/R/.test(xy)) { i++; if (parts[i]) out.push(parts[i]); } // a rename changes its "from" path too
-    else if (/C/.test(xy)) i++; // a copy leaves its source alone
-  }
-  return out;
-}
-
-/** The old names of renames in NUL-separated status output: a rename changes that path too, and diff --name-only
- *  lists only the new one. */
-export function renameSources(statusZ: string): string[] {
-  const parts = statusZ.split('\0');
-  const out: string[] = [];
-  for (let i = 0; i < parts.length; i++) {
-    const entry = parts[i];
-    if (!entry) continue;
-    if (/R/.test(entry.slice(0, 2))) { i++; if (parts[i]) out.push(parts[i]); }
-    else if (/C/.test(entry.slice(0, 2))) i++;
-  }
-  return out;
-}
-
-/** git output, or '' when the command fails; optional locks off so this read-only look never fights the agent's own git. */
-const gitOut = (cwd: string, ...args: string[]): string => {
-  try { return execFileSync('git', ['--no-optional-locks', ...args], { cwd, encoding: 'utf8', env: db.gitEnv(), maxBuffer: 64 * 1024 * 1024 }); } catch { return ''; }
-};
-
-/** What a shell command may have done behind chord's back: edits or commits to unclaimed files, git stash, and
- *  changes to the main checkout. */
-export function shellWarnings(ctx: Ctx, payload: Record<string, any>): string[] {
-  const out: string[] = [];
-  const mine = new Set(db.claimsBy(ctx.db, ctx.agent).map(c => c.file.toLowerCase()));
-  // uncommitted changes (-unormal folds an untracked directory into one entry) plus whatever the branch has
-  // committed since it left main: a commit made from the shell is no more a claim than an edit is
-  // tracked files: real changes only, so a repository whose files differ in line endings from the moment they are
-  // checked out does not make every shell command cry wolf; untracked files from status, directories folded
-  const status = gitOut(ctx.worktree, 'status', '--porcelain=v1', '-z', '-unormal');
-  const untracked = status.split('\0').filter(e => e.startsWith('?? ')).map(e => e.slice(3));
-  const modified = ['', '--cached'].flatMap(c => gitOut(ctx.worktree, 'diff', ...(c ? [c] : []), '--name-only', '-z', '--ignore-cr-at-eol').split('\0'));
-  const root = db.mainRoot(ctx.worktree);
-  const main = root ? gitOut(root, 'rev-parse', '--abbrev-ref', 'HEAD').trim() : '';
-  const base = main && main !== 'HEAD' ? gitOut(ctx.worktree, 'merge-base', 'HEAD', main).trim() : '';
-  const committed = base ? gitOut(ctx.worktree, 'diff', '--name-only', '-z', base, 'HEAD').split('\0').filter(Boolean) : [];
-  const touched = [...new Set([...modified.filter(Boolean), ...untracked, ...renameSources(status), ...committed])];
-  const unclaimed = touched.map(f => normFile(ctx, path.join(ctx.worktree, f))).filter(f => !mine.has(f.toLowerCase()));
-  const shown = unclaimed.slice(0, MAX_WARNED_FILES);
-  if (unclaimed.length) out.push(`[chord] The shell command changed files you have not claimed: ${shown.join(', ')}${unclaimed.length > shown.length ? ` and ${unclaimed.length - shown.length} more` : ''}. Claim them now with claim(), or revert the change.`);
-  const cmd = typeof payload.tool_input?.command === 'string' ? payload.tool_input.command : '';
-  if (/\bgit\b[^|;&\n]*\bstash\b/.test(cmd)) out.push("[chord] git stash is shared by every worktree of this repository: a stash pop can hand you another agent's changes, and yours to them. Make a work-in-progress commit instead.");
-  if (root && path.resolve(root) !== path.resolve(ctx.worktree)) {
-    const dirty = gitOut(root, 'status', '--porcelain', '--untracked-files=no').split('\n').filter(Boolean).map(l => l.slice(3));
-    if (dirty.length) out.push(`[chord] The main checkout (${root}) has uncommitted changes, which blocks everyone's finish(): ${dirty.slice(0, 10).join(', ')}. If your command did this, undo it there; the main branch is only ever changed through finish().`);
-  }
-  return out;
-}
-
-/** handleHook, but never lets an exception reach the tool: a broken hook must not fail open on a write. */
-export function safeHandle(ctx: Ctx, tool: Tool, event: Event, payload: Record<string, any>): HookOut {
-  try {
-    return handleHook(ctx, tool, event, payload);
-  } catch (e) {
-    const msg = (e as Error).message;
-    db.log(`hook ${event} failed: ${msg}`);
-    if (event === 'pre-tool-use' && filesTouched(tool, payload).length) {
-      return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: `chord could not check this write (${msg}); try again or report it to the user` } };
-    }
-    return undefined;
-  }
-}
-
-async function main(): Promise<void> {
-  const started = Date.now();
-  const event = process.argv[2] as Event;
-  const agent = process.env.CHORD_AGENT_ID;
-  const file = process.env.CHORD_DB;
-  const tool = process.env.CHORD_TOOL as Tool;
-  if (!agent || !file || !tool) { process.stderr.write('chord hook: CHORD_AGENT_ID, CHORD_DB and CHORD_TOOL must be set\n'); process.exit(0); }
-  const chunks: Buffer[] = [];
-  for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
-  const raw = Buffer.concat(chunks).toString('utf8'); // decode once: a multi-byte character may straddle chunks
-  let payload: Record<string, any> = {};
-  try { payload = JSON.parse(raw); } catch { /* no payload */ }
-  // the workspace is fixed per agent; the tool's own cwd moves when the agent runs `cd`, so it is not used as the base
-  const cwd = process.env.CHORD_WORKSPACE ?? (typeof payload.cwd === 'string' ? payload.cwd : process.cwd());
-  let ctx: Ctx;
-  try {
-    ctx = { db: db.openDb(file), agent, cwd, worktree: process.env.CHORD_WORKTREE ?? cwd, project: process.env.CHORD_PROJECT };
-  } catch (e) {
-    // the database would not open: a write must still not go through unchecked
-    const msg = (e as Error).message;
-    process.stderr.write(`chord hook: cannot open ${file}: ${msg}\n`);
-    if (event === 'pre-tool-use' && filesTouched(tool, payload).length) {
-      process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: `chord could not check this write (${msg}); try again or report it to the user` } }));
-    }
-    return;
-  }
-  if (process.env.CHORD_DEBUG_HOOKS) db.log(`hook payload ${event}: keys=${Object.keys(payload).join(',')} agent_id=${payload.agent_id ?? '-'} agent_type=${payload.agent_type ?? '-'} source=${payload.source ?? '-'} reason=${payload.reason ?? '-'}`);
-  const out = safeHandle(ctx, tool, event, payload);
-  db.log(`hook ${event} (${tool}, tool_name=${payload.tool_name ?? '-'}): ${out === undefined ? 'no output' : `${typeof out === 'string' ? 'text' : 'json'} ${JSON.stringify(out).length} chars`} in ${Date.now() - started}ms`);
-  if (out !== undefined) process.stdout.write(typeof out === 'string' ? out : JSON.stringify(out));
-}
-
-const isMain = (() => { try { return fs.realpathSync.native(process.argv[1] ?? '') === fs.realpathSync.native(fileURLToPath(new URL(import.meta.url))); } catch { return false; } })();
-if (isMain) main();

package/src/launch.ts

@@ -1,356 +0,0 @@
-// Everything `chord <tool>` needs before spawning: the project, an agent name, the agent's
-// workspace with its repository worktree, and the per-launch hook/MCP configuration for each
-// tool. Hook command strings must stay identical across launches (Codex persists trust by
-// hashing them), so per-session values go in env.
-import { execFileSync, execSync } from 'node:child_process';
-import { randomBytes } from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import type { DatabaseSync } from 'node:sqlite';
-import * as db from './db.ts';
-import { ensureStateDir, resolveProject, type Project } from './project.ts';
-import { claudeMcpChoices, claudeTrusts } from './trust.ts';
-import type { Event, Tool } from './hooks.ts';
-
-const git = (cwd: string, ...args: string[]) => execFileSync('git', args, { cwd, encoding: 'utf8', env: db.gitEnv(), stdio: ['ignore', 'pipe', 'pipe'] }).trim();
-
-// realpath gives one canonical spelling (drive letter and directory case): Codex persists hook trust by hashing the command string
-const here = (f: string) => fs.realpathSync.native(fileURLToPath(new URL(f, import.meta.url))).split(path.sep).join('/');
-export const HOOKS_TS = here('./hooks.ts');
-export const SERVE_TS = here('./serve.ts');
-
-const sleepSync = (ms: number) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-
-/** `staleWaitMs`: how long to watch a stale heartbeat before calling its agent dead (tests shorten it). */
-export function pickName(d: DatabaseSync, tool: Tool, project: string, override?: string, staleWaitMs = 2500): string {
-  if (override) {
-    if (!/^[A-Za-z0-9._-]+$/.test(override)) throw new Error('agent names may only contain letters, digits, ".", "_" and "-"');
-    // the name becomes a directory and a branch: ".." would escape agents/, git refuses components starting with "."
-    // or ending in "." or ".lock", and Windows reserves CON, NUL, COM1 and friends
-    if (/^[.-]|\.$|\.\.|\.lock$/i.test(override) || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\..*)?$/i.test(override)) throw new Error(`"${override}" cannot be an agent name: no leading "." or "-", no trailing "." or ".lock", no "..", and no Windows reserved names (CON, NUL, COM1...)`);
-    // workspace paths are case-insensitive on Windows and macOS, so names differing only in case would share one
-    const clash = db.listAgents(d).find(a => a.name.toLowerCase() === override.toLowerCase());
-    if (clash && clash.name !== override) throw new Error(`agent "${clash.name}" already exists; names must differ in more than case`);
-    if (clash && clash.status !== 'offline') {
-      // A lone agent killed outright, whose pid Windows has since handed to another process, is never swept: nobody
-      // else's heartbeat is fresh to compare with. A heartbeat that stays stale while we watch it is a dead wrapper
-      // (a live one writes every second), and this launch itself proves the machine is awake.
-      const stale = clash.heartbeat_at !== null && Date.now() - clash.heartbeat_at > db.HEARTBEAT_STALE_MS;
-      if (stale) sleepSync(staleWaitMs);
-      const again = stale ? db.getAgent(d, clash.name) : clash;
-      if (!stale || again?.heartbeat_at !== clash.heartbeat_at) throw new Error(`agent "${override}" is already online`);
-      db.log(`launch: ${override} has not had a heartbeat for ${Math.round((Date.now() - clash.heartbeat_at!) / 1000)}s; taking it for dead`);
-      db.setStatus(d, clash.name, 'offline');
-      db.releaseAll(d, clash.name, 'swept');
-    }
-    return override;
-  }
-  // the project name makes the agent recognisable in `chord ls --all`; kept short so the worktree path stays short
-  const base = path.basename(project).toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 12).replace(/^-+|-+$/g, '') || 'project';
-  for (;;) {
-    const name = `${tool}-${base}-${randomBytes(2).toString('hex')}`;
-    if (!db.getAgent(d, name)) return name;
-  }
-}
-
-/** The agent's workspace: <project>/chord/agents/<name>. Its repository worktree sits inside at <repoName>. */
-export const workspacePath = (p: Project, name: string) => path.join(p.dir, 'chord', 'agents', name);
-
-/** Create (or reuse) a worktree of `repo` at `wt` on branch chord/<name>, forked from the current main HEAD. */
-export function ensureWorktree(repo: string, wt: string, name: string): string {
-  const branch = `chord/${name}`;
-  if (fs.existsSync(path.join(wt, '.git'))) {
-    try { git(wt, 'rev-parse', '--git-dir'); } catch { // the link is broken, e.g. the project was moved
-      git(repo, 'worktree', 'repair', wt);
-      git(wt, 'rev-parse', '--git-dir');
-    }
-    return onBranch(wt, branch);
-  }
-  if (fs.existsSync(wt) && fs.readdirSync(wt).length) throw new Error(`${wt} exists but is not a git worktree; remove it or pick another --name`);
-  fs.mkdirSync(path.dirname(wt), { recursive: true });
-  // Every worktree directory is named after the repository, so git gives them ids repo, repo1, repo2... After the
-  // project moves, the registrations point at the old place: pruning first would drop them all and let this new
-  // worktree take the id "repo" that belonged to another agent, which a later repair of that agent would then share.
-  // Repair the siblings first; prune only removes what the user really deleted.
-  const siblings = siblingWorktrees(wt);
-  if (siblings.length) { try { git(repo, 'worktree', 'repair', ...siblings); } catch { /* a sibling beyond repair is pruned below */ } }
-  git(repo, 'worktree', 'prune');
-  const exists = git(repo, 'branch', '--list', branch) !== '';
-  try {
-    // core.longpaths: a worktree path is some forty characters longer than the main checkout's, which on Windows is
-    // enough to push a deep repository past MAX_PATH
-    if (exists) git(repo, '-c', 'core.longpaths=true', 'worktree', 'add', wt, branch);
-    else git(repo, '-c', 'core.longpaths=true', 'worktree', 'add', '-b', branch, wt);
-  } catch (e) {
-    // nothing half-made stays behind: a stale branch or an empty directory would trip the next launch
-    try { git(repo, 'worktree', 'prune'); } catch { /* best effort */ }
-    if (!exists) { try { git(repo, 'branch', '-D', branch); } catch { /* never created */ } }
-    try { fs.rmSync(wt, { recursive: true, force: true }); } catch { /* best effort */ }
-    const msg = ((e as { stderr?: string }).stderr ?? (e as Error).message).trim();
-    if (/too long/i.test(msg)) throw new Error(`${msg}\n${wt} is too long a path for git here; run "git config --global core.longpaths true", or move the project to a shorter path`);
-    throw new Error(`could not create the worktree ${wt}: ${msg}`);
-  }
-  return onBranch(wt, branch);
-}
-
-/** The other agents' worktrees beside `wt` (chord/agents/<other>/<repoName>) that still exist on disk. */
-function siblingWorktrees(wt: string): string[] {
-  const agents = path.dirname(path.dirname(wt));
-  try {
-    return fs.readdirSync(agents)
-      .map(n => path.join(agents, n, path.basename(wt)))
-      .filter(p => p !== wt && fs.existsSync(path.join(p, '.git')));
-  } catch { return []; }
-}
-
-/** A worktree that is not on its own branch is sharing a registration with another agent: refuse rather than let two
- *  agents work on one index. */
-function onBranch(wt: string, branch: string): string {
-  const head = git(wt, 'rev-parse', '--abbrev-ref', 'HEAD');
-  if (head !== branch) throw new Error(`${wt} is on ${head} instead of ${branch}; its git registration seems to be shared with another agent. Remove the directory and launch again`);
-  return wt;
-}
-
-// ctxLimit: Codex caps a hook's additionalContext (default about 2,500 tokens); the briefing and message batches need more
-const EVENTS: { event: Event; claude: string; codex?: string; matcher?: { claude: string; codex?: string }; timeout?: number; ctxLimit?: number }[] = [
-  { event: 'session-start', claude: 'SessionStart', codex: 'SessionStart', ctxLimit: 16000 },
-  { event: 'notification', claude: 'Notification', matcher: { claude: 'idle_prompt' } }, // Claude only: Codex reports idle through OSC 7501
-  { event: 'user-prompt-submit', claude: 'UserPromptSubmit', codex: 'UserPromptSubmit', ctxLimit: 16000 },
-  { event: 'pre-tool-use', claude: 'PreToolUse', codex: 'PreToolUse', matcher: { claude: 'Edit|Write|MultiEdit|NotebookEdit' } }, // Codex: every tool, so apply_patch run from the shell is seen too
-  { event: 'post-tool-use', claude: 'PostToolUse', codex: 'PostToolUse', ctxLimit: 16000 }, // every tool: shell-edit warnings and mid-turn message delivery
-  { event: 'stop', claude: 'Stop', codex: 'Stop' },
-  { event: 'session-end', claude: 'SessionEnd', codex: 'SessionEnd', timeout: 10 },
-];
-
-/** The node that runs chord, by absolute path, for the MCP server (spawned from an argument list, so spaces in the
- *  path are no problem). The hook commands say plain `node`: Codex cannot run a command whose executable is quoted
- *  ("C:/Program Files/nodejs/node.exe" fails silently, a quoted argument is fine), so instead the wrapper puts this
- *  node's directory at the front of the agent's PATH (see withNodeOnPath), which also keeps an older node on the
- *  user's PATH (nvm, a project .nvmrc) from being the one that cannot run .ts files. */
-export const NODE = fs.realpathSync.native(process.execPath).split(path.sep).join('/');
-export const hookCommand = (event: Event) => `node "${HOOKS_TS}" ${event}`;
-
-/** The environment with the directory of the node running chord first on PATH (whatever the variable's case). */
-export function withNodeOnPath(env: Record<string, string>): Record<string, string> {
-  const key = Object.keys(env).find(k => k.toUpperCase() === 'PATH') ?? 'PATH';
-  const dir = path.dirname(fs.realpathSync.native(process.execPath));
-  const current = env[key] ?? '';
-  if (current.split(path.delimiter)[0] === dir) return env;
-  return { ...env, [key]: current ? `${dir}${path.delimiter}${current}` : dir };
-}
-
-/** CLI arguments that inject chord's hooks and MCP server into Claude Code. */
-/** `projectConfig`: also load the repository's own .claude settings and .mcp.json. Only when the user has trusted the
- *  repository in Claude Code, because Claude's trust dialogue is what normally stands between a cloned repository's
- *  hooks and MCP servers and running them. */
-export interface ProjectConfigSource { repo: string; claudeConfig?: string }
-
-/** `$CLAUDE_PROJECT_DIR` in a repository's hook commands and MCP definitions means the repository, which for an agent
- *  is its worktree; Claude would point it at the workspace. */
-export function substituteProjectDir<T>(value: T, worktree: string): T {
-  const dir = worktree.split(path.sep).join('/');
-  const walk = (v: unknown): unknown => {
-    if (typeof v === 'string') return v.replace(/\$\{CLAUDE_PROJECT_DIR\}|\$CLAUDE_PROJECT_DIR/g, dir);
-    if (Array.isArray(v)) return v.map(walk);
-    if (v && typeof v === 'object') return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, walk(x)]));
-    return v;
-  };
-  return walk(value) as T;
-}
-
-/** The repository's .mcp.json as an --mcp-config value, reduced to the servers the user approved in Claude Code, or
- *  null when there is nothing to pass. */
-export function projectMcpConfig(worktree: string, source: ProjectConfigSource): string | null {
-  const file = path.join(worktree, '.mcp.json');
-  if (!fs.existsSync(file)) return null;
-  let parsed: { mcpServers?: Record<string, unknown> };
-  try { parsed = JSON.parse(fs.readFileSync(file, 'utf8')); } catch (e) { process.stderr.write(`chord: ${file} is not valid JSON (${(e as Error).message}); its servers are not loaded\n`); return null; }
-  const servers = parsed?.mcpServers ?? {};
-  const choice = claudeMcpChoices(source.repo, source.claudeConfig);
-  const keep = Object.fromEntries(Object.entries(servers).filter(([name]) => !choice.disabled.includes(name) && (choice.all || choice.enabled.includes(name))));
-  const skipped = Object.keys(servers).filter(n => !(n in keep));
-  if (skipped.length) process.stderr.write(`chord: not starting the repository's MCP server(s) ${skipped.join(', ')}: run claude in ${source.repo} once and approve them there first\n`);
-  return Object.keys(keep).length ? JSON.stringify({ mcpServers: substituteProjectDir(keep, worktree) }) : null;
-}
-
-export function claudeArgs(env: Record<string, string>, projectConfig: boolean | ProjectConfigSource = false): string[] {
-  const hooks: Record<string, unknown[]> = {};
-  for (const e of EVENTS) {
-    hooks[e.claude] = [{
-      ...(e.matcher ? { matcher: e.matcher.claude } : {}),
-      hooks: [{ type: 'command', command: hookCommand(e.event), ...(e.timeout ? { timeout: e.timeout } : {}) }],
-    }];
-  }
-  const mcp = { mcpServers: { chord: { command: NODE, args: [SERVE_TS], env } } };
-  // chord's own tools are pre-approved: in the default permission mode every claim, send and finish would otherwise
-  // stop at a prompt, and an unattended agent would never get past the first one
-  const ours = { hooks, permissions: { allow: ['mcp__chord'] } };
-  // The agent's cwd is its workspace, not the repository, so Claude Code would not pick up the repository's
-  // own CLAUDE.md, .claude/settings*.json or .mcp.json. --add-dir covers CLAUDE.md; the others are passed along.
-  const wt = env.CHORD_WORKTREE;
-  const addDir = wt ? ['--add-dir', wt] : [];
-  const source: ProjectConfigSource | null = projectConfig === true ? { repo: wt ?? '' } : projectConfig || null;
-  const projectMcp = source && wt ? projectMcpConfig(wt, source) : null;
-  const mcpFiles = projectMcp ? [projectMcp] : [];
-  const settings = source ? mergeProjectSettings(ours, wt) : ours;
-  // --add-dir and --mcp-config take any number of values, so they must not come last: the user's own arguments
-  // follow these, and a prompt such as `chord claude "fix the tests"` would be read as another directory.
-  // --settings takes exactly one value and closes the list.
-  return [...addDir, '--mcp-config', JSON.stringify(mcp), ...mcpFiles, '--settings', JSON.stringify(settings)];
-}
-
-/** The user's own --settings folded under chord's (chord's hooks stay, theirs are added), in place in `args`. */
-export function mergeUserSettings(args: string[], user: Record<string, any>): string[] {
-  const i = args.indexOf('--settings');
-  if (i < 0 || i + 1 >= args.length) return args;
-  const out = [...args];
-  out[i + 1] = JSON.stringify(mergeSettings(JSON.parse(args[i + 1]), user));
-  return out;
-}
-
-const PROJECT_CONFIG_FILES = ['.claude/settings.json', '.claude/settings.local.json', '.mcp.json'];
-export const hasProjectConfig = (worktree: string) => PROJECT_CONFIG_FILES.some(f => fs.existsSync(path.join(worktree, f)));
-
-/** chord's settings plus the repository's .claude/settings.json and settings.local.json (later files win,
- *  hook lists are concatenated so both chord's and the project's hooks run). */
-/** Hook lists of `b` appended to those of `a`, so both sets run. */
-function concatHooks(a: Record<string, any>, b: Record<string, any>): Record<string, unknown[]> {
-  const hooks: Record<string, unknown[]> = { ...(a.hooks ?? {}) };
-  for (const [event, list] of Object.entries(b.hooks ?? {})) hooks[event] = [...(hooks[event] ?? []), ...(Array.isArray(list) ? list : [])];
-  return hooks;
-}
-
-/** Somebody else's settings underneath chord's: their keys fill in, chord's keys win, hook lists are concatenated,
- *  and disableAllHooks is dropped because it would switch chord itself off. */
-export function mergeSettings(ours: Record<string, any>, theirs: Record<string, any>): Record<string, any> {
-  const out: Record<string, any> = { ...theirs, ...ours, hooks: concatHooks(ours, theirs) };
-  if (ours.permissions || theirs.permissions) {
-    // permission lists add up, as across Claude's own settings levels; other permission keys follow the usual precedence
-    const lists = (k: 'allow' | 'deny' | 'ask') => [...new Set([...(ours.permissions?.[k] ?? []), ...(theirs.permissions?.[k] ?? [])])];
-    out.permissions = { ...theirs.permissions, ...ours.permissions };
-    for (const k of ['allow', 'deny', 'ask'] as const) if (lists(k).length) out.permissions[k] = lists(k);
-  }
-  delete out.disableAllHooks;
-  return out;
-}
-
-export function mergeProjectSettings(ours: Record<string, any>, worktree?: string): Record<string, any> {
-  if (!worktree) return ours;
-  let theirs: Record<string, any> = {};
-  for (const name of ['settings.json', 'settings.local.json']) { // settings.local.json wins, as in Claude Code itself
-    let one: Record<string, any>;
-    try { one = JSON.parse(fs.readFileSync(path.join(worktree, '.claude', name), 'utf8')); } catch { continue; }
-    if (typeof one !== 'object' || one === null) continue;
-    one = substituteProjectDir(one, worktree);
-    theirs = { ...theirs, ...one, hooks: concatHooks(theirs, one) };
-  }
-  return mergeSettings(ours, theirs);
-}
-
-/** A JSON string literal is also a valid TOML basic string, quotes, backslashes and non-ASCII included. */
-const toml = (s: string) => JSON.stringify(s);
-
-/** CLI arguments that inject chord's hooks and MCP server into Codex. Values are TOML. */
-/** `writableRoots`: directories Codex's workspace-write sandbox must also be allowed to write. A linked worktree keeps
- *  its index and refs under the main checkout's .git, outside the agent's workspace, so without this every git commit
- *  fails inside the sandbox. */
-export function codexArgs(env: Record<string, string>, writableRoots: string[] = []): string[] {
-  const args: string[] = [];
-  if (writableRoots.length) args.push('-c', `sandbox_workspace_write.writable_roots=[${writableRoots.map(toml).join(',')}]`);
-  for (const e of EVENTS) {
-    if (!e.codex) continue;
-    const matcher = e.matcher?.codex ? `matcher=${toml(e.matcher.codex)},` : '';
-    const limit = e.ctxLimit ? `,additionalContextLimit=${e.ctxLimit}` : '';
-    args.push('-c', `hooks.${e.codex}=[{${matcher}hooks=[{type="command",command=${toml(hookCommand(e.event))}${limit}}]}]`);
-  }
-  const envToml = Object.entries(env).map(([k, v]) => `${k}=${toml(v)}`).join(',');
-  // finish may wait minutes for the merge lock; Codex's default tool timeout is 60s
-  args.push('-c', `mcp_servers.chord={command=${toml(NODE)},args=[${toml(SERVE_TS)}],env={${envToml}},tool_timeout_sec=600}`);
-  return args;
-}
-
-export interface Launch {
-  name: string;
-  project: Project;
-  cwd: string;      // the agent's workspace W
-  worktree: string; // W/<repoName>, the repository worktree
-  dbFile: string;
-  env: Record<string, string>;
-  args: string[];
-}
-
-const fwd = (p: string) => p.split(path.sep).join('/');
-
-/** Resolve everything for `chord <tool> [--name x] [tool args...]` without spawning. Throws NeedsRestructure. */
-export function prepare(tool: Tool, cwd: string, override?: string): Launch {
-  const project = resolveProject(cwd);
-  try { git(project.repo, 'rev-parse', '--verify', '-q', 'HEAD'); } catch { throw new Error(`${project.repo} has no commits yet; make an initial commit first`); }
-  ensureStateDir(project);
-  const dbFile = db.dbPath(project.stateDir);
-  const d = db.openDb(dbFile);
-  db.sweep(d);
-  const name = pickName(d, tool, project.dir, override);
-  const ws = workspacePath(project, name);
-  // Take the name now, before the worktree and setup take their time: a second launch under the same name a moment
-  // later must find it online. The wrapper re-registers with the tool's own pid when it starts.
-  db.addAgent(d, { name, tool, pid: process.pid, cwd: ws, worktree: path.join(ws, project.repoName), heartbeat: true });
-  try {
-    const config = readConfig(project);
-    const worktree = ensureWorktree(project.repo, path.join(ws, project.repoName), name);
-    const env = { CHORD_AGENT_ID: name, CHORD_DB: fwd(dbFile), CHORD_TOOL: tool, CHORD_PROJECT: fwd(project.dir), CHORD_WORKSPACE: fwd(ws), CHORD_WORKTREE: fwd(worktree) };
-    // Setup is owed until it has finished once: a marker, not the worktree's existence, says so, because a setup
-    // interrupted half-way leaves the worktree behind and a relaunch must not take a half-prepared checkout for ready.
-    const marker = setupMarker(project, name);
-    if (config.setup && !fs.existsSync(marker)) {
-      runSetup(project, name, worktree, config.setup, env);
-      fs.mkdirSync(path.dirname(marker), { recursive: true });
-      fs.writeFileSync(marker, `${Date.now()}\n`);
-    }
-    let projectConfig: boolean | ProjectConfigSource = false;
-    if (tool === 'claude' && hasProjectConfig(worktree)) {
-      projectConfig = claudeTrusts(project.repo) || claudeTrusts(project.dir) ? { repo: project.repo } : false;
-      if (!projectConfig) process.stderr.write(`chord: ${project.repo} has its own .claude settings or .mcp.json, but you have not trusted it in Claude Code, so they are not loaded for this agent. Run claude in ${project.repo} once and accept the trust prompt to change that.\n`);
-    }
-    return { name, project, cwd: ws, worktree, dbFile, env, args: tool === 'claude' ? claudeArgs(env, projectConfig) : codexArgs(env, [path.join(project.repo, '.git')]) };
-  } catch (e) {
-    db.setStatus(d, name, 'offline'); // the launch failed: the name is free again
-    throw e;
-  }
-}
-
-/** <project>/chord/config.json. `setup` is a shell command run in every new worktree before the agent starts,
- *  for example "npm install". */
-export function readConfig(project: Project): { setup?: string } {
-  const file = path.join(project.dir, 'chord', 'config.json');
-  let raw: string;
-  try { raw = fs.readFileSync(file, 'utf8'); } catch { return {}; }
-  let cfg: unknown;
-  try { cfg = JSON.parse(raw); } catch (e) { throw new Error(`${file} is not valid JSON: ${(e as Error).message}`); }
-  if (typeof cfg !== 'object' || cfg === null) throw new Error(`${file} must hold a JSON object`);
-  const setup = (cfg as { setup?: unknown }).setup;
-  if (setup !== undefined && typeof setup !== 'string') throw new Error(`${file}: "setup" must be a string (a shell command)`);
-  return setup ? { setup } : {};
-}
-
-/** Where `chord clean` and a relaunch look to see whether the setup command has run for this agent. */
-export const setupMarker = (project: Project, name: string) => path.join(project.stateDir, 'setup-done', name);
-
-/** A failed setup aborts the launch, and the half-prepared worktree and branch go with it so the next launch starts clean. */
-function runSetup(project: Project, name: string, worktree: string, setup: string, env: Record<string, string>): void {
-  process.stderr.write(`chord: running setup in ${worktree}: ${setup}\n`);
-  // Ctrl+C goes to the setup command, which then fails and is cleaned up below; without a listener it would kill chord
-  // itself first and leave the worktree and branch behind
-  const ignoreSigint = () => {};
-  process.on('SIGINT', ignoreSigint);
-  try {
-    execSync(setup, { cwd: worktree, stdio: 'inherit', env: { ...process.env, ...env } });
-  } catch (e) {
-    try { git(project.repo, 'worktree', 'remove', '--force', worktree); } catch { /* best effort */ }
-    try { git(project.repo, 'branch', '-D', `chord/${name}`); } catch { /* best effort */ }
-    const status = (e as { status?: number | null }).status;
-    throw new Error(`setup command failed${status != null ? ` with exit code ${status}` : ''}: ${setup}\nthe worktree was removed; fix the command in ${path.join(project.dir, 'chord', 'config.json')} or the repository and launch again`);
-  } finally {
-    process.off('SIGINT', ignoreSigint);
-  }
-}