@aragon-agent/cli 0.6.7 → 0.6.9

package/dist/cli.js

@@ -15,7 +15,8 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import process from 'node:process';
 import '../runtime/insecure-tls-warning.cjs';
-import { render } from 'ink';
+// Must precede every other dependency that imports Ink: CI detection is cached.
+import { render } from './ui/ink-runtime.js';
 import { Command } from 'commander';
 import { loadConfig } from './config/load.js';
 import { getConfigPath, readConfigFile, updatePersistedConfig } from './config/store.js';
@@ -40,11 +41,13 @@ import { registerExecCommand } from './exec/cli-commands.js';
 import { registerSessionsCommand } from './session/cli-commands.js';
 import { registerDoctorCommand, registerInfoCommand } from './diagnostics/cli-commands.js';
 import { App } from './ui/App.js';
-import { decideRenderMode } from './ui/layout/frame.js';
 import { createFrameDiffer } from './ui/frame-differ.js';
 import { wrapStdoutForFrames } from './ui/stdout-frame-writer.js';
 import { setFrameStatsProvider } from './commands/perf.js';
 import { tryCreateStdinFilter } from './input/stdin-filter.js';
+import { createScrollbarBridge } from './ui/scrollbar-controller.js';
+import { createPointerRouter } from './input/pointer-router.js';
+import { createFrameObserver } from './ui/frame-observer.js';
 import { enterAltScreen, writeExitTranscript } from './ui/screen.js';
 import { supportsWindowsVtInput } from './ui/win-vt-input.js';
 import { forceWindowsVtInput } from './ui/win-vt-force.js';
@@ -93,7 +96,6 @@ function toFlags(opts) {
         confirm: opts.confirm,
         toolTimeout: opts.toolTimeout,
         idleTimeout: opts.idleTimeout,
-        fullscreen: opts.fullscreen,
         exitTranscript: opts.exitTranscript,
         compact: opts.compact,
         hints: opts.hints,
@@ -227,14 +229,8 @@ function makeController(flags, opts = { interactive: true }) {
     // resolved a bootstrap level — it ran before commander and before `.env` were
     // readable — and without this hand-off the fully resolved one never applies.
     getLogger().reconfigure(config.log);
-    // Whether this session could EVER show the todo rail (todo-plan-execution
-    // §3.7 / P1-6). It varies ONE sentence of `<todo_planning>`; `decideRenderMode`
-    // is pure and `runInteractive` calls it again with the same inputs, so
-    // computing it here rather than threading it back costs nothing and keeps the
-    // controller's construction self-contained.
-    const todoPanelCapable = opts.interactive &&
-        decideRenderMode({ fullscreen: config.fullscreen }, process.env, process.stdout) ===
-            'fullscreen';
+    // Headless controllers never expose the task panel.
+    const todoPanelCapable = opts.interactive;
     const confirmBridge = { handler: null };
     // `cancelPending` is replaced by the App's own implementation on mount; this
     // no-op keeps the object total so nothing has to null-check it.
@@ -386,11 +382,15 @@ function forceVtInputForThisConsole() {
  * renders Ink, `runOneShot()` goes to `runHeadless()`, which never does.
  */
 function runInteractive(flags, extras = {}) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        process.stderr.write('Interactive UI requires a TTY. Use -p "<prompt>", exec, or config list / config set.\n');
+        process.exitCode = 2;
+        return;
+    }
     const { controller, confirmBridge, humanInputBridge } = makeController(flags);
     const config = controller.getConfig();
-    const mode = decideRenderMode({ fullscreen: config.fullscreen }, process.env, process.stdout);
     const logger = getLogger();
-    logger.info('cli', 'run_interactive', { mode, provider: config.provider, model: config.model });
+    logger.info('cli', 'run_interactive', { mode: 'fullscreen', provider: config.provider, model: config.model });
     attachAgentEvents(logger, controller);
     // The team stream is CLI-local (D-10), so `attachAgentEvents` cannot see it.
     // Without this a dispatch leaves NO trace in the log file at all — the wrong
@@ -439,8 +439,7 @@ function runInteractive(flags, extras = {}) {
     // a console this process just repaired.
     const vtInputByNode = supportsWindowsVtInput(process.platform, process.versions.node);
     const vtInputSupported = vtInputByNode || forceVtInputForThisConsole();
-    const wantMouse = mode === 'fullscreen' &&
-        config.mouse &&
+    const wantMouse = config.mouse &&
         !!process.stdout.isTTY &&
         !!process.stdin.isTTY &&
         vtInputSupported;
@@ -476,33 +475,26 @@ function runInteractive(flags, extras = {}) {
     const disposeStdinFilter = () => filter?.dispose();
     // --- Drag-select (tui-selection-and-scroll-follow §4.4). ------------------
     //
-    // ONE EXPRESSION, READ BY FOUR THINGS, and that is the same discipline
-    // `wantMouse` above follows for the same reason: the `?1002h` write, the
-    // controller, the differ's `decorate` hook and the startup notice must never
-    // disagree about whether drag-select is running. With it false the session is
-    // byte-identical to a pre-feature build — no extra escape on the wire (AC-8),
-    // no controller, no `decorate`, no mirror.
+    // Selection owns its controller, decoration and notice. Button motion follows
+    // mouseOn independently so --no-mouse-select still permits scrollbar dragging.
     const wantSelect = mouseOn && config.mouseSelect;
+    let mouseCaptured = mouseOn;
+    const scrollbar = createScrollbarBridge(() => mouseCaptured);
+    const pointerRouter = mouseOn && filter ? createPointerRouter({
+        source: filter.source, handle: (event) => scrollbar.controller?.handle(event) ?? false,
+    }) : null;
     const selectionBridge = {
         controller: null,
         onCopied: null,
         requestRedraw: null,
     };
-    // --- Frame differ (tui-input-flicker-fix §3.2 / §4.2). -------------------
-    //
-    // FULL-SCREEN ONLY, and that is invariant I-3 rather than caution: inline mode
-    // prints settled entries through Ink's `<Static>`, starts wherever the shell's
-    // cursor happened to be and scrolls, so row k of a frame is not absolute row k
-    // there and never will be. `--no-diff-render` skips construction entirely,
-    // which is what makes rung 2 of the fail-safe ladder byte-identical to a
-    // pre-fix build rather than merely equivalent.
-    //
-    // `rows` is a THUNK, not a snapshot: it is the only input to the I-9 geometry
-    // guard and it changes under the differ's feet on every resize.
-    const frameWriter = mode === 'fullscreen' && config.diffRender
+    const frameWriter = config.diffRender
         ? wrapStdoutForFrames(process.stdout, createFrameDiffer({
             sync: config.syncOutput && process.env.TERM !== 'dumb',
             rows: () => process.stdout.rows,
+            // Rows that fill the line skip `CSI K` so the scrollbar's last column
+            // is not erased on pending-wrap terminals (frame-differ I-4).
+            cols: () => process.stdout.columns,
             // The console bridge (`App.tsx`, full-screen only) turns this into
             // `dispatch({type:'notice', level:'warn'})`, which is the only legal
             // user-visible channel with the TUI mounted — a direct write would
@@ -535,14 +527,20 @@ function runInteractive(flags, extras = {}) {
     // than printing zeroes that read like a writer doing nothing (§5.4).
     if (frameWriter)
         setFrameStatsProvider(frameWriter.stats);
+    const frameObserver = createFrameObserver({
+        stdout: frameWriter?.stdout ?? process.stdout, terminal: process.stdout, scrollbar,
+    });
     const disposeFrameWriter = () => {
+        frameObserver.dispose();
+        pointerRouter?.dispose();
+        scrollbar.controller?.dispose();
         if (!frameWriter)
             return;
         setFrameStatsProvider(null);
         frameWriter.dispose();
     };
     const replayTranscript = () => {
-        if (replayed || mode !== 'fullscreen' || !config.exitTranscript)
+        if (replayed || !config.exitTranscript)
             return;
         replayed = true;
         const snapshot = readExitSnapshot();
@@ -561,7 +559,7 @@ function runInteractive(flags, extras = {}) {
             ...(snapshot.droppedEntries ? { droppedEntries: snapshot.droppedEntries } : {}),
         }));
     };
-    if (mode === 'fullscreen') {
+    {
         // `mouse` here means "a mouse-parsing filter is installed", NOT "the user
         // wants mouse support" — see `AltScreenOptions`. `screen.ts` must never
         // derive it for itself, or a later refactor re-opens the gap I-8 closes.
@@ -574,8 +572,8 @@ function runInteractive(flags, extras = {}) {
         // keep their terminal's own selection.
         screen = enterAltScreen(process.stdout, {
             mouse: mouseOn,
-            motion: wantSelect,
-            bracketedPaste: pasteOn && mode === 'fullscreen',
+            motion: mouseOn,
+            bracketedPaste: pasteOn,
         });
         const restore = () => screen?.restore();
         // Four idempotent restore paths (§4.4). The signal hook is NOT redundant:
@@ -600,44 +598,8 @@ function runInteractive(flags, extras = {}) {
             process.exit(128 + signo);
         });
     }
-    // --- Auto-update (cli-auto-update section 3.8). --------------------------
-    //
-    // THE ONLY CONSTRUCTION SITE. `runOneShot` / `runHeadless` never reach this
-    // function, so `aragon -p` executes zero update code and its stdout is
-    // byte-identical to a pre-feature build (AC-1); `aragon config <subcommand>`,
-    // `aragon logs`, `aragon skills` and `aragon --version` likewise. Bare
-    // `aragon config` DOES construct it, because it is a full interactive session
-    // with a settings overlay on top - which is correct, and is why AC-1's claim
-    // names the SUBCOMMAND form.
-    //
-    // `CI` is excluded on top of the two TTY tests because a CI runner with a pty
-    // allocated is otherwise a machine that silently mutates its own global
-    // toolchain mid-pipeline (D-11).
-    // --- The foreign-write door (§4.4.5). ------------------------------------
-    //
-    // Where bytes that are OURS but are NOT a frame go — today, the OSC 52
-    // clipboard sequence. THREE SHAPES, ONE DOOR, and the third one is the reason
-    // this is a resolved value rather than an inline arrow:
-    //
-    //  * with the differ in front of stdout it MUST be `frameWriter.writeForeign`,
-    //    which invalidates the cache and skips the fallback accounting — through
-    //    the proxy the same bytes are an unrecognised chunk, which is
-    //    `passThrough(true)`, which prints `FRAME_FALLBACK_NOTICE` at a user who
-    //    did nothing but copy something (P1-6);
-    //  * without one — `--no-diff-render`, and inline mode, which never builds a
-    //    differ at all — stdout IS the real stream, so a direct write is both safe
-    //    and what §4.4.5 prescribes. OSC 52 emits no newline, so Ink's own line
-    //    accounting is untouched and there is nothing to invalidate;
-    //  * on a non-TTY there is no terminal to accept it, so the door is ABSENT.
-    //
-    // It must never be a function that accepts a chunk and writes NOWHERE.
-    // `copyText` reports `'osc52'` whenever its door took the text, so a silent
-    // no-op door — which `frameWriter?.writeForeign(chunk)` is under
-    // `--no-diff-render` — makes the toast name a mechanism that was never
-    // attempted. Naming the mechanism honestly is the entire reason that return
-    // value exists (R-7), and a door that lies is worse than no door.
     const writeForeign = frameWriter
-        ? (text) => frameWriter.writeForeign(text)
+        ? (text) => { frameObserver?.invalidate(); frameWriter.writeForeign(text); }
         : process.stdout.isTTY
             ? (text) => {
                 try {
@@ -659,10 +621,9 @@ function runInteractive(flags, extras = {}) {
     // than inside `screen.ts`'s closure because `App` needs to READ it and the
     // handle's own flag is private (it has to be — `restore()` reads it, and
     // exposing a setter would be a second way to get the two out of step).
-    let mouseCaptured = mouseOn;
     if (wantSelect && filter) {
         selectionBridge.controller = createSelectionController({
-            source: filter.source,
+            source: pointerRouter?.selectionSource ?? filter.source,
             // The frame writer is absent under `--no-diff-render`, where there is no
             // cache to repaint from at all; the controller then falls back to asking
             // `App` for a React redraw on every drag flush, which is slower and
@@ -686,79 +647,82 @@ function runInteractive(flags, extras = {}) {
         selectionBridge.controller?.dispose();
         selectionBridge.controller = null;
     };
-    /**
-     * The terminal-facing services `App` cannot build for itself (§4.4).
-     *
-     * PRESENT IN INLINE MODE TOO, and only for the foreign-write door: §4.4.5
-     * routes `/copy` through `ui/clipboard.ts` precisely so it gains OSC 52 — the
-     * one mechanism that reaches the clipboard of the machine the USER is sitting
-     * at over SSH — and gating the whole bridge on full-screen would have handed
-     * that back only to full-screen users while the command is available in both.
-     * Every OTHER field stays absent there, so the inline tree is unchanged: there
-     * is no filter, hence no `setMouseCapture` and no `ctx.mouse`; `mouseSelect`
-     * is `wantSelect`, which is already false without one; and there is no
-     * controller, so no `selection`.
-     */
-    const terminalBridge = mode === 'fullscreen' || writeForeign
-        ? {
-            mouseSelect: wantSelect,
-            ...(mouseOn
-                ? {
-                    setMouseCapture: (on) => {
-                        screen?.setMouseCapture(on);
-                        mouseCaptured = on;
-                        // A released mouse cannot be dragging, and a selection left
-                        // painted over a screen the terminal is now selecting on its
-                        // own would be two highlights claiming the same rows.
-                        if (!on)
-                            selectionBridge.controller?.clear();
-                    },
-                    isMouseCaptured: () => mouseCaptured,
-                }
-                : {}),
-            // The same door the controller copies through, so `/copy` and a
-            // drag-release can never disagree about which stream OSC 52 goes to.
-            ...(writeForeign ? { writeForeign } : {}),
-            ...(selectionBridge.controller ? { selection: selectionBridge } : {}),
-        }
-        : undefined;
+    const terminalBridge = {
+        mouseSelect: wantSelect,
+        scrollbar,
+        ...(mouseOn
+            ? {
+                setMouseCapture: (on) => {
+                    screen?.setMouseCapture(on);
+                    mouseCaptured = on;
+                    if (!on)
+                        scrollbar.controller?.cancel();
+                    // A released mouse cannot be dragging, and a selection left
+                    // painted over a screen the terminal is now selecting on its
+                    // own would be two highlights claiming the same rows.
+                    if (!on)
+                        selectionBridge.controller?.clear();
+                },
+                isMouseCaptured: () => mouseCaptured,
+            }
+            : {}),
+        // The same door the controller copies through, so `/copy` and a
+        // drag-release can never disagree about which stream OSC 52 goes to.
+        ...(writeForeign ? { writeForeign } : {}),
+        ...(selectionBridge.controller ? { selection: selectionBridge } : {}),
+    };
     const updateBridge = { service: null, onAttach: null };
     let updateService = null;
+    let interactiveClosed = false;
+    const failInteractive = (error) => {
+        // Ink consumes render exceptions; retain failure even if a disposer throws.
+        process.exitCode = 1;
+        interactiveClosed = true;
+        logger.error('cli', 'render_failed', { error: String(error) });
+        for (const cleanup of [
+            () => screen?.restore(), disposeSelection, disposeStdinFilter, disposeFrameWriter,
+            () => controller.abort(), () => controller.dispose(), () => updateService?.dispose(),
+            () => { process.stdin.pause(); process.stdin.unref?.(); },
+        ]) {
+            try {
+                cleanup();
+            }
+            catch (cleanupError) {
+                logger.error('cli', 'render_cleanup_failed', { error: String(cleanupError) });
+            }
+        }
+    };
     const updateEligible = !!process.stdout.isTTY &&
         !!process.stdin.isTTY &&
         !process.env.CI &&
         config.update.mode !== 'off';
-    const instance = render(_jsx(App, { controller: controller, version: VERSION, mode: mode, confirmBridge: confirmBridge, humanInputBridge: humanInputBridge, initialPrompt: extras.initialPrompt, initialOverlay: extras.initialOverlay, 
-        // `mouseOn`, NOT the handle (I-11). `App.tsx:186-188` documents this
-        // prop's contract as "absent under `--no-mouse`, inline, or non-TTY", and
-        // it feeds `enabled: !!mouseSource` on a wheel subscription that would
-        // otherwise be a channel no event can ever arrive on.
-        mouseSource: mouseOn && filter ? filter.source : undefined, 
-        // Present ONLY when this console swallows `CSI Z` and mouse reports.
-        // Passed in rather than probed inside `App` so that every test renders
-        // the same tree on every machine — reading `process.versions.node` from
-        // a component would make the notice appear or vanish according to which
-        // Node the developer happened to have installed.
-        vtInputWarning: vtInputSupported ? undefined : { nodeVersion: process.versions.node }, updateBridge: updateEligible ? updateBridge : undefined, 
-        // Absent when nothing can refuse a paste, so a `--no-paste` tree is
-        // byte-identical to a build without this feature.
-        pasteBridge: pasteOn ? pasteBridge : undefined, terminal: terminalBridge }), 
-    // Full-screen owns console.* itself (I-4): Ink's patchConsole writes
-    // straight to stdout and permanently shifts the fixed frame's accounting.
-    {
-        exitOnCtrlC: false,
-        patchConsole: mode === 'inline',
-        // I-5: with mouse support off the REAL stdin is handed over unwrapped, so
-        // every existing path is provably unchanged.
-        stdin: filter?.stdin ?? process.stdin,
-        // SPREAD, not `frameWriter?.stdout ?? process.stdout`. This call passed no
-        // `stdout` at all before, and Ink defaults it to `process.stdout`; omitting
-        // the key entirely when the writer is off keeps the options object the same
-        // SHAPE it has always had, which is what makes AC-5 / AC-6 ("byte-identical
-        // with --no-diff-render, inline mode and `aragon -p`") a statement about
-        // the code rather than about Ink's defaulting.
-        ...(frameWriter ? { stdout: frameWriter.stdout } : {}),
-    });
+    let instance;
+    try {
+        instance = render(_jsx(App, { controller: controller, version: VERSION, confirmBridge: confirmBridge, humanInputBridge: humanInputBridge, initialPrompt: extras.initialPrompt, initialOverlay: extras.initialOverlay, mouseSource: mouseOn && filter ? filter.source : undefined, 
+            // Present ONLY when this console swallows `CSI Z` and mouse reports.
+            // Passed in rather than probed inside `App` so that every test renders
+            // the same tree on every machine — reading `process.versions.node` from
+            // a component would make the notice appear or vanish according to which
+            // Node the developer happened to have installed.
+            vtInputWarning: vtInputSupported ? undefined : { nodeVersion: process.versions.node }, updateBridge: updateEligible ? updateBridge : undefined, 
+            // Absent when nothing can refuse a paste, so a `--no-paste` tree is
+            // byte-identical to a build without this feature.
+            pasteBridge: pasteOn ? pasteBridge : undefined, terminal: terminalBridge }), 
+        // Full-screen owns console.* itself (I-4): Ink's patchConsole writes
+        // straight to stdout and permanently shifts the fixed frame's accounting.
+        {
+            exitOnCtrlC: false,
+            patchConsole: false,
+            // I-5: with mouse support off the REAL stdin is handed over unwrapped, so
+            // every existing path is provably unchanged.
+            stdin: filter?.stdin ?? process.stdin,
+            stdout: frameObserver.stdout,
+        });
+    }
+    catch (error) {
+        failInteractive(error);
+        throw error;
+    }
     // H1's primary disarm, and this is the earliest moment at which "this build
     // STARTS" is proven: the module graph loaded, config resolved, Ink mounted
     // (cli-auto-update-hardening section 5.1.4). It is what makes a long session
@@ -780,6 +744,8 @@ function runInteractive(flags, extras = {}) {
         // must degrade to "no updater", never to a crashed TUI.
         void import('./update/service.js')
             .then(({ UpdateService }) => {
+            if (interactiveClosed)
+                return;
             const service = new UpdateService({ config: config.update, currentVersion: VERSION });
             updateService = service;
             updateBridge.service = service;
@@ -810,6 +776,7 @@ function runInteractive(flags, extras = {}) {
     void instance
         .waitUntilExit()
         .then(() => {
+        interactiveClosed = true;
         screen?.restore();
         // BEFORE `disposeStdinFilter()`, which clears the listener set it subscribed to,
         // and after `restore()` for the reason that call records: the terminal must
@@ -838,18 +805,7 @@ function runInteractive(flags, extras = {}) {
         updateService?.dispose();
         replayTranscript();
     })
-        .catch(() => {
-        screen?.restore();
-        // BEFORE `disposeStdinFilter()`, which clears the listener set it subscribed to,
-        // and after `restore()` for the reason that call records: the terminal must
-        // stop reporting first, and anything already in flight is still consumed by
-        // a live filter.
-        disposeSelection();
-        disposeStdinFilter();
-        disposeFrameWriter();
-        controller.dispose();
-        updateService?.dispose();
-    });
+        .catch(failInteractive);
 }
 async function runOneShot(flags, prompt, quiet) {
     // Headless: no App is ever rendered, so there is no human to approve a skill
@@ -938,7 +894,6 @@ const CONFIG_SET_KEYS = new Set([
     'confirmTools',
     'toolTimeoutMs',
     'idleTimeoutMs',
-    'fullscreen',
     'exitTranscript',
     'transcriptWindow',
     // tui-render-performance L1 / L4. Listed here AND cased in the switch
@@ -1159,9 +1114,6 @@ function runConfigSet(key, value) {
         case 'idleTimeoutMs':
             patch.idleTimeoutMs = coercePositiveInt(value, 210_000);
             break;
-        case 'fullscreen':
-            patch.fullscreen = value === 'true' || value === '1';
-            break;
         case 'exitTranscript':
             patch.exitTranscript = value === 'true' || value === '1';
             break;
@@ -1450,30 +1402,16 @@ function buildProgram() {
         .option('--tool-timeout <ms>', 'Per-tool executor ceiling (default 180000)')
         .option('--idle-timeout <ms>', 'Watchdog idle timeout (auto-raised to >= tool-timeout+30s)')
         .option('--theme <name>', 'auto|warm|cool|light ("dark" is an alias for "cool")')
-        // Same tri-state shape as `--fullscreen`: declaring the positive form first
-        // keeps the default `undefined`, so "no opinion" stays distinguishable from
-        // an explicit choice and the config layer below can still win.
         .option('--compact', 'Compact transcript density (no blank rows between turns)')
         .option('--no-compact', 'Comfortable transcript density')
         .option('--hints', 'Always show the composer hint row')
         .option('--no-hints', 'Hide the composer hint row')
-        // Positive form first, same tri-state reason as `--fullscreen` above.
         .option('--show-thinking', 'Show the reasoning blocks the model returns')
         .option('--no-show-thinking', 'Hide reasoning blocks (the default)')
-        // Positive form first, same tri-state reason as `--fullscreen` above. The
-        // pair matters more here than for its neighbour because this key defaults to
-        // ON: a lone negative form would let commander synthesize `true` and
-        // overwrite a stored `false` on every run that passed no flag at all.
         .option('--live-tool-output', 'Show a running command output tail (the default)')
         .option('--no-live-tool-output', 'Keep a running tool card to one line')
-        // Positive form first, same tri-state reason as `--fullscreen` above.
         .option('--mouse', 'Wheel scrolls the transcript (full-screen mode)')
         .option('--no-mouse', 'Leave the mouse to the terminal (the wheel does nothing)')
-        // Positive form FIRST, for the tri-state reason `--fullscreen` records
-        // below: `mouseSelect` is persisted and defaults to `true`, so a lone
-        // `--no-mouse-select` would make commander default `opts.mouseSelect` to
-        // `true` — indistinguishable from silence, and silently overriding a stored
-        // `false` on every run that passes no flag at all.
         .option('--mouse-select', 'Drag with the mouse to select text; releasing copies it')
         .option('--no-mouse-select', 'Keep wheel scrolling, but leave drag-select off')
         // Positive form FIRST, same tri-state reason as `--mouse-select` above:
@@ -1482,16 +1420,7 @@ function buildProgram() {
         // silence, and silently overriding a stored `false` on every run.
         .option('--paste', 'Collapse large pastes into a placeholder (the default)')
         .option('--no-paste', 'Treat pasted bytes as keystrokes (pre-0.6.3 behavior)')
-        // Declaring `--fullscreen` BEFORE `--no-fullscreen` keeps the default
-        // `undefined` instead of `true`, which is what makes the tri-state work:
-        // "no opinion" must stay distinguishable from "force it".
-        .option('--fullscreen', 'Force the full-screen TUI (overrides auto-downgrade, except non-TTY)')
-        .option('--no-fullscreen', 'Force the inline renderer (v0.2.0 behavior)')
         .option('--no-exit-transcript', 'Do not replay the session summary after exiting')
-        // Same tri-state shape as `--fullscreen`: the positive form is declared
-        // FIRST so the default stays `undefined` and "no opinion" remains
-        // distinguishable from an explicit `--no-plan`, which is what lets the
-        // config layer win when neither flag was given.
         .option('--plan', 'Start the session in PLAN mode (read-only research + review)')
         .option('--no-plan', 'Start the session in BUILD mode (overrides planModeDefault)')
         // BOTH FORMS, positive first, and the pair is mandatory (team-subagents

package/dist/commands/builtins.js

@@ -724,7 +724,9 @@ const COMMANDS = [
                 // slash history already has. Putting this canned paragraph under the
                 // composer's up-arrow as well would be the same event recorded twice, in
                 // the more verbose of the two forms (AC-17).
-                ctx.submit(buildContinuationMessage(snapshot), { userInitiated: false });
+                ctx.submit(buildContinuationMessage(snapshot), {
+                    userInitiated: false, todoPolicy: 'continue',
+                });
                 return;
             }
             ctx.notify('warn', `Unknown argument "${verb}" - use ` +

package/dist/commands/perf.d.ts

@@ -16,6 +16,7 @@
  * display would be self-defeating.
  */
 import type { FrameWriterStats } from '../ui/frame-differ.js';
+import type { ScrollbarBridge } from '../ui/scrollbar-controller.js';
 import type { SlashCommand } from './registry.js';
 export interface PerfSnapshot {
     /** Governor rung, its resolved interval, and the last measured commit cost. */
@@ -33,10 +34,39 @@ export interface PerfSnapshot {
     heightsEstimated: number;
     cols: number;
     /** Geometry. */
-    mode: 'fullscreen' | 'inline';
+    mode: 'fullscreen';
     viewportRows: number;
     offset: number;
+    /** Right-edge scrollbar diagnostics; read lazily so it reflects the live bridge. */
+    scrollbar?: ScrollbarPerf;
 }
+/**
+ * Why the right-edge scrollbar is or is not usable, in one record
+ * (tui-scrollbar-edge-and-run-row section 3.2). "Cannot see it" and "cannot drag
+ * it" had no self-check before; each field below separates one cause.
+ */
+export interface ScrollbarPerf {
+    /** 1-based terminal column of the track, or `null` before the first layout. */
+    trackCol: number | null;
+    trackRows: number | null;
+    /** Mouse capture is on. Off keeps the track visible but not draggable. */
+    mouseOn: boolean;
+    /** A full frame matching the geometry was observed, so pointer hits are trusted. */
+    frameReady: boolean;
+    thumb: {
+        start: number;
+        size: number;
+    } | null;
+    unicode: boolean;
+    /** `skipped`: the differ omits CSI K on full-width rows; `n/a`: diff render is off. */
+    edgeEl: 'skipped' | 'always' | 'n/a';
+}
+/** Build the diagnostics record from the live bridge (called at `/perf` time). */
+export declare function readScrollbarPerf(opts: {
+    bridge: ScrollbarBridge | undefined;
+    diffRender: boolean;
+    unicode: boolean;
+}): ScrollbarPerf | undefined;
 /** Called by `App`. Passing `null` detaches. */
 export declare function setPerfSnapshotProvider(fn: (() => PerfSnapshot | null) | null): void;
 export declare function readPerfSnapshot(): PerfSnapshot | null;
@@ -44,6 +74,6 @@ export declare function setPerfResetHook(fn: (() => void) | null): void;
 /** Called by `cli.tsx` after building the writer. Passing `null` detaches. */
 export declare function setFrameStatsProvider(fn: (() => FrameWriterStats) | null): void;
 export declare function readFrameStats(): FrameWriterStats | null;
-/** Format a snapshot as the six-line block documented in §5.4. */
+/** Format a snapshot as the six-line block documented in §5.4 (plus the scrollbar line). */
 export declare function formatPerfReport(snap: PerfSnapshot): string;
 export declare const perfCommand: SlashCommand;

package/dist/commands/perf.js

@@ -16,6 +16,23 @@
  * display would be self-defeating.
  */
 import { clearRenderCaches, renderCacheStats } from '../ui/render-cache.js';
+/** Build the diagnostics record from the live bridge (called at `/perf` time). */
+export function readScrollbarPerf(opts) {
+    const { bridge, diffRender, unicode } = opts;
+    if (!bridge)
+        return undefined;
+    const geometry = bridge.geometry;
+    return {
+        trackCol: geometry?.trackCol ?? null,
+        trackRows: geometry?.trackRows ?? null,
+        mouseOn: bridge.isEnabled(),
+        frameReady: bridge.frameReady,
+        thumb: geometry?.thumb ? { start: geometry.thumb.start, size: geometry.thumb.size } : null,
+        unicode,
+        // `cli.tsx` always wires `cols` when it builds the differ.
+        edgeEl: diffRender ? 'skipped' : 'n/a',
+    };
+}
 /** Cleared on unmount, so `/perf` in a torn-down tree says so instead of lying. */
 let provider = null;
 /** Called by `App`. Passing `null` detaches. */
@@ -39,7 +56,7 @@ export function setPerfResetHook(fn) {
  * render — so routing them through a 1900-line component's props would buy
  * nothing and cost `App.tsx` plus `app.test.tsx` churn (P1-2).
  *
- * `null` means the writer was never built — `--no-diff-render`, inline mode, or
+ * `null` means the writer was never built — `--no-diff-render` or
  * a non-interactive path. `/perf` says so in words, so "the flag is off" and
  * "the writer crashed" never look alike.
  */
@@ -74,11 +91,23 @@ function formatWriterLine() {
         `lines/frame ${ratio(stats.linesWritten, stats.framesTotal)}  -  ` +
         `bytes/frame ${bytesPerFrame}  -  fallbacks ${stats.fallbacks}`);
 }
-/** Format a snapshot as the six-line block documented in §5.4. */
+function formatScrollbarLine(bar) {
+    const thumb = bar.thumb ? `${bar.thumb.start}+${bar.thumb.size}` : 'none';
+    const line = `scrollbar  col=${bar.trackCol ?? '-'} rows=${bar.trackRows ?? '-'} ` +
+        `mouse=${bar.mouseOn ? 'on' : 'off'} frameReady=${bar.frameReady ? 'yes' : 'no'} ` +
+        `thumb=${thumb} glyphs=${bar.unicode ? 'unicode' : 'ascii'} edge-el=${bar.edgeEl}`;
+    if (!bar.mouseOn || bar.frameReady)
+        return line;
+    const size = bar.trackCol !== null && bar.trackRows !== null
+        ? `${bar.trackCol}x${bar.trackRows + 4}` : 'the terminal size';
+    return `${line}\n           waiting for a full frame matching ${size}`;
+}
+/** Format a snapshot as the six-line block documented in §5.4 (plus the scrollbar line). */
 export function formatPerfReport(snap) {
     const caches = renderCacheStats();
     const eco = snap.rung > 0 ? '  -  eco' : '';
     const governor = snap.governorEnabled ? '' : '  -  governor off';
+    const scrollbar = snap.scrollbar ? [formatScrollbarLine(snap.scrollbar)] : [];
     return [
         `render     rung ${snap.rung}  -  interval ${snap.intervalMs}ms  -  last commit ` +
             `${Math.round(snap.lastCommitMs)}ms${eco}${governor}`,
@@ -91,6 +120,7 @@ export function formatPerfReport(snap) {
             `lines ${caches.lineEntries}`,
         `mode       ${snap.mode}  -  viewport ${snap.viewportRows} rows  -  offset ${snap.offset}`,
         formatWriterLine(),
+        ...scrollbar,
     ].join('\n');
 }
 export const perfCommand = {

package/dist/commands/registry.d.ts

@@ -2,6 +2,7 @@
  * Slash-command registry + dispatcher (spec §5.2). A leading `/` in the prompt
  * input is routed here instead of to the agent; `//` is the literal-`/` escape.
  */
+import type { SubmitMessageOptions } from '../agent/prompt-options.js';
 import type { AgentController } from '../agent/controller.js';
 import type { AgentMode } from '../agent/agent-mode.js';
 import type { NoticeLevel, Overlay, ToastLevel, ViewAction, ViewState } from '../agent/reducer.js';
@@ -38,9 +39,7 @@ export interface CommandContext {
      * (P1-5): `builtins.ts` reaches `submitMessage` only through here, so
      * `/todo continue` cannot opt out of prompt history without it.
      */
-    submit: (text: string, opts?: {
-        userInitiated?: boolean;
-    }) => void;
+    submit: (text: string, opts?: SubmitMessageOptions) => void;
     /**
      * The live auto-continue budget, for `/todo status`'s `(2/25 used)` clause
      * (todo-plan-followthrough §4.3).
@@ -90,7 +89,7 @@ export interface CommandContext {
     /**
      * Mouse capture, for `/mouse` (tui-selection-and-scroll-follow §6.2 / G3).
      *
-     * OPTIONAL, and legitimately absent: inline mode, `--no-mouse`, a non-TTY, a
+     * OPTIONAL, and legitimately absent: `--no-mouse`, a non-TTY, a
      * Windows console that cannot deliver reports, and every test that builds this
      * context by literal. `/mouse` has to have something honest to say when it is
      * missing, which is the same reason `update` above it is optional.
@@ -102,7 +101,7 @@ export interface CommandContext {
      * NOT `process.stdout.write`. In full-screen mode stdout is a `Proxy` in front
      * of the frame differ, and an unrecognised chunk there is counted as a foreign
      * write and prints a diagnostic at the user the first time they copy anything
-     * (P1-6). Absent in inline mode and with `--no-diff-render`, where the real
+     * (P1-6). Absent with `--no-diff-render`, where the real
      * stream is handed over directly.
      */
     writeForeign?: (text: string) => void;