@nonbot/cli 0.9.0 → 0.9.1

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,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 { 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';
@@ -13,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));
@@ -132,11 +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();
@@ -197,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}`,
@@ -247,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,
             });
@@ -332,10 +391,13 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                             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));
@@ -353,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 ?? {});
@@ -391,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/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.9.0';
+export const VERSION = '0.9.1';

package/package.json

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