@morlay/dsh-context-assembler 0.0.1-alpha.2 → 0.0.1-alpha.3

package/README.md

@@ -5,13 +5,13 @@
 见 [`src/rows.ts` 的 `contextChannel()`](./src/rows.ts)。引用展开原先也在这个包里，
 现在独立成 [`@morlay/dsh-reference`](../dsh-reference/README.md)（它只挂 `agent/pre-step`、不依赖通道）。
 
-| 出口                   | 行 id / 插件 name                                         | 做什么                                                                 |
-| ---------------------- | --------------------------------------------------------- | ---------------------------------------------------------------------- |
-| `.`                    | `context-assembler`（插件 name `context-assembler-tree`） | **组装出口**：按 config 决定装哪些能力、各带什么参数（缺省即四套能力） |
-| `./assembler`          | `context-assembler`                                       | 注入通道：唯一渲染者与唯一覆盖判定处，发布 `ctx.contextAssembler`      |
-| `./agent-instructions` | `context-agent-instructions`                              | 工作区指令链（`$DSH_HOME/AGENTS.md` + 项目根到 cwd 逐级）              |
-| `./skill-catalog`      | `context-skill-catalog`                                   | skill 目录规则块 + 模型侧 `skill` 工具                                 |
-| `./scope`              | `context-scope`                                           | 模式收口：工具白名单、instruction 总开关、动态快照开关                 |
+| 出口                   | 行 id / 插件 name                                         | 做什么                                                                       |
+| ---------------------- | --------------------------------------------------------- | ---------------------------------------------------------------------------- |
+| `.`                    | `context-assembler`（插件 name `context-assembler-tree`） | **组装出口**：按 config 决定装哪些能力、各带什么参数（缺省即四套能力）       |
+| `./assembler`          | `context-assembler`                                       | 注入通道：唯一渲染者与唯一覆盖判定处，发布 `ctx.contextAssembler`            |
+| `./agent-instructions` | `context-agent-instructions`                              | 工作区指令链（`$DSH_HOME/AGENTS.md` + 项目根到 cwd 逐级）                    |
+| `./skill-catalog`      | `context-skill-catalog`                                   | skill 目录规则块 + 模型侧 `skill` 工具                                       |
+| `./scope`              | `context-assembler-scope`                                 | 按会话收口：工具白名单、instruction 总开关、动态快照开关（模式把定义推给它） |
 
 规则、id 表与分层的 home 在 [上下文注入规则](./.agents/designs/20260921-上下文注入规则.md)；术语见
 [本包 CONTEXT](./.agents/CONTEXT.md)。
@@ -23,8 +23,8 @@
 （[`@morlay/dsh-agent-toolkit`](../../profile/dsh-agent-toolkit/README.md) 的 `guidance`）这类消费者住在别的包里，
 隔离会把它们挡在组外（行停在 waiting，不报错）；理由见
 [ADR 通道作为全局服务装配不隔离](./.agents/adrs/20260923-通道作为全局服务装配不隔离.md)。`scope` **不在这份 patch 里**
-——它是模式的开关，由 [`@morlay/dsh-agent-preset`](../../profile/dsh-agent-preset/README.md) 用 `scopeRow()` 按模式装
-（它 `inject` 通道，`ctx.get("contextAssembler")` 在 agent 子树里可达）。
+——它是模式那一层的收口行，由 [`@morlay/dsh-session-mode`](../../profile/dsh-session-mode/README.md) 的 patch 与模式定义
+一起装（行 id 与 name 归本包的 `scopeRow()`，单一 home）。
 
 工具说明（汉化 / 精简 / 用法分组）也不在这里：它归
 [`@morlay/dsh-agent-toolkit`](../../profile/dsh-agent-toolkit/README.md)，同样在 profile 平面装一次。
@@ -32,8 +32,8 @@
 ## 装配形态
 
 本包是 bundle：`cordis.patch.yml` 由 [`tool/patch.ts`](./tool/patch.ts) 从 [`src/rows.ts`](./src/rows.ts) 渲染，
-`rows` 出口导出同一份清单。`dsh.profile.bundles` 列出本包即装一次，**服务全局共享、不隔离**；preset 只用
-`scopeRow()` 按模式收口（工具白名单 / instruction / 动态快照），别的包的行（工具说明、skill 目录）直接 `inject`
+`rows` 出口导出同一份清单。`dsh.profile.bundles` 列出本包即装一次，**服务全局共享、不隔离**；模式的收口是
+另一行（`scopeRow()`：工具白名单 / instruction / 动态快照），别的包的行（工具说明、skill 目录）直接 `inject`
 同一份通道。
 
 ## 为什么合成一个包
@@ -70,7 +70,7 @@ user 消息注入（每条按文本幂等，只有变化的那条重发）。
 | `hiddenSkills(visible)`               | 声明了 `requires` 而入口工具一个都不可见的 skill 名                              |
 
 配置（`keep` / `suppress` / `replace`）的默认值在 [`src/assembler/defaults.ts`](./src/assembler/defaults.ts)。
-**全局一份、不隔离**：模式差异由 `context-scope` 登记（`setInstructions` / `restrictTools`）收口，跨包的
+**全局一份、不隔离**：模式差异由 `context-assembler-scope` 登记（`setInstructions` / `restrictTools`）收口，跨包的
 消费者（工具说明、技能目录）直接 `inject` 同一份通道（见
 [ADR 通道作为全局服务装配不隔离](./.agents/adrs/20260923-通道作为全局服务装配不隔离.md)）。
 
@@ -79,14 +79,14 @@ user 消息注入（每条按文本幂等，只有变化的那条重发）。
 `$DSH_HOME/AGENTS.md` 加项目根到 cwd 的逐级 `AGENTS.md` / `AGENTS.local.md`，**一条文件一条 id**
 （`agent-instructions:<根标识>:<文件>`，根标识是根目录的 8 位摘要——同进程两个项目根的同名文件因此不会互相
 顶掉），文件变化时只重发变了的那一份。取代上游 `@deepseek-ai/dsh-agent-instructions`（host 那行由上游
-web-app bundle 自己设在 preset 平面）。
+web-app bundle 自己设在装配层；我们那份由本包的组装出口在 profile 平面装）。
 
 - **不跟踪 `read`/`write`/`edit`**：上游靠 touch 上浮触发刷新；本部署的 `AGENTS.md` 几乎不变，按
   `mtime:size` 对账足够。
 - **超预算可见**：单文件超过 `maxBytes` 时截断并留一行提示，不静默丢内容。
 - **与上游的 baseline 认领对齐**：`source` 带 `kind: "agent-instructions"` + `baseline: true` +
   `baselineIdentity`（身份与上游 `workspaceBaselineIdentity` 逐字相等）。少了后两样会出一个只在真会话里
-  看得见的毛病：**同会话切到官方 preset 后出现两条 AGENTS.md**——上游认为基线不存在，再注入一条自己的模板
+  看得见的毛病：**同会话切到另一套装配后出现两条 AGENTS.md**——上游认为基线不存在，再注入一条自己的模板
   （"Use them as guidance…"），两条口径矛盾且模型无法理解为覆盖。
 - 配置：`instructionFileCandidates` / `localInstructionFileCandidates`（覆盖成只读 `AGENTS*`，不含 CLAUDE
   系列）、`maxBytes`（65536）、`dshHome`。
@@ -105,10 +105,15 @@ web-app bundle 自己设在 preset 平面）。
 
 ## scope
 
-预设模式的收口行：工具白名单（装配期投影 + 执行层 guard + 与工具同源的 `tool:<工具名>` 说明 section，三侧
-同判据）、`instructions`（关掉规则块与降级 section）、`runtimeContext`（关掉沙箱 / 审批那两条动态快照，按
-scope 抑制）。它解决的是"preset 只能决定加什么、管不了 host 层"——模式要表达"我只有这几个工具、一条提示词
-都不要"时，唯一与来源无关的做法是在会话语义上收口。`allowTools` 为空即装配失败（该省掉整行）。
+按会话收口的出口（行 id `context-assembler-scope`）：工具白名单（装配期投影 + 执行层 guard + 与工具同源的
+`tool:<工具名>` 说明 section，三侧同判据）、`instructions`（关掉规则块与降级 section）、`runtimeContext`
+（关掉沙箱 / 审批那两条动态快照，按 scope 抑制）。
+
+**定义由消费方推给它**，它自己不认识"模式"：`ctx.sessionToolScope.apply(agent, mode)` 是唯一入口，落在该
+agent 的 `ctx` 上（抑制器、guard 都在那里），同一个 agent 再 apply 一次就是换一份——旧的 effect 树收回、按新
+的装一遍。它解决的是"模式只能决定加什么、管不了 host 平面"：`dsh.profile.bundles` 打开的包（工具行、
+实验性的 Agent Teams）在 host 平面插行，对所有会话一视同仁；模式要表达"我只有这几个工具、一条提示词都不要"
+时，唯一与来源无关的做法是在会话语义上收口。
 
 白名单同时登记给通道（`restrictTools`）：技能目录与用法组正文按 `visibleTools` 收口，所以被收窄的工具既不在
 目录、也不会被讲——注册表里"装着"不等于这个会话"能用"。
@@ -125,15 +130,12 @@ scope 抑制）。它解决的是"preset 只能决定加什么、管不了 host
         capabilities: [assembler, agent-instructions, skill-catalog]
 ```
 
-**preset 平面**：模式只装一行开关（工具白名单 / instruction / 动态快照），通道由 profile 那份共享：
+**模式平面**：收口那一行（不带 config——模式定义在 `session-mode` 行的 `config.modes` 里）由
+[`@morlay/dsh-session-mode`](../../profile/dsh-session-mode/README.md) 的 patch 装，通道由 profile 那份共享：
 
 ```yaml
-- id: context-scope
+- id: context-assembler-scope
   name: "@morlay/dsh-context-assembler/scope"
-  config:
-    allowTools: [ask_user_question, web_search, web_fetch]
-    instructions: false
-    runtimeContext: false
 ```
 
 几点硬要求：
@@ -141,9 +143,10 @@ scope 抑制）。它解决的是"preset 只能决定加什么、管不了 host
 - **每个能力仍是独立的 cordis 插件**（组装出口只是 `ctx.plugin()` 装它们），各自带自己的 `inject`；合成单入口会让
   `inject` 变并集，一个可选搭档缺席就拖垮整包。
 - **通道不做隔离**：消费者跨包（`@morlay/dsh-agent-toolkit` 的工具说明、本包的技能目录），隔离会把它们挡在组外
-  （行停在 waiting）；模式差异改由 `context-scope` 登记给通道，见
+  （行停在 waiting）；模式差异改由 `context-assembler-scope` 登记给通道，见
   [ADR 通道作为全局服务装配不隔离](./.agents/adrs/20260923-通道作为全局服务装配不隔离.md)。真装配的判据是
-  `pnpm exec tsx packages/desktop/dsh-desktop-host/tool/verify-preset-isolation.mts`（装配层可见一份、模式里没有第二份）。
+  `pnpm exec tsx packages/desktop/dsh-desktop-host/tool/verify-session-mode.mts`（装配层可见一份、收口行装上、
+  官方 agent preset 不在）。
 - **子出口仍可单独装配**（`@morlay/dsh-context-assembler/assembler` 等）：同一些插件，只是默认走组装出口。
 
 ## 维护注意

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { n as agent_instructions_exports } from "./agent-instructions-BNEiZl0P.mjs";
 import { r as assembler_exports } from "./assembler-_F9urbPj.mjs";
-import { a as scope_exports } from "./scope-CI-fNq5A.mjs";
+import { t as scope_exports } from "./scope.mjs";
 import { t as skill_catalog_exports } from "./skill-catalog.mjs";
 import z from "@deepseek-ai/schemastery";
 //#region src/index.ts

package/dist/rows.d.mts

@@ -6,8 +6,9 @@
  * （`@morlay/dsh-agent-toolkit/guidance`，在别的包里）与 skill 目录这类消费者都在别的行上
  * `inject` 它，隔离会把它们挡在组外（行停在 waiting，不报错）。
  *
- * preset 只装 `scopeRow()`（模式的开关）：它 `inject` 通道，`ctx.get("contextAssembler")` 在 agent
- * 子树里可达，不需要另装一份通道。
+ * 本包自己的 bundle 只装通道（`PATCH_ROWS`）。模式的收口是另一行（`scopeRow()`），它由
+ * [`@morlay/dsh-session-mode`](../../../profile/dsh-session-mode/README.md) 的 patch 与模式定义一起装——
+ * 那一行的 config 就是模式清单。
  */
 /** 组装出口（包根）就是那个"按 config 装能力"的插件。 */
 declare const CONTEXT_PACKAGE = "@morlay/dsh-context-assembler";
@@ -23,18 +24,19 @@ interface ContextRow {
  */
 declare function contextChannel(config?: Readonly<Record<string, unknown>>): ContextRow;
 /**
- * 模式开关那一行：`scope` 出口按 preset 配（工具白名单、instruction 总开关、动态快照开关）。
+ * 模式收口那一行：`scope` 出口按 `ctx.sessionModes` 的模式定义收口（工具白名单、instruction 总开关、
+ * 动态快照开关）。
  *
- * 通道在 profile 平面装一次，这一行只按模式收口（它 `inject` `contextAssembler`，
- * `ctx.get("contextAssembler")` 在 agent 子树里可达）。
+ * 行 id 用全名 `context-assembler-scope`：它的搭档是同一份装配里的 `context-assembler`（通道），两个 id 放在
+ * 一起才看得出这一行属于哪个包、做什么——`context-scope` 那种短名会被误当成 `ctx.contextScope` 之类的服务。
+ *
+ * 行本身**不带 config**：装哪些模式、每个模式收什么，都由 `session-mode` 行的 `config.modes` 决定，
+ * 这一行只把它落到会话上（`inject` `sessionModes`，由
+ * [`@morlay/dsh-session-mode`](../../../profile/dsh-session-mode/README.md) 的 patch 插一行）。
  */
-declare function scopeRow(config?: Readonly<Record<string, unknown>>): {
-  readonly id: string;
-  readonly name: string;
-  readonly config?: Readonly<Record<string, unknown>>;
-};
+declare function scopeRow(): ContextRow;
 /**
- * bundle patch 的行清单：通道一行（`scope` 是模式的开关，由 preset 装 `scopeRow()`）。
+ * bundle patch 的行清单：只有通道一行（模式收口那一行归 `session-mode` 的 patch 装）。
  *
  * 形态是 `insert`：这些行由本包提供给 host 平面。写成 `- id: x` 那种"改已有行"的形态时，装配期找不到
  * 目标行（只 warn 后跳过），通道根本没装上，引用它的行停在 waiting。

package/dist/rows.mjs

@@ -6,8 +6,9 @@
 * （`@morlay/dsh-agent-toolkit/guidance`，在别的包里）与 skill 目录这类消费者都在别的行上
 * `inject` 它，隔离会把它们挡在组外（行停在 waiting，不报错）。
 *
-* preset 只装 `scopeRow()`（模式的开关）：它 `inject` 通道，`ctx.get("contextAssembler")` 在 agent
-* 子树里可达，不需要另装一份通道。
+* 本包自己的 bundle 只装通道（`PATCH_ROWS`）。模式的收口是另一行（`scopeRow()`），它由
+* [`@morlay/dsh-session-mode`](../../../profile/dsh-session-mode/README.md) 的 patch 与模式定义一起装——
+* 那一行的 config 就是模式清单。
 */
 /** 组装出口（包根）就是那个"按 config 装能力"的插件。 */
 const CONTEXT_PACKAGE = "@morlay/dsh-context-assembler";
@@ -23,20 +24,24 @@ function contextChannel(config) {
 	};
 }
 /**
-* 模式开关那一行：`scope` 出口按 preset 配（工具白名单、instruction 总开关、动态快照开关）。
+* 模式收口那一行：`scope` 出口按 `ctx.sessionModes` 的模式定义收口（工具白名单、instruction 总开关、
+* 动态快照开关）。
 *
-* 通道在 profile 平面装一次，这一行只按模式收口（它 `inject` `contextAssembler`，
-* `ctx.get("contextAssembler")` 在 agent 子树里可达）。
+* 行 id 用全名 `context-assembler-scope`：它的搭档是同一份装配里的 `context-assembler`（通道），两个 id 放在
+* 一起才看得出这一行属于哪个包、做什么——`context-scope` 那种短名会被误当成 `ctx.contextScope` 之类的服务。
+*
+* 行本身**不带 config**：装哪些模式、每个模式收什么，都由 `session-mode` 行的 `config.modes` 决定，
+* 这一行只把它落到会话上（`inject` `sessionModes`，由
+* [`@morlay/dsh-session-mode`](../../../profile/dsh-session-mode/README.md) 的 patch 插一行）。
 */
-function scopeRow(config) {
+function scopeRow() {
 	return {
-		id: "context-scope",
-		name: "@morlay/dsh-context-assembler/scope",
-		...config === void 0 ? {} : { config }
+		id: "context-assembler-scope",
+		name: "@morlay/dsh-context-assembler/scope"
 	};
 }
 /**
-* bundle patch 的行清单：通道一行（`scope` 是模式的开关，由 preset 装 `scopeRow()`）。
+* bundle patch 的行清单：只有通道一行（模式收口那一行归 `session-mode` 的 patch 装）。
 *
 * 形态是 `insert`：这些行由本包提供给 host 平面。写成 `- id: x` 那种"改已有行"的形态时，装配期找不到
 * 目标行（只 warn 后跳过），通道根本没装上，引用它的行停在 waiting。

package/dist/scope.d.mts

@@ -1,47 +1,41 @@
 import z from "@deepseek-ai/schemastery";
-import { Context } from "@deepseek-ai/cordis";
+import { Context, Service } from "@deepseek-ai/cordis";
+import { Agent } from "@deepseek-ai/dsh-agent";
 declare namespace index_d_exports {
-  export { Config, apply, inject, name };
+  export { Config, SessionToolScope, SessionToolScopeMode, apply, inject, name };
 }
-declare const name = "context-scope";
+declare const name = "context-assembler-scope";
+/** 收口要的服务；`sessionToolScope` 由本行自己发布，`tools` 的 guard 挂在每个 agent 的 ctx 上。 */
 declare const inject: string[];
-interface Config {
-  /**
-   * 只保留这些工具；其余（含 host 层 bundle 加进来的）既不进模型目录，调用不了，它们自己注册的说明
-   * section（`tool:<工具名>`）也不留在提示词里。
-   */
-  allowTools?: string[];
-  /**
-   * 是否要 instruction 类的注入（工作区指令、技能目录、用法正文那类规则块）。缺省要；
-   * `false` 表示这个模式不要任何 instructions——对话模式就是它。
-   *
-   * 关的是**规则块与降级 section**（通道的 `setInstructions`）；内容块（`auto` 组正文、引用材料）
-   * 不受这个开关管，要靠对应的注入方自己不注册（chat 同时给了 `groups: false`）。
-   * 注意这与工具白名单是两件事：工具没给，跟着它的注入本来就该自己关（见各注入包对 requires 的判断）；
-   * 这里是"连与工具无关的 instruction 也不要"的总开关。
-   */
-  instructions?: boolean;
+/** 本行不吃 config：要收成什么样由消费方在 `apply` 时给。 */
+declare const Config: z<Schemastery.ObjectS<{}>, Schemastery.ObjectT<{}>, "plain">;
+/** 一次收口的全部输入：模式定义里本出口用到的那几项。 */
+interface SessionToolScopeMode {
+  /** 拒绝对话时用的模式名。 */
+  readonly name: string;
+  /** 这个会话能用的工具；其余既不进目录，调用也被拒。 */
+  readonly allowTools: readonly string[];
+  /** 缺省为要；`false` 表示这个会话不要任何 instruction 类注入。 */
+  readonly instructions?: boolean | undefined;
+  /** 缺省为要；`false` 表示这个会话不要动态快照。 */
+  readonly runtimeContext?: boolean | undefined;
+}
+declare module "@deepseek-ai/cordis" {
+  interface Context {
+    sessionToolScope: SessionToolScope;
+  }
+}
+/** 按会话收口工具与注入的服务。 */
+declare class SessionToolScope extends Service {
+  private readonly applied;
+  constructor(ctx: Context);
   /**
-   * 是否要 runtime context（动态快照：文件沙箱策略、审批策略）。缺省要；`false` 表示这个模式不要它们
-   * ——对话模式没有文件与 shell 工具，"能改工作区哪些文件、要不要走审批"对它全是噪音。
-   *
-   * 抑制是**按 scope** 的（上游按装配的 scope 链查抑制器），所以本行装在 preset 子树里就只作用于这个
-   * 模式的会话；它只挡注入，不改任何提供方的行为（沙箱该怎么判还怎么判）。
+   * 把某个会话收口到这份定义上（同一个 agent 再调就是换一份）。
+   * @param agent - 目标会话的 agent。
+   * @param mode - 收口的全部输入。
    */
-  runtimeContext?: boolean;
+  apply(agent: Agent, mode: SessionToolScopeMode): void;
 }
-declare const Config: z<Config>;
-/**
- * 把某个 preset 的工具收成"只有这些"。
- *
- * 为什么需要它：preset composition 只能决定"加什么"，管不了 host 层——`dsh.profile.bundles` 打开的
- * bundle（例如实验性的 Agent Teams）会在 host 层插工具行与 section，对所有 preset 一视同仁。模式想
- * 表达"我只有这几个工具、一条提示词都不要"时，唯一与来源无关的做法是收口"有什么"。
- *
- * 为什么不是 `tools.restrict()`：它会改动可见工具集，从而触发 `tools/change`；上游 `tool-subagent`
- * 正是用该事件做 composition reconcile——两边互相触发会变成装配风暴。这里用投影过滤加执行层 guard：
- * 既不碰注册表、也不发事件。
- */
-declare function apply(ctx: Context, config: Config): void;
+declare function apply(ctx: Context): void;
 //#endregion
-export { Config, apply, inject, name, index_d_exports as t };
+export { Config, SessionToolScope, SessionToolScopeMode, apply, inject, name, index_d_exports as t };

package/dist/scope.mjs

@@ -1,2 +1,102 @@
-import { i as name, n as apply, r as inject, t as Config } from "./scope-CI-fNq5A.mjs";
-export { Config, apply, inject, name };
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import z from "@deepseek-ai/schemastery";
+import { Service } from "@deepseek-ai/cordis";
+//#region src/scope/index.ts
+/**
+* 按**会话**收口：工具白名单、instruction 总开关、动态快照。
+*
+* 这是本包的 `scope` 出口（行 id `context-assembler-scope`）。它不再吃 config，也不认识"模式"这个概念——
+* 收口要什么由消费方在会话建立时**推**进来：`ctx.sessionToolScope.apply(agent, mode)`（
+* [`@morlay/dsh-session-mode`](../../../profile/dsh-session-mode/README.md) 的模式定义里正好是这几项）。
+* 方向因此是单向的：装配层读这个服务，这个包不认识装配层。
+*
+* `apply` 落到该 agent 身上的三件事，各走一条与"谁注册了这个工具"无关的路：
+*
+* 1. **装配期投影**（每次装配按已注册的那份）：模型目录与工具说明的 `tool:<工具名>` section 同源过滤；
+* 2. **执行层 guard**：落在 `agent.ctx` 上，调用被拒时给出该模式的文案；
+* 3. **通道开关**：`instructions` 关掉该会话的规则块（工作区指令、技能目录、用法正文）、
+*    `runtimeContext` 抑制该会话的动态快照（沙箱与审批策略那两条）。
+*
+* 为什么不用 `tools.restrict()`：它会改动可见工具集，从而触发 `tools/change`；上游 `tool-subagent` 正是用
+* 该事件做 composition reconcile——两边互相触发会变成装配风暴。这里用投影过滤加执行层 guard：既不碰注册
+* 表、也不发事件。
+*
+* 为什么按 `agent.ctx` 注册而不是先建一棵 preset 子树：会话的 persona / 工具收口本来就是"这个 agent 的
+* 事"，`agent.ctx` 的 scope 已经够了（上游给子 agent 装 persona 用的也是这条路）；一棵子树要连带上游的
+* `agent-presets` 注册表、每 revision 一份 Loader 与 `isolate` realm，模式本身用不上。
+*
+* 模式在空白窗口里可以切换，所以状态是**可替换**的：同一个 agent 再 `apply` 一次就是换一份——旧的
+* disposer 全部收回，再按新的装一遍。
+*/
+var scope_exports = /* @__PURE__ */ __exportAll({
+	Config: () => Config,
+	SessionToolScope: () => SessionToolScope,
+	apply: () => apply,
+	inject: () => inject,
+	name: () => name
+});
+const name = "context-assembler-scope";
+/** 收口要的服务；`sessionToolScope` 由本行自己发布，`tools` 的 guard 挂在每个 agent 的 ctx 上。 */
+const inject = ["tools", "systemPrompt"];
+/** 本行不吃 config：要收成什么样由消费方在 `apply` 时给。 */
+const Config = z.object({});
+const OUT_OF_SCOPE = (toolName, modeName) => `${toolName} 不在「${modeName}」的工具范围内，用它不会有结果；按当前模式提供的工具完成任务，或让用户切到别的模式。`;
+/** 单个工具的说明 section 名前缀：`tool:<工具名>`（`tools:` 那类是聚合块，不归白名单管）。 */
+const TOOL_SECTION_PREFIX = "tool:";
+/** 通道是可选的搭档：没有它就没有 instruction 可关、也没人收窄技能目录，工具目录与执行 guard 照常生效。 */
+function channelOf(ctx) {
+	try {
+		return ctx.get("contextAssembler");
+	} catch {
+		return;
+	}
+}
+/** 按会话收口工具与注入的服务。 */
+var SessionToolScope = class extends Service {
+	applied = /* @__PURE__ */ new WeakMap();
+	constructor(ctx) {
+		super(ctx, "sessionToolScope");
+		ctx.on("system-prompt/assemble", async (_assembly, context, next) => {
+			const agent = context.agent;
+			const applied = agent === void 0 ? void 0 : this.applied.get(agent);
+			if (applied === void 0) return next();
+			const allow = new Set(applied.mode.allowTools);
+			const result = await next();
+			return {
+				...result,
+				sections: result.sections.filter((section) => section.name.startsWith(TOOL_SECTION_PREFIX) ? allow.has(section.name.slice(5)) : true),
+				tools: result.tools.filter((tool) => allow.has(tool.name))
+			};
+		});
+	}
+	/**
+	* 把某个会话收口到这份定义上（同一个 agent 再调就是换一份）。
+	* @param agent - 目标会话的 agent。
+	* @param mode - 收口的全部输入。
+	*/
+	apply(agent, mode) {
+		const previous = this.applied.get(agent);
+		if (previous !== void 0) previous.dispose();
+		const allow = new Set(mode.allowTools);
+		const dispose = agent.ctx.effect(() => {
+			const stoppers = [];
+			if (mode.runtimeContext === false) stoppers.push(agent.ctx.systemPrompt.suppressRuntimeContext());
+			const fiber = agent.ctx.inject(["tools"], (scope) => {
+				scope.tools.guard((exec) => allow.has(exec.name) ? void 0 : OUT_OF_SCOPE(exec.name, mode.name));
+			});
+			return [...stoppers, () => fiber.dispose()];
+		}, "sessionToolScope: per-session gate");
+		const channel = channelOf(this.ctx);
+		channel?.setInstructions(agent, mode.instructions !== false);
+		channel?.restrictTools(agent, (tool) => allow.has(tool));
+		this.applied.set(agent, {
+			mode,
+			dispose
+		});
+	}
+};
+function apply(ctx) {
+	new SessionToolScope(ctx);
+}
+//#endregion
+export { Config, SessionToolScope, apply, inject, name, scope_exports as t };

package/locale/en.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "Context Assembler",
-    "description": "Prompt-injection capability set: the single injection channel plus workspace instructions, skill catalog, tool-usage guidance and the per-mode scope gate."
+    "description": "Prompt-injection capability set: the single injection channel plus workspace instructions, skill catalog and the scope gate that narrows tools per session mode."
   }
 }

package/locale/zh.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "注入能力组",
-    "description": "提示词注入能力组：唯一注入通道，以及工作区指令、skill 目录、工具用法分组与模式收口。"
+    "description": "提示词注入能力组：唯一注入通道，以及工作区指令、skill 目录与模式收口。"
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@morlay/dsh-context-assembler",
-  "version": "0.0.1-alpha.2",
-  "description": "Prompt-injection capability set for dsh: the single channel (context assembler) plus the injectors it carries — workspace instructions, skill catalog, tool-usage guidance, and the per-mode scope gate. Reference expansion is its own package (@morlay/dsh-reference).",
+  "version": "0.0.1-alpha.3",
+  "description": "Prompt-injection capability set for dsh: the single channel (context assembler) plus the injectors it carries — workspace instructions, skill catalog — plus the scope gate that narrows tools per session mode. Reference expansion is its own package (@morlay/dsh-reference).",
   "keywords": [
     "context",
     "dsh",
@@ -40,39 +40,39 @@
   "devDependencies": {
     "@deepseek-ai/cordis": "4.0.4",
     "@deepseek-ai/cordis-plugin-include": "1.0.9",
-    "@deepseek-ai/dsh-agent": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-agent-instructions": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-agent-loop": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-agent-loop-testkit": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-commands": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-compaction-basic": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-fs": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-llm": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-scope": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-session": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-session-persistence-jsonl": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-skill": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-skill-filesystem": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-system-prompt": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-token-meter": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-tool-skill": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-tools": "0.1.7-alpha.2",
-    "@morlay/session-rdb": "0.0.21-alpha.7",
+    "@deepseek-ai/dsh-agent": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-agent-instructions": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-agent-loop": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-agent-loop-testkit": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-commands": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-compaction-basic": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-fs": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-llm": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-scope": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-session": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-session-persistence-jsonl": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-skill": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-skill-filesystem": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-system-prompt": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-token-meter": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-tool-skill": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-tools": "0.1.7-rc.1",
+    "@morlay/session-rdb": "0.0.21-alpha.8",
     "@types/js-yaml": "^4.0.9",
     "@types/mdast": "^4.0.4",
     "js-yaml": "^4.1.0"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "4.0.4",
-    "@deepseek-ai/dsh-agent": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-agent-instructions": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-commands": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-fs": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-llm": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-session": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-skill": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-system-prompt": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-tools": "0.1.7-alpha.2"
+    "@deepseek-ai/dsh-agent": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-agent-instructions": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-commands": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-fs": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-llm": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-session": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-skill": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-system-prompt": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-tools": "0.1.7-rc.1"
   },
   "dsh": {
     "bundle": {

package/src/index.ts

@@ -2,12 +2,12 @@
  * 组装出口：按 config 把各能力装成一个 cordis 插件树。
  *
  * 装配面因此只有**一行**（`@morlay/dsh-context-assembler`）：`isolate` 是行级选项，一行声明就覆盖它整棵子树，
- * 而这里 `ctx.plugin()` 出来的子插件都继承行 ctx 的 isolate map 与 scope——通道服务仍在 preset 的
- * realm 里、`scope` 的归属判据仍按 preset scope 成立。**每个子插件各有自己的 `inject`**（合成单入口会
- * 让 inject 变并集，一个可选搭档缺席就拖垮整包），这是这层组装唯一必须守住的东西。
+ * 而这里 `ctx.plugin()` 出来的子插件都继承行 ctx 的 isolate map 与 scope——**通道服务由这一行装一次**。
+ * **每个子插件各有自己的 `inject`**（合成单入口会让 inject 变并集，一个可选搭档缺席就拖垮整包），这是这层
+ * 组装唯一必须守住的东西。
  *
- * `coding` 不带 config（完整一套）；`chat` 用 `capabilities` 裁掉不要的能力、用 `options` 给留下的
- * 那些传参（能力名就是子出口名）。
+ * 模式之间的差异（哪个模式要哪些能力、工具收到什么程度）不在这里用 config 裁：由
+ * `context-assembler-scope` 那一行把模式定义登记给通道（`options` 只用来给留下的能力传参，能力名就是子出口名）。
  */
 import type { Context } from "@deepseek-ai/cordis";
 import z from "@deepseek-ai/schemastery";

package/src/rows.ts

@@ -5,8 +5,9 @@
  * （`@morlay/dsh-agent-toolkit/guidance`，在别的包里）与 skill 目录这类消费者都在别的行上
  * `inject` 它，隔离会把它们挡在组外（行停在 waiting，不报错）。
  *
- * preset 只装 `scopeRow()`（模式的开关）：它 `inject` 通道，`ctx.get("contextAssembler")` 在 agent
- * 子树里可达，不需要另装一份通道。
+ * 本包自己的 bundle 只装通道（`PATCH_ROWS`）。模式的收口是另一行（`scopeRow()`），它由
+ * [`@morlay/dsh-session-mode`](../../../profile/dsh-session-mode/README.md) 的 patch 与模式定义一起装——
+ * 那一行的 config 就是模式清单。
  */
 
 /** 组装出口（包根）就是那个"按 config 装能力"的插件。 */
@@ -32,25 +33,25 @@ export function contextChannel(config?: Readonly<Record<string, unknown>>): Cont
 }
 
 /**
- * 模式开关那一行：`scope` 出口按 preset 配（工具白名单、instruction 总开关、动态快照开关）。
+ * 模式收口那一行：`scope` 出口按 `ctx.sessionModes` 的模式定义收口（工具白名单、instruction 总开关、
+ * 动态快照开关）。
  *
- * 通道在 profile 平面装一次，这一行只按模式收口（它 `inject` `contextAssembler`，
- * `ctx.get("contextAssembler")` 在 agent 子树里可达）。
+ * 行 id 用全名 `context-assembler-scope`：它的搭档是同一份装配里的 `context-assembler`（通道），两个 id 放在
+ * 一起才看得出这一行属于哪个包、做什么——`context-scope` 那种短名会被误当成 `ctx.contextScope` 之类的服务。
+ *
+ * 行本身**不带 config**：装哪些模式、每个模式收什么，都由 `session-mode` 行的 `config.modes` 决定，
+ * 这一行只把它落到会话上（`inject` `sessionModes`，由
+ * [`@morlay/dsh-session-mode`](../../../profile/dsh-session-mode/README.md) 的 patch 插一行）。
  */
-export function scopeRow(config?: Readonly<Record<string, unknown>>): {
-  readonly id: string;
-  readonly name: string;
-  readonly config?: Readonly<Record<string, unknown>>;
-} {
+export function scopeRow(): ContextRow {
   return {
-    id: "context-scope",
+    id: "context-assembler-scope",
     name: "@morlay/dsh-context-assembler/scope",
-    ...(config === undefined ? {} : { config }),
   };
 }
 
 /**
- * bundle patch 的行清单：通道一行（`scope` 是模式的开关，由 preset 装 `scopeRow()`）。
+ * bundle patch 的行清单：只有通道一行（模式收口那一行归 `session-mode` 的 patch 装）。
  *
  * 形态是 `insert`：这些行由本包提供给 host 平面。写成 `- id: x` 那种"改已有行"的形态时，装配期找不到
  * 目标行（只 warn 后跳过），通道根本没装上，引用它的行停在 waiting。

package/src/scope/index.ts

@@ -1,118 +1,150 @@
-import type { Context } from "@deepseek-ai/cordis";
+/**
+ * 按**会话**收口：工具白名单、instruction 总开关、动态快照。
+ *
+ * 这是本包的 `scope` 出口（行 id `context-assembler-scope`）。它不再吃 config，也不认识"模式"这个概念——
+ * 收口要什么由消费方在会话建立时**推**进来：`ctx.sessionToolScope.apply(agent, mode)`（
+ * [`@morlay/dsh-session-mode`](../../../profile/dsh-session-mode/README.md) 的模式定义里正好是这几项）。
+ * 方向因此是单向的：装配层读这个服务，这个包不认识装配层。
+ *
+ * `apply` 落到该 agent 身上的三件事，各走一条与"谁注册了这个工具"无关的路：
+ *
+ * 1. **装配期投影**（每次装配按已注册的那份）：模型目录与工具说明的 `tool:<工具名>` section 同源过滤；
+ * 2. **执行层 guard**：落在 `agent.ctx` 上，调用被拒时给出该模式的文案；
+ * 3. **通道开关**：`instructions` 关掉该会话的规则块（工作区指令、技能目录、用法正文）、
+ *    `runtimeContext` 抑制该会话的动态快照（沙箱与审批策略那两条）。
+ *
+ * 为什么不用 `tools.restrict()`：它会改动可见工具集，从而触发 `tools/change`；上游 `tool-subagent` 正是用
+ * 该事件做 composition reconcile——两边互相触发会变成装配风暴。这里用投影过滤加执行层 guard：既不碰注册
+ * 表、也不发事件。
+ *
+ * 为什么按 `agent.ctx` 注册而不是先建一棵 preset 子树：会话的 persona / 工具收口本来就是"这个 agent 的
+ * 事"，`agent.ctx` 的 scope 已经够了（上游给子 agent 装 persona 用的也是这条路）；一棵子树要连带上游的
+ * `agent-presets` 注册表、每 revision 一份 Loader 与 `isolate` realm，模式本身用不上。
+ *
+ * 模式在空白窗口里可以切换，所以状态是**可替换**的：同一个 agent 再 `apply` 一次就是换一份——旧的
+ * disposer 全部收回，再按新的装一遍。
+ */
+
+import { Service, type Context } from "@deepseek-ai/cordis";
 import type { Agent } from "@deepseek-ai/dsh-agent";
-import { scopeChainOf, scopeOf } from "@deepseek-ai/dsh-scope";
 import z from "@deepseek-ai/schemastery";
 import type {} from "../assembler/index.ts";
 
-export const name = "context-scope";
+export const name = "context-assembler-scope";
 
+/** 收口要的服务；`sessionToolScope` 由本行自己发布，`tools` 的 guard 挂在每个 agent 的 ctx 上。 */
 export const inject = ["tools", "systemPrompt"];
 
-export interface Config {
-  /**
-   * 只保留这些工具；其余（含 host 层 bundle 加进来的）既不进模型目录，调用不了，它们自己注册的说明
-   * section（`tool:<工具名>`）也不留在提示词里。
-   */
-  allowTools?: string[];
-  /**
-   * 是否要 instruction 类的注入（工作区指令、技能目录、用法正文那类规则块）。缺省要；
-   * `false` 表示这个模式不要任何 instructions——对话模式就是它。
-   *
-   * 关的是**规则块与降级 section**（通道的 `setInstructions`）；内容块（`auto` 组正文、引用材料）
-   * 不受这个开关管，要靠对应的注入方自己不注册（chat 同时给了 `groups: false`）。
-   * 注意这与工具白名单是两件事：工具没给，跟着它的注入本来就该自己关（见各注入包对 requires 的判断）；
-   * 这里是"连与工具无关的 instruction 也不要"的总开关。
-   */
-  instructions?: boolean;
-  /**
-   * 是否要 runtime context（动态快照：文件沙箱策略、审批策略）。缺省要；`false` 表示这个模式不要它们
-   * ——对话模式没有文件与 shell 工具，"能改工作区哪些文件、要不要走审批"对它全是噪音。
-   *
-   * 抑制是**按 scope** 的（上游按装配的 scope 链查抑制器），所以本行装在 preset 子树里就只作用于这个
-   * 模式的会话；它只挡注入，不改任何提供方的行为（沙箱该怎么判还怎么判）。
-   */
-  runtimeContext?: boolean;
+/** 本行不吃 config：要收成什么样由消费方在 `apply` 时给。 */
+export const Config = z.object({});
+
+/** 一次收口的全部输入：模式定义里本出口用到的那几项。 */
+export interface SessionToolScopeMode {
+  /** 拒绝对话时用的模式名。 */
+  readonly name: string;
+  /** 这个会话能用的工具；其余既不进目录，调用也被拒。 */
+  readonly allowTools: readonly string[];
+  /** 缺省为要；`false` 表示这个会话不要任何 instruction 类注入。 */
+  readonly instructions?: boolean | undefined;
+  /** 缺省为要；`false` 表示这个会话不要动态快照。 */
+  readonly runtimeContext?: boolean | undefined;
 }
 
-export const Config: z<Config> = z.object({
-  allowTools: z.array(z.string()).default([]),
-  instructions: z.boolean().default(true),
-  runtimeContext: z.boolean().default(true),
-});
+declare module "@deepseek-ai/cordis" {
+  interface Context {
+    sessionToolScope: SessionToolScope;
+  }
+}
 
-const OUT_OF_SCOPE = (toolName: string): string =>
-  `${toolName} 不在本模式的工具范围内，用它不会有结果；按当前模式提供的工具完成任务，或让用户切到别的模式。`;
+const OUT_OF_SCOPE = (toolName: string, modeName: string): string =>
+  `${toolName} 不在「${modeName}」的工具范围内，用它不会有结果；按当前模式提供的工具完成任务，或让用户切到别的模式。`;
 
 /** 单个工具的说明 section 名前缀：`tool:<工具名>`（`tools:` 那类是聚合块，不归白名单管）。 */
 const TOOL_SECTION_PREFIX = "tool:";
 
-/**
- * 把某个 preset 的工具收成"只有这些"。
- *
- * 为什么需要它：preset composition 只能决定"加什么"，管不了 host 层——`dsh.profile.bundles` 打开的
- * bundle（例如实验性的 Agent Teams）会在 host 层插工具行与 section，对所有 preset 一视同仁。模式想
- * 表达"我只有这几个工具、一条提示词都不要"时，唯一与来源无关的做法是收口"有什么"。
- *
- * 为什么不是 `tools.restrict()`：它会改动可见工具集，从而触发 `tools/change`；上游 `tool-subagent`
- * 正是用该事件做 composition reconcile——两边互相触发会变成装配风暴。这里用投影过滤加执行层 guard：
- * 既不碰注册表、也不发事件。
- */
-export function apply(ctx: Context, config: Config): void {
-  const allow = new Set(config.allowTools ?? []);
-  if (allow.size === 0) {
-    throw new Error(
-      "context-scope: `allowTools` must name at least one tool; omit the row instead of mounting an empty scope",
-    );
-  }
-  const presetKey = scopeOf(ctx);
-  const scoped = new WeakSet<Agent>();
+/** 一个 agent 当前装着的那一份。 */
+interface Applied {
+  readonly mode: SessionToolScopeMode;
+  /** 收回这一份在 `agent.ctx` 上的注册（抑制器与执行层 guard）。 */
+  readonly dispose: () => void;
+}
 
-  if (config.runtimeContext === false) {
-    // service 在 scoped ctx 上是 shadow：注册落在本行的 scope（preset 子树），抑制因此只覆盖这个模式。
-    ctx.systemPrompt.suppressRuntimeContext();
+/** 通道是可选的搭档：没有它就没有 instruction 可关、也没人收窄技能目录，工具目录与执行 guard 照常生效。 */
+function channelOf(ctx: Context):
+  | {
+      setInstructions(agent: Agent, on: boolean): void;
+      restrictTools(agent: Agent, allowed: (tool: string) => boolean): void;
+    }
+  | undefined {
+  try {
+    return ctx.get("contextAssembler");
+  } catch {
+    return undefined;
   }
+}
 
-  const belongs = (agent: Agent): boolean => {
-    if (presetKey === undefined) return true;
-    const key = scopeOf(agent.ctx);
-    return key !== undefined && scopeChainOf(key).includes(presetKey);
-  };
-
-  /** 每个会话只做一次：拨提示词开关，并挂上执行层白名单。 */
-  const scopeOnce = (agent: Agent): void => {
-    if (scoped.has(agent) || !belongs(agent)) return;
-    scoped.add(agent);
-    // 通道是可选的（`ctx.get` 在未声明 inject 的 ctx 上会抛，所以自己兜住）：没有它就没有 instruction
-    // 可关、也没人收窄技能目录，但工具目录与执行 guard 照常生效——不该因为一个可选搭档缺席就让整个插件
-    // 不激活。工具收窄必须交给它：投影层的过滤不碰注册表，注册表上看不出"谁能用"。
-    try {
-      const channel = ctx.get("contextAssembler");
-      if (config.instructions === false) channel?.setInstructions(agent, false);
-      channel?.restrictTools(agent, (tool) => allow.has(tool));
-    } catch {
-      void 0;
-    }
-    // inject 回调只是在该 ctx 上解锁 `tools`；调用必须落在 `agent.ctx` 上才是这个会话的作用域。
-    agent.ctx.inject(["tools"], () => {
-      agent.ctx.tools.guard((exec) => (allow.has(exec.name) ? undefined : OUT_OF_SCOPE(exec.name)));
+/** 按会话收口工具与注入的服务。 */
+export class SessionToolScope extends Service {
+  private readonly applied = new WeakMap<Agent, Applied>();
+
+  constructor(ctx: Context) {
+    super(ctx, "sessionToolScope");
+    // 装配期过滤：这里只认已经 `apply` 过的会话；没登记过的（没装 session-mode 的部署）一律放行。
+    ctx.on("system-prompt/assemble", async (_assembly, context, next) => {
+      const agent = context.agent;
+      const applied = agent === undefined ? undefined : this.applied.get(agent);
+      if (applied === undefined) return next();
+      const allow = new Set(applied.mode.allowTools);
+      const result = await next();
+      return {
+        ...result,
+        // 工具自己的说明 section 与工具目录同源：目录里没有的工具，它的说明也不该留在提示词里。
+        sections: result.sections.filter((section) =>
+          section.name.startsWith(TOOL_SECTION_PREFIX)
+            ? allow.has(section.name.slice(TOOL_SECTION_PREFIX.length))
+            : true,
+        ),
+        tools: result.tools.filter((tool) => allow.has(tool.name)),
+      };
     });
-  };
-
-  // 在**装配期**注册，不在创建期：创建期 tools 的可用性还在变，那时注册容易与装配流程互相牵扯
-  // （`tools/change` 的回响就是这么来的）。目录过滤也在这里，每步幂等。
-  ctx.on("system-prompt/assemble", async (_assembly, context, next) => {
-    const agent = context.agent;
-    if (agent !== undefined) scopeOnce(agent);
-    const result = await next();
-    return {
-      ...result,
-      // 工具自己的说明 section 与工具目录同源：目录里没有的工具，它的说明也不该留在提示词里。
-      sections: result.sections.filter((section) =>
-        section.name.startsWith(TOOL_SECTION_PREFIX)
-          ? allow.has(section.name.slice(TOOL_SECTION_PREFIX.length))
-          : true,
-      ),
-      tools: result.tools.filter((tool) => allow.has(tool.name)),
-    };
-  });
+  }
+
+  /**
+   * 把某个会话收口到这份定义上（同一个 agent 再调就是换一份）。
+   * @param agent - 目标会话的 agent。
+   * @param mode - 收口的全部输入。
+   */
+  apply(agent: Agent, mode: SessionToolScopeMode): void {
+    const previous = this.applied.get(agent);
+    if (previous !== undefined) previous.dispose();
+    const allow = new Set(mode.allowTools);
+
+    // 落在 `agent.ctx` 上的那两件用一个 effect 装：抑制器是 scope 层的一次注册；执行层 guard 要等
+    // `tools` 激活才装得上（`inject` 的回调），它挂在那个 inject fiber 下，所以收回时连 fiber 一起收。
+    const dispose = agent.ctx.effect(() => {
+      const stoppers: (() => void)[] = [];
+      if (mode.runtimeContext === false) {
+        // service 在 `agent.ctx` 上是 shadow：抑制落在该 agent 的 scope 层，只覆盖这个会话。
+        stoppers.push(agent.ctx.systemPrompt.suppressRuntimeContext());
+      }
+      // 必须落在 `agent.ctx` 上才是这个会话的作用域。
+      const fiber = agent.ctx.inject(["tools"], (scope) => {
+        scope.tools.guard((exec) =>
+          allow.has(exec.name) ? undefined : OUT_OF_SCOPE(exec.name, mode.name),
+        );
+      });
+      return [...stoppers, () => fiber.dispose()];
+    }, "sessionToolScope: per-session gate");
+
+    // 与"谁注册了这个工具"无关的那两件：通道按 agent 覆盖，不需要收回。
+    const channel = channelOf(this.ctx);
+    channel?.setInstructions(agent, mode.instructions !== false);
+    channel?.restrictTools(agent, (tool) => allow.has(tool));
+
+    this.applied.set(agent, { mode, dispose });
+  }
+}
+
+export function apply(ctx: Context): void {
+  new SessionToolScope(ctx);
 }

package/dist/scope-CI-fNq5A.mjs

@@ -1,104 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import z from "@deepseek-ai/schemastery";
-import "@deepseek-ai/cordis";
-//#region ../../../vendor/deepseek-harness/packages/core/scope/lib/index.js
-/**
-* Scoped-context primitive: mint a Cordis context that tags registrations with
-* an opaque identity and build routing-only event carriers for that identity.
-*
-* @module @deepseek-ai/dsh-scope
-*/
-/** Context tag written by {@link createScope}. */
-const kScope = Symbol("dsh.scope");
-/**
-* The enclosing scope of each key. One relation powers both directions of
-* scope nesting: registration views inherit DOWN the chain (a child scope
-* sees its ancestors' layers — {@link ScopedLayers}), and event admission
-* extends UP it (a listener tagged with an ancestor receives events dispatched
-* to a descendant key — {@link scopeTarget}).
-*/
-const scopeParents = /* @__PURE__ */ new WeakMap();
-/**
-* The chain from a key to its root ancestor.
-* @param key - the starting key, or `undefined` for the empty chain.
-* @returns keys nearest-first: `[key, parent, grandparent, …]`.
-*/
-function scopeChainOf(key) {
-	const chain = [];
-	for (let cursor = key; cursor !== void 0; cursor = scopeParents.get(cursor)) chain.push(cursor);
-	return chain;
-}
-/**
-* Read the nearest scope tag inherited by a context.
-* @param ctx - context to inspect.
-* @returns its scope key, or `undefined` for an unscoped context.
-*/
-function scopeOf(ctx) {
-	return ctx[kScope];
-}
-//#endregion
-//#region src/scope/index.ts
-var scope_exports = /* @__PURE__ */ __exportAll({
-	Config: () => Config,
-	apply: () => apply,
-	inject: () => inject,
-	name: () => name
-});
-const name = "context-scope";
-const inject = ["tools", "systemPrompt"];
-const Config = z.object({
-	allowTools: z.array(z.string()).default([]),
-	instructions: z.boolean().default(true),
-	runtimeContext: z.boolean().default(true)
-});
-const OUT_OF_SCOPE = (toolName) => `${toolName} 不在本模式的工具范围内，用它不会有结果；按当前模式提供的工具完成任务，或让用户切到别的模式。`;
-/** 单个工具的说明 section 名前缀：`tool:<工具名>`（`tools:` 那类是聚合块，不归白名单管）。 */
-const TOOL_SECTION_PREFIX = "tool:";
-/**
-* 把某个 preset 的工具收成"只有这些"。
-*
-* 为什么需要它：preset composition 只能决定"加什么"，管不了 host 层——`dsh.profile.bundles` 打开的
-* bundle（例如实验性的 Agent Teams）会在 host 层插工具行与 section，对所有 preset 一视同仁。模式想
-* 表达"我只有这几个工具、一条提示词都不要"时，唯一与来源无关的做法是收口"有什么"。
-*
-* 为什么不是 `tools.restrict()`：它会改动可见工具集，从而触发 `tools/change`；上游 `tool-subagent`
-* 正是用该事件做 composition reconcile——两边互相触发会变成装配风暴。这里用投影过滤加执行层 guard：
-* 既不碰注册表、也不发事件。
-*/
-function apply(ctx, config) {
-	const allow = new Set(config.allowTools ?? []);
-	if (allow.size === 0) throw new Error("context-scope: `allowTools` must name at least one tool; omit the row instead of mounting an empty scope");
-	const presetKey = scopeOf(ctx);
-	const scoped = /* @__PURE__ */ new WeakSet();
-	if (config.runtimeContext === false) ctx.systemPrompt.suppressRuntimeContext();
-	const belongs = (agent) => {
-		if (presetKey === void 0) return true;
-		const key = scopeOf(agent.ctx);
-		return key !== void 0 && scopeChainOf(key).includes(presetKey);
-	};
-	/** 每个会话只做一次：拨提示词开关，并挂上执行层白名单。 */
-	const scopeOnce = (agent) => {
-		if (scoped.has(agent) || !belongs(agent)) return;
-		scoped.add(agent);
-		try {
-			const channel = ctx.get("contextAssembler");
-			if (config.instructions === false) channel?.setInstructions(agent, false);
-			channel?.restrictTools(agent, (tool) => allow.has(tool));
-		} catch {}
-		agent.ctx.inject(["tools"], () => {
-			agent.ctx.tools.guard((exec) => allow.has(exec.name) ? void 0 : OUT_OF_SCOPE(exec.name));
-		});
-	};
-	ctx.on("system-prompt/assemble", async (_assembly, context, next) => {
-		const agent = context.agent;
-		if (agent !== void 0) scopeOnce(agent);
-		const result = await next();
-		return {
-			...result,
-			sections: result.sections.filter((section) => section.name.startsWith(TOOL_SECTION_PREFIX) ? allow.has(section.name.slice(5)) : true),
-			tools: result.tools.filter((tool) => allow.has(tool.name))
-		};
-	});
-}
-//#endregion
-export { scope_exports as a, name as i, apply as n, inject as r, Config as t };