@aragon-agent/cli 0.6.8 → 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,7 +41,6 @@ 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';
@@ -96,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,
@@ -230,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.
@@ -389,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
@@ -442,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;
@@ -492,21 +488,13 @@ function runInteractive(flags, extras = {}) {
         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
@@ -539,11 +527,11 @@ function runInteractive(flags, extras = {}) {
     // than printing zeroes that read like a writer doing nothing (§5.4).
     if (frameWriter)
         setFrameStatsProvider(frameWriter.stats);
-    const frameObserver = mode === 'fullscreen' ? createFrameObserver({
+    const frameObserver = createFrameObserver({
         stdout: frameWriter?.stdout ?? process.stdout, terminal: process.stdout, scrollbar,
-    }) : null;
+    });
     const disposeFrameWriter = () => {
-        frameObserver?.dispose();
+        frameObserver.dispose();
         pointerRouter?.dispose();
         scrollbar.controller?.dispose();
         if (!frameWriter)
@@ -552,7 +540,7 @@ function runInteractive(flags, extras = {}) {
         frameWriter.dispose();
     };
     const replayTranscript = () => {
-        if (replayed || mode !== 'fullscreen' || !config.exitTranscript)
+        if (replayed || !config.exitTranscript)
             return;
         replayed = true;
         const snapshot = readExitSnapshot();
@@ -571,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.
@@ -585,7 +573,7 @@ function runInteractive(flags, extras = {}) {
         screen = enterAltScreen(process.stdout, {
             mouse: mouseOn,
             motion: mouseOn,
-            bracketedPaste: pasteOn && mode === 'fullscreen',
+            bracketedPaste: pasteOn,
         });
         const restore = () => screen?.restore();
         // Four idempotent restore paths (§4.4). The signal hook is NOT redundant:
@@ -610,42 +598,6 @@ 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) => { frameObserver?.invalidate(); frameWriter.writeForeign(text); }
         : process.stdout.isTTY
@@ -695,45 +647,30 @@ 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,
-            ...(mode === 'fullscreen' ? { 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 } : {}),
-        }
-        : 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;
@@ -761,12 +698,7 @@ function runInteractive(flags, extras = {}) {
         config.update.mode !== 'off';
     let instance;
     try {
-        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, 
+        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
@@ -780,17 +712,11 @@ function runInteractive(flags, extras = {}) {
         // straight to stdout and permanently shifts the fixed frame's accounting.
         {
             exitOnCtrlC: false,
-            patchConsole: mode === 'inline',
+            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,
-            // 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.
-            ...(frameObserver ? { stdout: frameObserver.stdout } : {}),
+            stdout: frameObserver.stdout,
         });
     }
     catch (error) {
@@ -968,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
@@ -1189,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;
@@ -1480,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:
@@ -1512,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/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

@@ -89,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.
@@ -101,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;