@aragon-agent/cli 0.6.8 → 0.6.10

package/dist/agent/reducer.js

@@ -289,6 +289,29 @@ function nextId(state) {
 function mapEntry(entries, id, fn) {
     return entries.map((e) => (e.id === id ? fn(e) : e));
 }
+/**
+ * Rewrite every `queued` entry in place as the user message it became
+ * (tui-shift-enter-copy-queue 5.2.3).
+ *
+ * SAME ID, NEW OBJECT -- the `mapEntry` discipline for a non-append change:
+ * the position (and therefore the settled boundary, which advances by
+ * POSITION and never by identity) is untouched, while the new object
+ * reference is what lets `React.memo` and the height cache see that this
+ * one row changed. ALL of them at once, because `drainSteering` is a full
+ * drain: converting only some would show a partial acceptance that never
+ * happened. Identity-preserving when nothing is queued -- `turnStart` fires
+ * every turn, and this must stay free for the common case.
+ */
+function convertQueuedEntries(entries) {
+    let touched = false;
+    const next = entries.map((e) => {
+        if (e.kind !== 'queued')
+            return e;
+        touched = true;
+        return { id: e.id, kind: 'user', text: e.text };
+    });
+    return touched ? next : entries;
+}
 /**
  * Seal `thinkingMs`, once, as a spreadable patch (§3.1.2).
  *
@@ -382,31 +405,6 @@ function settleRetryCard(state, entries, phase) {
         retryEntryId: undefined,
     };
 }
-/**
- * EVERY PATH THAT REACHES `status: 'idle'` RELEASES THE LIVE TAIL (D-35 / AC-40).
- *
- * `runEnd` finalizes only the streaming ASSISTANT entry and `abortMark` maps only
- * assistant entries, so neither touches a tool entry stranded at
- * `status: 'running'` -- the engine's own idle watchdog, a provider error mid-call
- * and `Esc` all produce one. Today that costs a single spinner row. With a tail
- * attached it costs a permanent multi-row card whose stall counter is frozen at
- * its last value, because the 200 ms ticker that feeds `nowSec` is torn down the
- * instant `state.status` leaves `running` -- and, worse, `computeSettledCount`
- * breaks on a non-settled tool entry, so that card pins `Transcript`'s MONOTONIC
- * settled boundary and re-renders the tail every frame for the rest of the
- * session. The rule and the stakes are `settleRetryCard`'s, verbatim.
- *
- * THE STATUS IS DELIBERATELY NOT CHANGED. That is a different decision with
- * different consequences for `bashBadge` and for the run's own bookkeeping, and
- * it is not this round's to make. Only the tail is released.
- *
- * `liveSeq` is BUMPED rather than cleared, and that is not bookkeeping: clearing
- * `live` is a non-append mutation, and with the status untouched nothing else in
- * the tool revision moves -- so without the bump the height cache would keep
- * serving the multi-row measurement for a card that now draws one row (I-L3-1).
- * Entries with no tail are returned by identity, which is what keeps
- * `EntryView`'s memo boundary intact for the rest of the transcript.
- */
 function releaseLiveTails(entries) {
     let touched = false;
     const next = entries.map((e) => {
@@ -450,6 +448,15 @@ export function viewReducer(state, action) {
                 aborted: false,
             };
         }
+        case 'steerQueued': {
+            const { id, seq } = nextId(state);
+            const entry = { id, kind: 'queued', text: action.text };
+            // NOTHING ELSE RESETS. This is not a new turn -- `turnProduced`,
+            // `errorNoticed` and `aborted` describe the run that is still in
+            // flight, and clearing them here would let the next `runEnd` failure
+            // guard misfire on a turn that produced plenty.
+            return { ...state, seq, ...appendEntry(state, state.entries, entry) };
+        }
         case 'runStart':
             return {
                 ...state,
@@ -460,6 +467,14 @@ export function viewReducer(state, action) {
             };
         case 'turnStart': {
             const { id, seq } = nextId(state);
+            // CONVERT, THEN APPEND, IN THAT ORDER AND IN THIS ONE ACTION
+            // (5.2.3): `turn_start` is the authoritative "the steering queue was
+            // drained into the conversation" signal (the loop drains at its top,
+            // immediately before emitting it), so the user message and the answer
+            // that follows it must land in the same commit, in render order, or a
+            // frame can exist where the message has vanished and the answer has
+            // not appeared.
+            const entries = convertQueuedEntries(state.entries);
             const entry = {
                 id,
                 kind: 'assistant',
@@ -468,7 +483,7 @@ export function viewReducer(state, action) {
                 thinkingOpen: false,
                 streaming: true,
             };
-            return { ...state, seq, ...appendEntry(state, state.entries, entry), streamingId: id };
+            return { ...state, seq, ...appendEntry(state, entries, entry), streamingId: id };
         }
         case 'thinkingStart': {
             if (!state.streamingId)
@@ -1218,22 +1233,6 @@ export function viewReducer(state, action) {
                 entries: mapEntry(state.entries, known, (e) => e.kind === 'retry' ? { ...e, phase: 'retrying', resumeAt: undefined } : e),
             };
         }
-        /**
-         * Rewind the view for a mid-stream restart.
-         *
-         * THE ONLY ACTION IN THIS REDUCER THAT SHRINKS `entries`, and it is safe for
-         * one specific reason (§6.4 / AC-22). `Transcript` clamps its settled boundary
-         * with a MONOTONIC high-water mark: if `highWater` ever exceeded
-         * `entries.length` the clamp would mark EVERYTHING settled — including the
-         * still-streaming assistant entry — and `<Static>` would duplicate it.
-         *
-         * It cannot, and the ORDERING is why: the entries removed here are
-         * `kind: 'tool'` cards created by `toolCallStart` AFTER `turnStart` created the
-         * streaming assistant entry, so they sit strictly above it in the array; and
-         * the boundary scan already breaks at that entry. Removing only entries above
-         * the boundary is the invariant. A future action that removed a SETTLED entry
-         * would break `<Static>` and nothing would report it.
-         */
         case 'streamRestart': {
             const discarded = new Set(action.discardedToolCallIds);
             const entries = state.entries.filter((e) => !(e.kind === 'tool' && discarded.has(e.toolCallId)));
@@ -1326,18 +1325,6 @@ export function viewReducer(state, action) {
                 droppedEntries: appended.droppedEntries,
             };
         }
-        /**
-         * Rewrite the LIVE card in place.
-         *
-         * SAFE ONLY BECAUSE OF D-11'S OTHER HALF: a `ready` / `running` card has
-         * reached `<Static>` and cannot be re-printed, so `serviceEnd` appends a new
-         * entry instead of routing through here. What this handles is the window in
-         * which the card is still in the live region — `starting`, and the one
-         * transition out of it — plus the output tail while it is there.
-         *
-         * The lookup is by `serviceId` and SKIPS terminal entries, so a stray update
-         * cannot rewrite the one-row record `serviceEnd` appended.
-         */
         case 'serviceUpdate': {
             const target = findServiceEntryId(state, action.service.id);
             if (!target)
@@ -1347,15 +1334,6 @@ export function viewReducer(state, action) {
                 entries: mapEntry(state.entries, target, (e) => e.kind === 'service' ? { ...e, ...serviceFields(action.service) } : e),
             };
         }
-        /**
-         * A service reached a terminal state.
-         *
-         * TWO WRITES, AND BOTH ARE REQUIRED. The live card is settled in place so
-         * `computeSettledCount` can move past it and `estimateEntryRows` stops
-         * charging for a tail nothing will add to; the NEW one-row entry is what the
-         * user actually reads, because the card may already be printed into
-         * `<Static>` and `<Static>` cannot un-print (D-11 / R-13).
-         */
         case 'serviceEnd': {
             const target = findServiceEntryId(state, action.service.id);
             const settled = target

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';
@@ -56,7 +56,6 @@ import { renderTranscriptText } from './ui/transcript-text.js';
 import { detectCapabilities } from './ui/capabilities.js';
 import { pickGlyphs } from './ui/glyphs.js';
 import { getTheme } from './ui/theme.js';
-import { copyText } from './ui/clipboard.js';
 import { createSelectionController, } from './ui/selection/selection-controller.js';
 import { DENY_ALL_HUMAN_INPUT } from './tools/human-input.js';
 // A VALUE import, and the one deliberate exception to the paragraph above
@@ -96,7 +95,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 +228,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 +381,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 +438,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 +487,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 +526,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 +539,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 +558,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 +572,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 +597,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
@@ -678,10 +629,10 @@ function runInteractive(flags, extras = {}) {
             // correct. That is rung 2 of the fail-safe ladder doing its job.
             repaint: () => frameWriter?.repaint() ?? false,
             requestRedraw: () => selectionBridge.requestRedraw?.(),
-            // `?? undefined` and not a wrapper: `copyText` skips OSC 52 entirely when
-            // it has no door, and reports `'native'`/`'none'` accordingly.
-            copy: (text) => copyText(text, writeForeign ?? undefined),
-            onCopied: (via, lines, chars) => selectionBridge.onCopied?.(via, lines, chars),
+            // The copy decision moved UP to `App` (tui-shift-enter-copy-queue
+            // 4.2.4): Ctrl+C with a settled selection is routed there, through
+            // the SAME `copyText` door and the SAME bridge `onCopied` toast
+            // funnel -- the controller keeps only the selection state machine.
             // Read at PAINT time, not captured: `/theme` rebuilds the theme mid-session.
             theme: () => getTheme(config.theme, detectCapabilities(process.env, process.stdout)),
             caps: detectCapabilities(process.env, process.stdout),
@@ -695,45 +646,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 +697,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 +711,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 +893,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 +1113,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,31 +1401,17 @@ 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('--mouse-select', 'Drag with the mouse to select text; Ctrl+C 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:
         // `paste` is persisted and defaults to `true`, so a lone `--no-paste` would
@@ -1512,16 +1419,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.d.ts

@@ -1,7 +1,8 @@
 /**
  * Built-in slash commands (spec §5.2):
  * /help /model /settings /thinking /max-tokens /tools /clear /reset /cwd /save
- * /resume /copy /exit (/quit), plus the /team, /fast and /todo subsystems.
+ * /resume /copy /terminal-setup /exit (/quit), plus the /team, /fast and
+ * /todo subsystems.
  */
 import { CommandRegistry } from './registry.js';
 export declare function registerBuiltinCommands(registry: CommandRegistry): void;

package/dist/commands/builtins.js

@@ -1,7 +1,8 @@
 /**
  * Built-in slash commands (spec §5.2):
  * /help /model /settings /thinking /max-tokens /tools /clear /reset /cwd /save
- * /resume /copy /exit (/quit), plus the /team, /fast and /todo subsystems.
+ * /resume /copy /terminal-setup /exit (/quit), plus the /team, /fast and
+ * /todo subsystems.
  */
 import { existsSync, statSync } from 'node:fs';
 import { isAbsolute, resolve } from 'node:path';
@@ -1013,7 +1014,10 @@ const COMMANDS = [
             const captured = port.captured();
             const lines = [
                 `Mouse capture: ${captured ? 'on' : 'off'}`,
-                `  drag-select  ${port.selectEnabled() ? 'on' : 'off (mouseSelect is false)'}`,
+                // The wording follows tui-shift-enter-copy-queue 4.4: releasing no
+                // longer copies, so this row must name the commit key -- leaving the
+                // bare `on` would keep teaching the gesture that was removed.
+                `  drag-select  ${port.selectEnabled() ? 'on (drag to select, ctrl+c to copy)' : 'off (mouseSelect is false)'}`,
                 '  /mouse off   hand the mouse to your terminal for this session',
                 '  /mouse on    take it back',
                 '  --no-mouse   never capture it (also ARAGON_MOUSE=0)',
@@ -1022,6 +1026,47 @@ const COMMANDS = [
             ctx.notify('info', lines.join('\n'));
         },
     },
+    {
+        name: 'terminal-setup',
+        description: 'How to make Shift+Enter send a newline in your terminal',
+        run: (ctx) => {
+            // READ-ONLY BY DESIGN (3.6): pushing kitty keyboard mode or
+            // modifyOtherKeys=2 would re-encode EVERY modified key as CSI-u and
+            // blind Ink's parser for the whole session. One user-side binding
+            // reaches the same result for the one key that needs it.
+            //
+            // Ctrl+J and Alt+Enter work with no setup at all; CSI-u terminals
+            // (kitty / WezTerm / foot with keyboard enhancement on) need none
+            // either. The lines below are for the terminals that send a plain
+            // CR for Shift+Enter and CAN be configured.
+            const lines = [
+                'Shift+Enter newline - terminal setup',
+                '',
+                'Ctrl+J and Alt+Enter insert a newline in every terminal, with no',
+                'setup. To get a dedicated Shift+Enter key, make the terminal send',
+                'the CSI-u sequence \\u001b[13;2u for it:',
+                '',
+                '  Windows Terminal  settings.json, actions array:',
+                '    { "keys": "shift+enter", "command": { "action": "sendInput",',
+                '      "input": "\\u001b[13;2u" } }',
+                '  VS Code terminal  keybindings.json:',
+                '    { "key": "shift+enter",',
+                '      "command": "workbench.action.terminal.sendSequence",',
+                '      "args": { "text": "\\u001b[13;2u" } }',
+                '  iTerm2            Settings > Profiles > Keys > Key Mappings:',
+                '    Shift+Enter -> Send Escape Sequence: [13;2u',
+                '  kitty/WezTerm/foot  native once keyboard enhancement is on',
+                '    (kitty: map shift+enter send_text all \\u001b[13;2u)',
+                '  Alacritty         alacritty.toml, [keyboard] bindings:',
+                '    { key = "Enter", mods = "Shift", chars = "\\u001b[13;2u" }',
+                '  macOS Terminal.app / conhost  cannot rebind Enter; use Ctrl+J',
+                '    or Alt+Enter',
+                '',
+                'This command only prints advice; it changes no terminal modes.',
+            ];
+            ctx.notify('info', lines.join('\n'));
+        },
+    },
     {
         name: 'logs',
         description: 'Show where this session is being logged',