@morlay/dsh-session-mode 0.0.2 → 0.0.4

package/src/client/index.ts

@@ -1,49 +1,40 @@
-/**
- * client 半：会话里那一个面（模式 chip）+ 设置页里那张「会话模式」卡片。
- *
- * | 槽位                      | 呈现                                                |
- * | ------------------------- | --------------------------------------------------- |
- * | `conversation.input.left` | chip——点开就是切换列表（新会话屏也是一个 composer）  |
- *
- * 官方 `@deepseek-ai/dsh-client-ui-agent-preset` 保留（它提供 preset 的选择面与设置页 roster）：官方管"挂哪套
- * 行"，我们管"会话级扩展"，两套入口并存、互不遮挡。
- *
- * 头部的只读标签**没有**：chip 本来就把当前模式写在脸上（会话与新会话屏都有 composer），右上角再写一遍是
- * 同一句话的复读。
- *
- * 本行的配置页（各模式的默认模型 `config.models`）不再由本包画：那个字段是 volatile 的，页面由
- * `@morlay/dsh-client-ui-primitives` 按 schema 自动生成（它注册到本行的配置入口 `plugins.row.config`，
- * key = `<bundle 包名>#<行 id>`）。本包只管会话里那一个面。
- */
+// client 半：会话里那一个面（模式 chip，槽位 `conversation.input.left`，list + session scope）+ 配置页字段文案。
+// 官方 `@deepseek-ai/dsh-client-ui-agent-preset` 保留（官方管"挂哪套行"，我们管"会话级扩展"，两套入口并存）；
+// 本行的配置页由 `@morlay/dsh-client-ui-primitives` 按 schema 自动生成，key = `<bundle 包名>#<行 id>`。
 
 import type { Context } from "@deepseek-ai/cordis";
 // Type-only：`ctx.remote` 的合并面（选模型的候选来自 LLM 目录）。
 import type {} from "@deepseek-ai/dsh-api-remotes/client";
 import type {} from "@deepseek-ai/dsh-client-locale/client";
 import type {} from "@deepseek-ai/dsh-client-ui-slots";
-
 // Type-only：槽位声明与 standard props（session / session-maybe / global）。
 import type {} from "@morlay/dsh-client-ui-conversation/client";
+import { POLICY_NAMES } from "../shared.ts";
 import { SessionModeSeat } from "./SessionModeSeat.tsx";
 import { en, zh, type SessionModeLocaleKey } from "./locales.ts";
 
 declare module "@deepseek-ai/dsh-client-ui-slots" {
   interface LocaleNamespaceMap {
-    /** 会话里两个面的文案（配置页文案在通用 schema 表单的字典里）。 */
+    // 会话里两个面的文案（配置页文案在通用 schema 表单的字典里）。
     "session-mode": SessionModeLocaleKey;
   }
 }
 
-/** 浏览器半插件的字典命名空间。 */
+// 浏览器半插件的字典命名空间。
 const NS = "session-mode";
 
-/** 这一行里需要中文文案的字段（都在 `modes.<模式>.defaultModel` 里，所以按模板路径注册一次）。 */
+// 这一行里需要中文文案的字段（都在 `modes.<模式>.defaultModel` 里，所以按模板路径注册一次）。
 const FIELDS = ["provider", "model", "reasoningEffort"] as const;
 
-/** 动态键的占位段（与通用表单的字段树同一约定）。 */
+// 两份 policy 名单的字段名（`modes.<模式>.<字段>`）：它们在 schema 上是**字符串数组**（`z.array(z.string())`，没有
+// enum），候选值由本文件登记的封闭名单 `POLICY_NAMES` 给（见下面 `hints.select` 那一段）——所以两条已知 policy
+// 都以"未配置"的形态各占一项可选，页面把每一项画成选择器。
+const POLICY_FIELDS = ["allowPolicies", "denyPolicies"] as const;
+
+// 动态键的占位段（与通用表单的字段树同一约定）。
 const DYNAMIC = "*";
 
-/** 一个可配置 provider 的候选信息：显示名 + 它的配置在哪（模型清单从那份配置里读）。 */
+// 一个可配置 provider 的候选信息：显示名 + 它的配置在哪（模型清单从那份配置里读）。
 interface ProviderEntry {
   value: string;
   label: string;
@@ -54,13 +45,13 @@ interface ProviderEntry {
 export type { SessionModeSeatProps } from "./SessionModeSeat.tsx";
 export type { SessionModeLocaleKey } from "./locales.ts";
 
-/** 需要的服务：槽位与字典（会话列表经槽位的标准 props 到达组件，不必自己 inject）。 */
+// 需要的服务：槽位与字典（会话列表经槽位的标准 props 到达组件，不必自己 inject）。
 export const inject = ["slots", "locale"];
 
-/** 本包 host 行 id：行配置页读的就是这个命名空间。 */
+// 本包 host 行 id：行配置页读的就是这个命名空间。
 export const SESSION_MODE_NS = "session-mode";
 
-/** 按路径读一段配置里的值（本包只读 provider 档案里的模型清单）。 */
+// 按路径读一段配置里的值（本包只读 provider 档案里的模型清单）。
 function readAt(root: unknown, path: readonly string[]): unknown {
   return path.reduce<unknown>((node, segment) => {
     if (Array.isArray(node)) return node[Number(segment)];
@@ -69,11 +60,7 @@ function readAt(root: unknown, path: readonly string[]): unknown {
   }, root);
 }
 
-/**
- * 装上会话里的两个面，以及本行配置页的字段文案。
- *
- * @param ctx - 浏览器插件上下文。
- */
+// 装上会话里的那一个面，以及本行配置页的字段文案。
 export function apply(ctx: Context): void {
   const t = ctx.locale.bind(NS);
   ctx.effect(() => ctx.locale.register(NS, { zh, en }), "session-mode: dictionaries");
@@ -95,6 +82,22 @@ export function apply(ctx: Context): void {
     }, "session-mode: field wording"),
   );
 
+  // 两份 policy 名单是**字符串数组**，键的候选是一份封闭名单（上游 waterfall 名，见 `shared.ts` 的
+  // `POLICY_NAMES`）：在数组**项**那一路径上登记候选值，页面因此把每一项画成选择器，两条已知 policy 直接可选
+  // （不必手写名字）。名单住在 `shared.ts`——client 半不 import `modes.ts`（免得把 schemastery 拖进浏览器包）。
+  ctx.inject(["schemaFormHints"], (scope) =>
+    scope.effect(() => {
+      const offs = POLICY_FIELDS.map((key) =>
+        scope.schemaFormHints.select(SESSION_MODE_NS, ["modes", DYNAMIC, key, DYNAMIC], {
+          options: () => POLICY_NAMES.map((value) => ({ value })),
+        }),
+      );
+      return () => {
+        for (const off of offs) off();
+      };
+    }, "session-mode: policy candidates"),
+  );
+
   // 选模型的候选不在本行的 schema 里：provider 是部署里的 LLM 目录（活着的路由 + 可配置声明），模型清单读那份声明
   // 指向的配置（`settingsNs` / `settingsPath`）。目录异步取到后注册——注册本身就是一次变更通知。
   ctx.inject(["schemaFormHints"], (scope) =>

package/src/client/locales.ts

@@ -1,9 +1,5 @@
-/**
- * client 半的文案：命名空间 `session-mode`（与 locale 注册时用的 key 一致）。
- *
- * 只有会话里那个模式 chip 用这份字典：模式的名字与说明由 host 的清单给（那是数据，不是文案）。本行的配置页
- * （各模式的默认模型）由通用 schema 表单渲染，文案在它自己的字典里。
- */
+// client 半的文案：命名空间 `session-mode`（与 locale 注册时用的 key 一致）。模式的名字与说明由 host 的清单给
+// （那是数据，不是文案）；本行配置页的文案在通用 schema 表单自己的字典里。
 
 export const zh = {
   seatHint: "选择这个会话的模式",

package/src/client/use-roster.ts

@@ -2,13 +2,11 @@ import { useEffect, useState } from "react";
 import type { SessionModeRoster } from "../shared.ts";
 import { fetchRoster } from "./api.ts";
 
-/**
- * 模块级缓存：清单是装配事实（`session-mode` 行的 config），页面生命周期里不会变，两次挂载之间不必重拉。
- * 失败不缓存——下次挂载就是一次重试。
- */
+// 模块级缓存：清单是装配事实（`session-mode` 行的 config），页面生命周期里不会变，两次挂载之间不必重拉。
+// 失败不缓存——下次挂载就是一次重试。
 let pending: Promise<SessionModeRoster> | undefined;
 
-/** 读模式清单；还没读到（或读失败）时返回 undefined，组件据此不渲染。 */
+// 读模式清单；还没读到（或读失败）时返回 undefined，组件据此不渲染。
 export function useRoster(): SessionModeRoster | undefined {
   const [roster, setRoster] = useState<SessionModeRoster | undefined>(undefined);
   useEffect(() => {

package/src/index.ts

@@ -1,26 +1,6 @@
-/**
- * 会话模式的 host 半：模式清单（config 里的纯数据）、会话 ↔ 模式的选择、按会话应用 persona 与收口。
- *
- * **模式不是 Cordis 子树**。旧的 `@morlay/dsh-agent-preset` 每个模式都是一行
- * `@deepseek-ai/dsh-agent-preset`，`config.plugins` 里装 persona 与 scope 行，靠 preset scope 的父链
- * 对会话生效——代价是整个官方 registry（声明式行、每 revision 一棵 Loader 子树、`isolate` realm）都在
- * 部署里。这里只留两件事：模式是一份数据，应用落在会话自己的 scope 上：
- *
- * | 事实             | 落在哪                                                                                     |
- * | ---------------- | ------------------------------------------------------------------------------------------ |
- * | 模式清单与默认值 | 本行的 `config`（装配层可整体改写；`modes.ts` 给形状与校验）                                |
- * | 各模式的默认模型 | 同一份 config 的顶层 `models`（**volatile**：设置页那张卡片改的就是它）                      |
- * | 会话当前模式     | session 事件 `session-mode/selected` + 投影 `sessionMode`（log-only，重建读投影）           |
- * | 提示词           | `persona`：把模式的 persona 注册到该 agent 的 scope（`persona.ts`）                         |
- * | 工具与注入开关   | 推给 `ctx.sessionToolScope`（`@morlay/dsh-context-assembler/scope`，行 id `context-assembler-scope`） |
- * | 页面上的选择面   | HTTP 路由 `GET/POST /session-mode`（清单与切换）+ 会话投影（当前值）                        |
- *
- * 应用时机是 `agent/created`：它早于任何一次提示词装配（装配发生在 turn 里），所以 persona 一定在该会话
- * 第一次装配之前就注册好了。模式在**空白会话**里可以切换，切换时对着已有的 agent 重新应用一遍。
- *
- * 切换只允许在空白窗口（还没开过 turn）：会话的历史是在某个模式的工具集与提示词下产生的，换了模式，那段
- * 历史就与实际装配对不上——与上游 `agentPresets.select` 的判据一致，也用同一个投影（`turnBoundary`）。
- */
+// 会话模式的 host 半：模式清单（config 里的纯数据）、会话 ↔ 模式的选择、按会话应用 persona 与**收口**。模式是一份
+// 数据，应用落在会话自己的 scope 上（persona + 工具收口与三个注入开关，见 `./scope.ts`），默认模型住在
+// `modes.<id>.defaultModel`；换模式只允许在空白窗口。取舍见 `.agents/designs/20260924-会话模式.md`。
 
 import { Service, type Context } from "@deepseek-ai/cordis";
 import type { Agent } from "@deepseek-ai/dsh-agent";
@@ -35,32 +15,31 @@ import type {} from "@deepseek-ai/dsh-session-projection";
 // Type-only：官方 roster 的会话投影（`agentPreset`）与它的选择事件——选择面归官方 preset，
 // 我们读它的选择、落成自己的会话事实。
 import type {} from "@deepseek-ai/dsh-agent-preset-registry";
-import type { SessionToolScope } from "@morlay/dsh-context-assembler/scope";
+// Type-only：上游 fs 的 policy 事件词汇（`fs/write-intent` / `fs/edit-intent` 的签名与 `FsWriteIntent`）。
+import type {} from "@deepseek-ai/dsh-fs";
 import { z } from "zod";
 import {
   configProblem,
+  derivedSkills,
   type ResolvedConfig,
   type SessionMode,
   type SessionModeRole,
 } from "./modes.ts";
 import { installPersona } from "./persona.ts";
+import { SessionScope } from "./scope.ts";
 import {
   SESSION_MODE_PATH,
+  type PolicyName,
   type SessionModeRoster,
   type SessionModeRow,
   type SessionModeSelectResult,
 } from "./shared.ts";
 
-/** Cordis 插件名：与行 id 一致。 */
+// Cordis 插件名：与行 id 一致。
 export const name = "session-mode";
 
-/**
- * 依赖：投影服务（登记 `sessionMode`、读 `turnBoundary`）、读会话与 agent 的两个注册表，以及提示词注册表
- * （persona 的 section 注册在它上面）。
- *
- * 这些名字必须在 `inject` 里点名：cordis 的**属性访问**（`this.ctx.sessions`）要求本 fiber 声明过那个服务，
- * 未声明会抛 `cannot get property "sessions" without inject`（`ctx.get(name)` 才不需要声明）。
- */
+// 这些名字必须在 `inject` 里点名：cordis 的属性访问（`this.ctx.sessions`）要求本 fiber 声明过那个服务，
+// 未声明会抛 `cannot get property "sessions" without inject`（`ctx.get(name)` 才不需要声明）。
 export const inject = ["agents", "sessions", "sessionProjections", "systemPrompt"];
 
 export { Config } from "./modes.ts";
@@ -72,7 +51,8 @@ export type {
   SessionModeRole,
 } from "./modes.ts";
 export { SESSION_MODE_PATH } from "./shared.ts";
-export type { SessionModeRoster, SessionModeRow } from "./shared.ts";
+export { POLICY_NAMES } from "./shared.ts";
+export type { PolicyName, SessionModeRoster, SessionModeRow } from "./shared.ts";
 
 declare module "@deepseek-ai/cordis" {
   interface Context {
@@ -82,10 +62,7 @@ declare module "@deepseek-ai/cordis" {
 
 declare module "@deepseek-ai/dsh-session/types" {
   interface SessionEventMap {
-    /**
-     * 会话在空白窗口里换了模式。**log-only**：它记录此后每一步实际运行的模式，恢复与 fork 时据此重建
-     * （模式决定模型看到的工具与提示词，所以它必须进日志）。
-     */
+    // 会话在空白窗口里换了模式；**log-only**，恢复与 fork 据此重建（模式决定模型看到的工具与提示词）。
     "session-mode/selected": { sessionMode: string };
   }
 }
@@ -96,16 +73,16 @@ declare module "@deepseek-ai/dsh-session-projection/types" {
     sessionModeEditable: boolean;
   }
   interface SessionProjectionMap {
-    /** 会话当前模式；`null` 表示没选过（用部署默认）。 */
+    // 会话当前模式；`null` 表示没选过（用部署默认）。
     sessionMode: string | null;
-    /** 会话还能不能换模式：`true` 是选择器，`false` 是只读标签（client 那个 chip 据此变形）。 */
+    // 会话还能不能换模式：`true` 是选择器，`false` 是只读标签（client 那个 chip 据此变形）。
     sessionModeEditable: boolean;
   }
 }
 
 const sessionModeSchema: z.ZodType<string | null> = z.union([z.string(), z.null()]);
 
-/** 会话模式的投影：初值来自空日志（没选过就是 `null`），只被选择事件推进。 */
+// 会话模式的投影：初值来自空日志（没选过就是 `null`），只被选择事件推进。
 export const sessionModeProjection = {
   key: "sessionMode",
   stateSchema: sessionModeSchema,
@@ -118,13 +95,8 @@ export const sessionModeProjection = {
 
 const sessionModeEditableSchema: z.ZodType<boolean> = z.boolean();
 
-/**
- * 这个会话能不能换模式的投影：空白会话为 `true`，一旦 `turn/start` 落库就永远 `false`（换模式要的是**整段
- * 历史**的模式一致，所以"开过 turn"之后连正在跑的那个 turn 也算）。
- *
- * **判据只有这一处**：服务端 {@link SessionModes.select} 的拒绝与 client chip 的只读形态都读它——以前
- * client 只能等服务端报错，现在连入口都不给，而两边的结论来自同一份会话事实。
- */
+// 这个会话能不能换模式的投影：空白会话为 `true`，`turn/start` 一落库就永远 `false`（换模式要的是整段历史的
+// 模式一致）。判据只有这一处——服务端拒绝与 client chip 的只读形态都读它。
 export const sessionModeEditableProjection = {
   key: "sessionModeEditable",
   stateSchema: sessionModeEditableSchema,
@@ -134,12 +106,16 @@ export const sessionModeEditableProjection = {
   stateVersion: 1,
 } satisfies ProjectionDefinition<"sessionModeEditable", boolean>;
 
-/** 模式清单、默认模式、按会话读取与切换。 */
+// 模式清单、默认模式、按会话读取与切换。
 export class SessionModes extends Service {
-  /** 每个 agent 已经装上的那一份（persona + 默认模型兜底；模式变了就换一份）。 */
+  // 每个 agent 已经装上的那一份（persona + 默认模型兜底；模式变了就换一份）。
   private readonly installs = new WeakMap<Agent, { mode: string; dispose: () => void }>();
 
-  /** 装配时的配置快照：`default` / `modes` 读它，改这两项靠 Loader 重挂这一行（已运行会话不自动换定义）。 */
+  // 按会话收口：工具名单、instruction / 技能目录 / 动态快照三个开关。它由本行**内部持有**（不发布服务）——收口的
+  // 输入就是模式定义、唯一消费者也是模式。
+  private readonly scope: SessionScope;
+
+  // 装配时的配置快照：`default` / `modes` 读它，改这两项靠 Loader 重挂这一行（已运行会话不自动换定义）。
   readonly config: {
     default: string;
     modes: Record<string, SessionMode>;
@@ -156,16 +132,38 @@ export class SessionModes extends Service {
     // 退役的顶层 `models` 还配着值就让装配期报错。
     const problem = configProblem({ ...this.config, models: config.models });
     if (problem !== undefined) throw new Error(problem);
+    this.scope = new SessionScope(ctx);
     ctx.sessionProjections.register(sessionModeProjection);
     ctx.sessionProjections.register(sessionModeEditableProjection);
+    // 按模式的 policy 拦截：两条上游 waterfall 各 `prepend` **一次**，注册在行 ctx 上、随行卸载一起撤。
+    //
+    // 接缝为什么只有这一种：fs 的调用是 `ctx.waterfall('fs/write-intent', target, actor, next)`——事件名在第一个
+    // 参数上，而 cordis 只在"第一个参数是对象 / 函数"时才取接收者并按 scope 过滤，所以这两条 waterfall 上
+    // **没有 scope 过滤**：注册在该 agent 的 ctx 上买不到隔离，只会多 N 份判断。归属只能从 `actor.agent` 认
+    // （工具把自己的 exec 当 actor 传进来），模式的判据每次调用**现算**——于是切模式 / `applyTo` / 子代理继承
+    // 都不需要换监听器，"重复应用不重复注册"是结构上的事，不靠判等维持。
+    //
+    // 位置：上游 `fs-observation-policy` 在这两条 waterfall 上**独占决策槽**（它不调 `next()`），所以链首只能靠
+    // `prepend` 抢——站在它后面就没有决策权。这份实现的前提就是这条契约（见
+    // `.agents/designs/20260929-按模式的policy拦截.md`）。
+    ctx.on(
+      // `satisfies PolicyName`：注册的事件名与 `POLICY_NAMES`（装配期校验与页面候选键读的同一份名单）必须在类型面
+      // 对得上——名单里删掉一个名字，这里就编不过，而不是静默拦不住。
+      "fs/write-intent" satisfies PolicyName,
+      (_target, actor, next) => this.decidePolicy("fs/write-intent", actor, next),
+      { prepend: true },
+    );
+    ctx.on(
+      "fs/edit-intent" satisfies PolicyName,
+      (_target, actor, next) => this.decidePolicy("fs/edit-intent", actor, next),
+      { prepend: true },
+    );
     // 会话一建立就装上：这早于它的第一次装配，persona 因此一定在装配之前注册好。
     ctx.on("agent/created", ({ agent }) => {
       this.installFor(agent);
     });
-    // 官方 roster 在空白窗口换 preset 时，把该会话的扩展换成新 preset 那一份：先把它写成我们的会话事实
-    // （`installFor` 读的就是这份事实），再按新模式装一遍。
-    // 只在 preset → 模式的映射唯一时动手：本部署两个模式共享同一份 preset，反查无意义（`modeForPreset`
-    // 返回 `undefined`），选模式不会经过这条监听，模式事实由 `select` 自己落。
+    // 官方 roster 换 preset 时把该会话的扩展换成新 preset 那一份（先落成会话事实再重装）；
+    // 只在 preset → 模式的映射唯一时动手（共享同一份 preset 时反查无意义）。
     ctx.on("agent-preset/selected", (sessionId: SessionId, preset: string) => {
       const mapped = this.modeForPreset(preset);
       const agent = ctx.agents.get(sessionId);
@@ -177,12 +175,12 @@ export class SessionModes extends Service {
     });
   }
 
-  /** 新会话用它：config 里的 `default`。 */
+  // 新会话用它：config 里的 `default`。
   get defaultId(): string {
     return this.config.default;
   }
 
-  /** 选择器要的清单：只列 `main` 角色的模式（id、展示名、说明，顺序即 config 里 `modes` 的插入序）。 */
+  // 选择器要的清单：只列 `main` 角色的模式（id、展示名、说明，顺序即 config 里 `modes` 的插入序）。
   list(): SessionModeRow[] {
     return this.idsFor("main").map((id) => {
       const mode = this.definition(id);
@@ -194,32 +192,24 @@ export class SessionModes extends Service {
     });
   }
 
-  /**
-   * 声明了某个角色的模式 id（顺序即 config 的插入序）：`main` 给用户选择器，`subagent` 给子代理候选。
-   * @param role - 目标角色。
-   * @returns 该角色下的模式 id。
-   */
+  // 声明了某个角色的模式 id（顺序即 config 的插入序）：`main` 给用户选择器，`subagent` 给子代理候选。
   idsFor(role: SessionModeRole): string[] {
     return Object.entries(this.config.modes)
       .filter(([, mode]) => mode.role.includes(role))
       .map(([id]) => id);
   }
 
-  /**
-   * 同 {@link idsFor}，给的是定义——"指定 mode" 那条接缝要拿候选集。
-   * @param role - 目标角色。
-   * @returns 该角色下的模式与其定义。
-   */
+  // 同 `idsFor`，给的是定义——"指定 mode" 那条接缝要拿候选集。
   modesFor(role: SessionModeRole): { id: string; mode: SessionMode }[] {
     return this.idsFor(role).map((id) => ({ id, mode: this.definition(id) }));
   }
 
-  /** 页面用的清单 + 默认模式。 */
+  // 页面用的清单 + 默认模式。
   roster(): SessionModeRoster {
     return { default: this.defaultId, modes: this.list() };
   }
 
-  /** 按 id 取定义；未知 id 直接抛（切换路径上它就是用户的错）。 */
+  // 按 id 取定义；未知 id 直接抛（切换路径上它就是用户的错）。
   definition(id?: string): SessionMode {
     const wanted = id ?? this.defaultId;
     const mode = this.config.modes[wanted];
@@ -231,30 +221,50 @@ export class SessionModes extends Service {
     return mode;
   }
 
-  /** 会话当前模式：投影上有就用它，否则是部署默认。 */
+  // 会话当前模式：投影上有就用它，否则是部署默认。
   modeOf(session: Session): string {
     const selected = this.ctx.sessionProjections.stateOf(session, "sessionMode");
     return selected ?? this.defaultId;
   }
 
-  /** 会话当前模式的定义。 */
+  // 会话当前模式的定义。
   modeOfSession(session: Session): SessionMode {
     return this.definition(this.modeOf(session));
   }
 
-  /**
-   * 把某个空白会话切到某个模式。
-   *
-   * 模式带着它的 preset（`preset` 决定行清单），所以这里**先把 agent preset 换成模式声明的那个**，再落我们的
-   * 会话事实：否则 preset realm 还是旧那一套的行，而它的注入在我们的开关之外（旧形态 `chat` 挂 `minimal`、
-   * 会话的 preset 却还是 `standard` 时，上游 `agent-instructions` 会照旧把工作区指令注进这个"不要注入"的会话）。
-   *
-   * 目标 preset 与当前挂着的**相同时不切**（本部署两个模式共享同一份 preset，所以切模式通常走不到这一步）：
-   * 换 preset 是一次重挂（卸旧行、装新行），没有变化就没有理由付出这个代价。
-   * @param sessionId - 目标会话（必须还没有开过 turn）。
-   * @param mode - 目标模式 id。
-   * @returns 提交后的模式 id。
-   */
+  // 这条 policy 规则在**这次调用**里还生效吗（`true` = 交给上游，`false` = 被这个模式禁用）。
+  // 判据只有一处：`actor.agent` → `agent.session` → `modeOf`。认不出 agent（没有 agent 的直接调用）、或模式 id 在
+  // config 里找不到（重挂前后的瞬间）时一律按"没配"读——拦截路径绝不抛错。
+  private policyInForce(policy: PolicyName, actor: object | undefined): boolean {
+    const agent = (actor as { readonly agent?: Agent } | undefined)?.agent;
+    if (agent === undefined) return true;
+    const mode = this.config.modes[this.modeOf(agent.session)];
+    if (mode === undefined) return true;
+    // 合成规则（deny 优先）：生效集合 =（`allowPolicies` 空 ? 全部 : `allowPolicies`）− `denyPolicies`。
+    if (mode.denyPolicies.includes(policy)) return false;
+    return mode.allowPolicies.length === 0 || mode.allowPolicies.includes(policy);
+  }
+
+  // 一条 policy 规则的裁决：规则生效就原样交给上游（`next()` 的返回值或拒绝照旧出去）；被禁用就**先让上游算完
+  // 再丢掉结论**——上游在链首之后独占决策槽，"放过"唯一可能的形态就是无条件裁决（`fs/edit-intent` 上它是免
+  // "先读后改"，`fs/write-intent` 上是连陈旧版本 / CAS 那层安全网一起丢）。上游抛出的拒绝也属于这条裁决：
+  // 接住它，返回 `undefined`（= 这次调用按"没有这条规则"继续）。
+  private async decidePolicy<T>(
+    policy: PolicyName,
+    actor: object | undefined,
+    next: () => T | Promise<T>,
+  ): Promise<T | undefined> {
+    if (this.policyInForce(policy, actor)) return await next();
+    try {
+      await next();
+    } catch {
+      // 上游的拒绝是这次裁决的一部分：禁用就是连它一起不要。
+    }
+    return undefined;
+  }
+
+  // 把某个空白会话（必须还没开过 turn）切到某个模式：先把 agent preset 换成模式声明的那个
+  // （目标与当前相同时不切——换 preset 是一次重挂），再落会话事实并重装该 agent 的扩展。
   async select(sessionId: SessionId, mode: string): Promise<string> {
     const definition = this.definition(mode);
     if (!definition.role.includes("main")) {
@@ -262,16 +272,15 @@ export class SessionModes extends Service {
     }
     const session = this.ctx.sessions.get(sessionId);
     if (session === undefined) throw new Error(`未知的会话 ${sessionId}`);
-    // 空白窗口的判据只有一处：{@link sessionModeEditableProjection}。client 那个 chip 读的是同一个投影，
-    // 所以"看起来能选"与"服务端接受"不会脱节。
+    // 空白窗口的判据只有一处：`sessionModeEditableProjection`（client chip 读同一个投影）。
     if (this.ctx.sessionProjections.stateOf(session, "sessionModeEditable") === false) {
       throw new Error("这个会话已经开始，模式不能再改；要换模式请新开一个会话。");
     }
     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`，
-      // 下面那个监听据此把模式落成会话事实并装一遍——所以写事实前先比一次投影，同一个值不写第二条。
+      // 官方那条路自己也会查空白窗口（`agent-preset/locked`）；它切完会 emit `agent-preset/selected`，
+      // 监听据此落事实并重装——所以这里先比一次投影，同一个值不写第二条。
       if (this.presetOfAgent(registry, agent) !== definition.preset) {
         await registry.select(agent, definition.preset);
       }
@@ -284,12 +293,7 @@ export class SessionModes extends Service {
     return mode;
   }
 
-  /**
-   * 某个 agent 当前挂着的 preset（registry 的 `composedPreset`）。
-   *
-   * 读不到时返回 `undefined`（按"未知"处理 → 该切就切）：`composedPreset` 是 registry 较新的读面，替身与老
-   * 版本可能没有它；而"没挂任何 preset"（返回值 `undefined`）与"读不到"在这里是同一个结论。
-   */
+  // 某个 agent 当前挂着的 preset（registry 的 `composedPreset`）；读不到时按"未知"处理（该切就切）。
   private presetOfAgent(registry: Context["agentPresets"], agent: Agent): string | undefined {
     const read = (registry as { composedPreset?: (ctx: Context) => string | undefined })
       .composedPreset;
@@ -301,10 +305,8 @@ export class SessionModes extends Service {
     }
   }
 
-  /**
-   * 官方 preset registry：行清单与它的选择面住在那一行。不在 `inject` 里点名（headless 部署没有它，
-   * 点名会让本行永不激活），所以按"可能拿不到"读——`ctx.get` 在当前 ctx 没声明那个服务时会抛。
-   */
+  // 官方 preset registry；不在 `inject` 里点名（headless 部署没有它，点名会让本行永不激活），
+  // 所以按"可能拿不到"读——`ctx.get` 在当前 ctx 没声明那个服务时会抛。
   private presetRegistry(): Context["agentPresets"] | undefined {
     try {
       return this.ctx.get("agentPresets");
@@ -313,13 +315,8 @@ export class SessionModes extends Service {
     }
   }
 
-  /**
-   * 把某个活着的 agent 切到某个模式。与 {@link select} 的差别：它不要求空白会话——子代理创建时的继承
-   * 走这里，**未来的"指定 mode"入口（模型侧或配置侧）也走这里**（那条接缝还没做）。
-   * @param agent - 目标 agent。
-   * @param mode - 目标模式 id。
-   * @param options.record - 是否把这次切换写进会话日志（缺省写；只想改当前进程时给 `false`）。
-   */
+  // 把某个活着的 agent 切到某个模式（不要求空白会话：子代理创建时的继承走这里）；
+  // `options.record: false` 时不写会话日志（只改当前进程）。
   applyTo(agent: Agent, mode: string, options: { record?: boolean } = {}): void {
     this.definition(mode);
     if (options.record !== false) {
@@ -328,17 +325,14 @@ export class SessionModes extends Service {
     this.installFor(agent, mode);
   }
 
-  /**
-   * 该 agent 用哪个模式：会话选过（投影上有）优先，子代理继承父，其余用部署默认。
-   *
-   * 继承要**写进子会话日志**：它是一条会话事实，冷恢复与 fork 都要靠它重建（{@link modeOf} 只读投影）。
-   */
+  // 该 agent 用哪个模式：会话选过（投影上有）优先，子代理继承父，其余用部署默认。
+  // 继承要写进子会话日志——它是一条会话事实，冷恢复与 fork 靠它重建（`modeOf` 只读投影）。
   private resolveModeId(agent: Agent): string {
     // `undefined` = 这个投影没注册（或还没初始化），与"没选过"（`null`）一样落到下一层。
     const selected = this.ctx.sessionProjections.stateOf(agent.session, "sessionMode");
     if (typeof selected === "string") return selected;
-    // 会话级选择归官方 roster：它的 preset 决定这个会话用哪份扩展，我们把结论落成自己的会话事实
-    // （`sessionMode` 是会话级事实的 home：恢复、子代理继承、服务端读取都读它）。
+    // 会话级选择归官方 roster；结论落成我们自己的会话事实（`sessionMode`：恢复、子代理继承、
+    // 服务端读取都读它）。
     const mapped = this.modeForPreset(this.presetOf(agent.session));
     if (mapped !== undefined) {
       agent.session.append("session-mode/selected", { sessionMode: mapped });
@@ -350,7 +344,7 @@ export class SessionModes extends Service {
     return inherited;
   }
 
-  /** 官方 roster 选定的 preset（没选过、或 registry 没装时为 `undefined`）。 */
+  // 官方 roster 选定的 preset（没选过、或 registry 没装时为 `undefined`）。
   private presetOf(session: Session): string | undefined {
     try {
       const state = this.ctx.sessionProjections.stateOf(session, "agentPreset");
@@ -361,16 +355,8 @@ export class SessionModes extends Service {
     }
   }
 
-  /**
-   * 某个 agent preset 对应的模式 id——**只在映射唯一时**回答（几个模式挂同一份 preset 时返回
-   * `undefined`，不反查）。
-   *
-   * 本部署的两个模式共享同一个 preset（`MODE_PRESET_ID`），差异全在会话级收口，所以 preset → 模式的反查在
-   * 这里无意义：模式由**会话事实**决定（`session-mode/selected` 投影 → 子代理继承 → 部署默认），
-   * 官方 roster 选了什么 preset 不改变这个会话是哪个模式。这条反查留给"一对一映射"的部署形态。
-   * @param preset - preset id（`undefined` 表示没选过、或 registry 没装）。
-   * @returns 该 preset 唯一对应的模式 id；没配扩展、或由多个模式共享时 `undefined`。
-   */
+  // 某个 preset 对应的模式 id——只在映射唯一时回答（共享同一份 preset、或没有模式挂它时 `undefined`）；
+  // 本部署的模式由会话事实决定，这条反查留给"一对一映射"的部署形态。
   modeForPreset(preset: string | undefined): string | undefined {
     if (preset === undefined) return undefined;
     const owners = Object.keys(this.config.modes).filter(
@@ -379,7 +365,7 @@ export class SessionModes extends Service {
     return owners.length === 1 ? owners[0] : undefined;
   }
 
-  /** 子代理（有 durable 父会话）继承父当前模式；父不在场、或不是子代理时没有可继承的。 */
+  // 子代理（有 durable 父会话）继承父当前模式；父不在场、或不是子代理时没有可继承的。
   private inheritedModeId(agent: Agent): string | undefined {
     const parentId = agent.session.header.parentSession;
     if (parentId === undefined) return undefined;
@@ -387,7 +373,7 @@ export class SessionModes extends Service {
     return parent === undefined ? undefined : this.modeOf(parent.session);
   }
 
-  /** 装或换该 agent 的那一份（幂等：同一模式不重复注册）。 */
+  // 装或换该 agent 的那一份（幂等：同一模式不重复注册）。
   private installFor(agent: Agent, modeId: string = this.resolveModeId(agent)): void {
     const installed = this.installs.get(agent);
     if (installed?.mode === modeId) return;
@@ -403,16 +389,20 @@ export class SessionModes extends Service {
         for (const dispose of disposers) dispose();
       },
     });
-    this.toolScope()?.apply(agent, mode);
+    // 收口要的那几项按模式定义整份推过去：`name` / `allowTools` / `denyTools` / 三个开关。`skills` 缺省时在这里
+    // 按这份定义自己的工具名单推导（见 `derivedSkills`）——收口那一侧只认解析后的布尔。
+    this.scope.apply(agent, {
+      name: mode.name,
+      allowTools: mode.allowTools,
+      denyTools: mode.denyTools,
+      instructions: mode.instructions,
+      skills: mode.skills ?? derivedSkills(mode),
+      runtimeContext: mode.runtimeContext,
+    });
   }
 
-  /**
-   * 模式的默认模型（`modes.<模式 id>.defaultModel`）兜底：只在会话**尚无任何模型事实**（没选过模型、也
-   * 还没跑过请求）时接管这一请求的路由；一旦用户选过（投影 `pending`）或会话已经落过 header，就不再插手。
-   *
-   * 它是**配置事实**，不写会话事件——重启后仍由 config 决定；设置页里那条会话级选择才是会话事实。读的是构造
-   * 时那份模式清单快照：设置页保存会让这一行重挂（`reconcileProfilePatches`），新定义随重挂生效。
-   */
+  // 模式的默认模型兜底：只在会话尚无任何模型事实（没选过模型、也没落过 request header）时接管这一请求的
+  // 路由。它是配置事实、不写会话事件，读构造时的模式快照（设置页保存会让这一行重挂）。
   private installDefaultModel(agent: Agent, modeId: string): () => void {
     return agent.ctx.on("agent/request", async (_payload, next): Promise<LlmCallConfig> => {
       const resolved = await next();
@@ -432,15 +422,6 @@ export class SessionModes extends Service {
       };
     });
   }
-
-  /** 收口服务由 `@morlay/dsh-context-assembler/scope` 那一行发布；没装它就只有 persona。 */
-  private toolScope(): SessionToolScope | undefined {
-    try {
-      return this.ctx.get("sessionToolScope");
-    } catch {
-      return undefined;
-    }
-  }
 }
 
 export function apply(ctx: Context, config: ResolvedConfig): void {
@@ -528,12 +509,8 @@ async function handleRoute(
   }
 }
 
-/**
- * 把清单与切换挂到同一张宿主路由表上。
- *
- * `webServer` **必须等**：它可能比本行晚激活，而一次性 `ctx.get` 取到 `undefined` 之后不会再试一次——
- * 路由没注册的后果是请求落到静态资源 fallback，非 GET/HEAD 一律 405。
- */
+// 把清单与切换挂到宿主路由表上。`webServer` 必须等：它可能比本行晚激活，一次性 `ctx.get` 取不到就不会
+// 再试（后果是请求落到静态资源 fallback）。
 function registerHttpRoutes(ctx: Context, modes: SessionModes): void {
   ctx.inject(["webServer"], (scope) => {
     // webServer 的类型由上游 `@deepseek-ai/dsh-host-webserver` 声明；这里只按用到的 register 面做结构转换。