@nonbot/cli 0.9.4 → 0.9.6

package/dist/commands/daemon.js

@@ -3,16 +3,17 @@ 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 { loadOrCreateMachineId, resolveMachineName } from '../lib/machine.js';
+import { evictOldestToCap } from '../lib/bounded-set.js';
+import { deliverAnsweredPrompts, capturePane, parsePromptMenu, mintPromptId, } from '../lib/run-prompt.js';
+import { loadOrCreateMachineId, resolveMachineName, shortMachineId } from '../lib/machine.js';
 import { emitRunStage as defaultEmitRunStage, startRunHeartbeat as defaultStartRunHeartbeat, RUN_STAGE, } from '../lib/choir/run-progress.js';
 import { groupBySession, launchCoordinatedSet, setIsIsolated, } from '../lib/choir/coordinated-set.js';
 import { IsolatedSessionTracker, reconcileAndCleanup as defaultReconcileAndCleanup, resolveBaseBranch as defaultResolveBaseBranch, } from '../lib/choir/isolated-session.js';
-import { applyPaneTitle } from '../lib/pane-title.js';
+import { applyPaneTitle, applyPaneState } from '../lib/pane-title.js';
 import { installService, uninstallService } from '../lib/service.js';
 import { detectTmuxSession, inTmuxSession, nonbotTmuxOptOut, resolveTerminal, } from '../lib/terminal.js';
 import { VERSION } from '../version.js';
-import { errorBlock, statusRow, daemonOpener, daemonCloser, pollTick, activationCard, runSummary, formatElapsed, c, } from '../lib/output.js';
+import { errorBlock, statusRow, daemonOpener, daemonCloser, pollTick, activationCard, runSummary, formatElapsed, liveFooter, needsYouBanner, resumedLine, buildPaneBorderFormat, buildTmuxStatusLeft, buildTmuxStatusRight, c, } from '../lib/output.js';
 export const POLL_FAST_MS = 2000;
 export const POLL_MAX_MS = 30000;
 export const POLL_INTERVAL_MS = POLL_FAST_MS;
@@ -81,6 +82,21 @@ export function applyNonbotTmuxConfig(deps = {}) {
     tmux('set-option', 'set-titles', 'on');
     tmux('set-option', 'set-titles-string', 'NONBOT TMUX │ #W');
     tmux('refresh-client', '-S');
+    if (deps.chrome) {
+        const ascii = env.NONBOT_ASCII_ONLY === '1' || env.NONBOT_ASCII_ONLY === 'true';
+        tmux('set-option', '-g', 'pane-border-status', 'top');
+        tmux('set-option', '-g', 'pane-border-format', buildPaneBorderFormat({ ascii }));
+        tmux('set-option', '-g', 'pane-border-lines', 'heavy');
+        tmux('set-option', '-g', 'status', 'on');
+        tmux('set-option', '-g', 'status-interval', '5');
+        tmux('set-option', '-g', 'status-style', 'bg=#0b0b12,fg=#8b949e');
+        tmux('set-option', '-g', 'status-left-length', '60');
+        tmux('set-option', '-g', 'status-right-length', '120');
+        tmux('set-option', '-g', 'status-left', buildTmuxStatusLeft({ ascii }));
+        tmux('set-option', '-g', 'status-right', buildTmuxStatusRight({ ascii }));
+        tmux('set-option', '-g', 'window-status-current-style', 'fg=#0b0b12,bg=#4fc3f7,bold');
+        tmux('refresh-client', '-S');
+    }
     if (!stdoutIsTTY)
         return;
     const insideTmux = inTmuxSession(env);
@@ -135,7 +151,7 @@ export function maybeReexecIntoTmux(deps = {}) {
     return 'reexeced';
 }
 export async function runDaemonCommand(args = [], options = {}, deps = {}) {
-    const log = deps.log ?? ((s) => process.stdout.write(s));
+    const rawLog = deps.log ?? ((s) => process.stdout.write(s));
     const errLog = deps.errLog ?? ((s) => process.stderr.write(s));
     const fetchImpl = deps.fetchImpl ?? fetch;
     const loader = deps.loadAuth ?? loadAuth;
@@ -147,7 +163,7 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
         const install = deps.installService ?? installService;
         const res = await install();
         if (res.ok)
-            log(statusRow('✓', 'Service installed', res.message) + '\n');
+            rawLog(statusRow('✓', 'Service installed', res.message) + '\n');
         else
             errLog(statusRow('✗', 'Service install failed', res.message, { stream: process.stderr }) + '\n');
         return res.ok ? 0 : 1;
@@ -156,7 +172,7 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
         const uninstall = deps.uninstallService ?? uninstallService;
         const res = await uninstall();
         if (res.ok)
-            log(statusRow('✓', 'Service removed', res.message) + '\n');
+            rawLog(statusRow('✓', 'Service removed', res.message) + '\n');
         else
             errLog(statusRow('✗', 'Service uninstall failed', res.message, { stream: process.stderr }) + '\n');
         return res.ok ? 0 : 1;
@@ -169,7 +185,7 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
     if (headless) {
         deps.headless = true;
         if (!deps.spawnTerminal) {
-            deps.spawnTerminal = makeHeadlessSpawner({ wait: false, log, errLog });
+            deps.spawnTerminal = makeHeadlessSpawner({ wait: false, log: rawLog, errLog });
         }
     }
     const auth = await loader();
@@ -181,8 +197,11 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
     const tmuxSessionName = detectTmux();
     const machineId = deps.machineId ?? loadOrCreateMachineId();
     const machineName = resolveMachineName();
+    const tmuxChromeEnabled = tmuxSessionName !== null &&
+        !nonbotTmuxOptOut() &&
+        process.env.NONBOT_NO_TMUX_STATUS !== '1';
     if (tmuxSessionName) {
-        applyNonbotTmuxConfig({ spawnSync: deps.spawnSync });
+        applyNonbotTmuxConfig({ spawnSync: deps.spawnSync, chrome: tmuxChromeEnabled });
     }
     const resolveTerminalFn = deps.resolveTerminal ?? resolveTerminal;
     const resolvedTerminalProfile = headless ? null : resolveTerminalFn(undefined);
@@ -201,6 +220,7 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
     const trackedPanes = new Map();
     const killedByStop = new Set();
     const injectedPrompts = new Set();
+    const openPrompts = new Map();
     const emitRunStageFn = deps.emitRunStage ?? defaultEmitRunStage;
     const startRunHeartbeatFn = deps.startRunHeartbeat ?? defaultStartRunHeartbeat;
     const runHeartbeats = new Map();
@@ -235,13 +255,144 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
     let doneCount = 0;
     let failedCount = 0;
     const paneTitlingEnabled = tmuxSessionName !== null && !nonbotTmuxOptOut();
+    const spawnForTmux = deps.spawnSync;
     const retitlePane = (state, paneId, story) => {
         if (!paneTitlingEnabled || !paneId)
             return;
-        applyPaneTitle(paneId, state, story, deps.spawnSync);
+        applyPaneTitle(paneId, state, story, spawnForTmux);
+        applyPaneState(paneId, state, spawnForTmux);
+    };
+    const pushTmuxStatus = (needsYou = openPrompts.size, halted = false) => {
+        if (!tmuxChromeEnabled)
+            return;
+        const spawn = deps.spawnSync ?? nodeSpawnSync;
+        const set = (name, value) => {
+            try {
+                spawn('tmux', ['set-option', '-g', name, String(value)], {
+                    encoding: 'utf-8',
+                    timeout: 1000,
+                    windowsHide: true,
+                });
+            }
+            catch {
+            }
+        };
+        set('@nb_running', trackedPanes.size);
+        set('@nb_done', doneCount);
+        set('@nb_failed', failedCount);
+        set('@nb_needsyou', needsYou);
+        set('@nb_poll', Math.round((fixedInterval ?? currentInterval) / 1000));
+        set('@nb_halted', halted ? 1 : 0);
+        try {
+            spawn('tmux', ['refresh-client', '-S'], { encoding: 'utf-8', timeout: 1000, windowsHide: true });
+        }
+        catch {
+        }
+    };
+    const stdoutIsTTY = deps.stdoutIsTTY ?? (process.stdout?.isTTY === true && !process.env.VITEST);
+    const footerEnabled = stdoutIsTTY && !headless;
+    let footerActive = false;
+    let lastPollOk = true;
+    const noBell = process.env.NONBOT_NO_BELL === '1' || process.env.NONBOT_NO_BELL === 'true';
+    const ERASE = '\r\x1b[K';
+    const footerHealth = () => {
+        if (openPrompts.size > 0)
+            return 'waiting';
+        if (!lastPollOk)
+            return 'reconnecting';
+        if (fixedInterval === undefined && currentInterval > POLL_FAST_MS)
+            return 'backoff';
+        return 'live';
+    };
+    const renderFooter = () => liveFooter({
+        running: trackedPanes.size,
+        waiting: openPrompts.size,
+        done: doneCount,
+        failed: failedCount,
+        nextPollMs: fixedInterval ?? currentInterval,
+        version: `v${VERSION}`,
+        machine: machineName,
+        health: footerHealth(),
+    });
+    const refreshFooter = () => {
+        if (footerEnabled && footerActive)
+            rawLog(ERASE + renderFooter());
+    };
+    const startFooter = () => {
+        if (!footerEnabled)
+            return;
+        footerActive = true;
+        rawLog(ERASE + renderFooter());
+    };
+    const log = (s) => {
+        if (!footerEnabled || !footerActive) {
+            rawLog(s);
+            return;
+        }
+        rawLog(ERASE);
+        rawLog(s);
+        rawLog(ERASE + renderFooter());
+    };
+    const dropFooter = () => {
+        if (footerActive) {
+            footerActive = false;
+            rawLog(ERASE);
+        }
     };
     const emitSummary = () => {
         log(runSummary({ running: trackedPanes.size, done: doneCount, failed: failedCount }) + '\n');
+        pushTmuxStatus();
+    };
+    const sweepPanePrompts = () => {
+        if (!paneTitlingEnabled || trackedPanes.size === 0)
+            return;
+        let changed = false;
+        for (const [activationId, paneId] of trackedPanes) {
+            let menu;
+            try {
+                menu = parsePromptMenu(capturePane(paneId, spawnForTmux), '');
+            }
+            catch {
+                continue;
+            }
+            const meta = trackedMeta.get(activationId);
+            if (menu.options.length > 0) {
+                const promptId = mintPromptId(activationId, paneId, menu);
+                if (openPrompts.get(activationId) === promptId)
+                    continue;
+                openPrompts.set(activationId, promptId);
+                log('\n' +
+                    needsYouBanner({
+                        activationId,
+                        story: meta?.story,
+                        paneId,
+                        provider: meta?.provider,
+                        options: menu.options,
+                        elapsedMs: meta ? Date.now() - meta.startedAt : undefined,
+                    }) +
+                    '\n');
+                retitlePane('waiting', paneId, meta?.story ?? '');
+                if (!noBell && footerEnabled)
+                    rawLog('\x07');
+                changed = true;
+            }
+            else if (openPrompts.has(activationId)) {
+                openPrompts.delete(activationId);
+                log(resumedLine(activationId) + '\n');
+                retitlePane('running', paneId, meta?.story ?? '');
+                changed = true;
+            }
+        }
+        for (const id of [...openPrompts.keys()]) {
+            if (!trackedPanes.has(id)) {
+                openPrompts.delete(id);
+                changed = true;
+            }
+        }
+        if (changed) {
+            pushTmuxStatus();
+            refreshFooter();
+        }
     };
     let running = true;
     let sigHandler;
@@ -250,7 +401,9 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
             running = false;
             for (const id of [...runHeartbeats.keys()])
                 stopHeartbeat(id);
-            log('\n' + statusRow('✓', 'daemon stopped', 'Ctrl-C received') + '\n');
+            dropFooter();
+            pushTmuxStatus(0, true);
+            rawLog('\n' + statusRow('✓', 'daemon stopped', 'Ctrl-C received') + '\n');
             process.exit(0);
         };
         process.on('SIGINT', sigHandler);
@@ -286,6 +439,7 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
     log(`${headerMarker} ${c.bold(headerLabel)}\n`);
     const ctxRows = [
         ['YOU', auth.email],
+        ['MACHINE', `${machineName}  ·  ${shortMachineId(machineId)}`],
         ['LISTENING', `${hostUrl}/api/cli/activations/pending`],
         ['PROFILE', profileName],
         ['LANDING', terminalLabel],
@@ -303,6 +457,8 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
         inTmux: tmuxSessionName !== null,
     }) + '\n');
     log('\n');
+    pushTmuxStatus();
+    startFooter();
     while (running) {
         let firedThisPoll = false;
         try {
@@ -329,6 +485,7 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                 return 1;
             }
             if (res.ok) {
+                lastPollOk = true;
                 const body = (await res.json());
                 const pendingKills = body?.pendingKills ?? [];
                 if (pendingKills.length > 0) {
@@ -496,6 +653,7 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                         baseUrl: auth.baseUrl,
                         pat: auth.pat,
                         injected: injectedPrompts,
+                        trackedPanes,
                         machineId,
                         fetchImpl,
                         spawnImpl: deps.spawnSync,
@@ -504,6 +662,11 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                 }
                 catch {
                 }
+                try {
+                    sweepPanePrompts();
+                }
+                catch {
+                }
                 if (trackedPanes.size > 0) {
                     const reported = await checkCompletions({
                         tracked: trackedPanes,
@@ -537,7 +700,7 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                             doneCount++;
                             trackedMeta.delete(id);
                             safeEmit(id, RUN_STAGE.FINISHED);
-                            stopHeartbeat(id, 'daemon-exit');
+                            stopHeartbeat(id, 'finished');
                             try {
                                 const session = isolatedSessions.noteTerminal(id);
                                 if (session) {
@@ -556,28 +719,30 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                         emitSummary();
                     }
                 }
-                if (!firedThisPoll && pendingKills.length === 0) {
+                if (!firedThisPoll && pendingKills.length === 0 && !footerEnabled) {
                     log(pollTick({
                         pending: 0,
                         sleepMs: fixedInterval ?? currentInterval,
                         backingOff: fixedInterval === undefined && currentInterval > POLL_FAST_MS,
                     }) + '\n');
                 }
-                if (seen.size > 500)
-                    seen.clear();
+                evictOldestToCap(seen, 500);
             }
         }
         catch (e) {
+            lastPollOk = false;
             errLog(statusRow('⚠', 'poll error', e.message, { stream: process.stderr }) + '\n');
         }
         if (options.oneShot)
             break;
         if (fixedInterval !== undefined) {
+            refreshFooter();
             await sleep(fixedInterval);
         }
         else {
             if (firedThisPoll)
                 currentInterval = POLL_FAST_MS;
+            refreshFooter();
             await sleep(currentInterval);
             if (!firedThisPoll) {
                 currentInterval = Math.min(currentInterval * 2, maxIntervalMs);

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

@@ -60,6 +60,17 @@ export async function runRunPromptHookCommand(deps = {}) {
     }
     if (!question && parsed.options.length === 0)
         return 0;
+    if (paneId && /^%\d+$/.test(paneId)) {
+        try {
+            spawnSync('tmux', ['set-option', '-p', '-t', paneId, '@nb_state', 'waiting'], {
+                encoding: 'utf-8',
+                timeout: 1000,
+                windowsHide: true,
+            });
+        }
+        catch {
+        }
+    }
     const promptId = mintPromptId(activationId, paneId, { question, options: parsed.options });
     const ok = await reportPrompt({
         baseUrl,

package/dist/lib/activations.js

@@ -9,6 +9,7 @@ import { appendActivityLog } from './activity-log.js';
 import { activationCard, clockTime } from './output.js';
 import { buildCommandFromParams, hookSettingsPathFor, shellQuoteSingle, } from './command-builders.js';
 import { validatePayload, validateActivationId, validateRepoPath, ValidationError, extractTerminalTheme, } from './payload-validator.js';
+const PANE_ID_RE = /^%\d+$/;
 export const BUILT_COMMAND_MAX_LENGTH = 32 * 1024;
 export const WIRE_COMMAND_MAX_LENGTH = 4096;
 export const COMMAND_WARN_LENGTH = 8192;
@@ -450,6 +451,8 @@ export async function executePendingKills(kills, baseUrl, token) {
         return;
     const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
     const runOne = async (k) => {
+        if (!PANE_ID_RE.test(k.tmuxPaneId))
+            return;
         try {
             spawnSync('tmux', ['send-keys', '-t', k.tmuxPaneId, 'C-c'], {
                 encoding: 'utf-8',

package/dist/lib/bounded-set.js

@@ -0,0 +1,13 @@
+export function evictOldestToCap(set, cap) {
+    if (set.size <= cap)
+        return;
+    const overflow = set.size - cap;
+    const victims = [];
+    for (const id of set) {
+        victims.push(id);
+        if (victims.length >= overflow)
+            break;
+    }
+    for (const id of victims)
+        set.delete(id);
+}

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

@@ -7,6 +7,7 @@ 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';
+import { resolveBaseBranch as defaultResolveBaseBranch } from './isolated-session.js';
 const defaultFs = {
     mkdirSync: (p, opts) => nodeFs.mkdirSync(p, opts),
     writeFileSync: (p, data, opts) => nodeFs.writeFileSync(p, data, opts),
@@ -122,7 +123,8 @@ export async function launchCoordinatedSet(args) {
         throw new Error('coordinated set token minting produced an empty token');
     }
     const sessionId = `choir_${sessionName}_${token.slice(0, 8)}`;
-    const baseBranch = 'HEAD';
+    const resolveBaseBranchFn = deps.resolveBaseBranchImpl ?? defaultResolveBaseBranch;
+    const baseBranch = resolveBaseBranchFn(repoRoot);
     const hub = createHubImpl({
         sessionId,
         repoRoot,

package/dist/lib/choir/isolated-session.js

@@ -1,5 +1,5 @@
 import { spawnSync as nodeSpawnSync } from 'node:child_process';
-import { removeWorktree as defaultRemoveWorktree } from './worktree.js';
+import { removeWorktree as defaultRemoveWorktree, pollGitStatus as defaultPollGitStatus } from './worktree.js';
 import { runReconcile as defaultRunReconcile } from './reconcile.js';
 import { isValidBranch } from './names.js';
 export class IsolatedSessionTracker {
@@ -55,10 +55,21 @@ export function resolveBaseBranch(repoRoot, spawnImpl = nodeSpawnSync) {
     }
     return 'main';
 }
+const LAUNCHER_ARTIFACTS = new Set(['.mcp.json']);
+function worktreeHasUnmergedWork(worktreePath, baseBranch, spawnImpl, pollGitStatusImpl) {
+    try {
+        const status = pollGitStatusImpl(worktreePath, spawnImpl, baseBranch);
+        return status.dirtyPaths.some((p) => !LAUNCHER_ARTIFACTS.has(p));
+    }
+    catch {
+        return true;
+    }
+}
 export function reconcileAndCleanup(session, deps = {}) {
     const spawnImpl = deps.spawnImpl ?? nodeSpawnSync;
     const runReconcileImpl = deps.runReconcileImpl ?? defaultRunReconcile;
     const removeWorktreeImpl = deps.removeWorktreeImpl ?? defaultRemoveWorktree;
+    const pollGitStatusImpl = deps.pollGitStatusImpl ?? defaultPollGitStatus;
     const log = deps.log;
     const branches = session.panes.map((p) => p.branch);
     const reconcile = runReconcileImpl({
@@ -72,9 +83,14 @@ export function reconcileAndCleanup(session, deps = {}) {
     });
     const removed = [];
     if (!reconcile.blocked) {
+        let kept = 0;
         for (const p of session.panes) {
+            if (worktreeHasUnmergedWork(p.worktreePath, session.baseBranch, spawnImpl, pollGitStatusImpl)) {
+                kept++;
+                continue;
+            }
             try {
-                removeWorktreeImpl({ repoRoot: session.repoRoot, worktreePath: p.worktreePath });
+                removeWorktreeImpl({ repoRoot: session.repoRoot, worktreePath: p.worktreePath, force: true });
                 removed.push(p.worktreePath);
             }
             catch {
@@ -82,7 +98,9 @@ export function reconcileAndCleanup(session, deps = {}) {
         }
         log?.(`[reconcile] ${session.sessionId} — merged ${reconcile.merged.length} ` +
             `branch${reconcile.merged.length === 1 ? '' : 'es'}, ` +
-            `removed ${removed.length} worktree${removed.length === 1 ? '' : 's'}\n`);
+            `removed ${removed.length} worktree${removed.length === 1 ? '' : 's'}` +
+            (kept > 0 ? `, kept ${kept} with uncommitted work for the human` : '') +
+            `\n`);
     }
     else {
         log?.(`[reconcile] ${session.sessionId} — BLOCKED (${reconcile.reason}); ` +

package/dist/lib/choir/worktree.js

@@ -84,8 +84,9 @@ export function listWorktrees(repoRoot, spawnImpl = nodeSpawnSync) {
     return entries;
 }
 export function removeWorktree(args) {
-    const { repoRoot, worktreePath, spawnImpl = nodeSpawnSync } = args;
-    const r = runGit(spawnImpl, repoRoot, ['worktree', 'remove', worktreePath]);
+    const { repoRoot, worktreePath, spawnImpl = nodeSpawnSync, force = false } = args;
+    const flags = force ? ['--force'] : [];
+    const r = runGit(spawnImpl, repoRoot, ['worktree', 'remove', ...flags, worktreePath]);
     assertOk(r, 'worktree remove');
 }
 export function ensureChoirGitignored(repoRoot, fsImpl = defaultFs) {

package/dist/lib/completion.js

@@ -6,13 +6,13 @@ export function listLivePaneIds(spawnImpl = nodeSpawnSync) {
             timeout: 1500,
             windowsHide: true,
         });
+        if (r.status !== 0)
+            return null;
         const out = typeof r.stdout === 'string' ? r.stdout : '';
-        if (r.status !== 0 && !out)
-            return new Set();
         return new Set(out.split('\n').map((s) => s.trim()).filter((s) => /^%\d+$/.test(s)));
     }
     catch {
-        return new Set();
+        return null;
     }
 }
 export function detectCompletedActivations(tracked, livePaneIds, killed) {
@@ -48,9 +48,11 @@ export async function checkCompletions(opts) {
     if (tracked.size === 0)
         return [];
     const live = listLivePaneIds(opts.spawnImpl);
+    if (live === null)
+        return [];
     const completed = detectCompletedActivations(tracked, live, killed);
     for (const [id, pane] of [...tracked.entries()]) {
-        if (!live.has(pane)) {
+        if (!live.has(pane) && killed.has(id)) {
             tracked.delete(id);
             killed.delete(id);
         }
@@ -58,11 +60,13 @@ export async function checkCompletions(opts) {
     const reported = [];
     for (const id of completed) {
         const ok = await postCompletion(baseUrl, pat, id, opts.fetchImpl);
-        if (ok) {
-            reported.push(id);
-            const card = opts.renderComplete?.(id);
-            opts.log?.(card && card.length > 0 ? card : `✓ ${id} · run completed (pane closed)\n`);
+        if (!ok) {
+            continue;
         }
+        tracked.delete(id);
+        reported.push(id);
+        const card = opts.renderComplete?.(id);
+        opts.log?.(card && card.length > 0 ? card : `✓ ${id} · run completed (pane closed)\n`);
     }
     return reported;
 }

package/dist/lib/machine.js

@@ -36,6 +36,12 @@ export function loadOrCreateMachineId(deps = {}) {
     }
     return machineId;
 }
+export function shortMachineId(id) {
+    const hex = (id || '').replace(/[^a-fA-F0-9]/g, '').toLowerCase();
+    if (hex.length === 0)
+        return 'm_unknown';
+    return `m_${hex.slice(0, 6)}`;
+}
 export function resolveMachineName(env = process.env) {
     const override = env.NONBOT_MACHINE_NAME;
     if (override && override.trim().length > 0)

package/dist/lib/output.js

@@ -390,3 +390,112 @@ export function daemonCloser(opts = {}) {
     }
     return parts.join('');
 }
+function stripControlBytes(s) {
+    return (s ?? '')
+        .replace(/[\x00-\x1f\x7f]/g, ' ')
+        .replace(/ {2,}/g, ' ')
+        .trim();
+}
+const FOOTER_DOT_COLOR = {
+    live: 'green',
+    backoff: 'amber',
+    reconnecting: 'red',
+    waiting: 'red',
+};
+export function liveFooter(args) {
+    const stream = args.stream ?? process.stdout;
+    const failed = args.failed ?? 0;
+    const health = args.health ?? (args.waiting > 0 ? 'waiting' : 'live');
+    const dotGlyph = asciiOnly() ? '*' : '●';
+    const dotColor = FOOTER_DOT_COLOR[health];
+    const dot = colorize(dotGlyph, dotColor, stream);
+    const healthLabel = colorize(health, dotColor, stream);
+    const sep = c.muted('·', stream);
+    const segs = [`${dot} ${healthLabel}`];
+    segs.push(c.green(`${args.running} running`, stream));
+    if (args.waiting > 0)
+        segs.push(c.bold(c.amber(`${args.waiting} waiting`, stream), stream));
+    segs.push(c.muted(`${args.done} done`, stream));
+    if (failed > 0)
+        segs.push(c.red(`${failed} failed`, stream));
+    if (args.nextPollMs !== undefined) {
+        segs.push(c.muted(`next poll ${formatMsToS(args.nextPollMs)}`, stream));
+    }
+    if (args.version)
+        segs.push(c.muted(args.version, stream));
+    if (args.machine)
+        segs.push(c.cyan(args.machine, stream));
+    return segs.join(`  ${sep}  `);
+}
+export function needsYouBanner(args) {
+    const stream = args.stream ?? process.stdout;
+    const ascii = asciiOnly();
+    const bang = ascii ? '!!' : '‼';
+    const ptr = ascii ? '>' : '❯';
+    const tl = ascii ? '+' : '╔';
+    const tr = ascii ? '+' : '╗';
+    const bl = ascii ? '+' : '╚';
+    const br = ascii ? '+' : '╝';
+    const h = ascii ? '-' : '═';
+    const v = ascii ? '|' : '║';
+    const inner = Math.max(40, Math.min(args.width ?? 72, 100)) - 4;
+    const titleRaw = `${bang}  NEEDS YOU  ·  a run is waiting on your answer`;
+    const title = titleRaw.length > inner ? titleRaw.slice(0, inner - 1) + '…' : titleRaw.padEnd(inner, ' ');
+    const sep = c.muted('·', stream);
+    const lines = [];
+    lines.push(c.amber(`  ${tl}${h.repeat(inner + 2)}${tr}`, stream));
+    lines.push(`  ${c.amber(v, stream)} ${c.amber(c.bold(title, stream), stream)} ${c.amber(v, stream)}`);
+    lines.push(c.amber(`  ${bl}${h.repeat(inner + 2)}${br}`, stream));
+    const story = stripControlBytes(args.story ?? '');
+    const idCell = c.bold(c.white(args.activationId, stream), stream);
+    lines.push(`       ${idCell}${story ? `  ${sep}  ${c.white(story, stream)}` : ''}`);
+    const metaParts = [c.amber('WAITING', stream)];
+    if (args.elapsedMs !== undefined)
+        metaParts.push(c.muted(formatElapsed(args.elapsedMs), stream));
+    metaParts.push(c.muted(`pane ${args.paneId}`, stream));
+    if (args.provider)
+        metaParts.push(c.muted(args.provider, stream));
+    lines.push(`       ${metaParts.join(`  ${sep}  `)}`);
+    if (args.options && args.options.length > 0) {
+        const opts = args.options.slice(0, 4).map((o, i) => {
+            const label = stripControlBytes(o.label).slice(0, 40);
+            const lead = i === 0 ? `${c.cyan(ptr, stream)} ` : '';
+            return `${lead}${c.white(`${o.index}. ${label}`, stream)}`;
+        });
+        lines.push(`       ${opts.join('   ')}`);
+    }
+    lines.push(`       ${c.muted('answer it →  on the canvas, on your phone, or', stream)}  ` +
+        c.cyan(`tmux select-window -t ${args.paneId}`, stream));
+    return lines.join('\n');
+}
+export function resumedLine(activationId, stream = process.stdout) {
+    const check = asciiOnly() ? 'OK' : '✓';
+    return (`  ${c.green(check, stream)} ${c.white(activationId, stream)} ` +
+        c.muted('· resumed · answer received', stream));
+}
+export function buildPaneBorderFormat(opts = {}) {
+    const warn = opts.ascii ? '!! ' : '⚠ ';
+    return (`#{?#{==:#{@nb_state},waiting},#[fg=colour203 bold]${warn},}` +
+        '#[fg=' +
+        '#{?#{==:#{@nb_state},waiting},colour203,' +
+        '#{?#{==:#{@nb_state},failed},colour203,' +
+        '#{?#{==:#{@nb_state},completed},colour78,' +
+        '#{?#{==:#{@nb_state},stopping},colour214,colour45}}}}' +
+        ']' +
+        ' #{pane_title} ');
+}
+export function buildTmuxStatusLeft(opts = {}) {
+    const dot = opts.ascii ? '* ' : '● ';
+    return (' #[fg=#ffffff,bold]non.bot#[default] ' +
+        '#{?#{==:#{@nb_halted},1},#[fg=#ff4c51]HALTED,' +
+        `#[fg=#28c76f]${dot}CONNECTED}#[default] `);
+}
+export function buildTmuxStatusRight(opts = {}) {
+    const warn = opts.ascii ? '!!' : '⚠';
+    const dot = '·';
+    return ('#[fg=#28c76f]#{@nb_running} run#[default] ' +
+        `#[fg=#8b949e]${dot} #{@nb_done} done` +
+        `#{?#{@nb_failed}, #[fg=#ff4c51]${dot} #{@nb_failed} fail,}#[default] ` +
+        `#{?#{@nb_needsyou},#[fg=#ff9f43,bold]${dot} ${warn} #{@nb_needsyou} NEEDS YOU ,}` +
+        `#[fg=#4fc3f7]${dot} #{host_short} ${dot} poll #{@nb_poll}s `);
+}

package/dist/lib/pane-title.js

@@ -4,12 +4,14 @@ const STATE_GLYPH = {
     completed: '✓',
     failed: '✗',
     stopping: '■',
+    waiting: '‼',
 };
 const STATE_GLYPH_ASCII = {
     running: '>',
     completed: 'OK',
     failed: 'XX',
     stopping: '#',
+    waiting: '!!',
 };
 function asciiOnly(env = process.env) {
     return env.NONBOT_ASCII_ONLY === '1' || env.NONBOT_ASCII_ONLY === 'true';
@@ -34,6 +36,26 @@ export function buildPaneTitleCommand(paneId, state, story, env = process.env) {
     const title = formatPaneTitle(state, story, env);
     return { cmd: 'tmux', args: ['select-pane', '-t', paneId, '-T', title] };
 }
+export function buildPaneStateOptionCommand(paneId, state) {
+    if (!/^%\d+$/.test(paneId))
+        return null;
+    return { cmd: 'tmux', args: ['set-option', '-p', '-t', paneId, '@nb_state', state] };
+}
+export function applyPaneState(paneId, state, spawnImpl = nodeSpawnSync) {
+    const command = buildPaneStateOptionCommand(paneId, state);
+    if (!command)
+        return false;
+    try {
+        spawnImpl(command.cmd, command.args, {
+            encoding: 'utf-8',
+            timeout: 1000,
+            windowsHide: true,
+        });
+    }
+    catch {
+    }
+    return true;
+}
 export function applyPaneTitle(paneId, state, story, spawnImpl = nodeSpawnSync, env = process.env) {
     const command = buildPaneTitleCommand(paneId, state, story, env);
     if (!command)

package/dist/lib/payload-validator.js

@@ -94,6 +94,9 @@ export function validateProvider(s) {
 const TMUX_SAFE_DIRECTIVES = new Set([
     'set', 'set-option', 'setw', 'set-window-option',
 ]);
+const TMUX_FORBIDDEN_OPTIONS = new Set([
+    'default-command', 'default-shell', 'command-alias',
+]);
 export function isSafeTmuxConf(conf) {
     for (const rawLine of conf.split(/\r?\n/)) {
         const line = rawLine.trim();
@@ -103,13 +106,32 @@ export function isSafeTmuxConf(conf) {
             continue;
         if (line.includes('#(') || line.includes('$(') || line.includes('`'))
             return false;
-        const firstToken = line.split(/\s+/)[0];
-        if (!TMUX_SAFE_DIRECTIVES.has(firstToken))
+        if (line.includes('\\'))
             return false;
+        for (const segment of line.split(';')) {
+            const cmd = segment.trim();
+            if (cmd === '')
+                continue;
+            const tokens = cmd.split(/\s+/);
+            if (!TMUX_SAFE_DIRECTIVES.has(tokens[0]))
+                return false;
+            for (const tok of tokens) {
+                if (TMUX_FORBIDDEN_OPTIONS.has(tok))
+                    return false;
+            }
+        }
     }
     return true;
 }
-const ITERM_FORBIDDEN_KEYS = ['Command', 'Initial Text', 'Send Text at Start'];
+const ITERM_FORBIDDEN_KEYS = [
+    'Command',
+    'Initial Text',
+    'Send Text at Start',
+    'Triggers',
+    'Smart Selection Rules',
+    'Semantic History',
+    'Bound Hosts',
+];
 export function isSafeItermProfileJson(jsonStr) {
     let parsed;
     try {

package/dist/lib/run-prompt.js

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import { spawnSync as nodeSpawnSync } from 'node:child_process';
 import { VERSION } from '../version.js';
+import { evictOldestToCap } from './bounded-set.js';
 const QUESTION_MAX = 200;
 const LABEL_MAX = 80;
 const OPTIONS_MAX = 8;
@@ -59,6 +60,21 @@ export function parsePromptMenu(paneText, fallbackMessage = '') {
     question = (question || fallback).slice(0, QUESTION_MAX);
     return { question, options };
 }
+export function capturePane(paneId, spawnImpl = nodeSpawnSync) {
+    if (!PANE_ID_RE.test(paneId))
+        return '';
+    try {
+        const r = spawnImpl('tmux', ['capture-pane', '-p', '-t', paneId], {
+            encoding: 'utf-8',
+            timeout: 2000,
+            windowsHide: true,
+        });
+        return typeof r.stdout === 'string' ? r.stdout : '';
+    }
+    catch {
+        return '';
+    }
+}
 export function mintPromptId(activationId, paneId, parsed) {
     const sig = JSON.stringify({
         q: parsed.question,
@@ -186,13 +202,26 @@ export async function deliverAnsweredPrompts(opts) {
         return [];
     const reported = [];
     for (const p of answered) {
-        if (!p.paneId)
+        const localPaneId = opts.trackedPanes?.get(p.activationId);
+        if (!localPaneId)
+            continue;
+        if (p.paneId && p.paneId !== localPaneId)
             continue;
         if (!opts.injected.has(p.promptId)) {
-            const sent = injectAnswer(p.paneId, p.answerIndex, p.answerText, opts.spawnImpl);
+            const sent = injectAnswer(localPaneId, p.answerIndex, p.answerText, opts.spawnImpl);
             if (!sent)
                 continue;
             opts.injected.add(p.promptId);
+            try {
+                const spawn = opts.spawnImpl ?? nodeSpawnSync;
+                spawn('tmux', ['set-option', '-p', '-t', localPaneId, '@nb_state', 'running'], {
+                    encoding: 'utf-8',
+                    timeout: 1000,
+                    windowsHide: true,
+                });
+            }
+            catch {
+            }
         }
         const confirmed = await confirmDelivered({
             baseUrl: opts.baseUrl,
@@ -202,10 +231,9 @@ export async function deliverAnsweredPrompts(opts) {
         });
         if (confirmed) {
             reported.push(p.promptId);
-            opts.log?.(`✓ ${p.activationId} · answer delivered to pane ${p.paneId}\n`);
+            opts.log?.(`✓ ${p.activationId} · answer delivered to pane ${localPaneId}\n`);
         }
     }
-    if (opts.injected.size > 500)
-        opts.injected.clear();
+    evictOldestToCap(opts.injected, 500);
     return reported;
 }

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.9.4';
+export const VERSION = '0.9.6';

package/package.json

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