@nonbot/cli 0.7.1 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @nonbot/cli changelog
 
+## 0.9.0
+
+- **Choir collapses into Run.** Launching multiple coordinated agents now comes from the canvas (select stories -> "Run together"), not a terminal command. The daemon groups activations that share a coordinated-set id and launches them with a git worktree per agent + the coordination MCP wired in, each pane on its own per-pane provider (e.g. 2 Claude + 1 Gemini).  remains as internal plumbing only.
+- The set spawn is hardened: repo path validated daemon-side, command written to a 0700 temp script (not an inline shell string), all panes asserted to share one repo, and the plan-not-API unset guard applies.
+
+## 0.8.0
+
+- **Conductor: Choir runs headless, panes appear only when needed.** `nonbot choir` no longer opens N terminal panes. Each agent runs headless in its own git worktree; the live radar is the web dashboard at /choir. A tmux pane is summoned (kill + `claude --resume` in the same worktree) ONLY when an agent hits awaiting-input or an escalated stall, and torn back down when resolved — so the steady state is zero extra windows. A tunable concurrency cap (`choir.maxActiveAgents`, default 2) keeps only K agents working at once.
+- **Runs light up the dashboard.** A ▶ Run now emits sanitized, metadata-only progress + a heartbeat to /choir (it is a 1-pane Choir), inheriting health/stall detection, the Needs-You queue, the dead-man's-switch and the digest — fire-and-forget, never affecting the Run itself.
+- Agents run on your Claude plan, not a metered API key (carried from 0.7.1; the headless + summon spawns both unset ANTHROPIC_API_KEY/AUTH_TOKEN).
+
 ## 0.7.1
 
 - **Agents run on your Claude plan, not a metered API key.** The spawned run

package/dist/commands/choir.js

@@ -5,6 +5,9 @@ import { header, kvRow, statusRow, statusBadge, c } from '../lib/output.js';
 import { assertValidName } from '../lib/choir/names.js';
 import { launchChoir, } from '../lib/choir/launcher.js';
 import { createHub } from '../lib/choir/hub.js';
+import { planConductorTick, DEFAULT_MAX_ACTIVE_AGENTS, } from '../lib/choir/conductor.js';
+import { summonPane, dematerialize } from '../lib/choir/materialize.js';
+import { resolveThresholds } from '../lib/choir/health.js';
 export function buildStartHub(repoRoot, auth) {
     return ({ sessionId, baseBranch, token }) => {
         const opts = {
@@ -22,6 +25,133 @@ export function buildStartHub(repoRoot, auth) {
         return hub;
     };
 }
+const TERMINAL_STATES = new Set(['complete', 'failed']);
+function buildSignals(agents, panes, now) {
+    const byName = new Map();
+    for (const p of Object.values(panes)) {
+        if (p && typeof p === 'object') {
+            const rec = p;
+            const name = typeof rec.name === 'string' ? rec.name : null;
+            if (name)
+                byName.set(name, rec);
+        }
+    }
+    const out = {};
+    for (const a of agents) {
+        const rec = byName.get(a.paneName);
+        if (!rec)
+            continue;
+        const num = (v, fallback) => typeof v === 'number' ? v : fallback;
+        out[a.paneName] = {
+            lastToolUse: num(rec.lastToolUse, now),
+            lastGitDelta: num(rec.lastGitDelta, now),
+            lastPaneActivity: num(rec.lastPaneActivity, now),
+            awaitingInput: rec.status === 'awaiting-input',
+            crashed: rec.status === 'failed',
+        };
+    }
+    return out;
+}
+function allTerminal(agents) {
+    return agents.every((a) => TERMINAL_STATES.has(a.state));
+}
+export function runConductorLoop(args, deps) {
+    const { agents, hub, cap } = args;
+    const thresholds = deps.thresholds ?? resolveThresholds('normal');
+    const tickMs = deps.tickMs ?? 5000;
+    let cancel = null;
+    let tornDown = false;
+    const teardown = async () => {
+        if (tornDown)
+            return;
+        tornDown = true;
+        if (cancel) {
+            try {
+                cancel();
+            }
+            catch {
+            }
+        }
+        for (const a of agents) {
+            if (a.state === 'summoned' && a.tmuxPaneId != null) {
+                try {
+                    await deps.dematerializeImpl(a);
+                }
+                catch {
+                }
+                a.tmuxPaneId = null;
+            }
+        }
+        try {
+            hub.stop();
+        }
+        catch {
+        }
+        logWorktreeNote();
+    };
+    const logWorktreeNote = () => {
+        deps.log('\n' + c.muted('worktrees kept (review before removing — unmerged work is never auto-deleted):') + '\n');
+        for (const a of agents) {
+            deps.log(`   ${c.cyan(a.branch)}  ${c.muted('·')}  ${c.muted(a.worktreePath)}\n`);
+        }
+    };
+    const tick = async () => {
+        if (tornDown)
+            return;
+        const now = deps.now();
+        const signalsByPane = buildSignals(agents, hub.getState().panes, now);
+        const decisions = deps.planTick({
+            agents,
+            signalsByPane,
+            cap,
+            now,
+            thresholds,
+        });
+        for (const d of decisions) {
+            const a = agents.find((x) => x.paneName === d.paneName);
+            if (!a)
+                continue;
+            try {
+                switch (d.action) {
+                    case 'start': {
+                        deps.spawnHeadlessImpl(a);
+                        a.state = 'headless';
+                        break;
+                    }
+                    case 'summon': {
+                        const paneId = await deps.summonPaneImpl(a);
+                        a.tmuxPaneId = paneId;
+                        a.state = 'summoned';
+                        break;
+                    }
+                    case 'dematerialize': {
+                        await deps.dematerializeImpl(a);
+                        a.tmuxPaneId = null;
+                        deps.spawnHeadlessImpl(a);
+                        a.state = 'headless';
+                        break;
+                    }
+                    case 'park':
+                    case 'noop':
+                    default:
+                        break;
+                }
+            }
+            catch {
+            }
+        }
+        if (allTerminal(agents)) {
+            await teardown();
+        }
+    };
+    cancel = deps.timerImpl(() => tick(), tickMs);
+    if (deps.onSigint) {
+        deps.onSigint(() => teardown());
+    }
+    return () => {
+        void teardown();
+    };
+}
 function flagValue(args, name) {
     for (let i = 0; i < args.length; i++) {
         if (args[i] === name)
@@ -72,7 +202,16 @@ export async function runChoirCommand(args = [], deps = {}) {
         return 1;
     }
     const repoRoot = process.cwd();
-    const startHub = deps.startHubImpl ?? buildStartHub(repoRoot, auth);
+    const innerStartHub = deps.startHubImpl ?? buildStartHub(repoRoot, auth);
+    let capturedHub = null;
+    const startHub = innerStartHub === false
+        ? false
+        : (a) => {
+            const hub = innerStartHub(a);
+            if (hub && typeof hub === 'object')
+                capturedHub = hub;
+            return hub;
+        };
     let session;
     try {
         session = launch({
@@ -88,23 +227,71 @@ export async function runChoirCommand(args = [], deps = {}) {
         errLog(`✗ choir launch failed: ${e.message}\n`);
         return 1;
     }
+    const cap = DEFAULT_MAX_ACTIVE_AGENTS;
     const lines = [];
     lines.push(header('nonbot choir', `session ${session.sessionName}  ·  v${VERSION}`));
     lines.push('');
     lines.push(kvRow('Repo', repoRoot));
     lines.push(kvRow('Base', session.baseBranch));
     lines.push(kvRow('Join mode', session.joinMode));
-    lines.push(kvRow('Panes', String(session.panes.length)));
+    lines.push(kvRow('Agents', String(session.agents.length)));
     lines.push('');
-    for (const p of session.panes) {
-        lines.push(statusRow('✓', p.name, `${p.branch}  ${c.muted('·')}  pane ${p.paneId}`));
+    for (const a of session.agents) {
+        lines.push(statusRow('✓', a.paneName, `${a.branch}  ${c.muted('·')}  ${a.state}`));
     }
     lines.push('');
     lines.push(statusBadge('green', 'choir live', [
-        'each pane is an autonomous Claude in its own worktree',
-        'advisory radar online — choir_radar before touching shared areas',
+        `▶ ${session.agents.length} agents running headless · watch the radar at /choir`,
+        'a pane only opens when one needs you',
+        `max ${cap} active at once`,
     ]));
     lines.push('');
     log(lines.join('\n') + '\n');
+    const runLoop = deps.runLoopImpl ?? runConductorLoop;
+    if (capturedHub) {
+        runLoop({ agents: session.agents, hub: capturedHub, cap }, {
+            timerImpl: (cb, ms) => {
+                const t = setInterval(() => void cb(), ms);
+                t.unref?.();
+                return () => clearInterval(t);
+            },
+            now: () => Date.now(),
+            planTick: planConductorTick,
+            summonPaneImpl: (a) => summonPane(a),
+            dematerializeImpl: (a) => dematerialize(a),
+            spawnHeadlessImpl: makeRespawnHeadless(session.tokenForTest),
+            log,
+            onSigint: (handler) => process.once('SIGINT', () => void handler()),
+        });
+    }
     return 0;
 }
+export function buildRespawnEnv(sessionToken, agent) {
+    return {
+        ...process.env,
+        CHOIR_SESSION_TOKEN: sessionToken,
+        CHOIR_PANE_ID: agent.branch,
+        CHOIR_PANE_NONCE: agent.nonce,
+    };
+}
+export function makeRespawnHeadless(sessionToken, spawnImpl) {
+    return (agent) => {
+        const safeWt = agent.worktreePath.replace(/'/g, `'\\''`);
+        const command = `unset ANTHROPIC_API_KEY; unset ANTHROPIC_AUTH_TOKEN; ` +
+            `cd '${safeWt}' && claude --resume '${agent.resumeSessionId.replace(/'/g, `'\\''`)}'`;
+        const env = buildRespawnEnv(sessionToken, agent);
+        if (spawnImpl) {
+            const { pid } = spawnImpl({ command, cwd: agent.worktreePath, env });
+            agent.headlessPid = typeof pid === 'number' ? pid : null;
+            return;
+        }
+        void import('node:child_process').then(({ spawn }) => {
+            const proc = spawn('bash', ['-c', command], {
+                cwd: agent.worktreePath,
+                env,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            agent.headlessPid = typeof proc.pid === 'number' ? proc.pid : null;
+        });
+    };
+}

package/dist/commands/daemon.js

@@ -3,6 +3,8 @@ import { loadAuth, getActiveProfile } from '../lib/auth.js';
 import * as activations from '../lib/activations.js';
 import { fireActivation, makeHeadlessSpawner, } from '../lib/activations.js';
 import { checkCompletions } from '../lib/completion.js';
+import { emitRunStage as defaultEmitRunStage, startRunHeartbeat as defaultStartRunHeartbeat, RUN_STAGE, } from '../lib/choir/run-progress.js';
+import { groupBySession, launchCoordinatedSet, } from '../lib/choir/coordinated-set.js';
 import { applyPaneTitle } from '../lib/pane-title.js';
 import { installService, uninstallService } from '../lib/service.js';
 import { detectTmuxSession, inTmuxSession, nonbotTmuxOptOut, resolveTerminal, } from '../lib/terminal.js';
@@ -131,8 +133,40 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
         applyNonbotTmuxConfig({ spawnSync: deps.spawnSync });
     }
     const seen = new Set();
+    const launchedSessions = new Set();
+    const launchCoordinatedSetFn = deps.launchCoordinatedSet ?? launchCoordinatedSet;
     const trackedPanes = new Map();
     const killedByStop = new Set();
+    const emitRunStageFn = deps.emitRunStage ?? defaultEmitRunStage;
+    const startRunHeartbeatFn = deps.startRunHeartbeat ?? defaultStartRunHeartbeat;
+    const runHeartbeats = new Map();
+    const safeEmit = (activationId, stage, metrics) => {
+        try {
+            void Promise.resolve(emitRunStageFn({ baseUrl: auth.baseUrl, pat: auth.pat, activationId, stage, metrics })).catch(() => { });
+        }
+        catch {
+        }
+    };
+    const stopHeartbeat = (activationId, reason) => {
+        const hb = runHeartbeats.get(activationId);
+        if (!hb)
+            return;
+        runHeartbeats.delete(activationId);
+        try {
+            void Promise.resolve(hb.stop(reason)).catch(() => { });
+        }
+        catch {
+        }
+    };
+    const seqMetrics = (act) => {
+        const p = (act.payload ?? {});
+        const m = {};
+        if (typeof p.storyIndex === 'number')
+            m.storyIndex = p.storyIndex;
+        if (typeof p.storyTotal === 'number')
+            m.storyTotal = p.storyTotal;
+        return m.storyIndex !== undefined || m.storyTotal !== undefined ? m : undefined;
+    };
     const trackedMeta = new Map();
     let doneCount = 0;
     let failedCount = 0;
@@ -150,6 +184,8 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
     if (!options.oneShot) {
         sigHandler = () => {
             running = false;
+            for (const id of [...runHeartbeats.keys()])
+                stopHeartbeat(id);
             log('\n' + statusRow('✓', 'daemon stopped', 'Ctrl-C received') + '\n');
             process.exit(0);
         };
@@ -243,15 +279,79 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                         killedByStop.add(k.activationId);
                         const meta = trackedMeta.get(k.activationId);
                         retitlePane('stopping', k.tmuxPaneId, meta?.story ?? '');
+                        safeEmit(k.activationId, RUN_STAGE.STOPPED);
+                        stopHeartbeat(k.activationId);
                     }
                     void activations.executePendingKills(pendingKills, auth.baseUrl, auth.pat);
                 }
                 const acts = body?.activations ?? [];
-                for (const act of acts) {
+                const { singletons, sets } = groupBySession(acts);
+                for (const [choirSessionId, setActs] of sets) {
+                    for (const a of setActs)
+                        if (a?.id)
+                            seen.add(a.id);
+                    if (launchedSessions.has(choirSessionId))
+                        continue;
+                    launchedSessions.add(choirSessionId);
+                    firedThisPoll = true;
+                    for (const a of setActs) {
+                        if (a.kind === 'real')
+                            safeEmit(a.id, RUN_STAGE.LAUNCHING, seqMetrics(a));
+                    }
+                    try {
+                        const result = await launchCoordinatedSetFn({
+                            choirSessionId,
+                            activations: setActs,
+                            auth,
+                            deps: deps.coordinatedSetDeps,
+                        });
+                        for (const pane of result.panes) {
+                            const a = setActs.find((x) => x.id === pane.activationId);
+                            const metrics = a && a.kind === 'real' ? seqMetrics(a) : undefined;
+                            if (pane.tmuxPaneId) {
+                                trackedPanes.set(pane.activationId, pane.tmuxPaneId);
+                                trackedMeta.set(pane.activationId, {
+                                    story: pane.paneName,
+                                    provider: pane.provider,
+                                    startedAt: Date.now(),
+                                    paneId: pane.tmuxPaneId,
+                                });
+                                retitlePane('running', pane.tmuxPaneId, pane.paneName);
+                            }
+                            safeEmit(pane.activationId, RUN_STAGE.AGENT_STARTED, metrics);
+                            try {
+                                const hb = startRunHeartbeatFn({
+                                    baseUrl: auth.baseUrl,
+                                    pat: auth.pat,
+                                    activationId: pane.activationId,
+                                    furthestStage: RUN_STAGE.AGENT_STARTED,
+                                    lastEventSeq: 0,
+                                });
+                                runHeartbeats.set(pane.activationId, hb);
+                            }
+                            catch {
+                            }
+                        }
+                        emitSummary();
+                    }
+                    catch (e) {
+                        errLog(statusRow('⚠', 'coordinated set failed', e.message, { stream: process.stderr }) + '\n');
+                        for (const a of setActs) {
+                            if (a.kind === 'real')
+                                safeEmit(a.id, RUN_STAGE.FAILED, seqMetrics(a));
+                            failedCount++;
+                        }
+                        emitSummary();
+                    }
+                }
+                for (const act of singletons) {
                     if (!act?.id || seen.has(act.id))
                         continue;
                     seen.add(act.id);
                     firedThisPoll = true;
+                    const metrics = act.kind === 'real' ? seqMetrics(act) : undefined;
+                    if (act.kind === 'real')
+                        safeEmit(act.id, RUN_STAGE.LAUNCHING, metrics);
                     const outcome = await fireActivation(auth, act, deps, log, errLog);
                     if (outcome.status === 'launched' && outcome.kind === 'real' && outcome.tmuxPaneId) {
                         trackedPanes.set(outcome.id, outcome.tmuxPaneId);
@@ -269,10 +369,25 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                             paneId: outcome.tmuxPaneId,
                         });
                         retitlePane('running', outcome.tmuxPaneId, story);
+                        safeEmit(act.id, RUN_STAGE.AGENT_STARTED, metrics);
+                        try {
+                            const hb = startRunHeartbeatFn({
+                                baseUrl: auth.baseUrl,
+                                pat: auth.pat,
+                                activationId: outcome.id,
+                                furthestStage: RUN_STAGE.AGENT_STARTED,
+                                lastEventSeq: 0,
+                            });
+                            runHeartbeats.set(outcome.id, hb);
+                        }
+                        catch {
+                        }
                         emitSummary();
                     }
                     else if (outcome.status === 'failed') {
                         failedCount++;
+                        if (act.kind === 'real')
+                            safeEmit(act.id, RUN_STAGE.FAILED, metrics);
                         emitSummary();
                     }
                 }
@@ -308,6 +423,8 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                         for (const id of reported) {
                             doneCount++;
                             trackedMeta.delete(id);
+                            safeEmit(id, RUN_STAGE.FINISHED);
+                            stopHeartbeat(id, 'daemon-exit');
                         }
                         emitSummary();
                     }

package/dist/lib/choir/conductor.js

@@ -0,0 +1,92 @@
+import { deriveHealth, shouldEscalateToPush } from './health.js';
+export const DEFAULT_MAX_ACTIVE_AGENTS = 2;
+const ACTIVE_STATES = new Set(['headless', 'summoned']);
+const TERMINAL_STATES = new Set(['complete', 'failed']);
+function isActive(state) {
+    return ACTIVE_STATES.has(state);
+}
+function isTerminal(state) {
+    return TERMINAL_STATES.has(state);
+}
+function needsHuman(health, signals, args) {
+    if (signals.crashed)
+        return 'agent-crashed';
+    if (health === 'awaiting-input')
+        return 'awaiting-input';
+    const escalate = shouldEscalateToPush(health, {
+        thresholds: args.thresholds,
+        paneTotal: args.total,
+        liveNonTerminalPanes: args.activeCount,
+        slowDwellMs: 0,
+    });
+    if (escalate)
+        return health === 'slow' ? 'stalled' : health;
+    return null;
+}
+export function planConductorTick(args) {
+    const { agents, signalsByPane, now, thresholds } = args;
+    const cap = typeof args.cap === 'number' && args.cap >= 0 ? args.cap : DEFAULT_MAX_ACTIVE_AGENTS;
+    let activeCount = agents.reduce((n, a) => (isActive(a.state) ? n + 1 : n), 0);
+    const totalNonTerminal = agents.reduce((n, a) => (isTerminal(a.state) ? n : n + 1), 0);
+    const decisions = [];
+    for (const a of agents) {
+        if (isTerminal(a.state)) {
+            decisions.push({ paneName: a.paneName, action: 'noop', reason: a.state });
+            continue;
+        }
+        if (a.state === 'pending')
+            continue;
+        const signals = signalsByPane[a.paneName];
+        if (!signals) {
+            decisions.push({ paneName: a.paneName, action: 'noop' });
+            continue;
+        }
+        const { state: health } = deriveHealth({
+            now,
+            thresholds,
+            lastToolUse: signals.lastToolUse,
+            lastGitDelta: signals.lastGitDelta,
+            lastPaneActivity: signals.lastPaneActivity,
+            awaitingInput: signals.awaitingInput,
+            crashed: signals.crashed,
+            churning: signals.churning,
+            loopFlips: signals.loopFlips,
+            commitsAdvancedInWindow: signals.commitsAdvancedInWindow,
+            expectSlow: signals.expectSlow,
+        });
+        const reason = needsHuman(health, signals, {
+            now,
+            thresholds,
+            activeCount,
+            total: totalNonTerminal,
+        });
+        if (a.state === 'headless') {
+            if (reason) {
+                decisions.push({ paneName: a.paneName, action: 'summon', reason });
+            }
+            else {
+                decisions.push({ paneName: a.paneName, action: 'noop' });
+            }
+        }
+        else {
+            if (reason) {
+                decisions.push({ paneName: a.paneName, action: 'noop', reason });
+            }
+            else {
+                decisions.push({ paneName: a.paneName, action: 'dematerialize', reason: 'resolved' });
+            }
+        }
+    }
+    for (const a of agents) {
+        if (a.state !== 'pending')
+            continue;
+        if (activeCount < cap) {
+            decisions.push({ paneName: a.paneName, action: 'start', reason: 'slot-free' });
+            activeCount += 1;
+        }
+        else {
+            decisions.push({ paneName: a.paneName, action: 'noop', reason: 'cap-reached' });
+        }
+    }
+    return decisions;
+}

package/dist/lib/choir/coordinated-set.js

@@ -0,0 +1,207 @@
+import nodeFs from 'node:fs';
+import nodePath from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomBytes } from 'node:crypto';
+import { assertValidName } from './names.js';
+import { addWorktree as defaultAddWorktree } from './worktree.js';
+import { createHub as defaultCreateHub } from './hub.js';
+import { PROVIDER_PROFILES } from '../command-builders.js';
+import { validateRepoPath } from '../payload-validator.js';
+const defaultFs = {
+    mkdirSync: (p, opts) => nodeFs.mkdirSync(p, opts),
+    writeFileSync: (p, data, opts) => nodeFs.writeFileSync(p, data, opts),
+};
+const MAX_PANES = 16;
+const PLAN_AUTH_GUARD = `unset ANTHROPIC_API_KEY; unset ANTHROPIC_AUTH_TOKEN`;
+function defaultRandom() {
+    return randomBytes(24).toString('hex');
+}
+function payloadOf(act) {
+    return (act?.payload ?? {});
+}
+export function choirSessionIdOf(act) {
+    const p = payloadOf(act);
+    return typeof p.choirSessionId === 'string' && p.choirSessionId.length > 0
+        ? p.choirSessionId
+        : null;
+}
+export function groupBySession(activations) {
+    const singletons = [];
+    const sets = new Map();
+    for (const act of activations) {
+        const sid = choirSessionIdOf(act);
+        if (sid === null) {
+            singletons.push(act);
+            continue;
+        }
+        const arr = sets.get(sid);
+        if (arr)
+            arr.push(act);
+        else
+            sets.set(sid, [act]);
+    }
+    return { singletons, sets };
+}
+function resolveProvider(act) {
+    const raw = payloadOf(act).provider;
+    if (typeof raw === 'string' && raw in PROVIDER_PROFILES)
+        return raw;
+    return 'claude';
+}
+function deriveSessionName(choirSessionId) {
+    let s = String(choirSessionId)
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 31);
+    if (s.length === 0 || !/^[a-z0-9]/.test(s))
+        s = `s${s}`.slice(0, 31);
+    return assertValidName(s, 'session');
+}
+function buildMcpJson() {
+    return JSON.stringify({
+        mcpServers: {
+            choir: {
+                command: 'nonbot',
+                args: ['choir-mcp'],
+                env: {
+                    CHOIR_SESSION_TOKEN: '',
+                    CHOIR_PANE_NONCE: '',
+                    CHOIR_PANE_ID: '',
+                },
+            },
+        },
+    }, null, 2);
+}
+function buildPaneCommand(worktreePath, provider, storyTitle) {
+    const cli = PROVIDER_PROFILES[provider].realCli;
+    const safeWt = worktreePath.replace(/'/g, `'\\''`);
+    const title = storyTitle.replace(/[\r\n]+/g, ' ');
+    const prompt = `You are one pane of a coordinated set. Read .choir/ for your brief, ` +
+        `use the choir MCP radar to coordinate, then work on: ${title}`;
+    const safePrompt = prompt.replace(/'/g, `'\\''`);
+    return `${PLAN_AUTH_GUARD}; cd '${safeWt}' && ${cli} '${safePrompt}'`;
+}
+export async function launchCoordinatedSet(args) {
+    const { choirSessionId, activations, auth } = args;
+    const deps = args.deps ?? {};
+    const fsImpl = deps.fsImpl ?? defaultFs;
+    const randomImpl = deps.randomImpl ?? defaultRandom;
+    const addWorktreeImpl = deps.addWorktreeImpl ?? defaultAddWorktree;
+    const createHubImpl = deps.createHubImpl ?? defaultCreateHub;
+    const spawnPane = deps.spawnPaneImpl ?? resolveDefaultSpawnPane(auth);
+    if (!Array.isArray(activations) || activations.length === 0) {
+        throw new Error('coordinated set has no activations');
+    }
+    if (activations.length > MAX_PANES) {
+        throw new Error(`coordinated set exceeds ${MAX_PANES} panes`);
+    }
+    const sessionName = deriveSessionName(choirSessionId);
+    const repoRootRaw = typeof payloadOf(activations[0]).repoPath === 'string'
+        ? payloadOf(activations[0]).repoPath
+        : (activations[0].repoPath ?? '');
+    if (!repoRootRaw)
+        throw new Error('coordinated set activation has no repoPath');
+    const repoRoot = validateRepoPath(repoRootRaw);
+    for (const act of activations) {
+        const p = payloadOf(act);
+        const actRepo = typeof p.repoPath === 'string' ? p.repoPath : (act.repoPath ?? '');
+        if (actRepo !== repoRoot) {
+            throw new Error('coordinated set spans multiple repoPaths — a set must be one repo');
+        }
+    }
+    const token = randomImpl();
+    if (typeof token !== 'string' || token.length === 0) {
+        throw new Error('coordinated set token minting produced an empty token');
+    }
+    const sessionId = `choir_${sessionName}_${token.slice(0, 8)}`;
+    const baseBranch = 'HEAD';
+    const hub = createHubImpl({
+        sessionId,
+        repoRoot,
+        baseBranch,
+        token,
+        baseUrl: auth.baseUrl,
+        pat: auth.pat,
+        autoTimers: true,
+    });
+    hub.start();
+    const panes = [];
+    let paneIndex = 0;
+    for (const act of activations) {
+        paneIndex += 1;
+        const paneName = assertValidName(`pane${paneIndex}`, 'pane');
+        const provider = resolveProvider(act);
+        const story = typeof payloadOf(act).storyTitle === 'string'
+            ? payloadOf(act).storyTitle
+            : `${act.kind} activation`;
+        const { worktreePath, branch } = addWorktreeImpl({
+            repoRoot,
+            sessionName,
+            paneName,
+            baseBranch,
+        });
+        const nonce = randomImpl();
+        const mcpPath = nodePath.join(worktreePath, '.mcp.json');
+        fsImpl.mkdirSync(worktreePath, { recursive: true });
+        fsImpl.writeFileSync(mcpPath, buildMcpJson(), { mode: 0o600 });
+        hub.dispatch({
+            type: 'register',
+            paneId: branch,
+            name: paneName,
+            branch,
+            worktreePath,
+            nonce,
+            ts: Date.now(),
+        });
+        const command = buildPaneCommand(worktreePath, provider, story);
+        const scriptPath = nodePath.join(tmpdir(), `nonbot-choir-${sessionId}-${paneName}.sh`);
+        const scriptBody = `#!/bin/bash\n${command}\n`;
+        fsImpl.writeFileSync(scriptPath, scriptBody, { mode: 0o700 });
+        const env = {
+            ...process.env,
+            CHOIR_SESSION_TOKEN: token,
+            CHOIR_PANE_NONCE: nonce,
+            CHOIR_PANE_ID: branch,
+            NONBOT_PAT: auth.pat,
+            NONBOT_RUN_ID: act.id,
+            NONBOT_BASE_URL: auth.baseUrl,
+            NONBOT_ROLE: 'lead',
+        };
+        const spawnResult = (await spawnPane({ command, scriptPath, cwd: worktreePath, env, provider, activationId: act.id, paneName })) ??
+            {};
+        const tmuxPaneId = spawnResult.tmuxPaneId ?? null;
+        panes.push({
+            activationId: act.id,
+            paneName,
+            branch,
+            worktreePath,
+            provider,
+            tmuxPaneId,
+        });
+    }
+    return { choirSessionId, sessionId, repoRoot, hub, panes, tokenForTest: token };
+}
+function resolveDefaultSpawnPane(_auth) {
+    return async (a) => {
+        const { spawn } = await import('node:child_process');
+        const proc = spawn('tmux', ['new-window', '-P', '-F', '#{pane_id}', '-n', a.paneName, `bash ${shArg(a.scriptPath)}`], {
+            cwd: a.cwd,
+            env: a.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        return await new Promise((resolve) => {
+            const chunks = [];
+            proc.stdout?.on('data', (c) => chunks.push(c));
+            proc.on('error', () => resolve({ tmuxPaneId: null }));
+            proc.on('exit', () => {
+                const out = Buffer.concat(chunks).toString('utf-8').trim().split(/\s+/)[0] ?? '';
+                resolve({ tmuxPaneId: /^%\d+$/.test(out) ? out : null });
+            });
+        });
+    };
+}
+function shArg(s) {
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+}

package/dist/lib/choir/launcher.js

@@ -1,4 +1,3 @@
-import { spawnSync as nodeSpawnSync } from 'node:child_process';
 import nodeFs from 'node:fs';
 import nodePath from 'node:path';
 import { randomBytes } from 'node:crypto';
@@ -13,32 +12,33 @@ const MAX_PANES = 16;
 function defaultRandom() {
     return randomBytes(24).toString('hex');
 }
-function buildPaneShell(worktreePath, briefRelPath) {
+const PLAN_AUTH_GUARD = `unset ANTHROPIC_API_KEY; unset ANTHROPIC_AUTH_TOKEN`;
+function buildHeadlessCommand(worktreePath, briefRelPath) {
     const safeWt = worktreePath.replace(/'/g, `'\\''`);
     const safeBrief = briefRelPath.replace(/'/g, `'\\''`);
     const prompt = `Read ${safeBrief} (your Choir brief) and start work in this worktree.`;
     const safePrompt = prompt.replace(/'/g, `'\\''`);
-    return (`cd '${safeWt}' && claude '${safePrompt}'` +
-        `; printf '\\n%s\\n' 'Choir pane finished — press enter to close'` +
-        `; read _` +
-        `; tmux kill-pane`);
+    return `${PLAN_AUTH_GUARD}; cd '${safeWt}' && claude '${safePrompt}'`;
 }
-function spawnPane(spawnImpl, shell, env) {
-    const r = spawnImpl('tmux', ['split-window', '-P', '-F', '#{pane_id}', shell, ';', 'select-layout', 'tiled'], {
-        encoding: 'utf-8',
-        timeout: 15_000,
-        windowsHide: true,
-        env,
-    });
-    if (r.status !== 0) {
-        throw new Error('choir pane spawn failed (tmux split-window)');
-    }
-    const out = typeof r.stdout === 'string' ? r.stdout : '';
-    const first = out.trim().split(/\s+/)[0] ?? '';
-    if (!/^%\d+$/.test(first)) {
-        throw new Error('choir pane spawn produced no pane id');
-    }
-    return first;
+function resolveDefaultSpawnHeadless() {
+    return (args) => {
+        void import('node:child_process').then(({ spawn }) => {
+            const proc = spawn('bash', ['-c', args.command], {
+                cwd: args.cwd,
+                env: args.env,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            const prefix = (chunk, sink) => {
+                const text = chunk.toString('utf-8');
+                for (const line of text.split('\n')) {
+                    if (line.length > 0)
+                        sink.write(`[choir:${args.paneName}] ${line}\n`);
+                }
+            };
+            proc.stdout?.on('data', (c) => prefix(c, process.stdout));
+            proc.stderr?.on('data', (c) => prefix(c, process.stderr));
+        });
+    };
 }
 function buildMcpJson() {
     const obj = {
@@ -57,7 +57,8 @@ function buildMcpJson() {
     return JSON.stringify(obj, null, 2);
 }
 export function launchChoir(args) {
-    const { repoRoot, sessionName: rawSession, paneCount, baseBranch: rawBase, joinMode, spawnImpl = nodeSpawnSync, fsImpl = defaultFs, randomImpl = defaultRandom, addWorktreeImpl = defaultAddWorktree, startHub, } = args;
+    const { repoRoot, sessionName: rawSession, paneCount, baseBranch: rawBase, joinMode, spawnHeadlessImpl, fsImpl = defaultFs, randomImpl = defaultRandom, addWorktreeImpl = defaultAddWorktree, startHub, } = args;
+    const spawnHeadless = spawnHeadlessImpl ?? resolveDefaultSpawnHeadless();
     const sessionName = assertValidName(rawSession, 'session');
     assertValidBranch(rawBase, 'base branch');
     const baseBranch = rawBase;
@@ -72,7 +73,7 @@ export function launchChoir(args) {
         throw new Error('choir token minting produced an empty token');
     }
     const sessionId = `choir_${sessionName}_${token.slice(0, 8)}`;
-    const panes = [];
+    const agents = [];
     for (const paneName of paneNames) {
         const { worktreePath, branch } = addWorktreeImpl({
             repoRoot,
@@ -92,15 +93,25 @@ export function launchChoir(args) {
         }
         else {
         }
-        const shell = buildPaneShell(worktreePath, briefRelPath);
+        const command = buildHeadlessCommand(worktreePath, briefRelPath);
         const childEnv = {
             ...process.env,
             CHOIR_SESSION_TOKEN: token,
             CHOIR_PANE_NONCE: nonce,
             CHOIR_PANE_ID: branch,
         };
-        const paneId = spawnPane(spawnImpl, shell, childEnv);
-        panes.push({ name: paneName, paneId, branch, worktreePath });
+        spawnHeadless({ command, cwd: worktreePath, env: childEnv, paneName });
+        agents.push({
+            paneName,
+            worktreePath,
+            branch,
+            resumeSessionId: branch,
+            nonce,
+            provider: 'claude',
+            state: 'headless',
+            tmuxPaneId: null,
+            headlessPid: null,
+        });
     }
     if (startHub !== false) {
         const start = startHub ?? resolveDefaultStartHub();
@@ -112,7 +123,7 @@ export function launchChoir(args) {
         repoRoot,
         baseBranch,
         joinMode,
-        panes,
+        agents,
         tokenForTest: token,
     };
 }

package/dist/lib/choir/materialize.js

@@ -0,0 +1,97 @@
+import { spawnSync as nodeSpawnSync } from 'node:child_process';
+import { isValidBranch, isValidPaneId } from './names.js';
+import { shellQuoteSingle } from '../command-builders.js';
+const defaultKill = (pid, signal) => {
+    try {
+        return process.kill(pid, signal);
+    }
+    catch {
+        return false;
+    }
+};
+const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const PRESS_ENTER_TRAILER = `; printf '\\n%s\\n' 'Resolved — press enter to send this agent back headless'` +
+    `; read _` +
+    `; tmux kill-pane`;
+function buildResumeInvocation(agent) {
+    const sid = shellQuoteSingle(agent.resumeSessionId);
+    switch (agent.provider) {
+        case 'claude':
+            return `claude --resume ${sid}`;
+        case 'codex': {
+            const brief = shellQuoteSingle('You were working in this git worktree — inspect `git status` / `git log` to see your state, then continue.');
+            return `codex ${brief}`;
+        }
+        case 'gemini-cli': {
+            const brief = shellQuoteSingle('You were working in this git worktree — inspect `git status` / `git log` to see your state, then continue.');
+            return `gemini ${brief}`;
+        }
+        default: {
+            const _never = agent.provider;
+            throw new Error(`choir materialize: unknown provider`);
+        }
+    }
+}
+function buildResumeShell(agent) {
+    const safeWt = shellQuoteSingle(agent.worktreePath);
+    const invocation = buildResumeInvocation(agent);
+    return (`unset ANTHROPIC_API_KEY` +
+        `; unset ANTHROPIC_AUTH_TOKEN` +
+        `; cd ${safeWt} && ${invocation}` +
+        PRESS_ENTER_TRAILER);
+}
+const SHELL_UNSAFE_RE = /[\n\r\0;`$"\\]/;
+function assertSafeWorktreePath(p) {
+    if (typeof p !== 'string' || p.length === 0 || p.length > 1024 || SHELL_UNSAFE_RE.test(p)) {
+        throw new Error('choir materialize: invalid worktree path');
+    }
+}
+export async function summonPane(agent, deps = {}) {
+    const spawnImpl = deps.spawnImpl ?? nodeSpawnSync;
+    const killImpl = deps.killImpl ?? defaultKill;
+    const sleepImpl = deps.sleepImpl ?? defaultSleep;
+    const graceMs = deps.graceMs ?? 2000;
+    assertSafeWorktreePath(agent.worktreePath);
+    if (!isValidBranch(agent.branch)) {
+        throw new Error('choir materialize: invalid branch');
+    }
+    if (typeof agent.headlessPid === 'number') {
+        const pid = agent.headlessPid;
+        killImpl(pid, 'SIGINT');
+        await sleepImpl(graceMs);
+        killImpl(pid, 'SIGKILL');
+    }
+    const shell = buildResumeShell(agent);
+    const r = spawnImpl('tmux', ['split-window', '-P', '-F', '#{pane_id}', shell, ';', 'select-layout', 'tiled'], {
+        encoding: 'utf-8',
+        timeout: 15_000,
+        windowsHide: true,
+    });
+    if (r.status !== 0) {
+        throw new Error('choir summon pane spawn failed (tmux split-window)');
+    }
+    const out = typeof r.stdout === 'string' ? r.stdout : '';
+    const first = out.trim().split(/\s+/)[0] ?? '';
+    if (!/^%\d+$/.test(first)) {
+        throw new Error('choir summon produced no pane id');
+    }
+    return first;
+}
+export async function dematerialize(agent, deps = {}) {
+    const spawnImpl = deps.spawnImpl ?? nodeSpawnSync;
+    const paneId = agent.tmuxPaneId;
+    if (paneId == null)
+        return;
+    if (!isValidPaneId(paneId)) {
+        throw new Error('choir materialize: invalid pane id');
+    }
+    try {
+        spawnImpl('tmux', ['kill-pane', '-t', paneId], {
+            encoding: 'utf-8',
+            timeout: 2000,
+            windowsHide: true,
+        });
+    }
+    catch {
+    }
+}

package/dist/lib/choir/progress-events.js

@@ -185,9 +185,10 @@ export function sanitizeForEgress(obj) {
 }
 const SECRET_RE = /\b(pat_[A-Za-z0-9_-]{4,}|sk_[A-Za-z0-9_-]{4,})/;
 const DIFF_RE = /^(diff --git |@@ |[+-]{3} )|(\n[+-])/;
-const PATH_RE = /(^|[\s'"])\/[\w.-]+\/[\w./-]+/;
+const PATH_MULTI_SEGMENT_RE = /(^|[\s'"])\/[\w.-]+\/[\w./-]+/;
+const PATH_SINGLE_SEGMENT_RE = /(^|[\s'"])\/[\w.-]{4,}/;
 function looksLikePath(s) {
-    return PATH_RE.test(s);
+    return PATH_MULTI_SEGMENT_RE.test(s) || PATH_SINGLE_SEGMENT_RE.test(s);
 }
 function looksLikeDiff(s) {
     return DIFF_RE.test(s);

package/dist/lib/choir/run-progress.js

@@ -0,0 +1,101 @@
+import { makeEvent, sanitizeForEgress, assertNoForbiddenFields } from './progress-events.js';
+const X_REQUESTED_WITH = 'ConradPM-Native';
+const HEARTBEAT_INTERVAL_MS = 30_000;
+export const RUN_STAGE = Object.freeze({
+    QUEUED: 'queued',
+    ACCEPTED: 'accepted',
+    LAUNCHING: 'launching',
+    AGENT_STARTED: 'agent-started',
+    WORKING: 'working',
+    FINISHED: 'finished',
+    FAILED: 'failed',
+    STOPPED: 'stopped',
+});
+export function runLifecycleStage(phase) {
+    return phase;
+}
+export async function emitRunStage(opts) {
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const now = opts.now ?? Date.now;
+    let body;
+    try {
+        const ts = Math.floor(now());
+        const event = makeEvent({
+            sessionId: opts.activationId,
+            engine: 'run',
+            paneId: null,
+            stage: opts.stage,
+            summary: opts.summary ?? '',
+            ts,
+            metrics: opts.metrics,
+            refs: opts.refs,
+        }, { now, random: opts.randomImpl });
+        const safe = sanitizeForEgress(event);
+        assertNoForbiddenFields(safe);
+        body = JSON.stringify({ events: [safe] });
+    }
+    catch {
+        return;
+    }
+    try {
+        await fetchImpl(`${opts.baseUrl}/api/cli/choir/events`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${opts.pat}`,
+                'Content-Type': 'application/json',
+                'X-Requested-With': X_REQUESTED_WITH,
+            },
+            body,
+        });
+    }
+    catch {
+    }
+}
+const defaultTimerImpl = {
+    setInterval: (h, ms) => setInterval(h, ms),
+    clearInterval: (handle) => clearInterval(handle),
+};
+export function startRunHeartbeat(opts) {
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const timerImpl = opts.timerImpl ?? defaultTimerImpl;
+    const beat = async (reason) => {
+        const body = {
+            sessionId: opts.activationId,
+            paneCount: 1,
+            furthestStage: opts.furthestStage,
+            lastEventSeq: opts.lastEventSeq,
+        };
+        if (reason)
+            body.last_beat_reason = reason;
+        try {
+            await fetchImpl(`${opts.baseUrl}/api/cli/choir/heartbeat`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${opts.pat}`,
+                    'Content-Type': 'application/json',
+                    'X-Requested-With': X_REQUESTED_WITH,
+                },
+                body: JSON.stringify(body),
+            });
+        }
+        catch {
+        }
+    };
+    const handle = timerImpl.setInterval(() => {
+        void beat();
+    }, HEARTBEAT_INTERVAL_MS);
+    if (handle && typeof handle.unref === 'function') {
+        ;
+        handle.unref();
+    }
+    let stopped = false;
+    return {
+        async stop(reason) {
+            if (stopped)
+                return;
+            stopped = true;
+            timerImpl.clearInterval(handle);
+            await beat(reason ?? 'daemon-exit');
+        },
+    };
+}

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.7.1';
+export const VERSION = '0.9.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nonbot/cli",
-  "version": "0.7.1",
+  "version": "0.9.0",
   "type": "module",
   "description": "The local host for non.bot ▶ Run — opens a terminal on your machine and starts the work in your linked repo.",
   "license": "UNLICENSED",