chord-cli 0.1.3 → 0.2.1

package/dist/pty.js

@@ -1,6 +1,7 @@
 // Run the agent under a pseudo-terminal: pass the user's keyboard through, and when the
 // agent is idle with unread messages, type a nudge in as if the user had.
 import fs from 'node:fs';
+import { createRequire } from 'node:module';
 import path from 'node:path';
 import { StringDecoder } from 'node:string_decoder';
 import pty from 'node-pty';
@@ -32,6 +33,27 @@ export function resolveCommand(tool, readFile = (f) => fs.readFileSync(f, 'utf8'
         throw new Error(`cannot read the script path from ${hit}`);
     return { file: process.execPath, args: [path.join(path.dirname(hit), m[1])] };
 }
+/** On macOS node-pty starts the tool through its `spawn-helper` binary, which the prebuilt package ships without the
+ *  execute bit (and npm no longer runs install scripts that might set it), so every launch would fail with
+ *  "posix_spawnp failed". The bit is set here, or the error says how when the install directory is not writable. */
+export function ensureSpawnHelper(root = path.dirname(createRequire(import.meta.url).resolve('node-pty/package.json'))) {
+    for (const dir of ['build/Release', 'build/Debug', `prebuilds/${process.platform}-${process.arch}`]) { // where node-pty looks
+        const helper = path.join(root, dir, 'spawn-helper');
+        if (!fs.existsSync(helper))
+            continue;
+        try {
+            fs.accessSync(helper, fs.constants.X_OK);
+            continue;
+        }
+        catch { /* not executable */ }
+        try {
+            fs.chmodSync(helper, 0o755);
+        }
+        catch (e) {
+            throw new Error(`${helper} is not executable, so no agent can start (${e.message}); run: chmod +x "${helper}"`);
+        }
+    }
+}
 const ESC_KEY = ''; // a decoded Esc key, kept apart from escape sequences while they are stripped
 const SOFT_NL = ''; // Shift+Enter: a newline inside the draft, not a submit
 /**
@@ -142,6 +164,15 @@ export function typedEchoed(output, text) {
     const squash = (s) => stripAnsi(s).replace(/\s+/g, '');
     return squash(output).includes(squash(text).slice(0, 25));
 }
+/** The Esc key as the tool reads it: in win32-input-mode (ConPTY turns a bare ESC byte into nothing, waiting for a
+ *  sequence) a key-down and key-up record; elsewhere the CSI u form the tools ask for (`ESC [ > 5 u`), which a legacy
+ *  reader ignores harmlessly. Verified against Claude Code on macOS; on Linux not yet. */
+const ESC_INPUT = process.platform === 'win32' ? '\x1b[27;1;27;1;0;1_\x1b[27;1;27;0;0;1_' : '\x1b[27u';
+/** Did the tool answer the exit command with its "background work is running, exit and stop it or stay?" dialogue?
+ *  Claude Code asks this while a shell the agent started (a monitor it is waiting on, say) still runs. */
+export function exitDeclined(output) {
+    return /Backgroundworkisrunning|willstopwhenyouexit/i.test(stripAnsi(output).replace(/\s+/g, ''));
+}
 /** The terminal title is chord's: "chord <agent> · <task>", so a window or tab can be matched to a `chord ls` row.
  *  The tools set their own titles (Claude Code its session summary, Codex the folder name), so their title
  *  sequences (OSC 0, 1, 2) are removed from the forwarded output; everything else, including Codex's OSC 7501
@@ -169,9 +200,14 @@ export const titleSequence = (title) => `\x1b]0;${title.replace(/[\x00-\x1f\x7f]
  *  stop`), press Enter once more, or nothing. Messages stay in the inbox until a hook takes them, so a lost
  *  keystroke is retried, never dropped. `typed`/`typedAt` say what was last typed and when; `echoed` whether the TUI
  *  showed it; `enters` how many times Enter was pressed for it and `enteredAt` when last. Enter is pressed at most
- *  twice per typed text, never when the text was not echoed, and nothing new is typed while the last text is fresh. */
+ *  twice per nudge, never when the text was not echoed, and nothing new is typed while the last text is fresh.
+ *  `quietFor`: milliseconds since the tool last wrote to the terminal. A Stop hook does not mean the turn is over: a
+ *  goal (/goal) or another plugin's Stop hook keeps the tool working after it, with the spinner still redrawing, so
+ *  nothing is typed until the screen has been still for a few seconds.
+ *  The exit command gets no second Enter: the first one quits the tool, and anything that then appears is a dialogue
+ *  (Claude Code asks about background tasks it would stop), where Enter would pick the default for the user. */
 export function nextAction(s, now) {
-    if (s.status !== 'idle' || !s.gateClear)
+    if (s.status !== 'idle' || !s.gateClear || s.quietFor < 3000)
         return null;
     const want = s.stop ? 'stop' : s.unread ? 'nudge' : null;
     if (!want)
@@ -180,20 +216,24 @@ export function nextAction(s, now) {
         return want; // first try, or the typed text was lost or swallowed
     if (s.typed !== want)
         return null; // something else is still in the input box; wait for it to go through or expire
-    if (!s.echoed || s.enters !== 1)
+    if (s.typed === 'stop' || !s.echoed || s.enters !== 1)
         return null; // swallowed: hands off; never pressed: the user got there first; pressed twice: enough
     if (now - s.enteredAt > 5_000)
         return 'enter'; // typed and echoed but not submitted: press Enter once more
     return null;
 }
-/** Codex reports its state to the terminal as OSC 7501 ("state=idle" / "state=working"); Claude Code does not. */
+/** Codex reports its state to the terminal as OSC 7501 ("state=idle" / "state=working", and "state=done" when a turn
+ *  ends, as of 0.164); Claude Code does not. */
 export function oscState(chunk) {
-    const m = /\x1b\]7501;state=(\w+)/g;
+    const m = /\x1b\]7501;state=(\w+)[^\x07\x1b]*(?:\x07|\x1b\\)/g; // complete reports only: "state=id" cut off by a chunk is not "busy"
     let last = null;
     for (const x of chunk.matchAll(m))
-        last = x[1] === 'idle' ? 'idle' : 'busy';
+        last = x[1] === 'idle' || x[1] === 'done' ? 'idle' : 'busy';
     return last;
 }
+/** An OSC sequence a chunk ends in the middle of, to prepend to the next chunk; '' when the chunk ends cleanly, so a
+ *  complete report is never read twice. */
+export const oscTail = (chunk) => /\x1b\][^\x07\x1b]*$/.exec(chunk)?.[0] ?? '';
 /** A database call from the wrapper's own callbacks. One that fails (a lock held past busy_timeout while the disk
  *  stalls) is logged and dropped: thrown from a timer or a PTY callback it would end the wrapper and the agent in
  *  it, and the next tick or terminal report puts the state right anyway. */
@@ -212,15 +252,19 @@ export function run(tool, launch, extraArgs) {
         if (/^CLAUDECODE/.test(k))
             delete env[k]; // allow launching from inside a Claude session
     const term = pty.spawn(file, [...args, ...launch.args, ...extraArgs], {
-        name: 'xterm-256color', cols: process.stdout.columns || 120, rows: process.stdout.rows || 40, cwd: launch.cwd, env,
+        name: 'xterm-256color', cols: process.stdout.columns || 120, rows: process.stdout.rows || 40, cwd: launch.project.dir, env, // the project folder: the tool then treats it as the project (same /resume list, CLAUDE.md, trust)
     });
     const d = db.openDb(launch.dbFile);
-    db.addAgent(d, { name: launch.name, tool, pid: term.pid, cwd: launch.cwd, worktree: launch.worktree, heartbeat: true });
-    let outTail = '', echoBuf = '', awaitingEcho = false;
+    // prepare registered the agent; the wrapper only takes it over (a fresh registration would drop messages that
+    // arrived during setup and a stop requested meanwhile)
+    db.setPid(d, launch.name, term.pid);
+    db.heartbeat(d, launch.name);
+    let outTail = '', echoBuf = '', awaitingEcho = false, lastOutputAt = Date.now();
     const titles = new TitleFilter();
     let title = titleFor(launch.name, null);
     process.stdout.write(titleSequence(title));
     term.onData(x => {
+        lastOutputAt = Date.now();
         process.stdout.write(titles.push(x));
         if (awaitingEcho)
             echoBuf = (echoBuf + x).slice(-16000);
@@ -228,7 +272,7 @@ export function run(tool, launch, extraArgs) {
             const state = oscState(outTail + x);
             if (state)
                 tolerant('terminal state report', () => db.setStatus(d, launch.name, state));
-            outTail = x.slice(-64);
+            outTail = oscTail(x);
         }
     });
     const gate = new InputGate();
@@ -243,8 +287,13 @@ export function run(tool, launch, extraArgs) {
     const onResize = () => term.resize(process.stdout.columns || 120, process.stdout.rows || 40);
     process.stdout.on('resize', onResize);
     Object.assign(process.env, launch.env); // so the wrapper writes to the same chord.db.log as the hooks
-    let typed = null, typedAt = 0, enteredAt = 0, enters = 0, echoed = false, lastState = '';
+    let typed = null, typedAt = 0, enteredAt = 0, enters = 0, echoed = false, lastState = '', lastTick = Date.now();
     const timer = setInterval(() => tolerant('wake loop', () => {
+        // a tick long overdue means the machine slept: vouch for every wrapper before a hook sweeps the ones not yet awake
+        const now = Date.now();
+        if (now - lastTick > db.HEARTBEAT_STALE_MS)
+            db.heartbeatAll(d);
+        lastTick = now;
         db.heartbeat(d, launch.name);
         const me = db.getAgent(d, launch.name);
         const wanted = titleFor(launch.name, me?.task);
@@ -258,11 +307,11 @@ export function run(tool, launch, extraArgs) {
             typedAt = enteredAt = enters = 0;
             echoed = false;
         }
-        const s = { status, unread: db.hasUnread(d, launch.name), stop: !!me?.stop_requested_at, gateClear: gate.clear() && gate.settled(), typed, typedAt, echoed, enters, enteredAt };
+        const s = { status, unread: db.hasUnread(d, launch.name), stop: !!me?.stop_requested_at, gateClear: gate.clear() && gate.settled(), quietFor: Date.now() - lastOutputAt, typed, typedAt, echoed, enters, enteredAt };
         const action = nextAction(s, Date.now());
-        const state = `${status}/${s.unread}/${s.stop}/${s.gateClear}/${action}`;
+        const state = `${status}/${s.unread}/${s.stop}/${s.gateClear}/${s.quietFor >= 3000}/${action}`;
         if (state !== lastState) {
-            db.log(`wake loop: status=${status} unread=${s.unread} stop=${s.stop} gateClear=${s.gateClear} action=${action}`);
+            db.log(`wake loop: status=${status} unread=${s.unread} stop=${s.stop} gateClear=${s.gateClear} quiet=${s.quietFor >= 3000} action=${action}`);
             lastState = state;
         }
         if (!action)
@@ -297,6 +346,19 @@ export function run(tool, launch, extraArgs) {
             term.write('\r');
             enteredAt = Date.now();
             enters = 1;
+            if (action !== 'stop')
+                return;
+            // Quitting over the agent's background work would kill it, so chord stays (Esc) and tries again once the exit
+            // command has expired, by which time the work may be done.
+            echoBuf = '';
+            awaitingEcho = true;
+            setTimeout(() => {
+                awaitingEcho = false;
+                if (!exitDeclined(echoBuf))
+                    return;
+                db.log('wake loop: the tool asked before quitting because the agent has background work running; staying, will try again later');
+                term.write(ESC_INPUT);
+            }, 2000);
         }, 1500);
     }), 1000);
     return new Promise(resolve => {

package/dist/serve.js

@@ -1,12 +1,11 @@
-// Entry point for the per-agent MCP server. Spawned by the coding agent over stdio, in the agent's workspace.
+// Entry point for the per-agent MCP server. Spawned by the coding agent over stdio, in the project folder; the
+// agent's workspace comes from the CHORD_* environment, never from cwd, which would make every claim path wrong.
 import { openDb } from "./db.js";
 import { serve } from "./mcp.js";
 import { tools } from "./tools.js";
-const agent = process.env.CHORD_AGENT_ID;
-const file = process.env.CHORD_DB;
-if (!agent || !file) {
-    process.stderr.write('chord: CHORD_AGENT_ID and CHORD_DB must be set\n');
+const { CHORD_AGENT_ID: agent, CHORD_DB: file, CHORD_WORKSPACE: cwd, CHORD_WORKTREE: worktree } = process.env;
+if (!agent || !file || !cwd || !worktree) {
+    process.stderr.write('chord: CHORD_AGENT_ID, CHORD_DB, CHORD_WORKSPACE and CHORD_WORKTREE must be set\n');
     process.exit(2);
 }
-const cwd = process.env.CHORD_WORKSPACE ?? process.cwd();
-serve(tools({ db: openDb(file), agent, cwd, worktree: process.env.CHORD_WORKTREE ?? cwd, project: process.env.CHORD_PROJECT }));
+serve(tools({ db: openDb(file), agent, cwd, worktree, project: process.env.CHORD_PROJECT }));

package/dist/tools.js

@@ -1,36 +1,47 @@
-import { execFileSync, execSync } from 'node:child_process';
+import { execSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import * as db from "./db.js";
-import { readConfig } from "./launch.js";
+/** path.relative, except that on macOS directory names differing only in case match, as path.relative already has them
+ *  on Windows: both file systems ignore case, so /P/Repo is /P/repo, and a write must not slip past a check that way. */
+function relativePath(from, to) {
+    if (process.platform !== 'darwin')
+        return path.relative(from, to);
+    const a = path.resolve(from).split('/').filter(Boolean), b = path.resolve(to).split('/').filter(Boolean);
+    let i = 0;
+    while (i < a.length && i < b.length && a[i].toLowerCase() === b[i].toLowerCase())
+        i++;
+    return [...a.slice(i).map(() => '..'), ...b.slice(i)].join('/');
+}
 /** Is `file` inside `dir`? False for paths on another drive or above it. */
 export function insideDir(dir, file) {
-    const rel = path.relative(dir, path.resolve(dir, file));
+    const rel = relativePath(dir, path.resolve(dir, file));
     return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
 }
 /**
- * The claim key for a path an agent names: workspace-relative with forward slashes. Absolute paths and
- * paths starting with the repository directory are taken as given; any other relative path is read as
- * repository-relative (what the schema used to say, and what agents working inside the repo naturally
- * write). Paths outside the workspace are refused: chord cannot coordinate them.
+ * The claim key for a path an agent names: workspace-relative with forward slashes. Absolute paths are taken as
+ * given; a path from the project folder (chord/agents/<name>/<repo>/...) is resolved there; any other relative
+ * path is repository-relative (what agents working on the repository naturally write). Paths outside the
+ * workspace are refused: chord cannot coordinate them.
  */
 export function claimPath(ctx, file) {
-    const repoDir = path.relative(ctx.cwd, ctx.worktree).split(path.sep).join('/');
     const asGiven = normFile(ctx, file);
     let abs;
-    if (path.isAbsolute(file) || !repoDir || repoDir === '.' || /^\.\.(\/|$)/.test(asGiven))
+    const fromProject = 'chord/agents/'; // the spelling from the tool's cwd, the project folder; another agent's folder then fails the check below
+    if (path.isAbsolute(file) || /^\.\.(\/|$)/.test(asGiven))
         abs = path.resolve(ctx.cwd, file);
-    else if (asGiven === repoDir || asGiven.startsWith(repoDir + '/')) {
-        // "rich/console.py" is the workspace path of the repository's console.py, or the repository path of a package
-        // named like the repository (rich/rich/console.py); whichever exists is meant, and both existing is ambiguous
-        const asWorkspace = path.resolve(ctx.cwd, file), asRepo = path.resolve(ctx.worktree, file);
-        const w = fs.existsSync(asWorkspace), r = fs.existsSync(asRepo);
-        if (w && r && asWorkspace !== asRepo)
-            throw new Error(`${file} is ambiguous: it could be ${normFile(ctx, asWorkspace)} or ${normFile(ctx, asRepo)}; give the path from your workspace root`);
-        abs = r && !w ? asRepo : asWorkspace;
-    }
-    else
+    else if (ctx.project && asGiven.startsWith(fromProject))
+        abs = path.resolve(ctx.project, file);
+    else {
         abs = path.resolve(ctx.worktree, file);
+        // From the project folder "<repo>/x" is the main checkout's x. An agent naming its own copy that way, where the
+        // repository has no such path but x exists at its root, is told the spellings that reach it rather than given a
+        // claim on a file that is not there.
+        const repoName = path.basename(ctx.worktree), inner = asGiven.slice(repoName.length + 1);
+        if (asGiven.startsWith(`${repoName}/`) && !fs.existsSync(abs) && fs.existsSync(path.resolve(ctx.worktree, inner))) {
+            throw new Error(`there is no ${asGiven} in the repository, but it has ${inner}: name files relative to the repository root ("${inner}") or from the project folder ("chord/agents/<you>/${repoName}/${inner}")`);
+        }
+    }
     if (!insideDir(ctx.cwd, abs))
         throw new Error(`${file} is outside your workspace; chord only coordinates files under ${ctx.cwd}`);
     return normFile(ctx, abs);
@@ -38,7 +49,7 @@ export function claimPath(ctx, file) {
 /** How long a latecomer waits for replies before it may write anyway. */
 export const REPLY_TIMEOUT_MS = 10 * 60 * 1000;
 /** How long before its claim a latecomer's message to an occupant still counts as asking about that file. */
-export const ASK_WINDOW_MS = 2 * 60 * 1000;
+const ASK_WINDOW_MS = 2 * 60 * 1000;
 const str = (desc) => ({ type: 'string', description: desc });
 function req(args, key) {
     const v = args[key];
@@ -46,9 +57,9 @@ function req(args, key) {
         throw new Error(`${key} is required`);
     return v;
 }
-/** Worktree-relative path with forward slashes, so the same file matches across worktrees. */
+/** Workspace-relative path with forward slashes (repo/src/x.ts), so the same file matches across agents' worktrees. */
 export function normFile(ctx, file) {
-    return path.relative(ctx.cwd, path.resolve(ctx.cwd, file)).split(path.sep).join('/');
+    return relativePath(ctx.cwd, path.resolve(ctx.cwd, file)).split(path.sep).join('/');
 }
 export function peers(ctx) {
     return db.listAgents(ctx.db).filter(a => a.name !== ctx.agent).map(a => ({
@@ -57,10 +68,11 @@ export function peers(ctx) {
 }
 // words that describe code rather than name it: "the parse function" and "parse tests" share only "parse"
 const NOT_SYMBOLS = new Set(['a', 'an', 'and', 'or', 'the', 'of', 'in', 'to', 'for', 'with', 'new', 'its', 'all', 'function', 'functions', 'method', 'methods', 'class', 'classes', 'test', 'tests', 'block', 'blocks', 'section', 'line', 'lines', 'file', 'helper', 'helpers', 'code', 'logic', 'docs', 'docstring']);
-const symbolSet = (s) => new Set((s ?? '').toLowerCase().match(/[a-z_$][\w$.]*/g)?.filter(w => !NOT_SYMBOLS.has(w)) ?? []);
+// "Parser.parse" names Parser and parse too: whoever holds either holds part of it
+const symbolSet = (s) => new Set((s ?? '').toLowerCase().match(/[a-z_$][\w$.]*/g)?.flatMap(w => [w, ...w.split('.')]).filter(w => w && !NOT_SYMBOLS.has(w)) ?? []);
 /** Two modify claims on one file that each name the functions or blocks they touch, with none in common, do not
  *  need to talk first. Anything less certain (no symbols on either side, or an add, delete or rename) does. */
-export function disjointEdits(a, b) {
+function disjointEdits(a, b) {
     if (a.kind !== 'modify' || b.kind !== 'modify')
         return false;
     const x = symbolSet(a.symbols), y = symbolSet(b.symbols);
@@ -69,7 +81,9 @@ export function disjointEdits(a, b) {
 /** Online agents who claimed `file` before `mine` did, split into those `mine` overlaps and must talk to and those
  *  editing other parts of it. */
 function earlierOccupants(ctx, mine) {
-    const before = (c) => c.created_at < mine.created_at || (c.created_at === mine.created_at && c.rid < mine.rid);
+    // by rowid, which the insert gets under the write lock, not by the timestamp read before waiting for it: two
+    // agents claiming at once would otherwise each see the other as later and neither would talk first
+    const before = (c) => c.rid < mine.rid;
     const all = db.claimsFor(ctx.db, mine.file).filter(c => c.agent !== ctx.agent && before(c) && db.getAgent(ctx.db, c.agent)?.status !== 'offline');
     return { overlap: all.filter(c => !disjointEdits(c, mine)), elsewhere: all.filter(c => disjointEdits(c, mine)) };
 }
@@ -99,7 +113,7 @@ export function canWrite(ctx, file, now = Date.now()) {
         const askedAt = db.firstMessageAt(ctx.db, ctx.agent, o.agent, Math.max(since, mine.created_at - ASK_WINDOW_MS));
         if (askedAt === null)
             notAsked.push(o.agent);
-        else if (!db.repliedSince(ctx.db, o.agent, ctx.agent, since) && now - askedAt < REPLY_TIMEOUT_MS)
+        else if (db.firstMessageAt(ctx.db, o.agent, ctx.agent, since) === null && now - askedAt < REPLY_TIMEOUT_MS)
             waiting.push({ agent: o.agent, left: REPLY_TIMEOUT_MS - (now - askedAt) });
     }
     if (notAsked.length) {
@@ -111,9 +125,7 @@ export function canWrite(ctx, file, now = Date.now()) {
     }
     return { ok: true };
 }
-// 64 MB of output: a project's post-merge hook may print a great deal, and the default 1 MB would turn a merge that
-// already happened into an exception
-const git = (cwd, ...args) => execFileSync('git', args, { cwd, encoding: 'utf8', env: db.gitEnv(), stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 64 * 1024 * 1024 }).trim();
+const { git } = db;
 const gitOk = (cwd, ...args) => { try {
     git(cwd, ...args);
     return true;
@@ -122,7 +134,7 @@ catch {
     return false;
 } };
 const stderrOf = (e) => (e.stderr ?? e.message).trim();
-const sleepSync = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+const { sleepSync } = db;
 /** Tracked files with real changes, staged or not, ignoring line-ending differences and whatever happens inside
  *  submodules; '' when clean. */
 export function dirtyTracked(cwd) {
@@ -144,8 +156,10 @@ function gitRetry(cwd, ...args) {
         }
     }
 }
-/** Run fn holding an exclusive lock file. Waits up to `waitMs`; a lock older than `staleMs` is taken over. */
-export function withLock(file, fn, waitMs = 240_000, staleMs = 180_000) {
+/** Run fn holding an exclusive lock file that names its holder's pid. Waits up to `waitMs`. A lock whose holder is
+ *  gone is taken over at once; one older than `staleMs` as well, which must exceed the longest run of the project's
+ *  test command (ten minutes) so a live holder is never robbed of its lock. */
+export function withLock(file, fn, waitMs = 240_000, staleMs = 15 * 60_000) {
     const t0 = Date.now();
     for (;;) {
         try {
@@ -156,7 +170,8 @@ export function withLock(file, fn, waitMs = 240_000, staleMs = 180_000) {
             if (e.code !== 'EEXIST')
                 throw e;
             try {
-                if (Date.now() - fs.statSync(file).mtimeMs > staleMs) {
+                const holder = Number(fs.readFileSync(file, 'utf8'));
+                if ((holder > 0 && !db.pidAlive(holder)) || Date.now() - fs.statSync(file).mtimeMs > staleMs) {
                     fs.unlinkSync(file);
                     continue;
                 }
@@ -169,16 +184,50 @@ export function withLock(file, fn, waitMs = 240_000, staleMs = 180_000) {
             sleepSync(150 + Math.random() * 200);
         }
     }
+    // only our own lock is removed: one taken over meanwhile belongs to whoever holds it now
     try {
         return fn();
     }
     finally {
         try {
-            fs.unlinkSync(file);
+            if (fs.readFileSync(file, 'utf8') === String(process.pid))
+                fs.unlinkSync(file);
         }
         catch { /* already gone */ }
     }
 }
+/** <project>/chord/config.json. `setup` is a shell command run in every new worktree before the agent starts,
+ *  for example "npm install". `test` is a shell command finish runs in the worktree after rebasing onto main and
+ *  before fast-forwarding it, for example "npm test"; when it fails nothing is merged. Lives here, not in launch.ts,
+ *  so the hooks (which load this module for finish's sake) do not load the launch code on every tool call. */
+export function readConfig(project) {
+    const file = path.join(project.dir, 'chord', 'config.json');
+    let raw;
+    try {
+        raw = fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        return {};
+    }
+    let cfg;
+    try {
+        cfg = JSON.parse(raw);
+    }
+    catch (e) {
+        throw new Error(`${file} is not valid JSON: ${e.message}`);
+    }
+    if (typeof cfg !== 'object' || cfg === null)
+        throw new Error(`${file} must hold a JSON object`);
+    const out = {};
+    for (const key of ['setup', 'test']) {
+        const v = cfg[key];
+        if (v !== undefined && typeof v !== 'string')
+            throw new Error(`${file}: "${key}" must be a string (a shell command)`);
+        if (v)
+            out[key] = v;
+    }
+    return out;
+}
 /** Rebase the agent's branch onto main and fast-forward main to it. Atomic from the agent's point of view.
  *  Finishes are serialised with a lock file: git cannot run two merges in one checkout concurrently. */
 export function finish(ctx) {
@@ -189,9 +238,9 @@ function finishLocked(ctx) {
     const wt = ctx.worktree;
     // A rebase in progress is only ours to clean up when finish itself started it (a finish killed mid-rebase leaves
     // the marker behind). Anyone else's rebase, perhaps with conflicts already resolved, is left alone.
-    const marker = path.resolve(wt, git(wt, 'rev-parse', '--git-path', 'chord-finish'));
-    for (const dir of ['rebase-merge', 'rebase-apply']) {
-        if (!fs.existsSync(path.resolve(wt, git(wt, 'rev-parse', '--git-path', dir))))
+    const [marker, rebaseMerge, rebaseApply, indexLock] = git(wt, 'rev-parse', '--git-path', 'chord-finish', '--git-path', 'rebase-merge', '--git-path', 'rebase-apply', '--git-path', 'index.lock').split('\n').map(p => path.resolve(wt, p));
+    for (const dir of [rebaseMerge, rebaseApply]) {
+        if (!fs.existsSync(dir))
             continue;
         if (!fs.existsSync(marker))
             throw new Error('a rebase is in progress in your worktree that finish did not start; run `git rebase --continue` (after resolving conflicts) or `git rebase --abort` first');
@@ -200,7 +249,6 @@ function finishLocked(ctx) {
     }
     fs.rmSync(marker, { force: true });
     // a finish killed mid-operation can leave the worktree's own index.lock behind; one older than a minute is debris
-    const indexLock = path.resolve(wt, git(wt, 'rev-parse', '--git-path', 'index.lock'));
     try {
         if (Date.now() - fs.statSync(indexLock).mtimeMs > 60_000) {
             fs.unlinkSync(indexLock);
@@ -213,6 +261,12 @@ function finishLocked(ctx) {
     // such file as modified the moment it is checked out, and no agent can commit that away.
     if (dirtyTracked(wt))
         throw new Error('your worktree has uncommitted changes to tracked files; commit them first');
+    // Except the files this agent claimed: one it wrote and never added (git commit -a skips new files) would leave
+    // main with half the change, and the claim that protected it would be released below.
+    const claimed = db.claimsBy(ctx.db, ctx.agent).map(c => relativePath(wt, path.resolve(ctx.cwd, c.file)).split(path.sep).join('/')).filter(f => f && !f.startsWith('..'));
+    const lost = claimed.length ? git(wt, 'ls-files', '--others', '--exclude-standard', '--', ...claimed) : '';
+    if (lost)
+        throw new Error(`you claimed ${lost.split('\n').join(', ')} but never committed it: git add and commit it (or release the claim) and call finish again. Nothing was merged.`);
     // What status still reports now differs only in line endings. git will not rebase over it, and nothing done in a
     // worktree can clear it: the repository needs a renormalised commit, which is the user's call.
     const phantom = git(wt, 'status', '--porcelain', '--untracked-files=no', '--ignore-submodules=dirty').split('\n').filter(Boolean).map(l => l.replace(/^[ MADRCU?!]{1,2}\s+/, ''));
@@ -265,7 +319,7 @@ function finishLocked(ctx) {
     const subjects = git(root, 'log', '--format=%s', `${main}..${branch}`).split('\n').filter(Boolean);
     // A submodule commit the branch points at must exist in the main checkout's copy of the submodule, or the
     // fast-forward leaves main pointing at a commit that is nowhere but inside this agent's worktree.
-    for (const line of git(root, 'diff', '--raw', main, branch).split('\n')) {
+    for (const line of git(root, '-c', 'core.quotePath=false', 'diff', '--raw', main, branch).split('\n')) { // a non-ASCII path arrives as itself, not quoted and escaped
         const m = /^:\d{6} 160000 [0-9a-f]+ ([0-9a-f]+) [AM]\t(.+)$/.exec(line);
         if (!m)
             continue;
@@ -306,7 +360,7 @@ function finishLocked(ctx) {
     db.releaseAll(ctx.db, ctx.agent, 'finish');
     const online = db.listAgents(ctx.db).filter(a => a.name !== ctx.agent && a.status !== 'offline').map(a => a.name);
     if (online.length)
-        db.send(ctx.db, ctx.agent, online, `${ctx.agent} merged into ${main}:\n${subjects.map(s => `- ${s}`).join('\n')}\nNo action is needed: finish() rebases your branch for you when you call it. This is a notification; do not reply.`, 'notice');
+        db.send(ctx.db, ctx.agent, online, `${ctx.agent} merged into ${main}:\n${subjects.map(s => `- ${s}`).join('\n')}\n${db.NOTICE_TAIL}`, 'notice');
     return { merged: subjects, into: main, notified: online };
 }
 export function tools(ctx) {
@@ -336,7 +390,7 @@ export function tools(ctx) {
             inputSchema: {
                 type: 'object',
                 properties: {
-                    file: str('The file, as a path from your working directory (e.g. <repo>/src/x.ts) or relative to the repository root (src/x.ts)'),
+                    file: str('The file, as a path from your working directory (chord/agents/<you>/<repo>/src/x.ts) or relative to the repository root (src/x.ts)'),
                     intent: str('One sentence: what you will change and why'),
                     kind: { type: 'string', enum: ['add', 'modify', 'delete', 'rename'] },
                     symbols: str('Optional: the functions or blocks you will touch, comma-separated. When you and an earlier holder of the file both name them and none are shared, you need not talk first.'),
@@ -351,7 +405,6 @@ export function tools(ctx) {
                 db.addClaim(ctx.db, { agent: ctx.agent, file, intent: req(a, 'intent'), kind, symbols: typeof a.symbols === 'string' ? a.symbols : null });
                 const mine = db.claimsFor(ctx.db, file).find(c => c.agent === ctx.agent);
                 const { overlap: others, elsewhere } = earlierOccupants(ctx, mine);
-                db.log(`claim ${file} by ${ctx.agent} (cwd ${ctx.cwd}): rows=${JSON.stringify(db.claimsFor(ctx.db, file).map(c => [c.agent, c.created_at]))} agents=${JSON.stringify(db.listAgents(ctx.db).map(a => [a.name, a.status, a.pid]))} others=${others.map(o => o.agent)} elsewhere=${elsewhere.map(o => o.agent)}`);
                 const brief = (o) => ({ agent: o.agent, intent: o.intent, kind: o.kind, symbols: o.symbols });
                 return {
                     claimed: file,

package/dist/trust.js

@@ -1,10 +1,9 @@
-// Claude Code asks "do you trust this folder?" once per working directory and records the answer in
-// ~/.claude.json. Every agent workspace is a new directory, so without this each launch asks again.
-// The workspace only holds a worktree of a repository the user already chose to run chord in.
+// What the user has told Claude Code and Codex to trust, read from their own config files. Agents run in the
+// project folder, which the user trusts (or not) in Claude Code themselves; chord writes no trust of its own.
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-export const claudeConfigPath = () => path.join(os.homedir(), '.claude.json');
+const claudeConfigPath = () => path.join(os.homedir(), '.claude.json');
 // Claude Code keys projects by the cwd with forward slashes, even on Windows
 const norm = (p) => p.replace(/\\/g, '/').toLowerCase();
 /** Whether the user has answered yes to Claude Code's "do you trust this folder?" dialogue for `dir`. */
@@ -18,37 +17,6 @@ export function claudeTrusts(dir, file = claudeConfigPath()) {
         return false;
     }
 }
-/** Mark `workspace` as trusted for Claude Code. Returns false when Claude Code has no config yet (nothing to do)
- *  or the entry was already there. Writes atomically; other fields of the file are left untouched. */
-export function pretrustClaude(workspace, file = claudeConfigPath()) {
-    let raw;
-    try {
-        raw = fs.readFileSync(file, 'utf8');
-    }
-    catch {
-        return false;
-    }
-    let cfg;
-    try {
-        cfg = JSON.parse(raw);
-    }
-    catch {
-        return false;
-    } // not ours to repair
-    if (typeof cfg !== 'object' || cfg === null)
-        return false;
-    const projects = (cfg.projects ??= {});
-    const key = Object.keys(projects).find(k => norm(k) === norm(workspace)) ?? workspace.replace(/\\/g, '/');
-    if (projects[key]?.hasTrustDialogAccepted === true)
-        return false;
-    projects[key] = projects[key]
-        ? { ...projects[key], hasTrustDialogAccepted: true } // existing entry: flip the flag, keep everything else
-        : { allowedTools: [], mcpContextUris: [], mcpServers: {}, enabledMcpjsonServers: [], disabledMcpjsonServers: [], hasTrustDialogAccepted: true, hasClaudeMdExternalIncludesApproved: false, hasClaudeMdExternalIncludesWarningShown: false };
-    const tmp = `${file}.chord-${process.pid}.tmp`;
-    fs.writeFileSync(tmp, JSON.stringify(cfg, null, 2));
-    fs.renameSync(tmp, file);
-    return true;
-}
 /** Which of a repository's .mcp.json servers the user has approved or rejected in Claude Code, and whether they
  *  approved them all at once. Claude asks per server when it runs in the repository; chord has no prompt, so it only
  *  starts what the user has already approved there. */
@@ -63,7 +31,7 @@ export function claudeMcpChoices(dir, file = claudeConfigPath()) {
         return { all: false, enabled: [], disabled: [] };
     }
 }
-export const codexConfigPath = () => path.join(os.homedir(), '.codex', 'config.toml');
+const codexConfigPath = () => path.join(os.homedir(), '.codex', 'config.toml');
 /** Codex keeps a trust hash and an on/off switch per hook in ~/.codex/config.toml. One keypress in its
  *  "Hooks need review" screen switches a hook off, and chord then silently loses the feature behind it, so
  *  chord names the switched-off hooks at launch. Returns Codex event names such as "session_start". */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chord-cli",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "Run several coding agents in one git project, each in its own worktree, with shared file claims and messaging",
   "license": "MIT",
   "keywords": [
@@ -31,7 +31,11 @@
   "engines": {
     "node": ">=24"
   },
-  "os": ["win32", "linux"],
+  "os": [
+    "win32",
+    "linux",
+    "darwin"
+  ],
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
     "prepare": "tsc -p tsconfig.build.json",