@morlay/dsh-session-mode 0.0.1 → 0.0.3

package/src/modes.ts

@@ -1,105 +1,86 @@
-/**
- * 模式的**定义形状**与它的装配期校验：一个模式就是"一段提示词 + 一组能力开关"。
- *
- * 与旧形态（每个模式一行 `@deepseek-ai/dsh-agent-preset`，`config.plugins` 里塞 persona / scope 行）的区别：
- * 模式不再是 Cordis 子树，而是这份纯数据——本包的插件行只在 `config.modes` 里声明它们，运行期按会话读取
- * 并应用（persona 注册到该 agent 的 scope，工具收口交给 `@morlay/dsh-context-assembler/scope`）。
- *
- * 行清单（工具 / 命令 / 压缩 / 委派…）来自 `preset` 指的那份 agent preset：本部署自己注册了一份
- * （`packages/bundles/session-mode-profile` 的 `preset-mode-switch`），两个模式共享它，差异全在会话级收口。
- *
- * "支持自定义"就是指这份 config：装配层（`cordis.patch.yml` / profile 的用户层）能整体改写 `modes`，
- * 也可以只给某几个模式换提示词或白名单——不需要任何插件行。
- *
- * "某个模式默认用哪个模型"**不在**模式里，而是 config 的顶层 `models`（模式 id → 模型）：它是 settings
- * 的设置面要编辑的东西，而设置面只认 volatile 字段、且只认**固定路径**（dict 内部的字段一律 blocked，见
- * `@deepseek-ai/schemastery` 的 `validateVolatileSchema`）。取舍与理由见
- * [ADR 模式默认模型搬到顶层 volatile](../.agents/adrs/20260925-模式默认模型搬到顶层volatile.md)。
- */
+// 模式的定义形状与它的装配期校验：一个模式就是"一段提示词 + 一组能力开关"，本行的 `config.modes` 声明它们。
+// 行清单来自 `preset` 指的那份 agent preset；装配层能整体改写 `modes`，也可以只给某几个模式换提示词或白名单。
+// 取舍见 `.agents/adrs/20260925-默认模型住在模式定义里.md`、`.agents/designs/20260924-会话模式.md`。
 
 import type { Volatile } from "@deepseek-ai/cordis";
 import z from "@deepseek-ai/schemastery";
+import { POLICY_NAMES } from "./shared.ts";
 
-/** 一个模式的提示词：两段文本，注册成 agent 作用域的 `deployment:persona-prefix` / `-suffix` section。 */
+// 一个模式的提示词：两段文本，注册成 agent 作用域的 `deployment:persona-prefix` / `-suffix` section。
 export interface SessionModePersona {
-  /** 系统提示词最前的一段；空串表示不遮蔽部署级那层。 */
+  // 系统提示词最前的一段；空串表示不遮蔽部署级那层。
   readonly prefix: string;
-  /** 系统提示词最后的一段；空串表示不写。 */
+  // 系统提示词最后的一段；空串表示不写。
   readonly suffix: string;
 }
 
-/**
- * 一个模式对谁可见：`main` 进用户选择器（会话级选择），`subagent` 表示它**可以**作为子代理的 mode。
- * 两个角色可以同时声明；不写默认 `["main"]`——没写角色的模式不该悄悄变成子代理候选。
- *
- * `subagent` 目前只是候选集的声明：子代理默认继承父 mode（不看角色），"按角色指派 mode" 还没做。
- */
+// 一个模式对谁可见：`main` 进用户选择器（会话级选择），`subagent` 表示它**可以**作为子代理的 mode。
+// 两个角色可以同时声明；不写默认 `["main"]`。`subagent` 现在只是候选集的声明——子代理默认继承父 mode。
 export type SessionModeRole = "main" | "subagent";
 
-/** 一个模式的默认模型；省略的字段跟着 provider 默认走（与全局 `agent-default-model` 同形状）。 */
+// 一个模式的默认模型；省略的字段跟着 provider 默认走（与全局 `agent-default-model` 同形状）。
 export interface SessionModeModel {
   readonly provider: string;
   readonly model: string;
   readonly reasoningEffort?: string;
 }
 
-/** 退役的顶层形状：模式 id → 模型（默认模型现在住在各自的模式里）。 */
+// 退役的顶层形状：模式 id → 模型（默认模型现在住在各自的模式里）。
 export type SessionModeModels = Readonly<Record<string, SessionModeModel>>;
 
-/**
- * 一个模式：提示词 + 能力开关。
- *
- * 这份形状是 **schema 归一化之后**的：每个字段都有值（写配置时可以不写，schema 用默认补上——`description`
- * 补空串、`persona` 补两段空文本、两个布尔开关补 `true`）。配置里能省略哪些字段看 `modeSchema` 的 default，
- * 不看这里。
- */
+// 一个模式：提示词 + 能力开关。这份形状是 **schema 归一化之后**的（每个字段都有值，schema 用默认补上），
+// 配置里能省略哪些字段看 `modeSchema` 的 default。
 export interface SessionMode {
-  /**
-   * 这个模式挂在哪个 **agent preset** 上（官方 `standard` / `ptc` / `minimal` / `cordis`，或本部署自己
-   * 注册的那一份的 `id`，见 `mode-sources.ts` 的 `MODE_PRESET_ID`）。
-   *
-   * preset 决定这个 agent 有哪些行（工具 / 命令 / 压缩 / 委派…），模式只决定"这些行怎么被用"：
-   * `allowTools` 里 preset 没有的工具自动跳过，其余扩展（persona / 注入开关 / 默认模型）照常应用。
-   * **可以共享**（本部署就是两个模式挂同一份 preset，差异全在会话级收口）；共享时 preset → 模式的反查无从下手，
-   * 见 `SessionModes.modeForPreset`。空串表示不挂（只能由 applyTo / 继承使用）。
-   */
+  // 这个模式挂在哪个 **agent preset** 上（官方四个，或本部署自己注册的那一份）。**可选**：不写（schema 里是空串）
+  // 就是不绑——选这个模式不换 preset，会话保持它当前挂着的那份，行清单由那份 preset 提供；模式自己的那几项扩展
+  // （persona / 工具名单 / policy 名单 / 三个开关 / `defaultModel`）在任意 preset 上都照常生效。
+  // 写了才在切模式时切过去；**可以共享**（共享时反查无从下手，见 `SessionModes.modeForPreset`）。
   readonly preset: string;
-  /** 模式的展示名（选择面归官方 roster；这里留着做事实文案）。 */
+  // 模式的展示名（选择面归官方 roster；这里留着做事实文案）。
   readonly name: string;
-  /** 一句话说明这个模式干什么；空串表示没写。 */
+  // 一句话说明这个模式干什么；空串表示没写。
   readonly description: string;
-  /** 这个模式归谁用：`main`（用户选择器）/ `subagent`（可作子代理 mode）。至少一个。 */
+  // 这个模式归谁用：`main`（用户选择器）/ `subagent`（可作子代理 mode）。至少一个。
   readonly role: SessionModeRole[];
-  /** 该模式的提示词。 */
+  // 该模式的提示词。
   readonly persona: SessionModePersona;
-  /**
-   * 这个模式能用哪些工具；其余工具既不进模型目录、调用也被执行层拒绝，它们自己的说明 section
-   * （`tool:<工具名>`）也不留在提示词里。**至少给一个**——想要"全都要"就列出全部，别留空。
-   */
+  // 这个模式能用哪些工具；其余工具既不进模型目录、调用也被执行层拒绝，它们自己的说明 section
+  // （`tool:<工具名>`）也不留在提示词里。**留空表示不设收窄**：这个会话用它挂着的 preset 装着的全部工具
+  // （想收窄就列名单——"全都要"不需要抄一份清单）。
   readonly allowTools: string[];
-  /**
-   * 是否要 instruction 类注入（工作区指令、技能目录、用法正文）。缺省要；`false` 表示这个模式一条都不要
-   * ——对话模式就是它。开关由 `@morlay/dsh-context-assembler/scope` 落到通道上。
-   */
+  // 这个模式**不用**哪些工具（黑名单）：从 `allowTools` 定下的那份里减掉（`allowTools` 留空时就是从全部里减）。
+  // 留空表示不禁任何工具。同时命中两份名单时以这里为准（deny 优先）。
+  readonly denyTools: string[];
+  // 上游 policy 规则的**生效白名单**：留空（或不写）表示全部规则照旧生效；有值表示只有列出的那些生效，
+  // 其余的按 `denyPolicies` 那一套被绕过。名单见 `POLICY_NAMES`。空数组与不写同义。
+  readonly allowPolicies: string[];
+  // 上游 policy 规则的黑名单：列出的规则**禁用**——上游在那条 waterfall 上的裁决（连它抛出的拒绝）被丢掉，
+  // 调用按"没有这条规则"继续。留空表示一条都不禁；同时命中两份名单时以这里为准（deny 优先）。
+  readonly denyPolicies: string[];
+  // 是否要 instruction 类注入。缺省要；`false` 表示这个模式一条都不要——对话模式就是它。落到两处：丢掉官方
+  // `agent-instructions` 的注入（`agent/pre-step` 上过滤），以及关掉通道自己的降级注入。
   readonly instructions: boolean;
-  /**
-   * 是否要 runtime context（文件沙箱策略、审批策略那两条动态快照）。缺省要；`false` 表示这个模式不要它们
-   * ——对话模式没有文件与 shell 工具，"能改工作区哪些文件、要不要走审批"对它全是噪音。
-   */
+  // 是否要技能目录。**可选**：不写就由这个模式自己的工具名单推导——`(allowTools 留空 ? 全部 : allowTools) −
+  // denyTools` 里含 `skill` 就要（`allowTools` 留空即"全部"，所以只有 `denyTools` 能把它推成 `false`）。
+  // `false` 表示这个模式不要技能目录：丢掉官方 `skill-catalog` 的注入（`skill` 工具的收窄仍归 `allowTools`）。
+  readonly skills?: boolean;
+  // 是否要 runtime context（文件沙箱策略、审批策略那两条动态快照）。缺省要；`false` 表示这个模式不要它们
+  // ——对话模式没有文件与 shell 工具，"能改工作区哪些文件、要不要走审批"对它全是噪音。
   readonly runtimeContext: boolean;
-  /**
-   * 这个模式的默认模型；省略就跟全局 `agent-default-model`。**可选**：没配的模式在页面上不出现在这一行
-   * （`defaultModel` 是它所在模式的一个可加字段）。
-   */
+  // 这个模式的默认模型；省略就跟全局 `agent-default-model`。**可选**：没配的模式在页面上不出现在这一行
+  // （`defaultModel` 是它所在模式的一个可加字段）。
   readonly defaultModel?: SessionModeModel;
 }
 
+// `skills` 不写时的推导：起点是白名单（留空 = 起点是全部工具，含 `skill`），减去黑名单，还留着 `skill` 就要技能
+// 目录。名单留空等于"全部工具"，所以只有 `denyTools` 能把它推成 `false`。
+export function derivedSkills(mode: Pick<SessionMode, "allowTools" | "denyTools">): boolean {
+  const allowed = mode.allowTools.length === 0 || mode.allowTools.includes("skill");
+  return allowed && !mode.denyTools.includes("skill");
+}
+
 // 每个字段都带 default：schema 的产物因此没有 `undefined` 键（`exactOptionalPropertyTypes` 下"缺省的键"
-// 会与可选属性对不上），而默认值就是"不遮蔽"的那个语义——persona 的默认是两段空文本。
-/**
- * 本地化说明：`description()` 的类型签名只声明 `string`，而 meta 本身接受 `Dict<string>`
- * （`vendor/schemastery/src/index.ts` 的 `mergeDesc` 就是按字典合并的），所以这里只做一次类型放行。
- */
+// 会与可选属性对不上）。`description()` 的类型签名只声明 `string`，这里做一次类型放行。
 const localized = (text: { zh: string; en: string }): string => text as unknown as string;
 
 const personaSchema = z.object({
@@ -107,10 +88,10 @@ const personaSchema = z.object({
   suffix: z.string().default(""),
 });
 
-/** 角色是个封闭集合：写错的 role 在装配期就拒绝，而不是静默变成"谁都不用"。 */
+// 角色是个封闭集合：写错的 role 在装配期就拒绝，而不是静默变成"谁都不用"。
 const roleSchema = z.union([z.const("main"), z.const("subagent")]);
 
-/** 默认模型的形状与全局 `agent-default-model` 一致；省略 effort 就跟 provider 默认。 */
+// 默认模型的形状与全局 `agent-default-model` 一致；省略 effort 就跟 provider 默认。
 const modelSchema = z.object({
   provider: z
     .string()
@@ -140,28 +121,24 @@ const modelSchema = z.object({
   ),
 });
 
-/** 本包 config 的**源码形状**：装配层与设置页写的那个形状。 */
+// 本包 config 的**源码形状**：装配层与设置页写的那个形状。
 export interface Config {
-  /** 新会话（还没选过模式的会话）用哪个模式。必须是 `modes` 里的一个 id。 */
+  // 新会话（还没选过模式的会话）用哪个模式。必须是 `modes` 里的一个 id。
   readonly default: string;
-  /** 模式清单：id → 定义（含各自的 `defaultModel`）。顺序即选择器里的顺序（`Object.entries` 的插入序）。 */
+  // 模式清单：id → 定义（含各自的 `defaultModel`）。顺序即选择器里的顺序（`Object.entries` 的插入序）。
   readonly modes: Record<string, SessionMode>;
-  /**
-   * 各模式默认模型曾经住在这里（模式 id → 模型）。现在住在**每个模式自己的 `defaultModel`** 里，这个字段
-   * 只剩一件事：装配期看见它还配着值就报错，提醒把它挪进对应的模式——否则它会静静地失效。
-   */
+  // 退役字段：各模式的默认模型住在每个模式自己的 `defaultModel` 里；这里留着只为装配期报错
+  // （见 `configProblem`）。
   readonly models?: SessionModeModels;
 }
 
-/**
- * schema 解析之后的形状：volatile 字段被换成**稳定引用**，读它要过 `.get()`（设置页改的就是同一份）。
- *
- * `default` 与 `modes` 都是 volatile：默认模式与整份模式清单（含各自的 `defaultModel`）都在行配置页上。
- */
+// schema 解析之后的形状：volatile 字段被换成**稳定引用**，读它要过 `.get()`（设置页改的就是同一份）。
+//
+// `default` 与 `modes` 都是 volatile：默认模式与整份模式清单（含各自的 `defaultModel`）都在行配置页上。
 export interface ResolvedConfig {
   readonly default: Volatile<string>;
   readonly modes: Volatile<Record<string, SessionMode>>;
-  /** 退役的顶层字段：解析后仍在这儿（普通值，不 volatile），装配期据此发现"还配着值"并报错。 */
+  // 退役的顶层字段：解析后仍在这儿（普通值，不 volatile），装配期据此发现"还配着值"并报错。
   readonly models: SessionModeModels;
 }
 
@@ -171,8 +148,8 @@ const modeSchema: z<SessionMode> = z.object({
     .default("")
     .description(
       localized({
-        zh: "这个模式挂哪个 agent preset（它的 id，官方或本部署自建的）：行清单由那个 preset 提供，几个模式可以共享同一个；空串表示不挂（只能由 applyTo / 继承使用）。",
-        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; empty means none (usable only through applyTo / inheritance).",
+        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.",
       }),
     ),
   name: z
@@ -208,8 +185,35 @@ const modeSchema: z<SessionMode> = z.object({
     .default([])
     .description(
       localized({
-        zh: "这个会话能用的工具；其余既不进目录，调用也被拒。",
-        en: "Tools this session may use; everything else leaves the catalog and calls are refused.",
+        zh: "这个会话能用的工具；其余既不进目录，调用也被拒。**留空就是不设收窄**：用这个会话挂着的 preset 提供的全部工具。",
+        en: "Tools this session may use; everything else leaves the catalog and calls are refused. Leave it empty to narrow nothing: the session then uses every tool its preset provides.",
+      }),
+    ),
+  denyTools: z
+    .array(z.string())
+    .default([])
+    .description(
+      localized({
+        zh: "这个模式不用的工具（黑名单）：从 `allowTools` 定下的那份里减掉（`allowTools` 留空就是从全部里减）。留空 = 一条都不禁；同时命中两份名单时以这里为准。",
+        en: "Tools this mode must not use (deny list): subtracted from whatever `allowTools` settled on (with an empty `allowTools`, from everything). Empty denies nothing; a name in both lists is denied.",
+      }),
+    ),
+  allowPolicies: z
+    .array(z.string())
+    .default([])
+    .description(
+      localized({
+        zh: "上游 policy 规则的生效白名单（`fs/write-intent` / `fs/edit-intent`）：留空 = 全部规则照旧生效；有值 = 只有列出的生效，其余的被绕过。",
+        en: "Allow list of upstream policy rules that stay in force (`fs/write-intent` / `fs/edit-intent`): empty keeps every rule; when set, only the listed ones stay, and the others are bypassed.",
+      }),
+    ),
+  denyPolicies: z
+    .array(z.string())
+    .default([])
+    .description(
+      localized({
+        zh: "上游 policy 规则的黑名单：列出的规则禁用（它的裁决连拒绝一起丢掉，调用按没有这条规则继续）。留空 = 一条都不禁；同时命中两份名单时以这里为准。",
+        en: "Deny list of upstream policy rules: the listed ones are disabled — their verdict (rejection included) is dropped and the call proceeds as if the rule were absent. Empty denies nothing; a name in both lists is denied.",
       }),
     ),
   instructions: z
@@ -217,10 +221,16 @@ const modeSchema: z<SessionMode> = z.object({
     .default(true)
     .description(
       localized({
-        zh: "是否要 instruction 类注入（工作区指令、技能目录、用法正文）。",
-        en: "Whether instruction-class injections apply (workspace instructions, skill catalog, guidance).",
+        zh: "是否要 instruction 类注入（工作区指令、用法正文）：`false` 时丢掉官方 `agent-instructions` 的注入，并关掉通道自己的降级注入。",
+        en: "Whether instruction-class injections apply (workspace instructions, guidance): `false` drops the official `agent-instructions` injection and turns off the channel's own demoted delivery.",
       }),
     ),
+  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`).",
+    }),
+  ),
   runtimeContext: z
     .boolean()
     .default(true)
@@ -230,10 +240,8 @@ const modeSchema: z<SessionMode> = z.object({
         en: "Whether the runtime snapshot applies (sandbox and approval policy).",
       }),
     ),
-  /**
-   * 这个模式的默认模型。不标 `volatile`：`modes` 本身就是 volatile，整棵子树都在页面上——再标一层会被
-   * schemastery 拒（`validateVolatileSchema` 不许 volatile 套 volatile）。
-   */
+  // 这个模式的默认模型。不标 `volatile`：`modes` 本身就是 volatile，整棵子树都在页面上——再标一层会被
+  // schemastery 拒（`validateVolatileSchema` 不许 volatile 套 volatile）。
   defaultModel: modelSchema
     // `default(null)` 是"没配就没有这个键"：schemastery 对缺省的对象字段会造一个空对象，那样每个模式都会
     // 凭空多出一行；给了 null 反而让它保持缺失（页面按非必填处理，从候选加成）。
@@ -264,43 +272,51 @@ export const Config: z<Config, ResolvedConfig> = z.object({
     .description(
       localized({
         zh:
-          "模式清单：id → 定义（persona / 允许的工具 / 角色）。改它对**已运行会话**不自动生效——重挂后新建的会话、" +
-          "或重新应用模式的会话才用新定义。",
+          "模式清单：id → 定义（persona / 工具名单 / 生效的 policy 规则 / 角色）。改它对**已运行会话**不自动生效" +
+          "——重挂后新建的会话、或重新应用模式的会话才用新定义。",
         en:
-          "Mode roster: id to definition (persona, allowed tools, role). Edits do not follow into already-running " +
-          "sessions; sessions created after the row is remounted use the new definition.",
+          "Mode roster: id to definition (persona, tool lists, effective policy rules, role). Edits do not follow " +
+          "into already-running sessions; sessions created after the row is remounted use the new definition.",
       }),
     )
     .volatile(),
-  /**
-   * 退役字段：默认模型住在每个模式自己的 `defaultModel` 里。这里留着是为了**报错**（见 `configProblem`），
-   * 页面上不出现（`hidden()`）。
-   */
+  // 退役字段：默认模型住在每个模式自己的 `defaultModel` 里。这里留着是为了**报错**（见 `configProblem`），
+  // 页面上不出现（`hidden()`）。
   models: z.dict(modelSchema).default({}).hidden(),
 });
 
-/** 校验只需要看的那几件事：默认模式、每个模式的工具名单与角色、每个模式自己的默认模型。 */
+// 校验只需要看的那几件事：默认模式、每个模式的角色、工具名单、policy 名单与默认模型。
 interface Validated {
   readonly default: string;
   readonly modes: Readonly<
     Record<
       string,
       {
-        /** 空串合法的"不挂"；共享合法（差异由会话级收口表达），所以这里不做任何映射唯一性校验。 */
+        // 空串合法的"不挂"；共享合法（差异由会话级收口表达），所以这里不做任何映射唯一性校验。
         readonly preset?: string;
+        // 留空合法：不设收窄（用 preset 的全部工具）。
         readonly allowTools?: readonly string[];
+        // 留空合法：不禁任何工具；与 `allowTools` 同时命中合法（deny 优先）。
+        readonly denyTools?: readonly string[];
+        // 留空合法：全部规则生效。
+        readonly allowPolicies?: readonly string[];
+        // 留空合法：一条都不禁；与 `allowPolicies` 同时命中合法（deny 优先）。
+        readonly denyPolicies?: readonly string[];
         readonly role?: readonly string[];
         readonly defaultModel?: { readonly provider?: string; readonly model?: string };
       }
     >
   >;
-  /** 退役的顶层字段：还配着值就报错（它已经不再生效）。 */
+  // 退役的顶层字段：还配着值就报错（它已经不再生效）。
   readonly models?: Readonly<Record<string, unknown>>;
 }
 
-/** 模式定义里不合法的地方（装配期 fail loud，而不是等到某个会话装配提示词时才发现）。 */
+// 已知的 policy 名（上游 waterfall 名）：写错的名字静默变成"没配"是这份配置最坏的失效方式，所以装配期拒绝。
+const POLICY_NAME_SET: ReadonlySet<string> = new Set(POLICY_NAMES);
+
+// 模式定义里不合法的地方（装配期 fail loud，而不是等到某个会话装配提示词时才发现）。
 export function configProblem(config: Validated): string | undefined {
-  /** 没写 `role` 等于默认 `["main"]`（与 schema 的默认一致）——字面量与归一化后的形状都能校验。 */
+  // 没写 `role` 等于默认 `["main"]`（与 schema 的默认一致）——字面量与归一化后的形状都能校验。
   const roles = (id: string): readonly string[] => config.modes[id]?.role ?? ["main"];
   const ids = Object.keys(config.modes);
   if (ids.length === 0) return "session-mode: `modes` must declare at least one mode";
@@ -314,14 +330,19 @@ export function configProblem(config: Validated): string | undefined {
   if (!roles(config.default).includes("main")) {
     return `session-mode: \`default\` names ${JSON.stringify(config.default)}, which does not declare role "main"; a session that can never be re-selected is a contradiction`;
   }
-  const empty = ids.filter((id) => (config.modes[id]?.allowTools ?? []).length === 0);
-  if (empty.length > 0) {
-    return `session-mode: mode(s) ${empty.join(", ")} declare no \`allowTools\`; list the tools instead of leaving it empty`;
+  // 每个模式列出的 policy 名都必须在已知名单里（名单见 `shared.ts` 的 `POLICY_NAMES`）。`denyTools` 与
+  // `allowTools` 同时命中是**合法**的（deny 优先）：这里不报错，只拒绝认不出的名字。
+  const unknownPolicies = Object.entries(config.modes).flatMap(([id, mode]) =>
+    [...(mode.allowPolicies ?? []), ...(mode.denyPolicies ?? [])]
+      .filter((policy) => !POLICY_NAME_SET.has(policy))
+      .map((policy) => `${id}: ${policy}`),
+  );
+  if (unknownPolicies.length > 0) {
+    return `session-mode: mode(s) ${unknownPolicies.join(", ")} name unknown policies; the known ones are ${POLICY_NAMES.join(", ")}`;
   }
-  // `preset` **允许共享**（本部署两个模式挂同一份 preset，差异由会话级收口表达）：共享时 preset → 模式
-  // 的反查无从下手，那件事交给 `SessionModes.modeForPreset` 处理（共享时它返回 `undefined`，不反查）。
-  // 空串是"不挂"，合法；除此之外没有可校验的东西——preset 是否存在由 registry 自己回答。
-  // 退役的顶层字段还配着值：它已经不再生效，别让一份"看着像配过"的配置静静地失效。
+  // `allowTools` **留空是合法的**：不设收窄，用这个会话挂着的 preset 的全部工具。
+  // `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`";
   }

package/src/persona.ts

@@ -1,13 +1,5 @@
-/**
- * 按会话给提示词：把模式的 persona 注册到**该 agent 自己的 scope** 上。
- *
- * 为什么不是一行 `@deepseek-ai/dsh-persona`：那一行只能按 scope 遮蔽，得先有一棵 preset 子树。这里走的是
- * 上游自己给子 agent 用的那条路——在 `agent.ctx` 上注册同名 section（`deployment:persona-prefix` /
- * `-suffix`），跨层遮蔽部署级那层，不需要任何子树。
- *
- * 两个 section 都注册（哪怕只给了一段文本）：suffix 缺省就是空串，语义与上游 persona 行一致。注册与
- * 注销都发 `system-prompt/change`，所以模式切换后下一次装配自然读到新文本。
- */
+// 按会话给提示词：把模式的 persona 注册到该 agent 自己的 scope 上（`deployment:persona-prefix` / `-suffix`），
+// 跨层遮蔽部署级那层。两个 section 都注册（缺省是空串）；注册与注销都发 `system-prompt/change`。
 
 import type { Agent } from "@deepseek-ai/dsh-agent";
 import type { PromptSectionOrderName } from "@deepseek-ai/dsh-system-prompt";
@@ -18,12 +10,7 @@ import type { SessionModePersona } from "./modes.ts";
 const PREFIX_ORDER: PromptSectionOrderName = "DEPLOYMENT_PERSONA_PREFIX";
 const SUFFIX_ORDER: PromptSectionOrderName = "DEPLOYMENT_PERSONA_SUFFIX";
 
-/**
- * 把一段 persona 装到该 agent 的 scope 上。
- * @param agent - 目标 agent（用它的 `ctx` 定作用域）。
- * @param persona - 模式的提示词；缺省时两段都注册成空串，等于遮蔽掉部署级那层。
- * @returns 注销这两个 section 的 disposer（模式切换时先调它）。
- */
+// 把一段 persona 装到该 agent 的 scope 上；返回注销这两个 section 的 disposer（模式切换时先调它）。
 export function installPersona(agent: Agent, persona: SessionModePersona | undefined): () => void {
   const prompt = agent.ctx.systemPrompt;
   const disposers = [

package/src/rows.ts

@@ -1,42 +1,54 @@
-/**
- * 本包作为能力包发布的**装配数据**：`session-mode` 行的 config（各模式的会话级扩展）由这里渲染，
- * 装配入口在 `packages/bundles/session-mode-profile`（它同时装注入通道、工具说明与 subagent 那几行）。
- */
+// 本包作为能力包发布的**装配数据**：`session-mode` 行的 config（各模式的会话级扩展）由这里渲染，
+// 装配入口在 `packages/bundles/session-mode-profile`（它同时装注入通道、工具说明与 subagent 那几行）。
 
 import { DEFAULT_MODE, MODE_SOURCES, type ModeSource } from "./mode-sources.ts";
 
-// 装配入口要拿这个 id 声明 preset 行（`preset-<id>` 的行 id 与 `config.id` 都用它）：与模式里的 `preset`
-// 是同一个事实，所以只有一份。
-export { MODE_PRESET_ID } from "./mode-sources.ts";
-
-/** 一行装配条目：与 `cordis.patch.yml` 的顶层结构同形。 */
+// 一行装配条目：与 `cordis.patch.yml` 的顶层结构同形。
 export interface PatchRow {
   readonly insert?: readonly RowEntry[];
 }
 
-/** `insert` 里的一个条目。 */
+// `insert` 里的一个条目。
 export interface RowEntry {
   readonly id: string;
   readonly name: string;
   readonly config?: Readonly<Record<string, unknown>>;
 }
 
-/** 一个模式的源定义 → 行 config（schema 的输入形状：可省的字段就省）。 */
+// 一份名单：留空（或没写）就不进 config——空数组与不写同义，行 config 里不留空键。
+function list<T>(values: readonly T[] | undefined): readonly T[] | undefined {
+  return values === undefined || values.length === 0 ? undefined : [...values];
+}
+
+// 一个模式的源定义 → 行 config（schema 的输入形状：可省的字段就省）。
 function modeConfig(source: ModeSource): Record<string, unknown> {
+  const allowTools = list(source.allowTools);
+  const denyTools = list(source.denyTools);
+  const allowPolicies = list(source.allowPolicies);
+  const denyPolicies = list(source.denyPolicies);
   return {
-    preset: source.preset,
+    // `preset` 是可选的：不写就是不绑（行 config 里也不出现这个键，schema 默认空串）。
+    ...(source.preset === undefined ? {} : { preset: source.preset }),
     name: source.name,
     description: source.description,
     ...(source.role === undefined ? {} : { role: [...source.role] }),
     ...(source.persona === undefined ? {} : { persona: { ...source.persona } }),
-    allowTools: [...source.allowTools],
+    // 四份名单都是可选的：不写（或写成空数组）就是这个键不进 config，schema 默认空数组。
+    // `allowTools` 不写 = 不设收窄；`denyTools` 不写 = 一件都不禁（两份同配时 deny 优先）；
+    // `allowPolicies` 不写 = 全部上游 policy 规则生效；`denyPolicies` 不写 = 一条都不禁。
+    ...(allowTools === undefined ? {} : { allowTools }),
+    ...(denyTools === undefined ? {} : { denyTools }),
+    ...(allowPolicies === undefined ? {} : { allowPolicies }),
+    ...(denyPolicies === undefined ? {} : { denyPolicies }),
     ...(source.instructions === undefined ? {} : { instructions: source.instructions }),
+    // `skills` 不写就是不进 config：缺省由这份定义自己的工具名单推导（写成 `false` 才落进 config）。
+    ...(source.skills === undefined ? {} : { skills: source.skills }),
     ...(source.runtimeContext === undefined ? {} : { runtimeContext: source.runtimeContext }),
     ...(source.defaultModel === undefined ? {} : { defaultModel: { ...source.defaultModel } }),
   };
 }
 
-/** `session-mode` 行的装配：默认模式与各模式的扩展定义。 */
+// `session-mode` 行的装配：默认模式与各模式的扩展定义。
 export function sessionModeRows(): readonly PatchRow[] {
   return [
     {