feat: remember the last chosen model and prefer newer versions in ranking

Removing every provider and re-adding one made new sessions start on
zai/glm-5.2 instead of the zai/glm-5.3-flash that was in use. Two causes.

Nothing recorded which model the user had actually chosen. default_model was
the only memory of it, and the provider-removal cascade clears that pointer
when the removed provider owned it; the value was then re-derived from a
ranking and the choice was lost for good.

The ranking's final tie-break also preferred older versions. Candidates tied
on capability and context window fell through to an ascending id comparison,
so "5.2" sorted before "5.3" and the oldest sibling won.

Add a last_used_model config key alongside default_model, owned by
IModelService and persisted through the same bridge as the default pointer.
Default resolution now prefers the configured default, then the last chosen
model, then the highest-ranked resolvable candidate, then the empty state.
It is written only on an explicit switch through the session profile route,
never from profile binding or the automatic fallback, and it is never
cascade-cleared: a pointer at a missing model is inert because every read is
readiness-gated, which is what lets a choice survive a provider round-trip.

Order equally capable candidates by provider ascending, then model part
descending with numeric collation, then full id for a total order. Splitting
on the first slash only keeps compound model ids intact.

Also fixes a defect this exposed: the models-section arm of
onConfigSectionChanged re-hydrated the registry without the last-used value,
resetting it and cascading the clear into config.toml.

Author: elkaix

.changeset/remember-last-used-model.md

@@ -0,0 +1,5 @@
+---
+"@pymodel/pythinker-code": minor
+---
+
+Your last chosen model is now remembered and restored when your configured default becomes unavailable, and equally capable models now prefer newer versions.

packages/agent-core-v2/docs/config-manifest.toml

@@ -8,7 +8,7 @@
 # commented "# field: type" lines describe the remaining schema fields.
 # Values resolve as: default -> config.toml -> env overlay -> memory.
 
-# Index (28 sections · 2 overlay(s))
+# Index (29 sections · 2 overlay(s))
 #   advisor                  src/session/advisor/configSection.ts
 #   background               src/agent/task/configSection.ts
 #   builtinProductSkills     src/features/skill/catalog/configSection.ts
@@ -22,6 +22,7 @@
 #   hooks                    src/features/externalHooks/configSection.ts
 #   identity                 src/app/agentIdentity/configSection.ts
 #   image                    src/agent/media/configSection.ts
+#   lastUsedModel            src/app/kosongConfig/configSection.ts
 #   llm                      src/app/kosongConfig/configSection.ts
 #   loopControl              src/agent/loop/configSection.ts
 #   mcp                      src/app/mcpConfig/configSection.ts
@@ -203,6 +204,14 @@ extra_skill_dirs = []
 # max_edge_px: integer
 # read_byte_budget: integer
 
+# ##########################################################################
+# lastUsedModel (config.toml: last_used_model)
+#   owner: src/app/kosongConfig/configSection.ts
+#   scope: core
+# ##########################################################################
+
+# last_used_model: string
+
 # ##########################################################################
 # llm
 #   owner: src/app/kosongConfig/configSection.ts

packages/agent-core-v2/src/app/kosongConfig/configSection.ts

@@ -144,6 +144,8 @@ export const MODELS_SECTION = 'models';
 
 export const DEFAULT_MODEL_SECTION = 'defaultModel';
 
+export const LAST_USED_MODEL_SECTION = 'lastUsedModel';
+
 const ModelBaseSchema = z.object({
   providerId: z.string().optional(),
 
@@ -260,6 +262,8 @@ registerConfigSection(MODELS_SECTION, ModelsSectionSchema, {
   toToml: modelsToToml,
 });
 
+registerConfigSection(LAST_USED_MODEL_SECTION, z.string().optional());
+
 export const THINKING_SECTION = 'thinking';
 
 export const ThinkingConfigSchema = z.object({

packages/agent-core-v2/src/app/kosongConfig/kosongConfigService.ts

@@ -14,6 +14,7 @@ import { IKosongConfigService } from './kosongConfig';
 import {
   DEFAULT_MODEL_SECTION,
   DEFAULT_PROVIDER_SECTION,
+  LAST_USED_MODEL_SECTION,
   MODELS_SECTION,
   PROVIDERS_SECTION,
 } from './configSection';
@@ -51,6 +52,7 @@ export class KosongConfigService extends Disposable implements IKosongConfigServ
     this.models.loadAll(
       this.config.get<ModelsSection>(MODELS_SECTION) ?? {},
       this.config.get<string>(DEFAULT_MODEL_SECTION),
+      this.config.get<string>(LAST_USED_MODEL_SECTION),
     );
     this._register(this.config.onDidSectionChange((e) => this.onConfigSectionChanged(e)));
     this._register(
@@ -83,6 +85,12 @@ export class KosongConfigService extends Disposable implements IKosongConfigServ
         e.waitUntil(this.enqueuePersistDefaultPointer(DEFAULT_MODEL_SECTION, e.id));
       }),
     );
+    this._register(
+      this.models.onDidChangeLastUsedModel((e) => {
+        if (this.config.get<string>(LAST_USED_MODEL_SECTION) === e.id) return;
+        e.waitUntil(this.enqueuePersistDefaultPointer(LAST_USED_MODEL_SECTION, e.id));
+      }),
+    );
   }
 
   private onConfigSectionChanged(e: ConfigSectionChangedEvent): void {
@@ -97,6 +105,7 @@ export class KosongConfigService extends Disposable implements IKosongConfigServ
         this.models.loadAll(
           (e.value as ModelsSection | undefined) ?? {},
           this.models.getDefaultModel(),
+          this.models.getLastUsedModel(),
         );
         break;
       case DEFAULT_PROVIDER_SECTION:
@@ -109,6 +118,11 @@ export class KosongConfigService extends Disposable implements IKosongConfigServ
           .setDefaultModel(e.value as string | undefined)
           .catch((error) => this.logPersistFailure(error));
         break;
+      case LAST_USED_MODEL_SECTION:
+        void this.models
+          .setLastUsedModel(e.value as string | undefined)
+          .catch((error) => this.logPersistFailure(error));
+        break;
     }
   }
 
@@ -142,6 +156,10 @@ export class KosongConfigService extends Disposable implements IKosongConfigServ
         void this.models
           .setDefaultModel(effective)
           .catch((error) => this.logPersistFailure(error));
+      } else if (domain === LAST_USED_MODEL_SECTION) {
+        void this.models
+          .setLastUsedModel(effective)
+          .catch((error) => this.logPersistFailure(error));
       }
     });
   }

packages/agent-core-v2/src/kosong/model/defaultModelPolicy.ts

@@ -21,17 +21,34 @@ export function rankDefaultModelCandidates(models: ModelsSection): string[] {
     .toSorted((a, b) => {
       if (a.declaresToolUse !== b.declaresToolUse) return a.declaresToolUse ? -1 : 1;
       if (a.context !== b.context) return b.context - a.context;
+      const aParts = splitModelId(a.id);
+      const bParts = splitModelId(b.id);
+      if (aParts.providerId !== bParts.providerId) {
+        return aParts.providerId.localeCompare(bParts.providerId);
+      }
+      const byModelPart = bParts.modelPart.localeCompare(aParts.modelPart, 'en', {
+        numeric: true,
+      });
+      if (byModelPart !== 0) return byModelPart;
       return a.id.localeCompare(b.id);
     })
     .map((candidate) => candidate.id);
 }
 
+function splitModelId(id: string): { readonly providerId: string; readonly modelPart: string } {
+  const slash = id.indexOf('/');
+  if (slash === -1) return { providerId: '', modelPart: id };
+  return { providerId: id.slice(0, slash), modelPart: id.slice(slash + 1) };
+}
+
 export function resolveDefaultModel(
   models: ModelsSection,
   current: string | undefined,
   isReady: (id: string) => boolean = () => true,
+  lastUsed?: string,
 ): string | undefined {
   if (current !== undefined && isReady(current)) return current;
+  if (lastUsed !== undefined && isReady(lastUsed)) return lastUsed;
   return rankDefaultModelCandidates(models).find((candidate) => isReady(candidate));
 }
 

packages/agent-core-v2/src/kosong/model/model.ts

@@ -71,14 +71,17 @@ export interface IModelService {
   readonly settled: Promise<void>;
   readonly onDidChangeModels: Event<ModelsChangedEvent & IWaitUntil>;
   readonly onDidChangeDefaultModel: Event<DefaultModelChangedEvent & IWaitUntil>;
+  readonly onDidChangeLastUsedModel: Event<DefaultModelChangedEvent & IWaitUntil>;
   get(id: string): ModelRecord | undefined;
   list(): Readonly<Record<string, ModelRecord>>;
   getDefaultModel(): string | undefined;
+  getLastUsedModel(): string | undefined;
   set(id: string, model: ModelRecord): Promise<void>;
   delete(id: string): Promise<void>;
-  loadAll(models: ModelsSection, defaultModel: string | undefined): void;
+  loadAll(models: ModelsSection, defaultModel: string | undefined, lastUsedModel?: string): void;
   replaceAll(models: ModelsSection): Promise<void>;
   setDefaultModel(id: string | undefined): Promise<void>;
+  setLastUsedModel(id: string | undefined): Promise<void>;
 }
 
 export const IModelService: ServiceIdentifier<IModelService> =

packages/agent-core-v2/src/kosong/model/modelService.ts

@@ -25,6 +25,7 @@ export class ModelService extends Disposable implements IModelService {
 
   private models: Readonly<Record<string, ModelRecord>> = {};
   private defaultModel: string | undefined;
+  private lastUsedModel: string | undefined;
   private settling: Promise<void> = Promise.resolve();
   private hydrated = false;
   private resolveReady!: () => void;
@@ -49,6 +50,11 @@ export class ModelService extends Disposable implements IModelService {
   );
   readonly onDidChangeDefaultModel: Event<DefaultModelChangedEvent & IWaitUntil> =
     this._onDidChangeDefaultModel.event;
+  private readonly _onDidChangeLastUsedModel = this._register(
+    new AsyncEmitter<DefaultModelChangedEvent & IWaitUntil>(),
+  );
+  readonly onDidChangeLastUsedModel: Event<DefaultModelChangedEvent & IWaitUntil> =
+    this._onDidChangeLastUsedModel.event;
 
   get settled(): Promise<void> {
     return this.settling;
@@ -66,9 +72,14 @@ export class ModelService extends Disposable implements IModelService {
     return this.defaultModel;
   }
 
-  loadAll(models: ModelsSection, defaultModel: string | undefined): void {
+  getLastUsedModel(): string | undefined {
+    return this.lastUsedModel;
+  }
+
+  loadAll(models: ModelsSection, defaultModel: string | undefined, lastUsedModel?: string): void {
     void this.applyRecords(models);
     void this.applyDefaultModel(defaultModel);
+    void this.applyLastUsedModel(lastUsedModel);
     this.settling = this.settleDefaultModel();
     if (!this.hydrated) {
       this.hydrated = true;
@@ -102,11 +113,22 @@ export class ModelService extends Disposable implements IModelService {
     await this.applyDefaultModel(id);
   }
 
+  async setLastUsedModel(id: string | undefined): Promise<void> {
+    await this.ready;
+    await this.applyLastUsedModel(id);
+  }
+
   private settleDefaultModel(): Promise<void> {
     const current = this.defaultModel;
+    const lastUsed = this.lastUsedModel;
     const resolve = (id: string) =>
       resolveModelForReady(id, this.models, this.providers.list(), this.providers.getDefaultProvider());
-    const next = resolveDefaultModel(this.models, current, (id) => resolve(id).resolved);
+    const next = resolveDefaultModel(
+      this.models,
+      current,
+      (id) => resolve(id).resolved,
+      lastUsed,
+    );
     const currentResolution = current === undefined ? undefined : resolve(current);
     if (
       currentResolution !== undefined &&
@@ -145,6 +167,12 @@ export class ModelService extends Disposable implements IModelService {
     this.defaultModel = id;
     await this._onDidChangeDefaultModel.fireAsync({ id }, NO_ABORT);
   }
+
+  private async applyLastUsedModel(id: string | undefined): Promise<void> {
+    if (this.lastUsedModel === id) return;
+    this.lastUsedModel = id;
+    await this._onDidChangeLastUsedModel.fireAsync({ id }, NO_ABORT);
+  }
 }
 
 registerScopedService(LifecycleScope.App, IModelService, ModelService, ScopeActivation.OnScopeCreated, 'model');

packages/agent-core-v2/test/app/kosongConfig/kosongConfigService.test.ts

@@ -4,6 +4,7 @@ import { ILogService, type LogPayload } from '#/_base/log/log';
 import {
   DEFAULT_MODEL_SECTION,
   DEFAULT_PROVIDER_SECTION,
+  LAST_USED_MODEL_SECTION,
   MODELS_SECTION,
   PROVIDERS_SECTION,
 } from '#/app/kosongConfig/configSection';
@@ -100,6 +101,18 @@ describe('KosongConfigService startup hydration', () => {
     expect(models.list()).toEqual({});
     expect(models.getDefaultModel()).toBeUndefined();
   });
+
+  it('hydrates the last-used model pointer from config', async () => {
+    const { models } = await createBridge({ ...seededSections, lastUsedModel: 'k1' });
+
+    expect(models.getLastUsedModel()).toBe('k1');
+  });
+
+  it('leaves the last-used pointer unset when config does not carry one', async () => {
+    const { models } = await createBridge(seededSections);
+
+    expect(models.getLastUsedModel()).toBeUndefined();
+  });
 });
 
 describe('KosongConfigService kosong → config persistence', () => {
@@ -158,6 +171,23 @@ describe('KosongConfigService kosong → config persistence', () => {
       bridge.dispose();
     }
   });
+
+  it('persists the last-used model pointer', async () => {
+    const { config, models, bridge } = await createBridge(seededSections);
+    try {
+      await models.setLastUsedModel('k1');
+      await flush();
+
+      expect(config.get<string>(LAST_USED_MODEL_SECTION)).toBe('k1');
+
+      await models.setLastUsedModel(undefined);
+      await flush();
+
+      expect(config.get<string>(LAST_USED_MODEL_SECTION)).toBeUndefined();
+    } finally {
+      bridge.dispose();
+    }
+  });
 });
 
 describe('KosongConfigService awaited-mutation semantics', () => {
@@ -261,6 +291,10 @@ describe('KosongConfigService config → kosong sync', () => {
       await config.replace(DEFAULT_PROVIDER_SECTION, 'openai');
       await flush();
       expect(providers.getDefaultProvider()).toBe('openai');
+
+      await config.replace(LAST_USED_MODEL_SECTION, 'k2');
+      await flush();
+      expect(models.getLastUsedModel()).toBe('k2');
     } finally {
       bridge.dispose();
     }
@@ -311,6 +345,35 @@ describe('KosongConfigService loop termination', () => {
   });
 });
 
+describe('KosongConfigService last-used model survival', () => {
+  it('keeps last_used_model in config when the models section is wiped and the default pointer clears', async () => {
+    const { config, models, bridge } = await createBridge({
+      ...seededSections,
+      lastUsedModel: 'k1',
+    });
+    try {
+      expect(models.getDefaultModel()).toBe('k1');
+
+      await config.replace(MODELS_SECTION, {});
+      await flush();
+
+      expect(models.list()).toEqual({});
+      expect(models.getDefaultModel()).toBeUndefined();
+      expect(config.get<string>(DEFAULT_MODEL_SECTION)).toBeUndefined();
+      expect(config.get<string>(LAST_USED_MODEL_SECTION)).toBe('k1');
+      expect(models.getLastUsedModel()).toBe('k1');
+
+      await config.replace(MODELS_SECTION, { k1: K1_MODEL });
+      await flush();
+
+      expect(models.getDefaultModel()).toBe('k1');
+      expect(config.get<string>(DEFAULT_MODEL_SECTION)).toBe('k1');
+    } finally {
+      bridge.dispose();
+    }
+  });
+});
+
 describe('KosongConfigService default-provider deletion', () => {
   it('clears the pointer when the default provider is deleted and persists the cleared pointer', async () => {
     const { config, providers, bridge } = await createBridge({