@aragon-agent/cli 0.6.12 → 0.6.14

package/dist/commands/builtins.js

@@ -4,6 +4,7 @@
  * /resume /copy /terminal-setup /exit (/quit), plus the /team, /fast and
  * /todo subsystems.
  */
+import { modelSettingsResultMessage } from '../agent/model-profile-settings.js';
 import { existsSync, statSync } from 'node:fs';
 import { isAbsolute, resolve } from 'node:path';
 import { resolveOutputTokens } from '@aragon-agent/core';
@@ -13,10 +14,9 @@ import { mergePendingEntries } from '../agent/queued-messages.js';
 import { TODO_FOLLOW_LIMITS } from '../todo/limits.js';
 import { buildContinuationMessage } from '../todo/follow-through.js';
 import { MODE_LABEL, nextMode } from '../agent/agent-mode.js';
-import { loadConfig } from '../config/load.js';
 import { loadSession, resolveSessionPath, saveSession } from '../session/persist.js';
 import { getLogger } from '../logging/logger.js';
-import { copyText } from '../ui/clipboard.js';
+import { registerQueueCommand } from './queue-command.js';
 import { perfCommand } from './perf.js';
 import { runCompactCommand } from '../compaction/command.js';
 import { runContextCommand } from '../compaction/context-command.js';
@@ -371,8 +371,16 @@ const COMMANDS = [
                 return;
             }
             const persist = (patch) => {
-                controller.setFastConfig(patch);
-                ctx.persistConfig({ fast: patch });
+                const connection = ['provider', 'model', 'baseUrl'].some((key) => key in patch);
+                if (!connection) {
+                    controller.setFastConfig(patch);
+                    ctx.persistConfig({ fast: patch });
+                    return true;
+                }
+                const result = controller.saveModelSettingsPatch({ fast: patch });
+                if (!result.ok)
+                    ctx.notify('warn', modelSettingsResultMessage(result));
+                return result.ok;
             };
             if (!verb || verb === 'status') {
                 ctx.notify('info', formatFastStatus(controller));
@@ -380,7 +388,8 @@ const COMMANDS = [
             }
             if (verb === 'on' || verb === 'off') {
                 const enabled = verb === 'on';
-                persist({ enabled });
+                if (!persist({ enabled }))
+                    return;
                 if (!controller.isFastRegistered()) {
                     // The honest branch, and the whole point of splitting by what was
                     // decided at construction (§3.3). It is one sentence, and it keeps
@@ -414,11 +423,13 @@ const COMMANDS = [
                         ctx.notify('warn', `Unknown provider "${provider}". Choose: ${ADAPTER_PROVIDERS.join(', ')}.`);
                         return;
                     }
-                    persist({ provider, model });
+                    if (!persist({ provider, model }))
+                        return;
                     ctx.toast('success', `Fast model set to ${provider}:${model}.`);
                     return;
                 }
-                persist({ model: raw });
+                if (!persist({ model: raw }))
+                    return;
                 ctx.toast('success', `Fast model set to ${raw}.`);
                 return;
             }
@@ -432,7 +443,8 @@ const COMMANDS = [
                     ctx.notify('warn', `Unknown provider "${raw}". Choose: ${ADAPTER_PROVIDERS.join(', ')}.`);
                     return;
                 }
-                persist({ provider: raw });
+                if (!persist({ provider: raw }))
+                    return;
                 ctx.toast('success', `Fast provider set to ${raw}.`);
                 return;
             }
@@ -441,18 +453,20 @@ const COMMANDS = [
                 // (R-13): the user is allowed to run both tiers on one model, and the
                 // review still costs what it costs.
                 const cfg = controller.getConfig();
-                persist({
+                if (!persist({
                     provider: cfg.provider,
                     model: cfg.model,
                     baseUrl: cfg.baseUrl ?? '',
-                });
+                }))
+                    return;
                 ctx.toast('success', `Fast tier set to ${cfg.provider}:${cfg.model} (same as main).`);
                 return;
             }
             if (verb === 'review') {
                 const raw = (value ?? '').trim().toLowerCase();
                 if (raw === 'off') {
-                    persist({ review: false });
+                    if (!persist({ review: false }))
+                        return;
                     ctx.toast('success', 'Fast review off.');
                     return;
                 }
@@ -508,7 +522,8 @@ const COMMANDS = [
                     ctx.notify('warn', 'Usage: /fast delegate <on|off>');
                     return;
                 }
-                persist({ delegate: raw === 'on' });
+                if (!persist({ delegate: raw === 'on' }))
+                    return;
                 ctx.toast('success', `Fast delegation ${raw}.`);
                 return;
             }
@@ -891,6 +906,8 @@ const COMMANDS = [
             ctx.controller.clearAllQueues();
             ctx.dispatch({ type: 'resetConversation' });
             ctx.toast('info', 'Started a new conversation.');
+            if (ctx.state.pendingSteering.length)
+                ctx.notify('warn', `\u5df2\u53d6\u6d88 ${ctx.state.pendingSteering.length} \u6761\u672a\u63a5\u6536\u6d88\u606f`);
         },
     },
     {
@@ -941,15 +958,15 @@ const COMMANDS = [
         name: 'resume',
         description: 'Load a saved session',
         run: (ctx) => {
-            if (ctx.controller.isRunning()) {
-                ctx.notify('warn', 'Cannot resume while the agent is running. Wait for it to stop.');
+            if (ctx.controller.isRunning() || ctx.controller.isModelSettingsBusy?.()) {
+                ctx.notify('warn', 'Cannot resume while running work, team, review, or compaction is busy.');
                 return;
             }
             try {
                 const path = resolveSessionPath(ctx.args, ctx.controller.getCwd());
                 const session = loadSession(path);
-                if (ctx.controller.isRunning()) {
-                    ctx.notify('warn', 'Cannot resume while the agent is running. Wait for it to stop.');
+                if (ctx.controller.isRunning() || ctx.controller.isModelSettingsBusy?.()) {
+                    ctx.notify('warn', 'Cannot resume while running work, team, review, or compaction is busy.');
                     return;
                 }
                 // Loading has validated and normalized every external value. Commit
@@ -963,6 +980,8 @@ const COMMANDS = [
                     ctx.controller.setModel(session.model.providerId, session.model.modelId, session.model.baseUrl);
                 }
                 ctx.notify('info', `Resumed session from ${path}`);
+                if (ctx.state.pendingSteering.length)
+                    ctx.notify('warn', `\u5df2\u53d6\u6d88 ${ctx.state.pendingSteering.length} \u6761\u672a\u63a5\u6536\u6d88\u606f`);
             }
             catch (err) {
                 ctx.notify('error', `Resume failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -972,7 +991,7 @@ const COMMANDS = [
     {
         name: 'copy',
         description: 'Copy the last answer to the clipboard',
-        run: (ctx) => {
+        run: async (ctx) => {
             const last = [...ctx.state.entries].reverse().find((e) => e.kind === 'assistant');
             if (!last || last.kind !== 'assistant' || last.text.trim().length === 0) {
                 ctx.notify('warn', 'No assistant message to copy.');
@@ -984,15 +1003,11 @@ const COMMANDS = [
             // which the local `pbcopy` never could.
             //
             // `ctx.writeForeign` and not `stdout.write` — see the field's comment.
-            const via = copyText(last.text, ctx.writeForeign);
-            if (via === 'none') {
-                ctx.toast('warn', 'Clipboard not available.');
+            if (!ctx.requestCopy) {
+                ctx.notify('warn', 'Clipboard coordinator unavailable.');
                 return;
             }
-            // NAMES THE MECHANISM RATHER THAN CLAIMING SUCCESS: neither path is
-            // detectable, and tmux without `set -g set-clipboard on` swallows OSC 52
-            // silently (R-7).
-            ctx.toast('success', via === 'osc52' ? 'Sent to the terminal clipboard.' : 'Sent to the system clipboard.');
+            await ctx.requestCopy({ text: last.text, lines: last.text.split('\n').length });
         },
     },
     {
@@ -1053,20 +1068,24 @@ const COMMANDS = [
             const lines = [
                 'Shift+Enter newline - terminal setup',
                 '',
-                'Ctrl+J and Alt+Enter insert a newline in every terminal, with no',
-                'setup. To get a dedicated Shift+Enter key, make the terminal send',
+                'Ctrl+J inserts a newline when delivered; Alt+Enter may be intercepted.',
+                'To get a dedicated Shift+Enter key, make the terminal send',
                 'the CSI-u sequence \\u001b[13;2u for it:',
                 '',
-                '  Windows Terminal  settings.json, actions array:',
-                '    { "keys": "shift+enter", "command": { "action": "sendInput",',
-                '      "input": "\\u001b[13;2u" } }',
+                '  Windows Terminal settings.json, merge root-level arrays:',
+                '    "copyOnSelect": false,',
+                '    "actions": [{ "id": "User.AragonNewline", "command":',
+                '      { "action": "sendInput", "input": "\\u001b[13;2u" } }],',
+                '    "keybindings": [{ "keys": "shift+enter", "id": "User.AragonNewline" }]',
                 '    PowerShell runs inside the terminal; configure this binding in',
                 '    Windows Terminal, not in the PowerShell profile. If both keys',
                 '    send CR, the application cannot distinguish Shift+Enter from Enter.',
                 '  VS Code terminal  keybindings.json:',
                 '    { "key": "shift+enter",',
                 '      "command": "workbench.action.terminal.sendSequence",',
+                '      "when": "terminalFocus",',
                 '      "args": { "text": "\\u001b[13;2u" } }',
+                '    User settings: "terminal.integrated.copyOnSelection": false',
                 '  iTerm2            Settings > Profiles > Keys > Key Mappings:',
                 '    Shift+Enter -> Send Escape Sequence: [13;2u',
                 '  kitty/WezTerm/foot  native once keyboard enhancement is on',
@@ -1077,6 +1096,13 @@ const COMMANDS = [
                 '    or Alt+Enter',
                 '',
                 'This command only prints advice; it changes no terminal modes.',
+                'Host selections (Shift+drag or /mouse off) belong to the terminal.',
+                'App selections wait for Ctrl+C; only a native tool exit confirms copying.',
+                'SSH uses OSC 52: the terminal may deny it; sent does not mean confirmed.',
+                'Without the stdin filter, Delete falls back to Backspace.',
+                'Without paste support, multiline paste cannot be guaranteed safe.',
+                'IME confirmation has no composition signal in PTY bytes. If it emits CR,',
+                'edit externally and use bracketed paste; this host combination needs validation.',
             ];
             ctx.notify('info', lines.join('\n'));
         },
@@ -1104,12 +1130,12 @@ const COMMANDS = [
                 ctx.notify('warn', 'Cannot reload the config while a run is in progress.');
                 return;
             }
-            const config = loadConfig({ cwd: ctx.controller.getCwd() });
-            ctx.controller.setModel(config.provider, config.model, config.baseUrl);
-            ctx.controller.setThinkingLevel(config.thinkingLevel);
-            ctx.controller.setMaxTokens(config.maxTokens);
-            ctx.controller.setTheme(config.theme);
-            getLogger().reconfigure(config.log);
+            const result = ctx.controller.reloadModelSettings();
+            if (!result.ok) {
+                ctx.notify('warn', modelSettingsResultMessage(result));
+                return;
+            }
+            const config = ctx.controller.getConfig();
             getLogger().info('config', 'reload', { provider: config.provider, model: config.model });
             ctx.toast('success', `Reloaded config: ${config.provider}:${config.model}.`);
         },
@@ -1219,6 +1245,7 @@ const DEFAULT_BG_LOG_ROWS = 40;
 export function registerBuiltinCommands(registry) {
     for (const command of COMMANDS)
         registry.register(command);
+    registerQueueCommand(registry);
 }
 /**
  * Every built-in command name INCLUDING aliases (`quit`), for documentation and
@@ -1228,10 +1255,10 @@ export function registerBuiltinCommands(registry) {
  * `registry.get(name)` instead, because that is the only check that stays
  * correct when commands are registered dynamically (§7.1 / P1-2).
  */
-export const BUILTIN_COMMAND_NAMES = COMMANDS.flatMap((c) => [
-    c.name,
-    ...(c.aliases ?? []),
-]).sort();
+export const BUILTIN_COMMAND_NAMES = ['queue', ...COMMANDS.flatMap((c) => [
+        c.name,
+        ...(c.aliases ?? []),
+    ])].sort();
 // The `copyToClipboard` helper that used to live here moved into
 // `ui/clipboard.ts` (tui-selection-and-scroll-follow §4.4.5), unchanged, so that
 // `/copy` and the drag-select release share ONE clipboard path instead of two

package/dist/commands/queue-command.d.ts

@@ -0,0 +1,3 @@
+import type { CommandRegistry } from './registry.js';
+/** Read-only access to the live receipt-backed queue through the standard overlay port. */
+export declare function registerQueueCommand(registry: CommandRegistry): void;

package/dist/commands/queue-command.js

@@ -0,0 +1,5 @@
+/** Read-only access to the live receipt-backed queue through the standard overlay port. */
+export function registerQueueCommand(registry) {
+    registry.register({ name: 'queue', description: '\u67e5\u770b\u5f85\u5904\u7406\u6d88\u606f\u5168\u6587',
+        run: (ctx) => { ctx.setOverlay('queue'); } });
+}

package/dist/commands/registry.d.ts

@@ -3,6 +3,7 @@
  * input is routed here instead of to the agent; `//` is the literal-`/` escape.
  */
 import type { SubmitMessageOptions } from '../agent/prompt-options.js';
+import type { CopyRequest, CopyRequestResult } from '../ui/clipboard-task.js';
 import type { AgentController } from '../agent/controller.js';
 import type { AgentMode } from '../agent/agent-mode.js';
 import type { NoticeLevel, Overlay, ToastLevel, ViewAction, ViewState } from '../agent/reducer.js';
@@ -10,6 +11,8 @@ import type { PersistedConfig } from '../config/schema.js';
 import type { FollowThroughBudget } from '../todo/follow-through.js';
 import type { UpdateCommandPort } from '../update/types.js';
 export interface CommandContext {
+    /** App-owned shared lock and single feedback path for command and selection copies. */
+    requestCopy?: (request: CopyRequest) => Promise<CopyRequestResult>;
     /** Raw argument string after the command word (may be empty). */
     args: string;
     controller: AgentController;

package/dist/compaction/child.d.ts

@@ -28,13 +28,14 @@
  * lead's own history had been compacted. The team panel row and the dispatch
  * report are where a child's internals belong.
  */
+import type { ModelRole } from '../config/model-profiles.js';
 import type { AssistantMessage, ContextManager, LLMRequest, Message, ModelInfo, ModelRef, TokenUsage } from '@aragon-agent/core';
 import type { CliConfig } from '../config/schema.js';
 export interface ChildCompactionDeps {
     /** Read LIVE on every call - see `childConfig` below. */
     getConfig: () => CliConfig;
-    hasKey: (providerId: string) => boolean;
-    getApiKey: (providerId: string) => string | undefined;
+    hasKey: (providerId: string, role?: ModelRole) => boolean;
+    getApiKey: (providerId: string, role?: ModelRole) => string | undefined;
     getModelInfoFor: (ref: Pick<ModelRef, 'providerId' | 'modelId'>) => ModelInfo;
     isPricedModel: (ref: Pick<ModelRef, 'providerId' | 'modelId'>) => boolean;
     /** The lead wiring's own transport, reused (D-10 stays true). */
@@ -50,6 +51,7 @@ export interface ChildCompactionDeps {
  * exactly on the cap.
  */
 export interface ChildContextManagerRequest {
+    role?: ModelRole;
     label: string;
     /**
      * The model the child actually runs on.

package/dist/compaction/child.js

@@ -28,6 +28,7 @@
  * lead's own history had been compacted. The team panel row and the dispatch
  * report are where a child's internals belong.
  */
+import { resolveFastTier } from '../fast/resolve.js';
 import { getLogger } from '../logging/logger.js';
 import { Compactor } from './compactor.js';
 import { COMPACTION_LIMITS } from './limits.js';
@@ -52,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,
-            ...(req.model.baseUrl !== undefined ? { baseUrl: req.model.baseUrl } : {}),
+            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,
@@ -71,6 +76,8 @@ export function createChildContextManager(req, deps) {
     };
     const compactor = new Compactor({
         getConfig: childConfig,
+        mainRole: req.role ?? 'main',
+        resolveFastCandidate: () => resolveFastTier(deps.getConfig(), deps.hasKey),
         hasKey: deps.hasKey,
         getApiKey: deps.getApiKey,
         getModelInfoFor: deps.getModelInfoFor,

package/dist/compaction/compactor.d.ts

@@ -9,16 +9,20 @@
  * keep, which model summarizes, what the prompt asks for, what happens when the
  * call fails, and when to stop spending.
  */
+import type { ModelRole } from '../config/model-profiles.js';
 import { type Message, type ModelInfo, type ModelRef, type TokenUsage, type AssistantMessage, type CompactionContext, type CompactionOutcome, type CompactionProbe, type ContextManager, type LLMRequest } from '@aragon-agent/core';
 import type { CliConfig } from '../config/schema.js';
 import type { NoticeLevel } from '../agent/reducer.js';
+import { resolveFastTier } from '../fast/resolve.js';
 import { ContextMeter } from './meter.js';
 import type { CompactionEvent, Pressure } from './types.js';
 export interface CompactorDeps {
+    mainRole?: ModelRole;
+    resolveFastCandidate?: () => ReturnType<typeof resolveFastTier>;
     /** Read LIVE on every call — the controller replaces the object on mutation. */
     getConfig: () => CliConfig;
-    hasKey: (providerId: string) => boolean;
-    getApiKey: (providerId: string) => string | undefined;
+    hasKey: (providerId: string, role?: ModelRole) => boolean;
+    getApiKey: (providerId: string, role?: ModelRole) => string | undefined;
     /**
      * The engine's live history and system prompt.
      *
@@ -87,6 +91,7 @@ export interface CompactorOptions {
 }
 /** The summarizer the next compaction would use. */
 export interface SummarizerChoice {
+    role: ModelRole;
     ref: ModelRef;
     /** Whether the fast tier supplied it, for `/compact status` and the card. */
     fromFastTier: boolean;

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),
@@ -486,20 +486,22 @@ export class Compactor {
         const { summarizer } = args;
         if (!summarizer)
             return { kind: 'failed', reason: 'no_summarizer_model' };
-        const first = await this.callOnce(summarizer.ref, args);
+        const first = await this.callOnce(summarizer, args);
         if (first.kind === 'ok' || first.kind === 'aborted')
             return first;
         // Rung 2 — retry, on the MAIN model when rung 1 was the fast tier.
-        const mainRef = this.mainRef();
-        const retryRef = summarizer.fromFastTier && mainRef.modelId !== summarizer.ref.modelId ? mainRef : summarizer.ref;
-        this.log.warn('summarize_retry', { reason: first.reason, model: retryRef.modelId });
-        const second = await this.callOnce(retryRef, args);
+        const retryChoice = summarizer.fromFastTier
+            ? { ref: this.mainRef(), role: this.deps.mainRole ?? 'main', fromFastTier: false }
+            : summarizer;
+        this.log.warn('summarize_retry', { reason: first.reason, model: retryChoice.ref.modelId });
+        const second = await this.callOnce(retryChoice, args);
         if (second.kind === 'ok' || second.kind === 'aborted')
             return second;
         return { kind: 'failed', reason: second.reason };
     }
-    async callOnce(ref, args) {
-        const apiKey = this.deps.getApiKey(ref.providerId);
+    async callOnce(choice, args) {
+        const { ref, role } = choice;
+        const apiKey = this.deps.getApiKey(ref.providerId, role);
         if (!apiKey)
             return { kind: 'failed', reason: 'no_api_key' };
         if (args.ctx.signal.aborted)
@@ -567,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
@@ -576,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;
@@ -764,14 +766,14 @@ export class Compactor {
     resolveSummarizer() {
         const config = this.deps.getConfig();
         if (config.compaction.useFastTier) {
-            const tier = resolveFastTier(config, this.deps.hasKey);
+            const tier = this.deps.resolveFastCandidate?.() ?? resolveFastTier(config, this.deps.hasKey);
             if (tier.ok)
-                return { ref: tier.ref, fromFastTier: true };
+                return { ref: tier.ref, role: 'fast', fromFastTier: true };
         }
         const ref = this.mainRef();
-        if (!this.deps.hasKey(ref.providerId))
+        if (!this.deps.hasKey(ref.providerId, this.deps.mainRole ?? 'main'))
             return null;
-        return { ref, fromFastTier: false };
+        return { ref, role: this.deps.mainRole ?? 'main', fromFastTier: false };
     }
     /**
      * The meter this compactor reads, injected or private (R-1).
@@ -790,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

@@ -45,6 +45,11 @@ export function formatContextReport(ctx) {
     // one line and answers the same question.
     lines.push('                 includes subagent, fast-tier and compaction spend,');
     lines.push('                 not just this conversation');
+    lines.push('  Scope          lead occupancy is used / limit in tokens; session input includes caches.');
+    lines.push('  Estimate       USD session cost, including restored usage; missing prices count as 0.');
+    lines.push('                 Zero estimated cost does not guarantee free usage or match the bill.');
+    lines.push('  Run average    booked output-token delta / elapsed time, not instantaneous generation.');
+    lines.push('                 May include team, fast-tier and compaction output booked during this run.');
     return lines.join('\n');
 }
 /**
@@ -64,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}`;
 }
 /**
@@ -78,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.d.ts

@@ -35,6 +35,7 @@
  * guard is now unreachable for declines and stays for the abort race it was
  * written for.
  */
+import type { ModelRole } from '../config/model-profiles.js';
 import { type AgentEvent, type ContextManager, type Message, type ModelInfo, type ModelRef, type ProviderRegistry, type ProviderRegistryOptions, type TokenUsage } from '@aragon-agent/core';
 import type { CliConfig } from '../config/schema.js';
 import type { NoticeLevel } from '../agent/reducer.js';
@@ -44,8 +45,8 @@ import type { CompactionEventListener, CompactionSnapshot } from './types.js';
 export interface CompactionWiringDeps {
     /** Read LIVE on every call - the controller replaces the object on mutation. */
     getConfig: () => CliConfig;
-    hasKey: (providerId: string) => boolean;
-    getApiKey: (providerId: string) => string | undefined;
+    hasKey: (providerId: string, role?: ModelRole) => boolean;
+    getApiKey: (providerId: string, role?: ModelRole) => string | undefined;
     getModelInfoFor: (ref: Pick<ModelRef, 'providerId' | 'modelId'>) => ModelInfo;
     isPricedModel: (ref: Pick<ModelRef, 'providerId' | 'modelId'>) => boolean;
     /**
@@ -158,7 +159,7 @@ export declare class CompactionWiring {
     isEnabled(): boolean;
     setEnabled(enabled: boolean): void;
     /** Re-emit the snapshot after any config mutation, so the chip and the gauge move. */
-    onConfigChanged(): void;
+    onConfigChanged(enabled?: boolean): void;
     abort(): void;
     /**
      * The host replaced or cleared the history (hardening §3.2.3, sites 3 and 4).

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({
@@ -209,7 +212,12 @@ export class CompactionWiring {
         this.emit({ type: 'snapshot', snapshot: this.snapshot() });
     }
     /** Re-emit the snapshot after any config mutation, so the chip and the gauge move. */
-    onConfigChanged() {
+    onConfigChanged(enabled) {
+        if (enabled !== undefined && enabled !== this.enabled) {
+            this.enabled = enabled;
+            if (enabled)
+                this.compactor.clearSelfDisable();
+        }
         this.emit({ type: 'snapshot', snapshot: this.snapshot() });
     }
     abort() {

package/dist/config/cli-commands.d.ts

@@ -168,6 +168,8 @@ export declare function applyCompactionConfigSet(key: string, value: string): Pa
  * later pastes a log into an issue.
  */
 export declare function warnIfRedactionDisabled(key: string, value: string): void;
+/** Every secret is masked wherever it is printed, `--json` included (R-12). */
+export declare function maskConfig(config: PersistedConfig): Record<string, unknown>;
 export declare function runConfigGet(key: string): void;
 export declare function runConfigList(opts?: {
     json?: boolean;