@aragon-agent/cli 0.6.2 → 0.6.4

package/dist/config/schema.d.ts

@@ -115,6 +115,36 @@ export declare const DEFAULT_DIFF_RENDER = true;
  * because the frame differ already removes the flicker on its own.
  */
 export declare const DEFAULT_SYNC_OUTPUT = true;
+/**
+ * Drag-select + copy, and — because §4.4.1 gates `\x1b[?1002h` on exactly this
+ * value — whether motion reporting is requested from the terminal at all.
+ *
+ * That gating is what makes `false` BYTE-IDENTICAL to a pre-feature session
+ * rather than merely equivalent (AC-8 / D-15). Ignored when `mouse` is false,
+ * since there is no capture to select with.
+ */
+export declare const DEFAULT_MOUSE_SELECT = true;
+/**
+ * Idle delay before a paused viewport returns to the newest line, in ms.
+ *
+ * Five seconds is chosen to be LONGER than a glance and SHORTER than a read.
+ * `0` disables auto-resume entirely, and it is a real value rather than a
+ * sentinel-shaped default: `shouldArmResume` refuses on it before any timer is
+ * created (AC-9), so the revert for Rule B is one config key.
+ *
+ * NO CLI FLAG (§6.1). It is a comfort preference, set once
+ * (`aragon config set scrollResumeMs 8000`) and then forgotten — the same
+ * argument this file already makes for `historyEnabled`. Adding a flag for every
+ * scalar is how a CLI ends up with sixty of them.
+ */
+export declare const DEFAULT_SCROLL_RESUME_MS = 5000;
+/**
+ * `clampIntAllowingZero`, and the choice is load-bearing: `clampInt` delegates to
+ * `coercePositiveInt`, which returns the FALLBACK for `n <= 0` — so `0` would
+ * silently become 5000 and the documented off switch would not be an off switch.
+ * Exactly the trap `retry.maxRetries` needed this helper for.
+ */
+export declare function clampScrollResumeMs(v: unknown, fallback: number): number;
 /** `ask_user` calls allowed per user turn. */
 export declare const DEFAULT_PLAN_MAX_ASK_ROUNDS = 4;
 /**
@@ -489,6 +519,136 @@ export declare const DEFAULT_UPDATE_CONFIG: UpdateConfig;
  * cannot see it reading.
  */
 export declare function clampUpdateConfig(raw: unknown): UpdateConfig;
+export type CompactionFailureMode = 'truncate' | 'stop';
+export interface CompactionConfig {
+    /**
+     * Whether a `ContextManager` is constructed at all. Default TRUE.
+     *
+     * THE ONLY KEY IN THIS SECTION THAT DEFAULTS ON, AND THE ONLY ONE READ ONCE AT
+     * CONSTRUCTION — the `team.enabled` / `todo.enabled` / `fast.enabled` rule.
+     *
+     * IT DEFAULTS TO `true` UNLIKE EVERY OTHER OPTIONAL SUBSYSTEM HERE, and that is
+     * deliberate (D-16): `fast.enabled` and `team.enabled` default off because they
+     * ADD behaviour the user did not ask for. This one REMOVES a failure the user
+     * did not ask for — without it, the answer to a full context window is a dead
+     * run. Byte-identity is still honoured: `--no-compaction` constructs no
+     * manager, subscribes nothing, allocates no registry, and leaves the engine
+     * loop with `ctx.contextManager === undefined`.
+     */
+    enabled: boolean;
+    /** Occupancy ratio that triggers compaction. Read LIVE. */
+    threshold: number;
+    /**
+     * Where the status-bar gauge turns amber.
+     *
+     * CLAMPED JOINTLY WITH `threshold`, AND THE ORDER IS FIXED — see
+     * `clampCompactionConfig`. "Jointly" is not an instruction.
+     */
+    warnThreshold: number;
+    /** Complete turns kept verbatim in the tail. Read LIVE. */
+    keepRecentTurns: number;
+    /**
+     * Summarize with the fast tier when it resolves. Default TRUE.
+     *
+     * A PREFERENCE, NOT THE COMMON PATH (P2-8). `resolveFastTier` returns
+     * `{ok:false, reason:'disabled'}` on `fast.enabled !== true` alone, and
+     * `fast.enabled` defaults to `false` — so out of the box the summarizer is the
+     * SESSION'S OWN MODEL, and the first compaction is a ~30 k-token call on it.
+     */
+    useFastTier: boolean;
+    /** What happens when summarization fails outright. See §3.7 rungs 3 / 4. */
+    onFailure: CompactionFailureMode;
+    /**
+     * Give `task` children their own compaction
+     * (context-auto-compaction-hardening §3.4 / W3). Default TRUE.
+     *
+     * IT REVERSES D-15, WHOSE PREMISE IS MEASURABLY FALSE at the configured bounds:
+     * `team.maxTurnsPerSubagent` is 24 and `team.dispatchTimeoutMs` is 900 000, and
+     * 24 turns over fifteen minutes is the same profile as the lead run this
+     * feature exists for. When a child overflows today its history is discarded and
+     * the lead receives one partial sentence for the whole dispatch.
+     *
+     * `false` REPRODUCES ROUND 1 EXACTLY: `subagent.ts` spreads no `contextManager`
+     * key at all, so the child's loop gate tests an absent field.
+     */
+    subagents: boolean;
+    /**
+     * Write the dropped messages to `<home>/compaction/` before adopting a splice
+     * (context-auto-compaction-hardening §3.5 / W4). Default TRUE.
+     *
+     * NOT UNDO (§12): restoring an over-full history restores the condition that
+     * triggered the compaction. This is fidelity on disk, so "the summary is wrong
+     * and the agent proceeded on a false record" becomes something a human can
+     * check rather than something they must accept.
+     */
+    archive: boolean;
+}
+export declare const DEFAULT_COMPACTION_CONFIG: CompactionConfig;
+/**
+ * THE single gate for every compaction-config read AND write, mirroring the six
+ * clamps above for the reason all of them record: hardening only the read path
+ * leaves a bad value on disk that reverts to the default on every launch, which
+ * presents to the user as "my setting won't stick".
+ *
+ * THE ORDER IS FIXED AND IT MATTERS (§4.2 / P2-5). `threshold` is clamped to
+ * `[0.5, 0.95]` FIRST, then `warnThreshold` to
+ * `[0.4, clampedThreshold - 0.05]`. The other order lets a file holding
+ * `{threshold: 0.6, warnThreshold: 0.9}` produce a warn mark ABOVE the trigger —
+ * a gauge that turns amber after it has already gone red. Both bounds of the
+ * second range stay reachable at the extremes: `threshold` floored at `0.5`
+ * gives `warnThreshold` a range of `[0.4, 0.45]`.
+ */
+export declare function clampCompactionConfig(raw: unknown): CompactionConfig;
+export interface BashConfig {
+    /**
+     * Register `bash_output` / `bash_kill`, honour `background`, splice the prompt
+     * block, render the chip. Default TRUE.
+     *
+     * READ ONCE AT CONSTRUCTION, the `team.enabled` / `todo.enabled` /
+     * `fast.enabled` rule.
+     *
+     * IT GOVERNS *SERVICES*, NEVER *INTERRUPTIBILITY* (I-2 / D-9). `Esc`/`Esc`,
+     * the foreground child registry and `forceStop()` are unconditional, because
+     * "bash always settles" and "Esc twice always works" are promised
+     * unconditionally — a user who turned background services off has not asked
+     * for a less interruptible agent.
+     */
+    background: boolean;
+    /**
+     * Let the classifier decide when the model did not say. Default TRUE.
+     *
+     * RESOLVES TO `false` WITHOUT AN INTERACTIVE VIEW (D-15 / P1-8), and that is
+     * decided at the tool layer rather than here: the value on disk is the user's
+     * preference, and headless has no card, no `/bg` and no user to keep a service
+     * alive, so the rescue would be a surprise instead. An explicit
+     * `background: true` is still honoured there — that one the model asked for.
+     */
+    autoBackground: boolean;
+    /** How long a background launch may block the turn before returning. */
+    startupSettleMs: number;
+    /** How long a service may stay `starting` before it is called `running`. */
+    readyTimeoutMs: number;
+}
+export declare const DEFAULT_BASH_CONFIG: BashConfig;
+/**
+ * THE single gate for every bash-config read AND write, mirroring
+ * `clampSkillsConfig` / `clampLogConfig` / `clampTeamConfig` / `clampTodoConfig`
+ * for the reason those record: hardening only the read path leaves a bad value
+ * on disk that reverts to the default on every launch, which presents to the
+ * user as "my setting won't stick".
+ *
+ * CLAMPED, NEVER REJECTED — the discipline every other key in this file follows.
+ * A garbage `startupSettleMs` resolves to 4000 and throws nothing.
+ */
+export declare function clampBashConfig(raw: unknown): BashConfig;
+/**
+ * Parse `0.9`, `90%` or `90` into a ratio, or `null` when it is neither.
+ *
+ * `null` RATHER THAN A CLAMPED DEFAULT, because this is a COMMAND argument and
+ * not a config value: `/compact threshold banana` must say so rather than
+ * silently setting 0.9 and reporting success.
+ */
+export declare function parseThresholdInput(raw: string): number | null;
 export interface PersistedConfig {
     version: number;
     provider: string;
@@ -578,6 +738,24 @@ export interface PersistedConfig {
      * heuristics for an explicit `true` to override (D-10).
      */
     mouse: boolean;
+    /**
+     * Drag-select + copy in full-screen mode (tui-selection-and-scroll-follow
+     * §6.1). Ignored when `mouse` is false; also decides whether `?1002h` is
+     * written at all, so `false` is byte-identical to a pre-feature session.
+     */
+    mouseSelect: boolean;
+    /**
+     * Recognise pasted text and collapse a large paste into a placeholder
+     * (tui-paste-handling D-10 / section 7.3).
+     *
+     * A PLAIN BOOLEAN and the ONLY user-facing key this feature adds: the collapse
+     * threshold and every size bound are structural and live in `input/limits.ts`
+     * / `ui/composer-limits.ts`. A tunable threshold is a preference nobody has
+     * asked for; a kill switch is what a bug report needs.
+     */
+    paste: boolean;
+    /** Idle ms before a paused viewport returns to the newest line; `0` disables. */
+    scrollResumeMs: number;
     /** Start every session in PLAN mode (plan-mode §4.4). */
     planModeDefault: boolean;
     /** `ask_user` rounds allowed per user turn; clamped to [1, 10]. */
@@ -598,6 +776,10 @@ export interface PersistedConfig {
     fast: FastConfig;
     /** Auto-update. The EIGHTH nested object; scalars only (see UpdateConfig). */
     update: UpdateConfig;
+    /** Context compaction. The NINTH nested object; scalars only (see CompactionConfig). */
+    compaction: CompactionConfig;
+    /** Background services. The TENTH nested object; scalars only (see BashConfig). */
+    bash: BashConfig;
 }
 export declare const DEFAULT_CONFIG: PersistedConfig;
 /**
@@ -727,6 +909,30 @@ export interface CliConfig {
      * only). Resolved by `resolveMouse` in `load.ts`.
      */
     mouse: boolean;
+    /**
+     * Whether this session may drag-select and copy.
+     *
+     * IT MUST EXIST HERE AND NOT ONLY IN `PersistedConfig`, for the reason
+     * `diffRender` above records at length: `runInteractive` reads
+     * `config.mouseSelect` — where `config` is a `CliConfig` — to decide the
+     * `?1002h` write, the controller and the `decorate` hook. A key added to the
+     * persisted shape alone would round-trip through `config set`, appear in
+     * `config list`, and never reach a single one of them.
+     */
+    mouseSelect: boolean;
+    /**
+     * Whether this session recognises pastes at all.
+     *
+     * IT MUST EXIST HERE AND NOT ONLY IN `PersistedConfig`, for the reason
+     * `mouseSelect` above records: `runInteractive` reads `config.paste` -- where
+     * `config` is a `CliConfig` -- to decide the filter's `paste` feature, the
+     * `?2004h` write and the `PasteBridge`. A key added to the persisted shape
+     * alone would round-trip through `config set`, appear in `config list`, and
+     * reach none of them.
+     */
+    paste: boolean;
+    /** Idle ms before a paused viewport returns to the newest line; `0` disables. */
+    scrollResumeMs: number;
     /**
      * Whether this session opens in PLAN mode.
      *
@@ -800,6 +1006,44 @@ export interface CliConfig {
      * and be discarded, with no compile error and no runtime error.
      */
     update: UpdateConfig;
+    /**
+     * Resolved context-compaction settings (context-auto-compaction §4.2).
+     *
+     * `enabled` here decides whether `AgentController` CONSTRUCTS a
+     * `CompactionWiring` at all, which is what makes `false` byte-identical to a
+     * pre-feature build: no manager is passed to `new Agent({...})`, nothing is
+     * subscribed, no registry is allocated, and the loop's checkpoint is one `if`
+     * against an absent field. The other five keys are read LIVE on every use, so
+     * `/compact threshold 0.8` takes effect in the running session.
+     *
+     * IT MUST EXIST HERE AND NOT ONLY IN `PersistedConfig`, for the reason
+     * `showThinking`, `liveToolOutput`, `diffRender`, `mouseSelect` and `update`
+     * each record above: the controller and the compactor read `config.compaction`,
+     * where `config` is a `CliConfig`, so a key added to the persisted shape alone
+     * would round-trip through `config set`, appear in `config list` — and never
+     * reach either of them.
+     */
+    compaction: CompactionConfig;
+    /**
+     * Resolved background-service settings (background-service-supervision §5.4).
+     *
+     * `background` here decides whether `bash`'s schema carries a `background`
+     * property, whether `bash_output` / `bash_kill` are REGISTERED and whether
+     * `<background_services>` is spliced — all three at construction, and none of
+     * them undoable, the `team.enabled` / `todo.enabled` / `fast.enabled` rule.
+     * The other three keys are read LIVE.
+     *
+     * IT DOES NOT GATE THE INTERRUPT LADDER (I-2 / D-9). `ProcSupervisor` is
+     * constructed unconditionally, because `Esc`/`Esc` and the foreground registry
+     * are what make G2 and G3 true and those are promised whatever this says.
+     *
+     * IT MUST EXIST HERE AND NOT ONLY IN `PersistedConfig`, for the reason every
+     * section above records: the controller and `bash` read `config.bash`, where
+     * `config` is a `CliConfig`, so a key added to the persisted shape alone would
+     * round-trip through `config set`, appear in `config list` — and never reach
+     * either of them.
+     */
+    bash: BashConfig;
     /**
      * Lifetime submit count driving the composer hint fade (`HINT_FADE_AFTER`).
      *

package/dist/config/schema.js

@@ -169,6 +169,42 @@ export const DEFAULT_DIFF_RENDER = true;
  */
 export const DEFAULT_SYNC_OUTPUT = true;
 // ---------------------------------------------------------------------------
+// Selection + scroll follow (tui-selection-and-scroll-follow §6.1)
+// ---------------------------------------------------------------------------
+/**
+ * Drag-select + copy, and — because §4.4.1 gates `\x1b[?1002h` on exactly this
+ * value — whether motion reporting is requested from the terminal at all.
+ *
+ * That gating is what makes `false` BYTE-IDENTICAL to a pre-feature session
+ * rather than merely equivalent (AC-8 / D-15). Ignored when `mouse` is false,
+ * since there is no capture to select with.
+ */
+export const DEFAULT_MOUSE_SELECT = true;
+/**
+ * Idle delay before a paused viewport returns to the newest line, in ms.
+ *
+ * Five seconds is chosen to be LONGER than a glance and SHORTER than a read.
+ * `0` disables auto-resume entirely, and it is a real value rather than a
+ * sentinel-shaped default: `shouldArmResume` refuses on it before any timer is
+ * created (AC-9), so the revert for Rule B is one config key.
+ *
+ * NO CLI FLAG (§6.1). It is a comfort preference, set once
+ * (`aragon config set scrollResumeMs 8000`) and then forgotten — the same
+ * argument this file already makes for `historyEnabled`. Adding a flag for every
+ * scalar is how a CLI ends up with sixty of them.
+ */
+export const DEFAULT_SCROLL_RESUME_MS = 5000;
+const SCROLL_RESUME_RANGE = { min: 0, max: 120_000 };
+/**
+ * `clampIntAllowingZero`, and the choice is load-bearing: `clampInt` delegates to
+ * `coercePositiveInt`, which returns the FALLBACK for `n <= 0` — so `0` would
+ * silently become 5000 and the documented off switch would not be an off switch.
+ * Exactly the trap `retry.maxRetries` needed this helper for.
+ */
+export function clampScrollResumeMs(v, fallback) {
+    return clampIntAllowingZero(v, fallback, SCROLL_RESUME_RANGE);
+}
+// ---------------------------------------------------------------------------
 // Plan mode (plan-mode §4.4)
 //
 // THREE FLAT KEYS, not a nested `planMode` object. `store.ts` documents that its
@@ -669,6 +705,126 @@ function isRegistryUrl(raw) {
         return false;
     }
 }
+export const DEFAULT_COMPACTION_CONFIG = {
+    enabled: true,
+    threshold: 0.9,
+    warnThreshold: 0.75,
+    keepRecentTurns: 4,
+    useFastTier: true,
+    onFailure: 'truncate',
+    subagents: true,
+    archive: true,
+};
+const THRESHOLD_RANGE = { min: 0.5, max: 0.95 };
+const WARN_THRESHOLD_FLOOR = 0.4;
+/** The gap the warn mark must stay below the trigger by. */
+const WARN_THRESHOLD_GAP = 0.05;
+const KEEP_RECENT_TURNS_RANGE = { min: 1, max: 20 };
+const COMPACTION_FAILURE_MODES = ['truncate', 'stop'];
+/**
+ * Round a ratio to two decimals — the precision a percentage actually has.
+ *
+ * BINARY FLOATING POINT MAKES `0.95 - 0.05` EQUAL `0.8999999999999999`, and both
+ * numbers here are produced by subtraction (`threshold - WARN_THRESHOLD_GAP`) and
+ * by division (`parseThresholdInput` turning `90` into `90/100`). Without this,
+ * `aragon config list` shows a seventeen-digit value for a setting the user typed
+ * as `90%`, and `config.json` records one — which looks like corruption and
+ * invites a hand-edit that the clamp then has to defend against.
+ *
+ * Two decimals is exact for every value the range can hold: the clamp is
+ * `[0.5, 0.95]` and the UI reads it as a whole percentage.
+ */
+function ratio(value) {
+    return Math.round(value * 100) / 100;
+}
+function failureMode(value, fallback) {
+    return typeof value === 'string' && COMPACTION_FAILURE_MODES.includes(value)
+        ? value
+        : fallback;
+}
+/**
+ * THE single gate for every compaction-config read AND write, mirroring the six
+ * clamps above for the reason all of them record: hardening only the read path
+ * leaves a bad value on disk that reverts to the default on every launch, which
+ * presents to the user as "my setting won't stick".
+ *
+ * THE ORDER IS FIXED AND IT MATTERS (§4.2 / P2-5). `threshold` is clamped to
+ * `[0.5, 0.95]` FIRST, then `warnThreshold` to
+ * `[0.4, clampedThreshold - 0.05]`. The other order lets a file holding
+ * `{threshold: 0.6, warnThreshold: 0.9}` produce a warn mark ABOVE the trigger —
+ * a gauge that turns amber after it has already gone red. Both bounds of the
+ * second range stay reachable at the extremes: `threshold` floored at `0.5`
+ * gives `warnThreshold` a range of `[0.4, 0.45]`.
+ */
+export function clampCompactionConfig(raw) {
+    const src = (raw && typeof raw === 'object' ? raw : {});
+    const threshold = ratio(clampNumber(src.threshold, DEFAULT_COMPACTION_CONFIG.threshold, THRESHOLD_RANGE));
+    const warnCeiling = ratio(threshold - WARN_THRESHOLD_GAP);
+    return {
+        enabled: bool(src.enabled, DEFAULT_COMPACTION_CONFIG.enabled),
+        threshold,
+        warnThreshold: ratio(clampNumber(src.warnThreshold, DEFAULT_COMPACTION_CONFIG.warnThreshold, {
+            min: Math.min(WARN_THRESHOLD_FLOOR, warnCeiling),
+            max: warnCeiling,
+        })),
+        keepRecentTurns: clampInt(src.keepRecentTurns, DEFAULT_COMPACTION_CONFIG.keepRecentTurns, KEEP_RECENT_TURNS_RANGE),
+        useFastTier: bool(src.useFastTier, DEFAULT_COMPACTION_CONFIG.useFastTier),
+        // CLAMPED TO THE DEFAULT, NEVER REJECTED — the discipline every other key in
+        // this file follows. `ARAGON_COMPACTION_ON_FAILURE=garbage` resolves to
+        // `truncate` and throws nothing.
+        onFailure: failureMode(src.onFailure, DEFAULT_COMPACTION_CONFIG.onFailure),
+        subagents: bool(src.subagents, DEFAULT_COMPACTION_CONFIG.subagents),
+        archive: bool(src.archive, DEFAULT_COMPACTION_CONFIG.archive),
+    };
+}
+export const DEFAULT_BASH_CONFIG = {
+    background: true,
+    autoBackground: true,
+    startupSettleMs: 4000,
+    readyTimeoutMs: 60_000,
+};
+const STARTUP_SETTLE_RANGE = { min: 500, max: 30_000 };
+const READY_TIMEOUT_RANGE = { min: 5_000, max: 600_000 };
+/**
+ * THE single gate for every bash-config read AND write, mirroring
+ * `clampSkillsConfig` / `clampLogConfig` / `clampTeamConfig` / `clampTodoConfig`
+ * for the reason those record: hardening only the read path leaves a bad value
+ * on disk that reverts to the default on every launch, which presents to the
+ * user as "my setting won't stick".
+ *
+ * CLAMPED, NEVER REJECTED — the discipline every other key in this file follows.
+ * A garbage `startupSettleMs` resolves to 4000 and throws nothing.
+ */
+export function clampBashConfig(raw) {
+    const src = (raw && typeof raw === 'object' ? raw : {});
+    return {
+        background: bool(src.background, DEFAULT_BASH_CONFIG.background),
+        autoBackground: bool(src.autoBackground, DEFAULT_BASH_CONFIG.autoBackground),
+        startupSettleMs: clampInt(src.startupSettleMs, DEFAULT_BASH_CONFIG.startupSettleMs, STARTUP_SETTLE_RANGE),
+        readyTimeoutMs: clampInt(src.readyTimeoutMs, DEFAULT_BASH_CONFIG.readyTimeoutMs, READY_TIMEOUT_RANGE),
+    };
+}
+/**
+ * Parse `0.9`, `90%` or `90` into a ratio, or `null` when it is neither.
+ *
+ * `null` RATHER THAN A CLAMPED DEFAULT, because this is a COMMAND argument and
+ * not a config value: `/compact threshold banana` must say so rather than
+ * silently setting 0.9 and reporting success.
+ */
+export function parseThresholdInput(raw) {
+    const trimmed = raw.trim().replace(/%$/, '');
+    if (trimmed.length === 0)
+        return null;
+    const n = Number.parseFloat(trimmed);
+    if (!Number.isFinite(n))
+        return null;
+    // `90` means 90 %, `0.9` means 0.9. The ambiguity is only at `1`, which is
+    // above the clamp ceiling either way.
+    const ratio = n > 1 ? n / 100 : n;
+    if (ratio <= 0 || ratio > 1)
+        return null;
+    return ratio;
+}
 export const DEFAULT_CONFIG = {
     version: CONFIG_VERSION,
     provider: 'anthropic',
@@ -703,6 +859,9 @@ export const DEFAULT_CONFIG = {
     density: 'comfortable',
     hints: true,
     mouse: true,
+    mouseSelect: DEFAULT_MOUSE_SELECT,
+    paste: true,
+    scrollResumeMs: DEFAULT_SCROLL_RESUME_MS,
     planModeDefault: false,
     planModeMaxAskRounds: DEFAULT_PLAN_MAX_ASK_ROUNDS,
     planModeHumanTimeoutMs: DEFAULT_PLAN_HUMAN_TIMEOUT_MS,
@@ -728,6 +887,17 @@ export const DEFAULT_CONFIG = {
     // (`cfg.update.mode !== 'off'`) would read TRUE and the feature would be on
     // for a reason nobody could point at.
     update: DEFAULT_UPDATE_CONFIG,
+    // And one section later again, for the fourth time. Without this line a user
+    // whose `config.json` predates compaction resolves `config.compaction.enabled`
+    // to `undefined`, which is FALSY — so a feature that is `true` by default would
+    // arrive OFF for every existing user, which is the one direction this
+    // particular default must never fail in.
+    compaction: DEFAULT_COMPACTION_CONFIG,
+    // And one section later again, for the fifth time. `bash.background` is `true`
+    // by default, so a `config.json` predating this feature resolving it to
+    // `undefined` would arrive with background services OFF for every existing
+    // user — the same direction the compaction line above must never fail in.
+    bash: DEFAULT_BASH_CONFIG,
 };
 /**
  * Runtime state that used to be stored in `config.json` by mistake

package/dist/config/store.js

@@ -14,7 +14,7 @@ import { dirname } from 'node:path';
 import process from 'node:process';
 import { getConfigPath, getSessionsDir } from './app-paths.js';
 import { registerSecretsFrom } from '../logging/secret-registry.js';
-import { CONFIG_VERSION, DEFAULT_CONFIG, clampFastConfig, clampLogConfig, clampMaxTokens, clampRetryConfig, clampSkillsConfig, clampTeamConfig, clampTodoConfig, clampUpdateConfig, isAutoToken, stripLegacyStateKeys, } from './schema.js';
+import { clampBashConfig, CONFIG_VERSION, DEFAULT_CONFIG, clampCompactionConfig, clampFastConfig, clampLogConfig, clampMaxTokens, clampRetryConfig, clampSkillsConfig, clampTeamConfig, clampTodoConfig, clampUpdateConfig, isAutoToken, stripLegacyStateKeys, } from './schema.js';
 /**
  * Normalize `maxTokens` for both directions of the config file.
  *
@@ -139,6 +139,29 @@ export function loadPersistedConfig() {
         // predates auto-update, which is all of them. Without it `config.update.mode`
         // reads `undefined`, and the §3.8 gate tests `!== 'off'`.
         update: clampUpdateConfig({ ...DEFAULT_CONFIG.update, ...(partial.update ?? {}) }),
+        // `compaction` is the ninth. Same one-level rule, same merge — and the READ
+        // half supplies a whole section to every user whose `config.json` predates
+        // this feature, which is all of them. Without it `config.compaction.enabled`
+        // reads `undefined`, which is FALSY, so a feature that is `true` by default
+        // would arrive off for every existing user.
+        compaction: clampCompactionConfig({
+            ...DEFAULT_CONFIG.compaction,
+            ...(partial.compaction ?? {}),
+        }),
+        // `bash` is the tenth. Same one-level rule, same merge — and the READ half
+        // supplies a whole section to every user whose `config.json` predates
+        // background services, which is all of them. Without it
+        // `config.bash.background` reads `undefined`, which is FALSY, so a feature
+        // that is `true` by default would arrive off for every existing user.
+        //
+        // A SIBLING OF `compaction`, NOT A KEY INSIDE ITS ARGUMENT. Nesting it one
+        // level too deep type-checks — `...DEFAULT_CONFIG` above already supplies a
+        // `bash`, so nothing is missing from the return type — and hands
+        // `clampCompactionConfig` a key it drops on the floor. The section then
+        // reaches callers straight off the shallow `...partial` spread: unclamped,
+        // and NOT merged over the defaults, which is verbatim the failure the
+        // paragraph above says this line prevents.
+        bash: clampBashConfig({ ...DEFAULT_CONFIG.bash, ...(partial.bash ?? {}) }),
     };
 }
 /**
@@ -208,6 +231,19 @@ export function updatePersistedConfig(patch) {
         // enterprise mirror the user configured last month is gone with no error
         // anywhere. AC-20 is the assertion that proves both halves exist.
         update: clampUpdateConfig({ ...current.update, ...(patch.update ?? {}) }),
+        // The ninth section, and the fourth time this file records the same trap.
+        // `/compact threshold 0.8` sends `{ compaction: { threshold: 0.8 } }`;
+        // without this line the shallow top-level spread REPLACES the section,
+        // `enabled` is written absent, and a user who deliberately turned compaction
+        // OFF finds it back on tomorrow — a feature that spends money on their behalf
+        // re-enabling itself because they nudged a threshold.
+        compaction: clampCompactionConfig({ ...current.compaction, ...(patch.compaction ?? {}) }),
+        // The tenth section, and the fifth time this file records the same trap.
+        // A patch carrying only `{ bash: { autoBackground: false } }` — turning the
+        // CLASSIFIER off — would, without this line, be spread shallowly over the
+        // top level and write `background` absent, silently unregistering
+        // `bash_output` / `bash_kill` from the next launch onward.
+        bash: clampBashConfig({ ...current.bash, ...(patch.bash ?? {}) }),
     };
     writeConfigFile(merged);
     return merged;

package/dist/config/ui-state.d.ts

@@ -32,8 +32,32 @@ export interface UiState {
     schema: number;
     /** Lifetime submit count; drives the composer hint fade (`HINT_FADE_AFTER`). */
     submitCount: number;
-    /** Whether the one-shot "hold Shift to select text" notice has been shown. */
+    /**
+     * Whether the one-shot "hold Shift to select text" notice has been shown.
+     *
+     * DELIBERATELY NOT READ BY THE LIVE GATE ANY MORE (tui-selection-and-scroll-
+     * follow P1-8). It is kept in the shape so `importLegacyUiState` still has
+     * somewhere to put a migrated value and so a file written by 0.6.2 round-trips
+     * unchanged; `mouseNoticeVersion` below is what the notice now consults.
+     */
     mouseNoticeSeen: boolean;
+    /**
+     * Which revision of the mouse notice this user has already been shown
+     * (`0` = none).
+     *
+     * A VERSION BESIDE THE BOOLEAN, NOT A BUMPED SCHEMA, and this is the second
+     * time this file has had to say so. The audience for the CORRECTED text — "drag
+     * to select, releasing copies" — is exactly the set of users who already have
+     * `mouseNoticeSeen: true` on disk from the old "hold Shift" text, so a boolean
+     * can only say "shown", never "shown WHAT". And bumping `UI_STATE_SCHEMA`, the
+     * nearest thing to "bump the key", makes `readFromDisk` discard the WHOLE
+     * object: every user's `submitCount` resets and the composer hint un-fades for
+     * all of them, to re-show one notice.
+     *
+     * `vtInputNoticeVersion` below is the precedent, written about this exact
+     * situation one feature earlier.
+     */
+    mouseNoticeVersion: number;
     /**
      * Which revision of the "this Windows console cannot deliver Shift+Tab or the
      * wheel" notice this user has already been shown (`0` = none).
@@ -69,6 +93,9 @@ export declare function bumpSubmitCount(): number;
 export declare function getMouseNoticeSeen(): boolean;
 export declare function setMouseNoticeSeen(seen: boolean): void;
 /** `0` on a file written before the field existed — see the field's comment. */
+export declare function getMouseNoticeVersion(): number;
+export declare function setMouseNoticeVersion(version: number): void;
+/** `0` on a file written before the field existed — see the field's comment. */
 export declare function getVtInputNoticeVersion(): number;
 export declare function setVtInputNoticeVersion(version: number): void;
 /**

package/dist/config/ui-state.js

@@ -35,6 +35,7 @@ const DEFAULT_UI_STATE = {
     schema: UI_STATE_SCHEMA,
     submitCount: 0,
     mouseNoticeSeen: false,
+    mouseNoticeVersion: 0,
     vtInputNoticeVersion: 0,
 };
 let memory = null;
@@ -66,6 +67,7 @@ function readFromDisk() {
             mouseNoticeSeen: typeof parsed.mouseNoticeSeen === 'boolean'
                 ? parsed.mouseNoticeSeen
                 : DEFAULT_UI_STATE.mouseNoticeSeen,
+            mouseNoticeVersion: coerceCount(parsed.mouseNoticeVersion, DEFAULT_UI_STATE.mouseNoticeVersion),
             vtInputNoticeVersion: coerceCount(parsed.vtInputNoticeVersion, DEFAULT_UI_STATE.vtInputNoticeVersion),
         };
     }
@@ -127,6 +129,13 @@ export function setMouseNoticeSeen(seen) {
     update({ mouseNoticeSeen: seen });
 }
 /** `0` on a file written before the field existed — see the field's comment. */
+export function getMouseNoticeVersion() {
+    return loadUiState().mouseNoticeVersion;
+}
+export function setMouseNoticeVersion(version) {
+    update({ mouseNoticeVersion: version });
+}
+/** `0` on a file written before the field existed — see the field's comment. */
 export function getVtInputNoticeVersion() {
     return loadUiState().vtInputNoticeVersion;
 }