@qduc/term2 0.31.0 → 0.32.0

package/dist/services/settings/settings-schema.js

@@ -1,92 +1,64 @@
 import { z } from 'zod';
 import envPaths from 'env-paths';
 import path from 'node:path';
+import { ModelSelectionSchema } from './model-selection.js';
 import { THEME_SETTING_VALUES } from '../../theme/resolve-theme.js';
 import { SKIN_NAMES } from '../../skins/names.js';
 import { normalizeProviderIdentifier, resolveProviderId, resolveProviderName, } from './custom-provider-normalization.js';
-// Shared shape for the fan-out mentor model pool. One entry overrides the
-// role's configured model; `provider`/`reasoningEffort` fall back to the
-// role's configuration when omitted.
-const SubagentPoolEntrySchema = z.object({
-    model: z.string().min(1),
-    provider: z.string().min(1).optional(),
+// Saved mentor entries pin the host and model; only reasoning may inherit.
+export const SubagentPoolEntrySchema = ModelSelectionSchema.extend({
     reasoningEffort: z.enum(['default', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh']).optional(),
 });
+function rejectRemovedSelectionKeys(keys) {
+    return (value, ctx) => {
+        if (value && typeof value === 'object') {
+            for (const key of keys) {
+                if (Object.hasOwn(value, key)) {
+                    ctx.addIssue({
+                        code: 'custom',
+                        path: [key],
+                        message: 'Removed model/provider setting; use complete bound selections in modelSelection or tier/mentor pools',
+                    });
+                }
+            }
+        }
+        return value;
+    };
+}
 const MAX_SUBAGENT_POOL_ENTRIES = 8;
 const subagentPoolSchema = (description) => z.array(SubagentPoolEntrySchema).max(MAX_SUBAGENT_POOL_ENTRIES).default([]).describe(description);
-// Tier model settings are model pools: a list of model ids round-robined for
-// subagent spawns (see SubagentRolePoolSelector) and read first-entry for
-// other ancillary consumers. A bare id runs on the tier's provider; an entry
-// picked from another provider's catalog pins it as `{model, provider}`. A
-// bare string from older configs (or the legacy migration) normalizes to a
-// single-entry pool.
-export const TierModelPoolEntrySchema = z.union([
-    z.string().min(1),
-    z.object({ model: z.string().min(1), provider: z.string().min(1).optional() }),
-]);
-const tierModelPoolSchema = (description) => z
-    .preprocess((value) => {
-    if (value === undefined || value === null || value === '')
-        return undefined;
-    return Array.isArray(value) ? value : [value];
-}, z.array(TierModelPoolEntrySchema).max(MAX_SUBAGENT_POOL_ENTRIES).optional())
-    .describe(description);
-// Define schemas for validation
-export const AgentSettingsSchema = z.object({
-    model: z.string().min(1).default('gpt-5.1'),
-    efficientModel: z
-        .string()
-        .min(1)
-        .optional()
-        .describe('Model for lower-tier workflow agents. Falls back to agent.model when unset.'),
-    capableModel: z
-        .string()
-        .min(1)
-        .optional()
-        .describe('Model for higher-tier workflow agents. Falls back to agent.model when unset.'),
-    smartModel: tierModelPoolSchema('Models for smart-tier helper agents (the hardest side tasks); subagent spawns round-robin the pool, other consumers use the first entry. Falls back to agent.model when unset.'),
-    smartProvider: z
-        .string()
-        .min(1)
-        .optional()
-        .describe('Provider for smart-tier helper agents (the hardest side tasks). Falls back to agent.provider when unset.'),
+export const TierModelPoolEntrySchema = ModelSelectionSchema;
+const tierModelPoolSchema = (description) => z.array(TierModelPoolEntrySchema).max(MAX_SUBAGENT_POOL_ENTRIES).optional().describe(description);
+const AgentSettingsObjectSchema = z.object({
+    modelSelection: ModelSelectionSchema.default({ model: 'gpt-5.1', provider: 'openai' }).describe('Bound provider and model selection for the main agent'),
+    smartModel: tierModelPoolSchema('Models for smart-tier helper agents (the hardest side tasks); subagent spawns round-robin the pool, other consumers use the first entry. Falls back to agent.modelSelection when unset.'),
     smartReasoningEffort: z
         .enum(['default', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh'])
         .optional()
         .describe('Reasoning effort for smart-tier helper agents (the hardest side tasks). Falls back to agent.reasoningEffort when unset.'),
-    balancedModel: tierModelPoolSchema('Models for balanced-tier helper agents (everyday side tasks); subagent spawns round-robin the pool, other consumers use the first entry. Falls back to agent.model when unset.'),
-    balancedProvider: z
-        .string()
-        .min(1)
-        .optional()
-        .describe('Provider for balanced-tier helper agents (everyday side tasks). Falls back to agent.provider when unset.'),
+    balancedModel: tierModelPoolSchema('Models for balanced-tier helper agents (everyday side tasks); subagent spawns round-robin the pool, other consumers use the first entry. Falls back to agent.modelSelection when unset.'),
     balancedReasoningEffort: z
         .enum(['default', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh'])
         .optional()
         .describe('Reasoning effort for balanced-tier helper agents (everyday side tasks). Falls back to agent.reasoningEffort when unset.'),
-    cheapModel: tierModelPoolSchema('Models for cheap-tier helper agents (simple, high-volume side tasks); subagent spawns round-robin the pool, other consumers use the first entry. Falls back to agent.model when unset.'),
-    cheapProvider: z
-        .string()
-        .min(1)
-        .optional()
-        .describe('Provider for cheap-tier helper agents (simple, high-volume side tasks). Falls back to agent.provider when unset.'),
+    cheapModel: tierModelPoolSchema('Models for cheap-tier helper agents (simple, high-volume side tasks); subagent spawns round-robin the pool, other consumers use the first entry. Falls back to agent.modelSelection when unset.'),
     cheapReasoningEffort: z
         .enum(['default', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh'])
         .optional()
         .describe('Reasoning effort for cheap-tier helper agents (simple, high-volume side tasks). Falls back to agent.reasoningEffort when unset.'),
-    choreModel: tierModelPoolSchema('Models for small background jobs like repairing failed file edits and reviewing shell auto-approvals (auto-approval reviews, edit healing). Falls back to agent.model when unset.'),
-    choreProvider: z
-        .string()
-        .min(1)
-        .optional()
-        .describe('Provider for small background jobs like repairing failed file edits and reviewing shell auto-approvals. Falls back to agent.provider when unset.'),
-    // 'default' signals we should *not* explicitly pass a reasoningEffort
-    // to the API, allowing it to decide what to use.
+    choreModel: tierModelPoolSchema('Models for small background jobs like repairing failed file edits and reviewing shell auto-approvals (auto-approval reviews, edit healing). Falls back to agent.modelSelection when unset.'),
     reasoningEffort: z.enum(['default', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh']).default('default'),
     // Temperature controls randomness. We keep it optional so providers/models
     // can use their own defaults when unset.
     temperature: z.number().min(0).max(2).optional(),
     maxTurns: z.number().int().positive().default(100),
+    maxRequestInputTokens: z
+        .number()
+        .int()
+        .min(1_000)
+        .nullable()
+        .default(null)
+        .describe('Per-request estimated or last-observed input cost/latency ceiling; retains work on refusal (null uses known model capacity)'),
     maxOutputTokens: z.number().int().positive().default(32_000),
     maxStreamOutputChars: z.number().int().positive().default(100_000),
     // Total wall-clock ceiling per provider request. 0 means "no ceiling": the
@@ -122,9 +94,9 @@ export const AgentSettingsSchema = z.object({
         maxParentExtensions: z.number().int().nonnegative().finite().default(2),
         identicalToolCallThreshold: z.number().int().positive().finite().default(3),
         escalation: z
-            .enum(['warn', 'pause', 'disabled'])
+            .enum(['warn', 'contain', 'pause', 'disabled'])
             .default('warn')
-            .describe('What a non-soft budget stage does: warn in the status bar, pause the run for a decision, or disabled'),
+            .describe('warn is advisory; contain pauses at exhaustion; pause also stops on warning/stall; disabled emits no evidence'),
     })
         .default({
         maxUsdMicros: 5_000_000,
@@ -161,7 +133,6 @@ export const AgentSettingsSchema = z.object({
     // NOTE: We do NOT validate provider existence here because the provider
     // registry can be extended at runtime from settings.json (custom providers).
     // We validate/fallback after SettingsService loads and registers runtime providers.
-    provider: z.string().min(1).default('openai').describe('Provider to use for the agent'),
     favoriteModels: z
         .array(z.string())
         .optional()
@@ -196,12 +167,6 @@ export const AgentSettingsSchema = z.object({
         websocketInterFrameTimeoutMs: z.number().int().positive().finite().default(600_000),
     })
         .default({ websocketFirstFrameTimeoutMs: 90_000, websocketInterFrameTimeoutMs: 600_000 }),
-    mentorModel: z.string().optional().describe('Model to use as a mentor'),
-    mentorProvider: z
-        .string()
-        .min(1)
-        .optional()
-        .describe('Provider to use for the mentor model (defaults to agent.provider when unset)'),
     mentorReasoningEffort: z
         .enum(['default', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh'])
         .default('default')
@@ -221,23 +186,13 @@ export const AgentSettingsSchema = z.object({
         .describe('Use OpenAI Flex Service Tier to reduce costs (OpenAI only)'),
     contextCompaction: z
         .object({
-        enabled: z.boolean().default(false),
+        enabled: z.boolean().default(true),
         mode: z.enum(['native', 'auto', 'local']).default('auto'),
         compactThreshold: z.number().finite().min(0).max(1).default(0.8),
         compactThresholdTokens: z.number().int().finite().min(1_000).nullable().default(null),
     })
-        .default({ enabled: false, mode: 'auto', compactThreshold: 0.8, compactThresholdTokens: null })
+        .default({ enabled: true, mode: 'auto', compactThreshold: 0.8, compactThresholdTokens: null })
         .describe('Native and application-owned context compaction settings'),
-    autoApproveModel: z
-        .string()
-        .optional()
-        .default('gpt-4o-mini')
-        .describe('Faster model to use for auto-approval evaluation'),
-    autoApproveProvider: z
-        .string()
-        .min(1)
-        .optional()
-        .describe('Provider to use for the auto-approval model (defaults to agent.provider when unset)'),
     autoApproveReasoningEffort: z
         .enum(['none', 'minimal', 'low', 'medium', 'high', 'xhigh'])
         .default('low')
@@ -247,49 +202,39 @@ export const AgentSettingsSchema = z.object({
         .min(1)
         .optional()
         .describe('OpenRouter Decisions model shared by the approval fast path and failure-triage comparisons. For approval, only low/medium-risk, explicit/implied decisions at confidence 0.8 or higher can authorize execution; every other outcome falls back to the chore reviewer. Sends approval context plus failure evidence. Adds API charges'),
-    subagentExplorerModel: z
-        .string()
-        .min(1)
-        .optional()
-        .describe('Model override for the explorer subagent. Falls back to agent.model when unset.'),
-    subagentExplorerProvider: z
-        .string()
-        .min(1)
-        .optional()
-        .describe('Provider override for the explorer subagent. Falls back to agent.provider when unset.'),
     subagentExplorerReasoningEffort: z
         .enum(['default', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh'])
         .optional()
         .describe('Reasoning effort override for the explorer subagent. Falls back to agent.reasoningEffort when unset.'),
-    subagentWorkerModel: z
-        .string()
-        .min(1)
-        .optional()
-        .describe('Model override for the worker subagent. Falls back to agent.model when unset.'),
-    subagentWorkerProvider: z
-        .string()
-        .min(1)
-        .optional()
-        .describe('Provider override for the worker subagent. Falls back to agent.provider when unset.'),
     subagentWorkerReasoningEffort: z
         .enum(['default', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh'])
         .optional()
         .describe('Reasoning effort override for the worker subagent. Falls back to agent.reasoningEffort when unset.'),
-    subagentLibrarianModel: z
-        .string()
-        .min(1)
-        .optional()
-        .describe('Model override for the librarian subagent. Falls back to agent.model when unset.'),
-    subagentLibrarianProvider: z
-        .string()
-        .min(1)
-        .optional()
-        .describe('Provider override for the librarian subagent. Falls back to agent.provider when unset.'),
     subagentLibrarianReasoningEffort: z
         .enum(['default', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh'])
         .optional()
         .describe('Reasoning effort override for the librarian subagent. Falls back to agent.reasoningEffort when unset.'),
 });
+export const AgentSettingsSchema = z.preprocess(rejectRemovedSelectionKeys([
+    'model',
+    'provider',
+    'efficientModel',
+    'capableModel',
+    'mentorModel',
+    'mentorProvider',
+    'subagentExplorerModel',
+    'subagentExplorerProvider',
+    'subagentWorkerModel',
+    'subagentWorkerProvider',
+    'subagentLibrarianModel',
+    'subagentLibrarianProvider',
+    'autoApproveModel',
+    'autoApproveProvider',
+    'smartProvider',
+    'balancedProvider',
+    'cheapProvider',
+    'choreProvider',
+]), AgentSettingsObjectSchema);
 export const ShellSettingsSchema = z.object({
     timeout: z.number().int().positive().default(120000),
     backgroundTimeout: z
@@ -399,15 +344,9 @@ export const AppSettingsSchema = z.object({
         .optional()
         .default('auto'),
 });
-export const ToolsSettingsSchema = z.object({
+const ToolsSettingsObjectSchema = z.object({
     logFileOperations: z.boolean().optional().default(true),
     enableEditHealing: z.boolean().optional().default(true),
-    editHealingModel: z.string().optional().default('gpt-4o-mini'),
-    editHealingProvider: z
-        .string()
-        .min(1)
-        .optional()
-        .describe('Provider to use for the edit-healing model (defaults to agent.provider when unset)'),
     // Per-tool-group kill switches for the main agent. Each masks exactly one
     // capability group from the profile's tool capabilities (tool-toggles.ts),
     // removing that group's tools and capability-gated prompt fragments on the
@@ -476,6 +415,7 @@ export const ToolsSettingsSchema = z.object({
         .default({ enabled: true })
         .describe('Enable code-context tools (read_code_outline, code_context_search) for the main agent (true|false). Applies on the next model request.'),
 });
+export const ToolsSettingsSchema = z.preprocess(rejectRemovedSelectionKeys(['editHealingModel', 'editHealingProvider']), ToolsSettingsObjectSchema);
 export const DebugSettingsSchema = z.object({
     debugBashTool: z.boolean().optional().default(false),
 });
@@ -604,7 +544,7 @@ function getSensitiveSettingKeys() {
     ]);
 }
 export const SENSITIVE_SETTING_KEYS = getSensitiveSettingKeys();
-export const SettingsSchema = z.object({
+const SettingsObjectSchema = z.object({
     providers: z.array(CustomProviderSchema).optional().default([]),
     enable_agent_workflow: z.boolean().optional().default(false),
     agent: AgentSettingsSchema.optional(),
@@ -623,33 +563,28 @@ export const SettingsSchema = z.object({
     memory: MemorySettingsSchema.optional().default(MemorySettingsSchema.parse({})),
     hooks: HooksSettingsSchema.optional().default(HooksSettingsSchema.parse({})),
 });
+export const SettingsSchema = SettingsObjectSchema;
 /**
  * Centralized list of all setting keys for consistency across the app.
  * Used by settings command UI and other components to avoid duplication.
  */
 export const SETTING_KEYS = {
     ENABLE_AGENT_WORKFLOW: 'enable_agent_workflow',
-    AGENT_MODEL: 'agent.model',
-    AGENT_EFFICIENT_MODEL: 'agent.efficientModel',
-    AGENT_CAPABLE_MODEL: 'agent.capableModel',
+    AGENT_MODEL_SELECTION: 'agent.modelSelection',
     AGENT_SMART_MODEL: 'agent.smartModel',
-    AGENT_SMART_PROVIDER: 'agent.smartProvider',
     AGENT_SMART_REASONING_EFFORT: 'agent.smartReasoningEffort',
     AGENT_BALANCED_MODEL: 'agent.balancedModel',
-    AGENT_BALANCED_PROVIDER: 'agent.balancedProvider',
     AGENT_BALANCED_REASONING_EFFORT: 'agent.balancedReasoningEffort',
     AGENT_CHEAP_MODEL: 'agent.cheapModel',
-    AGENT_CHEAP_PROVIDER: 'agent.cheapProvider',
     AGENT_CHEAP_REASONING_EFFORT: 'agent.cheapReasoningEffort',
     AGENT_CHORE_MODEL: 'agent.choreModel',
-    AGENT_CHORE_PROVIDER: 'agent.choreProvider',
     AGENT_REASONING_EFFORT: 'agent.reasoningEffort',
     AGENT_TEMPERATURE: 'agent.temperature',
-    AGENT_PROVIDER: 'agent.provider',
     AGENT_FAVORITE_MODELS: 'agent.favoriteModels',
     AGENT_MODEL_NICKNAMES: 'agent.modelNicknames',
     AGENT_DISABLED_PROVIDERS: 'agent.disabledProviders',
     AGENT_MAX_TURNS: 'agent.maxTurns',
+    AGENT_MAX_REQUEST_INPUT_TOKENS: 'agent.maxRequestInputTokens',
     AGENT_MAX_OUTPUT_TOKENS: 'agent.maxOutputTokens',
     AGENT_MAX_STREAM_OUTPUT_CHARS: 'agent.maxStreamOutputChars',
     AGENT_MAX_MODEL_REQUEST_DURATION_MS: 'agent.maxModelRequestDurationMs',
@@ -683,8 +618,6 @@ export const SETTING_KEYS = {
     AGENT_OPENROUTER_TITLE: 'agent.openrouter.title', // Sensitive - env only
     AGENT_CODEX_WEBSOCKET_FIRST_FRAME_TIMEOUT_MS: 'agent.codex.websocketFirstFrameTimeoutMs',
     AGENT_CODEX_WEBSOCKET_INTER_FRAME_TIMEOUT_MS: 'agent.codex.websocketInterFrameTimeoutMs',
-    AGENT_MENTOR_MODEL: 'agent.mentorModel',
-    AGENT_MENTOR_PROVIDER: 'agent.mentorProvider',
     AGENT_MENTOR_REASONING_EFFORT: 'agent.mentorReasoningEffort',
     AGENT_MENTOR_SAMPLES: 'agent.mentorSamples',
     AGENT_MENTOR_POOL: 'agent.mentorPool',
@@ -703,18 +636,10 @@ export const SETTING_KEYS = {
     SANDBOX_ALLOW_READ_EXTRA: 'sandbox.allowReadExtra',
     SANDBOX_DOCKER_HOST_CONTROL_PROJECTS: 'sandbox.dockerHostControlProjects',
     SANDBOX_ALLOW_NETWORKING: 'sandbox.allowNetworking',
-    AGENT_AUTO_APPROVE_MODEL: 'agent.autoApproveModel',
-    AGENT_AUTO_APPROVE_PROVIDER: 'agent.autoApproveProvider',
     AGENT_AUTO_APPROVE_REASONING_EFFORT: 'agent.autoApproveReasoningEffort',
     AGENT_DECISION_MODEL: 'agent.decisionModel',
-    AGENT_SUBAGENT_EXPLORER_MODEL: 'agent.subagentExplorerModel',
-    AGENT_SUBAGENT_EXPLORER_PROVIDER: 'agent.subagentExplorerProvider',
     AGENT_SUBAGENT_EXPLORER_REASONING_EFFORT: 'agent.subagentExplorerReasoningEffort',
-    AGENT_SUBAGENT_WORKER_MODEL: 'agent.subagentWorkerModel',
-    AGENT_SUBAGENT_WORKER_PROVIDER: 'agent.subagentWorkerProvider',
     AGENT_SUBAGENT_WORKER_REASONING_EFFORT: 'agent.subagentWorkerReasoningEffort',
-    AGENT_SUBAGENT_LIBRARIAN_MODEL: 'agent.subagentLibrarianModel',
-    AGENT_SUBAGENT_LIBRARIAN_PROVIDER: 'agent.subagentLibrarianProvider',
     AGENT_SUBAGENT_LIBRARIAN_REASONING_EFFORT: 'agent.subagentLibrarianReasoningEffort',
     SUBAGENT_ASYNC_SESSION_TTL_MS: 'subagent.asyncSessionTtlMs',
     SUBAGENT_ASYNC_MESSAGE_CAP: 'subagent.asyncMessageCap',
@@ -740,8 +665,6 @@ export const SETTING_KEYS = {
     APP_SEARCH_VIA_SHELL: 'app.searchViaShell',
     TOOLS_LOG_FILE_OPS: 'tools.logFileOperations',
     TOOLS_ENABLE_EDIT_HEALING: 'tools.enableEditHealing',
-    TOOLS_EDIT_HEALING_MODEL: 'tools.editHealingModel',
-    TOOLS_EDIT_HEALING_PROVIDER: 'tools.editHealingProvider',
     TOOLS_SHELL_ENABLED: 'tools.shell.enabled',
     TOOLS_WEB_ENABLED: 'tools.web.enabled',
     TOOLS_FILE_READ_ENABLED: 'tools.fileRead.enabled',
@@ -781,31 +704,25 @@ export const SETTING_KEYS = {
 };
 // Define which settings are modifiable at runtime
 export const RUNTIME_MODIFIABLE_SETTINGS = new Set([
+    'agent.modelSelection',
     SETTING_KEYS.AGENT_OPENROUTER_API_KEY,
     SETTING_KEYS.AGENT_OPENAI_API_KEY,
-    SETTING_KEYS.AGENT_MODEL,
-    SETTING_KEYS.AGENT_EFFICIENT_MODEL,
-    SETTING_KEYS.AGENT_CAPABLE_MODEL,
     SETTING_KEYS.AGENT_SMART_MODEL,
-    SETTING_KEYS.AGENT_SMART_PROVIDER,
     SETTING_KEYS.AGENT_SMART_REASONING_EFFORT,
     SETTING_KEYS.AGENT_BALANCED_MODEL,
-    SETTING_KEYS.AGENT_BALANCED_PROVIDER,
     SETTING_KEYS.AGENT_BALANCED_REASONING_EFFORT,
     SETTING_KEYS.AGENT_CHEAP_MODEL,
-    SETTING_KEYS.AGENT_CHEAP_PROVIDER,
     SETTING_KEYS.AGENT_CHEAP_REASONING_EFFORT,
     SETTING_KEYS.AGENT_CHORE_MODEL,
-    SETTING_KEYS.AGENT_CHORE_PROVIDER,
     SETTING_KEYS.AGENT_AUTO_APPROVE_REASONING_EFFORT,
     SETTING_KEYS.AGENT_DECISION_MODEL,
     SETTING_KEYS.AGENT_REASONING_EFFORT,
     SETTING_KEYS.AGENT_TEMPERATURE,
-    SETTING_KEYS.AGENT_PROVIDER,
     SETTING_KEYS.AGENT_FAVORITE_MODELS,
     SETTING_KEYS.AGENT_MODEL_NICKNAMES,
     SETTING_KEYS.AGENT_DISABLED_PROVIDERS,
     SETTING_KEYS.AGENT_RETRY_ATTEMPTS,
+    SETTING_KEYS.AGENT_MAX_REQUEST_INPUT_TOKENS,
     SETTING_KEYS.AGENT_MAX_OUTPUT_TOKENS,
     SETTING_KEYS.AGENT_MAX_STREAM_OUTPUT_CHARS,
     SETTING_KEYS.AGENT_MAX_MODEL_REQUEST_DURATION_MS,
@@ -830,8 +747,6 @@ export const RUNTIME_MODIFIABLE_SETTINGS = new Set([
     SETTING_KEYS.AGENT_SESSION_ROLLOVER_ENABLED,
     SETTING_KEYS.AGENT_SESSION_ROLLOVER_MILESTONES,
     SETTING_KEYS.AGENT_SESSION_ROLLOVER_AUTO_BRIEF,
-    SETTING_KEYS.AGENT_MENTOR_MODEL,
-    SETTING_KEYS.AGENT_MENTOR_PROVIDER,
     SETTING_KEYS.AGENT_MENTOR_REASONING_EFFORT,
     SETTING_KEYS.AGENT_MENTOR_POOL,
     SETTING_KEYS.AGENT_USE_FLEX_SERVICE_TIER,
@@ -864,21 +779,11 @@ export const RUNTIME_MODIFIABLE_SETTINGS = new Set([
     SETTING_KEYS.UI_DISPLAY_MODE,
     SETTING_KEYS.UI_THEME,
     SETTING_KEYS.UI_SKIN,
-    SETTING_KEYS.AGENT_AUTO_APPROVE_MODEL,
-    SETTING_KEYS.AGENT_AUTO_APPROVE_PROVIDER,
-    SETTING_KEYS.AGENT_SUBAGENT_EXPLORER_MODEL,
-    SETTING_KEYS.AGENT_SUBAGENT_EXPLORER_PROVIDER,
     SETTING_KEYS.AGENT_SUBAGENT_EXPLORER_REASONING_EFFORT,
-    SETTING_KEYS.AGENT_SUBAGENT_WORKER_MODEL,
-    SETTING_KEYS.AGENT_SUBAGENT_WORKER_PROVIDER,
     SETTING_KEYS.AGENT_SUBAGENT_WORKER_REASONING_EFFORT,
-    SETTING_KEYS.AGENT_SUBAGENT_LIBRARIAN_MODEL,
-    SETTING_KEYS.AGENT_SUBAGENT_LIBRARIAN_PROVIDER,
     SETTING_KEYS.AGENT_SUBAGENT_LIBRARIAN_REASONING_EFFORT,
     SETTING_KEYS.SUBAGENT_ASYNC_SESSION_TTL_MS,
     SETTING_KEYS.SUBAGENT_ASYNC_MESSAGE_CAP,
-    SETTING_KEYS.TOOLS_EDIT_HEALING_MODEL,
-    SETTING_KEYS.TOOLS_EDIT_HEALING_PROVIDER,
     SETTING_KEYS.TOOLS_SHELL_ENABLED,
     SETTING_KEYS.TOOLS_WEB_ENABLED,
     SETTING_KEYS.TOOLS_FILE_READ_ENABLED,
@@ -906,28 +811,24 @@ export const RUNTIME_MODIFIABLE_SETTINGS = new Set([
     SETTING_KEYS.HOOKS_TIMEOUT_MS,
 ]);
 // Some settings with default values are optional to persist
-export const OPTIONAL_DEFAULT_KEYS = new Set([]);
+// Absence preserves inherited output-allocation provenance on disk.
+export const OPTIONAL_DEFAULT_KEYS = new Set(['agent.maxOutputTokens']);
 // Default settings
 export const DEFAULT_SETTINGS = {
     providers: [],
     enable_agent_workflow: false,
     agent: {
-        model: 'gpt-5.1',
-        efficientModel: undefined,
-        capableModel: undefined,
+        modelSelection: { model: 'gpt-5.1', provider: 'openai' },
         smartModel: undefined,
-        smartProvider: undefined,
         smartReasoningEffort: undefined,
         balancedModel: undefined,
-        balancedProvider: undefined,
         balancedReasoningEffort: undefined,
         cheapModel: undefined,
-        cheapProvider: undefined,
         cheapReasoningEffort: undefined,
         choreModel: undefined,
-        choreProvider: undefined,
         reasoningEffort: 'default',
         maxTurns: 100,
+        maxRequestInputTokens: null,
         maxOutputTokens: 32_000,
         maxStreamOutputChars: 100_000,
         maxModelRequestDurationMs: 0,
@@ -960,7 +861,6 @@ export const DEFAULT_SETTINGS = {
             milestones: [200_000, 300_000, 400_000],
             autoBrief: true,
         },
-        provider: 'openai',
         favoriteModels: [],
         modelNicknames: {},
         disabledProviders: [],
@@ -975,30 +875,20 @@ export const DEFAULT_SETTINGS = {
             websocketFirstFrameTimeoutMs: 90_000,
             websocketInterFrameTimeoutMs: 600_000,
         },
-        mentorModel: undefined,
-        mentorProvider: undefined,
         mentorReasoningEffort: 'default',
         mentorSamples: 1,
         mentorPool: [],
         useFlexServiceTier: false,
         contextCompaction: {
-            enabled: false,
+            enabled: true,
             mode: 'auto',
             compactThreshold: 0.8,
             compactThresholdTokens: null,
         },
-        autoApproveModel: 'gpt-4o-mini',
-        autoApproveProvider: undefined,
         autoApproveReasoningEffort: 'low',
         decisionModel: undefined,
-        subagentExplorerModel: undefined,
-        subagentExplorerProvider: undefined,
         subagentExplorerReasoningEffort: undefined,
-        subagentWorkerModel: undefined,
-        subagentWorkerProvider: undefined,
         subagentWorkerReasoningEffort: undefined,
-        subagentLibrarianModel: undefined,
-        subagentLibrarianProvider: undefined,
         subagentLibrarianReasoningEffort: undefined,
     },
     shell: {
@@ -1058,8 +948,6 @@ export const DEFAULT_SETTINGS = {
     tools: {
         logFileOperations: true,
         enableEditHealing: true,
-        editHealingModel: 'gpt-4o-mini',
-        editHealingProvider: undefined,
         shell: { enabled: true },
         web: { enabled: true },
         fileRead: { enabled: true },