agentus 0.15.5 → 0.15.7

package/README.md

@@ -57,7 +57,7 @@ background process comes back as a turn of its own), an **ACP session that write
 cockpit-side failure is diagnosable afterwards), and a **DeepSeek web backend** (search +
 extract on the model key) — come from the fork's integration build instead. That is a five-line install:
 [§ Which Hermes to run](docs/installation.md#which-hermes-to-run) — currently the tag
-`agentus/v0.22.0/merge-20261028-1949`, on Hermes `v0.22.0`.
+`agentus/v0.22.0/merge-20261028-2028`, on Hermes `v0.22.0`.
 
 The first slot you start will use the Hermes home **your own agent already uses**
 (`~/.hermes`) unless the backend row names another one — see "HERMES_HOME" below.

package/README.zh-CN.md

@@ -51,7 +51,7 @@ web bundle、配套 APK —— 然后直接退出，不启动任何东西）。
 以及 **DeepSeek 的 web 后端**（搜索 + 正文抓取，共用模型 key）—— 来自 fork 的集成构建（tag）。
 装法就五行：
 [§ 该跑哪份 Hermes](docs/installation.zh-CN.md#该跑哪份-hermes) —— 当前是 tag
-`agentus/v0.22.0/merge-20261028-1949`，基座 Hermes `v0.22.0`。
+`agentus/v0.22.0/merge-20261028-2028`，基座 Hermes `v0.22.0`。
 
 你启动的第一个 slot 会使用**你自己的 agent 已经在用的**那个 Hermes home（`~/.hermes`），除非后端那一行
 指定了另一个 —— 见下面的「HERMES_HOME」。

package/docs/installation.md

@@ -60,7 +60,7 @@ ref and gets rebuilt, while a tag never moves — so pin the tag. The `agentus/`
 ours apart from upstream's own tags (`v0.22.0`, `v0.22.0+canary.*`), and the timestamp in the
 last segment sorts, so "newest" is a `sort -V`.
 
-**Current integration build: `agentus/v0.22.0/merge-20261028-1949`** — the newest tag on the fork,
+**Current integration build: `agentus/v0.22.0/merge-20261028-2028`** — the newest tag on the fork,
 built on Hermes `v0.22.0`. This line is for orientation only, not the source of truth: the
 `TAG=$(…)` step below resolves the newest one on every run, so read it there if this sentence
 ever looks stale.

package/docs/installation.zh-CN.md

@@ -52,7 +52,7 @@ agentus/<hermes 内部版本>/merge-<YYYYMMDD-HHMM>
 tag。`agentus/` 这个前缀也把它和上游自己的 tag（`v0.22.0`、`v0.22.0+canary.*`）分开；最后一段是时间戳，
 可排序，所以「最新」就是一次 `sort -V`。
 
-**当前集成构建：`agentus/v0.22.0/merge-20261028-1949`** —— fork 上最新的那个 tag，基座 Hermes
+**当前集成构建：`agentus/v0.22.0/merge-20261028-2028`** —— fork 上最新的那个 tag，基座 Hermes
 `v0.22.0`。这行只为一眼看个大概，不是权威：下面的 `TAG=$(…)` 每次都会自己解析出最新，觉得这行过期就
 以它为准。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentus",
-  "version": "0.15.5",
+  "version": "0.15.7",
   "description": "Multi-session web cockpit for ACP-speaking coding agents (Qoder CLI / Hermes). UI has no intelligence — the agent lives in spawned CLI subprocesses.",
   "license": "Apache-2.0",
   "repository": {

package/packages/server/src/acp/session-manager.ts

@@ -1402,7 +1402,11 @@ export class SessionManager {
         // 就会改到默认 profile 的默认模型上，当前会话那个 profile 反而没变。
         profile: shape.spec.profile ?? null,
       });
-      if (!r.ok) console.log(`[agentus] model default not written (${info.backend}): ${r.reason}`);
+      if (!r.ok) {
+        // 唯一一处"操作者需要动手"的失败：set-model 已经把成功回给页面了，这句日志如果不显眼，
+        // 下一次新会话会悄悄退回到旧默认（#72 的症状原样回来）。所以带上 backend 与会话，稳定可 grep。
+        console.warn(`[agentus] modelWriteBack: refused for ${info.id} (${info.backend}, picked ${modelId}): ${r.reason}`);
+      }
       else if (r.changed) {
         console.log(`[agentus] model default → ${r.model ?? modelId}${r.provider ? ` (provider ${r.provider})` : ""} for ${info.backend} (picked ${modelId})`);
       }
@@ -3092,6 +3096,9 @@ export class SessionManager {
       if (!row) throw new Error(`no such session: ${id}`);
       const known = ((row.models ?? null) as SessionInfo["models"])?.availableModels ?? [];
       if (known.length && !known.some((m) => m.modelId === modelId)) {
+        // 重放的是对话框里的旧值：这一行的清单已经不认它了。不是操作者的错，也不该变成一条红色
+        // 错误：什么都不做，让会话按自己的默认起来（缓存那份由下一次启动的握手刷掉）。
+        if (opts.fromReplay) return this.#coldInfo(id);
         throw new Error(`unknown model: ${modelId}`);
       }
       if (!this.#store.setPendingModel(id, modelId)) throw new Error(`no such session: ${id}`);
@@ -3103,6 +3110,14 @@ export class SessionManager {
     if (!conn || !s.info.acpSessionId) throw new Error("session not ready — resume it first");
     const known = s.info.models?.availableModels ?? [];
     if (known.length && !known.some((m) => m.modelId === modelId)) {
+      if (opts.fromReplay) {
+        // 同上，但活会话有更新的清单在手上：顺手把缓存里的陈旧 id 换掉，下一次对话框就显示真的默认。
+        this.#store.recordHandshakeModels(s.info.backend, {
+          currentModelId: s.info.models?.currentModelId ?? null,
+          available: known.map((m) => m.modelId).filter(Boolean),
+        });
+        return s.info;
+      }
       throw new Error(`unknown model: ${modelId}`);
     }
     const reply = await conn.request("session/set_model", { sessionId: s.info.acpSessionId, modelId });
@@ -3125,15 +3140,19 @@ export class SessionManager {
     }
     // #72：缓存握手是"上一次真启动"的快照，新建会话对话框只读它 —— 换了模型却不改它，对话框会一直
     // 显示（并且把）切换前的那个 id 当中文默认值。活会话手里有完整清单，顺手把两份都刷新。
+    // 以**活会话**为准：agent 可能在回复里规范化了 id（或表示"没变"），那时缓存的默认值必须跟它走，
+    // 否则对话框显示的、重放的，都是槽位没在跑的那个 id（MINOR 4）。
     this.#store.recordHandshakeModels(s.info.backend, {
-      currentModelId: modelId,
+      currentModelId: s.info.models?.currentModelId ?? modelId,
       available: (s.info.models?.availableModels ?? []).map((m) => m.modelId).filter(Boolean),
     });
     if (s.info.pendingModelId) s.info.pendingModelId = null;
     this.#store.setPendingModel(id, null);
     // #62-1: 只有 agent **接受**过的切换才计数 —— 被拒的条目永不加分，于是"广告了但实际不可用"
     // 的模型会自己沉到列表底部，不需要任何端点探活。
-    bumpModelUsage(`${s.info.backend}|${modelId}`);
+    // 重放（新建会话时把对话框里的选择下发）不是操作者的切换动作：既不该改写全局默认，也不该给
+    // 「常用模型」加分，否则排序量的是"起了多少会话"，不是"选了哪个模型"（#72 review MINOR 6）。
+    if (!opts.fromReplay) bumpModelUsage(`${s.info.backend}|${modelId}`);
     // #62-3：选定即成为 agent 的全局默认（设置里可关）。同样只在这一行之后 —— 被拒的模型不落盘。
     // **重放不算**：冷槽上留下的意图可能被一次无人值守的 completion 唤醒带上（resume <-
     // `this.resume(e.origin)`），那时代码里没有"操作者在选模型"这件事，不该改全局配置。

package/packages/server/src/index.ts

@@ -2159,7 +2159,7 @@ wss.on("connection", (ws) => {
           await mgr.setConfig(cmd.sessionId, cmd.configId, cmd.value);
           break;
         case "set-model":
-          await mgr.setModel(cmd.sessionId, cmd.modelId);
+          await mgr.setModel(cmd.sessionId, cmd.modelId, { fromReplay: cmd.fromReplay === true });
           break;
         case "respond-permission": {
           const applied = mgr.respondPermission(cmd.sessionId, cmd.requestId, cmd.decision, {

package/packages/server/src/model-default.ts

@@ -126,8 +126,17 @@ function setKey(lines: string[], key: string, value: string, indent: string): st
 export interface EndpointInfo {
   /** 持久身份：`custom:<config 键>`（legacy 条目用规范化后的 name） */
   id: string;
+  /** 条目自己声明的端点；`null` = 这个块没有端点（见 `namedEndpoints` 为什么跳过它） */
   apiUrl: string | null;
   apiMode: string | null;
+  /** 条目声明的模型 id；`models:` 没写就是空数组（靠发现拿模型的那种条目） */
+  models: string[];
+}
+
+/** 一张表两个命名空间：**键**是身份，**显示名**只是弱别名。 */
+export interface NamedEndpoints {
+  byKey: Map<string, EndpointInfo>;
+  byAlias: Map<string, EndpointInfo>;
 }
 
 /** hermes 的 `custom_provider_slug`：小写、空格换连字符、补 `custom:` 前缀。 */
@@ -138,25 +147,49 @@ const customSlug = (display: string): string => {
 
 const bareName = (id: string): string => id.trim().toLowerCase().replace(/^custom:/, "");
 
-/** hermes 的 `is_provider_enabled`：`enabled:` 的假值一律视为停用。 */
+/** hermes 的 `is_provider_enabled`：假值一律视为停用（非字符串非布尔的容器值按 truthiness）。 */
 const isDisabled = (entry: Record<string, unknown>): boolean => {
   const raw = entry.enabled;
   if (raw === undefined || raw === null) return false;
   if (typeof raw === "boolean") return !raw;
-  return ["false", "no", "off", "0", "disabled"].includes(String(raw).trim().toLowerCase());
+  if (typeof raw === "string") {
+    return ["false", "no", "off", "0", "disabled"].includes(raw.trim().toLowerCase());
+  }
+  return !raw;
+};
+
+/** 条目声明的模型 id（`models:` 里元素可以是字符串或 `{id|model|name}`）。 */
+const declaredModels = (entry: Record<string, unknown>): string[] => {
+  const raw = entry.models;
+  if (!Array.isArray(raw)) return [];
+  const out: string[] = [];
+  for (const item of raw) {
+    const value = typeof item === "string" ? item
+      : item && typeof item === "object" ? ((item as Record<string, unknown>).id
+        ?? (item as Record<string, unknown>).model ?? (item as Record<string, unknown>).name) : null;
+    const text = typeof value === "string" ? value.trim() : "";
+    if (text) out.push(text);
+  }
+  return out;
 };
 
-/** 配置里的命名端点，**键是持久身份** `custom:<条目>`；显示名另作别名指向同一条目。
+/** 配置里**真的能路由**的命名端点：键是持久身份 `custom:<条目>`，显示名另作弱别名。
+ *
+ *  三条判据都是 hermes 自己的：
  *
- *  为什么别名也进这张表：choice id 是身份的权威来源（`custom:<键>:<模型>`），但旧形状
- *  （`custom:<模型>`）与裸模型名只剩描述里的**显示名**可用。用显示名当 `model.provider` 写下去，
- *  一旦操作者改了 `name:`，那份配置就再也解析不回来 —— 所以别名必须翻译成 `custom:<键>`，
- *  而不是跟着名字走。
+ *  1. **没有端点的块不是命名端点。** `providers.bedrock: {stale_timeout_seconds: 600}` 是给内置
+ *     provider 调参的，`_pick_provider_base_url` 为空的条目会被 `get_compatible_custom_providers`
+ *     丢掉、`resolve_user_provider` 也不认 —— 把它当端点写下去，`custom:bedrock` 是个谁都不认识的
+ *     身份，还会顺手删掉块里唯一能路由的 `base_url`。所以这种块整条跳过。
+ *  2. **停用条目不存在**（`enabled: false`）：写进 `model.provider` 等于让下一次 spawn 起不来。
+ *  3. **别名永不覆盖键。** 条目 A 的 `name:` 可能与条目 B 的键同名；键是身份、别名只是「描述里印的
+ *     是哪个名字」，所以别名只在键查不到时用，且先到先得（hermes 的解析也是取第一个匹配）。
  *
- *  端点字段的顺序照 hermes 的 `_pick_provider_base_url`：`base_url` → `url` → `api`。
- *  `api_url` 是 inventory 行（运行时）的字段，不是 config 键；它只作为最后的容错。 */
-export function namedEndpoints(doc: unknown): Map<string, EndpointInfo> {
-  const out = new Map<string, EndpointInfo>();
+ *  端点字段顺序照 hermes 的 `_pick_provider_base_url`：`base_url` → `url` → `api`。
+ *  `api_url` 是 inventory 行（运行时）的字段，不是 config 键；只作最后容错。 */
+export function namedEndpoints(doc: unknown): NamedEndpoints {
+  const byKey = new Map<string, EndpointInfo>();
+  const byAlias = new Map<string, EndpointInfo>();
   const endpointOf = (entry: Record<string, unknown>): string | null => {
     for (const key of ["base_url", "url", "api", "api_url"]) {
       const value = entry[key];
@@ -165,10 +198,20 @@ export function namedEndpoints(doc: unknown): Map<string, EndpointInfo> {
     return null;
   };
   const add = (id: string, entry: Record<string, unknown>): void => {
-    const info: EndpointInfo = { id, apiUrl: endpointOf(entry), apiMode: typeof entry.api_mode === "string" ? entry.api_mode : null };
-    out.set(id, info);
+    const apiUrl = endpointOf(entry);
+    if (!apiUrl) return; // 见上：调参块不是端点
+    const info: EndpointInfo = {
+      id, apiUrl,
+      apiMode: typeof entry.api_mode === "string" ? entry.api_mode : null,
+      models: declaredModels(entry),
+    };
+    // 同一个键写两遍时后者覆盖（YAML 本身也不允许），但别名绝不覆盖任何已存在的**键**。
+    byKey.set(id, info);
     const display = typeof entry.name === "string" ? entry.name.trim() : "";
-    if (display) out.set(customSlug(display), info);
+    if (display) {
+      const alias = customSlug(display);
+      if (!byKey.has(alias) && !byAlias.has(alias)) byAlias.set(alias, info);
+    }
   };
   const d = (doc ?? {}) as { providers?: unknown; custom_providers?: unknown };
   const providers = d.providers;
@@ -176,7 +219,7 @@ export function namedEndpoints(doc: unknown): Map<string, EndpointInfo> {
     for (const [key, entry] of Object.entries(providers as Record<string, unknown>)) {
       if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
       const raw = entry as Record<string, unknown>;
-      if (isDisabled(raw)) continue; // hermes 不认停用条目：写进 provider 等于让下一次 spawn 起不来
+      if (isDisabled(raw)) continue;
       // 键是身份（显示名可以改），和 hermes 的 custom_provider_slug(display, key) 同一个取向。
       add(customSlug(key), raw);
     }
@@ -192,82 +235,99 @@ export function namedEndpoints(doc: unknown): Map<string, EndpointInfo> {
       add(customSlug(name), raw);
     }
   }
-  return out;
+  return { byKey, byAlias };
 }
 
 export interface ChoiceSplit {
   /** hermes `model.default` 该写的值：裸模型名 */
   model: string;
-  /** hermes `model.provider` 该写的值；null = 推不出来，保持原样 */
+  /** hermes `model.provider` 该写的值；null = 推不出来，**保持原样**（不猜） */
   provider: string | null;
-  /** true = 这个 id 描述了一个本配置里不存在的条目：**不许写**，也算不出可信的模型名 */
+  /** true = 这个 id 描述了一个本配置里没有的条目，且连 provider 都定不下来：不许写 */
   unresolved?: boolean;
 }
 
 /** 把选择器的 choice id 拆回 `(裸模型名, 持久 provider 身份)`。
  *
  *  规则就是 hermes 自己的那条：provider 只在左半段是**已知 provider/条目**时才算分隔符，
- *  否则整串都是模型名（`anthropic/claude-3.5-sonnet:beta` 不能被切）。条目名到身份的映射由
- *  `namedEndpoints` 提供，所以这里不需要再猜"哪些名字是 provider"。 */
+ *  否则整串都是模型名（`anthropic/claude-3.5-sonnet:beta` 不能被切）。
+ *
+ *  描述（`Provider: <名字>`）只当**弱**信号用，这是这里最容易错的地方：
+ *  - 它印的是条目的**显示名**，可能与另一个条目/内置 provider 重名，所以只有「条目自己声明了这个
+ *    模型」时它才算证据（否则 `OpenRouter` 这个显示名会把内置 openrouter 的 pick 拽到本地代理上）；
+ *  - 带前缀的 id（`<左段>:<模型>`）里左段不是键时一律按 canonical/provider 读，不看描述 —— 行自己
+ *    带来的前缀比描述更权威；
+ *  - 什么都推不出来时返回 `provider: null`（调用方保持 `model.provider` 原样），不写一个不存在的
+ *    slug —— 那会让下一次 spawn 拿到一个解析不了的 provider。 */
 export function splitChoiceId(
   modelId: string,
   providerHint: string | null,
-  endpoints: Map<string, EndpointInfo>,
+  named: NamedEndpoints,
 ): ChoiceSplit {
   const raw = (modelId ?? "").trim();
   if (!raw) return { model: raw, provider: null };
   const lowered = raw.toLowerCase();
+  const hintSlug = providerHint
+    ? (providerHint.includes(":") ? providerHint.trim().toLowerCase() : customSlug(providerHint))
+    : null;
+  const keyInfo = hintSlug ? named.byKey.get(hintSlug) : undefined;
+  const aliasInfo = hintSlug && !keyInfo ? named.byAlias.get(hintSlug) : undefined;
+  /** 描述指向的条目身份（键优先，别名次之）。只在 `custom:` 前缀已经把「这是条目」说清的地方用。 */
+  const hintEntryId = keyInfo?.id ?? aliasInfo?.id ?? null;
+  /** 描述本身长得像一个 provider slug（而不是一句显示名）：`Alibaba` / `kimi-coding`。 */
+  const hintIsSlug = Boolean(hintSlug && /^[a-z0-9][a-z0-9._-]*$/.test(hintSlug.replace(/^custom:/, "")));
+  const declares = (info: EndpointInfo | undefined, model: string): boolean =>
+    Boolean(info && model && info.models.some((m) => m.toLowerCase() === model.toLowerCase()));
 
-  // 描述里的名字是**显示名**：先翻成持久身份（改名也不会断），翻不到才当 canonical slug 用。
-  const hintSlug = providerHint ? (providerHint.includes(":") ? providerHint.trim().toLowerCase() : customSlug(providerHint)) : null;
-  const hintInfo = hintSlug ? endpoints.get(hintSlug) : undefined;
-  const hintId = hintInfo?.id ?? null;
-  const hintBares = new Set<string>();
-  if (hintSlug) hintBares.add(bareName(hintSlug));
-  if (hintId) hintBares.add(bareName(hintId));
-  hintBares.delete("custom");
-  hintBares.delete("");
-
-  // 1) 描述里声明的条目自己认领前缀：`custom:<条目>:<模型>` / `<条目>:<模型>`。
-  for (const bare of hintBares) {
-    const customPrefix = `custom:${bare}:`;
-    if (lowered.startsWith(customPrefix)) {
-      // 只有这个条目真的在配置里，才允许把它的名字当成身份写下去。
-      const entry = endpoints.get(`custom:${bare}`);
-      return { model: raw.slice(customPrefix.length).trim(), provider: entry?.id ?? hintId ?? null,
-        unresolved: entry ? undefined : true };
-    }
-    if (!lowered.startsWith("custom:") && lowered.startsWith(`${bare}:`)) {
-      return { model: raw.slice(bare.length + 1).trim(), provider: hintId ?? bare };
-    }
-  }
-
-  // 2) `custom:` 开头的三段 id：第二段是已配置条目才切。
+  // 1) `custom:<…>` —— 前缀自己说明「这是个 custom 条目」，所以这里别名也算数（F5：显示名 → 键）。
   if (lowered.startsWith("custom:")) {
     const rest = raw.slice("custom:".length);
     const cut = rest.indexOf(":");
     if (cut > 0) {
-      const named = endpoints.get(customSlug(rest.slice(0, cut)));
-      if (named) return { model: rest.slice(cut + 1).trim(), provider: named.id };
-      // 这个条目本配置里没有（被改名/删掉，而对话框拿的是旧快照）。把整串写进 model.default
-      // 正是 #72 的病灶：模型名变成 `条目:模型`，或者被按第一个冒号切成 provider=custom。
-      return { model: raw, provider: hintId, unresolved: true };
+      const head = customSlug(rest.slice(0, cut));
+      const entry = named.byKey.get(head) ?? named.byAlias.get(head);
+      if (entry) return { model: rest.slice(cut + 1).trim(), provider: entry.id };
+      // 第二段不是条目，两种读法都说得通，只能让条目自己的声明白话：
+      //  · 条目**声明了** `qwen3:32b` 这种带冒号的模型 → 旧形状（模型名是整段）
+      //  · 条目声明了后半段 → 条目前缀是陈旧的（条目被改名/删掉过，对话框还是旧快照）
+      // 两种都对上（或都没声明）才是真歧义：那时不写，让调用方看到原因。
+      if (keyInfo && declares(keyInfo, rest)) return { model: rest.trim(), provider: keyInfo.id };
+      if (keyInfo && declares(keyInfo, rest.slice(cut + 1).trim())) {
+        return { model: rest.slice(cut + 1).trim(), provider: keyInfo.id };
+      }
+      // 真歧义：条目既没声明整段、也没声明后半段。写哪个都得赌一次，所以不写（reason 会带上）。
+      return { model: raw, provider: null, unresolved: true };
     }
-    // `custom:<模型>`（旧形状）：模型名是确定的那半，provider 只能靠描述推。
-    return { model: rest.trim(), provider: hintId };
+    // `custom:<模型>`：模型名是确定的那半，provider 只能靠描述推。
+    return { model: rest.trim(), provider: hintEntryId };
   }
 
-  // 3) `<provider>:<模型>`：左半段是已配置条目（含显示名）、或就是描述里声明的那个名字。
-  const colon = raw.indexOf(":");
-  if (colon > 0) {
-    const left = raw.slice(0, colon).trim().toLowerCase();
-    const named = endpoints.get(customSlug(left));
-    if (named) return { model: raw.slice(colon + 1).trim(), provider: named.id };
-    if (hintBares.has(left)) return { model: raw.slice(colon + 1).trim(), provider: hintId ?? left };
+  // 2) `<左段>:<模型>`：左段是配置键 → 身份权威；否则整段就是模型名的一部分被行前缀带着，
+  //    按 provider/canonical slug 原样写（`openrouter:claude` 绝不能因为显示名重名改成 custom:x）。
+  const cut = raw.indexOf(":");
+  if (cut > 0) {
+    const left = raw.slice(0, cut).trim().toLowerCase();
+    const tail = raw.slice(cut + 1).trim();
+    const entry = named.byKey.get(customSlug(left));
+    if (entry) return { model: tail, provider: entry.id };
+    // 左段与描述指的是同一个名字，且那个名字是个 provider slug ⇒ 左段就是 provider（`alibaba:x`）。
+    if (hintIsSlug && bareName(customSlug(left)) === bareName(hintSlug ?? "")) {
+      // 只有**键**能当身份：别名说「描述里印的是这个名字」，而 cloud 与本地代理重名时
+      // 正是靠这一条才不会把云 provider 的 pick 写成本地条目（MAJOR 3）。
+      return { model: tail, provider: keyInfo?.id ?? left };
+    }
+    // 其余情况：左段不是已知条目/描述里的名字，那它可能只是模型名的一部分
+    // （`anthropic/claude-3.5-sonnet:beta` 的冒号在斜杠后面）。整串留着，不猜。
+    return { model: raw, provider: null };
   }
 
-  // 4) 裸模型名 + 描述里的条目：描述只用来定 provider，绝不改模型名。
-  return { model: raw, provider: hintId ?? (hintSlug && hintBares.size ? [...hintBares][0] : null) };
+  // 3) 裸模型名：键就是证据；显示名要再对上「条目声明了这个模型」才算（重名时不敢认）。
+  if (keyInfo) return { model: raw, provider: keyInfo.id };
+  if (aliasInfo && declares(aliasInfo, raw)) return { model: raw, provider: aliasInfo.id };
+  // 描述是个 slug 形状（`Alibaba`/`kimi-coding`）⇒ canonical provider，写下去 hermes 认得。
+  // 一句显示名（`My Lab Box`）推不出任何身份，保持 `model.provider` 原样。
+  if (hintIsSlug && hintSlug) return { model: raw, provider: bareName(hintSlug) };
+  return { model: raw, provider: null };
 }
 
 function deleteKey(lines: string[], key: string): string[] {
@@ -311,8 +371,8 @@ export function writeModelDefault(
   // 配置里有哪些命名端点，决定了 choice id 怎么拆、以及块内残留的端点要不要清。
   let before: unknown = null;
   try { before = parseYaml(text); } catch { before = null; }
-  const endpoints = namedEndpoints(before);
-  const split = splitChoiceId(modelId, options.provider ?? null, endpoints);
+  const named = namedEndpoints(before);
+  const split = splitChoiceId(modelId, options.provider ?? null, named);
   const provider = split.provider;
   const desiredModel = split.model;
   if (split.unresolved) {
@@ -327,13 +387,15 @@ export function writeModelDefault(
   const previousProvider = (before as { model?: { provider?: unknown } } | null)?.model?.provider;
   const previous = typeof previousProvider === "string" ? previousProvider.trim() : null;
   const providerChanged = provider != null && provider !== previous;
-  const entry = provider ? endpoints.get(provider) : undefined;
+  // 端点归属问的是「这个条目**声明了**端点吗」，不是「有这个条目吗」：没有端点的块是给内置
+  // provider 调参用的（见 namedEndpoints），它既不拥有块里的 base_url，也当不了 model.provider。
+  const entry = provider ? named.byKey.get(provider) : undefined;
   // 块级的 base_url/api_mode 是**上一个 provider 的口子**，两种情况下都必然过期或多余：
   //   · 换了 provider —— 它描述的是被换掉的那一个；
   //   · 新 provider 是命名条目 —— 端点归条目所有（条目改了端口/协议，块里那份就成了矛盾状态）。
   // 只按「换 provider 且端点归某个条目」判断，会漏掉 `custom → openrouter`（新 provider 不声明端点），
   // 于是写出「provider 是云厂商、base_url 还指着本地边车」的块，那正是 #72 B 段的错路由。
-  const dropEndpointKeys = providerChanged || Boolean(entry);
+  const dropEndpointKeys = providerChanged || Boolean(entry?.apiUrl);
 
   const indent = blockIndent(lines);
   let work = lines;
@@ -349,6 +411,9 @@ export function writeModelDefault(
 
   // 写盘前的最后一道闸：真解析一遍。不只看"两行读得回"，要看**这个块自洽**——
   // provider 指向的条目和块里的端点必须是同一个端点，否则整次拒写（旧闸门会稳定放过矛盾状态）。
+  // 常规路径上端点键已经在上面被删掉了，所以这里主要拦 `deleteKey` 正则认不出的写法
+  // （`base_url :` 中间带空格之类）—— 门槛低但便宜，且它是唯一一处验证「磁盘上的块」而不是
+  // 「我打算写的块」的地方。
   let doc: unknown;
   try {
     doc = parseYaml(next);

package/packages/server/src/store/store.ts

@@ -1815,7 +1815,13 @@ export class Store {
     // `current` must stay inside `available`: the dialog only shows an id that is in the list
     // (`startModelValue`), so caching a current the list cannot contain would silently downgrade the
     // next new-session default to "agent default" right after the operator switched (#72 review).
-    const available = current && !supplied.includes(current) ? [current, ...supplied] : supplied;
+    // …but it must not GROW the cache either: `available` is the new-session dialog's model list, so a
+    // prepend per switch would accrete ids of endpoints/models that no longer exist, each one a
+    // selectable row that answers "unknown model". Keep the list's length and let the oldest entry
+    // fall off — the next real agent start refreshes the whole snapshot anyway (#72 review).
+    const available = current && !supplied.includes(current)
+      ? [current, ...supplied.filter((m) => m !== current)].slice(0, Math.max(supplied.length, 1))
+      : supplied;
     hs.models = { ...hs.models, currentModelId: current, available };
     this.#db.prepare("update backends set handshake = ? where id = ?").run(JSON.stringify(hs), id);
   }

package/packages/shared/src/index.ts

@@ -502,7 +502,9 @@ export type ClientCommand =
   | { t: "cancel"; sessionId: string }
   | { t: "set-mode"; sessionId: string; modeId: string }
   | { t: "set-config"; sessionId: string; configId: string; value: string | number | boolean }
-  | { t: "set-model"; sessionId: string; modelId: string }
+  /** `fromReplay` = 这条帧是在重放对话框里的选择（新会话建立时那一轮），不是操作者刚点的切换：
+   *  写回全局默认与用量计数都只认后者（见 session-manager 的 `#writeBackModelDefault`/`bumpModelUsage`）。 */
+  | { t: "set-model"; sessionId: string; modelId: string; fromReplay?: boolean }
   | {
       t: "respond-permission";
       sessionId: string;