shortcutxl 0.4.1 → 0.4.2

package/BINARY-INVENTORY.json

@@ -1,14 +1,14 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-10-20T06:34:34.546Z",
+  "generatedAt": "2026-10-20T23:01:29.571Z",
   "package": "shortcutxl",
   "build": {
     "builder": "github-actions",
     "repository": "lyfegame/shortcut",
     "sourceRef": "refs/heads/main",
-    "sourceCommit": "d31a59fd8f7ebec7800d9bd325ccc4835ecab91c",
+    "sourceCommit": "29226447fc54eb8379f8b0b5823e158a24d562d3",
     "workflowRef": "lyfegame/shortcut/.github/workflows/release-shortcut-cli-npm-package.yml@refs/heads/main",
-    "runId": "39380994342",
+    "runId": "39512005187",
     "runnerOs": "Windows",
     "runnerImage": "win25-vs2026",
     "runnerImageVersion": "20261007.264.1"
@@ -550,7 +550,7 @@
     },
     {
       "path": "xll/python/Scripts/httpx.exe",
-      "sha256": "0ae7fc1605a56db84f3824478722830defc55116228e0d6ce810d593cc54f4e3",
+      "sha256": "1ef3333c745fc7dbaff8a2dcf6de6491e9e44e44580a1b3ca630019ec18aac8b",
       "source": "httpx console launcher installed into embedded Python",
       "version": "see packaged httpx distribution",
       "builtBy": "third-party",
@@ -558,7 +558,7 @@
     },
     {
       "path": "xll/python/Scripts/idna.exe",
-      "sha256": "2aba1463e9caa2be1f8f12beee70995c893af72dd9dc81a8317056e478a15470",
+      "sha256": "89c1645a20d2119a8b1271a572cbf398e7000b9dd57a04b56906c513024f4771",
       "source": "Python package console launcher installed into embedded Python",
       "version": "see owning Python package metadata in site-packages",
       "builtBy": "third-party",
@@ -566,7 +566,7 @@
     },
     {
       "path": "xll/python/Scripts/pip.exe",
-      "sha256": "ccdb9c9263d20f71609aadb08a785ba78c7e6f6757437629d96fd1078f6676af",
+      "sha256": "733632fc67f2f4f54f646f7a97c126ea76dc88a25761908d1c4411eed0b600ff",
       "source": "pip console launcher installed into embedded Python",
       "version": "see packaged pip distribution",
       "builtBy": "third-party",
@@ -574,7 +574,7 @@
     },
     {
       "path": "xll/python/Scripts/pip3.13.exe",
-      "sha256": "ccdb9c9263d20f71609aadb08a785ba78c7e6f6757437629d96fd1078f6676af",
+      "sha256": "733632fc67f2f4f54f646f7a97c126ea76dc88a25761908d1c4411eed0b600ff",
       "source": "pip console launcher installed into embedded Python",
       "version": "see packaged pip distribution",
       "builtBy": "third-party",
@@ -582,7 +582,7 @@
     },
     {
       "path": "xll/python/Scripts/pip3.exe",
-      "sha256": "ccdb9c9263d20f71609aadb08a785ba78c7e6f6757437629d96fd1078f6676af",
+      "sha256": "733632fc67f2f4f54f646f7a97c126ea76dc88a25761908d1c4411eed0b600ff",
       "source": "pip console launcher installed into embedded Python",
       "version": "see packaged pip distribution",
       "builtBy": "third-party",
@@ -590,7 +590,7 @@
     },
     {
       "path": "xll/python/Scripts/pywin32_postinstall.exe",
-      "sha256": "72d1e776a493eddcfbcd852b3b9f79c50480d6886fffa1c1798d88625148f22a",
+      "sha256": "36d372cde19e37f53f33cfe10de6ee4b4f26f6abeb98b2831bf3fe4c95655380",
       "source": "Python package console launcher installed into embedded Python",
       "version": "see owning Python package metadata in site-packages",
       "builtBy": "third-party",
@@ -598,7 +598,7 @@
     },
     {
       "path": "xll/python/Scripts/pywin32_testall.exe",
-      "sha256": "13146537a7cf67f66380470f48d4de7d2d4d12632415c673f191ab0e744fad7d",
+      "sha256": "223e9358a7135a893a91ac7e2ab575cbe6ab83052292687c55b3e33424bd94d1",
       "source": "Python package console launcher installed into embedded Python",
       "version": "see owning Python package metadata in site-packages",
       "builtBy": "third-party",

package/dist/app/agent-session-runtime-adapter.d.ts

@@ -48,6 +48,8 @@ export interface CreateAgentSessionRuntimeAdapterOptions {
     fastModeDisabledReason?: FastModeDisabledReason;
     modeName?: string;
     model?: Model<Api>;
+    /** Whether `model` is the user's choice; false for a resolved default. Defaults to true. */
+    modelExplicit?: boolean;
     observability?: RuntimeObservability;
     permissionPolicy?: RuntimePermissionPolicy;
     prePromptContext?: () => Promise<{
@@ -73,12 +75,15 @@ export interface CreateAgentSessionRuntimeAdapterResult extends CreateAgentSessi
 }
 export declare function resolveInitialSessionModel(options: {
     model?: Model<Api>;
+    modelExplicit?: boolean;
     modelRegistry: AgentModelRegistry;
     sessionManager?: ProductSessionStore;
     settingsManager: AgentSessionSettingsStore;
 }): Promise<{
     model: Model<Api> | undefined;
     modelFallbackMessage?: string;
+    /** False when the model is a resolved default that login may replace. */
+    modelExplicit: boolean;
 }>;
 export declare function createAgentSessionRuntimeAdapter(options: CreateAgentSessionRuntimeAdapterOptions): Promise<CreateAgentSessionRuntimeAdapterResult>;
 //# sourceMappingURL=agent-session-runtime-adapter.d.ts.map

package/dist/app/agent-session-runtime-adapter.js

@@ -23,14 +23,14 @@ import { convertToLlm } from './messages.js';
 import { findInitialModel } from './providers/model-resolver.js';
 export async function resolveInitialSessionModel(options) {
     if (options.model)
-        return { model: options.model };
+        return { model: options.model, modelExplicit: options.modelExplicit ?? true };
     const existingSession = options.sessionManager?.buildSessionContext();
     const hasExistingSession = (existingSession?.messages.length ?? 0) > 0;
     let modelFallbackMessage;
     if (hasExistingSession && existingSession?.model) {
         const restoredModel = options.modelRegistry.find(existingSession.model.provider, existingSession.model.modelId);
         if (restoredModel && (await options.modelRegistry.getApiKey(restoredModel))) {
-            return { model: restoredModel };
+            return { model: restoredModel, modelExplicit: true };
         }
         modelFallbackMessage = `Could not restore model ${existingSession.model.provider}/${existingSession.model.modelId}`;
     }
@@ -44,13 +44,14 @@ export async function resolveInitialSessionModel(options) {
     if (!resolved.model) {
         return {
             model: undefined,
-            modelFallbackMessage: 'No models available. Configure credentials or provide a model.'
+            modelFallbackMessage: 'No models available. Configure credentials or provide a model.',
+            modelExplicit: false
         };
     }
     if (modelFallbackMessage) {
         modelFallbackMessage += `. Using ${resolved.model.provider}/${resolved.model.id}`;
     }
-    return { model: resolved.model, modelFallbackMessage };
+    return { model: resolved.model, modelFallbackMessage, modelExplicit: resolved.explicit };
 }
 function createAgentSessionCore(session, pendingHostToolRequests, shortyRuntime) {
     // AgentSession itself doesn't carry a "the last turn was cancelled" flag —
@@ -141,6 +142,7 @@ export async function createAgentSessionRuntimeAdapter(options) {
         .some((entry) => entry.type === 'thinking_level_change');
     const initialModel = await resolveInitialSessionModel({
         model: options.model,
+        modelExplicit: options.modelExplicit,
         modelRegistry,
         sessionManager,
         settingsManager
@@ -264,6 +266,7 @@ export async function createAgentSessionRuntimeAdapter(options) {
         modelRegistry,
         fastModeAllowed: options.fastModeAllowed,
         fastModeDisabledReason: options.fastModeDisabledReason,
+        initialModelExplicit: initialModel.modelExplicit,
         extensionRunnerRef,
         prePromptContext: options.prePromptContext,
         budgetLimits: options.budgetLimits,

package/dist/app/agent-session.d.ts

@@ -29,6 +29,7 @@ import type { PromptTemplate } from './resources/prompt-templates.js';
 import { type AutonomousState, type ConsumedPendingRefresh, type PendingRefresh } from './session/autonomous-workflow.js';
 import { type ForkResult, type NavigateTreeResult } from './session/branch-manager.js';
 import { type ExtensionBindings } from './session/extension-lifecycle.js';
+import { type SetModelOptions } from './session/model-manager.js';
 import { type ModelCycleResult } from './session/session-models.js';
 import type { AgentSessionSettingsStore } from './session/session-settings-store.js';
 import { type FastModeDisabledReason } from './session/session-speed.js';
@@ -105,6 +106,8 @@ export interface AgentSessionConfig {
     modelRegistry: AgentModelRegistry;
     fastModeAllowed?: boolean;
     fastModeDisabledReason?: FastModeDisabledReason;
+    /** False when the initial model is a resolved default that login may re-resolve (default true). */
+    initialModelExplicit?: boolean;
     /** Mutable ref used by AgentController to access the current ExtensionRunner */
     extensionRunnerRef?: {
         current?: ExtensionRunner;
@@ -449,8 +452,10 @@ export declare class AgentSession {
         setup?: (sessionManager: ExtensionSessionSetupStore) => Promise<void>;
         preserveAutonomous?: boolean;
     }): Promise<boolean>;
-    /** Switch the session's active LLM to `model`, persisting the change. */
-    setModel(model: Model<any>): Promise<void>;
+    /** Switch the active LLM; `{ explicit: false }` marks a runtime-chosen default (not saved). */
+    setModel(model: Model<any>, options?: SetModelOptions): Promise<void>;
+    /** True when the current model is the user's choice rather than a resolved default. */
+    get isModelExplicitlySelected(): boolean;
     /** Cycle to the next configured model and report the switch result. */
     cycleModel(direction?: 'forward' | 'backward'): Promise<ModelCycleResult | undefined>;
     /** Set the model's reasoning/thinking level for subsequent turns. */

package/dist/app/agent-session.js

@@ -163,7 +163,7 @@ export class AgentSession {
         });
         // Construct extracted modules with stable deps
         this._tools = new ToolRegistry(this.agent, this._resourceLoader, this.settingsManager, config.cwd, config.initialPermissionPolicy);
-        this._models = new ModelManager(this.agent, this._modelRegistry, this.sessionManager, this.settingsManager);
+        this._models = new ModelManager(this.agent, this._modelRegistry, this.sessionManager, this.settingsManager, config.initialModelExplicit ?? true);
         this._branches = new BranchManager({
             agent: this.agent,
             sessionManager: this.sessionManager,
@@ -242,7 +242,7 @@ export class AgentSession {
             compaction: this._compaction,
             compactionActions: () => this._compactionActions,
             removeLastErrorGroup: () => this._removeLastErrorGroup(),
-            setModel: (model) => this.setModel(model)
+            setModel: (model) => this.setModel(model, { explicit: false }) // automatic fallback, not a pick
         });
         // Forward extracted module events to session listeners
         this._recovery.onEvent((event) => this._emit(event));
@@ -1330,11 +1330,15 @@ export class AgentSession {
     // =========================================================================
     // Model Management (delegated to ModelManager)
     // =========================================================================
-    /** Switch the session's active LLM to `model`, persisting the change. */
-    async setModel(model) {
-        await this._models.setModel(model);
+    /** Switch the active LLM; `{ explicit: false }` marks a runtime-chosen default (not saved). */
+    async setModel(model, options) {
+        await this._models.setModel(model, options);
         this._speed.clearUnavailableSpeed();
     }
+    /** True when the current model is the user's choice rather than a resolved default. */
+    get isModelExplicitlySelected() {
+        return this._models.isExplicit;
+    }
     /** Cycle to the next configured model and report the switch result. */
     async cycleModel(direction = 'forward') {
         const result = await this._models.cycleModel(direction);

package/dist/app/observability/client-logging/client-logger.d.ts

@@ -60,7 +60,8 @@ export declare class ShortcutClientLogger {
     private bufferAccountGeneration?;
     private emit;
     private startPeriodicFlush;
-    flush(): Promise<void>;
+    /** Send buffered entries; resolves true only when this call delivered a batch. */
+    flush(): Promise<boolean>;
     destroy(): Promise<void>;
 }
 //# sourceMappingURL=client-logger.d.ts.map

package/dist/app/observability/client-logging/client-logger.js

@@ -79,9 +79,9 @@ export class ShortcutClientLogger {
             this.flushTimer = null;
         }
     }
-    disable() {
+    async disable() {
         this.setEnabled(false);
-        return this.flush();
+        await this.flush();
     }
     info(input) {
         this.emit('info', input);
@@ -127,27 +127,32 @@ export class ShortcutClientLogger {
             void this.flush();
         }, this.flushIntervalMs);
     }
+    /** Send buffered entries; resolves true only when this call delivered a batch. */
     async flush() {
         const routing = getLocalShortcutRouting();
         if (routing &&
             (!routing.canSendUsageLogs() || this.bufferAccountGeneration !== routing.generation)) {
             this.buffer = [];
-            return;
+            return false;
         }
         if (this.pendingFlush) {
             await this.pendingFlush;
-            return;
+            return false;
         }
         if (this.buffer.length === 0) {
-            return;
+            return false;
         }
         const batch = {
             client_time: this.now().toISOString(),
             entries: this.buffer
         };
         this.buffer = [];
+        let delivered = false;
         this.pendingFlush = this.transport
             .send(batch)
+            .then(() => {
+            delivered = true;
+        })
             .catch(() => {
             // Fail open. Observability must never break the primary user flow.
         })
@@ -155,6 +160,7 @@ export class ShortcutClientLogger {
             this.pendingFlush = null;
         });
         await this.pendingFlush;
+        return delivered;
     }
     async destroy() {
         this.destroyed = true;

package/dist/app/providers/model-resolver.d.ts

@@ -70,6 +70,12 @@ export interface InitialModelResult {
     model: Model<Api> | undefined;
     thinkingLevel: ThinkingLevel;
     fallbackMessage: string | undefined;
+    /**
+     * True when the model was chosen by the user (CLI flag or saved settings), false when it is
+     * the resolved default. A default may be re-resolved when the account changes (login).
+     * Saved settings are honoured as written, even for a model the picker no longer lists.
+     */
+    explicit: boolean;
 }
 /**
  * Find the initial model to use based on priority:

package/dist/app/providers/model-resolver.js

@@ -4,7 +4,9 @@
 import chalk from 'chalk';
 import { resolveModelReasoningLevel } from '../../ai/models.js';
 import { DEFAULT_THINKING_LEVEL, isValidThinkingLevel } from '../../core/defaults.js';
-import { SHORTCUT_FREE_MODEL_ID, SHORTCUT_MODEL_ID, SHORTCUT_OPENAI_MODEL_ID, SHORTCUT_PROVIDER_ID } from '../../model-ids.js';
+import { SHORTCUT_MODEL_ID, SHORTCUT_OPENAI_MODEL_ID, SHORTCUT_PROVIDER_ID } from '../../model-ids.js';
+import { getShortcutDefaultModelCandidates, getShortcutDefaultModelPlan, SHORTCUT_PRODUCT_DEFAULT_MODEL_ID } from '../../shortcut-default-model.js';
+import { filterInteractiveSelectableModels } from '../session/session-models.js';
 export function formatModelRef(model) {
     return `${model.provider}/${model.id}`;
 }
@@ -37,7 +39,7 @@ export function resolveExactModelRef(availableModels, requested) {
 }
 /** Default model IDs for each provider with a preferred initial model. */
 export const defaultModelPerProvider = {
-    [SHORTCUT_PROVIDER_ID]: SHORTCUT_MODEL_ID.Gpt61Sol,
+    [SHORTCUT_PROVIDER_ID]: SHORTCUT_PRODUCT_DEFAULT_MODEL_ID,
     anthropic: SHORTCUT_MODEL_ID.ClaudeOpus5,
     openai: SHORTCUT_OPENAI_MODEL_ID,
     'azure-openai-responses': SHORTCUT_OPENAI_MODEL_ID,
@@ -57,16 +59,8 @@ export const defaultModelPerProvider = {
 };
 function getDefaultModelCandidatesForProvider(provider) {
     if (provider === SHORTCUT_PROVIDER_ID) {
-        return [
-            SHORTCUT_MODEL_ID.Gpt61Sol,
-            SHORTCUT_MODEL_ID.Gpt6Sol,
-            SHORTCUT_OPENAI_MODEL_ID,
-            SHORTCUT_MODEL_ID.ClaudeFable51,
-            SHORTCUT_MODEL_ID.ClaudeFable5,
-            SHORTCUT_MODEL_ID.ClaudeOpus5,
-            // Accounts without a paid plan see none of the models above.
-            SHORTCUT_FREE_MODEL_ID
-        ];
+        // Plan-aware and picker-listed only, matching the web app's plan default.
+        return getShortcutDefaultModelCandidates(getShortcutDefaultModelPlan());
     }
     return [defaultModelPerProvider[provider]].filter((modelId) => !!modelId);
 }
@@ -330,7 +324,8 @@ export async function findInitialModel(options) {
         return {
             model: found,
             thinkingLevel: resolveModelReasoningLevel(found, undefined),
-            fallbackMessage: undefined
+            fallbackMessage: undefined,
+            explicit: true
         };
     }
     // 2. Try saved default from settings
@@ -339,7 +334,7 @@ export async function findInitialModel(options) {
         if (found) {
             model = found;
             thinkingLevel = resolveModelReasoningLevel(found, defaultThinkingLevel);
-            return { model, thinkingLevel, fallbackMessage: undefined };
+            return { model, thinkingLevel, fallbackMessage: undefined, explicit: true };
         }
     }
     // 4. Try first available model with valid API key
@@ -353,19 +348,27 @@ export async function findInitialModel(options) {
                     return {
                         model: match,
                         thinkingLevel: resolveModelReasoningLevel(match, undefined),
-                        fallbackMessage: undefined
+                        fallbackMessage: undefined,
+                        explicit: false
                     };
                 }
             }
         }
-        // If no default found, use first available
+        // If no default found, use the first available model the picker lists.
+        const firstModel = filterInteractiveSelectableModels(availableModels)[0] ?? availableModels[0];
         return {
-            model: availableModels[0],
-            thinkingLevel: resolveModelReasoningLevel(availableModels[0], undefined),
-            fallbackMessage: undefined
+            model: firstModel,
+            thinkingLevel: resolveModelReasoningLevel(firstModel, undefined),
+            fallbackMessage: undefined,
+            explicit: false
         };
     }
     // 5. No model found
-    return { model: undefined, thinkingLevel: DEFAULT_THINKING_LEVEL, fallbackMessage: undefined };
+    return {
+        model: undefined,
+        thinkingLevel: DEFAULT_THINKING_LEVEL,
+        fallbackMessage: undefined,
+        explicit: false
+    };
 }
 //# sourceMappingURL=model-resolver.js.map

package/dist/app/services/user-context.d.ts

@@ -19,6 +19,8 @@ export interface UserInfo {
     proCreditsTier?: number | null;
     authorizedSkillTeamIds?: string[];
     additionalModelPickerEntries?: UserModelPickerEntry[];
+    /** Picker key the user's default resolves to (the org-admin-saved key for Team accounts). */
+    defaultModelPickerEntryKey?: string | null;
 }
 export interface UserModelPickerEntry {
     modelName: string;

package/dist/app/services/user-context.js

@@ -90,7 +90,10 @@ export async function fetchUserInfo(accessToken, options) {
                 plan: hasPlan ? (data.plan ?? null) : undefined,
                 proCreditsTier: data.proCreditsTier ?? null,
                 authorizedSkillTeamIds: parseAuthorizedSkillTeamIds(data),
-                ...(additionalModelPickerEntries.length > 0 ? { additionalModelPickerEntries } : {})
+                ...(additionalModelPickerEntries.length > 0 ? { additionalModelPickerEntries } : {}),
+                ...(typeof data.defaultModelPickerEntryKey === 'string'
+                    ? { defaultModelPickerEntryKey: data.defaultModelPickerEntryKey }
+                    : {})
             };
         }
         catch (error) {

package/dist/app/session/account-default-model.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Keeps a session's model in line with the signed-in account.
+ *
+ * A model the runtime resolved itself (no user pick yet) follows the account's plan
+ * default when the account changes, so a runtime that starts signed out lands on the
+ * same model as one that starts signed in. A model the user picked is kept unless the
+ * new account cannot use it.
+ */
+import type { Model } from '../../ai/types.js';
+import type { SetModelOptions } from './model-manager.js';
+export interface AccountModelSession {
+    readonly model: Model<any> | undefined;
+    readonly isModelExplicitlySelected: boolean;
+    /** The user's saved pick (settings defaultProvider/defaultModel), if any. */
+    readonly settingsManager?: {
+        getDefaultProvider(): string | undefined;
+        getDefaultModel(): string | undefined;
+    };
+    setModel(model: Model<any>, options?: SetModelOptions): Promise<void>;
+}
+export interface AccountModelRegistry {
+    find(provider: string, modelId: string): Model<any> | undefined;
+    getAvailable(): Model<any>[] | Promise<Model<any>[]>;
+}
+/** Move off a model the account's policy no longer allows, onto the plan default. */
+export declare function moveSessionOffPolicyDeniedModel(session: AccountModelSession | null | undefined, modelRegistry: AccountModelRegistry): Promise<void>;
+/**
+ * After a login or account refresh: a resolved default becomes the user's saved pick when
+ * there is one (a signed-out start cannot restore it), otherwise the account's plan default;
+ * an explicit pick is kept unless the account cannot use it.
+ */
+export declare function alignSessionModelWithAccount(session: AccountModelSession | null | undefined, modelRegistry: AccountModelRegistry): Promise<void>;
+//# sourceMappingURL=account-default-model.d.ts.map

package/dist/app/session/account-default-model.js

@@ -0,0 +1,53 @@
+import { resolveShortcutDefaultModel } from '../../shortcut-default-model.js';
+import { filterInteractiveSelectableModels } from './session-models.js';
+function sameModel(a, b) {
+    return a?.provider === b.provider && a?.id === b.id;
+}
+/** Move off a model the account's policy no longer allows, onto the plan default. */
+export async function moveSessionOffPolicyDeniedModel(session, modelRegistry) {
+    const currentModel = session?.model;
+    if (!session || !currentModel)
+        return;
+    if (modelRegistry.find(currentModel.provider, currentModel.id))
+        return;
+    const availableModels = await modelRegistry.getAvailable();
+    const fallback = resolveShortcutDefaultModel(availableModels) ??
+        filterInteractiveSelectableModels(availableModels)[0] ??
+        availableModels[0];
+    if (fallback)
+        await session.setModel(fallback, { explicit: false });
+}
+/** The user's saved pick (settings), when the account can run it. */
+function savedPick(session, availableModels) {
+    const provider = session.settingsManager?.getDefaultProvider();
+    const modelId = session.settingsManager?.getDefaultModel();
+    if (!provider || !modelId)
+        return undefined;
+    return availableModels.find((model) => model.provider === provider && model.id === modelId);
+}
+/**
+ * After a login or account refresh: a resolved default becomes the user's saved pick when
+ * there is one (a signed-out start cannot restore it), otherwise the account's plan default;
+ * an explicit pick is kept unless the account cannot use it.
+ */
+export async function alignSessionModelWithAccount(session, modelRegistry) {
+    if (!session)
+        return;
+    if (!session.isModelExplicitlySelected) {
+        const availableModels = await modelRegistry.getAvailable();
+        const pick = savedPick(session, availableModels);
+        if (pick) {
+            await session.setModel(pick);
+            return;
+        }
+        const planDefault = resolveShortcutDefaultModel(availableModels);
+        if (planDefault) {
+            if (!sameModel(session.model, planDefault)) {
+                await session.setModel(planDefault, { explicit: false });
+            }
+            return;
+        }
+    }
+    await moveSessionOffPolicyDeniedModel(session, modelRegistry);
+}
+//# sourceMappingURL=account-default-model.js.map

package/dist/app/session/model-manager.d.ts

@@ -21,14 +21,25 @@ export interface ModelManagerAgent {
     setModel(model: Model<any>): void;
     setThinkingLevel(level: ThinkingLevel): void;
 }
+export interface SetModelOptions {
+    /**
+     * False when the runtime picks the model itself (the plan default after login, a
+     * policy fallback). Such a pick is not saved as the user's default model and may be
+     * re-resolved when the account changes. Defaults to true: a user selection.
+     */
+    explicit?: boolean;
+}
 export declare class ModelManager {
     private readonly _agent;
     private readonly _modelRegistry;
     private readonly _sessionManager;
     private readonly _settingsManager;
-    constructor(_agent: ModelManagerAgent, _modelRegistry: AgentModelRegistry, _sessionManager: ModelSessionStore, _settingsManager: RuntimeDefaultsStore);
-    /** Set a specific model. Validates API key and persists. */
-    setModel(model: Model<any>): Promise<void>;
+    private _explicit;
+    constructor(_agent: ModelManagerAgent, _modelRegistry: AgentModelRegistry, _sessionManager: ModelSessionStore, _settingsManager: RuntimeDefaultsStore, initialModelExplicit?: boolean);
+    /** True when the current model is the user's choice rather than a resolved default. */
+    get isExplicit(): boolean;
+    /** Set a specific model. Validates API key; persists as the default only for user picks. */
+    setModel(model: Model<any>, options?: SetModelOptions): Promise<void>;
     /** Cycle to the next available model. Returns result or undefined if none available. */
     cycleModel(direction?: 'forward' | 'backward'): Promise<ModelCycleResult | undefined>;
     /**

package/dist/app/session/model-manager.js

@@ -16,16 +16,24 @@ export class ModelManager {
     _modelRegistry;
     _sessionManager;
     _settingsManager;
-    constructor(_agent, _modelRegistry, _sessionManager, _settingsManager) {
+    _explicit;
+    constructor(_agent, _modelRegistry, _sessionManager, _settingsManager, initialModelExplicit = true) {
         this._agent = _agent;
         this._modelRegistry = _modelRegistry;
         this._sessionManager = _sessionManager;
         this._settingsManager = _settingsManager;
+        this._explicit = initialModelExplicit;
     }
-    /** Set a specific model. Validates API key and persists. */
-    async setModel(model) {
+    /** True when the current model is the user's choice rather than a resolved default. */
+    get isExplicit() {
+        return this._explicit;
+    }
+    /** Set a specific model. Validates API key; persists as the default only for user picks. */
+    async setModel(model, options = {}) {
         await this._validateApiKey(model);
-        this._applyAndPersist(model);
+        const explicit = options.explicit ?? true;
+        this._applyAndPersist(model, explicit);
+        this._explicit = explicit;
         this.setThinkingLevel(this._agent.state.thinkingLevel);
     }
     /** Cycle to the next available model. Returns result or undefined if none available. */
@@ -35,7 +43,8 @@ export class ModelManager {
         if (!next)
             return undefined;
         await this._validateApiKey(next);
-        this._applyAndPersist(next);
+        this._applyAndPersist(next, true);
+        this._explicit = true;
         this.setThinkingLevel(this._agent.state.thinkingLevel);
         return { model: next, thinkingLevel: this._agent.state.thinkingLevel };
     }
@@ -45,6 +54,8 @@ export class ModelManager {
      */
     async restoreModel(model) {
         this._agent.setModel(model);
+        // A resumed session keeps the model it was using; login does not replace it.
+        this._explicit = true;
     }
     /** Set thinking level, clamped to model capabilities. Persists only on change. */
     setThinkingLevel(level) {
@@ -75,10 +86,11 @@ export class ModelManager {
         if (!apiKey)
             throw new Error(`No API key for ${model.provider}/${model.id}`);
     }
-    _applyAndPersist(model) {
+    _applyAndPersist(model, saveAsDefault) {
         this._agent.setModel(model);
         this._sessionManager.appendModelChange(model.provider, model.id);
-        this._settingsManager.setDefaultModelAndProvider(model.provider, model.id);
+        if (saveAsDefault)
+            this._settingsManager.setDefaultModelAndProvider(model.provider, model.id);
     }
 }
 //# sourceMappingURL=model-manager.js.map