@nonbot/cli 0.9.5 → 0.9.7

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, activationCard, runSummary, formatElapsed, liveFooter, needsYouBanner, resumedLine, buildPaneBorderFormat, buildTmuxStatusLeft, buildTmuxStatusRight, WORDMARK_WIDTH, 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=#0a0d17,fg=#8a93a6');
+        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=#0a0d17,bg=#6c8cff,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,116 @@ 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 log = (s) => rawLog(s);
+    let lastPollOk = true;
+    const noBell = process.env.NONBOT_NO_BELL === '1' || process.env.NONBOT_NO_BELL === 'true';
+    const stdoutIsTTY = deps.stdoutIsTTY ?? (process.stdout?.isTTY === true && !process.env.VITEST);
+    const pollHealth = () => {
+        if (openPrompts.size > 0)
+            return 'waiting';
+        if (!lastPollOk)
+            return 'reconnecting';
+        if (fixedInterval === undefined && currentInterval > POLL_FAST_MS)
+            return 'backoff';
+        return 'live';
+    };
+    const heartbeatLine = () => liveFooter({
+        running: trackedPanes.size,
+        waiting: openPrompts.size,
+        done: doneCount,
+        failed: failedCount,
+        nextPollMs: fixedInterval ?? currentInterval,
+        version: `v${VERSION}`,
+        machine: machineName,
+        health: pollHealth(),
+    });
     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 && stdoutIsTTY)
+                    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();
+        }
     };
     let running = true;
     let sigHandler;
@@ -250,7 +373,8 @@ 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');
+            pushTmuxStatus(0, true);
+            rawLog('\n' + statusRow('✓', 'daemon stopped', 'Ctrl-C received') + '\n');
             process.exit(0);
         };
         process.on('SIGINT', sigHandler);
@@ -275,17 +399,23 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
     ];
     if (tmuxSessionName)
         badgeSublines.push(`tmux host: ${tmuxSessionName}`);
+    const stdoutCols = deps.stdoutColumns ?? process.stdout?.columns ?? 0;
+    const stdoutRows = deps.stdoutRows ?? process.stdout?.rows ?? 0;
+    const compactMast = stdoutIsTTY &&
+        ((stdoutCols > 0 && stdoutCols < WORDMARK_WIDTH + 4) || (stdoutRows > 0 && stdoutRows < 16));
     log(daemonOpener(`v${VERSION}`, {
         state: 'IDLE',
         badgeColor: 'green',
         badgeLabel: 'CONNECTED',
         badgeSublines,
+        compact: compactMast,
     }) + '\n\n');
     const headerMarker = c.green('[ + ]');
     const headerLabel = c.white('LISTENING  ·  READY FOR ACTIVATIONS');
     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 +433,7 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
         inTmux: tmuxSessionName !== null,
     }) + '\n');
     log('\n');
+    pushTmuxStatus();
     while (running) {
         let firedThisPoll = false;
         try {
@@ -329,6 +460,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 +628,7 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                         baseUrl: auth.baseUrl,
                         pat: auth.pat,
                         injected: injectedPrompts,
+                        trackedPanes,
                         machineId,
                         fetchImpl,
                         spawnImpl: deps.spawnSync,
@@ -504,6 +637,11 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                 }
                 catch {
                 }
+                try {
+                    sweepPanePrompts();
+                }
+                catch {
+                }
                 if (trackedPanes.size > 0) {
                     const reported = await checkCompletions({
                         tracked: trackedPanes,
@@ -537,7 +675,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,18 +694,14 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                         emitSummary();
                     }
                 }
-                if (!firedThisPoll && pendingKills.length === 0) {
-                    log(pollTick({
-                        pending: 0,
-                        sleepMs: fixedInterval ?? currentInterval,
-                        backingOff: fixedInterval === undefined && currentInterval > POLL_FAST_MS,
-                    }) + '\n');
+                if (!firedThisPoll && pendingKills.length === 0 && !tmuxChromeEnabled) {
+                    log(heartbeatLine() + '\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)

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/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,7 +83,12 @@ 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, force: true });
                 removed.push(p.worktreePath);
@@ -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/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

@@ -1,12 +1,15 @@
 import { ANSI, renderBannerHeader } from './banner.js';
 export { ANSI };
 export const BRAND = {
-    white: '\x1b[38;2;255;255;255m',
-    cyan: '\x1b[38;2;79;195;247m',
-    green: '\x1b[38;2;40;199;111m',
-    amber: '\x1b[38;2;255;159;67m',
-    red: '\x1b[38;2;255;76;81m',
-    muted: '\x1b[38;2;139;148;158m',
+    white: '\x1b[38;2;240;235;226m',
+    cream: '\x1b[38;2;240;235;226m',
+    blue: '\x1b[38;2;108;140;255m',
+    indigo: '\x1b[38;2;155;108;240m',
+    cyan: '\x1b[38;2;88;199;230m',
+    green: '\x1b[38;2;69;209;127m',
+    amber: '\x1b[38;2;255;180;84m',
+    red: '\x1b[38;2;255;92;108m',
+    muted: '\x1b[38;2;138;147;166m',
     bold: '\x1b[1m',
     reset: '\x1b[0m',
     underline: '\x1b[4m',
@@ -31,6 +34,9 @@ function paint(s, code, stream = process.stdout) {
 }
 export const c = {
     white: (s, stream) => paintRaw(s, BRAND.white, stream),
+    cream: (s, stream) => paintRaw(s, BRAND.cream, stream),
+    blue: (s, stream) => paintRaw(s, BRAND.blue, stream),
+    indigo: (s, stream) => paintRaw(s, BRAND.indigo, stream),
     cyan: (s, stream) => paintRaw(s, BRAND.cyan, stream),
     green: (s, stream) => paintRaw(s, BRAND.green, stream),
     amber: (s, stream) => paintRaw(s, BRAND.amber, stream),
@@ -137,17 +143,7 @@ const WORDMARK_LINES = [
 ];
 export const WORDMARK_WIDTH = 63;
 export const WORDMARK_HEIGHT = 6;
-export const WORDMARK_GRADIENT = [
-    '#13b9e2', '#1abadc', '#20bad7', '#27bbd1', '#2ebbcb', '#35bcc5', '#3bbdc0',
-    '#42bdba', '#49beb4', '#50bfae', '#50bfae', '#5dc0a3', '#64c09d', '#6bc197',
-    '#71c292', '#78c28c', '#7fc386', '#86c380', '#8cc47b', '#93c575', '#93c575',
-    '#a1c669', '#a7c664', '#aec75e', '#b5c858', '#bcc852', '#c2c94d', '#c9ca47',
-    '#d0ca41', '#d7cb3b', '#ddcb36', '#e4cc30', '#e0c536', '#dcbf3b', '#d8b841',
-    '#d4b246', '#d0ab4c', '#cca551', '#c89e57', '#c4975d', '#c09162', '#bc8a68',
-    '#bc8a68', '#bc8a68', '#b07679', '#ac707e', '#a86984', '#a36389', '#9f5c8f',
-    '#9b5694', '#974f9a', '#9348a0', '#8f42a5', '#8f42a5', '#8735b0', '#832eb6',
-    '#7f27bc', '#7b21c1', '#771ac7', '#7314cc', '#6f0dd2', '#6b07d7', '#6700dd',
-];
+export const WORDMARK_DOT_COLS = [31, 32, 33];
 function hexFg(hex) {
     const n = parseInt(hex.slice(1), 16);
     return `\x1b[38;2;${(n >> 16) & 255};${(n >> 8) & 255};${n & 255}m`;
@@ -163,8 +159,8 @@ function paintWordmarkLine(line, stream = process.stdout) {
             out += ' ';
             continue;
         }
-        const hex = WORDMARK_GRADIENT[i] ?? WORDMARK_GRADIENT[WORDMARK_GRADIENT.length - 1];
-        out += BRAND.bold + hexFg(hex) + ch + BRAND.reset;
+        const colour = WORDMARK_DOT_COLS.includes(i) ? BRAND.blue : BRAND.cream;
+        out += BRAND.bold + colour + ch + BRAND.reset;
     }
     return out;
 }
@@ -333,6 +329,43 @@ export function fixBlock(args) {
     });
     return lines.join('\n');
 }
+export function promptLine(opts = {}) {
+    const stream = opts.stream ?? process.stdout;
+    const cursor = asciiOnly() ? '_' : '▌';
+    return (`${c.cyan('~', stream)} ${c.green('$', stream)} ` +
+        `${c.bold(c.cream('nonbot', stream), stream)} ${c.blue('run', stream)}` +
+        c.cream(cursor, stream));
+}
+export function gradientRule(width, opts = {}) {
+    const stream = opts.stream ?? process.stdout;
+    const n = Math.max(0, Math.floor(width));
+    const glyph = asciiOnly() ? '-' : '━';
+    if (!isTTY(stream) || n === 0)
+        return glyph.repeat(n);
+    const from = [0x6c, 0x8c, 0xff];
+    const to = [0x9b, 0x6c, 0xf0];
+    let out = '';
+    for (let i = 0; i < n; i++) {
+        const t = n === 1 ? 0 : i / (n - 1);
+        const r = Math.round(from[0] + (to[0] - from[0]) * t);
+        const g = Math.round(from[1] + (to[1] - from[1]) * t);
+        const b = Math.round(from[2] + (to[2] - from[2]) * t);
+        out += `\x1b[38;2;${r};${g};${b}m${glyph}`;
+    }
+    return out + BRAND.reset;
+}
+export function compactMasthead(version, opts = {}) {
+    const stream = opts.stream ?? process.stdout;
+    const state = opts.state ?? 'IDLE';
+    const badgeColor = opts.badgeColor ?? 'green';
+    const badgeLabel = opts.badgeLabel ?? 'CONNECTED';
+    const dotGlyph = asciiOnly() ? '*' : '●';
+    const brand = `${c.bold(c.cream('non.bot', stream), stream)}${c.blue('.', stream)}`;
+    const badge = colorize(`${dotGlyph} ${badgeLabel}`, badgeColor, stream);
+    const sep = c.muted('·', stream);
+    const tail = [c.muted(`daemon ${version}`, stream), sep, c.muted(state, stream)].join(' ');
+    return `${brand} ${badge}  ${tail}`;
+}
 export const DAEMON_TAGLINES = [
     "click ▶ on the canvas. terminal opens here. that's it.",
 ];
@@ -348,10 +381,19 @@ export function daemonOpener(version, opts = {}) {
     const seed = opts.seed ?? Date.now();
     const tagline = pickDaemonTagline(seed, opts.pool);
     const state = opts.state ?? 'IDLE';
-    const breadcrumb = opts.breadcrumb ?? 'SYS://nonbot/daemon';
-    const breadcrumbLine = breadcrumb
-        ? `  ${c.cyan(breadcrumb, stream)}\n\n`
-        : '';
+    if (opts.compact) {
+        return compactMasthead(version, {
+            state,
+            badgeColor: opts.badgeColor ?? 'green',
+            badgeLabel: opts.badgeLabel ?? 'CONNECTED',
+            stream,
+        });
+    }
+    const topLine = opts.breadcrumb === ''
+        ? ''
+        : opts.breadcrumb
+            ? `  ${c.cyan(opts.breadcrumb, stream)}\n\n`
+            : `  ${promptLine({ stream })}\n\n`;
     const stamp = renderWordmarkWithBadge({
         badgeColor: opts.badgeColor ?? 'green',
         badgeLabel: opts.badgeLabel ?? 'CONNECTED',
@@ -369,8 +411,10 @@ export function daemonOpener(version, opts = {}) {
         subParts.push(c.muted(trackedCaps(state), stream));
     }
     const subtitleLine = `  ${subParts.join('  ')}`;
+    const ruleWidth = Math.min(46, Math.max(10, terminalWidth(opts.width) - 2));
+    const ruleLine = `  ${gradientRule(ruleWidth, { stream })}`;
     const taglineLine = tagline ? `\n\n  ${c.muted(tagline, stream)}` : '';
-    return `${breadcrumbLine}${stamp}\n\n${subtitleLine}${taglineLine}`;
+    return `${topLine}${stamp}\n\n${ruleLine}\n\n${subtitleLine}${taglineLine}`;
 }
 export function daemonCloser(opts = {}) {
     const stream = opts.stream ?? process.stdout;
@@ -390,3 +434,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=#ffb454 bold]${warn},}` +
+        '#[fg=' +
+        '#{?#{==:#{@nb_state},waiting},#ffb454,' +
+        '#{?#{==:#{@nb_state},failed},#ff5c6c,' +
+        '#{?#{==:#{@nb_state},completed},#45d17f,' +
+        '#{?#{==:#{@nb_state},stopping},#ffb454,#58c7e6}}}}' +
+        ']' +
+        ' #{pane_title} ');
+}
+export function buildTmuxStatusLeft(opts = {}) {
+    const dot = opts.ascii ? '* ' : '● ';
+    return (' #[fg=#f0ebe2,bold]non#[fg=#6c8cff].#[fg=#f0ebe2]bot#[default] ' +
+        '#{?#{==:#{@nb_halted},1},#[fg=#ff5c6c]HALTED,' +
+        `#[fg=#45d17f]${dot}CONNECTED}#[default] `);
+}
+export function buildTmuxStatusRight(opts = {}) {
+    const warn = opts.ascii ? '!!' : '⚠';
+    const dot = '·';
+    return ('#[fg=#45d17f]#{@nb_running} run#[default] ' +
+        `#[fg=#8a93a6]${dot} #{@nb_done} done` +
+        `#{?#{@nb_failed}, #[fg=#ff5c6c]${dot} #{@nb_failed} fail,}#[default] ` +
+        `#{?#{@nb_needsyou},#[fg=#ffb454,bold]${dot} ${warn} #{@nb_needsyou} NEEDS YOU ,}` +
+        `#[fg=#58c7e6]${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.5';
+export const VERSION = '0.9.7';

package/package.json

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