@nonbot/cli 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @nonbot/cli changelog
 
+## 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
+  script now `unset`s `ANTHROPIC_API_KEY` / `ANTHROPIC_AUTH_TOKEN` before
+  launching, so a key sitting in your shell profile can't silently switch an
+  agent onto pay-per-token billing — it uses your `claude login` subscription.
+  A BYOK command that explicitly sets a key still wins (the unset only clears an
+  ambient key). Applies to both Run and Choir agents.
+
 ## 0.7.0
 
 - The per-pane Choir coordination MCP is now **bundled** as the `nonbot

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,7 @@ 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 { applyPaneTitle } from '../lib/pane-title.js';
 import { installService, uninstallService } from '../lib/service.js';
 import { detectTmuxSession, inTmuxSession, nonbotTmuxOptOut, resolveTerminal, } from '../lib/terminal.js';
@@ -133,6 +134,36 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
     const seen = new Set();
     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 +181,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,6 +276,8 @@ 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);
                 }
@@ -252,6 +287,9 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                         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 +307,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 +361,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/activations.js

@@ -215,7 +215,8 @@ export async function spawnTerminalDefault(act, auth) {
         const roleLine = `export NONBOT_ROLE='lead'`;
         envPrefix = `${patLine}\n${runIdLine}\n${baseUrlLine}\n${roleLine}\n`;
     }
-    const body = `#!/bin/bash\n${envPrefix}${resolved.shell}\n`;
+    const planAuthGuard = `unset ANTHROPIC_API_KEY\nunset ANTHROPIC_AUTH_TOKEN\n`;
+    const body = `#!/bin/bash\n${planAuthGuard}${envPrefix}${resolved.shell}\n`;
     await fs.writeFile(scriptPath, body, { mode: 0o700 });
     await fs.chmod(scriptPath, 0o700);
     const profile = resolveTerminal(act.terminal);

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/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.0';
+export const VERSION = '0.8.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nonbot/cli",
-  "version": "0.7.0",
+  "version": "0.8.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",