@nonbot/cli 0.8.0 → 0.9.1

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # @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.

package/dist/commands/choir.js

@@ -25,6 +25,26 @@ export function buildStartHub(repoRoot, auth) {
         return hub;
     };
 }
+export function registerAgentsWithHub(hub, agents, now = Date.now) {
+    const dispatch = hub?.dispatch;
+    if (typeof dispatch !== 'function')
+        return;
+    for (const a of agents) {
+        try {
+            dispatch.call(hub, {
+                type: 'register',
+                paneId: a.branch,
+                name: a.paneName,
+                branch: a.branch,
+                worktreePath: a.worktreePath,
+                nonce: a.nonce,
+                ts: now(),
+            });
+        }
+        catch {
+        }
+    }
+}
 const TERMINAL_STATES = new Set(['complete', 'failed']);
 function buildSignals(agents, panes, now) {
     const byName = new Map();
@@ -227,6 +247,9 @@ export async function runChoirCommand(args = [], deps = {}) {
         errLog(`✗ choir launch failed: ${e.message}\n`);
         return 1;
     }
+    if (capturedHub) {
+        registerAgentsWithHub(capturedHub, session.agents);
+    }
     const cap = DEFAULT_MAX_ACTIVE_AGENTS;
     const lines = [];
     lines.push(header('nonbot choir', `session ${session.sessionName}  ·  v${VERSION}`));

package/dist/commands/daemon.js

@@ -3,7 +3,9 @@ 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 { deliverAnsweredPrompts } from '../lib/run-prompt.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';
@@ -12,6 +14,53 @@ import { errorBlock, statusRow, daemonOpener, daemonCloser, pollTick, activation
 export const POLL_FAST_MS = 2000;
 export const POLL_MAX_MS = 30000;
 export const POLL_INTERVAL_MS = POLL_FAST_MS;
+const TERMINAL_KIND_BY_PROFILE_ID = {
+    'terminal': 'terminal.app',
+    'iterm': 'iterm',
+    'iterm-tab': 'iterm',
+    'wezterm': 'wezterm',
+    'kitty': 'kitty',
+    'alacritty': 'alacritty',
+    'gnome-terminal': 'gnome-terminal',
+};
+export function terminalKindForProfile(profile) {
+    if (!profile)
+        return 'headless';
+    return TERMINAL_KIND_BY_PROFILE_ID[profile.id] ?? profile.id;
+}
+export function probeTerminalLaunchable(profile, spawnSyncImpl = nodeSpawnSync) {
+    if (!profile)
+        return true;
+    let cmd;
+    try {
+        cmd = profile.launch('/tmp/nonbot-launchable-probe').cmd;
+    }
+    catch {
+        return true;
+    }
+    try {
+        const finder = process.platform === 'win32' ? 'where' : 'which';
+        const probe = spawnSyncImpl(finder, [cmd], { encoding: 'utf-8', timeout: 1000, windowsHide: true });
+        if (typeof probe.status === 'number' && probe.status !== 0)
+            return false;
+        return true;
+    }
+    catch {
+        return true;
+    }
+}
+export const LAST_FAILURE_REASON_MAX = 256;
+export function sanitizeFailureReason(reason) {
+    if (typeof reason !== 'string')
+        return null;
+    const cleaned = reason
+        .replace(/[^\x20-\x7e]+/g, ' ')
+        .replace(/ {2,}/g, ' ')
+        .trim();
+    if (!cleaned)
+        return null;
+    return cleaned.slice(0, LAST_FAILURE_REASON_MAX);
+}
 export function applyNonbotTmuxConfig(deps = {}) {
     const spawnSync = deps.spawnSync ?? nodeSpawnSync;
     const stdoutWrite = deps.stdoutWrite ?? ((s) => process.stdout.write(s));
@@ -131,9 +180,19 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
     if (tmuxSessionName) {
         applyNonbotTmuxConfig({ spawnSync: deps.spawnSync });
     }
+    const resolveTerminalFn = deps.resolveTerminal ?? resolveTerminal;
+    const resolvedTerminalProfile = headless ? null : resolveTerminalFn(undefined);
+    const terminalKind = terminalKindForProfile(resolvedTerminalProfile);
+    const probeLaunchable = deps.probeTerminalLaunchable
+        ?? ((p) => probeTerminalLaunchable(p));
+    const terminalLaunchable = probeLaunchable(resolvedTerminalProfile);
+    let lastFailureReason = null;
     const seen = new Set();
+    const launchedSessions = new Set();
+    const launchCoordinatedSetFn = deps.launchCoordinatedSet ?? launchCoordinatedSet;
     const trackedPanes = new Map();
     const killedByStop = new Set();
+    const injectedPrompts = new Set();
     const emitRunStageFn = deps.emitRunStage ?? defaultEmitRunStage;
     const startRunHeartbeatFn = deps.startRunHeartbeat ?? defaultStartRunHeartbeat;
     const runHeartbeats = new Map();
@@ -194,14 +253,13 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
         ? `${fixedInterval}ms fixed`
         : `${Math.round(POLL_FAST_MS / 1000)}s -> ${Math.round(maxIntervalMs / 1000)}s adaptive`;
     let terminalLabel;
-    if (headless) {
+    if (!resolvedTerminalProfile) {
         terminalLabel = 'headless (inline, no terminal window)';
     }
     else {
-        const profile = resolveTerminal(undefined);
         terminalLabel = tmuxSessionName
-            ? `${profile.displayName}  ·  tmux pane (in session '${tmuxSessionName}')`
-            : profile.displayName;
+            ? `${resolvedTerminalProfile.displayName}  ·  tmux pane (in session '${tmuxSessionName}')`
+            : resolvedTerminalProfile.displayName;
     }
     const badgeSublines = [
         `listening on ${auth.baseUrl}`,
@@ -244,9 +302,13 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                 Authorization: `Bearer ${auth.pat}`,
                 'X-Requested-With': 'ConradPM-Native',
                 'X-CLI-Version': VERSION,
+                'X-Terminal-Kind': terminalKind,
+                'X-Terminal-Launchable': terminalLaunchable ? 'true' : 'false',
             };
             if (tmuxSessionName)
                 headers['X-Tmux-Session'] = tmuxSessionName;
+            if (lastFailureReason)
+                headers['X-Last-Failure-Reason'] = lastFailureReason;
             const res = await fetchImpl(`${auth.baseUrl}/api/cli/activations/pending`, {
                 headers,
             });
@@ -282,7 +344,69 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                     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 {
+                            }
+                        }
+                        lastFailureReason = null;
+                        emitSummary();
+                    }
+                    catch (e) {
+                        errLog(statusRow('⚠', 'coordinated set failed', e.message, { stream: process.stderr }) + '\n');
+                        lastFailureReason = sanitizeFailureReason(e.message)
+                            ?? 'coordinated set launch failed';
+                        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);
@@ -291,6 +415,13 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                     if (act.kind === 'real')
                         safeEmit(act.id, RUN_STAGE.LAUNCHING, metrics);
                     const outcome = await fireActivation(auth, act, deps, log, errLog);
+                    if (outcome.status === 'launched') {
+                        lastFailureReason = null;
+                    }
+                    else {
+                        lastFailureReason = sanitizeFailureReason(outcome.errorReason)
+                            ?? 'activation launch failed';
+                    }
                     if (outcome.status === 'launched' && outcome.kind === 'real' && outcome.tmuxPaneId) {
                         trackedPanes.set(outcome.id, outcome.tmuxPaneId);
                         const p = (act.payload ?? {});
@@ -329,6 +460,20 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                         emitSummary();
                     }
                 }
+                if (trackedPanes.size > 0) {
+                    try {
+                        await deliverAnsweredPrompts({
+                            baseUrl: auth.baseUrl,
+                            pat: auth.pat,
+                            injected: injectedPrompts,
+                            fetchImpl,
+                            spawnImpl: deps.spawnSync,
+                            log,
+                        });
+                    }
+                    catch {
+                    }
+                }
                 if (trackedPanes.size > 0) {
                     const reported = await checkCompletions({
                         tracked: trackedPanes,

package/dist/commands/run-prompt-hook.js

@@ -0,0 +1,78 @@
+import { spawnSync as nodeSpawnSync } from 'node:child_process';
+import { parsePromptMenu, mintPromptId, reportPrompt, } from '../lib/run-prompt.js';
+function defaultReadStdin() {
+    if (process.stdin.isTTY)
+        return Promise.resolve('');
+    const chunks = [];
+    return new Promise((resolve) => {
+        let done = false;
+        const finish = () => {
+            if (done)
+                return;
+            done = true;
+            resolve(Buffer.concat(chunks).toString('utf-8'));
+        };
+        process.stdin.on('data', (c) => chunks.push(c));
+        process.stdin.on('end', finish);
+        process.stdin.on('error', finish);
+        setTimeout(finish, 1500);
+    });
+}
+function capturePane(paneId, spawnSync) {
+    try {
+        const r = spawnSync('tmux', ['capture-pane', '-p', '-t', paneId], {
+            encoding: 'utf-8',
+            timeout: 2000,
+            windowsHide: true,
+        });
+        return typeof r.stdout === 'string' ? r.stdout : '';
+    }
+    catch {
+        return '';
+    }
+}
+export async function runRunPromptHookCommand(deps = {}) {
+    const env = deps.env ?? process.env;
+    const spawnSync = deps.spawnSync ?? nodeSpawnSync;
+    const errLog = deps.errLog ?? ((s) => process.stderr.write(s));
+    const pat = env.NONBOT_PAT;
+    const baseUrl = env.NONBOT_BASE_URL;
+    const activationId = env.NONBOT_RUN_ID;
+    if (!pat || !baseUrl || !activationId)
+        return 0;
+    const paneId = typeof env.TMUX_PANE === 'string' && env.TMUX_PANE.length > 0 ? env.TMUX_PANE : null;
+    let message = '';
+    try {
+        const raw = await (deps.readStdin ?? defaultReadStdin)();
+        if (raw) {
+            const parsed = JSON.parse(raw);
+            if (typeof parsed?.message === 'string')
+                message = parsed.message;
+        }
+    }
+    catch {
+    }
+    const paneText = paneId ? capturePane(paneId, spawnSync) : '';
+    const parsed = parsePromptMenu(paneText, message);
+    let question = parsed.question;
+    if (!question && parsed.options.length > 0) {
+        question = 'The agent is waiting on your input.';
+    }
+    if (!question && parsed.options.length === 0)
+        return 0;
+    const promptId = mintPromptId(activationId, paneId, { question, options: parsed.options });
+    const ok = await reportPrompt({
+        baseUrl,
+        pat,
+        activationId,
+        promptId,
+        question,
+        options: parsed.options,
+        paneId,
+        fetchImpl: deps.fetchImpl,
+    });
+    if (!ok) {
+        errLog('nonbot run-prompt-hook: prompt report failed (will retry on next notification)\n');
+    }
+    return 0;
+}

package/dist/index.js

@@ -10,6 +10,7 @@ import { runLogsCommand } from './commands/logs.js';
 import { runProfilesCommand } from './commands/profiles.js';
 import { runChoirCommand } from './commands/choir.js';
 import { runChoirMcpCommand } from './commands/choir-mcp.js';
+import { runRunPromptHookCommand } from './commands/run-prompt-hook.js';
 import { setActiveProfile } from './lib/auth.js';
 import { header, kvRow, ANSI, isTTY } from './lib/output.js';
 const COMMANDS = [
@@ -38,6 +39,11 @@ const COMMANDS = [
         description: 'Per-pane Choir MCP server over stdio. Launched by .mcp.json — not run by hand.',
         run: () => runChoirMcpCommand(),
     },
+    {
+        name: 'run-prompt-hook',
+        description: "Claude Code Notification-hook handler — surfaces a Run's mid-run prompt. Not run by hand.",
+        run: () => runRunPromptHookCommand(),
+    },
     {
         name: 'status',
         description: 'Report login state + last daemon heartbeat.',

package/dist/lib/activations.js

@@ -7,13 +7,13 @@ import { resolveTerminal } from './terminal.js';
 import { getActiveProfile } from './auth.js';
 import { appendActivityLog } from './activity-log.js';
 import { activationCard, clockTime } from './output.js';
-import { buildCommandFromParams, shellQuoteSingle } from './command-builders.js';
+import { buildCommandFromParams, hookSettingsPathFor, shellQuoteSingle, } from './command-builders.js';
 import { validatePayload, validateActivationId, validateRepoPath, ValidationError, extractTerminalTheme, } from './payload-validator.js';
 export const BUILT_COMMAND_MAX_LENGTH = 32 * 1024;
 export const WIRE_COMMAND_MAX_LENGTH = 4096;
 export const COMMAND_WARN_LENGTH = 8192;
 export const COMMAND_MAX_LENGTH = 16384;
-export function resolveExecutableCommand(act, warn = (s) => console.warn(s)) {
+export function resolveExecutableCommand(act, warn = (s) => console.warn(s), opts = {}) {
     if (process.env.NONBOT_TEST_DIRECT_SHELL === '1' && act.payload) {
         const p = act.payload;
         if (p.template === 'test-direct-shell' && typeof p.shell === 'string') {
@@ -58,6 +58,13 @@ export function resolveExecutableCommand(act, warn = (s) => console.warn(s)) {
     if (typeof act.command === 'string' && act.command.length > 0 && act.command !== shell) {
         warn(`[${act.id}] note: daemon-built command differs from server-supplied command (executing daemon-built; server text is informational).\n`);
     }
+    if (opts.injectClaudeHook && params.template === 'real' && params.provider === 'claude') {
+        const withHook = {
+            ...params,
+            hookSettingsPath: hookSettingsPathFor(params.activationId),
+        };
+        shell = buildCommandFromParams(withHook);
+    }
     return { shell, params };
 }
 export function validateActivationEnvelope(act) {
@@ -201,7 +208,7 @@ async function captureSpawn(cmd, args) {
 export const _captureSpawnForTests = captureSpawn;
 export async function spawnTerminalDefault(act, auth) {
     validateActivationEnvelope(act);
-    const resolved = resolveExecutableCommand(act);
+    const resolved = resolveExecutableCommand(act, undefined, { injectClaudeHook: true });
     const ext = process.platform === 'darwin' ? 'command' : 'sh';
     const scriptPath = path.join(tmpdir(), `nonbot-${act.id}.${ext}`);
     if (path.dirname(scriptPath) !== tmpdir()) {
@@ -428,7 +435,7 @@ export async function fireActivation(auth, act, deps = {}, log = (s) => process.
             reason,
             profile: getActiveProfile(),
         });
-        return { id: act.id, status: 'failed', kind: act.kind };
+        return { id: act.id, status: 'failed', kind: act.kind, errorReason: reason };
     }
 }
 async function logActivity(entry) {

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/hub.js

@@ -260,7 +260,7 @@ export function createHub(opts) {
             }
             if (msg && msg.type === 'call') {
                 const res = handleCall(ident, String(msg.tool ?? ''), String(msg.paneId ?? ''), msg.args ?? {});
-                respond(res);
+                respond({ type: 'response', id: msg.id, ...res });
                 return;
             }
             respond({ ok: false, error: 'unknown message type' });

package/dist/lib/choir/mcp-hub-client.js

@@ -98,7 +98,7 @@ export function createHubClient(opts) {
     async function request(tool, args) {
         await ensureConnected();
         const id = nextId++;
-        const frame = { type: 'request', id, tool, args };
+        const frame = { type: 'call', id, tool, paneId: opts.paneId, args };
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 pending.delete(id);

package/dist/lib/command-builders.js

@@ -113,6 +113,27 @@ export function buildAgentsMdHeredoc(agentsMd, activationId) {
         `NONBOT_AGENTS_EOF\n` +
         `grep -qxF .nonbot/ .gitignore 2>/dev/null || printf '%s\\n' .nonbot/ >> .gitignore`);
 }
+export const RUN_PROMPT_HOOK_COMMAND = 'nonbot run-prompt-hook';
+export function hookSettingsPathFor(activationId) {
+    const safe = String(activationId || '').replace(/[^a-zA-Z0-9_-]/g, '');
+    const id = safe.length > 0 ? safe : 'unknown';
+    return `.nonbot/hook-${id}.settings.json`;
+}
+export function buildHookSettingsJson() {
+    return JSON.stringify({
+        hooks: {
+            Notification: [
+                { matcher: '', hooks: [{ type: 'command', command: RUN_PROMPT_HOOK_COMMAND }] },
+            ],
+        },
+    });
+}
+export function buildHookSettingsHeredoc(settingsPath) {
+    return (`mkdir -p .nonbot && ` +
+        `cat > ${settingsPath} <<'NONBOT_HOOK_EOF'\n` +
+        `${buildHookSettingsJson()}\n` +
+        `NONBOT_HOOK_EOF`);
+}
 export function buildDiagnosticCommand(params) {
     const trimmed = typeof params.repoPath === 'string' ? params.repoPath.trim() : '';
     const head = trimmed ? `cd ${shellQuoteSingle(trimmed)} && ` : '';
@@ -261,7 +282,16 @@ export function buildRealCommand(params) {
     }
     const briefPath = briefPathFor(params.activationId);
     const prompt = `Read ${briefPath} (your per-run brief) and start work on activation ${idLabel} — story: ${safeTitleLabel}`;
-    return `${head}${agentsMdPrefix}${bannerEmit}${cli} ${shellQuoteSingle(prompt)}`;
+    const wantHook = cli === 'claude' &&
+        typeof params.hookSettingsPath === 'string' &&
+        params.hookSettingsPath.length > 0;
+    const hookHeredocPrefix = wantHook
+        ? `${buildHookSettingsHeredoc(params.hookSettingsPath)} && `
+        : '';
+    const settingsFlag = wantHook
+        ? `--settings ${shellQuoteSingle(params.hookSettingsPath)} `
+        : '';
+    return `${head}${agentsMdPrefix}${hookHeredocPrefix}${bannerEmit}${cli} ${settingsFlag}${shellQuoteSingle(prompt)}`;
 }
 export function buildCommandFromParams(params) {
     switch (params.template) {

package/dist/lib/payload-validator.js

@@ -91,6 +91,50 @@ export function validateProvider(s) {
     }
     return s;
 }
+const TMUX_SAFE_DIRECTIVES = new Set([
+    'set', 'set-option', 'setw', 'set-window-option',
+]);
+export function isSafeTmuxConf(conf) {
+    for (const rawLine of conf.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (line === '')
+            continue;
+        if (line.startsWith('#'))
+            continue;
+        if (line.includes('#(') || line.includes('$(') || line.includes('`'))
+            return false;
+        const firstToken = line.split(/\s+/)[0];
+        if (!TMUX_SAFE_DIRECTIVES.has(firstToken))
+            return false;
+    }
+    return true;
+}
+const ITERM_FORBIDDEN_KEYS = ['Command', 'Initial Text', 'Send Text at Start'];
+export function isSafeItermProfileJson(jsonStr) {
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonStr);
+    }
+    catch {
+        return false;
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return false;
+    const root = parsed;
+    const profiles = Array.isArray(root.Profiles) ? root.Profiles : [root];
+    for (const prof of profiles) {
+        if (!prof || typeof prof !== 'object')
+            return false;
+        const p = prof;
+        for (const k of ITERM_FORBIDDEN_KEYS) {
+            if (k in p)
+                return false;
+        }
+        if ('Custom Command' in p && p['Custom Command'] !== 'No')
+            return false;
+    }
+    return true;
+}
 export function validateTerminalTheme(raw) {
     if (raw === undefined || raw === null)
         return null;
@@ -107,6 +151,10 @@ export function validateTerminalTheme(raw) {
         return null;
     if (typeof t.itermProfileJson !== 'string' || t.itermProfileJson.length > THEME_ITERM_JSON_MAX)
         return null;
+    if (!isSafeTmuxConf(t.tmuxConf))
+        return null;
+    if (!isSafeItermProfileJson(t.itermProfileJson))
+        return null;
     return {
         id: t.id,
         name: t.name,

package/dist/lib/run-prompt.js

@@ -0,0 +1,204 @@
+import { createHash } from 'node:crypto';
+import { spawnSync as nodeSpawnSync } from 'node:child_process';
+import { VERSION } from '../version.js';
+const QUESTION_MAX = 200;
+const LABEL_MAX = 80;
+const OPTIONS_MAX = 8;
+const MENU_LINE_RE = /^\s*[>❯▸▶*•]?\s*(\d{1,2})[.)]\s+(\S.*)$/;
+const GLYPH_RE = /[│┃|╭╮╯╰─━┄┈┌┐└┘├┤>❯▸▶*•]/g;
+export function parsePromptMenu(paneText, fallbackMessage = '') {
+    const fallback = (fallbackMessage || '').trim().slice(0, QUESTION_MAX);
+    if (typeof paneText !== 'string' || paneText.length === 0) {
+        return { question: fallback, options: [] };
+    }
+    const lines = paneText.split('\n');
+    let endIdx = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (MENU_LINE_RE.test(lines[i])) {
+            endIdx = i;
+            break;
+        }
+    }
+    if (endIdx === -1)
+        return { question: fallback, options: [] };
+    let startIdx = endIdx;
+    while (startIdx - 1 >= 0 && MENU_LINE_RE.test(lines[startIdx - 1]))
+        startIdx--;
+    const options = [];
+    for (let i = startIdx; i <= endIdx; i++) {
+        if (options.length >= OPTIONS_MAX)
+            break;
+        const m = lines[i].match(MENU_LINE_RE);
+        if (!m)
+            continue;
+        const index = Number.parseInt(m[1], 10);
+        if (!Number.isFinite(index))
+            continue;
+        const label = m[2].trim().slice(0, LABEL_MAX);
+        if (!label)
+            continue;
+        options.push({ index, label });
+    }
+    if (options.length === 0)
+        return { question: fallback, options: [] };
+    let question = '';
+    for (let i = startIdx - 1; i >= 0; i--) {
+        if (MENU_LINE_RE.test(lines[i]))
+            continue;
+        const t = lines[i].replace(GLYPH_RE, '').trim();
+        if (!t)
+            continue;
+        if (!/[A-Za-z0-9]/.test(t))
+            continue;
+        question = t;
+        break;
+    }
+    question = (question || fallback).slice(0, QUESTION_MAX);
+    return { question, options };
+}
+export function mintPromptId(activationId, paneId, parsed) {
+    const sig = JSON.stringify({
+        q: parsed.question,
+        o: parsed.options.map((o) => `${o.index}:${o.label}`),
+    });
+    const hash = createHash('sha256')
+        .update(`${activationId}|${paneId || ''}|${sig}`)
+        .digest('hex')
+        .slice(0, 24);
+    return `rp_${hash}`;
+}
+export async function reportPrompt(args) {
+    const fetchImpl = args.fetchImpl ?? fetch;
+    try {
+        const body = {
+            promptId: args.promptId,
+            question: args.question,
+            options: args.options,
+        };
+        if (args.paneId)
+            body.paneId = args.paneId;
+        const res = await fetchImpl(`${args.baseUrl}/api/cli/activations/${args.activationId}/prompt`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${args.pat}`,
+                'Content-Type': 'application/json',
+                'X-Requested-With': 'ConradPM-Native',
+                'X-CLI-Version': VERSION,
+            },
+            body: JSON.stringify(body),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export async function pollAnsweredPrompts(args) {
+    const fetchImpl = args.fetchImpl ?? fetch;
+    try {
+        const res = await fetchImpl(`${args.baseUrl}/api/cli/run-prompts/answered`, {
+            headers: {
+                Authorization: `Bearer ${args.pat}`,
+                'X-Requested-With': 'ConradPM-Native',
+                'X-CLI-Version': VERSION,
+            },
+        });
+        if (!res.ok)
+            return [];
+        const data = (await res.json());
+        if (!data || !Array.isArray(data.prompts))
+            return [];
+        const out = [];
+        for (const r of data.prompts) {
+            if (!r || typeof r.promptId !== 'string' || typeof r.activationId !== 'string')
+                continue;
+            out.push({
+                promptId: r.promptId,
+                activationId: r.activationId,
+                paneId: typeof r.paneId === 'string' && r.paneId.length > 0 ? r.paneId : null,
+                answerIndex: typeof r.answerIndex === 'number' ? r.answerIndex : null,
+                answerText: typeof r.answerText === 'string' ? r.answerText : null,
+                answeredAt: typeof r.answeredAt === 'number' ? r.answeredAt : undefined,
+            });
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+export async function confirmDelivered(args) {
+    const fetchImpl = args.fetchImpl ?? fetch;
+    try {
+        const res = await fetchImpl(`${args.baseUrl}/api/cli/run-prompts/${args.promptId}/delivered`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${args.pat}`,
+                'Content-Type': 'application/json',
+                'X-Requested-With': 'ConradPM-Native',
+                'X-CLI-Version': VERSION,
+            },
+            body: '{}',
+        });
+        return res.ok || res.status === 409;
+    }
+    catch {
+        return false;
+    }
+}
+export function injectAnswer(paneId, answerIndex, answerText, spawnImpl = nodeSpawnSync) {
+    const keys = answerIndex !== null && Number.isFinite(answerIndex)
+        ? String(answerIndex)
+        : answerText ?? '';
+    if (keys.length === 0)
+        return false;
+    try {
+        spawnImpl('tmux', ['send-keys', '-l', '-t', paneId, keys], {
+            encoding: 'utf-8',
+            timeout: 2000,
+            windowsHide: true,
+        });
+        spawnImpl('tmux', ['send-keys', '-t', paneId, 'Enter'], {
+            encoding: 'utf-8',
+            timeout: 2000,
+            windowsHide: true,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function deliverAnsweredPrompts(opts) {
+    const answered = await pollAnsweredPrompts({
+        baseUrl: opts.baseUrl,
+        pat: opts.pat,
+        fetchImpl: opts.fetchImpl,
+    });
+    if (answered.length === 0)
+        return [];
+    const reported = [];
+    for (const p of answered) {
+        if (!p.paneId)
+            continue;
+        if (!opts.injected.has(p.promptId)) {
+            const sent = injectAnswer(p.paneId, p.answerIndex, p.answerText, opts.spawnImpl);
+            if (!sent)
+                continue;
+            opts.injected.add(p.promptId);
+        }
+        const confirmed = await confirmDelivered({
+            baseUrl: opts.baseUrl,
+            pat: opts.pat,
+            promptId: p.promptId,
+            fetchImpl: opts.fetchImpl,
+        });
+        if (confirmed) {
+            reported.push(p.promptId);
+            opts.log?.(`✓ ${p.activationId} · answer delivered to pane ${p.paneId}\n`);
+        }
+    }
+    if (opts.injected.size > 500)
+        opts.injected.clear();
+    return reported;
+}

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.8.0';
+export const VERSION = '0.9.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nonbot/cli",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "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",
@@ -26,8 +26,8 @@
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
-    "tsx": "^4.7.0",
+    "tsx": "^4.22.4",
     "typescript": "^5.3.0",
-    "vitest": "^3.0.0"
+    "vitest": "^4.1.8"
   }
 }