@morlay/dsh-session-mode 0.0.7 → 0.0.9

package/src/client/llm-directory.ts

@@ -0,0 +1,149 @@
+// 部署的 LLM 目录读数：provider 候选（活着的路由 + 可配置声明）与每个 provider 的模型清单（在声明指向的那份
+// 配置里）。
+//
+// 两处消费它：提示面的 `llm-providers` / `llm-models` 两个具名源（行配置页与通用 schema 表单用），以及 bundle
+// 配置页的模型路由清单——"已设置的模型"按**路由**给，一条路由就是 provider + model 这一对。
+
+import type { Context } from "@deepseek-ai/cordis";
+import type {} from "@deepseek-ai/dsh-api-remotes/client";
+
+// 一条可选路由：`key` 是稳定身份（调用方只用来比对，不解析它）。
+export interface ModelRoute {
+  readonly key: string;
+  readonly provider: string;
+  readonly providerName: string;
+  readonly model: string;
+  readonly modelName: string;
+}
+
+// 一个 provider 与它当前可用的模型。
+export interface ProviderModels {
+  readonly value: string;
+  readonly label: string;
+  readonly models: readonly { readonly value: string; readonly label: string }[];
+}
+
+// 路由的稳定身份：provider 与 model 一起才是路由。
+export function routeKey(provider: string, model: string): string {
+  return `${provider}\u0000${model}`;
+}
+
+// 客户端 remote 的命名空间是一个**独立服务**（服务名 `remote.<命名空间>`，gateway 的 client 半按 mount 注册），
+// 不是 `remote` 服务上的属性——属性访问读到的是 `undefined`。读不到（这一版部署没装那个命名空间）就按"没有"处理。
+export function remoteNamespace<T>(scope: Context, namespace: string): T | undefined {
+  try {
+    return (scope as unknown as { get(key: string): unknown }).get(`remote.${namespace}`) as
+      | T
+      | undefined;
+  } catch {
+    // 服务没注册时 `ctx.get` 抛错：按"这个命名空间不在这一版部署里"处理。
+    return undefined;
+  }
+}
+
+// LLM 命名空间里本包用到的那两个读面：活着的路由与可配置声明。
+interface LlmReader {
+  listProviders: () => Promise<
+    { ok: true; value: readonly { id: string; name: string }[] } | { ok: false }
+  >;
+  listConfigurableProviders: () => Promise<
+    | {
+        ok: true;
+        value: readonly {
+          provider: string;
+          displayName: string;
+          settingsNs: string;
+          settingsPath: readonly string[];
+        }[];
+      }
+    | { ok: false }
+  >;
+}
+
+// 一份 provider 档案的读数面（模型清单住在声明指向的那份配置里）。
+interface ConfigFormsReader {
+  get(ns: string): { getSnapshot(): { value: unknown } };
+}
+
+// 按路径读一段配置里的值。
+function readAt(root: unknown, path: readonly string[]): unknown {
+  return path.reduce<unknown>((node, segment) => {
+    if (Array.isArray(node)) return node[Number(segment)];
+    if (typeof node !== "object" || node === null) return undefined;
+    return Reflect.get(node, segment);
+  }, root);
+}
+
+// 一个 provider 当前有哪些模型：声明给了配置地址就按路径读它的 `models`（每项取 `id`）。
+function modelsOf(
+  entry: { settingsNs: string; settingsPath: readonly string[] },
+  forms: ConfigFormsReader,
+): readonly { value: string; label: string }[] {
+  if (entry.settingsNs === "") return [];
+  const profile = readAt(forms.get(entry.settingsNs).getSnapshot().value, entry.settingsPath);
+  const models =
+    typeof profile === "object" && profile !== null ? Reflect.get(profile, "models") : undefined;
+  if (!Array.isArray(models)) return [];
+  return models.flatMap((model) => {
+    if (typeof model !== "object" || model === null) return [];
+    const id = Reflect.get(model, "id");
+    if (typeof id !== "string") return [];
+    // 显示名优先取档案里的 `name`（"DeepSeek V4.1 Flash @ Ollama Cloud" 这种），没有就用 id。
+    const name = Reflect.get(model, "name");
+    return [{ value: id, label: typeof name === "string" && name !== "" ? name : id }];
+  });
+}
+
+// 部署里"已设置"的 provider 与它们的模型：活着的路由与可配置声明合并（按 provider 去重，声明的显示名优先）。
+export async function loadLlmProviders(scope: Context): Promise<readonly ProviderModels[]> {
+  const llm = remoteNamespace<LlmReader>(scope, "llm");
+  const forms = (scope as unknown as { get(key: string): unknown }).get("configForms") as
+    | ConfigFormsReader
+    | undefined;
+  if (llm === undefined || forms === undefined) return [];
+  const [routes, directory] = await Promise.all([
+    llm.listProviders(),
+    llm.listConfigurableProviders(),
+  ]);
+  if (!routes.ok || !directory.ok) return [];
+  const merged = new Map<
+    string,
+    { value: string; label: string; settingsNs: string; settingsPath: readonly string[] }
+  >();
+  for (const entry of directory.value) {
+    merged.set(entry.provider, {
+      value: entry.provider,
+      label: entry.displayName,
+      settingsNs: entry.settingsNs,
+      settingsPath: [...entry.settingsPath],
+    });
+  }
+  for (const route of routes.value) {
+    if (!merged.has(route.id)) {
+      merged.set(route.id, {
+        value: route.id,
+        label: route.name,
+        settingsNs: "",
+        settingsPath: [],
+      });
+    }
+  }
+  return [...merged.values()].map((entry) => ({
+    value: entry.value,
+    label: entry.label,
+    models: modelsOf(entry, forms),
+  }));
+}
+
+// 目录里的每一条路由（provider + 它有模型的每一项）：bundle 配置页的模型清单用它。
+export function routesOf(providers: readonly ProviderModels[]): readonly ModelRoute[] {
+  return providers.flatMap((provider) =>
+    provider.models.map((model) => ({
+      key: routeKey(provider.value, model.value),
+      provider: provider.value,
+      providerName: provider.label,
+      model: model.value,
+      modelName: model.label,
+    })),
+  );
+}

package/src/client/locales.ts

@@ -11,7 +11,7 @@ export const zh = {
   model: "模型",
   modelHint: "模型 id。",
   reasoningEffort: "思考档位",
-  reasoningEffortHint: "省略就跟服务商自己的默认。",
+  reasoningEffortHint: "默认就跟服务商自己的默认。",
 };
 
 export const en: Record<keyof typeof zh, string> = {
@@ -24,7 +24,7 @@ export const en: Record<keyof typeof zh, string> = {
   model: "Model",
   modelHint: "Model id.",
   reasoningEffort: "Reasoning effort",
-  reasoningEffortHint: "Unset keeps the provider's own default.",
+  reasoningEffortHint: "Default keeps the provider's own default.",
 };
 
 export type SessionModeLocaleKey = keyof typeof zh;

package/src/index.ts

@@ -25,6 +25,7 @@ import {
   type SessionMode,
   type SessionModeRole,
 } from "./modes.ts";
+import { SessionModeCatalog } from "./catalog.ts";
 import { installPersona } from "./persona.ts";
 import { SessionScope } from "./scope.ts";
 import {
@@ -263,8 +264,8 @@ export class SessionModes extends Service {
     return undefined;
   }
 
-  // 把某个空白会话（必须还没开过 turn）切到某个模式：先把 agent preset 换成模式声明的那个
-  // （目标与当前相同时不切——换 preset 是一次重挂），再落会话事实并重装该 agent 的扩展。
+  // 把某个空白会话（必须还没开过 turn）切到某个模式：先按模式的白名单把 agent preset 落到位（当前那份已经在
+  // 名单里就不换——换 preset 是一次重挂；不在名单里就换成名单里的第一个），再落会话事实并重装该 agent 的扩展。
   async select(sessionId: SessionId, mode: string): Promise<string> {
     const definition = this.definition(mode);
     if (!definition.role.includes("main")) {
@@ -278,11 +279,12 @@ export class SessionModes extends Service {
     }
     const agent = this.ctx.agents.get(sessionId);
     const registry = this.presetRegistry();
-    if (agent !== undefined && registry !== undefined && definition.preset.length > 0) {
-      // 官方那条路自己也会查空白窗口（`agent-preset/locked`）；它切完会 emit `agent-preset/selected`，
-      // 监听据此落事实并重装——所以这里先比一次投影，同一个值不写第二条。
-      if (this.presetOfAgent(registry, agent) !== definition.preset) {
-        await registry.select(agent, definition.preset);
+    if (agent !== undefined && registry !== undefined) {
+      const target = this.presetTarget(definition.presetsOnly, this.presetOfAgent(registry, agent));
+      if (target !== undefined) {
+        // 官方那条路自己也会查空白窗口（`agent-preset/locked`）；它切完会 emit `agent-preset/selected`，
+        // 监听据此落事实并重装——所以这里先比一次投影，同一个值不写第二条。
+        await registry.select(agent, target);
       }
     }
     if (this.ctx.sessionProjections.stateOf(session, "sessionMode") !== mode) {
@@ -293,6 +295,19 @@ export class SessionModes extends Service {
     return mode;
   }
 
+  // 把当前挂着的 preset 落进模式的白名单：已经在名单里就返回 `undefined`（不换）；不在里面（或读不到当前那份）
+  // 就返回名单的**第一个**（`undefined` = 名单为空 = 不限制，什么都不换）。
+  private presetTarget(
+    allowed: readonly string[],
+    current: string | undefined,
+  ): string | undefined {
+    if (allowed.length === 0) return undefined;
+    // 当前那份在名单里：保持不动（用户自己选的 preset 落在许可范围内，模式不去覆盖它）。
+    if (current !== undefined && allowed.includes(current)) return undefined;
+    const target = allowed[0];
+    return target === current ? undefined : target;
+  }
+
   // 某个 agent 当前挂着的 preset（registry 的 `composedPreset`）；读不到时按"未知"处理（该切就切）。
   private presetOfAgent(registry: Context["agentPresets"], agent: Agent): string | undefined {
     const read = (registry as { composedPreset?: (ctx: Context) => string | undefined })
@@ -355,12 +370,12 @@ export class SessionModes extends Service {
     }
   }
 
-  // 某个 preset 对应的模式 id——只在映射唯一时回答（共享同一份 preset、或没有模式挂它时 `undefined`）；
-  // 本部署的模式由会话事实决定，这条反查留给"一对一映射"的部署形态。
+  // 某个 preset 对应的模式 id——只在映射唯一时回答（只有它一个模式的名单里有这份 preset；没有模式认领、或几个
+  // 模式的名单都含它时 `undefined`）；本部署的模式由会话事实决定，这条反查留给"一对一映射"的部署形态。
   modeForPreset(preset: string | undefined): string | undefined {
     if (preset === undefined) return undefined;
-    const owners = Object.keys(this.config.modes).filter(
-      (id) => this.config.modes[id]?.preset === preset,
+    const owners = Object.keys(this.config.modes).filter((id) =>
+      this.config.modes[id]?.presetsOnly.includes(preset),
     );
     return owners.length === 1 ? owners[0] : undefined;
   }
@@ -429,6 +444,8 @@ export class SessionModes extends Service {
 export function apply(ctx: Context, config: ResolvedConfig): void {
   const modes = new SessionModes(ctx, config);
   registerHttpRoutes(ctx, modes);
+  // 配置页的工具 / 技能候选：一条本包自己开的 Remote 面（客户端半自己 mount，见 `./catalog-remote.ts`）。
+  ctx.plugin(SessionModeCatalog);
 }
 
 interface HttpRequestLike {

package/src/mode-sources.ts

@@ -7,10 +7,10 @@ import type { PolicyName } from "./shared.ts";
 // 一个模式的源定义：就是 `session-mode` 行 `config.modes` 里的一项。
 export interface ModeSource {
   readonly id: string;
-  // 挂哪个 agent preset（它的 `id`）：**可选**，不写就是不绑——选这个模式不换 preset，会话保持它当前挂着的那份，
-  // 行清单由那份 preset 提供（官方四个 shipped preset 照旧可选）。写了才在切模式时把 preset 切过去；
-  // 模式定义里可以整体改写它（用户 patch 层）。
-  readonly preset?: string;
+  // 这个模式**只允许**挂哪些 agent preset（它们的 `id`）：**可选**，不写（留空）就是不限制——选这个模式不换 preset，
+  // 会话保持它当前挂着的那份，行清单由那份 preset 提供（官方四个 shipped preset 照旧可选）。有值时切模式会让 preset
+  // 落进名单：当前的已经在里面就不动，否则换成第一个。模式定义里可以整体改写它（用户 patch 层）。
+  readonly presetsOnly?: readonly string[];
   readonly name: string;
   readonly description: string;
   // 归谁用：`main`（用户选择器，缺省）、`subagent`（可作子代理 mode 的候选）。
@@ -44,13 +44,16 @@ export interface ModeModelSource {
   readonly reasoningEffort?: string;
 }
 
-// 编码模式：编程专家 + 语言与思考纪律 + 工作目录提醒。
+// 编码模式：编程专家 + 语言与思考纪律。
+// 这里**不再有**工作目录那半句（原为 `你的工作目录在 \`{{cwd}}\``）：上游 0.2.1-alpha.2 起工作目录由
+// `working-directory:current` 这条运行时上下文注入（文本是 `Current working directory: "<绝对路径>".`），
+// 而 persona 用的提示词插值是**严格**的——`cwd` 变量已不再注册，残留 `{{cwd}}` 会在渲染时直接抛
+// `unknown prompt variable`（注册变量只剩 provider / model）。
 const CODING_PERSONA = {
   prefix: [
     "你是一个经验丰富的编程专家，YAGNI 是你的编程哲学，PDCA 是你的行为规范。",
     "全程用中文（专有名词除外），包括但不限于思考，回答，工具描述，subagent 提示词；思考不要陷入重复循环，一旦循环立即退出；思考聚焦需求理解与方案设计，不预演具体代码实现，正确性由验证环节确认。",
   ].join("\n"),
-  suffix: "你的工作目录在 `{{cwd}}`",
 };
 
 // 对话模式：一个助手，保留语言与思考纪律，没有 suffix。
@@ -59,11 +62,16 @@ const CHAT_PERSONA = {
     "你是一个助手。全程用中文（专有名词除外），包括但不限于思考，回答，工具描述；思考不要陷入重复循环，一旦循环立即退出。",
 };
 
+// 原样模式：**一份什么都不加的扩展**——persona 空、名单全空、三个开关不写，装配结果与"没有模式"时一致。
+// 它存在的理由有两个：想完全按上游默认跑的会话有个可选项；排查扩展干扰时有一个对照档（切到它就只剩上游行为）。
+// 它同样是 `session-mode` 行的一份定义，所以模式自己的收口代码照常经过它——只是没有任何收口要求。
+const NOOP_MODE_ID = "noop";
+
 // 新会话用哪个模式（`session-mode` 行的 `config.default`）。
 export const DEFAULT_MODE = "coding";
 
-// 两个模式：编码与对话。**都不绑定 preset**（差异全在会话级收口），行清单由会话挂着的 preset 提供：`coding`
-// 不收窄（用全部），`chat` 收成提问 + 联网三件。
+// 三个模式：编码、对话与原样。**都不限制 preset**（差异全在会话级收口），行清单由会话挂着的那份提供：`coding`
+// 不收窄（用全部），`chat` 收成提问 + 联网三件，`noop` 什么都不加。
 export const MODE_SOURCES: readonly ModeSource[] = [
   {
     id: "coding",
@@ -78,10 +86,7 @@ export const MODE_SOURCES: readonly ModeSource[] = [
     // 官方 Office 技能的三个名字同样按会话排除：技能目录里不列它们，`skill` 工具加载它们也被拒。
     // 名单是技能名这一层的模型可见契约（官方 `skill-office` 的 `SKILL_NAMES`），跟着上游改名走。
     denySkills: ["office-docx", "office-pptx", "office-xlsx"],
-    //
-    // `denyPolicies` 只禁 `fs/edit-intent`（上游那条"先读后改"）：改文件不再要求先读过——写路径上的
-    // `fs/write-intent`（陈旧版本 CAS 那层安全网）照旧生效，那正是这条配置不写成"两条都禁"的理由。
-    denyPolicies: ["fs/edit-intent"],
+    denyPolicies: ["fs/edit-intent", "fs/write-intent"],
   },
   {
     id: "chat",
@@ -98,10 +103,22 @@ export const MODE_SOURCES: readonly ModeSource[] = [
     // 配了只是噪音，所以留空。
     // 没有文件与 shell 工具，"能改工作区哪些文件、要不要走审批"对它全是噪音。
     //
-    // 两个抑制面都关：`instructions: false` 丢掉官方 `agent-instructions`（工作区指令）的注入；这个模式不写
+    // 注入面全关：`instructions: false` 丢掉官方 `agent-instructions`（工作区指令）的注入；这个模式不写
     // `skills`，而白名单三件里没有 `skill`、`denyTools` 也留空 → 推导成 `false`，官方 `skill-catalog` 的注入
-    // 同样丢掉。取舍见 `.agents/designs/20260929-抑制官方注入面.md`。
+    // 同样丢掉；`runtimeContext: false` 连动态快照与时钟（`standard` 那类 preset 声明的 `time-context`）一起收。
+    // **收不掉的**：上游 `working-directory:current` 是 required 的目录上下文（0.2.1-alpha.2 起工作目录只走这条），
+    // 抑制可选运行时上下文不影响它——chat 会话的模型仍会看到工作目录那条快照。
+    // 取舍见 `.agents/designs/20260929-抑制官方注入面.md`。
     instructions: false,
     runtimeContext: false,
   },
+  {
+    id: NOOP_MODE_ID,
+    name: "原样模式",
+    description: "与上游一致：不加人格提示词、不收窄工具与技能、policy 规则全开、官方注入面照旧。",
+    // 用户可选，也允许作为子代理的 mode：它不做任何过滤，给子代理当候选同样成立。
+    role: ["main", "subagent"],
+    // 其余字段一律不写：名单留空 = 不设收窄，`instructions` / `runtimeContext` 走 schema 默认 `true`，
+    // `skills` 由工具名单推导（`allowTools` 留空 → 含 `skill` → 要目录），`presetsOnly` 留空 = 不限制、`defaultModel` 跟全局。
+  },
 ];

package/src/modes.ts

@@ -1,5 +1,6 @@
 // 模式的定义形状与它的装配期校验：一个模式就是"一段提示词 + 一组能力开关"，本行的 `config.modes` 声明它们。
-// 行清单来自 `preset` 指的那份 agent preset；装配层能整体改写 `modes`，也可以只给某几个模式换提示词或白名单。
+// 行清单来自会话挂着的那份 agent preset（`presetsOnly` 只声明这个模式允许挂哪些）；装配层能整体改写 `modes`，
+// 也可以只给某几个模式换提示词或白名单。
 // 取舍见 `.agents/adrs/20260925-默认模型住在模式定义里.md`、`.agents/designs/20260924-会话模式.md`。
 
 import type { Volatile } from "@deepseek-ai/cordis";
@@ -31,11 +32,12 @@ export type SessionModeModels = Readonly<Record<string, SessionModeModel>>;
 // 一个模式：提示词 + 能力开关。这份形状是 **schema 归一化之后**的（每个字段都有值，schema 用默认补上），
 // 配置里能省略哪些字段看 `modeSchema` 的 default。
 export interface SessionMode {
-  // 这个模式挂在哪个 **agent preset** 上（官方四个，或本部署自己注册的那一份）。**可选**：不写（schema 里是空串）
-  // 就是不绑——选这个模式不换 preset，会话保持它当前挂着的那份，行清单由那份 preset 提供；模式自己的那几项扩展
+  // 这个模式**只允许**挂哪些 **agent preset**（官方四个，或本部署自己注册的那一份）。**留空（不写）表示不限制**：
+  // 选这个模式不换 preset，会话保持它当前挂着的那份；行清单由那份 preset 提供，模式自己的那几项扩展
   // （persona / 工具名单 / policy 名单 / 三个开关 / `defaultModel`）在任意 preset 上都照常生效。
-  // 写了才在切模式时切过去；**可以共享**（共享时反查无从下手，见 `SessionModes.modeForPreset`）。
-  readonly preset: string;
+  // 有值时切到这个模式会让会话的 preset 落进名单：当前那份已经在名单里就原样不动，否则换成名单里的**第一个**
+  // （`modes.ts` 只声明"允许哪些"，落在哪个由 `SessionModes.select` 决定）。多个模式可以共享同一份名单。
+  readonly presetsOnly: string[];
   // 模式的展示名（选择面归官方 roster；这里留着做事实文案）。
   readonly name: string;
   // 一句话说明这个模式干什么；空串表示没写。
@@ -70,12 +72,15 @@ export interface SessionMode {
   // denyTools` 里含 `skill` 就要（`allowTools` 留空即"全部"，所以只有 `denyTools` 能把它推成 `false`）。
   // `false` 表示这个模式不要技能目录：丢掉官方 `skill-catalog` 的注入（`skill` 工具的收窄仍归 `allowTools`）。
   readonly skills?: boolean;
-  // 是否要 runtime context（文件沙箱策略、审批策略那两条动态快照）。缺省要；`false` 表示这个模式不要它们
-  // ——对话模式没有文件与 shell 工具，"能改工作区哪些文件、要不要走审批"对它全是噪音。
+  // 是否要动态快照（文件沙箱策略、审批策略那两条 snapshot section，以及 `standard` 那类 preset 声明的时钟
+  // `time-context` 注入）。缺省要；`false` 表示这个模式不要它们——对话模式没有文件与 shell 工具，"能改工作区
+  // 哪些文件、要不要走审批"对它全是噪音，它也不谈时间。
   readonly runtimeContext: boolean;
   // 这个模式的默认模型；省略就跟全局 `agent-default-model`。**可选**：没配的模式在页面上不出现在这一行
   // （`defaultModel` 是它所在模式的一个可加字段）。
   readonly defaultModel?: SessionModeModel;
+  // 退役字段：单个 `preset` 已换成白名单 `presetsOnly`。这里留着只为**报错**（见 `configProblem`），页面上不出现。
+  readonly preset?: string;
 }
 
 // `skills` 不写时的推导：起点是白名单（留空 = 起点是全部工具，含 `skill`），减去黑名单，还留着 `skill` 就要技能
@@ -121,8 +126,8 @@ const modelSchema = z.object({
     ),
   reasoningEffort: z.string().description(
     localized({
-      zh: "思考档位；省略就跟服务商自己的默认。",
-      en: "Reasoning effort; unset keeps the provider's own default.",
+      zh: "思考档位；默认跟服务商自己的默认。",
+      en: "Reasoning effort; the default is the provider's own.",
     }),
   ),
 });
@@ -149,13 +154,17 @@ export interface ResolvedConfig {
 }
 
 const modeSchema: z<SessionMode> = z.object({
-  preset: z
-    .string()
-    .default("")
+  // 退役字段：这里留着只为**报错**（见 `configProblem`），页面上不出现（`hidden()`）。不给默认：没配就没这个键。
+  preset: z.string().hidden(),
+  presetsOnly: z
+    .array(z.string())
+    // 候选是部署里注册的 agent preset（具名源 `agent-presets`）：字段只说"这是选几个"，不关心它从哪来。
+    .role("select", { source: "agent-presets" })
+    .default([])
     .description(
       localized({
-        zh: "这个模式挂哪个 agent preset（它的 id，官方或本部署自建的）：行清单由那份 preset 提供，几个模式可以共享同一个。留空就是不绑——选这个模式不换 preset，会话保持当前挂着的那份，模式自己的提示词、工具收口与开关照常生效。",
-        en: "Which agent preset this mode rides on (its id, shipped or deployment-owned): that preset supplies the row list, and several modes may share it. Leave it empty to bind none — selecting the mode then keeps whatever preset the session already has, while the mode's persona, tool narrowing, and switches still apply.",
+        zh: "这个模式只允许挂哪些 agent preset（它们的 id，官方或本部署自建的）：行清单由挂着的那份提供，几个模式可以共享同一份名单。留空表示**允许全部**——哪份 preset 都行，选这个模式也不动会话当前挂着的那份；有值时当前的已经在名单里就不动，否则换成名单里的第一个。模式自己的提示词、工具收口与开关照常生效。",
+        en: "Which agent presets this mode may ride on (their ids, shipped or deployment-owned): that preset supplies the row list, and several modes may share one list. Empty means **every preset is allowed** — selecting the mode then leaves the session's current preset alone; when set, the current one stays if it is listed, otherwise the session switches to the first entry. The mode's persona, tool narrowing, and switches apply either way.",
       }),
     ),
   name: z
@@ -188,6 +197,8 @@ const modeSchema: z<SessionMode> = z.object({
   persona: personaSchema.default({}),
   allowTools: z
     .array(z.string())
+    // 候选是部署里的工具名（具名源 `catalog-tools`，由 client 半注册）：字段只说"这是选几个"，不关心清单从哪来。
+    .role("select", { source: "catalog-tools" })
     .default([])
     .description(
       localized({
@@ -197,6 +208,7 @@ const modeSchema: z<SessionMode> = z.object({
     ),
   denyTools: z
     .array(z.string())
+    .role("select", { source: "catalog-tools" })
     .default([])
     .description(
       localized({
@@ -206,6 +218,8 @@ const modeSchema: z<SessionMode> = z.object({
     ),
   allowSkills: z
     .array(z.string())
+    // 候选是技能注册表里的名字（具名源 `catalog-skills`）。
+    .role("select", { source: "catalog-skills" })
     .default([])
     .description(
       localized({
@@ -215,6 +229,7 @@ const modeSchema: z<SessionMode> = z.object({
     ),
   denySkills: z
     .array(z.string())
+    .role("select", { source: "catalog-skills" })
     .default([])
     .description(
       localized({
@@ -224,6 +239,8 @@ const modeSchema: z<SessionMode> = z.object({
     ),
   allowPolicies: z
     .array(z.string())
+    // 候选是上游那两条 policy 名（具名源 `policies`）。
+    .role("select", { source: "policies" })
     .default([])
     .description(
       localized({
@@ -233,6 +250,7 @@ const modeSchema: z<SessionMode> = z.object({
     ),
   denyPolicies: z
     .array(z.string())
+    .role("select", { source: "policies" })
     .default([])
     .description(
       localized({
@@ -251,8 +269,8 @@ const modeSchema: z<SessionMode> = z.object({
     ),
   skills: z.boolean().description(
     localized({
-      zh: "是否要技能目录（官方 `skill-catalog` 的注入）。**不写就按这个模式自己的工具名单推导**：`(allowTools 留空 ? 全部 : allowTools) − denyTools` 里含 `skill` 就要；写 `false` 就丢掉官方 `skill-catalog` 的注入（`skill` 工具的可见性仍归 `allowTools`）。",
-      en: "Whether the skill catalog applies (the official `skill-catalog` injection). Unset derives it from this mode's own tool lists: it applies when `(empty allowTools ? every tool : allowTools) − denyTools` contains `skill`; `false` drops the official `skill-catalog` injection (`skill` tool visibility still belongs to `allowTools`).",
+      zh: "是否要技能目录（官方 `skill-catalog` 的注入）。**默认就按这个模式自己的工具名单推导**：`(allowTools 留空 ? 全部 : allowTools) − denyTools` 里含 `skill` 就要；写 `false` 就丢掉官方 `skill-catalog` 的注入（`skill` 工具的可见性仍归 `allowTools`）。",
+      en: "Whether the skill catalog applies (the official `skill-catalog` injection). The default derives it from this mode's own tool lists: it applies when `(empty allowTools ? every tool : allowTools) − denyTools` contains `skill`; `false` drops the official `skill-catalog` injection (`skill` tool visibility still belongs to `allowTools`).",
     }),
   ),
   runtimeContext: z
@@ -260,21 +278,20 @@ const modeSchema: z<SessionMode> = z.object({
     .default(true)
     .description(
       localized({
-        zh: "是否要动态快照（文件沙箱策略、审批策略）。",
-        en: "Whether the runtime snapshot applies (sandbox and approval policy).",
+        zh: "是否要动态快照（文件沙箱策略、审批策略）与时钟注入（`standard` 那类 preset 声明的 `time-context`）。",
+        en: "Whether the runtime snapshot (sandbox and approval policy) and the clock injection (`time-context`, declared by presets such as `standard`) apply.",
       }),
     ),
   // 这个模式的默认模型。不标 `volatile`：`modes` 本身就是 volatile，整棵子树都在页面上——再标一层会被
   // schemastery 拒（`validateVolatileSchema` 不许 volatile 套 volatile）。
-  defaultModel: modelSchema
-    // `default(null)` 是"没配就没有这个键"：schemastery 对缺省的对象字段会造一个空对象，那样每个模式都会
+  defaultModel: modelSchema // `default(null)` 是"没配就没有这个键"：schemastery 对缺省的对象字段会造一个空对象，那样每个模式都会
     // 凭空多出一行；给了 null 反而让它保持缺失（页面按非必填处理，从候选加成）。
     // 类型上放行一次：`null` 在这里只是"没有这个键"的写法，schema 的输入形状不接受它。
     .default(null as unknown as SessionModeModel)
     .description(
       localized({
-        zh: "这个模式的默认模型；省略就跟全局默认模型。只在会话还没有模型事实时接管。",
-        en: "Default model for this mode; unset follows the global default. Applies only while a session has no model fact yet.",
+        zh: "这个模式的默认模型；不设就跟全局默认模型。只在会话还没有模型事实时接管。",
+        en: "Default model for this mode; empty follows the global default. Applies only while a session has no model fact yet.",
       }),
     ),
 });
@@ -316,7 +333,9 @@ interface Validated {
     Record<
       string,
       {
-        // 空串合法的"不挂"；共享合法（差异由会话级收口表达），所以这里不做任何映射唯一性校验。
+        // 留空合法的"不限制"；允许共享（差异由会话级收口表达），所以这里不做任何映射唯一性校验。
+        readonly presetsOnly?: readonly string[];
+        // 退役的单个 preset：还配着值就报错（它已经不再生效）。
         readonly preset?: string;
         // 留空合法：不设收窄（用 preset 的全部工具）。
         readonly allowTools?: readonly string[];
@@ -369,11 +388,18 @@ export function configProblem(config: Validated): string | undefined {
     return `session-mode: mode(s) ${unknownPolicies.join(", ")} name unknown policies; the known ones are ${POLICY_NAMES.join(", ")}`;
   }
   // `allowTools` **留空是合法的**：不设收窄，用这个会话挂着的 preset 的全部工具。
-  // `preset` **允许共享**（共享时 preset → 模式的反查交给 `SessionModes.modeForPreset`），空串是"不挂"；
-  // 退役的顶层 `models` 还配着值就报错——别让一份"看着像配过"的配置静静地失效。
+  // `presetsOnly` **允许留空**（不限制会话挂哪份 preset）**也允许共享**（共享时 preset → 模式的反查交给
+  // `SessionModes.modeForPreset`）；退役的顶层 `models` 还配着值就报错——别让一份"看着像配过"的配置静静地失效。
   if (Object.keys(config.models ?? {}).length > 0) {
     return "session-mode: `models` has moved into each mode's `defaultModel`; move the entries there and drop the top-level `models`";
   }
+  // 退役的单个 `preset`（现在是白名单 `presetsOnly`）：旧写法照旧"看着像配过"却不再生效，所以装配期拒绝。
+  const retiredPresets = Object.entries(config.modes)
+    .filter(([, mode]) => mode.preset !== undefined)
+    .map(([id]) => id);
+  if (retiredPresets.length > 0) {
+    return `session-mode: mode(s) ${retiredPresets.join(", ")} still declare \`preset\`; it has moved to \`presetsOnly\` (the presets that mode may ride on)`;
+  }
   // 每个模式自己的默认模型：成对给全（`provider` 与 `model` 都要）。
   const partial = Object.entries(config.modes)
     .filter(([, mode]) => {

package/src/rows.ts

@@ -22,6 +22,7 @@ function list<T>(values: readonly T[] | undefined): readonly T[] | undefined {
 
 // 一个模式的源定义 → 行 config（schema 的输入形状：可省的字段就省）。
 function modeConfig(source: ModeSource): Record<string, unknown> {
+  const presetsOnly = list(source.presetsOnly);
   const allowTools = list(source.allowTools);
   const denyTools = list(source.denyTools);
   const allowSkills = list(source.allowSkills);
@@ -29,8 +30,8 @@ function modeConfig(source: ModeSource): Record<string, unknown> {
   const allowPolicies = list(source.allowPolicies);
   const denyPolicies = list(source.denyPolicies);
   return {
-    // `preset` 是可选的：不写就是不绑（行 config 里也不出现这个键，schema 默认空串）。
-    ...(source.preset === undefined ? {} : { preset: source.preset }),
+    // `presetsOnly` 是可选的：不写（或写成空数组）就是这个键不进 config，schema 默认空数组（= 不限制）。
+    ...(presetsOnly === undefined ? {} : { presetsOnly }),
     name: source.name,
     description: source.description,
     ...(source.role === undefined ? {} : { role: [...source.role] }),