@aragon-agent/cli 0.6.13 → 0.6.14

package/CHANGELOG.md

@@ -7,6 +7,33 @@ were written.
 
 ## Unreleased
 
+### Consistent TUI styling
+
+- Interactive sessions always use Unicode and default to truecolor, including
+  PowerShell sessions without terminal or UTF locale markers. Ink's actual color
+  output follows the same policy, with renderer state restored on exit.
+- Explicit color opt-outs keep Unicode borders and icons; the opening logo now
+  depends only on available space. Headless terminal detection is unchanged.
+- Reloading model settings preserves session display preferences. Syntax
+  highlighting follows the same color policy, and status icons use consistent
+  single-column glyphs to prevent narrow-frame overflow.
+- Hiding the editor caret while scrolling preserves draft geometry, preventing
+  a layout update loop when entering text above the full startup logo.
+- Register exit cleanup before mounting the application, so immediate exits and
+  initial render failures restore terminal and color state reliably. Failed
+  mounts no longer mark an auto-installed build as healthy.
+
+### Model context window
+
+- Discover context limits at startup and after connection changes without blocking
+  input. The status bar and compaction use the discovered limit; `/context` names
+  API versus catalog metadata. Unknown windows show `?`, not a fabricated 128k
+  capacity or percentage. Manual `contextWindow` overrides retain precedence.
+- Window overrides now apply to tail relief and compaction progress as well as
+  the gauge. Workers on different models/endpoints do not inherit the lead's
+  override. API-key changes refresh metadata, and ending a session cancels its
+  pending model queries. `/context` also hides unknown capacities/percentages.
+
 ### TUI 输入与排队可靠性
 
 - Shift+Enter 与粘贴按输入顺序处理；普通 Enter 保持弹层兼容，混合输入最多提交一次，

package/README.md

@@ -1316,9 +1316,9 @@ The readouts drop as the terminal narrows, in that order of priority:
   either no completed turn has reported usage yet (right after `/resume`, or
   right after a compaction), or tool results have been appended since the last
   measurement and their size is estimated.
-- `?` sits on the **window** and means the *denominator* is a guess: the model is
-  not in the built-in table, so a flat 128 000 was substituted. See
-  `contextWindow` below.
+- `?` replaces the **window** when neither the API nor the catalog provides a
+  limit. No percentage is shown in that case. The internal 128 000-token fallback
+  remains a compaction budget, not a claim about model capacity. See `contextWindow` below.
 
 **The percentage keeps moving during a turn.** Every tool result nudges it,
 whether or not compaction is enabled — it is not a compaction feature, and a
@@ -1343,7 +1343,7 @@ Context
 ```
 
 Two lines are worth reading closely. **`Window`** always names where the number
-came from — the model table, your own `contextWindow`, or the invented
+came from — the model API, the model table, your own `contextWindow`, or the invented
 placeholder — because those are indistinguishable everywhere else. And
 **`Compaction`** reports what is actually true of this session, including
 `off - not registered for this session (started with --no-compaction)`; it never
@@ -1351,13 +1351,21 @@ promises a threshold that nothing will act on.
 
 ### `contextWindow`
 
-When the model is not in the built-in table — a custom `baseUrl`, a self-hosted
-id, something released last week — the denominator is a **fabricated** 128 000
-and the percentage is meaningless. Correct it:
+Window resolution uses your explicit override first, then API metadata from the
+configured endpoint, then the built-in catalog (including known aliases and dated
+snapshots). Startup, connection changes, and subsequent prompts refresh discovery
+in the background, with a five-minute cache. OpenAI-compatible endpoints may expose
+`context_length` or `context_window`; Anthropic uses `max_input_tokens`; Google uses
+`inputTokenLimit`. An ID-only models response cannot establish the real limit.
+Google/Anthropic lists are paginated (up to 20 pages within one 15-second deadline).
+Changing the connection or ending the session cancels its pending lookup.
+
+If neither the endpoint nor the catalog knows your model, the status bar shows `?`.
+Set a verified provider limit explicitly:
 
 ```bash
 aragon config set contextWindow 1000000   # persisted; prints "Set contextWindow = 1000000"
-aragon config set contextWindow auto      # back to the model table / placeholder
+aragon config set contextWindow auto      # back to API discovery / catalog
 ARAGON_CONTEXT_WINDOW=1000000 aragon      # one session
 ```
 
@@ -1890,7 +1898,7 @@ env / `.env` → CLI flags**.
 | Config key | Default | Meaning |
 | --- | --- | --- |
 | `maxTokens` | `64000` | Output token cap, clamped to `[256, 200000]`. `null` means **auto** — use each model's own ceiling, never above 64000. Absent means the default. See [Output token limits](#output-token-limits). |
-| `contextWindow` | `null` | The window the context gauge measures against, clamped to `[8000, 5000000]`. `null` means **auto** — the built-in model table, or a fabricated 128000 for a model it has never seen. Set it when the gauge shows `?` on the denominator. See [The context gauge](#the-context-gauge). |
+| `contextWindow` | `null` | The window the context gauge measures against, clamped to `[8000, 5000000]`. `null` means **auto** — API metadata, then the built-in catalog. Unknown windows show `?`; the internal fallback is 128000. See [The context gauge](#the-context-gauge). |
 | `showThinking` | `false` | Draw the reasoning the model returns. `thinkingLevel` is the effort the provider is asked to **spend**; this is whether the terminal **shows** it. Off by default: a settled turn that thought leaves one muted `thought for 12s` row in its place, so nothing is hidden silently. |
 | `liveToolOutput` | `true` | Draw up to eight sanitised rows of a **running** tool's output on its card, plus a `no output for Ns` row when the child goes quiet. On by default, unlike `showThinking`: this ADDS the information a long `bash` call otherwise hides, and its cost is bounded by construction — eight rows per call, sixteen calls, whatever the command emits. Turn it off and the card is a single `running` row again, with no store allocated and no recorder attached. |
 | `exitTranscript` | `true` | Replay a plain-text session summary after exiting (full-screen only). |
@@ -1968,7 +1976,7 @@ aragon config set maxTokens 32000    # persisted; prints "Set maxTokens = 32000"
 aragon config set maxTokens auto     # persisted as null
 aragon config set maxTokens default  # back to 64000
 aragon config set contextWindow 1000000  # the gauge's denominator
-aragon config set contextWindow auto     # back to the model table
+aragon config set contextWindow auto     # back to API discovery / catalog
 aragon config get maxTokens          # "64000" | "auto"
 ```
 
@@ -2272,12 +2280,15 @@ quiet output is required.
 `--theme` / `config.theme` / `/theme` pick a palette: `warm`, `cool`, `light`, or
 `auto` (which resolves to `warm` — terminals can't reliably report their
 background). `dark` remains accepted everywhere as an alias for `cool`.
-Colors degrade automatically to your terminal's depth (truecolor → 256 → 16 →
-monochrome) and glyphs fall back to ASCII on terminals without Unicode. Color is
-disabled — and the UI renders plain monochrome with ASCII glyphs — when any of
-`NO_COLOR`, `--no-color`, `TERM=dumb`, or `config.color=false` is set; `FORCE_COLOR`
-is respected. `reducedMotion` (also `ARAGON_REDUCED_MOTION`, and implied by
-`--no-color`) replaces spinners with a static glyph.
+Interactive sessions always use Unicode borders, icons and scrollbars, with
+truecolor and gradients by default. Missing terminal/locale markers, `TERM=dumb`,
+and low `FORCE_COLOR` levels do not simplify the TUI. `--no-color`, `NO_COLOR`
+(including an empty value), or `FORCE_COLOR=0/false` explicitly disable color;
+Unicode stays enabled. The opening logo adapts only to available space and
+remains visible in monochrome. `reducedMotion` (also `ARAGON_REDUCED_MOTION`,
+and implied by disabling color) replaces spinners with a static glyph.
+Headless commands retain their existing terminal detection. The terminal and
+font still need to support the characters and colors the TUI emits.
 
 ### Timeout invariant
 

package/dist/agent/controller.d.ts

@@ -123,6 +123,10 @@ export declare class AgentController {
     private readonly agent;
     private readonly providerRegistry;
     private readonly modelRegistry;
+    private modelMetadataEnabled;
+    private modelMetadataGeneration;
+    private modelMetadataAbort;
+    private disposed;
     private readonly tools;
     private readonly skills;
     private readonly skillsEnabled;
@@ -608,7 +612,11 @@ export declare class AgentController {
      * cost table for the model that actually billed" cannot drift from "the cost
      * table for the session's model" as two separate bodies.
      */
-    getModelInfoFor(ref: Pick<ModelRef, 'providerId' | 'modelId'>): ModelInfo;
+    getModelInfoFor(ref: Pick<ModelRef, 'providerId' | 'modelId' | 'baseUrl'>): ModelInfo;
+    /** Best-effort metadata lookup; never block typing or a model request. */
+    refreshModelMetadata(): Promise<void>;
+    /** Invalidate an old connection without restarting a lookup on every prompt. */
+    private resetModelMetadataRequest;
     /**
      * Whether the STATIC table knows this model's price (C-11 / RV-4).
      *

package/dist/agent/controller.js

@@ -51,6 +51,10 @@ export class AgentController {
     agent;
     providerRegistry;
     modelRegistry;
+    modelMetadataEnabled = false;
+    modelMetadataGeneration = 0;
+    modelMetadataAbort = new AbortController();
+    disposed = false;
     tools;
     skills;
     skillsEnabled;
@@ -529,15 +533,8 @@ export class AgentController {
             getMessages: () => this.agent.state.messages,
             getSystemPrompt: () => this.agent.state.systemPrompt,
             getModelInfo: () => this.getModelInfo(),
-            // ONE PREDICATE FOR "IS THE DENOMINATOR REAL". `isPricedModel` is
-            // `modelRegistry.getModel(...) !== undefined`, and `getModelInfoFor` falls
-            // back to `buildRuntimeModel` - a 128k placeholder AND a zero cost table -
-            // for exactly the models it answers `false` for. The two are the same
-            // question about the same static table, not a coincidence.
-            isWindowKnown: () => this.isPricedModel({
-                providerId: this.config.provider,
-                modelId: this.config.model,
-            }),
+            // Context discovery does not imply that the model's price is known.
+            isWindowKnown: () => this.getModelInfo().contextWindowSource !== 'fallback',
             // LIVE, so a settings-screen edit moves the denominator without a relaunch.
             getWindowOverride: () => this.config.contextWindow,
         });
@@ -863,6 +860,8 @@ export class AgentController {
         if (this.modelSettingsBlocked) {
             return { status: 'not-started', reason: 'failed' };
         }
+        if (this.modelMetadataEnabled)
+            void this.refreshModelMetadata();
         const request = ++this.startupSequence;
         try {
             if (this.agent.state.isRunning) {
@@ -1257,6 +1256,9 @@ export class AgentController {
     }
     /** Abort every child and clear timers. Idempotent; safe to call twice. */
     dispose() {
+        this.disposed = true;
+        this.modelMetadataGeneration += 1;
+        this.modelMetadataAbort.abort();
         this.teamRuntime?.dispose();
         this.fast?.dispose();
         this.compaction?.dispose();
@@ -1419,6 +1421,12 @@ export class AgentController {
             this.agent.setModel(snapshot.model);
             this.agent.setThinkingLevel(snapshot.config.thinkingLevel);
             this.agent.setMaxTokens(snapshot.config.maxTokens);
+            // Credentials may change even when endpoint/model do not. Invalidate
+            // before publishing a window, including when the new profile has no key.
+            if (this.modelMetadataEnabled) {
+                this.resetModelMetadataRequest();
+                this.modelRegistry.clearCache();
+            }
             this.fast?.onConfigChanged(false, snapshot.config.fast.enabled);
             this.compaction?.onConfigChanged(snapshot.config.compaction.enabled);
             this.contextMeter.onWindowChanged();
@@ -1427,6 +1435,8 @@ export class AgentController {
         finally {
             this.preparedSystemPrompt = undefined;
         }
+        if (this.modelMetadataEnabled)
+            void this.refreshModelMetadata();
     }
     /** Potentially failing ordinary-setting side effects are isolated from model application. */
     applyModelSettingsEffects() { getLogger().reconfigure(this.config.log); }
@@ -1434,12 +1444,15 @@ export class AgentController {
     blockModelSettingsRequests() {
         this.modelSettingsBlocked = true;
         this.config.modelSettingsRestartRequired = true;
+        this.resetModelMetadataRequest();
     }
     /** The UI uses this before accepting or draining queued prompts. */
     areModelSettingsBlocked() { return this.modelSettingsBlocked; }
     setModel(provider, model, baseUrl) {
         if (this.isModelSettingsBusy())
             throw new Error('Model settings are busy.');
+        if (this.modelMetadataEnabled)
+            this.resetModelMetadataRequest();
         this.settingsRevision += 1;
         this.config = { ...this.config, provider, model, baseUrl };
         this.config.modelProfileState = resolveModelProfileState(this.config);
@@ -1462,6 +1475,8 @@ export class AgentController {
         // numerator's calibration is one turn stale until the next `turn_end`
         // (RV-13), which is the trade this call names.
         this.contextMeter.onWindowChanged();
+        if (this.modelMetadataEnabled)
+            void this.refreshModelMetadata();
     }
     setThinkingLevel(level) {
         this.settingsRevision += 1;
@@ -1481,6 +1496,12 @@ export class AgentController {
             ...this.config,
             apiKeys: { ...this.config.apiKeys, [provider]: key },
         };
+        if (this.modelMetadataEnabled) {
+            this.resetModelMetadataRequest();
+            this.modelRegistry.clearCache(provider);
+            this.contextMeter.onWindowChanged();
+            void this.refreshModelMetadata();
+        }
         // Rule 5 of §3.2 reads `apiKeys`, so a key edit is a tier event: this is the
         // path that turns `no_key` back into a working tier without a relaunch.
         this.fast?.onConfigChanged();
@@ -1639,9 +1660,38 @@ export class AgentController {
      */
     getModelInfoFor(ref) {
         const found = this.modelRegistry.getModel(ref.providerId, ref.modelId);
-        if (found)
-            return found;
-        return this.modelRegistry.buildRuntimeModel(ref.providerId, ref.modelId);
+        const baseUrl = ref.baseUrl ?? (ref.providerId === this.config.provider && ref.modelId === this.config.model
+            ? this.config.baseUrl : undefined);
+        return {
+            ...(found ?? this.modelRegistry.buildRuntimeModel(ref.providerId, ref.modelId)),
+            ...this.modelRegistry.getContextWindow(ref.providerId, ref.modelId, baseUrl),
+        };
+    }
+    /** Best-effort metadata lookup; never block typing or a model request. */
+    async refreshModelMetadata() {
+        if (this.disposed || this.modelSettingsBlocked)
+            return;
+        this.modelMetadataEnabled = true;
+        const generation = ++this.modelMetadataGeneration;
+        const { provider, baseUrl } = this.config;
+        try {
+            const key = this.resolveKey(provider);
+            if (!key)
+                return;
+            await this.modelRegistry.discoverModels(provider, key, baseUrl, this.modelMetadataAbort.signal);
+            if (this.disposed || generation !== this.modelMetadataGeneration)
+                return;
+            this.contextMeter.onWindowChanged();
+        }
+        catch {
+            // Offline or unsupported discovery leaves catalog/unknown metadata intact.
+        }
+    }
+    /** Invalidate an old connection without restarting a lookup on every prompt. */
+    resetModelMetadataRequest() {
+        this.modelMetadataGeneration += 1;
+        this.modelMetadataAbort.abort();
+        this.modelMetadataAbort = new AbortController();
     }
     /**
      * Whether the STATIC table knows this model's price (C-11 / RV-4).

package/dist/agent/model-profile-settings.js

@@ -182,8 +182,17 @@ export function reloadModelSettings(controller) {
     if (validateModelProfiles(disk.config?.modelProfiles).length)
         return rejected('invalid');
     try {
-        const resolved = loadConfig({ cwd: controller.getConfig().cwd });
-        resolved.liveToolOutput = controller.getConfig().liveToolOutput;
+        const live = controller.getConfig();
+        const resolved = loadConfig({ cwd: live.cwd });
+        resolved.liveToolOutput = live.liveToolOutput;
+        // The mounted renderer owns these session preferences. Reloading model
+        // settings must not re-detect the shell or discard a startup --no-color.
+        resolved.color = live.color;
+        if (live.colorLevel !== undefined)
+            resolved.colorLevel = live.colorLevel;
+        if (live.unicode !== undefined)
+            resolved.unicode = live.unicode;
+        resolved.reducedMotion ||= !live.color;
         const after = readModelSettingsDisk();
         if (!after.ok)
             return rejected('read_failed');

package/dist/agent/reducer.js

@@ -1190,6 +1190,7 @@ export function viewReducer(state, action) {
                 prev.source === next.source &&
                 prev.deltaTokens === next.deltaTokens &&
                 prev.windowKnown === next.windowKnown &&
+                prev.windowSource === next.windowSource &&
                 prev.windowOverridden === next.windowOverridden) {
                 return state;
             }

package/dist/boot/guard.d.ts

@@ -109,9 +109,9 @@ export declare function runBootGuard(deps?: BootGuardDeps): void;
  *
  * Called from two places, and both matter:
  *
- *  - `cli.tsx::runInteractive`, immediately after `render()` returns - the
- *    earliest moment at which "this build starts" is PROVEN: the module graph
- *    loaded, config resolved, Ink mounted. This is the primary, and it is what
+ *  - `cli.tsx::runInteractive`, after mount-time exit promises settle, while
+ *    the app is still live (or has exited successfully): the module graph
+ *    loaded, config resolved, Ink mounted successfully. This primary path
  *    makes a long session that is later `SIGKILL`ed (terminal window closed,
  *    machine slept badly, OOM killer) still count as healthy.
  *  - the exit hook installed by `runBootGuard`, when the code is `0` - the

package/dist/boot/guard.js

@@ -178,9 +178,9 @@ export function runBootGuard(deps = {}) {
  *
  * Called from two places, and both matter:
  *
- *  - `cli.tsx::runInteractive`, immediately after `render()` returns - the
- *    earliest moment at which "this build starts" is PROVEN: the module graph
- *    loaded, config resolved, Ink mounted. This is the primary, and it is what
+ *  - `cli.tsx::runInteractive`, after mount-time exit promises settle, while
+ *    the app is still live (or has exited successfully): the module graph
+ *    loaded, config resolved, Ink mounted successfully. This primary path
  *    makes a long session that is later `SIGKILL`ed (terminal window closed,
  *    machine slept badly, OOM killer) still count as healthy.
  *  - the exit hook installed by `runBootGuard`, when the code is `0` - the

package/dist/cli.js

@@ -16,7 +16,7 @@ import { fileURLToPath } from 'node:url';
 import process from 'node:process';
 import '../runtime/insecure-tls-warning.cjs';
 // Must precede every other dependency that imports Ink: CI detection is cached.
-import { render } from './ui/ink-runtime.js';
+import { renderTui as render } from './ui/ink-runtime.js';
 import { Command } from 'commander';
 import { ModelProfileConfigError } from './config/model-profile-store.js';
 import { loadConfig } from './config/load.js';
@@ -54,7 +54,7 @@ import { supportsWindowsVtInput } from './ui/win-vt-input.js';
 import { forceWindowsVtInput } from './ui/win-vt-force.js';
 import { readExitSnapshot } from './ui/exit-snapshot.js';
 import { renderTranscriptText } from './ui/transcript-text.js';
-import { detectCapabilities } from './ui/capabilities.js';
+import { resolveTuiCapabilities } from './ui/capabilities.js';
 import { pickGlyphs } from './ui/glyphs.js';
 import { getTheme } from './ui/theme.js';
 import { createSelectionController, } from './ui/selection/selection-controller.js';
@@ -224,7 +224,7 @@ function toFlags(opts) {
  * instead of writing to disk unattended.
  */
 function makeController(flags, opts = { interactive: true }) {
-    const config = loadConfig(flags);
+    const config = loadConfig(flags, { interactive: opts.interactive });
     // The authoritative log level lands here (§4.4.5). `installLogging()` only
     // resolved a bootstrap level — it ran before commander and before `.env` were
     // readable — and without this hand-off the fully resolved one never applies.
@@ -283,6 +283,7 @@ function makeController(flags, opts = { interactive: true }) {
  */
 function makeExecController(flags, deps) {
     const { controller } = makeController(flags, { interactive: false, ...deps });
+    void controller.refreshModelMetadata();
     const logger = getLogger();
     logger.info('cli', 'run_exec', {});
     logger.onFailure((reason) => process.stderr.write(`[log] ${reason}\n`));
@@ -388,9 +389,14 @@ function runInteractive(flags, extras = {}) {
         return;
     }
     const { controller, confirmBridge, humanInputBridge } = makeController(flags);
+    void controller.refreshModelMetadata();
     const config = controller.getConfig();
+    const caps = resolveTuiCapabilities({}, config.color);
     const logger = getLogger();
-    logger.info('cli', 'run_interactive', { mode: 'fullscreen', provider: config.provider, model: config.model });
+    logger.info('cli', 'run_interactive', {
+        mode: 'fullscreen', provider: config.provider, model: config.model,
+        unicode: caps.unicode, colorLevel: caps.colorLevel,
+    });
     attachAgentEvents(logger, controller);
     // The team stream is CLI-local (D-10), so `attachAgentEvents` cannot see it.
     // Without this a dispatch leaves NO trace in the log file at all — the wrong
@@ -548,7 +554,7 @@ function runInteractive(flags, extras = {}) {
             return; // Never published (instant exit) — skip, do not throw.
         writeExitTranscript(process.stdout, renderTranscriptText(snapshot.entries, {
             // Same terminal the TUI just left, so the same glyph tier applies.
-            glyphs: pickGlyphs(detectCapabilities(process.env, process.stdout)),
+            glyphs: pickGlyphs(caps),
             usageTotal: snapshot.usageTotal,
             provider: snapshot.provider,
             model: snapshot.model,
@@ -635,8 +641,8 @@ function runInteractive(flags, extras = {}) {
             // the SAME `copyText` door and the SAME bridge `onCopied` toast
             // funnel -- the controller keeps only the selection state machine.
             // 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),
+            theme: () => getTheme(config.theme, caps),
+            caps,
             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`.
@@ -718,14 +724,15 @@ function runInteractive(flags, extras = {}) {
             // every existing path is provably unchanged.
             stdin: filter?.stdin ?? process.stdin,
             stdout: frameObserver.stdout,
-        });
+        }, caps);
     }
     catch (error) {
         failInteractive(error);
         throw error;
     }
-    // H1's primary disarm, and this is the earliest moment at which "this build
-    // STARTS" is proven: the module graph loaded, config resolved, Ink mounted
+    // H1's primary disarm. Let mount-time exit promises settle first: Ink may
+    // return from render after its error boundary has already unmounted the app.
+    // A live app on the next turn has loaded, resolved config, and mounted
     // (cli-auto-update-hardening section 5.1.4). It is what makes a long session
     // that is later `SIGKILL`ed - terminal window closed, machine slept badly, OOM
     // killer - still count as healthy.
@@ -735,7 +742,8 @@ function runInteractive(flags, extras = {}) {
     // never armed it this is one read and one string compare. Gating it would mean
     // a user who switches `mode` to `off` between the install and the next launch
     // leaves the guard armed with nothing able to disarm it.
-    markBootHealthy(VERSION);
+    setImmediate(() => { if (!interactiveClosed)
+        markBootHealthy(VERSION); });
     if (updateEligible) {
         // DYNAMIC, and fire-and-forget AFTER `render()` (D-25). Dynamic because a
         // static import would make AC-1 false for `aragon -p`, which shares this
@@ -778,6 +786,9 @@ function runInteractive(flags, extras = {}) {
         .waitUntilExit()
         .then(() => {
         interactiveClosed = true;
+        // Also cover a successful immediate exit when launched via dist/cli.js,
+        // which bypasses the launcher's code-zero boot-guard backstop.
+        markBootHealthy(VERSION);
         screen?.restore();
         // BEFORE `disposeStdinFilter()`, which clears the listener set it subscribed to,
         // and after `restore()` for the reason that call records: the terminal must
@@ -813,6 +824,7 @@ async function runOneShot(flags, prompt, quiet) {
     // install. The gate must know that up front rather than discovering a null
     // handler and defaulting to "yes" (§7.4 / AC-13).
     const { controller } = makeController(flags, { interactive: false });
+    void controller.refreshModelMetadata();
     const logger = getLogger();
     logger.info('cli', 'run_oneshot', { quiet });
     // Headless has no frame, so a logging failure can safely reach stderr — the
@@ -831,10 +843,16 @@ async function runOneShot(flags, prompt, quiet) {
     // `followThrough` is read off the REAL controller here rather than through
     // `HeadlessController`, which is deliberately the minimal surface a test can
     // satisfy with an object literal (todo-plan-followthrough §3.6).
-    const code = await runHeadless(controller, prompt, {
-        quiet,
-        followThrough: controller.getTodoConfig().followThrough,
-    });
+    let code;
+    try {
+        code = await runHeadless(controller, prompt, {
+            quiet,
+            followThrough: controller.getTodoConfig().followThrough,
+        });
+    }
+    finally {
+        controller.dispose();
+    }
     // Flushed HERE and not inside `runHeadless`: that module is deliberately
     // injectable (its own controller interface, its own stdout/stderr) and has an
     // early `return 2`, so a singleton dependency in there would be both a new

package/dist/compaction/child.js

@@ -53,11 +53,15 @@ export function createChildContextManager(req, deps) {
      */
     const childConfig = () => {
         const base = deps.getConfig();
+        const sameConnection = base.provider === req.model.providerId &&
+            base.model === req.model.modelId && base.baseUrl === req.model.baseUrl;
         return {
             ...base,
             provider: req.model.providerId,
             model: req.model.modelId,
             baseUrl: req.model.baseUrl,
+            // The lead's manual limit describes its connection, not every worker.
+            contextWindow: sameConnection ? base.contextWindow : null,
             compaction: {
                 ...base.compaction,
                 keepRecentTurns: COMPACTION_LIMITS.childKeepRecentTurns,

package/dist/compaction/compactor.js

@@ -468,7 +468,7 @@ export class Compactor {
             from,
             systemPrompt,
             budget: tailBudgetTokens({
-                contextWindow: this.modelInfo().contextWindow,
+                contextWindow: this.meter().current().contextWindow,
                 maxOutputTokens: this.effectiveMaxOutputTokens(),
             }),
             log: (event, fields) => this.log.info(event, fields),
@@ -569,7 +569,7 @@ export class Compactor {
      */
     checkProgress(ctx, uiTrigger, after) {
         const config = this.deps.getConfig().compaction;
-        const info = this.modelInfo();
+        const pressure = this.meter().current();
         // THE OFFSET NOW LIVES ON THE METER (W1), and it is read from the last
         // PUBLISHED pressure rather than re-derived: `Pressure.estimateOffset` is
         // carried on every measurement, so this is the same number the field used to
@@ -578,8 +578,8 @@ export class Compactor {
         const projected = computePressure({
             messages: after,
             systemPrompt: ctx.systemPrompt,
-            contextWindow: info.contextWindow,
-            windowKnown: true,
+            contextWindow: pressure.contextWindow,
+            windowKnown: pressure.windowKnown,
             ...(estimateOffset !== undefined ? { estimateOffset } : {}),
         });
         const target = config.threshold - COMPACTION_LIMITS.minReclaimRatio;
@@ -792,7 +792,10 @@ export class Compactor {
                 getMessages: () => this.deps.getMessages(),
                 getSystemPrompt: () => this.deps.getSystemPrompt(),
                 getModelInfo: () => this.modelInfo(),
-                isWindowKnown: () => this.deps.isPricedModel(this.mainRef()),
+                isWindowKnown: () => {
+                    const source = this.modelInfo().contextWindowSource;
+                    return source === undefined ? this.deps.isPricedModel(this.mainRef()) : source !== 'fallback';
+                },
                 getWindowOverride: () => this.deps.getConfig().contextWindow,
             });
         }

package/dist/compaction/context-command.js

@@ -69,6 +69,8 @@ function occupancyLine(usage) {
         : usage.deltaTokens > 0
             ? `[measured ${formatTokens(measured)} + ${formatTokens(usage.deltaTokens)} estimated]`
             : `[measured ${formatTokens(measured)}]`;
+    if (!usage.windowKnown)
+        return `${formatTokens(usage.occupied)} of ?   ${breakdown}`;
     return `${pct}   ${formatTokens(usage.occupied)} of ${formatTokens(usage.window)}   ${breakdown}`;
 }
 /**
@@ -83,13 +85,13 @@ function occupancyLine(usage) {
  */
 function windowLine(usage) {
     if (usage.windowOverridden) {
-        return `${usage.window}   from contextWindow in config.json (overrides the model table)`;
+        return `${usage.window}   from contextWindow configuration (overrides API and model table)`;
     }
     if (!usage.windowKnown) {
-        return (`${usage.window}   PLACEHOLDER - this model is not in the table; ` +
+        return (`UNKNOWN - no verified model limit; internal fallback budget ${usage.window}; ` +
             'set contextWindow to correct it');
     }
-    return `${usage.window}   from the model table`;
+    return `${usage.window}   from ${usage.windowSource === 'api' ? 'the model API' : 'the model table'}`;
 }
 /**
  * How stale the measured half is.

package/dist/compaction/meter.js

@@ -53,6 +53,7 @@ export const CONTEXT_METER_TICK_MS = 400;
 export function toContextUsage(p) {
     return {
         occupied: p.occupied,
+        ...(p.windowSource ? { windowSource: p.windowSource } : {}),
         window: p.contextWindow,
         // FROM `ratio`, NOT FROM A SECOND DIVISION. `computePressure` already
         // clamped it to [0, 1] and already decided what a zero window means.
@@ -380,6 +381,7 @@ export class ContextMeter {
             messages: this.deps.getMessages(),
             systemPrompt: this.readSystemPrompt(),
             contextWindow: window.contextWindow,
+            windowSource: this.deps.getModelInfo().contextWindowSource,
             windowKnown: window.windowKnown,
             windowOverridden: window.windowOverridden,
             ...(this.estimateOffset !== undefined ? { estimateOffset: this.estimateOffset } : {}),

package/dist/compaction/pressure.d.ts

@@ -50,6 +50,7 @@ export declare function occupiedTokens(usage: TokenUsage): number;
  */
 export declare function computeEstimateOffset(usage: TokenUsage, messages: readonly Message[], systemPrompt: string): number;
 export interface PressureInput {
+    windowSource?: Pressure['windowSource'];
     /** Authoritative usage of the last completed turn, or `undefined` (§3.4.2). */
     lastUsage?: TokenUsage;
     messages: readonly Message[];

package/dist/compaction/pressure.js

@@ -133,6 +133,7 @@ export function computePressure(input) {
     const ratio = window > 0 ? Math.max(0, Math.min(1, occupied / window)) : 0;
     return {
         occupied,
+        ...(input.windowSource ? { windowSource: input.windowSource } : {}),
         contextWindow: window,
         ratio,
         headroom: Math.max(0, window - occupied),

package/dist/compaction/types.d.ts

@@ -51,6 +51,7 @@ export type CompactionUiTrigger = 'pressure' | 'overflow' | 'manual';
 /** Whether a figure was measured by the provider or estimated by us. */
 export type PressureSource = 'usage' | 'estimate';
 export interface Pressure {
+    windowSource?: 'api' | 'catalog' | 'fallback';
     occupied: number;
     contextWindow: number;
     /** `occupied / contextWindow`, clamped to [0, 1]. */
@@ -115,6 +116,7 @@ export interface Pressure {
  * view state, and `toContextUsage` in `meter.ts` is the ONLY converter.
  */
 export interface ContextUsageSnapshot {
+    windowSource?: Pressure['windowSource'];
     /** Occupied tokens (measured, plus an estimate of anything appended since). */
     occupied: number;
     /** The denominator actually used. */

package/dist/compaction/wiring.js

@@ -135,7 +135,10 @@ export class CompactionWiring {
                     getMessages: deps.getMessages,
                     getSystemPrompt: deps.getSystemPrompt,
                     getModelInfo: () => deps.getModelInfoFor(this.mainRef()),
-                    isWindowKnown: () => deps.isPricedModel(this.mainRef()),
+                    isWindowKnown: () => {
+                        const source = deps.getModelInfoFor(this.mainRef()).contextWindowSource;
+                        return source === undefined ? deps.isPricedModel(this.mainRef()) : source !== 'fallback';
+                    },
                     getWindowOverride: () => deps.getConfig().contextWindow,
                 });
         this.compactor = new Compactor({

package/dist/config/load.d.ts

@@ -241,7 +241,9 @@ export interface CliFlags {
  * Resolve the effective config by merging all layers, then derive the runtime
  * (non-persisted) fields and enforce the timeout invariant.
  */
-export declare function loadConfig(flags?: CliFlags): CliConfig;
+export declare function loadConfig(flags?: CliFlags, options?: {
+    interactive?: boolean;
+}): CliConfig;
 /**
  * Build the `getApiKey(providerId)` resolver the core `Agent` consumes.
  * The one-shot `--api-key` override wins, but only for the active provider.

package/dist/config/load.js

@@ -16,7 +16,7 @@ import { setEntryRetain } from '../agent/entry-limits.js';
 import { readSubmitCount } from './ui-state.js';
 import { getLogger } from '../logging/logger.js';
 import { registerSecret, registerSecretsFrom } from '../logging/secret-registry.js';
-import { detectCapabilities } from '../ui/capabilities.js';
+import { detectCapabilities, resolveTuiCapabilities } from '../ui/capabilities.js';
 /** Interpret a boolean-ish env value (`1/true/on/yes`) as `true`. */
 function envFlagTrue(value) {
     if (!value)
@@ -436,7 +436,7 @@ function resolveContextWindow(env, file) {
  * Resolve the effective config by merging all layers, then derive the runtime
  * (non-persisted) fields and enforce the timeout invariant.
  */
-export function loadConfig(flags = {}) {
+export function loadConfig(flags = {}, options = {}) {
     const cwd = flags.cwd ? flags.cwd : process.cwd();
     // `.env` must be loaded before reading env overrides.
     loadDotenv(cwd);
@@ -519,13 +519,17 @@ export function loadConfig(flags = {}) {
     // registering twice costs a `Set.add`, missing once costs a credential.
     registerSecretsFrom(apiKeys);
     registerSecret(flags.apiKey);
-    const color = flags.color !== undefined ? flags.color : !process.env.NO_COLOR;
+    const caps = options.interactive
+        ? resolveTuiCapabilities(process.env, flags.color)
+        : detectCapabilities(process.env, process.stdout);
+    const color = options.interactive
+        ? caps.colorLevel !== 0
+        : flags.color !== undefined ? flags.color : !process.env.NO_COLOR;
     // `--no-color` implies calmer chrome; env / file may also opt in explicitly.
     const reducedMotion = envFlagTrue(process.env.ARAGON_REDUCED_MOTION) ||
         (file.reducedMotion ?? DEFAULT_CONFIG.reducedMotion) ||
         !color;
     // Detect terminal capabilities once; force monochrome when color is disabled.
-    const caps = detectCapabilities(process.env, process.stdout);
     const colorLevel = color ? caps.colorLevel : 0;
     // No flag and no env var: a privacy switch you set once, not a per-run knob.
     const historyEnabled = file.historyEnabled ?? DEFAULT_CONFIG.historyEnabled;

package/dist/config/schema.d.ts

@@ -1097,9 +1097,9 @@ export interface CliConfig {
     cwd: string;
     /** Whether ANSI color is enabled. */
     color: boolean;
-    /** Detected terminal color depth (0 none · 1 16 · 2 256 · 3 truecolor). */
+    /** Resolved color depth: TUI policy or non-interactive terminal detection. */
     colorLevel?: 0 | 1 | 2 | 3;
-    /** Detected Unicode support (box/round glyphs & spinners). */
+    /** TUI always enables Unicode; non-interactive output uses detection. */
     unicode?: boolean;
     /** One-shot `--api-key` override; applies to the active provider only. */
     apiKeyOverride?: string;

package/dist/ui/App.js

@@ -8,7 +8,6 @@ import { selectTranscriptEntries, mergePendingEntries } from '../agent/queued-me
  * input / toast stack / status bar / overlays.
  */
 import { useCallback, useEffect, useMemo, useReducer, useRef, useState } from 'react';
-import process from 'node:process';
 import { Text, useApp, useInput, useStdout } from 'ink';
 import { advanceInterruptGesture, cancelInterruptConfirmation, } from '../input/interrupt-gesture.js';
 import { initialViewState, reduceEvent, viewReducer, } from '../agent/reducer.js';
@@ -22,7 +21,7 @@ import { getLogger } from '../logging/logger.js';
 import { isTerminalStatus } from '../proc/types.js';
 import { getSecrets } from '../logging/secret-registry.js';
 import { redactText } from '../logging/redact.js';
-import { detectCapabilities } from './capabilities.js';
+import { resolveTuiCapabilities } from './capabilities.js';
 import { useStartupNotices, MOUSE_NOTICE_VERSION, VT_INPUT_NOTICE_VERSION, } from './use-startup-notices.js';
 import { getTheme } from './theme.js';
 import { pickGlyphs } from './glyphs.js';
@@ -206,13 +205,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     // the completion list are memoized against it, so a skill installed mid-session
     // gets its `/<name>` command and its autocomplete entry immediately.
     const [skillsNonce, setSkillsNonce] = useState(0);
-    const caps = useMemo(() => {
-        const detected = detectCapabilities(process.env, stdout);
-        return {
-            colorLevel: cfg.color === false ? 0 : cfg.colorLevel ?? detected.colorLevel,
-            unicode: cfg.unicode ?? detected.unicode,
-        };
-    }, [cfg.color, cfg.colorLevel, cfg.unicode, stdout]);
+    const caps = useMemo(() => resolveTuiCapabilities({}, cfg.color), [cfg.color]);
     const theme = useMemo(() => getTheme(cfg.theme, caps), [cfg.theme, caps]);
     const glyphs = useMemo(() => pickGlyphs(caps), [caps]);
     const reducedMotion = cfg.reducedMotion ?? false;
@@ -1956,7 +1949,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     // The wordmark + getting-started card now live INSIDE the viewport, as its
     // first block of content, so they scroll away instead of being yanked out of
     // the header the moment the first message lands.
-    const opener = empty ? (_jsx(SessionOpener, { variant: pickOpenerVariant(viewportBudget, contentCols, caps), version: version, cwd: controller.getCwd(), hasKey: hasKey, viewportRows: viewportBudget, theme: theme, caps: caps })) : null;
+    const opener = empty ? (_jsx(SessionOpener, { variant: pickOpenerVariant(viewportBudget, contentCols), version: version, cwd: controller.getCwd(), hasKey: hasKey, viewportRows: viewportBudget, theme: theme, caps: caps })) : null;
     const density = cfg.density;
     const transcriptWindow = cfg.transcriptWindow ?? DEFAULT_TRANSCRIPT_WINDOW;
     // The fixed status bar remains visible underneath every overlay and toast.

package/dist/ui/Logo.d.ts

@@ -19,12 +19,10 @@ export declare function pickHeaderVariant(cols: number): HeaderVariant;
  * now spends the viewport's budget, not the frame's: the test has to be against
  * the account being charged.
  *
- * No hand-drawn ASCII fallback for `art`: figlet-style art is hard to keep
- * column-aligned, and a terminal without Unicode should not be paying six rows
- * for a wordmark in the first place. `banner` still carries the brand there, and
- * the always-present header bar carries it even at `none` (R1).
+ * Color preferences must not change geometry: a monochrome TUI gets the same
+ * wordmark as a colored one when there is room for it.
  */
-export declare function pickOpenerVariant(viewportRows: number, cols: number, caps: TermCapabilities): OpenerVariant;
+export declare function pickOpenerVariant(viewportRows: number, cols: number): OpenerVariant;
 export interface LogoProps {
     /** `art` / `banner` come from `SessionOpener`; `bar` / `mini` from `Header`. */
     variant: HeaderVariant | OpenerVariant;

package/dist/ui/Logo.js

@@ -32,16 +32,12 @@ export function pickHeaderVariant(cols) {
  * now spends the viewport's budget, not the frame's: the test has to be against
  * the account being charged.
  *
- * No hand-drawn ASCII fallback for `art`: figlet-style art is hard to keep
- * column-aligned, and a terminal without Unicode should not be paying six rows
- * for a wordmark in the first place. `banner` still carries the brand there, and
- * the always-present header bar carries it even at `none` (R1).
+ * Color preferences must not change geometry: a monochrome TUI gets the same
+ * wordmark as a colored one when there is room for it.
  */
-export function pickOpenerVariant(viewportRows, cols, caps) {
+export function pickOpenerVariant(viewportRows, cols) {
     if (viewportRows >= ART_MIN_VIEWPORT_ROWS &&
-        cols >= ART_MIN_COLS &&
-        caps.unicode &&
-        caps.colorLevel >= 2) {
+        cols >= ART_MIN_COLS) {
         return 'art';
     }
     if (cols >= BANNER_MIN_COLS)

package/dist/ui/PromptInput.js

@@ -334,7 +334,9 @@ export function PromptInput({ cols: colsProp, cursorVisible = true, onInteractio
         cursor,
         cols: wrapCols,
         maxRows: draftMaxRows(terminalRows),
-        active: isActive && cursorVisible,
+        // Scrolling may hide the caret, but must not change the measured draft.
+        // Otherwise visibility can toggle wrapping and feed back into scrolling.
+        active: isActive,
     });
     // TWO PASSES, AND THE SECOND ONE IS LOAD-BEARING (I-8). The overflow indicator
     // rides the last rendered row INSIDE the box the draft wraps in, so its cells

package/dist/ui/capabilities.d.ts

@@ -22,4 +22,6 @@ interface StdoutLike {
  * for future TTY-aware refinements and kept in the signature for callers.
  */
 export declare function detectCapabilities(env: EnvLike, _stdout?: StdoutLike): TermCapabilities;
+/** Full TUI styling is a policy, not a guess based on inherited shell markers. */
+export declare function resolveTuiCapabilities(env: EnvLike, color?: boolean): TermCapabilities;
 export {};

package/dist/ui/capabilities.js

@@ -57,3 +57,9 @@ export function detectCapabilities(env, _stdout) {
         unicode: detectUnicode(env),
     };
 }
+/** Full TUI styling is a policy, not a guess based on inherited shell markers. */
+export function resolveTuiCapabilities(env, color) {
+    const disabled = color === false || env.NO_COLOR !== undefined ||
+        env.FORCE_COLOR === '0' || env.FORCE_COLOR === 'false';
+    return { unicode: true, colorLevel: disabled ? 0 : 3 };
+}

package/dist/ui/color-runtime.d.ts

@@ -0,0 +1,5 @@
+import type { TermCapabilities } from './capabilities.js';
+/** Highlight cache entries must not cross color preferences between sessions. */
+export declare function syntaxColorLevel(): number;
+/** Apply session colors without changing environment inherited by agent tools. */
+export declare function useTuiColors(level: TermCapabilities['colorLevel']): () => void;

package/dist/ui/color-runtime.js

@@ -0,0 +1,29 @@
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import chalk from 'chalk';
+const require = createRequire(import.meta.url);
+/** Resolve the actual dependency instance even when npm nests its Chalk. */
+async function dependencyChalk(packageName) {
+    const dependency = createRequire(require.resolve(packageName));
+    return (await import(pathToFileURL(dependency.resolve('chalk')).href)).default;
+}
+const [inkChalk, highlightChalk] = await Promise.all([
+    dependencyChalk('ink'), dependencyChalk('cli-highlight'),
+]);
+/** Highlight cache entries must not cross color preferences between sessions. */
+export function syntaxColorLevel() { return highlightChalk.level; }
+/** Apply session colors without changing environment inherited by agent tools. */
+export function useTuiColors(level) {
+    const renderers = new Set([chalk, inkChalk, highlightChalk]);
+    const previous = new Map([...renderers].map(renderer => [renderer, renderer.level]));
+    for (const renderer of renderers)
+        renderer.level = level;
+    let restored = false;
+    return () => {
+        if (restored)
+            return;
+        restored = true;
+        for (const [renderer, original] of previous)
+            renderer.level = original;
+    };
+}

package/dist/ui/glyphs.js

@@ -24,18 +24,20 @@ const UNICODE_GLYPHS = {
     thinking: '✱',
     toolPending: '◦',
     toolRunning: '◍',
-    toolDone: '✔',
-    toolError: '✖',
-    info: 'ℹ',
+    // U+2714 has conflicting emoji widths in Ink and string-width. U+2713 is
+    // consistently one cell, including beside the right-edge scrollbar.
+    toolDone: '✓',
+    toolError: '×',
+    info: 'ⓘ',
     warn: '▲',
-    error: '✖',
+    error: '×',
     bullet: '•',
     spinnerStill: '·',
     gaugeFull: '█',
     gaugeEmpty: '░',
     keyOn: '●',
     keyOff: '○',
-    boxChecked: '☑',
+    boxChecked: '☒',
     boxEmpty: '☐',
     wordmark: '◇',
     ellipsis: '…',
@@ -60,10 +62,10 @@ const UNICODE_GLYPHS = {
     maskDot: '•',
     boxStyle: 'round',
     teamAgent: '◆',
-    teamMail: '✉',
+    teamMail: '⇄',
     todoPending: '○',
     todoActive: '▸',
-    todoDone: '✔',
+    todoDone: '✓',
     retry: '↻',
     compaction: '⤓',
     queued: '◷',
@@ -78,7 +80,7 @@ const UNICODE_GLYPHS = {
         ask_user: '?',
         submit_plan: '◈',
         task: '◆',
-        todo_write: '☰',
+        todo_write: '≡',
     },
     toolDefault: '•',
 };

package/dist/ui/ink-runtime.d.ts

@@ -1 +1,4 @@
+import type { TermCapabilities } from './capabilities.js';
 export declare const render: (node: import("react").ReactNode, options?: NodeJS.WriteStream | import("ink").RenderOptions) => import("ink").Instance;
+/** Mount the TUI with its resolved colors, restoring all renderers on exit. */
+export declare function renderTui(node: Parameters<typeof render>[0], options: Parameters<typeof render>[1], caps: TermCapabilities): ReturnType<typeof render>;

package/dist/ui/ink-runtime.js

@@ -19,3 +19,33 @@ async function loadInk() {
     }
 }
 export const { render } = await loadInk();
+// Keep asynchronous dependency resolution after Ink's CI initialization. A
+// static import here would let sibling UI modules load Ink before CI is reset.
+const { useTuiColors } = await import('./color-runtime.js');
+/** Mount the TUI with its resolved colors, restoring all renderers on exit. */
+export function renderTui(node, options, caps) {
+    const restore = useTuiColors(caps.colorLevel);
+    try {
+        // Ink creates its exit promise lazily and does not replay earlier exits.
+        // Mount the host first, then subscribe before application render or layout
+        // effects can fail or call useApp().exit().
+        const instance = render(null, options);
+        void instance.waitUntilExit().then(restore, restore);
+        instance.rerender(node);
+        return {
+            ...instance,
+            unmount() {
+                try {
+                    instance.unmount();
+                }
+                finally {
+                    restore();
+                }
+            },
+        };
+    }
+    catch (error) {
+        restore();
+        throw error;
+    }
+}

package/dist/ui/layout/status-layout.js

@@ -41,7 +41,8 @@ function contextText(context, detail = false, exponent = false) {
         return copy.contextUnknown;
     const number = exponent ? scientific : detail ? formatTokens : compactNumber;
     const approximate = context.source === 'estimate' || context.deltaTokens > 0 ? '~' : '';
-    return `${copy.context} ${approximate}${number(context.occupied)}/${number(context.window)}${context.windowKnown ? '' : '?'} ${detail ? 'tokens' : 'tok'}`;
+    const limit = context.windowKnown ? number(context.window) : '?';
+    return `${copy.context} ${approximate}${number(context.occupied)}/${limit} ${detail ? 'tokens' : 'tok'}`;
 }
 function secondaryFields(input) {
     const list = [];
@@ -60,7 +61,7 @@ function secondaryFields(input) {
     if (input.thinkingLevel !== 'off')
         list.push(field('thinking', `think:${cleanStatusText(input.thinkingLevel)}`));
     list.push(field('usage', `${copy.sessionInput} ${compactNumber(promptTokensOf(input.usageTotal))} ${copy.output} ${compactNumber(input.usageTotal.outputTokens)} tok`));
-    if (Number.isFinite(input.context.pct))
+    if (input.context.windowKnown && Number.isFinite(input.context.pct))
         list.push(field('percentage', `${input.context.source === 'estimate' || input.context.deltaTokens > 0 || !input.context.windowKnown ? '~' : ''}${Math.round(input.context.pct)}%`));
     if (input.ecoRung)
         list.push(field('eco', 'eco'));

package/dist/ui/render-cache.d.ts

@@ -12,7 +12,7 @@
  *   - `Markdown` re-split and re-regexed the whole answer into one React element
  *     per line on every render.
  *
- * Everything cached here is a function of its INPUT STRING ALONE. Theme and
+ * Cached text depends on its input and, for highlighting, the color level. Theme and
  * glyphs are applied at render time and are never cached, because a themed
  * React element in a cache makes `/theme` a no-op until the entry evicts (K-5) —
  * exactly the class of silent bug this package writes comments to avoid.
@@ -50,7 +50,7 @@ export interface RenderCacheStats {
     misses: number;
 }
 /**
- * Syntax-highlight `code`, memoised on `(lang, code)`.
+ * Syntax-highlight `code`, memoised on `(colorLevel, lang, code)`.
  *
  * `cli-highlight` emits chalk-level ANSI that does not depend on `theme.*`, so
  * unlike a rendered element this string IS safe to cache across a `/theme`

package/dist/ui/render-cache.js

@@ -12,7 +12,7 @@
  *   - `Markdown` re-split and re-regexed the whole answer into one React element
  *     per line on every render.
  *
- * Everything cached here is a function of its INPUT STRING ALONE. Theme and
+ * Cached text depends on its input and, for highlighting, the color level. Theme and
  * glyphs are applied at render time and are never cached, because a themed
  * React element in a cache makes `/theme` a no-op until the entry evicts (K-5) —
  * exactly the class of silent bug this package writes comments to avoid.
@@ -22,6 +22,7 @@
  * caches would miss precisely when a scroll brings an old entry back.
  */
 import { highlight } from 'cli-highlight';
+import { syntaxColorLevel } from './color-runtime.js';
 import { parseMarkdownBlocks } from './markdown-blocks.js';
 import { pickGlyphs } from './glyphs.js';
 export const RENDER_CACHE_LIMITS = {
@@ -113,7 +114,7 @@ const markdownCache = new LruCache(RENDER_CACHE_LIMITS.markdownEntries, RENDER_C
  */
 const lineCache = new LruCache(RENDER_CACHE_LIMITS.linesEntries, RENDER_CACHE_LIMITS.markdownBytes);
 /**
- * Syntax-highlight `code`, memoised on `(lang, code)`.
+ * Syntax-highlight `code`, memoised on `(colorLevel, lang, code)`.
  *
  * `cli-highlight` emits chalk-level ANSI that does not depend on `theme.*`, so
  * unlike a rendered element this string IS safe to cache across a `/theme`
@@ -129,7 +130,7 @@ export function highlightCached(code, lang) {
     // ripgrep, which silently hides every definition in it from the tool this
     // codebase navigates itself with. NUL rather than a space because a space
     // still lets ("a b", "ts") and ("b", "ts a") collide on one key.
-    const key = `${lang}\u0000${code}`;
+    const key = `${syntaxColorLevel()}\u0000${lang}\u0000${code}`;
     const hit = highlightCache.get(key);
     if (hit !== undefined)
         return hit;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aragon-agent/cli",
-  "version": "0.6.13",
+  "version": "0.6.14",
   "description": "AragonAgent CLI — a Claude-Code / Codex-style interactive terminal UI (TUI) on top of the @aragon-agent/core engine. Installable and runnable via npm / npx.",
   "license": "MIT",
   "author": "AragonAgent contributors",
@@ -56,7 +56,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@aragon-agent/core": "^0.2.25",
+    "@aragon-agent/core": "^0.2.26",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",