chord-cli 0.1.2 → 0.2.0

package/dist/launch.js

@@ -16,7 +16,6 @@ const git = (cwd, ...args) => execFileSync('git', args, { cwd, encoding: 'utf8',
 const here = (f) => fs.realpathSync.native(fileURLToPath(new URL(f + path.extname(fileURLToPath(import.meta.url)), import.meta.url))).split(path.sep).join('/');
 export const HOOKS_TS = here('./hooks');
 export const SERVE_TS = here('./serve');
-const sleepSync = (ms) => 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, tool, project, override, staleWaitMs = 2500) {
     if (override) {
@@ -36,7 +35,7 @@ export function pickName(d, tool, project, override, staleWaitMs = 2500) {
             // (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);
+                db.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`);
@@ -211,8 +210,9 @@ export function claudeArgs(env, projectConfig = false) {
     // 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.
+    // The agent's cwd is the project folder, not the repository, so Claude Code would not pick up the repository's
+    // skills, commands and agents under .claude/, nor its settings*.json or .mcp.json. --add-dir covers the first group
+    // (the briefing carries CLAUDE.md itself); the others are passed along.
     const wt = env.CHORD_WORKTREE;
     const addDir = wt ? ['--add-dir', wt] : [];
     const source = projectConfig === true ? { repo: wt ?? '' } : projectConfig || null;
@@ -345,7 +345,8 @@ export function prepare(tool, cwd, override) {
     }
 }
 /** <project>/chord/config.json. `setup` is a shell command run in every new worktree before the agent starts,
- *  for example "npm install". */
+ *  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. */
 export function readConfig(project) {
     const file = path.join(project.dir, 'chord', 'config.json');
     let raw;
@@ -364,10 +365,15 @@ export function readConfig(project) {
     }
     if (typeof cfg !== 'object' || cfg === null)
         throw new Error(`${file} must hold a JSON object`);
-    const setup = cfg.setup;
-    if (setup !== undefined && typeof setup !== 'string')
-        throw new Error(`${file}: "setup" must be a string (a shell command)`);
-    return setup ? { setup } : {};
+    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;
 }
 /** Where `chord clean` and a relaunch look to see whether the setup command has run for this agent. */
 export const setupMarker = (project, name) => path.join(project.stateDir, 'setup-done', name);

package/dist/pty.js

@@ -142,6 +142,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. Linux form not yet verified against the real tools. */
+export 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 +178,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,7 +194,7 @@ 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
@@ -194,6 +208,17 @@ export function oscState(chunk) {
         last = x[1] === 'idle' ? 'idle' : 'busy';
     return last;
 }
+/** 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. */
+function tolerant(what, f) {
+    try {
+        f();
+    }
+    catch (e) {
+        db.log(`${what}: ${e.message}; skipped`);
+    }
+}
 export function run(tool, launch, extraArgs) {
     const { file, args } = resolveCommand(tool);
     const env = withNodeOnPath({ ...process.env, ...launch.env });
@@ -201,22 +226,23 @@ 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;
+    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);
         if (tool === 'codex') { // the hooks set status too; the terminal report catches turns the hooks miss (Esc, untrusted hooks)
             const state = oscState(outTail + x);
             if (state)
-                db.setStatus(d, launch.name, state);
+                tolerant('terminal state report', () => db.setStatus(d, launch.name, state));
             outTail = x.slice(-64);
         }
     });
@@ -233,7 +259,7 @@ export function run(tool, launch, extraArgs) {
     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 = '';
-    const timer = setInterval(() => {
+    const timer = setInterval(() => tolerant('wake loop', () => {
         db.heartbeat(d, launch.name);
         const me = db.getAgent(d, launch.name);
         const wanted = titleFor(launch.name, me?.task);
@@ -247,11 +273,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)
@@ -286,8 +312,21 @@ 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);
+    }), 1000);
     return new Promise(resolve => {
         term.onExit(({ exitCode }) => {
             clearInterval(timer);
@@ -296,8 +335,8 @@ export function run(tool, launch, extraArgs) {
             if (process.stdin.isTTY)
                 process.stdin.setRawMode(false);
             process.stdin.pause();
-            db.setStatus(d, launch.name, 'offline');
-            db.releaseAll(d, launch.name, 'exit');
+            tolerant('exit', () => db.setStatus(d, launch.name, 'offline'));
+            tolerant('exit', () => db.releaseAll(d, launch.name, 'exit')); // missed here, the next sweep releases them
             resolve(exitCode);
         });
     });

package/dist/serve.js

@@ -1,4 +1,5 @@
-// 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, not from cwd.
 import { openDb } from "./db.js";
 import { serve } from "./mcp.js";
 import { tools } from "./tools.js";

package/dist/tools.js

@@ -1,7 +1,8 @@
-import { execFileSync } from 'node:child_process';
+import { execFileSync, 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";
 /** 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));
@@ -9,16 +10,20 @@ export function insideDir(dir, file) {
 }
 /**
  * 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.
+ * paths starting with the repository directory are taken as given; a path from the project folder
+ * (chord/agents/<name>/<repo>/...) is resolved there; any other relative path is read as
+ * repository-relative (what agents working inside the repo 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;
+    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) || !repoDir || repoDir === '.' || /^\.\.(\/|$)/.test(asGiven))
         abs = path.resolve(ctx.cwd, file);
+    else if (ctx.project && asGiven.startsWith(fromProject))
+        abs = path.resolve(ctx.project, 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
@@ -54,10 +59,23 @@ export function peers(ctx) {
         name: a.name, tool: a.tool, status: a.status, cwd: a.cwd, task: a.task, scope: a.scope,
     }));
 }
-/** Online agents who claimed `file` before `mine` did. */
+// 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)) ?? []);
+/** 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) {
+    if (a.kind !== 'modify' || b.kind !== 'modify')
+        return false;
+    const x = symbolSet(a.symbols), y = symbolSet(b.symbols);
+    return x.size > 0 && y.size > 0 && ![...x].some(w => y.has(w));
+}
+/** 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);
-    return db.claimsFor(ctx.db, mine.file).filter(c => c.agent !== ctx.agent && before(c) && db.getAgent(ctx.db, c.agent)?.status !== 'offline');
+    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)) };
 }
 /**
  * May `ctx.agent` write `file` now? It must hold a claim, and if others claimed the file first it must
@@ -70,7 +88,7 @@ export function canWrite(ctx, file, now = Date.now()) {
     const mine = db.claimsFor(ctx.db, rel).find(c => c.agent === ctx.agent);
     if (!mine)
         return { ok: false, reason: `${rel} is not claimed by you. Call claim(file, intent, kind) first.` };
-    const others = earlierOccupants(ctx, mine);
+    const others = earlierOccupants(ctx, mine).overlap;
     if (!others.length)
         return { ok: true };
     const myStart = db.getAgent(ctx.db, ctx.agent)?.started_at ?? mine.created_at;
@@ -230,7 +248,23 @@ function finishLocked(ctx) {
             throw new Error(`rebase onto ${main} failed (not a conflict); nothing was merged.\n${stderrOf(e)}`);
         db.log(`finish: rebase of ${branch} onto ${main} conflicted; aborted`);
         db.addEvent(ctx.db, ctx.agent, 'conflict', null, `rebase of ${branch} onto ${main} conflicted; aborted, nothing merged`);
-        throw new Error(`rebase onto ${main} failed; nothing was merged. Ask the user how to resolve it.\n${stderrOf(e)}`);
+        throw new Error(`rebase onto ${main} failed; nothing was merged. Run \`git rebase ${main}\` in your worktree, resolve the conflicts so both changes survive, run the tests, then call finish again; ask the user only if you cannot resolve them.\n${stderrOf(e)}`);
+    }
+    // The project's tests, on the branch as it now sits on top of main: a clean rebase can still break what another
+    // agent merged. ponytail: they run inside the finish lock, so other agents' finish waits for them (withLock gives
+    // up after 240 s); run them before taking the lock and re-check main if test suites get long.
+    const test = ctx.project ? readConfig({ dir: ctx.project }).test : undefined;
+    if (test) {
+        db.log(`finish: running the test command in ${wt}: ${test}`);
+        try {
+            execSync(test, { cwd: wt, stdio: 'pipe', timeout: 600_000, maxBuffer: 64 << 20 });
+        }
+        catch (e) {
+            const x = e;
+            const out = `${x.stdout ?? ''}${x.stderr ?? ''}`.trimEnd().split('\n').slice(-40).join('\n');
+            db.log(`finish: the test command failed${x.status != null ? ` with exit code ${x.status}` : ''}; nothing merged`);
+            throw new Error(`your branch is now rebased onto ${main}, but the project's test command failed there, so nothing was merged: ${test}\n${out}\nFix it (another agent's merged work may be what broke), commit, and call finish again.`);
+        }
     }
     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
@@ -276,7 +310,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) {
@@ -306,10 +340,10 @@ 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: functions or blocks you will touch'),
+                    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.'),
                 },
                 required: ['file', 'intent', 'kind'],
             },
@@ -320,11 +354,13 @@ export function tools(ctx) {
                     throw new Error('kind must be add, modify, delete or rename');
                 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 others = 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)}`);
+                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,
-                    must_talk_to: others.map(o => ({ agent: o.agent, intent: o.intent, kind: o.kind, symbols: o.symbols })),
+                    must_talk_to: others.map(brief),
+                    ...(elsewhere.length ? { also_editing: elsewhere.map(brief) } : {}),
                     ...(others.length ? { next: 'Send each agent above a message describing your change. You may write once each has replied, or after 10 minutes.' } : {}),
                 };
             },
@@ -366,7 +402,7 @@ export function tools(ctx) {
         },
         {
             name: 'finish',
-            description: 'Your work is committed on your branch: rebase it onto main, fast-forward main, release all your claims and tell the other agents. On a rebase conflict nothing is changed; stop and ask the user.',
+            description: 'Your work is committed on your branch: rebase it onto main, fast-forward main, release all your claims and tell the other agents. On a rebase conflict nothing is changed; rebase onto main yourself, resolve it, then call finish again.',
             inputSchema: { type: 'object', properties: {} },
             handler: () => finish(ctx),
         },

package/dist/trust.js

@@ -1,6 +1,5 @@
-// 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';
@@ -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. */
@@ -88,3 +56,65 @@ export function disabledCodexHooks(file = codexConfigPath()) {
     }
     return off;
 }
+const hasCodexState = (home) => { try {
+    return fs.readdirSync(home).some(f => /^state_\d+\.sqlite$/.test(f));
+}
+catch {
+    return false;
+} };
+/** Codex creates and migrates its state database (~/.codex/state_N.sqlite) on its first start, and when two start at
+ *  once the second exits with "local database appears to be damaged". Until that database exists, launches take
+ *  turns: the first holds a lock while its Codex creates it, the others wait for the lock. Call the returned
+ *  function once Codex has been spawned; it lets go of the lock when the database is there, or after a minute. */
+export async function codexFirstStart(home = path.join(os.homedir(), '.codex')) {
+    if (hasCodexState(home))
+        return () => { };
+    const lock = path.join(home, '.chord-first-start');
+    const t0 = Date.now();
+    try {
+        fs.mkdirSync(home, { recursive: true });
+    }
+    catch {
+        return () => { };
+    }
+    for (;;) {
+        try {
+            fs.writeFileSync(lock, String(process.pid), { flag: 'wx' });
+            break;
+        }
+        catch (e) {
+            if (e.code !== 'EEXIST')
+                return () => { };
+            try {
+                if (Date.now() - fs.statSync(lock).mtimeMs > 60_000) {
+                    fs.unlinkSync(lock);
+                    continue;
+                }
+            }
+            catch {
+                continue;
+            }
+            if (Date.now() - t0 > 90_000)
+                return () => { }; // a launch that never lets go must not hold this one up for good
+            await new Promise(r => setTimeout(r, 250));
+        }
+    }
+    const unlock = () => { try {
+        fs.unlinkSync(lock);
+    }
+    catch { /* gone */ } };
+    if (hasCodexState(home)) {
+        unlock();
+        return () => { };
+    } // the launch before this one created it
+    return () => {
+        const started = Date.now();
+        const poll = setInterval(() => {
+            if (!hasCodexState(home) && Date.now() - started < 60_000)
+                return;
+            clearInterval(poll);
+            setTimeout(unlock, 2000).unref(); // the file appears before its migrations have run
+        }, 250);
+        poll.unref();
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chord-cli",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "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,10 @@
   "engines": {
     "node": ">=24"
   },
-  "os": ["win32", "linux"],
+  "os": [
+    "win32",
+    "linux"
+  ],
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
     "prepare": "tsc -p tsconfig.build.json",