@aragon-agent/cli 0.6.8 → 0.6.10

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;

package/dist/config/env.js

@@ -77,8 +77,6 @@ export function readEnvConfig() {
     if (process.env.ARAGON_THINKING) {
         partial.thinkingLevel = clampThinkingLevel(process.env.ARAGON_THINKING.trim(), 'off');
     }
-    // Parsed by the POSITIVE list, like ARAGON_FULLSCREEN: anything else is left
-    // ABSENT so the config file underneath still wins.
     const showThinking = process.env.ARAGON_SHOW_THINKING?.trim().toLowerCase();
     if (showThinking !== undefined && showThinking.length > 0) {
         partial.showThinking =
@@ -130,16 +128,7 @@ export function readEnvConfig() {
     if (process.env.ARAGON_THEME) {
         partial.theme = clampTheme(process.env.ARAGON_THEME.trim(), 'auto');
     }
-    // ARAGON_FULLSCREEN=0|1 — the one channel that works where neither a flag nor
     // a config file is reachable (containers, SSH, being spawned by another tool).
-    const fullscreen = process.env.ARAGON_FULLSCREEN?.trim().toLowerCase();
-    if (fullscreen !== undefined && fullscreen.length > 0) {
-        partial.fullscreen = fullscreen === '1' || fullscreen === 'true' || fullscreen === 'on' || fullscreen === 'yes';
-    }
-    // ARAGON_MOUSE=0 turns off wheel region routing. Parsed by the POSITIVE list
-    // above, exactly as ARAGON_FULLSCREEN is — NOT by `envBool` below, which uses
-    // a negative list. The two disagree on `ARAGON_MOUSE=disable`, and `mouse` is
-    // modelled on `--fullscreen`, so it uses the reader `--fullscreen` uses.
     const mouse = process.env.ARAGON_MOUSE?.trim().toLowerCase();
     if (mouse !== undefined && mouse.length > 0) {
         partial.mouse = mouse === '1' || mouse === 'true' || mouse === 'on' || mouse === 'yes';
@@ -174,8 +163,6 @@ export function readEnvConfig() {
         if (Number.isFinite(n) && n >= 0)
             partial.scrollResumeMs = n;
     }
-    // ARAGON_PLAN=1 starts the session in PLAN mode — the same channel story as
-    // ARAGON_FULLSCREEN, for terminals reached through a wrapper that owns argv.
     const plan = process.env.ARAGON_PLAN?.trim().toLowerCase();
     if (plan !== undefined && plan.length > 0) {
         partial.planModeDefault = plan === '1' || plan === 'true' || plan === 'on' || plan === 'yes';
@@ -191,12 +178,6 @@ export function readEnvConfig() {
             enabled: !(skills === '0' || skills === 'false' || skills === 'off' || skills === 'no'),
         };
     }
-    // ARAGON_TEAM=0 turns team mode off; ARAGON_TEAM_MAX=<n> overrides the fan-out
-    // width. Parsed by the POSITIVE list, exactly as ARAGON_FULLSCREEN /
-    // ARAGON_MOUSE / ARAGON_PLAN are — NOT by `envBool` below, which uses a
-    // negative list. The two readers disagree on `ARAGON_TEAM=disable`, and the
-    // documented-but-dead outcome of copying the wrong one is what `load.ts`
-    // records for `ARAGON_MOUSE`.
     const team = process.env.ARAGON_TEAM?.trim().toLowerCase();
     const teamMax = process.env.ARAGON_TEAM_MAX?.trim();
     if ((team !== undefined && team.length > 0) || (teamMax !== undefined && teamMax.length > 0)) {
@@ -217,27 +198,6 @@ export function readEnvConfig() {
         if (Object.keys(section).length > 0)
             partial.team = section;
     }
-    // ARAGON_TODO=0 turns todo planning off entirely (no tool, no rail). Parsed by
-    // the POSITIVE list, exactly as ARAGON_FULLSCREEN / ARAGON_MOUSE / ARAGON_PLAN
-    // / ARAGON_TEAM are — NOT by `envBool` below, which uses a negative list. The
-    // two readers disagree on values like `ARAGON_TODO=disable`, and this file
-    // already records that once for team mode.
-    //
-    // There is no `ARAGON_TODO_PANEL`: the panel is a per-machine display
-    // preference, which is what `config.json` is for, and every env var here
-    // exists because a flag and a config file are BOTH unreachable in the channel
-    // it serves (containers, SSH, being spawned by another tool).
-    //
-    // ARAGON_TODO_FOLLOW=notify|auto|off PASSES THAT SAME TEST (D-18), which is
-    // why it exists where `ARAGON_TODO_PANEL` does not: follow-through is exactly
-    // the knob an unattended `-p` run in a container with a fixed entrypoint needs
-    // and can reach no other way.
-    //
-    // ONE ACCUMULATED SECTION, ASSIGNED ONCE — the shape the `team` branch above
-    // already uses, and NOT two `if` blocks each assigning `partial.todo` (P1-4).
-    // THE CAST IS WHAT WOULD MAKE THAT MISTAKE SILENT: a second assignment
-    // compiles clean and drops `enabled`, so `ARAGON_TODO=0 ARAGON_TODO_FOLLOW=auto`
-    // would quietly re-enable the tool the user turned off.
     const todo = process.env.ARAGON_TODO?.trim().toLowerCase();
     const todoFollow = process.env.ARAGON_TODO_FOLLOW?.trim().toLowerCase();
     if ((todo !== undefined && todo.length > 0) ||
@@ -260,24 +220,6 @@ export function readEnvConfig() {
         if (Object.keys(section).length > 0)
             partial.todo = section;
     }
-    // ARAGON_BASH_BACKGROUND=0 turns background services off entirely (no
-    // `background` param, no `bash_output`/`bash_kill`, no prompt block, no chip);
-    // ARAGON_BASH_AUTO_BACKGROUND=0 keeps them but stops the classifier firing on
-    // an unset `background`. Parsed by the POSITIVE list, exactly as
-    // ARAGON_FULLSCREEN / ARAGON_MOUSE / ARAGON_PLAN / ARAGON_TEAM / ARAGON_TODO
-    // are - NOT by `envBool` below, which uses a negative list.
-    //
-    // Both pass the test every env var in this file has to pass: an unattended run
-    // in a container with a fixed entrypoint can reach neither a flag nor a config
-    // file, and "do not leave a dev server running in my CI job" is exactly the
-    // kind of decision that channel needs to make.
-    //
-    // ONE ACCUMULATED SECTION, ASSIGNED ONCE - the shape the `team` and `todo`
-    // branches above already use, and NOT two `if` blocks each assigning
-    // `partial.bash` (the `todo` P1-4 trap). THE CAST IS WHAT WOULD MAKE THAT
-    // MISTAKE SILENT: a second assignment compiles clean and drops the first key,
-    // so `ARAGON_BASH_BACKGROUND=0 ARAGON_BASH_AUTO_BACKGROUND=0` would quietly
-    // re-register the tools the user turned off.
     const bashBackground = process.env.ARAGON_BASH_BACKGROUND?.trim().toLowerCase();
     const bashAuto = process.env.ARAGON_BASH_AUTO_BACKGROUND?.trim().toLowerCase();
     if ((bashBackground !== undefined && bashBackground.length > 0) ||
@@ -300,22 +242,6 @@ export function readEnvConfig() {
         if (Object.keys(section).length > 0)
             partial.bash = section;
     }
-    // ARAGON_RETRY=0 is the kill switch for API retry; ARAGON_RETRY_MAX=<n>
-    // overrides the count. Parsed by the POSITIVE list, exactly as
-    // ARAGON_FULLSCREEN / ARAGON_MOUSE / ARAGON_PLAN / ARAGON_TEAM / ARAGON_TODO
-    // are — NOT by `envBool` below, which uses a negative list.
-    //
-    // TWO VARS ONLY, and no third for the delays: every env var in this file exists
-    // because a flag and a config file are BOTH unreachable in the channel it
-    // serves, and nobody tunes a backoff multiplier from a container entrypoint.
-    //
-    // `>= 0`, NOT `> 0`, and the difference is the whole point (R-16).
-    // `ARAGON_TEAM_MAX` above guards `parsed > 0`, which is right for a fan-out
-    // width and wrong here: `0` is this key's documented floor AND its kill switch,
-    // so a `> 0` guard would drop `ARAGON_RETRY_MAX=0` on the floor and leave the
-    // user with the default 10. "Left ABSENT when unparseable" still holds and
-    // still matters — an unparseable value must not look permanently supplied, or
-    // the config file can never win again.
     const retry = process.env.ARAGON_RETRY?.trim().toLowerCase();
     const retryMax = process.env.ARAGON_RETRY_MAX?.trim();
     if ((retry !== undefined && retry.length > 0) || (retryMax !== undefined && retryMax.length > 0)) {
@@ -333,26 +259,6 @@ export function readEnvConfig() {
         if (Object.keys(section).length > 0)
             partial.retry = section;
     }
-    // ARAGON_FAST=1 turns the fast model tier on; the other three name it
-    // (fast-model-tier §4.3). Parsed by the POSITIVE list, exactly as
-    // ARAGON_FULLSCREEN / ARAGON_MOUSE / ARAGON_PLAN / ARAGON_TEAM / ARAGON_TODO /
-    // ARAGON_RETRY are — NOT by `envBool` below, whose NEGATIVE list disagrees with
-    // it on values like `ARAGON_FAST=disable`.
-    //
-    // FOUR VARS, AND DELIBERATELY NO `ARAGON_FAST_REVIEW_EVERY` / `_MAX_CHARS` /
-    // `_DELEGATE` (D-14). The rule this file states is that an environment variable
-    // exists only where a flag AND a config file are BOTH unreachable — a
-    // container, an ssh session, being spawned by another tool. "Which model, and
-    // is it on" passes that test; tuning a review cadence does not, and every key
-    // that fails it is documentation debt plus a fifth place for the value to
-    // disagree with itself.
-    //
-    // ONE ACCUMULATED SECTION, ASSIGNED ONCE — the shape the `team`, `todo` and
-    // `retry` branches above all use, and NOT four `if` blocks each assigning
-    // `partial.fast`. THE CAST IS WHAT WOULD MAKE THAT MISTAKE SILENT: a second
-    // assignment compiles clean and drops `enabled`, so
-    // `ARAGON_FAST=1 ARAGON_FAST_MODEL=x` would quietly resolve with the tier off
-    // (the P1-4 defect this file records for `todo`).
     const fast = process.env.ARAGON_FAST?.trim().toLowerCase();
     const fastProvider = process.env.ARAGON_FAST_PROVIDER?.trim();
     const fastModel = process.env.ARAGON_FAST_MODEL?.trim();
@@ -376,25 +282,6 @@ export function readEnvConfig() {
         if (Object.keys(section).length > 0)
             partial.fast = section;
     }
-    // ARAGON_COMPACTION=0 turns context compaction off; the other two tune it
-    // (context-auto-compaction §4.3). Parsed by the POSITIVE list, exactly as
-    // ARAGON_FULLSCREEN / ARAGON_MOUSE / ARAGON_PLAN / ARAGON_TEAM / ARAGON_TODO /
-    // ARAGON_RETRY / ARAGON_FAST are — NOT by `envBool` below, whose NEGATIVE list
-    // disagrees with it on values like `ARAGON_COMPACTION=disable`.
-    //
-    // THREE VARS, AND DELIBERATELY NO `ARAGON_COMPACTION_ON_FAILURE` /
-    // `_USE_FAST_TIER` / `_WARN_THRESHOLD`. The rule this file states is that an
-    // environment variable exists only where a flag AND a config file are BOTH
-    // unreachable — a container, an ssh session, being spawned by another tool.
-    // "Is it on, when does it fire, and how much does it keep" passes that test;
-    // "what should it do if the summarizer 500s" does not, and every key that fails
-    // it is documentation debt plus a fifth place for the value to disagree with
-    // itself.
-    //
-    // ONE ACCUMULATED SECTION, ASSIGNED ONCE — the shape the four branches above
-    // all use, and NOT three `if` blocks each assigning `partial.compaction`. THE
-    // CAST IS WHAT WOULD MAKE THAT MISTAKE SILENT: a second assignment compiles
-    // clean and drops `enabled`.
     const compaction = process.env.ARAGON_COMPACTION?.trim().toLowerCase();
     const compactionThreshold = process.env.ARAGON_COMPACTION_THRESHOLD?.trim();
     const compactionKeepTurns = process.env.ARAGON_COMPACTION_KEEP_TURNS?.trim();
@@ -471,23 +358,12 @@ export function readEnvConfig() {
             partial.update = { mode };
         }
     }
-    // Render bounds (tui-render-performance §5.3). Same channel story as
-    // ARAGON_FULLSCREEN: a container or a wrapper that owns argv can reach neither
-    // a flag nor a config file, and a session that freezes is exactly the case
-    // where the user needs a knob they can turn from the outside.
-    //
-    // ARAGON_TRANSCRIPT_RETAIN / ARAGON_MAX_RENDER_INTERVAL_MS are left ABSENT
-    // when unparseable rather than written as a default, so the config file can
-    // still win — the rule `ARAGON_TEAM_MAX` above records.
     const retain = process.env.ARAGON_TRANSCRIPT_RETAIN?.trim();
     if (retain !== undefined && retain.length > 0) {
         const parsed = Number.parseInt(retain, 10);
         if (Number.isFinite(parsed) && parsed > 0)
             partial.transcriptRetain = parsed;
     }
-    // Parsed by the POSITIVE list, exactly as ARAGON_FULLSCREEN / ARAGON_MOUSE /
-    // ARAGON_PLAN / ARAGON_TEAM / ARAGON_TODO are — NOT by `envBool` below, which
-    // uses a negative list. The two readers disagree on `ARAGON_RENDER_GOVERNOR=disable`.
     const governor = process.env.ARAGON_RENDER_GOVERNOR?.trim().toLowerCase();
     if (governor !== undefined && governor.length > 0) {
         partial.renderGovernor =
@@ -499,12 +375,6 @@ export function readEnvConfig() {
         if (Number.isFinite(parsed) && parsed > 0)
             partial.maxRenderIntervalMs = parsed;
     }
-    // ARAGON_DIFF_RENDER=0 restores the pre-fix full-frame repaint;
-    // ARAGON_SYNC_OUTPUT=0 drops the DEC 2026 envelope (tui-input-flicker-fix
-    // §5.3). Parsed by the POSITIVE list, exactly as ARAGON_FULLSCREEN /
-    // ARAGON_MOUSE / ARAGON_PLAN / ARAGON_TEAM / ARAGON_TODO / ARAGON_RENDER_GOVERNOR
-    // are — NOT by `envBool` below, whose NEGATIVE list disagrees with it on values
-    // like `ARAGON_DIFF_RENDER=disable`.
     const diffRender = process.env.ARAGON_DIFF_RENDER?.trim().toLowerCase();
     if (diffRender !== undefined && diffRender.length > 0) {
         partial.diffRender =

package/dist/config/load.d.ts

@@ -19,8 +19,6 @@ export interface CliFlags {
     confirm?: boolean;
     toolTimeout?: string | number;
     idleTimeout?: string | number;
-    /** `--fullscreen` ⇒ true, `--no-fullscreen` ⇒ false, absent ⇒ undefined. */
-    fullscreen?: boolean;
     /** `--no-exit-transcript` ⇒ false. */
     exitTranscript?: boolean;
     /** `--compact` ⇒ true, `--no-compact` ⇒ false, absent ⇒ undefined. */

package/dist/config/load.js

@@ -23,32 +23,11 @@ function envFlagTrue(value) {
     const v = value.trim().toLowerCase();
     return v === '1' || v === 'true' || v === 'on' || v === 'yes';
 }
-/**
- * Resolve the tri-state full-screen preference (see `CliConfig.fullscreen`).
- * Only a flag or the env var counts as an explicit FORCE; a config file holding
- * the default `true` must not disable the automatic downgrades.
- */
-function resolveFullscreen(flags, env, file) {
-    if (flags.fullscreen !== undefined)
-        return flags.fullscreen;
-    if (env.fullscreen !== undefined)
-        return env.fullscreen;
-    if (file.fullscreen === false)
-        return false;
-    return undefined;
-}
 /**
  * Resolve wheel region routing: flag › env › file › default `true`.
  *
- * THIS NEEDS ITS OWN RESOLVER; it does not "match every other boolean" in this
- * file. `hints` is `flags.hints !== undefined ? … : file.hints ?? DEFAULT` and
- * reads NO ENV AT ALL — copying that line would ship `ARAGON_MOUSE` as
- * documented-but-dead (P1-9). Only `fullscreen` has an env layer, and only
- * because `resolveFullscreen` above was written to give it one.
- *
- * Unlike `fullscreen` this is a plain boolean rather than a tri-state: there
- * are no heuristics for an explicit `true` to override, so a persisted `true`
- * is just a value and not an opinion that has to be told apart from silence.
+ * Unlike `hints`, mouse routing accepts an environment override. Keep that
+ * layer explicit so ARAGON_MOUSE works even when a wrapper owns the arguments.
  */
 function resolveMouse(flags, env, file) {
     if (flags.mouse !== undefined)
@@ -463,12 +442,6 @@ export function loadConfig(flags = {}) {
     const read = readConfigFile();
     const file = read.config ?? {};
     const env = readEnvConfig();
-    // A config file that exists but will not parse used to reset EVERY setting
-    // with nothing anywhere explaining it. The fallback is unchanged; what is new
-    // is that it leaves a trace. The record alone is not the explanation, so the
-    // two owners of a user-visible channel say it too: `main()` writes one stderr
-    // line (headless, inline and every subcommand) and `App.tsx` raises a toast
-    // (full-screen, where the alternate screen wipes that line away).
     if (read.parseError) {
         getLogger().error('config', 'config_parse_failed', { error: read.parseError });
     }
@@ -580,7 +553,6 @@ export function loadConfig(flags = {}) {
         contextWindow,
         theme,
         reducedMotion,
-        fullscreen: resolveFullscreen(flags, env.partial, file),
         exitTranscript: flags.exitTranscript !== undefined
             ? flags.exitTranscript
             : file.exitTranscript ?? DEFAULT_CONFIG.exitTranscript,
@@ -658,7 +630,6 @@ function recordResolvedConfig(config) {
         // "why is my output truncated" was unanswerable after the fact.
         maxTokens: config.maxTokens ?? 'auto',
         theme: config.theme,
-        fullscreen: config.fullscreen,
         toolTimeoutMs: config.toolTimeoutMs,
         idleTimeoutMs: config.idleTimeoutMs,
         historyEnabled: config.historyEnabled,

package/dist/config/schema.d.ts

@@ -729,7 +729,6 @@ export interface PersistedConfig {
     /** Replace spinners with a static glyph for calmer, low-motion output. */
     reducedMotion: boolean;
     /** Full-screen TUI (still subject to the automatic downgrades in §4.1). */
-    fullscreen: boolean;
     /** Replay a plain-text session summary after leaving the alternate screen. */
     exitTranscript: boolean;
     /** Entries reachable by scrolling; older ones show the "collapsed" line (I-3). */
@@ -767,8 +766,7 @@ export interface PersistedConfig {
      * transcript, whatever row the pointer is on (wheel-scrolls-transcript-only
      * §4.1).
      *
-     * A PLAIN BOOLEAN, not a `fullscreen`-style tri-state: there are no
-     * heuristics for an explicit `true` to override (D-10).
+     * A plain boolean: persisted values and per-run overrides use the same meaning.
      */
     mouse: boolean;
     /**
@@ -881,17 +879,6 @@ export interface CliConfig {
     contextWindow: number | null;
     theme: ThemeName;
     reducedMotion: boolean;
-    /**
-     * TRI-STATE, and deliberately so (spec §4.1 vs §6.2):
-     *   `false`     — an explicit opt-out from any layer; always inline.
-     *   `true`      — an explicit FORCE, only from `--fullscreen` / `ARAGON_FULLSCREEN=1`;
-     *                 overrides the TERM/CI/size heuristics.
-     *   `undefined` — no explicit choice (including a config file holding the
-     *                 default `true`); full-screen with the heuristics live.
-     * Folding the persisted default into `true` would turn every user's config
-     * file into a permanent "ignore the CI and TERM=dumb downgrades" switch.
-     */
-    fullscreen?: boolean;
     /** Replay a plain-text summary on exit (full-screen only — see §4.4). */
     exitTranscript: boolean;
     /** Entries reachable by scrolling; older ones show the "collapsed" line (I-3). */

package/dist/config/schema.js

@@ -879,7 +879,6 @@ export const DEFAULT_CONFIG = {
     contextWindow: null,
     theme: 'auto',
     reducedMotion: false,
-    fullscreen: true,
     exitTranscript: true,
     transcriptWindow: DEFAULT_TRANSCRIPT_WINDOW,
     transcriptRetain: DEFAULT_TRANSCRIPT_RETAIN,

package/dist/config/store.js

@@ -69,6 +69,8 @@ export function readConfigFile() {
         const raw = readFileSync(file, 'utf-8');
         const parsed = JSON.parse(raw);
         if (parsed && typeof parsed === 'object') {
+            // Retired layout preference: tolerate old files without restoring a UI mode.
+            delete parsed.fullscreen;
             return { config: parsed };
         }
         return { config: null, parseError: `${file} does not contain a JSON object` };

package/dist/input/enter-sequences.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Enter-family sequence recognition (tui-shift-enter-copy-queue §3.3) -- pure,
+ * stream-free, no node/React imports, callable from any test environment.
+ *
+ * WHY THIS LIVES BELOW INK. Ink 5's `parse-keypress.js` calls `parseKeypress`
+ * ONCE per stdin chunk and hard-codes `shift: false` for the exact string
+ * `'\r'`, so a component can never see `key.return && key.shift` -- the
+ * `PromptInput` branch for it is dead code. Worse, terminals that DO encode a
+ * distinct Shift+Enter send CSI-u (`\x1b[13;2u`), which Ink's `fnKeyRe` does
+ * not match: the ESC is stripped by `use-input.js` and `'[13;2u'` falls through
+ * to the PRINTABLE branch, typing garbage into the draft. The only layer that
+ * sees the bytes before Ink mangles them is the stdin filter, which is where
+ * the mouse-report and paste-marker dialects are already translated.
+ *
+ * THE CONTRACT: rewrite every recognized sequence to ONE normalized token --
+ * `ENTER_NEWLINE_FRAME` for "this was a modified Enter, the user wants a
+ * newline" and `'\r'` for the unmodified CSI-u Enter some other program left
+ * behind. No state, no partial-output: `rewriteEnterSequences` is idempotent
+ * because its output contains none of its inputs.
+ */
+/** What one recognized sequence means, for tests and `/terminal-setup` copy. */
+export interface EnterSequenceSpec {
+    /** The exact byte sequence a terminal sends for this key. */
+    readonly seq: string;
+    /** The chord it names, e.g. `'shift+enter'`, `'ctrl+alt+enter'`, `'enter'`. */
+    readonly meaning: string;
+    /** What `rewriteEnterSequences` replaces it with. */
+    readonly to: string;
+}
+/**
+ * The recognition table (§3.3). CSI-u modifiers 2-8 cover Shift(2), Alt(3),
+ * Shift+Alt(4), Ctrl(5), Ctrl+Shift(6), Ctrl+Alt(7), Ctrl+Alt+Shift(8) as
+ * emitted by kitty/WezTerm keyboard-enhancement mode and by
+ * `modifyOtherKeys=2`; every one of them means "Enter with a modifier", and a
+ * modified Enter must NEVER submit the draft. `\x1b\r` / `\x1b\n` are the
+ * classic Alt+Enter encodings. `\x1b[13u` (no modifier field) is what a
+ * leftover kitty mode sends for a PLAIN Enter: it must submit, so it maps to
+ * `'\r'` rather than to a newline.
+ */
+export declare const ENTER_SEQUENCES: readonly EnterSequenceSpec[];
+/**
+ * Rewrite every recognized Enter-family sequence to its normalized token.
+ *
+ * ONE ANCHORED REGEX, not a per-sequence scan and not a state machine: the
+ * CSI-u family shares one shape and the two literal Alt+Enter encodings cannot
+ * nest inside it, so a single left-to-right pass is unambiguous. `\x1b[13;9u`
+ * and other unknown modifiers are deliberately left untouched -- rewriting an
+ * unrecognized sequence would be guessing at a terminal dialect we have not
+ * seen.
+ */
+export declare function rewriteEnterSequences(text: string): string;
+/**
+ * Length of the trailing run of `text` that is a proper prefix of an
+ * Enter-family sequence, or 0.
+ *
+ * LONGEST MATCH, not shortest: unlike the mouse and paste families, a torn
+ * CSI-u sequence diverges from its siblings only at the LAST byte
+ * (`\x1b[13;` + `2u`), so every byte before the divergence point must be held
+ * back for the next chunk or the sequence is destroyed a byte early. Feeding
+ * the result into the filter's `keep = max(...)` alongside the other two
+ * families keeps every family's hold intact.
+ */
+export declare function trailingEnterPrefixLength(text: string): number;