@aragon-agent/cli 0.6.3 → 0.6.7

package/dist/compaction/wiring.js

@@ -25,12 +25,22 @@
  * methods delegate to a compactor that reads config LIVE - which is what lets
  * `/compact off`, `/compact threshold 0.8` and a settings-screen save take effect
  * mid-session without touching the `Agent`.
+ *
+ * DECLINED COMPACTIONS PRODUCE NO CLI EVENTS (quiet-noop §3.6). A `pressure`
+ * compaction that changed nothing, called nothing and spent nothing never emits
+ * `compaction_start`, so `onCompactorEvent` never opens a card and `settlePending`
+ * finds neither a held record nor a skeleton to synthesize. CORE still emits its
+ * own pair for every attempt, which is why `settlePending` still runs - it just
+ * refreshes the snapshot and returns. `onCompactorEvent`'s `if (!this.open)`
+ * guard is now unreachable for declines and stays for the abort race it was
+ * written for.
  */
 import { DEFAULT_RETRY_POLICY, estimatePromptTokens, initProviders, validateHistory, } from '@aragon-agent/core';
 import { getLogger } from '../logging/logger.js';
 import { mintRunId, writeArchive } from './archive.js';
 import { createChildContextManager } from './child.js';
 import { Compactor } from './compactor.js';
+import { ContextMeter } from './meter.js';
 /**
  * One retry, not ten and not zero - the `fast/wiring.ts` argument unchanged
  * (D-10).
@@ -59,6 +69,7 @@ export function offCompactionSnapshot() {
             headroom: 0,
             source: 'estimate',
             windowKnown: false,
+            windowOverridden: false,
             deltaTokens: 0,
         },
     };
@@ -68,6 +79,8 @@ export class CompactionWiring {
     log = getLogger().child('compaction');
     listeners = new Set();
     compactor;
+    /** The occupancy meter, injected or private (R-1). Forwarded to the compactor. */
+    meter;
     /** The compactor's OWN transport (D-10). Lazy - see `getRegistry()`. */
     registry = null;
     unsubscribe = null;
@@ -116,6 +129,15 @@ export class CompactionWiring {
     constructor(deps) {
         this.deps = deps;
         this.enabled = deps.getConfig().compaction.enabled;
+        this.meter =
+            deps.meter ??
+                new ContextMeter({
+                    getMessages: deps.getMessages,
+                    getSystemPrompt: deps.getSystemPrompt,
+                    getModelInfo: () => deps.getModelInfoFor(this.mainRef()),
+                    isWindowKnown: () => deps.isPricedModel(this.mainRef()),
+                    getWindowOverride: () => deps.getConfig().contextWindow,
+                });
         this.compactor = new Compactor({
             getConfig: deps.getConfig,
             hasKey: deps.hasKey,
@@ -130,6 +152,9 @@ export class CompactionWiring {
             complete: (providerId, request) => this.getRegistry().complete(providerId, request),
             emit: (event) => this.onCompactorEvent(event),
             notify: deps.notify,
+            // ONE METER PER PROCESS. The compactor must not build its own fallback
+            // here, or the trigger would read a different number from the gauge.
+            meter: this.meter,
             // ONE NUMBER ON SCREEN AND IN THE TRIGGER (R-11 / DH-15). The checkpoint
             // has already measured; publishing THAT pressure rather than re-measuring
             // is what keeps the two from disagreeing by one turn's tool results.
@@ -196,9 +221,23 @@ export class CompactionWiring {
      * `/clear`, `/resume`, and any future host-side rewrite. A recorded prefix
      * length indexes an array that no longer exists, so the delta must be
      * abandoned rather than applied to a different history.
+     *
+     * THE **DEEP** RESET (I-8). `/resume` can change the model in the same breath,
+     * so `estimateOffset` - a calibration for one toolset on one model - goes too.
+     * The SHALLOW reset is `settlePending`'s splice branch, and the two are not
+     * interchangeable: swapping them produces silent errors in OPPOSITE
+     * directions (a splice that drops the offset reads too low and climbs back; a
+     * resume that keeps it reads too high and never self-corrects).
+     *
+     * DUPLICATED BY `AgentController` ON PURPOSE. The controller calls
+     * `contextMeter.onHistoryReplaced()` directly at the same two sites, because
+     * this class does not exist at all when `compaction.enabled` is false - and
+     * that unconditional call is the only thing that keeps `/resume` re-measuring
+     * for such a session. A deep reset is idempotent, so both firing costs
+     * nothing; deleting the controller's copy "to de-duplicate" reintroduces P0-2.
      */
     onHistoryReplaced() {
-        this.compactor.invalidateMeasurement();
+        this.meter.onHistoryReplaced();
     }
     /**
      * The per-child manager factory, or `null` when children get none
@@ -305,13 +344,19 @@ export class CompactionWiring {
     // -----------------------------------------------------------------------
     // Status and events
     // -----------------------------------------------------------------------
+    /**
+     * The status a reader gets right now.
+     *
+     * IT READS `meter.current()`, WHICH RE-MEASURES WHEN DIRTY - and that is the
+     * fix for P0-1 (§3.3). This method is called one statement after
+     * `settlePending` marks the meter spliced, so the `snapshot` event emitted
+     * immediately after `compaction_end` carries the POST-compaction occupancy.
+     * The old body preferred `compactor.lastMeasured()`, i.e. the measurement that
+     * TRIGGERED this compaction, so the gauge fell and was bounced straight back
+     * to the pre-compaction figure inside the same synchronous emit loop.
+     */
     snapshot() {
-        const pressure = this.compactor.lastMeasured() ??
-            this.compactor.measure({
-                messages: this.deps.getMessages(),
-                systemPrompt: this.deps.getSystemPrompt(),
-            });
-        return this.snapshotWith(pressure);
+        return this.snapshotWith(this.meter.current());
     }
     /**
      * `snapshot()` with the pressure argument substituted for the re-measurement.
@@ -328,6 +373,10 @@ export class CompactionWiring {
             live: this.enabled && summarizer !== null,
             model: summarizer?.ref.modelId ?? '',
             compactions: totals.compactions,
+            // OMITTED WHEN ZERO (quiet-noop D-9), so a healthy session's snapshot is
+            // shaped exactly as it was before this feature and `/compact status` has
+            // nothing extra to render.
+            ...(totals.declined > 0 ? { declined: totals.declined } : {}),
             tokensReclaimed: totals.tokensReclaimed,
             usage: totals.usage,
             pricingUnknown: totals.pricingUnknown,
@@ -349,6 +398,17 @@ export class CompactionWiring {
     // -----------------------------------------------------------------------
     // Internals
     // -----------------------------------------------------------------------
+    /**
+     * The main model, for the FALLBACK meter's deps only (R-1).
+     *
+     * Production injects a meter built by `AgentController`, which resolves the
+     * same ref from the same live config; this exists so a test that constructs a
+     * bare wiring still gets a working denominator.
+     */
+    mainRef() {
+        const config = this.deps.getConfig();
+        return { providerId: config.provider, modelId: config.model };
+    }
     /**
      * The transport one summarization call goes through - separate from the lead's,
      * and fail-fast (D-10).
@@ -395,19 +455,16 @@ export class CompactionWiring {
             return;
         }
         if (event.type === 'turn_end') {
-            // The calibration offset, re-measured every turn (D-23). Read the history
-            // AFTER the turn's assistant message is pushed? No: `turn_end` is emitted
-            // BEFORE the push, so this is exactly the history the reported `usage`
-            // was measured against, which is what makes the difference meaningful.
-            this.compactor.onTurnEnd(event.usage, this.deps.getMessages(), this.deps.getSystemPrompt());
-            // The gauge and the trigger read one function (R-11 / AC-3), so the
-            // snapshot's pressure is refreshed from the same measurement the status bar
-            // is about to render.
-            this.compactor.measure({
-                lastUsage: event.usage,
-                messages: this.deps.getMessages(),
-                systemPrompt: this.deps.getSystemPrompt(),
-            });
+            // THE MEASUREMENT IS THE METER'S (context-usage-gauge-accuracy §3.3.4). It
+            // subscribes to `turn_end` on the same stream and recomputes the offset,
+            // the prefix length and the pressure there; the two calls that used to
+            // live here - `compactor.onTurnEnd(...)` and `compactor.measure(...)` -
+            // were both forwarders to it and doing the same work twice.
+            //
+            // THE SNAPSHOT EMIT STAYS. The other fields on it - `inFlight`, the
+            // session counts, the summarizer - are this class's own and still need
+            // refreshing on a turn boundary, and `snapshot()` picks up the meter's
+            // freshly published pressure for free.
             this.emit({ type: 'snapshot', snapshot: this.snapshot() });
             return;
         }
@@ -445,8 +502,20 @@ export class CompactionWiring {
         // compaction no matter which branch the verdict took - including the early
         // `return` below.
         const dropped = this.compactor.takeLastDropped();
-        if (!record)
+        if (!record) {
+            // A SILENT DECLINE (quiet-noop §3.6). No card - but the gauge and the chip
+            // are still refreshed: `inFlight` has just gone false and `/compact status`
+            // reads this same snapshot, which is where the `declined` count surfaces.
+            //
+            // `snapshot()` NOW GOES THROUGH `meter.current()`, so this path DOES pay a
+            // re-measurement when the history has moved since the last one (RV-11 -
+            // the previous sentence here claimed the opposite and was left stale by
+            // context-usage-gauge-accuracy). The cost is bounded the same way it always
+            // was: guard 4 caps declines per session at `stuckLimit`, and a re-measure
+            // on the measured branch walks one turn's worth of appended messages.
+            this.emit({ type: 'snapshot', snapshot: this.snapshot() });
             return;
+        }
         const settled = {
             ...record,
             applied: verdict.applied,
@@ -457,10 +526,23 @@ export class CompactionWiring {
         };
         if (verdict.applied) {
             this.compactor.recordApplied(settled.tokensBefore, settled.tokensAfter);
-            // SITE 1 OF THE FOUR INVALIDATION SITES (hardening §3.2.3). The in-loop
-            // splice replaced the history, so every recorded index means nothing; the
-            // manual path settles through here too, so one call covers both.
-            this.compactor.invalidateMeasurement();
+            // SITE 1 OF THE FOUR INVALIDATION SITES (hardening §3.2.3), and THE LOAD-
+            // BEARING LINE OF THE P0-1 FIX (context-usage-gauge-accuracy I-9).
+            //
+            // ITS POSITION IS THE WHOLE ARGUMENT: it runs in this class's own
+            // synchronous code, BEFORE both `emit` calls below, so the `snapshot()`
+            // two statements down is guaranteed to see a dirty meter and re-measure -
+            // no matter which of the two agent-stream listeners the emitter reached
+            // first. Deleting it and relying on the meter's own `compaction_end`
+            // subscription instead moves correctness onto subscription ORDER, which is
+            // true in every unit test and false in production import order.
+            //
+            // THE **SHALLOW** RESET (I-8). A splice changes the history and nothing
+            // else, so `estimateOffset` - a calibration for this toolset on this model
+            // - is still valid and is the only thing keeping the post-compaction
+            // estimate honest (I-5). `onHistoryReplaced()` is the other depth and is
+            // NOT interchangeable with this one.
+            this.meter.onHistorySpliced();
             const path = this.archive(settled, dropped);
             if (path)
                 settled.archivePath = path;

package/dist/config/cli-commands.js

@@ -405,6 +405,11 @@ function maskConfig(config) {
 function displayOverride(key, value) {
     if (key === 'maxTokens' && value === null)
         return 'auto';
+    // The SECOND tri-state key, and it needs this for the same reason (§4.5):
+    // `contextWindow: null` is AUTO ("use the model table"), not "unset", and a
+    // bare `null` sends the user looking for a bug that is not there.
+    if (key === 'contextWindow' && value === null)
+        return 'auto';
     return undefined;
 }
 /** Resolve a flat or one-level-dotted key against the persisted config. */

package/dist/config/env.d.ts

@@ -7,7 +7,7 @@
  *   - Overrides: ARAGON_PROVIDER, ARAGON_MODEL, ARAGON_BASE_URL, ARAGON_THINKING,
  *     ARAGON_SHOW_THINKING,
  *     ARAGON_MAX_TOKENS (a number, or `auto` / `0` for the per-model ceiling),
- *     ARAGON_THEME, ARAGON_MOUSE, ARAGON_PLAN, ARAGON_TEAM,
+ *     ARAGON_THEME, ARAGON_MOUSE, ARAGON_PASTE, ARAGON_PLAN, ARAGON_TEAM,
  *     ARAGON_TEAM_MAX, ARAGON_RETRY, ARAGON_RETRY_MAX, ARAGON_FAST,
  *     ARAGON_FAST_PROVIDER, ARAGON_FAST_MODEL, ARAGON_FAST_BASE_URL,
  *     ARAGON_LOG_LEVEL,

package/dist/config/env.js

@@ -7,7 +7,7 @@
  *   - Overrides: ARAGON_PROVIDER, ARAGON_MODEL, ARAGON_BASE_URL, ARAGON_THINKING,
  *     ARAGON_SHOW_THINKING,
  *     ARAGON_MAX_TOKENS (a number, or `auto` / `0` for the per-model ceiling),
- *     ARAGON_THEME, ARAGON_MOUSE, ARAGON_PLAN, ARAGON_TEAM,
+ *     ARAGON_THEME, ARAGON_MOUSE, ARAGON_PASTE, ARAGON_PLAN, ARAGON_TEAM,
  *     ARAGON_TEAM_MAX, ARAGON_RETRY, ARAGON_RETRY_MAX, ARAGON_FAST,
  *     ARAGON_FAST_PROVIDER, ARAGON_FAST_MODEL, ARAGON_FAST_BASE_URL,
  *     ARAGON_LOG_LEVEL,
@@ -37,7 +37,7 @@ import process from 'node:process';
 import dotenv from 'dotenv';
 import { registerSecretsFrom } from '../logging/secret-registry.js';
 import { clampLogLevel } from '../logging/levels.js';
-import { clampMaxTokens, clampTheme, clampThinkingLevel, isAutoToken, parseThresholdInput, } from './schema.js';
+import { clampContextWindow, clampMaxTokens, clampTheme, clampThinkingLevel, isAutoToken, parseThresholdInput, } from './schema.js';
 /**
  * Load a project `.env` from the given directory into `process.env` (existing
  * process env wins — dotenv never overrides already-set variables).
@@ -113,6 +113,20 @@ export function readEnvConfig() {
                 partial.maxTokens = clamped;
         }
     }
+    // `auto` / `0` mean AUTO (`null`); a number is clamped. Anything else is LEFT
+    // ABSENT rather than written as `null`, the rule `ARAGON_MAX_TOKENS` states one
+    // block up: a typo must not silently discard the number in the config file.
+    const contextWindow = process.env.ARAGON_CONTEXT_WINDOW?.trim();
+    if (contextWindow !== undefined && contextWindow.length > 0) {
+        if (isAutoToken(contextWindow)) {
+            partial.contextWindow = null;
+        }
+        else {
+            const clamped = clampContextWindow(contextWindow, null);
+            if (clamped !== null)
+                partial.contextWindow = clamped;
+        }
+    }
     if (process.env.ARAGON_THEME) {
         partial.theme = clampTheme(process.env.ARAGON_THEME.trim(), 'auto');
     }
@@ -141,6 +155,13 @@ export function readEnvConfig() {
                 mouseSelect === 'on' ||
                 mouseSelect === 'yes';
     }
+    // ARAGON_PASTE=0 turns paste recognition off, which is the documented one-env
+    // revert to v0.6.3 input handling (tui-paste-handling section 7.2). Parsed by
+    // the POSITIVE list, exactly as its two neighbours above are.
+    const paste = process.env.ARAGON_PASTE?.trim().toLowerCase();
+    if (paste !== undefined && paste.length > 0) {
+        partial.paste = paste === '1' || paste === 'true' || paste === 'on' || paste === 'yes';
+    }
     // ARAGON_SCROLL_RESUME_MS=<n> — idle delay before a paused viewport returns to
     // the newest line; `0` disables auto-resume. THE ONLY CHANNEL BESIDES THE
     // CONFIG FILE, because §6.1 gives this key no CLI flag on purpose. `load.ts`
@@ -239,6 +260,46 @@ export function readEnvConfig() {
         if (Object.keys(section).length > 0)
             partial.todo = section;
     }
+    // ARAGON_BASH_BACKGROUND=0 turns background services off entirely (no
+    // `background` param, no `bash_output`/`bash_kill`, no prompt block, no chip);
+    // ARAGON_BASH_AUTO_BACKGROUND=0 keeps them but stops the classifier firing on
+    // an unset `background`. Parsed by the POSITIVE list, exactly as
+    // ARAGON_FULLSCREEN / ARAGON_MOUSE / ARAGON_PLAN / ARAGON_TEAM / ARAGON_TODO
+    // are - NOT by `envBool` below, which uses a negative list.
+    //
+    // Both pass the test every env var in this file has to pass: an unattended run
+    // in a container with a fixed entrypoint can reach neither a flag nor a config
+    // file, and "do not leave a dev server running in my CI job" is exactly the
+    // kind of decision that channel needs to make.
+    //
+    // ONE ACCUMULATED SECTION, ASSIGNED ONCE - the shape the `team` and `todo`
+    // branches above already use, and NOT two `if` blocks each assigning
+    // `partial.bash` (the `todo` P1-4 trap). THE CAST IS WHAT WOULD MAKE THAT
+    // MISTAKE SILENT: a second assignment compiles clean and drops the first key,
+    // so `ARAGON_BASH_BACKGROUND=0 ARAGON_BASH_AUTO_BACKGROUND=0` would quietly
+    // re-register the tools the user turned off.
+    const bashBackground = process.env.ARAGON_BASH_BACKGROUND?.trim().toLowerCase();
+    const bashAuto = process.env.ARAGON_BASH_AUTO_BACKGROUND?.trim().toLowerCase();
+    if ((bashBackground !== undefined && bashBackground.length > 0) ||
+        (bashAuto !== undefined && bashAuto.length > 0)) {
+        const section = {};
+        if (bashBackground !== undefined && bashBackground.length > 0) {
+            section.background =
+                bashBackground === '1' ||
+                    bashBackground === 'true' ||
+                    bashBackground === 'on' ||
+                    bashBackground === 'yes';
+        }
+        if (bashAuto !== undefined && bashAuto.length > 0) {
+            section.autoBackground =
+                bashAuto === '1' || bashAuto === 'true' || bashAuto === 'on' || bashAuto === 'yes';
+        }
+        // A PARTIAL section, safe only because every consumer deep-merges it - the
+        // same contract `partial.skills`, `partial.log`, `partial.team` and
+        // `partial.todo` rely on.
+        if (Object.keys(section).length > 0)
+            partial.bash = section;
+    }
     // ARAGON_RETRY=0 is the kill switch for API retry; ARAGON_RETRY_MAX=<n>
     // overrides the count. Parsed by the POSITIVE list, exactly as
     // ARAGON_FULLSCREEN / ARAGON_MOUSE / ARAGON_PLAN / ARAGON_TEAM / ARAGON_TODO

package/dist/config/load.d.ts

@@ -49,6 +49,17 @@ export interface CliFlags {
      * `false` on every run (the `--todo-panel` trap).
      */
     mouseSelect?: boolean;
+    /**
+     * `--paste` ⇒ true, `--no-paste` ⇒ false, absent ⇒ undefined
+     * (tui-paste-handling section 7.1).
+     *
+     * DECLARED AS A PAIR, and carried through `toFlags`, for the reason the two
+     * notes above record. `paste` is additionally 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 that passed no flag at all.
+     */
+    paste?: boolean;
     /** `--no-skills` ⇒ false. Turns the whole skill subsystem off (§7.5). */
     skills?: boolean;
     /** `--skill <name>` ×N — force Level 2 injection for this run. */
@@ -174,6 +185,23 @@ export interface CliFlags {
      * to keep in step with `toFlags`.
      */
     fastReview?: string;
+    /**
+     * `--fast-delegate` ⇒ true, `--no-fast-delegate` ⇒ false, absent ⇒ undefined
+     * (web-use-tier-cooperation-and-control-closure §4.1.5).
+     *
+     * DECLARED AS A PAIR — MANDATORY, for the reason `--team`, `--todo-panel`,
+     * `--render-governor`, `--retry` and `--fast` each record in turn, and here
+     * with the SAME polarity as `--update`: `fast.delegate` is PERSISTED and
+     * defaults to `true`, so a lone `--no-fast-delegate` would make commander
+     * default `opts.fastDelegate` to `true` and silently overwrite a stored
+     * `false` on every run that passed no flag at all.
+     *
+     * It exists because it is the ONLY `fast.*` sub-switch with no channel a
+     * wrapper can reach: `--fast-review <n|off>` already covers `review` and
+     * `reviewEveryTurns`, and `enabled` / `model` / `provider` have both a flag
+     * and an environment variable.
+     */
+    fastDelegate?: boolean;
     /**
      * `--update` ⇒ true, `--no-update` ⇒ false, absent ⇒ undefined
      * (cli-auto-update §4.2).

package/dist/config/load.js

@@ -6,7 +6,7 @@
  * legitimately long single tool run can never be watchdog-killed.
  */
 import process from 'node:process';
-import { DEFAULT_CONFIG, IDLE_TIMEOUT_MARGIN_MS, clampAskRounds, clampDensity, clampHumanTimeout, clampCompactionConfig, clampLogConfig, clampFastConfig, clampRetryConfig, clampSkillsConfig, clampTeamConfig, clampTodoConfig, clampUpdateConfig, clampTheme, clampThinkingLevel, clampMaxTokens, clampMaxRenderInterval, clampScrollResumeMs, clampTranscriptRetain, clampTranscriptWindow, coercePositiveInt, isAutoToken, isSkillsToolPolicyMode, parseThresholdInput, } from './schema.js';
+import { DEFAULT_CONFIG, IDLE_TIMEOUT_MARGIN_MS, clampAskRounds, clampDensity, clampHumanTimeout, clampCompactionConfig, clampLogConfig, clampFastConfig, clampRetryConfig, clampSkillsConfig, clampTeamConfig, clampTodoConfig, clampBashConfig, clampUpdateConfig, clampTheme, clampThinkingLevel, clampContextWindow, clampMaxTokens, clampMaxRenderInterval, clampScrollResumeMs, clampTranscriptRetain, clampTranscriptWindow, coercePositiveInt, isAutoToken, isSkillsToolPolicyMode, parseThresholdInput, } from './schema.js';
 import { loadDotenv, readEnvConfig, readEnvDisabledSkills } from './env.js';
 import { readConfigFile } from './store.js';
 import { getConfigPath } from './app-paths.js';
@@ -80,6 +80,24 @@ function resolveMouseSelect(flags, env, file) {
         return file.mouseSelect;
     return DEFAULT_CONFIG.mouseSelect;
 }
+/**
+ * Paste handling: flag > env > file > default `true` (tui-paste-handling
+ * section 7.4).
+ *
+ * SHAPED EXACTLY LIKE `resolveMouse` above, for the reason its own note gives:
+ * reaching for the `hints` shape -- `flags.x !== undefined ? ... : file.x ??
+ * DEFAULT`, which reads NO ENV AT ALL -- would ship `ARAGON_PASTE` as
+ * documented-but-dead.
+ */
+function resolvePaste(flags, env, file) {
+    if (flags.paste !== undefined)
+        return flags.paste;
+    if (env.paste !== undefined)
+        return env.paste;
+    if (file.paste !== undefined)
+        return file.paste;
+    return DEFAULT_CONFIG.paste;
+}
 /**
  * Idle scroll-resume delay: env › file › default 5000, clamped to [0, 120000].
  *
@@ -153,6 +171,24 @@ function resolveTodoConfig(flags, env, file) {
         ...(flags.todoFollow !== undefined ? { followThrough: flags.todoFollow } : {}),
     });
 }
+/**
+ * Merge the `bash` section across the three layers that supply it
+ * (defaults > file > env), background-service-supervision §5.4.
+ *
+ * THREE LAYERS, NOT FOUR, AND THAT IS NOT AN OVERSIGHT. There is deliberately no
+ * `--no-background` flag: the two switches this section carries are already
+ * reachable from `config.json` (a per-machine preference) and from the
+ * environment (the channel a container entrypoint has), which is the two-part
+ * test every knob in this file is held to. A third spelling would be a third
+ * place for the answer to differ.
+ */
+function resolveBashConfig(env, file) {
+    return clampBashConfig({
+        ...DEFAULT_CONFIG.bash,
+        ...(file.bash ?? {}),
+        ...(env.bash ?? {}),
+    });
+}
 /**
  * Merge the `retry` section across all four layers (defaults › file › env ›
  * flags), llm-api-retry-backoff §6.2.
@@ -214,6 +250,12 @@ function resolveFastConfig(flags, env, file) {
         ...(flags.fastProvider !== undefined && flags.fastProvider !== ''
             ? { provider: flags.fastProvider }
             : {}),
+        // `!== undefined`, for the reason stated on `flags.fast` above: commander
+        // materialises a lone `--no-fast-delegate` as `opts.fastDelegate = true`
+        // when the flag is absent, and `delegate` defaults to TRUE — so a truthiness
+        // check would force it on for every run that passed no flag at all,
+        // overwriting a stored `false` with nothing to show for it.
+        ...(flags.fastDelegate !== undefined ? { delegate: flags.fastDelegate } : {}),
         ...reviewPatch,
     });
 }
@@ -374,6 +416,42 @@ function resolveMaxTokens(flags, env, file) {
     }
     return DEFAULT_CONFIG.maxTokens ?? undefined;
 }
+/**
+ * Resolve the context-window override: env > file > default, where an EXPLICIT
+ * `null` at either layer means AUTO (context-usage-gauge-accuracy §3.6).
+ *
+ * IT CANNOT USE `pick()` FOR THE REASON `resolveMaxTokens` GIVES: `pick` skips
+ * `null`, and `null` is exactly the value being looked for. NO CLI FLAG feeds
+ * this - it is a per-installation correction for a model table entry, not a
+ * per-invocation choice, so `config set` and the environment variable are the
+ * two surfaces the design names.
+ */
+function resolveContextWindow(env, file) {
+    const layers = [
+        {
+            name: 'ARAGON_CONTEXT_WINDOW',
+            value: hasOwn(env, 'contextWindow') ? env.contextWindow : undefined,
+        },
+        {
+            name: 'config.json contextWindow',
+            value: hasOwn(file, 'contextWindow') ? file.contextWindow : undefined,
+        },
+    ];
+    for (const layer of layers) {
+        if (layer.value === undefined)
+            continue; // this layer said nothing
+        if (layer.value === null || isAutoToken(layer.value))
+            return null; // AUTO
+        const n = clampContextWindow(layer.value, null);
+        if (n !== null)
+            return n;
+        getLogger().warn('config', 'context_window_unusable', {
+            source: layer.name,
+            value: String(layer.value),
+        });
+    }
+    return DEFAULT_CONFIG.contextWindow;
+}
 /**
  * Resolve the effective config by merging all layers, then derive the runtime
  * (non-persisted) fields and enforce the timeout invariant.
@@ -409,6 +487,7 @@ export function loadConfig(flags = {}) {
     const liveToolOutput = pick(flags.liveToolOutput, env.partial.liveToolOutput, file.liveToolOutput) ??
         DEFAULT_CONFIG.liveToolOutput;
     const maxTokens = resolveMaxTokens(flags, env.partial, file);
+    const contextWindow = resolveContextWindow(env.partial, file);
     // `clampTheme` is also where the v0.3.0 `dark` name is migrated to `cool`,
     // so reading a legacy config file needs no extra step here (§4.5 / R-4).
     const theme = clampTheme(pick(flags.theme, env.partial.theme, file.theme), DEFAULT_CONFIG.theme);
@@ -498,6 +577,7 @@ export function loadConfig(flags = {}) {
         showThinking,
         liveToolOutput,
         maxTokens,
+        contextWindow,
         theme,
         reducedMotion,
         fullscreen: resolveFullscreen(flags, env.partial, file),
@@ -520,6 +600,7 @@ export function loadConfig(flags = {}) {
         hints,
         mouse: resolveMouse(flags, env.partial, file),
         mouseSelect: resolveMouseSelect(flags, env.partial, file),
+        paste: resolvePaste(flags, env.partial, file),
         scrollResumeMs: resolveScrollResumeMs(env.partial, file),
         // From `<home>/state.json`, not the config file — see `ui-state.ts`.
         submitCount: readSubmitCount(),
@@ -545,6 +626,7 @@ export function loadConfig(flags = {}) {
         fast: resolveFastConfig(flags, env.partial, file),
         update: resolveUpdateConfig(flags, env.partial, file),
         compaction: resolveCompactionConfig(flags, env.partial, file),
+        bash: resolveBashConfig(env.partial, file),
         cwd,
         color,
         colorLevel,