@aragon-agent/cli 0.6.2 → 0.6.3

package/dist/agent/reducer.js

@@ -11,6 +11,7 @@
  *     synthesizes a generic error notice (a swallowed throw is never a no-op).
  */
 import process from 'node:process';
+import { occupiedTokens } from '../compaction/pressure.js';
 import { computeCost } from './usage.js';
 import { ENTRY_LIMITS, appendBounded, entryRetain, trimEntries } from './entry-limits.js';
 /** Default auto-dismiss window for a toast. */
@@ -46,11 +47,14 @@ export function initialViewState(seed = {}) {
         todos: null,
         retry: null,
         fast: null,
+        compaction: null,
+        contextTokensEstimated: false,
         seq: 0,
         teamEntryId: undefined,
         todoEntryId: undefined,
         retryEntryId: undefined,
         fastEntryId: undefined,
+        compactionEntryId: undefined,
         streamingId: undefined,
         turnProduced: false,
         errorNoticed: false,
@@ -223,6 +227,17 @@ function reduceStreamEvent(se) {
             return [];
     }
 }
+/**
+ * The opening words of the `context_overflow` banner.
+ *
+ * A SHARED CONSTANT RATHER THAN TWO LITERALS, because `compactionStart` matches
+ * on it to rewrite the notice a successful reactive recovery would otherwise
+ * leave behind (P1-4). Two spellings that must agree, with nothing checking that
+ * they do, is how that rewrite silently stops matching — at which point the red
+ * "start over" banner comes back and only on the recovery path, which is the one
+ * place nobody re-tests.
+ */
+export const CONTEXT_OVERFLOW_NOTICE_PREFIX = 'Context length exceeded';
 /** Turn a provider error into a friendly banner, mapping LLMError.errorType. */
 export function formatStreamError(error) {
     const errorType = error.errorType;
@@ -235,7 +250,13 @@ export function formatStreamError(error) {
         case 'overloaded':
             return `Provider overloaded - please retry shortly. (${base})`;
         case 'context_overflow':
-            return `Context length exceeded - start a new conversation with /reset. (${base})`;
+            // `/compact` IS NAMED FIRST, and adding it is the second half of P1-4's
+            // fix. This remedy list predates context compaction and was, until it
+            // existed, complete: throwing the conversation away really was the only
+            // exit. It is not any more, and a banner that offers only `/reset` now
+            // tells the user to discard a session the very next line of code may be
+            // about to save.
+            return `${CONTEXT_OVERFLOW_NOTICE_PREFIX} - try /compact, or start over with /reset. (${base})`;
         case 'network_error':
             return `Network error reaching the provider. (${base})`;
         case 'timeout':
@@ -295,6 +316,11 @@ function appendEntry(state, entries, entry) {
             // `fastEntryId` IS PART OF THIS LIST for the reason the note above gives:
             // a fifth live card left out of it is a card I-L1-1 does not cover.
             state.fastEntryId,
+            // And `compactionEntryId` is the sixth. Same reason, and it is the one
+            // whose absence would be hardest to notice: a compaction card is rare, so
+            // a `mapEntry` that silently stopped matching would be found by a user
+            // rather than by a test.
+            state.compactionEntryId,
         ].filter((id) => typeof id === 'string');
         for (const id of live) {
             if (!trimmed.entries.some((e) => e.id === id)) {
@@ -584,7 +610,17 @@ export function viewReducer(state, action) {
                 ...state,
                 streamingId: undefined,
                 turnProduced: true,
-                contextTokens: action.usage.inputTokens + action.usage.outputTokens,
+                // ONE FUNCTION, SHARED WITH THE COMPACTION TRIGGER (§3.4.1 / R-11 /
+                // AC-3). The old expression — `inputTokens + outputTokens` — silently
+                // UNDER-reports for anyone behind a caching gateway, because Anthropic
+                // reports `input_tokens` EXCLUDING cached tokens and puts them in two
+                // separate fields. That was a live defect in the number this gauge shows;
+                // it becomes a much worse one the moment a trigger fires on a different
+                // number from the one the user is watching.
+                contextTokens: occupiedTokens(action.usage),
+                // A MEASUREMENT SUPERSEDES A DERIVATION (§6.2). `compactionEnd` writes an
+                // estimate so the bar falls immediately; this is where it stops being one.
+                contextTokensEstimated: false,
                 usageTotal: {
                     inputTokens: state.usageTotal.inputTokens + action.usage.inputTokens,
                     outputTokens: state.usageTotal.outputTokens + action.usage.outputTokens,
@@ -713,6 +749,12 @@ export function viewReducer(state, action) {
                 // holds, it is a projection of an entry that has just been erased.
                 retryEntryId: undefined,
                 retry: null,
+                // Same reasoning again for the compaction card: the entry is gone, so the
+                // id must go with it or `compactionEnd` would `mapEntry` an id that no
+                // longer exists. `compaction` STAYS — unlike `retry` it is not a
+                // projection of an entry, it is the live state of a subsystem that is
+                // still running, and `/clear` clears the screen rather than the session.
+                compactionEntryId: undefined,
             };
         case 'resetConversation':
             return {
@@ -731,6 +773,11 @@ export function viewReducer(state, action) {
                 todoEntryId: undefined,
                 retryEntryId: undefined,
                 retry: null,
+                compactionEntryId: undefined,
+                // `contextTokens` is zeroed above, so the flag that says it is a
+                // DERIVATION has to go with it — otherwise a fresh conversation renders
+                // `~0%` and the tilde is a lie about a number that is simply zero.
+                contextTokensEstimated: false,
             };
         case 'setOverlay':
             return { ...state, overlay: action.overlay };
@@ -957,6 +1004,158 @@ export function viewReducer(state, action) {
             };
         case 'fastTier':
             return { ...state, fast: action.snapshot };
+        // --- Context compaction (context-auto-compaction §5.5) ----------------
+        case 'compactionStart': {
+            const { id, seq } = nextId(state);
+            let entries = state.entries;
+            // RESPONSIBILITY 1 — SEAL ANY LIVE `streamingId` ENTRY, defensively.
+            // C-8's failure mode, and reachable here: `provider.ts` records that
+            // Anthropic can deliver an error IN-STREAM, after the connection is open
+            // and therefore after text deltas have already been emitted. An entry that
+            // never settles pins `Transcript`'s monotonic boundary and re-renders the
+            // tail forever.
+            if (state.streamingId) {
+                entries = mapEntry(entries, state.streamingId, (e) => e.kind === 'assistant' ? { ...e, streaming: false, ...sealThinkingMs(e) } : e);
+            }
+            // RESPONSIBILITY 2 — REWRITE A TRAILING `context_overflow` ERROR NOTICE
+            // (P1-4). `agent-loop.ts` emits `message_update` for EVERY stream event
+            // before the `error` branch throws, and `reduceStreamEvent`'s `case 'error'`
+            // turns that into a `level: 'error'` notice reading "Context length
+            // exceeded". So the HAPPY PATH of the reactive recovery would otherwise end
+            // with a red banner telling the user to throw away the session we are one
+            // frame from saving.
+            //
+            // IT REWRITES RATHER THAN REMOVES, because `<Static>` cannot un-print an
+            // entry it has already drawn — and it matches ONLY when that notice is the
+            // TAIL entry, so it can never touch an older, genuine error. If the
+            // recovery then fails, the ladder's own notice or the re-thrown 400 is what
+            // the user is left with, so neither direction lies.
+            if (action.trigger === 'overflow') {
+                const tail = entries[entries.length - 1];
+                if (tail &&
+                    tail.kind === 'notice' &&
+                    tail.level === 'error' &&
+                    tail.text.startsWith(CONTEXT_OVERFLOW_NOTICE_PREFIX)) {
+                    entries = mapEntry(entries, tail.id, (e) => e.kind === 'notice'
+                        ? { ...e, level: 'info', text: 'Context window exceeded - compacting and retrying.' }
+                        : e);
+                }
+            }
+            const entry = {
+                id,
+                kind: 'compaction',
+                index: action.index,
+                trigger: action.trigger,
+                mode: 'none',
+                applied: false,
+                messagesBefore: 0,
+                messagesAfter: 0,
+                tokensBefore: 0,
+                tokensAfter: 0,
+                model: action.model,
+                startedAt: Date.now(),
+                live: true,
+            };
+            return {
+                ...state,
+                seq,
+                ...appendEntry(state, entries, entry),
+                compactionEntryId: id,
+                streamingId: undefined,
+            };
+        }
+        case 'compactionEnd': {
+            const { record } = action;
+            const settle = (e) => e.kind === 'compaction'
+                ? {
+                    ...e,
+                    index: record.index,
+                    trigger: record.trigger,
+                    mode: record.mode,
+                    applied: record.applied,
+                    ...(record.reason !== undefined ? { reason: record.reason } : {}),
+                    messagesBefore: record.messagesBefore,
+                    messagesAfter: record.messagesAfter,
+                    tokensBefore: record.tokensBefore,
+                    tokensAfter: record.tokensAfter,
+                    ...(record.summary !== undefined ? { summary: record.summary } : {}),
+                    ...(record.tailRelief ? { tailRelief: record.tailRelief } : {}),
+                    model: record.model,
+                    durationMs: record.durationMs,
+                    // SETTLED. `Transcript`'s boundary is monotonic, so a card that
+                    // never settles is re-rendered on every frame for the rest of the
+                    // session (C-8).
+                    live: false,
+                }
+                : e;
+            // THE SECOND BRANCH IS NOT DEFENSIVE PADDING, exactly as `fastEnd`'s is
+            // not: the IDLE `/compact` path settles a record for a card this session
+            // may never have opened, and "it did nothing" must never be the observable
+            // outcome (R-8 / §6.4).
+            if (state.compactionEntryId) {
+                return {
+                    ...state,
+                    entries: mapEntry(state.entries, state.compactionEntryId, settle),
+                    compactionEntryId: undefined,
+                };
+            }
+            const { id, seq } = nextId(state);
+            const entry = {
+                id,
+                kind: 'compaction',
+                index: record.index,
+                trigger: record.trigger,
+                mode: record.mode,
+                applied: record.applied,
+                ...(record.reason !== undefined ? { reason: record.reason } : {}),
+                messagesBefore: record.messagesBefore,
+                messagesAfter: record.messagesAfter,
+                tokensBefore: record.tokensBefore,
+                tokensAfter: record.tokensAfter,
+                ...(record.summary !== undefined ? { summary: record.summary } : {}),
+                ...(record.tailRelief ? { tailRelief: record.tailRelief } : {}),
+                model: record.model,
+                durationMs: record.durationMs,
+                live: false,
+            };
+            return { ...state, seq, ...appendEntry(state, state.entries, entry) };
+        }
+        case 'compactionUsage':
+            // `usageTotal` AND NOTHING ELSE, exactly as `teamUsage` and `fastUsage`. In
+            // particular NOT `contextTokens`: that gauge shows the LEAD's context
+            // occupancy against the lead model's window, and a summarization is a
+            // separate conversation with a possibly different model entirely.
+            return {
+                ...state,
+                usageTotal: {
+                    inputTokens: state.usageTotal.inputTokens + action.usage.inputTokens,
+                    outputTokens: state.usageTotal.outputTokens + action.usage.outputTokens,
+                    costUsd: state.usageTotal.costUsd + action.costDelta,
+                },
+            };
+        case 'compactionSnapshot':
+            return { ...state, compaction: action.snapshot };
+        /**
+         * THE GAUGE MUST FALL IMMEDIATELY (§6.2 / AC-5).
+         *
+         * `contextTokens` is otherwise only written at `turnEnd`, so a compaction
+         * that took the session from 92 % to 24 % would leave the bar at 92 % until
+         * the next turn completes — and the user would reasonably conclude that
+         * nothing happened. This is a small change and it is the difference between
+         * the feature feeling real and feeling broken.
+         *
+         * The value arrives ALREADY CALIBRATED from `App` (§6.2 / P1-11): it replaces
+         * a MEASUREMENT that included the tool schemas, and core's raw estimator
+         * never counts them, so writing the raw figure would make the bar fall too
+         * far and then visibly climb again on the next `turn_end` for no reason the
+         * user can see.
+         */
+        case 'contextTokensEstimated':
+            return {
+                ...state,
+                contextTokens: Math.max(0, Math.round(action.tokens)),
+                contextTokensEstimated: true,
+            };
         // --- API retry (llm-api-retry-backoff §6.4) ---------------------------
         case 'retryScheduled': {
             const snapshot = {

package/dist/cli.js

@@ -23,11 +23,11 @@ import { formatMigrationNotice, migrateLegacyState } from './config/migrate-lega
 import { formatHomeMigrationNotice, migrateToHome } from './config/migrate-home.js';
 import { migrateStateOutOfConfig } from './config/migrate-state-out-of-config.js';
 import { runHistoryCommand } from './config/history-commands.js';
-import { FAST_CONFIG_SET_KEYS, LOG_CONFIG_SET_KEYS, RETRY_CONFIG_SET_KEYS, TEAM_CONFIG_SET_KEYS, UPDATE_CONFIG_SET_KEYS, applyFastConfigSet, applyLogConfigSet, applyRetryConfigSet, applyTeamConfigSet, applyUpdateConfigSet, runConfigEdit, runConfigGet, runConfigHome, runConfigList, warnIfRedactionDisabled, } from './config/cli-commands.js';
+import { COMPACTION_CONFIG_SET_KEYS, FAST_CONFIG_SET_KEYS, LOG_CONFIG_SET_KEYS, RETRY_CONFIG_SET_KEYS, TEAM_CONFIG_SET_KEYS, UPDATE_CONFIG_SET_KEYS, applyCompactionConfigSet, applyFastConfigSet, applyLogConfigSet, applyRetryConfigSet, applyTeamConfigSet, applyUpdateConfigSet, runConfigEdit, runConfigGet, runConfigHome, runConfigList, warnIfRedactionDisabled, } from './config/cli-commands.js';
 import { attachAgentEvents, attachTeamEvents, installLogging, setScreenRestore, setSignalTerminator, } from './logging/install.js';
 import { getLogger } from './logging/logger.js';
 import { runLogsCommand } from './logging/cli-commands.js';
-import { ADAPTER_PROVIDERS, clampDensity, clampTheme, clampThinkingLevel, clampAskRounds, clampHumanTimeout, clampSkillsIntegrity, clampSkillsToolPolicy, clampMaxRenderInterval, clampTranscriptRetain, clampTranscriptWindow, coercePositiveInt, isAdapterProvider, parseMaxTokensInput, DEFAULT_MAX_RENDER_INTERVAL_MS, DEFAULT_MAX_TOKENS, DEFAULT_PLAN_HUMAN_TIMEOUT_MS, DEFAULT_PLAN_MAX_ASK_ROUNDS, DEFAULT_SKILLS_CONFIG, DEFAULT_TRANSCRIPT_RETAIN, DEFAULT_TRANSCRIPT_WINDOW, } from './config/schema.js';
+import { ADAPTER_PROVIDERS, clampDensity, clampTheme, clampThinkingLevel, clampAskRounds, clampHumanTimeout, clampSkillsIntegrity, clampSkillsToolPolicy, clampMaxRenderInterval, clampScrollResumeMs, clampTranscriptRetain, clampTranscriptWindow, coercePositiveInt, isAdapterProvider, parseMaxTokensInput, DEFAULT_MAX_RENDER_INTERVAL_MS, DEFAULT_MAX_TOKENS, DEFAULT_PLAN_HUMAN_TIMEOUT_MS, DEFAULT_PLAN_MAX_ASK_ROUNDS, DEFAULT_SCROLL_RESUME_MS, DEFAULT_SKILLS_CONFIG, DEFAULT_TRANSCRIPT_RETAIN, DEFAULT_TRANSCRIPT_WINDOW, } from './config/schema.js';
 import { makeGetApiKey } from './config/load.js';
 import { AgentController, DENY_ALL_APPROVAL } from './agent/controller.js';
 import { runSkillsCommand } from './skills/cli-commands.js';
@@ -52,6 +52,9 @@ import { readExitSnapshot } from './ui/exit-snapshot.js';
 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
 // (cli-auto-update-hardening P2-7). `boot/guard.js` statically pulls
@@ -105,6 +108,11 @@ function toFlags(opts) {
         // Without this line the flag never reaches `CliFlags` and `--no-mouse` is
         // inert — a failure with no compile error and no runtime error (P1-2).
         mouse: opts.mouse,
+        // Site three of three for `--mouse-select` / `--no-mouse-select` — NINE
+        // features, one trap. A flag needs the `.option()` declaration below, a field
+        // on `CliFlags`, AND a line here; `config.test.ts` is the regression pin that
+        // exists because `--no-mouse` shipped inert once already.
+        mouseSelect: opts.mouseSelect,
         skills: opts.skills,
         skill: opts.skill,
         skillsYes: opts.skillsYes,
@@ -171,6 +179,15 @@ function toFlags(opts) {
         // means `--no-update` reports nothing, does nothing, and leaves the updater
         // running.
         update: opts.update,
+        // Site three of three for `--compaction` / `--no-compaction` — NINE
+        // features, one trap. A flag needs the `.option()` declaration below, a field
+        // on `CliFlags`, AND a line here; miss this one and the flag is inert with no
+        // compile error and no runtime error. It bites here for the same reason it
+        // does one field up: this is the KILL SWITCH for a feature that spends the
+        // user's money on a summarizer, so a missing line means `--no-compaction`
+        // reports nothing, does nothing, and leaves compaction armed.
+        compaction: opts.compaction,
+        compactionThreshold: opts.compactionThreshold,
     };
 }
 // ---------------------------------------------------------------------------
@@ -421,6 +438,20 @@ function runInteractive(flags, extras = {}) {
         ? tryCreateMouseFilter(process.stdin, (reason) => logger.warn('cli', 'mouse_filter_failed', { reason }))
         : null;
     const disposeMouse = () => mouseFilter?.dispose();
+    // --- Drag-select (tui-selection-and-scroll-follow §4.4). ------------------
+    //
+    // ONE EXPRESSION, READ BY FOUR THINGS, and that is the same discipline
+    // `wantMouse` above follows for the same reason: the `?1002h` write, the
+    // controller, the differ's `decorate` hook and the startup notice must never
+    // disagree about whether drag-select is running. With it false the session is
+    // byte-identical to a pre-feature build — no extra escape on the wire (AC-8),
+    // no controller, no `decorate`, no mirror.
+    const wantSelect = mouseFilter !== null && config.mouseSelect;
+    const selectionBridge = {
+        controller: null,
+        onCopied: null,
+        requestRedraw: null,
+    };
     // --- Frame differ (tui-input-flicker-fix §3.2 / §4.2). -------------------
     //
     // FULL-SCREEN ONLY, and that is invariant I-3 rather than caution: inline mode
@@ -443,6 +474,25 @@ function runInteractive(flags, extras = {}) {
             // edge inside the differ: a notice per fallback would be a repaint
             // storm triggered by a repaint problem (§5.6).
             onFirstFallback: () => console.warn(FRAME_FALLBACK_NOTICE),
+            // ABSENT ENTIRELY without drag-select, not a no-op function: the
+            // differ's identity path then allocates nothing and copies nothing,
+            // which is what makes `mouseSelect: false` a statement about the code
+            // rather than about how cheap an empty function is.
+            ...(wantSelect
+                ? {
+                    decorate: (lines) => selectionBridge.controller?.decorate(lines) ?? lines,
+                    // P1-7: a pass-through frame writes the RAW Ink frame verbatim,
+                    // so the highlight is wiped off the terminal while the
+                    // controller still believes it is painted. Deferred out of the
+                    // current stack because this fires from inside `transform`,
+                    // which is inside Ink's own `stdout.write`.
+                    onInvalidate: () => {
+                        const controller = selectionBridge.controller;
+                        if (controller)
+                            setImmediate(() => controller.clear());
+                    },
+                }
+                : {}),
         }))
         : null;
     // `null` when no writer was built, so `/perf` can say "diff render off" rather
@@ -478,8 +528,9 @@ function runInteractive(flags, extras = {}) {
     if (mode === 'fullscreen') {
         // `mouse` here means "a 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.
-        screen = enterAltScreen(process.stdout, { mouse: mouseFilter !== null });
+        // itself, or a later refactor re-opens the gap I-8 closes. `motion` carries
+        // the same discipline for `?1002h`: already decided, never re-derived.
+        screen = enterAltScreen(process.stdout, { mouse: mouseFilter !== null, motion: wantSelect });
         const restore = () => screen?.restore();
         // Four idempotent restore paths (§4.4). The signal hook is NOT redundant:
         //   - `waitUntilExit().then()` is a microtask and may never be reached when
@@ -516,6 +567,115 @@ function runInteractive(flags, extras = {}) {
     // `CI` is excluded on top of the two TTY tests because a CI runner with a pty
     // allocated is otherwise a machine that silently mutates its own global
     // toolchain mid-pipeline (D-11).
+    // --- The foreign-write door (§4.4.5). ------------------------------------
+    //
+    // Where bytes that are OURS but are NOT a frame go — today, the OSC 52
+    // clipboard sequence. THREE SHAPES, ONE DOOR, and the third one is the reason
+    // this is a resolved value rather than an inline arrow:
+    //
+    //  * with the differ in front of stdout it MUST be `frameWriter.writeForeign`,
+    //    which invalidates the cache and skips the fallback accounting — through
+    //    the proxy the same bytes are an unrecognised chunk, which is
+    //    `passThrough(true)`, which prints `FRAME_FALLBACK_NOTICE` at a user who
+    //    did nothing but copy something (P1-6);
+    //  * without one — `--no-diff-render`, and inline mode, which never builds a
+    //    differ at all — stdout IS the real stream, so a direct write is both safe
+    //    and what §4.4.5 prescribes. OSC 52 emits no newline, so Ink's own line
+    //    accounting is untouched and there is nothing to invalidate;
+    //  * on a non-TTY there is no terminal to accept it, so the door is ABSENT.
+    //
+    // It must never be a function that accepts a chunk and writes NOWHERE.
+    // `copyText` reports `'osc52'` whenever its door took the text, so a silent
+    // no-op door — which `frameWriter?.writeForeign(chunk)` is under
+    // `--no-diff-render` — makes the toast name a mechanism that was never
+    // attempted. Naming the mechanism honestly is the entire reason that return
+    // value exists (R-7), and a door that lies is worse than no door.
+    const writeForeign = frameWriter
+        ? (text) => frameWriter.writeForeign(text)
+        : process.stdout.isTTY
+            ? (text) => {
+                try {
+                    process.stdout.write(text);
+                }
+                catch {
+                    // A closed or broken stdout must never turn a copy into a crash.
+                }
+            }
+            : null;
+    // --- The selection controller (§4.4). ------------------------------------
+    //
+    // BUILT AFTER `enterAltScreen` AND BEFORE `render()`. After, because it must
+    // not exist on a session that never asked the terminal to report motion;
+    // before, because `decorate` is read by the differ from the very first frame
+    // Ink produces.
+    //
+    // `mouseCaptured` is the run-time answer for `/mouse`, and it lives here rather
+    // than inside `screen.ts`'s closure because `App` needs to READ it and the
+    // handle's own flag is private (it has to be — `restore()` reads it, and
+    // exposing a setter would be a second way to get the two out of step).
+    let mouseCaptured = mouseFilter !== null;
+    if (wantSelect && mouseFilter) {
+        selectionBridge.controller = createSelectionController({
+            source: mouseFilter.source,
+            // The frame writer is absent under `--no-diff-render`, where there is no
+            // cache to repaint from at all; the controller then falls back to asking
+            // `App` for a React redraw on every drag flush, which is slower and
+            // 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),
+            // 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),
+            cols: () => process.stdout.columns ?? 80,
+            // The STATIC half of the gate. The dynamic half — "no overlay is open" —
+            // belongs to `App`, which owns that state and calls `setEnabled`.
+            isSelectable: () => mouseCaptured,
+        });
+    }
+    const disposeSelection = () => {
+        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,
+            ...(mouseFilter
+                ? {
+                    setMouseCapture: (on) => {
+                        screen?.setMouseCapture(on);
+                        mouseCaptured = on;
+                        // A released mouse cannot be dragging, and a selection left
+                        // painted over a screen the terminal is now selecting on its
+                        // own would be two highlights claiming the same rows.
+                        if (!on)
+                            selectionBridge.controller?.clear();
+                    },
+                    isMouseCaptured: () => mouseCaptured,
+                }
+                : {}),
+            // The same door the controller copies through, so `/copy` and a
+            // drag-release can never disagree about which stream OSC 52 goes to.
+            ...(writeForeign ? { writeForeign } : {}),
+            ...(selectionBridge.controller ? { selection: selectionBridge } : {}),
+        }
+        : undefined;
     const updateBridge = { service: null, onAttach: null };
     let updateService = null;
     const updateEligible = !!process.stdout.isTTY &&
@@ -528,7 +688,7 @@ function runInteractive(flags, extras = {}) {
         // the same tree on every machine — reading `process.versions.node` from
         // a component would make the notice appear or vanish according to which
         // Node the developer happened to have installed.
-        vtInputWarning: vtInputSupported ? undefined : { nodeVersion: process.versions.node }, updateBridge: updateEligible ? updateBridge : undefined }), 
+        vtInputWarning: vtInputSupported ? undefined : { nodeVersion: process.versions.node }, updateBridge: updateEligible ? updateBridge : undefined, terminal: terminalBridge }), 
     // Full-screen owns console.* itself (I-4): Ink's patchConsole writes
     // straight to stdout and permanently shifts the fixed frame's accounting.
     {
@@ -597,6 +757,11 @@ function runInteractive(flags, extras = {}) {
         .waitUntilExit()
         .then(() => {
         screen?.restore();
+        // BEFORE `disposeMouse()`, which clears the listener set it subscribed to,
+        // and after `restore()` for the reason that call records: the terminal must
+        // stop reporting first, and anything already in flight is still consumed by
+        // a live filter.
+        disposeSelection();
         disposeMouse();
         // BOTH BRANCHES, the same discipline `controller.dispose()` and
         // `updateService?.dispose()` already follow. It drops the `'resize'`
@@ -621,6 +786,11 @@ function runInteractive(flags, extras = {}) {
     })
         .catch(() => {
         screen?.restore();
+        // BEFORE `disposeMouse()`, which clears the listener set it subscribed to,
+        // and after `restore()` for the reason that call records: the terminal must
+        // stop reporting first, and anything already in flight is still consumed by
+        // a live filter.
+        disposeSelection();
         disposeMouse();
         disposeFrameWriter();
         controller.dispose();
@@ -737,6 +907,11 @@ const CONFIG_SET_KEYS = new Set([
     // falls through every case, writes nothing, and still prints
     // `Set mouse = false` (P1-2) -- exactly what happened to `density`/`hints`.
     'mouse',
+    // Both cased in the switch below, for the reason the note above `mouse`
+    // records: a key listed here but absent there writes nothing and still prints
+    // `Set mouseSelect = false`.
+    'mouseSelect',
+    'scrollResumeMs',
     'historyEnabled',
     'planModeDefault',
     'planModeMaxAskRounds',
@@ -763,6 +938,11 @@ const CONFIG_SET_KEYS = new Set([
     ...FAST_CONFIG_SET_KEYS,
     // `update.*` keys are handled by `applyUpdateConfigSet`, same reasoning again.
     ...UPDATE_CONFIG_SET_KEYS,
+    // `compaction.*` keys are handled by `applyCompactionConfigSet`, same
+    // reasoning again — and this set is what makes the kill switch reachable from
+    // a script at all: `config list` enumerates the section dynamically and so
+    // shows these keys whether they are here or not, while `config set` does not.
+    ...COMPACTION_CONFIG_SET_KEYS,
 ]);
 /**
  * `aragon config set maxTokens <n|auto|default>`.
@@ -849,6 +1029,18 @@ function runConfigSet(key, value) {
         process.stdout.write(`Set ${key} = ${String(merged.update[field])}\n`);
         return;
     }
+    const compactionPatch = applyCompactionConfigSet(key, value);
+    if (compactionPatch) {
+        // Echoed from the STORED value, so `config set compaction.threshold 0.2`
+        // prints the clamped 0.5 rather than reporting a number that was never
+        // written — the rule `team.*`, `retry.*`, `fast.*` and `update.*` each state
+        // above. It matters most for `warnThreshold`, which is clamped against the
+        // stored `threshold` and so can move for a reason the caller cannot see.
+        const merged = updatePersistedConfig(compactionPatch);
+        const field = key.slice('compaction.'.length);
+        process.stdout.write(`Set ${key} = ${String(merged.compaction[field])}\n`);
+        return;
+    }
     const patch = {};
     switch (key) {
         case 'provider':
@@ -914,6 +1106,16 @@ function runConfigSet(key, value) {
         case 'mouse':
             patch.mouse = value === 'true' || value === '1';
             break;
+        case 'mouseSelect':
+            patch.mouseSelect = value === 'true' || value === '1';
+            break;
+        // Clamped rather than rejected, for the same reason `planModeDefault` below
+        // records: hardening only the READ path leaves a bad value on disk that
+        // reverts to the default on every launch, which presents as "my setting
+        // won't stick". `0` is a legal value here and its documented off switch.
+        case 'scrollResumeMs':
+            patch.scrollResumeMs = clampScrollResumeMs(value, DEFAULT_SCROLL_RESUME_MS);
+            break;
         // Turning this off stops new prompts being recorded; it does NOT delete
         // what is already in `prompt-history.jsonl` (that is `aragon history clear`).
         case 'historyEnabled':
@@ -1172,6 +1374,13 @@ function buildProgram() {
         // Positive form first, same tri-state reason as `--fullscreen` above.
         .option('--mouse', 'Wheel scrolls the transcript (full-screen mode)')
         .option('--no-mouse', 'Leave the mouse to the terminal (the wheel does nothing)')
+        // Positive form FIRST, for the tri-state reason `--fullscreen` records
+        // below: `mouseSelect` is persisted and defaults to `true`, so a lone
+        // `--no-mouse-select` would make commander default `opts.mouseSelect` to
+        // `true` — indistinguishable from silence, and silently overriding a stored
+        // `false` on every run that passes no flag at all.
+        .option('--mouse-select', 'Drag with the mouse to select text; releasing copies it')
+        .option('--no-mouse-select', 'Keep wheel scrolling, but leave drag-select off')
         // 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".
@@ -1228,6 +1437,16 @@ function buildProgram() {
         // feature that installs software would quietly un-set itself (C-11).
         .option('--update', 'Check for and install updates in the background (the default)')
         .option('--no-update', 'Disable auto-update for this session')
+        // BOTH FORMS, positive first, for the reason recorded eight times above —
+        // and this pair shares `--update`'s polarity, which is the worst one.
+        // `compaction.enabled` is PERSISTED and defaults to `true`, so a lone
+        // `--no-compaction` would make commander default `opts.compaction` to `true`
+        // and silently overwrite a stored `false` on EVERY run that passed no flag at
+        // all: the kill switch for a feature that spends the user's money on a
+        // summarizer would quietly un-set itself (C-13 / P1-5).
+        .option('--compaction', 'Compact the conversation when the context window fills (the default)')
+        .option('--no-compaction', 'Never compact; a full context window ends the run as before')
+        .option('--compaction-threshold <n>', 'Occupancy that triggers compaction for this run: 0.9 or 90% (0.5-0.95)')
         .option('--no-skills', 'Disable the skill system entirely (no catalog, no skill tools)')
         .option('--skill <name>', 'Force-load a skill at Level 2 for this run (repeatable)', (value, previous = []) => [...previous, value])
         .option('--skills-yes', 'Approve skill installs for this run (CI / headless)')