@aragon-agent/cli 0.6.2 → 0.6.4

package/dist/ui/layout/follow-state.js

@@ -0,0 +1,150 @@
+/**
+ * Follow rules for the self-drawn viewport (tui-selection-and-scroll-follow
+ * §4.3). PURE, React-free, unit-tested — the shape `scroll.ts`,
+ * `virtual-window.ts` and `frame-differ.ts` all already use.
+ *
+ * It lives here rather than inside `ScrollViewport` because
+ * `ink-testing-library`'s stdout stub reports no height, so a MOUNTED viewport
+ * measures `content === viewport`, `overflowLines === 0`, and neither rule below
+ * ever engages (`__tests__/render-at-width.ts`, and `transcript-virtual.test.tsx`
+ * records the same limitation and the same workaround). A state machine that can
+ * only be exercised through a box the test cannot size is a state machine with
+ * no tests (P1-10).
+ *
+ * ═══════════════════════════════════════════════════════════════════════════
+ * NOTHING IN THIS FILE MAY READ A MEASUREMENT (AC-17, and it is a `grep`).
+ *
+ * The gate is a `grep` for the name of Ink's element-measuring helper returning
+ * NOTHING from this file, so that name is deliberately left unspelled here and
+ * below, even where writing it would read more directly. A grep a COMMENT can
+ * trip is a grep whoever runs it learns to ignore, and then the import it exists
+ * to catch walks straight past it — the same reason `glyphs.test.ts` strips
+ * comments before judging a line.
+ *
+ * The transcript's MEASURED CONTENT HEIGHT — what `ScrollViewport` reads out of
+ * Ink's layout for the inner box — is the height of everything the transcript is
+ * currently drawing, and FOUR different things move it — only one of which is
+ * "the agent produced output":
+ *
+ *   1. rows appended at the tail                        <- Rule A must react
+ *   2. an entry ABOVE the reading position changing     <- must NOT move
+ *      height (Ctrl+T, Ctrl+O, a first real measurement
+ *      of an entry that stood on an estimate)
+ *   3. the scroll horizon dropping entries off the      <- must NOT move
+ *      FRONT (`Transcript.tsx`, `entries.slice(-size)`)
+ *   4. a re-wrap after a resize                         <- must NOT move
+ *
+ * For (2) and (3) `virtual-window.ts`'s invariant V-4 is explicit: counting the
+ * offset FROM THE BOTTOM makes an above-the-viewport height change
+ * self-compensating, and that is what buys virtualisation its "no
+ * scroll-anchoring compensation pass required". Reacting to total content growth
+ * would make Rule A that compensation pass, applied to changes that never needed
+ * compensating — and it would additionally make (3) look like new output and arm
+ * the idle timer on a transcript that produced nothing, the exact failure G6
+ * exists to prevent.
+ *
+ * There is a second, sharper reason. `selectWindow` TAKES `offset` AS AN INPUT,
+ * so the mounted set — and therefore which entries are measured rather than
+ * estimated — is a function of the offset. An offset that is in turn a function
+ * of the measured height closes a loop: offset -> mounted set -> measured
+ * heights -> content height -> offset. The loop is broken by the INPUT rather
+ * than by a convergence argument: `advanceTailRows` reads the height table and
+ * never the geometry context (P0-1 / D-13).
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+import { clampScroll } from './scroll.js';
+/**
+ * Rule A. When rows are appended AT THE TAIL while the user is not pinned to the
+ * bottom, grow the offset by the same amount: `shiftUp = overflowLines - offset`
+ * is then constant and the rows on screen do not move.
+ *
+ * SIGNED, NOT GROWTH-ONLY (I-7). A tail SHRINK is rows that no longer exist
+ * below the reading position, so shrinking the offset by the same amount is what
+ * keeps the screen still — and it is self-correcting when the source of the
+ * delta was an upper-bound height estimate that a later measurement brings down
+ * (`estimateEntryRows` is deliberately an upper bound). An unsigned rule
+ * over-counts once and never finds its way back.
+ */
+export function reduceFollow(input) {
+    const { offset, overflowLines, tailDelta, hold } = input;
+    // Pinned and not holding: anchoring is free — `offset` stays 0 and the
+    // existing arithmetic keeps showing the tail. `hold` LIFTS the precondition
+    // because a drag that starts while pinned must still freeze the rows under the
+    // pointer (S3), and freezing means the pin becomes an anchor for the duration
+    // of the drag (T-20).
+    if (offset === 0 && !hold)
+        return { offset, newLinesWhilePaused: 0 };
+    if (tailDelta === 0)
+        return { offset, newLinesWhilePaused: input.newLinesWhilePaused };
+    const next = clampScroll(offset + tailDelta, overflowLines);
+    return {
+        offset: next,
+        // Only real arrivals arm the resume timer, and reaching the bottom by ANY
+        // route resets the count (Rule B condition 2 / G6). Expressing the reset
+        // here is what keeps it one rule rather than two.
+        newLinesWhilePaused: next === 0 ? 0 : Math.max(0, input.newLinesWhilePaused + tailDelta),
+    };
+}
+/**
+ * Rule B's three conditions, and they are three rather than one on purpose:
+ *
+ *  1. `offset > 0`   — there is somewhere to return FROM;
+ *  2. `newLines > 0` — something arrived that is worth returning TO. THIS IS
+ *     G6: a user reading a FINISHED transcript is never yanked to the bottom,
+ *     which is the new bug that a timing-only rule would ship wearing the fix's
+ *     clothes (D-3);
+ *  3. `!hold`        — no selection drag is in progress (§4.4).
+ *
+ * AC-9 rides on the first line: with `scrollResumeMs: 0` this returns `false`
+ * before anything else is considered, so no timer is ever created.
+ */
+export function shouldArmResume(input) {
+    if (!Number.isFinite(input.resumeMs) || input.resumeMs <= 0)
+        return false;
+    if (input.offset <= 0)
+        return false;
+    if (input.newLinesWhilePaused <= 0)
+        return false;
+    if (input.hold)
+        return false;
+    return true;
+}
+export function emptyTailState() {
+    return { rows: 0, lastId: null, lastHeight: 0 };
+}
+/**
+ * Advance the tail counter by one frame.
+ *
+ * `ids` are the entries the transcript is drawing, in order; `heightOf(index)`
+ * is the transcript's own per-entry height table (measured where it exists, an
+ * upper-bound estimate where it does not). NO GEOMETRY IS READ HERE, which is
+ * what breaks P0-1's loop by construction.
+ *
+ * RE-ANCHORING CONTRIBUTES ZERO (R-11). When the scroll horizon drops the entry
+ * this counter was anchored on, the anchor is simply moved to the new last entry
+ * and the frame contributes a delta of 0. Losing one frame of anchoring is a row
+ * of drift at worst; treating a FRONT-DROP as tail motion is a visible jump, and
+ * an unbounded one.
+ */
+export function advanceTailRows(prev, ids, heightOf) {
+    if (ids.length === 0)
+        return { rows: prev.rows, lastId: null, lastHeight: 0 };
+    const lastIndex = ids.length - 1;
+    const lastId = ids[lastIndex];
+    const lastHeight = heightOf(lastIndex);
+    if (prev.lastId === null) {
+        // First frame: there is no "before", so there is no delta to attribute.
+        return { rows: prev.rows, lastId, lastHeight };
+    }
+    const anchor = ids.lastIndexOf(prev.lastId);
+    if (anchor === -1) {
+        // The anchor is gone (horizon front-drop, `/clear`, `/reset`, `/resume`).
+        return { rows: prev.rows, lastId, lastHeight };
+    }
+    // The anchor entry may have grown in place (a streaming tail entry), and
+    // everything after it is new. Both terms are signed.
+    let delta = heightOf(anchor) - prev.lastHeight;
+    for (let i = anchor + 1; i <= lastIndex; i += 1)
+        delta += heightOf(i);
+    return { rows: prev.rows + delta, lastId, lastHeight };
+}

package/dist/ui/layout/virtual-window.d.ts

@@ -20,6 +20,17 @@
  * `overflowLines`, while `offset` — and hence what the user is looking at — is
  * unchanged. No scroll-anchoring compensation pass is required. Do NOT
  * "simplify" `offset` to count from the top.
+ *
+ * V-4 AS AMENDED BY tui-selection-and-scroll-follow (§4.3.1a). There is now
+ * exactly ONE compensation pass — `follow-state.ts`'s Rule A — and it is
+ * deliberately restricted to rows appended AT THE TAIL, published by
+ * `Transcript.tsx` from the height table below. Everything the paragraph above
+ * describes still self-compensates and is still not compensated for again.
+ * The restriction is the whole of V-4's survival: an offset that reacted to
+ * TOTAL measured height would turn every above-the-viewport correction into a
+ * jump, would read a horizon front-drop as new output — and, because
+ * `selectWindow` takes `offset` as an INPUT, would close a loop from the offset
+ * through the mounted set and the measured heights back to the offset.
  */
 import type { Entry } from '../../agent/reducer.js';
 import type { DensityMode } from '../density.js';

package/dist/ui/layout/virtual-window.js

@@ -20,9 +20,22 @@
  * `overflowLines`, while `offset` — and hence what the user is looking at — is
  * unchanged. No scroll-anchoring compensation pass is required. Do NOT
  * "simplify" `offset` to count from the top.
+ *
+ * V-4 AS AMENDED BY tui-selection-and-scroll-follow (§4.3.1a). There is now
+ * exactly ONE compensation pass — `follow-state.ts`'s Rule A — and it is
+ * deliberately restricted to rows appended AT THE TAIL, published by
+ * `Transcript.tsx` from the height table below. Everything the paragraph above
+ * describes still self-compensates and is still not compensated for again.
+ * The restriction is the whole of V-4's survival: an offset that reacted to
+ * TOTAL measured height would turn every above-the-viewport correction into a
+ * jump, would read a horizon front-drop as new output — and, because
+ * `selectWindow` takes `offset` as an INPUT, would close a loop from the offset
+ * through the mounted set and the measured heights back to the offset.
  */
 import { FAST_LIMITS } from '../../fast/limits.js';
+import { COMPACTION_LIMITS } from '../../compaction/limits.js';
 import { GUTTER_WIDTH } from './Gutter.js';
+import { USER_ENTRY_MAX_ROWS } from '../composer-limits.js';
 export const VIRTUAL_LIMITS = {
     /**
      * Entries kept mounted on each side of the visible band.
@@ -101,6 +114,32 @@ export function entryRevision(entry) {
          */
         case 'fast':
             return `f${entry.status}.${entry.live ? 1 : 0}.${entry.text?.length ?? 0}.${entry.detail?.length ?? 0}`;
+        /**
+         * `live`, the SUMMARY LENGTH and `mode`, because all three change the rows the
+         * card draws: a live card renders a headline and no body, a settled one
+         * renders the summary (whose length decides how many rows it wraps to), and
+         * `mode` selects between the "summarized N messages" and "dropped N WITHOUT a
+         * summary" detail lines. `durationMs` is inside the `wrap="truncate"`
+         * headline, so it can never change the height.
+         */
+        case 'compaction':
+            return `c${entry.live ? 1 : 0}.${entry.summary?.length ?? 0}.${entry.mode}.${entry.applied ? 1 : 0}`;
+        /**
+         * `rowsSeen`, AND NEVER `rows.length` (background-service-supervision P0-3).
+         *
+         * The service tail is a FIXED-SIZE RING: it evicts its oldest row while
+         * appending a new one, so the joined length is unchanged while the content is
+         * not. That is verbatim the NON-APPEND mutation I-L3-1 above says must extend
+         * the revision, and it is the same trap — and the same fix — as the `tool`
+         * branch's `liveSeq` two cases up. A length term would go on matching while
+         * the card changed underneath it, and the card would freeze at a stale height
+         * AND a stale rendered subtree with nothing anywhere reporting it.
+         *
+         * `status` and the presence of a URL are in because both change the rows the
+         * card draws; `exitCode` is in because the terminal row names it.
+         */
+        case 'service':
+            return `v${entry.status}.${entry.rowsSeen}.${entry.url ? 1 : 0}.${entry.exitCode ?? -1}.${entry.terminal ? 1 : 0}`;
         default:
             return 'x';
     }
@@ -142,6 +181,10 @@ const TOOL_COLLAPSED_LINES = 8;
 const DIFF_COLLAPSED_LINES = 12;
 /** Live tail rows in `ToolCard`; duplicated as a NUMBER, for the same reason. */
 const TOOL_LIVE_TAIL_ROWS = 8;
+/** Tail rows a COLLAPSED `ServiceCard` draws; duplicated for the same reason. */
+const SERVICE_COLLAPSED_TAIL_ROWS = 2;
+/** Tail rows an EXPANDED `ServiceCard` draws; the snapshot cap (8). */
+const SERVICE_EXPANDED_TAIL_ROWS = 8;
 /**
  * Pure UPPER-BOUND estimate of an entry's height, used until a real measurement
  * exists.
@@ -159,7 +202,14 @@ export function estimateEntryRows(entry, cols, density, expanded, thinkingVisibl
     const separation = density === 'comfortable' ? 1 : 0;
     switch (entry.kind) {
         case 'user':
-            return separation + wrappedRows(entry.text, usable);
+            // MIRRORS `UserEntry`'s RENDER CAP (+1 for the `... +N more lines` tail).
+            // THESE TWO NUMBERS ARE ONE NUMBER (I-13). Capping the renderer alone
+            // would leave this function believing a 5 000-line message is 5 000 rows
+            // tall -- and unlike an ordinary over-estimate that failure does NOT
+            // self-correct: this file's own note above records that "an entry
+            // estimated at 400 rows is exactly the one that never gets mounted", and
+            // an unmounted entry is never measured.
+            return (separation + Math.min(wrappedRows(entry.text, usable), USER_ENTRY_MAX_ROWS + 1));
         case 'notice':
             return separation + wrappedRows(entry.text, usable);
         case 'assistant': {
@@ -243,6 +293,40 @@ export function estimateEntryRows(entry, cols, density, expanded, thinkingVisibl
                 : 1;
             return separation + 1 + body;
         }
+        // THE SECOND SWITCH, and adding the case to only one of the two yields a
+        // transcript whose scroll arithmetic disagrees with what it drew — drift
+        // rather than an error (C-9 / RV-13). Headline row, one detail row, then the
+        // summary clamped to `cardTextRows` (or unclamped when expanded) plus the
+        // `+N more lines` footer. An UPPER BOUND, which is what this function owes
+        // its caller.
+        case 'compaction': {
+            const lines = entry.summary ? wrappedRows(entry.summary, usable) : 0;
+            const body = expanded ? lines : Math.min(lines, COMPACTION_LIMITS.cardTextRows);
+            const footer = lines > body || (expanded && lines > COMPACTION_LIMITS.cardTextRows) ? 1 : 0;
+            return separation + 1 + 1 + body + footer;
+        }
+        /**
+         * THE THIRD SWITCH, and adding the case to only one of this file's two
+         * yields a transcript whose scroll arithmetic disagrees with what it drew —
+         * drift rather than an error (P0-3 / RV-13). Both `default` branches swallow
+         * an unknown kind silently, and `virtual-window.test.ts` hand-enumerates
+         * kinds, so neither omission turns anything red on its own.
+         *
+         * A terminal record is exactly one row. A live card is the status row, the
+         * URL row when there is one, and the tail — counted, not wrapped, which is
+         * legitimate only because every row is `wrap="truncate"` AND clipped at
+         * `LIVE_ROW_MAX_CHARS` on the way into the ring, the same coupling the
+         * `tool` branch above records for itself.
+         */
+        case 'service': {
+            if (entry.terminal)
+                return separation + 1;
+            const url = entry.url ? 1 : 0;
+            const tail = expanded
+                ? Math.min(entry.rows.length, SERVICE_EXPANDED_TAIL_ROWS)
+                : Math.min(entry.rows.length, SERVICE_COLLAPSED_TAIL_ROWS);
+            return separation + 1 + url + tail;
+        }
         default:
             return separation + 1;
     }

package/dist/ui/overlays/HelpOverlay.js

@@ -21,7 +21,14 @@ function keyRows(times) {
         ['Shift+Up / Shift+Down', 'Scroll the transcript a line (full-screen mode)'],
         ['Wheel', 'Scroll the transcript (or the open overlay)'],
         ['Shift+Wheel', 'Scroll the transcript a page'],
+        // Drag-select is the one affordance here a user cannot discover by pressing
+        // a key, so it has to be named somewhere they can look it up. The one-shot
+        // startup notice is the other place, and it scrolls away.
+        ['Drag (left button)', 'Select text on screen; releasing copies it'],
         ['Up / Down', 'Prompt history (empty input)'],
+        // Pasting is the one affordance here with no key of its own, so the only
+        // place a user can learn what happened to their 218 lines is this row.
+        ['Paste', 'Inserted as-is up to 6 lines; larger becomes [Pasted text #N] (--no-paste)'],
     ];
 }
 const COMMANDS = [
@@ -44,7 +51,8 @@ const COMMANDS = [
     ['/cwd [dir]', 'Show or change the tool working directory'],
     ['/save [file]', 'Save the session to JSON'],
     ['/resume [file]', 'Load a saved session'],
-    ['/copy', 'Copy the last answer to the clipboard'],
+    ['/copy', 'Copy the last answer to the clipboard (OSC 52, so it works over ssh)'],
+    ['/mouse [on|off]', 'Release the mouse to your terminal, or take it back'],
     ['/exit', 'Exit'],
 ];
 const SKILL_ROWS = [

package/dist/ui/overlays/PlanReviewOverlay.js

@@ -27,6 +27,7 @@ import { Text, useInput } from 'ink';
 import { pickGlyphs } from '../glyphs.js';
 import { OverlayFrame } from '../layout/OverlayFrame.js';
 import { wrapToRows } from '../layout/wrap-rows.js';
+import { stripPasteFrames } from '../paste-frames.js';
 /** The frame's border plus its one-column padding on each side. */
 const FRAME_CHROME_COLS = 4;
 export function PlanReviewOverlay({ plan, maxRows, cols, scrollOffset, onScrollClamp, theme, caps, onVerdict, }) {
@@ -55,8 +56,15 @@ export function PlanReviewOverlay({ plan, maxRows, cols, scrollOffset, onScrollC
                 setFeedback(feedback.slice(0, -1));
                 return;
             }
-            if (input && !key.ctrl && !key.meta && !key.tab)
-                setFeedback(feedback + input);
+            // `stripPasteFrames`, NOT `input` (I-12 / P0-2). This is the THIRD consumer
+            // that appends `input` to a string; the design's table listed it as
+            // "key-driven only, inert", which was true of the version that had no
+            // free-text field. Revision feedback is exactly the kind of thing a user
+            // pastes — a failing test, a stack trace — and a framed paste appended
+            // verbatim would put NULs into text the model then reads.
+            if (input && !key.ctrl && !key.meta && !key.tab) {
+                setFeedback(feedback + stripPasteFrames(input));
+            }
             return;
         }
         if (input === 'a' || input === 'A')

package/dist/ui/overlays/QuestionOverlay.js

@@ -19,6 +19,7 @@ import { useState } from 'react';
 import { Box, Text, useInput } from 'ink';
 import { pickGlyphs } from '../glyphs.js';
 import { OverlayFrame } from '../layout/OverlayFrame.js';
+import { stripPasteFrames } from '../paste-frames.js';
 /** Which option index each question starts on: the recommended one. */
 function initialCursors(questions) {
     return questions.map((q) => Math.max(0, q.options.findIndex((o) => o.recommended)));
@@ -121,8 +122,11 @@ export function QuestionOverlay({ questions, maxRows, cols, theme, caps, onSubmi
                 setDraft(draft.slice(0, -1));
                 return;
             }
+            // `stripPasteFrames`, NOT `input` (I-12 / P0-2) -- the same broadcast
+            // hazard `SettingsScreen` documents at length: a framed paste appended
+            // verbatim stores NULs that render as nothing.
             if (input && !key.ctrl && !key.meta && !key.tab)
-                setDraft(draft + input);
+                setDraft(draft + stripPasteFrames(input));
             return;
         }
         // phase === 'choosing'

package/dist/ui/overlays/SettingsScreen.d.ts

@@ -9,7 +9,7 @@
  */
 import React from 'react';
 import { type ThinkingLevel } from '@aragon-agent/core';
-import { type FastConfig } from '../../config/schema.js';
+import { type CompactionConfig, type FastConfig } from '../../config/schema.js';
 import { type LogLevelName } from '../../logging/levels.js';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
@@ -57,6 +57,33 @@ export interface SettingsValues {
     fastReview: string;
     /** The session review budget. `fastReview` is the PACE, this is the TOTAL. */
     fastReviewBudget: string;
+    /**
+     * Context compaction (context-auto-compaction §4.5).
+     *
+     * THREE ROWS, NOT SIX. `onFailure` and `useFastTier` are file- and
+     * `/compact`-only on purpose: this screen is for the settings a user CHANGES,
+     * not for every setting that exists, and "what should it do if the summarizer
+     * 500s" is not a question a user reaches for with arrow keys.
+     *
+     * `string` rather than their config types because this screen edits TEXT, and
+     * a typo must change NOTHING rather than resolve to a default — the discipline
+     * `maxTokens` and `fastReview` already follow here.
+     */
+    compactionEnabled: 'on' | 'off';
+    /** A percentage the user types, e.g. `90`. Parsed on save; a typo is ignored. */
+    compactionThreshold: string;
+    compactionKeepTurns: string;
+    /**
+     * The two hardening toggles (context-auto-compaction-hardening §4.6).
+     *
+     * FIVE ROWS NOW, NOT THREE, and these two earn their place where `onFailure`
+     * did not: each one names a THING THE SESSION WILL DO - spend money inside a
+     * fan-out, and write conversation content to disk - rather than a policy for a
+     * failure the user has never seen. Both are questions a user reaches for
+     * deliberately.
+     */
+    compactionSubagents: 'on' | 'off';
+    compactionArchive: 'on' | 'off';
 }
 interface SettingsScreenProps {
     initial: SettingsValues;
@@ -121,6 +148,25 @@ export declare function readFastSettings(values: Pick<SettingsValues, 'fastEnabl
  * save writes the clamp's default over whatever the user had.
  */
 export declare function fastSettingsFrom(fast: FastConfig): Pick<SettingsValues, 'fastEnabled' | 'fastModel' | 'fastProvider' | 'fastReview' | 'fastReviewBudget'>;
+/**
+ * Read the three compaction rows back into a config patch.
+ *
+ * A TYPO CHANGES NOTHING — the discipline `readFastSettings` states one function
+ * up, and the reason is the same: a threshold that silently resolved to the
+ * default on a mistyped keystroke would be a setting the user believes they
+ * changed and did not. `parseThresholdInput` returns `null` for anything that is
+ * not a ratio or a percentage, and the key is then simply absent from the patch.
+ */
+export declare function readCompactionSettings(values: Pick<SettingsValues, 'compactionEnabled' | 'compactionThreshold' | 'compactionKeepTurns' | 'compactionSubagents' | 'compactionArchive'>): Partial<CompactionConfig>;
+/**
+ * The inverse: seed the three rows from a resolved config.
+ *
+ * OMITTING A KEY HERE IS THE SILENT HALF OF ADDING A ROW, exactly as it is for
+ * the fast rows above: the row renders empty, `readCompactionSettings` sees an
+ * unparseable value, and an untouched save writes the clamp's default over
+ * whatever the user had.
+ */
+export declare function compactionSettingsFrom(compaction: CompactionConfig): Pick<SettingsValues, 'compactionEnabled' | 'compactionThreshold' | 'compactionKeepTurns' | 'compactionSubagents' | 'compactionArchive'>;
 /**
  * The cap this setting will ACTUALLY produce against the selected model.
  *

package/dist/ui/overlays/SettingsScreen.js

@@ -11,13 +11,15 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from 'react';
 import { Text, useInput } from 'ink';
 import { DEFAULT_MAX_OUTPUT_TOKENS, resolveOutputTokens, } from '@aragon-agent/core';
-import { ADAPTER_PROVIDERS, THINKING_LEVELS, maskSecret, parseMaxTokensInput, } from '../../config/schema.js';
+import { ADAPTER_PROVIDERS, THINKING_LEVELS, maskSecret, parseMaxTokensInput, parseThresholdInput, } from '../../config/schema.js';
 import { LOG_LEVEL_NAMES } from '../../logging/levels.js';
 import { pickGlyphs } from '../glyphs.js';
 import { OverlayFrame } from '../layout/OverlayFrame.js';
+import { stripPasteFrames } from '../paste-frames.js';
 const SHOW_THINKING_OPTIONS = ['off', 'on'];
 const LIVE_OUTPUT_OPTIONS = ['off', 'on'];
 const FAST_ENABLED_OPTIONS = ['off', 'on'];
+const COMPACTION_ENABLED_OPTIONS = ['off', 'on'];
 /**
  * `(inherit)` IS THE EMPTY STRING, rendered as a word.
  *
@@ -107,6 +109,48 @@ export function fastSettingsFrom(fast) {
         fastReviewBudget: String(fast.reviewMaxPerSession),
     };
 }
+/**
+ * Read the three compaction rows back into a config patch.
+ *
+ * A TYPO CHANGES NOTHING — the discipline `readFastSettings` states one function
+ * up, and the reason is the same: a threshold that silently resolved to the
+ * default on a mistyped keystroke would be a setting the user believes they
+ * changed and did not. `parseThresholdInput` returns `null` for anything that is
+ * not a ratio or a percentage, and the key is then simply absent from the patch.
+ */
+export function readCompactionSettings(values) {
+    const threshold = parseThresholdInput(values.compactionThreshold);
+    const keep = values.compactionKeepTurns.trim();
+    const parsedKeep = /^\d+$/.test(keep) ? Number.parseInt(keep, 10) : Number.NaN;
+    return {
+        enabled: values.compactionEnabled === 'on',
+        ...(threshold !== null ? { threshold } : {}),
+        ...(Number.isFinite(parsedKeep) && parsedKeep > 0 ? { keepRecentTurns: parsedKeep } : {}),
+        // AN ENUM ROW CANNOT BE MISTYPED, so unlike the two text rows above these are
+        // written unconditionally.
+        subagents: values.compactionSubagents === 'on',
+        archive: values.compactionArchive === 'on',
+    };
+}
+/**
+ * The inverse: seed the three rows from a resolved config.
+ *
+ * OMITTING A KEY HERE IS THE SILENT HALF OF ADDING A ROW, exactly as it is for
+ * the fast rows above: the row renders empty, `readCompactionSettings` sees an
+ * unparseable value, and an untouched save writes the clamp's default over
+ * whatever the user had.
+ */
+export function compactionSettingsFrom(compaction) {
+    return {
+        compactionEnabled: compaction.enabled ? 'on' : 'off',
+        // A PERCENTAGE, because that is the unit the status bar shows and the unit a
+        // user thinks in. `parseThresholdInput` accepts it back.
+        compactionThreshold: String(Math.round(compaction.threshold * 100)),
+        compactionKeepTurns: String(compaction.keepRecentTurns),
+        compactionSubagents: compaction.subagents ? 'on' : 'off',
+        compactionArchive: compaction.archive ? 'on' : 'off',
+    };
+}
 const FIELDS = [
     { key: 'provider', label: 'Provider', kind: 'enum', options: ADAPTER_PROVIDERS },
     { key: 'model', label: 'Model', kind: 'text' },
@@ -146,6 +190,22 @@ const FIELDS = [
     { key: 'fastProvider', label: 'Fast provider', kind: 'enum', options: FAST_PROVIDER_OPTIONS },
     { key: 'fastReview', label: 'Fast review', kind: 'text' },
     { key: 'fastReviewBudget', label: 'Fast budget', kind: 'text' },
+    // Context compaction sits after the fast rows and still BEFORE `API key`, for
+    // the reason recorded above that row: the key is the one a user scrolls to
+    // deliberately, and burying it further would be worse than the ordering is
+    // better. Three rows, and every label is inside the 18-column budget
+    // `.padEnd(18)` enforces below.
+    //
+    // `Compact at` is a PERCENTAGE and carries no `(50-95)` hint, for the reason
+    // `Fast budget` records: no other bounded row carries its range either,
+    // `clampCompactionConfig` is the enforcement, and `/compact threshold` states
+    // the range in the one place a user meets it — when it refuses a bad one.
+    { key: 'compactionEnabled', label: 'Auto-compaction', kind: 'enum', options: COMPACTION_ENABLED_OPTIONS },
+    { key: 'compactionThreshold', label: 'Compact at %', kind: 'text' },
+    { key: 'compactionKeepTurns', label: 'Keep turns', kind: 'text' },
+    // Both labels are inside the 18-column budget `.padEnd(18)` enforces below.
+    { key: 'compactionSubagents', label: 'Compact children', kind: 'enum', options: COMPACTION_ENABLED_OPTIONS },
+    { key: 'compactionArchive', label: 'Archive dropped', kind: 'enum', options: COMPACTION_ENABLED_OPTIONS },
     { key: 'apiKey', label: 'API key', kind: 'secret' },
     { key: 'logLevel', label: 'Log level', kind: 'enum', options: LOG_LEVEL_NAMES },
 ];
@@ -233,7 +293,19 @@ export function SettingsScreen({ initial, apiKeys, maxRows, cols, scrollOffset,
             return;
         }
         if (input && !key.ctrl && !key.meta) {
-            setValues((prev) => ({ ...prev, [field.key]: String(prev[field.key]) + input }));
+            // `stripPasteFrames`, NOT `input` (I-12 / P0-2). `useInput` is a BROADCAST,
+            // so this handler sees the NUL-framed paste the composer was sent. An API
+            // key is ~100 characters with no line break, which trips the filter's Tier
+            // 2 burst rule and gets framed -- and nothing downstream would remove the
+            // NULs: `trim()` does not treat U+0000 as whitespace, `maskDot` hides the
+            // damage, and the value is handed to `registerSecret()` and
+            // `controller.setApiKey()`. The user is told the settings were saved and
+            // every request afterwards fails to authenticate with nothing on screen to
+            // explain it. Pasting IS how a key enters this process.
+            const text = stripPasteFrames(input);
+            if (text.length === 0)
+                return;
+            setValues((prev) => ({ ...prev, [field.key]: String(prev[field.key]) + text }));
         }
     });
     const displayValue = (f, selected) => {

package/dist/ui/palettes.d.ts

@@ -32,6 +32,22 @@ export interface Palette {
     idleBorder: string;
     hintFg: string;
     logoShadow: string;
+    /**
+     * Drag-selection highlight (tui-selection-and-scroll-follow §4.4.4).
+     *
+     * A PAIR, not a background alone: the selected run has its inner SGR stripped
+     * before it is repainted, so whatever foreground the row had is gone by the
+     * time the highlight is applied and a background on its own would leave the
+     * text at the terminal's default colour over an arbitrary hue. The two are
+     * contrast-pinned against EACH OTHER in `palettes.test.ts` — the surface a
+     * selected glyph sits on is `selectionBg`, not `DARK_SURFACE`.
+     *
+     * Below ansi-256 these never reach the terminal at all: `highlight.ts` emits
+     * plain reverse video there, because `getTheme` has degraded them to chalk
+     * colour NAMES by then and a name is not an escape sequence.
+     */
+    selectionBg: string;
+    selectionFg: string;
     gradient: [string, string, string];
     gauge: {
         track: string;

package/dist/ui/palettes.js

@@ -39,6 +39,8 @@ export const WARM = {
     idleBorder: '#4a423b',
     hintFg: '#9c9086',
     logoShadow: '#4a423b',
+    selectionBg: '#e0b088',
+    selectionFg: '#1c1917',
     gradient: ['#d08c60', '#c9a227', '#b0916a'],
     gauge: { track: '#4a423b', low: '#7fb08a', mid: '#c9a227', high: '#cf6b5c' },
     diff: { add: '#7fb08a', remove: '#cf6b5c', meta: '#d08c60', context: '#a2968a' },
@@ -66,6 +68,8 @@ export const COOL = {
     idleBorder: '#3b4261',
     hintFg: '#565f89',
     logoShadow: '#3b4261',
+    selectionBg: '#7aa2f7',
+    selectionFg: '#1a1b26',
     gradient: ['#7aa2f7', '#bb9af7', '#7dcfff'],
     gauge: { track: '#3b4261', low: '#9ece6a', mid: '#e0af68', high: '#f7768e' },
     diff: { add: '#9ece6a', remove: '#f7768e', meta: '#7aa2f7', context: '#7a86b8' },
@@ -92,6 +96,8 @@ export const LIGHT = {
     idleBorder: '#c8cdd6',
     hintFg: '#6b7280',
     logoShadow: '#c8cdd6',
+    selectionBg: '#2959aa',
+    selectionFg: '#ffffff',
     gradient: ['#2959aa', '#8c4bc9', '#0f7490'],
     gauge: { track: '#c8cdd6', low: '#2e7d32', mid: '#b5730f', high: '#c62828' },
     diff: { add: '#2e7d32', remove: '#c62828', meta: '#2959aa', context: '#6b7280' },