@aragon-agent/cli 0.6.2 → 0.6.4

package/dist/agent/system-prompt.d.ts

@@ -88,6 +88,20 @@ export interface SystemPromptParams {
      * for a fixed `tools` array. Every existing caller passes nothing.
      */
     appendSystemPrompt?: string;
+    /**
+     * The rendered `<background_services>` block, or `''`
+     * (background-service-supervision §5.2).
+     *
+     * Spliced conditionally exactly as `skillsBlock`, the plan block, `teamBlock`,
+     * `todoBlock` and `fastBlock` are, which is what keeps I-2 true:
+     * `bash.background: false` produces the pre-feature prompt BYTE FOR BYTE for a
+     * fixed tool array.
+     *
+     * A CHILD'S PROMPT NEVER CARRIES IT: subagents build tools from the same
+     * factory but are given no supervisor, so telling one about `bash_output` /
+     * `bash_kill` would describe tools it does not have.
+     */
+    backgroundBlock?: string;
 }
 /** Describe the active shell so the model does not emit incompatible syntax. */
 export declare function describeShell(): {

package/dist/agent/system-prompt.js

@@ -41,6 +41,7 @@ export function buildSystemPrompt(params) {
     const subagentBlock = params.subagentBlock ?? '';
     const todoBlock = params.todoBlock ?? '';
     const fastBlock = params.fastBlock ?? '';
+    const backgroundBlock = params.backgroundBlock ?? '';
     const appended = (params.appendSystemPrompt ?? '').trim();
     return [
         'You are AragonAgent, an autonomous coding assistant operating inside a terminal (TUI).',
@@ -59,6 +60,7 @@ export function buildSystemPrompt(params) {
         ...(subagentBlock ? ['', subagentBlock] : []),
         ...(todoBlock ? ['', todoBlock] : []),
         ...(fastBlock ? ['', fastBlock] : []),
+        ...(backgroundBlock ? ['', backgroundBlock] : []),
         '',
         'Operating guidance:',
         '- Prefer reading files and inspecting the workspace before making changes.',

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';
@@ -44,7 +44,7 @@ import { decideRenderMode } from './ui/layout/frame.js';
 import { createFrameDiffer } from './ui/frame-differ.js';
 import { wrapStdoutForFrames } from './ui/stdout-frame-writer.js';
 import { setFrameStatsProvider } from './commands/perf.js';
-import { tryCreateMouseFilter } from './input/stdin-mouse-filter.js';
+import { tryCreateStdinFilter } from './input/stdin-filter.js';
 import { enterAltScreen, writeExitTranscript } from './ui/screen.js';
 import { supportsWindowsVtInput } from './ui/win-vt-input.js';
 import { forceWindowsVtInput } from './ui/win-vt-force.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,16 @@ 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,
+        // Site three of three for `--paste` / `--no-paste` -- TEN 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.
+        paste: opts.paste,
         skills: opts.skills,
         skill: opts.skill,
         skillsYes: opts.skillsYes,
@@ -171,6 +184,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,
     };
 }
 // ---------------------------------------------------------------------------
@@ -399,7 +421,7 @@ function runInteractive(flags, extras = {}) {
     // before it reaches this process, so `\x1b[?1000h` is a pure no-op and the
     // filter has nothing to filter. Gating `wantMouse` — rather than the three
     // things downstream of it — is what keeps the three in agreement: the
-    // `?1000h` write (`enterAltScreen(..., { mouse: filter !== null })`), the
+    // `?1000h` write (`enterAltScreen(..., { mouse: mouseOn })`), the
     // filter itself, and the `mouseSource` prop that decides whether the user is
     // advised about a mode that is not running. Wiring any of them separately
     // re-opens the gap where the app claims a capability it does not have.
@@ -417,10 +439,50 @@ function runInteractive(flags, extras = {}) {
         !!process.stdout.isTTY &&
         !!process.stdin.isTTY &&
         vtInputSupported;
-    const mouseFilter = wantMouse
-        ? tryCreateMouseFilter(process.stdin, (reason) => logger.warn('cli', 'mouse_filter_failed', { reason }))
+    // --- Paste handling (tui-paste-handling section 5.1.1 / D-13 / D-17). ----
+    //
+    // THE GATE IS WIDER THAN THE MOUSE'S, AND `paste` DEFAULTS TO TRUE. Paste
+    // needs no `vtInputSupported` and no full-screen: Tier 2 is a heuristic on
+    // chunk shape and needs no terminal cooperation at all, which is exactly why
+    // it exists for the consoles that never deliver `\x1b[200~` (R-11).
+    //
+    // WHAT THIS WIDENING BREAKS IF IT IS NOT PAIRED WITH `mouseOn` BELOW (P0-1).
+    // `filter !== null` used to be the answer to FIVE questions, only one of which
+    // is really about the stream. With paste able to build a filter on its own,
+    // `aragon --no-mouse` would get a non-null handle and every one of those five
+    // would flip true: `?1000h`/`?1006h`/`?1002h` written, terminal selection taken
+    // away (the ONLY reason anyone passes `--no-mouse`), and a startup notice
+    // advising the user about a mode they just disabled.
+    const wantPaste = config.paste && !!process.stdin.isTTY;
+    const pasteBridge = { notify: null };
+    const filter = wantMouse || wantPaste
+        ? tryCreateStdinFilter(process.stdin, { mouse: wantMouse, paste: wantPaste }, (reason) => logger.warn('cli', 'stdin_filter_failed', { reason }), pasteBridge)
         : null;
-    const disposeMouse = () => mouseFilter?.dispose();
+    /**
+     * THE ONE EXPRESSION EVERY MOUSE SITE READS (I-11 / D-17).
+     *
+     * `filter !== null` now answers exactly one question -- "is a stream wrapped?"
+     * -- and the only site allowed to keep reading it is the `stdin` handed to
+     * `render()`.
+     */
+    const mouseOn = wantMouse && filter !== null;
+    /** Same discipline for DEC 2004: already decided here, never re-derived. */
+    const pasteOn = wantPaste && filter !== null;
+    const disposeStdinFilter = () => filter?.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 = mouseOn && 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 +505,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
@@ -476,10 +557,21 @@ 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 });
+        // `mouse` here means "a mouse-parsing filter is installed", NOT "the user
+        // wants mouse support" — see `AltScreenOptions`. `screen.ts` must never
+        // derive it for itself, or a later refactor re-opens the gap I-8 closes.
+        // `motion` carries the same discipline for `?1002h`, and `bracketedPaste`
+        // for `?2004h`: all three are already decided, none is re-derived.
+        //
+        // IT IS `mouseOn`, NOT `filter !== null` (P0-1). A `--no-mouse` session with
+        // paste at its default `true` still builds a filter, and passing the handle
+        // here would write `?1000h` at a user who disabled the mouse precisely to
+        // keep their terminal's own selection.
+        screen = enterAltScreen(process.stdout, {
+            mouse: mouseOn,
+            motion: wantSelect,
+            bracketedPaste: pasteOn && mode === 'fullscreen',
+        });
         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,19 +608,136 @@ 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 = mouseOn;
+    if (wantSelect && filter) {
+        selectionBridge.controller = createSelectionController({
+            source: filter.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,
+            ...(mouseOn
+                ? {
+                    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 &&
         !!process.stdin.isTTY &&
         !process.env.CI &&
         config.update.mode !== 'off';
-    const instance = render(_jsx(App, { controller: controller, version: VERSION, mode: mode, confirmBridge: confirmBridge, humanInputBridge: humanInputBridge, initialPrompt: extras.initialPrompt, initialOverlay: extras.initialOverlay, mouseSource: mouseFilter?.source, 
+    const instance = render(_jsx(App, { controller: controller, version: VERSION, mode: mode, confirmBridge: confirmBridge, humanInputBridge: humanInputBridge, initialPrompt: extras.initialPrompt, initialOverlay: extras.initialOverlay, 
+        // `mouseOn`, NOT the handle (I-11). `App.tsx:186-188` documents this
+        // prop's contract as "absent under `--no-mouse`, inline, or non-TTY", and
+        // it feeds `enabled: !!mouseSource` on a wheel subscription that would
+        // otherwise be a channel no event can ever arrive on.
+        mouseSource: mouseOn && filter ? filter.source : undefined, 
         // Present ONLY when this console swallows `CSI Z` and mouse reports.
         // Passed in rather than probed inside `App` so that every test renders
         // the same tree on every machine — reading `process.versions.node` from
         // 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, 
+        // Absent when nothing can refuse a paste, so a `--no-paste` tree is
+        // byte-identical to a build without this feature.
+        pasteBridge: pasteOn ? pasteBridge : 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.
     {
@@ -536,7 +745,7 @@ function runInteractive(flags, extras = {}) {
         patchConsole: mode === 'inline',
         // I-5: with mouse support off the REAL stdin is handed over unwrapped, so
         // every existing path is provably unchanged.
-        stdin: mouseFilter?.stdin ?? process.stdin,
+        stdin: filter?.stdin ?? process.stdin,
         // SPREAD, not `frameWriter?.stdout ?? process.stdout`. This call passed no
         // `stdout` at all before, and Ink defaults it to `process.stdout`; omitting
         // the key entirely when the writer is off keeps the options object the same
@@ -597,7 +806,12 @@ function runInteractive(flags, extras = {}) {
         .waitUntilExit()
         .then(() => {
         screen?.restore();
-        disposeMouse();
+        // BEFORE `disposeStdinFilter()`, 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();
+        disposeStdinFilter();
         // BOTH BRANCHES, the same discipline `controller.dispose()` and
         // `updateService?.dispose()` already follow. It drops the `'resize'`
         // listener of I-8 and detaches the `/perf` provider so a later `/perf` in a
@@ -621,7 +835,12 @@ function runInteractive(flags, extras = {}) {
     })
         .catch(() => {
         screen?.restore();
-        disposeMouse();
+        // BEFORE `disposeStdinFilter()`, 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();
+        disposeStdinFilter();
         disposeFrameWriter();
         controller.dispose();
         updateService?.dispose();
@@ -737,6 +956,15 @@ 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',
+    // Listed here AND cased in the switch below, for the reason the note above
+    // `mouse` records: a key present here but absent there falls through every
+    // case, writes nothing, and still prints `Set paste = false`.
+    'paste',
+    'scrollResumeMs',
     'historyEnabled',
     'planModeDefault',
     'planModeMaxAskRounds',
@@ -763,6 +991,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 +1082,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 +1159,19 @@ function runConfigSet(key, value) {
         case 'mouse':
             patch.mouse = value === 'true' || value === '1';
             break;
+        case 'mouseSelect':
+            patch.mouseSelect = value === 'true' || value === '1';
+            break;
+        case 'paste':
+            patch.paste = 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 +1430,19 @@ 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')
+        // Positive form FIRST, same tri-state reason as `--mouse-select` above:
+        // `paste` is persisted and defaults to `true`, so a lone `--no-paste` would
+        // make commander default `opts.paste` to `true` -- indistinguishable from
+        // silence, and silently overriding a stored `false` on every run.
+        .option('--paste', 'Collapse large pastes into a placeholder (the default)')
+        .option('--no-paste', 'Treat pasted bytes as keystrokes (pre-0.6.3 behavior)')
         // Declaring `--fullscreen` BEFORE `--no-fullscreen` keeps the default
         // `undefined` instead of `true`, which is what makes the tri-state work:
         // "no opinion" must stay distinguishable from "force it".
@@ -1228,6 +1499,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)')