@aragon-agent/cli 0.6.12 → 0.6.13

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';
@@ -56,7 +57,7 @@ export function createChildContextManager(req, deps) {
             ...base,
             provider: req.model.providerId,
             model: req.model.modelId,
-            ...(req.model.baseUrl !== undefined ? { baseUrl: req.model.baseUrl } : {}),
+            baseUrl: req.model.baseUrl,
             compaction: {
                 ...base.compaction,
                 keepRecentTurns: COMPACTION_LIMITS.childKeepRecentTurns,
@@ -71,6 +72,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

@@ -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)
@@ -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).

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');
 }
 /**

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

@@ -209,7 +209,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;

package/dist/config/cli-commands.js

@@ -13,6 +13,7 @@ import process from 'node:process';
 import { getConfigBackupPath, getConfigPath, getHomeRoot, getLogsDir, getPromptHistoryPath, getUiStatePath, isHomeOverridden, } from './app-paths.js';
 import { getHomeMigrationBreadcrumbPath } from './migrate-home.js';
 import { loadPersistedConfig, updatePersistedConfig } from './store.js';
+import { normalizeModelProfiles, validateModelProfiles } from './model-profiles.js';
 import { clampFastConfig, clampRetryConfig, clampCompactionConfig, parseThresholdInput, clampUpdateConfig, coercePositiveInt, maskSecret, DEFAULT_FAST_CONFIG, DEFAULT_RETRY_CONFIG, DEFAULT_TEAM_CONFIG, DEFAULT_COMPACTION_CONFIG, DEFAULT_UPDATE_CONFIG, } from './schema.js';
 import { clampLogLevel } from '../logging/levels.js';
 /** Config keys under `log.` that `aragon config set` accepts. */
@@ -386,12 +387,23 @@ export function warnIfRedactionDisabled(key, value) {
 // get / list
 // ---------------------------------------------------------------------------
 /** Every secret is masked wherever it is printed, `--json` included (R-12). */
-function maskConfig(config) {
+export function maskConfig(config) {
     const apiKeys = {};
     for (const [provider, key] of Object.entries(config.apiKeys)) {
         apiKeys[provider] = maskSecret(key);
     }
-    return { ...config, apiKeys };
+    const masked = { ...config, apiKeys };
+    if (config.modelProfiles !== undefined) {
+        if (validateModelProfiles(config.modelProfiles).length)
+            masked.modelProfiles = { invalid: true };
+        else {
+            const profiles = normalizeModelProfiles(config.modelProfiles);
+            masked.modelProfiles = { ...profiles, entries: profiles.entries.map((entry) => ({
+                    ...entry, apiKey: entry.apiKey ? 'Configured' : 'Missing',
+                })) };
+        }
+    }
+    return masked;
 }
 /**
  * The human-readable label for a value whose raw form would mislead, or
@@ -503,8 +515,8 @@ export async function runConfigEdit() {
         JSON.parse(readFileSync(file, 'utf-8'));
         process.stdout.write(`${file} saved.\n`);
     }
-    catch (err) {
-        process.stderr.write(`${file} is not valid JSON (${err instanceof Error ? err.message : String(err)}).\n` +
+    catch {
+        process.stderr.write(`${file} is not valid JSON.\n` +
             `The previous version is still at ${backup}.\n`);
         process.exitCode = 1;
     }

package/dist/config/load.d.ts

@@ -6,6 +6,7 @@
  * legitimately long single tool run can never be watchdog-killed.
  */
 import { type CliConfig } from './schema.js';
+import type { ModelRole } from './model-profiles.js';
 export interface CliFlags {
     provider?: string;
     model?: string;
@@ -245,4 +246,4 @@ export declare function loadConfig(flags?: CliFlags): CliConfig;
  * Build the `getApiKey(providerId)` resolver the core `Agent` consumes.
  * The one-shot `--api-key` override wins, but only for the active provider.
  */
-export declare function makeGetApiKey(config: CliConfig): (providerId: string) => string | undefined;
+export declare function makeGetApiKey(config: CliConfig, role?: ModelRole): (providerId: string) => string | undefined;

package/dist/config/load.js

@@ -9,6 +9,7 @@ import process from 'node:process';
 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 { projectModelProfiles, resolveModelProfileState, resolveModelRoleKey } from './model-profile-resolution.js';
 import { getConfigPath } from './app-paths.js';
 import { setHistoryEnabled } from './prompt-history.js';
 import { setEntryRetain } from '../agent/entry-limits.js';
@@ -440,11 +441,17 @@ export function loadConfig(flags = {}) {
     // `.env` must be loaded before reading env overrides.
     loadDotenv(cwd);
     const read = readConfigFile();
-    const file = read.config ?? {};
+    const projection = projectModelProfiles(read.config ?? {});
+    const file = projection.file;
     const env = readEnvConfig();
     if (read.parseError) {
         getLogger().error('config', 'config_parse_failed', { error: read.parseError });
     }
+    if (projection.issues.length) {
+        getLogger().warn('config', 'model_profiles_invalid', {
+            error: 'Invalid model profiles; using custom connections. Repair with aragon config edit.',
+        });
+    }
     const provider = pick(flags.provider, env.partial.provider, file.provider) ?? DEFAULT_CONFIG.provider;
     const model = pick(flags.model, env.partial.model, file.model) ?? DEFAULT_CONFIG.model;
     const baseUrl = pick(flags.baseUrl, env.partial.baseUrl ?? undefined, file.baseUrl ?? undefined);
@@ -543,6 +550,7 @@ export function loadConfig(flags = {}) {
     // it through the same module-singleton channel `setHistoryEnabled` uses.
     setEntryRetain(transcriptRetain);
     const config = {
+        modelProfiles: projection.issues.length ? undefined : file.modelProfiles,
         provider,
         model,
         baseUrl,
@@ -605,6 +613,10 @@ export function loadConfig(flags = {}) {
         unicode: caps.unicode,
         apiKeyOverride: flags.apiKey && flags.apiKey.trim().length > 0 ? flags.apiKey.trim() : undefined,
     };
+    config.modelProfileState = resolveModelProfileState(config, config.modelProfiles, projection.issues.length > 0);
+    if (config.apiKeyOverride && (config.modelProfiles?.mainId || config.modelProfiles?.fastId)) {
+        config.apiKeyOverrideTarget = { provider, baseUrl: baseUrl?.trim() || null };
+    }
     recordResolvedConfig(config);
     return config;
 }
@@ -646,11 +658,6 @@ function recordResolvedConfig(config) {
  * Build the `getApiKey(providerId)` resolver the core `Agent` consumes.
  * The one-shot `--api-key` override wins, but only for the active provider.
  */
-export function makeGetApiKey(config) {
-    return (providerId) => {
-        if (config.apiKeyOverride && providerId === config.provider) {
-            return config.apiKeyOverride;
-        }
-        return config.apiKeys[providerId];
-    };
+export function makeGetApiKey(config, role = 'main') {
+    return (providerId) => resolveModelRoleKey({ config, role, providerId });
 }

package/dist/config/model-profile-resolution.d.ts

@@ -0,0 +1,20 @@
+import { type CliConfig, type PersistedConfig } from './schema.js';
+import { type ModelProfilesConfig, type ModelProfilesRuntime, type ModelRole, type ProfileValidationIssue } from './model-profiles.js';
+export interface ProfileProjection {
+    file: Partial<PersistedConfig>;
+    state: ModelProfilesRuntime;
+    issues: ProfileValidationIssue[];
+}
+export interface RoleKeyInput {
+    config: CliConfig;
+    role: ModelRole;
+    providerId: string;
+}
+/** Compare configured endpoint spelling strictly, with null and undefined equivalent. */
+export declare function normalizeProfileBaseUrl(value: string | null | undefined): string | null;
+/** Project a valid library onto a copy without rewriting legacy preferences. */
+export declare function projectModelProfiles(file: Partial<PersistedConfig>): ProfileProjection;
+/** Derive binding status from current connections, including session/model overrides. */
+export declare function resolveModelProfileState(config: CliConfig, profiles?: ModelProfilesConfig | undefined, invalid?: boolean): ModelProfilesRuntime;
+/** Resolve only credentials scoped to the requested role and actual connection target. */
+export declare function resolveModelRoleKey(input: RoleKeyInput): string | undefined;