agentus 0.15.4 → 0.15.6

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-1850`, 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-1850`，基座 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-1850`** — 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-1850`** —— 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.4",
+  "version": "0.15.6",
   "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,9 +1402,13 @@ 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 → ${modelId}${r.provider ? ` (provider ${r.provider})` : ""} for ${info.backend}`);
+        console.log(`[agentus] model default → ${r.model ?? modelId}${r.provider ? ` (provider ${r.provider})` : ""} for ${info.backend} (picked ${modelId})`);
       }
     } catch (e) {
       console.log(`[agentus] model default write-back failed: ${errMessage(e)}`);
@@ -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,15 +3110,49 @@ 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}`);
     }
-    await conn.request("session/set_model", { sessionId: s.info.acpSessionId, modelId });
-    if (s.info.models) s.info.models = { ...s.info.models, currentModelId: modelId };
+    const reply = await conn.request("session/set_model", { sessionId: s.info.acpSessionId, modelId });
+    // The agent answers with its model state; a few of them (hermes does) re-render the list and mark
+    // the new current there. Ignoring it leaves the slot and the cached handshake on the list from
+    // *before* the switch, which the next start dialog then reads (#72 review). Ids we already know
+    // keep their names/descriptions — the richer shape only exists on the live session.
+    const replied = (reply ?? {}) as {
+      models?: { currentModelId?: string; availableModels?: { modelId?: string }[] } | null;
+    };
+    const returnedIds = (replied.models?.availableModels ?? [])
+      .map((m) => String(m.modelId ?? "")).filter(Boolean);
+    if (s.info.models) {
+      const known = s.info.models.availableModels ?? [];
+      const merged = [...known];
+      for (const id of returnedIds) {
+        if (!merged.some((m) => m.modelId === id)) merged.push({ modelId: id, name: id, description: null });
+      }
+      s.info.models = { ...s.info.models, currentModelId: replied.models?.currentModelId ?? modelId, availableModels: merged };
+    }
+    // #72：缓存握手是"上一次真启动"的快照，新建会话对话框只读它 —— 换了模型却不改它，对话框会一直
+    // 显示（并且把）切换前的那个 id 当中文默认值。活会话手里有完整清单，顺手把两份都刷新。
+    // 以**活会话**为准：agent 可能在回复里规范化了 id（或表示"没变"），那时缓存的默认值必须跟它走，
+    // 否则对话框显示的、重放的，都是槽位没在跑的那个 id（MINOR 4）。
+    this.#store.recordHandshakeModels(s.info.backend, {
+      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

@@ -8,7 +8,14 @@
 //   · 只在 server 的 setModel **成功之后**、且是操作者动作时调用（重放不算，见 session-manager）。
 //   · 写完必须能读回来：写盘前用真 YAML 解析器验一遍 `model.default` 是不是那个值，验不过就**拒写**。
 //     这是别人的全局配置文件，写坏了下次 spawn 直接起不来 —— 宁可不动，也不能"改成功但改坏"。
-//   · 原子写（临时文件 + rename）并保持原权限；只动 `model.default` / `model.provider` 两行。
+//   · 原子写（临时文件 + rename）并保持原权限。
+//   · 写进去的必须是 hermes 的**配置形状**，不是 ACP 的线格式：`default: <裸模型名>` +
+//     `provider: custom:<条目名>`。把选择器的三段 id（`custom:<条目>:<模型>`）直接塞进
+//     `model.default`，新建会话会把它整体当模型名发出去（`404 model_not_found`），或者被按第一个
+//     冒号切成 `provider=custom` + 剩下的整串 —— 静默跑到别的端点上（#72）。
+//   · 端点跟着条目走：命名条目自己声明 api_url/api_mode，块里残留的是**上一个** provider 的口子
+//     （`base_url` 指向旧云端点、`api_mode: codex_responses`），换 provider 时必须清掉，
+//     否则它会盖掉条目的声明。
 import { chmodSync, copyFileSync, existsSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { parse as parseYaml } from "yaml";
@@ -18,6 +25,8 @@ export interface WriteBackResult {
   changed: boolean;
   /** 写进去的 provider；null = 没写（推不出或不安全） */
   provider: string | null;
+  /** 写进 `model.default` 的裸模型名（从 ACP choice id 拆出来的那个） */
+  model?: string;
   reason?: string;
 }
 
@@ -109,6 +118,226 @@ function setKey(lines: string[], key: string, value: string, indent: string): st
   return copy;
 }
 
+
+/** 命名端点（`providers:` 的键 / `custom_providers:` 的 name）在配置里声明的端点与协议。
+ *
+ *  写回时这两样是**端点归属**的唯一来源：provider 认条目，端口跟着条目走。块级的
+ *  `base_url` / `api_mode` 是上一个 provider 留下的，换 provider 时要清掉（#72）。 */
+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:` 前缀。 */
+const customSlug = (display: string): string => {
+  const normalized = display.trim().toLowerCase().replace(/ /g, "-");
+  return normalized.startsWith("custom:") ? normalized : `custom:${normalized}`;
+};
+
+const bareName = (id: string): string => id.trim().toLowerCase().replace(/^custom:/, "");
+
+/** 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;
+  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:<条目>`，显示名另作弱别名。
+ *
+ *  三条判据都是 hermes 自己的：
+ *
+ *  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): 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];
+      if (typeof value === "string" && value.trim()) return value.trim();
+    }
+    return null;
+  };
+  const add = (id: string, entry: Record<string, unknown>): void => {
+    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) {
+      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;
+  if (providers && typeof providers === "object" && !Array.isArray(providers)) {
+    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 的 custom_provider_slug(display, key) 同一个取向。
+      add(customSlug(key), raw);
+    }
+  }
+  const legacy = d.custom_providers;
+  if (Array.isArray(legacy)) {
+    for (const entry of legacy) {
+      if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+      const raw = entry as Record<string, unknown>;
+      if (isDisabled(raw)) continue;
+      const name = typeof raw.name === "string" ? raw.name.trim() : "";
+      if (!name) continue;
+      add(customSlug(name), raw);
+    }
+  }
+  return { byKey, byAlias };
+}
+
+export interface ChoiceSplit {
+  /** hermes `model.default` 该写的值：裸模型名 */
+  model: string;
+  /** hermes `model.provider` 该写的值；null = 推不出来，**保持原样**（不猜） */
+  provider: string | null;
+  /** true = 这个 id 描述了一个本配置里没有的条目，且连 provider 都定不下来：不许写 */
+  unresolved?: boolean;
+}
+
+/** 把选择器的 choice id 拆回 `(裸模型名, 持久 provider 身份)`。
+ *
+ *  规则就是 hermes 自己的那条：provider 只在左半段是**已知 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,
+  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()));
+
+  // 1) `custom:<…>` —— 前缀自己说明「这是个 custom 条目」，所以这里别名也算数（F5：显示名 → 键）。
+  if (lowered.startsWith("custom:")) {
+    const rest = raw.slice("custom:".length);
+    const cut = rest.indexOf(":");
+    if (cut > 0) {
+      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: hintEntryId };
+  }
+
+  // 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 };
+  }
+
+  // 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[] {
+  const at = findInModelBlock(lines, key);
+  if (at < 0) return lines;
+  const copy = [...lines];
+  copy.splice(at, 1);
+  return copy;
+}
+
 /** 把 modelId（以及可安全推断时的 provider）写进 agent 的配置文件。 */
 export function writeModelDefault(
   backend: string,
@@ -139,28 +368,74 @@ export function writeModelDefault(
     return { ok: false, changed: false, provider: null, reason: `model: is not a plain block (${header.trim().slice(0, 40)})` };
   }
 
-  const provider = options.provider ? String(options.provider).trim() : null;
+  // 配置里有哪些命名端点，决定了 choice id 怎么拆、以及块内残留的端点要不要清。
+  let before: unknown = null;
+  try { before = parseYaml(text); } catch { before = null; }
+  const named = namedEndpoints(before);
+  const split = splitChoiceId(modelId, options.provider ?? null, named);
+  const provider = split.provider;
+  const desiredModel = split.model;
+  if (split.unresolved) {
+    // 对话框拿的是旧快照时会出现：条目已被改名/删除，pick 却还带着 `custom:<旧名>:<模型>`。
+    // 把它当 model.default 写下去，等于把 #72 的病灶重新种进配置（模型名带条目前缀、或按第一个冒号
+    // 切成 provider=custom），所以整次拒写，让调用方看到原因。
+    return {
+      ok: false, changed: false, provider, model: desiredModel,
+      reason: `refusing to write: ${modelId} names an endpoint this config does not declare`,
+    };
+  }
+  const previousProvider = (before as { model?: { provider?: unknown } } | null)?.model?.provider;
+  const previous = typeof previousProvider === "string" ? previousProvider.trim() : null;
+  const providerChanged = provider != null && provider !== previous;
+  // 端点归属问的是「这个条目**声明了**端点吗」，不是「有这个条目吗」：没有端点的块是给内置
+  // 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?.apiUrl);
+
   const indent = blockIndent(lines);
   let work = lines;
   if (provider) work = setKey(work, "provider", provider, indent);
-  work = setKey(work, "default", modelId, indent);
+  work = setKey(work, "default", desiredModel, indent);
+  if (dropEndpointKeys) {
+    work = deleteKey(work, "base_url");
+    work = deleteKey(work, "api_mode");
+  }
 
   const next = work.join("\n");
-  if (next === text) return { ok: true, changed: false, provider };
+  if (next === text) return { ok: true, changed: false, provider, model: desiredModel };
 
-  // 写盘前的最后一道闸：真解析一遍，两个值都得读回来。任何一个不成立就一个字都不写。
+  // 写盘前的最后一道闸：真解析一遍。不只看"两行读得回"，要看**这个块自洽**——
+  // provider 指向的条目和块里的端点必须是同一个端点，否则整次拒写（旧闸门会稳定放过矛盾状态）。
+  // 常规路径上端点键已经在上面被删掉了，所以这里主要拦 `deleteKey` 正则认不出的写法
+  // （`base_url :` 中间带空格之类）—— 门槛低但便宜，且它是唯一一处验证「磁盘上的块」而不是
+  // 「我打算写的块」的地方。
   let doc: unknown;
   try {
     doc = parseYaml(next);
   } catch (e) {
-    return { ok: false, changed: false, provider, reason: `refusing to write: result would not parse (${(e as Error).message.split("\n")[0]})` };
+    return { ok: false, changed: false, provider, model: desiredModel, reason: `refusing to write: result would not parse (${(e as Error).message.split("\n")[0]})` };
   }
-  const model = (doc as { model?: { default?: unknown; provider?: unknown } } | null)?.model;
-  if (!model || model.default !== modelId) {
-    return { ok: false, changed: false, provider, reason: "refusing to write: model.default would not read back" };
+  const model = (doc as { model?: { default?: unknown; provider?: unknown; base_url?: unknown; api_mode?: unknown } } | null)?.model;
+  if (!model || model.default !== desiredModel) {
+    return { ok: false, changed: false, provider, model: desiredModel, reason: "refusing to write: model.default would not read back" };
   }
   if (provider && model.provider !== provider) {
-    return { ok: false, changed: false, provider, reason: "refusing to write: model.provider would not read back" };
+    return { ok: false, changed: false, provider, model: desiredModel, reason: "refusing to write: model.provider would not read back" };
+  }
+  if (entry?.apiUrl) {
+    const norm = (v: unknown) => String(v ?? "").trim().replace(/\/+$/, "").toLowerCase();
+    const blockUrl = norm(model.base_url);
+    if (blockUrl && blockUrl !== norm(entry.apiUrl)) {
+      return { ok: false, changed: false, provider, model: desiredModel, reason: `refusing to write: model.base_url (${String(model.base_url)}) is not where ${provider} lives (${entry.apiUrl})` };
+    }
+    if (model.api_mode && entry.apiMode && String(model.api_mode) !== entry.apiMode) {
+      return { ok: false, changed: false, provider, model: desiredModel, reason: `refusing to write: model.api_mode (${String(model.api_mode)}) contradicts ${provider} (${entry.apiMode})` };
+    }
   }
 
   // 配置里可能有 api_key：比 0600 宽的一律收紧。
@@ -173,7 +448,7 @@ export function writeModelDefault(
     renameSync(tmp, file);
   } catch (e) {
     try { rmSync(tmp, { force: true }); } catch { /* best effort */ }
-    return { ok: false, changed: false, provider, reason: `write failed: ${(e as Error).message}` };
+    return { ok: false, changed: false, provider, model: desiredModel, reason: `write failed: ${(e as Error).message}` };
   }
-  return { ok: true, changed: true, provider };
+  return { ok: true, changed: true, provider, model: desiredModel };
 }

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

@@ -1786,6 +1786,46 @@ export class Store {
     return Number(info.changes ?? 0) > 0;
   }
 
+  /**
+   * Refresh the MODEL half of a row's cached handshake.
+   *
+   * The handshake is a snapshot of the last real start, and it is the only thing a start dialog can
+   * read for a backend that is not running: a `currentModelId` captured before the operator switched
+   * models is stale forever (nothing else rewrites it), and the dialog would present — and replay —
+   * the model the agent no longer uses (#72). ``available`` is optional: only the live session knows
+   * the full list, so pass it when the caller has one.
+   */
+  recordHandshakeModels(
+    id: string,
+    models: { currentModelId?: string | null; available?: string[] },
+  ): void {
+    const row = this.#db.prepare("select handshake from backends where id = ?").get(id) as
+      | { handshake?: string | null }
+      | undefined;
+    if (!row?.handshake) return; // a row that never ran has no snapshot to correct
+    let hs: BackendHandshake;
+    try {
+      hs = JSON.parse(row.handshake) as BackendHandshake;
+    } catch {
+      return;
+    }
+    if (!hs?.models) return;
+    const current = models.currentModelId ?? null;
+    const supplied = models.available?.length ? models.available : hs.models.available;
+    // `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).
+    // …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);
+  }
+
   /**
    * Write back a health snapshot (and optionally a handshake) for one row. Deliberately a
    * column-scoped UPDATE rather than upsertBackend: a check must never resurrect a stale copy of

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;