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

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/dist/skill-catalog.d.mts

@@ -10,6 +10,13 @@ declare const CATALOG_ID = "skill-catalog";
  *
  * 目录只列模型可调用的 skill；`auto` 的 skill 标 `modelInvocable: false`，所以它不出现在目录里
  * （它的正文已经随提示送达）。工具的渲染用通道的虚拟 skill 形态，不带 `<skill_resources>`。
+ *
+ * **这一面归通道**（工作区指令那一面相反，是让位给 preset）：官方 preset 自己装了上游 `tool-skill`，那份
+ * 注册在 preset 的 scope 层；我们把 `skill` 工具按会话注册进 **agent 自己那一层**——它最靠里，同名注册遮蔽
+ * 继承来的那一份（[`core/tools/src/index.ts:1185-1207`](../../../vendor/deepseek-harness/packages/core/tools/src/index.ts)），
+ * 于是模型看到的是我们的工具（中文描述 + 按会话修剪的正文）。上游的目录发布判据是"它自己注册的那个工具是
+ * 本会话可见的那个"（[`skill/tool-skill/src/index.ts:213-236`](../../../vendor/deepseek-harness/packages/skill/tool-skill/src/index.ts)），
+ * 被遮蔽之后它闭嘴，目录由我们发布；`minimal`（`chat`）那种没有上游行的会话里也只有我们这一份。
  */
 declare function apply(ctx: Context): void;
 //#endregion

package/dist/skill-catalog.mjs

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { u as renderVirtualSkill } from "./assembler-_F9urbPj.mjs";
+import { u as renderVirtualSkill } from "./assembler-CDMIBAi8.mjs";
 import { isModelInvocable, isSkillName } from "@deepseek-ai/dsh-skill";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 //#region src/skill-catalog/index.ts
@@ -11,6 +11,7 @@ var skill_catalog_exports = /* @__PURE__ */ __exportAll({
 });
 const name = "context-skill-catalog";
 const inject = [
+	"agents",
 	"skills",
 	"tools",
 	"contextAssembler"
@@ -23,6 +24,13 @@ const DESCRIPTION_MAX_LENGTH = 500;
 *
 * 目录只列模型可调用的 skill；`auto` 的 skill 标 `modelInvocable: false`，所以它不出现在目录里
 * （它的正文已经随提示送达）。工具的渲染用通道的虚拟 skill 形态，不带 `<skill_resources>`。
+*
+* **这一面归通道**（工作区指令那一面相反，是让位给 preset）：官方 preset 自己装了上游 `tool-skill`，那份
+* 注册在 preset 的 scope 层；我们把 `skill` 工具按会话注册进 **agent 自己那一层**——它最靠里，同名注册遮蔽
+* 继承来的那一份（[`core/tools/src/index.ts:1185-1207`](../../../vendor/deepseek-harness/packages/core/tools/src/index.ts)），
+* 于是模型看到的是我们的工具（中文描述 + 按会话修剪的正文）。上游的目录发布判据是"它自己注册的那个工具是
+* 本会话可见的那个"（[`skill/tool-skill/src/index.ts:213-236`](../../../vendor/deepseek-harness/packages/skill/tool-skill/src/index.ts)），
+* 被遮蔽之后它闭嘴，目录由我们发布；`minimal`（`chat`）那种没有上游行的会话里也只有我们这一份。
 */
 function apply(ctx) {
 	/**
@@ -30,10 +38,26 @@ function apply(ctx) {
 	* （`collect` 里先算正文再取 source）。
 	*/
 	const catalogEntries = /* @__PURE__ */ new WeakMap();
+	const skillTool = ctx.tools.get("skill") === void 0 ? defineSkillTool(ctx) : void 0;
+	if (skillTool === void 0) ctx.logger.warn("context-skill-catalog: a `skill` tool is already registered; keeping the existing one and only publishing the catalog");
+	else {
+		const install = (agent) => {
+			if (ctx.tools.get("skill", agent) === skillTool) return;
+			try {
+				agent.ctx.tools.register(skillTool);
+			} catch (error) {
+				ctx.logger.warn(`context-skill-catalog: ${String(error)}`);
+			}
+		};
+		ctx.on("agent/created", ({ agent }) => {
+			install(agent);
+		});
+		for (const agent of ctx.agents.list()) install(agent);
+	}
 	ctx.contextAssembler.registerRule({
 		id: CATALOG_ID,
 		source: (agent) => ({
-			kind: "skill-catalog",
+			kind: "context-assembler",
 			form: "catalog",
 			entries: catalogEntries.get(agent) ?? []
 		}),
@@ -66,11 +90,10 @@ function apply(ctx) {
 			].join("\n");
 		}
 	});
-	if (ctx.tools.get("skill") !== void 0) ctx.logger.warn("context-skill-catalog: a `skill` tool is already registered; keeping the existing one and only publishing the catalog");
-	else registerSkillTool(ctx);
 }
-function registerSkillTool(ctx) {
-	const skillTool = defineTool({
+/** 一份工具定义，按会话注册进每个 agent 的自己那一层（同一个定义对象，判据里的同一性靠它）。 */
+function defineSkillTool(ctx) {
+	return defineTool({
 		name: "skill",
 		description: "按需加载 skill 的完整说明。",
 		parameters: { name: {
@@ -175,7 +198,6 @@ function registerSkillTool(ctx) {
 			};
 		}
 	});
-	ctx.tools.register(skillTool);
 }
 function clamp(text, max) {
 	return text.length <= max ? text : `${text.slice(0, max - 1)}…`;

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.4",
+  "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",
@@ -19,65 +19,63 @@
     "dist",
     "src",
     "tool",
-    "cordis.patch.yml",
     "!**/__tests__"
   ],
   "type": "module",
   "exports": {
     ".": "./dist/index.mjs",
+    "./rows": "./dist/rows.mjs",
     "./assembler": "./dist/assembler.mjs",
     "./agent-instructions": "./dist/agent-instructions.mjs",
     "./skill-catalog": "./dist/skill-catalog.mjs",
     "./scope": "./dist/scope.mjs",
     "./package.json": "./package.json",
-    "./rows": "./dist/rows.mjs",
-    "./cordis.patch.yml": "./cordis.patch.yml",
     "./locale/*.json": "./locale/*.json"
   },
   "dependencies": {
-    "@deepseek-ai/schemastery": "3.18.4"
+    "@deepseek-ai/schemastery": "^3.18.4"
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "4.0.4",
+    "@deepseek-ai/cordis-plugin-group": "1.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/cordis-plugin-loader": "1.0.5",
+    "@deepseek-ai/dsh-agent": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-agent-instructions": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-agent-loop": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-agent-loop-testkit": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-agent-preset-registry": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-commands": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-compaction-basic": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-fs": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-fs-local": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-llm": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-scope": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-session": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-session-persistence-jsonl": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-skill": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-skill-filesystem": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-token-meter": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-tool-skill": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-tools": "0.1.7-rc.2",
+    "@morlay/session-rdb": "0.0.21-alpha.9",
     "@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"
-  },
-  "dsh": {
-    "bundle": {
-      "patch": "./cordis.patch.yml"
-    }
+    "@deepseek-ai/cordis": "^4.0.4",
+    "@deepseek-ai/dsh-agent": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-agent-instructions": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-agent-preset-registry": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-commands": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-fs": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-session": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-skill": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-tools": "^0.1.7-rc.2"
   },
   "scripts": {
     "build": "pnpm exec tsdown"

package/src/agent-instructions/index.ts

@@ -7,6 +7,7 @@ import z from "@deepseek-ai/schemastery";
 import type {} from "../assembler/index.ts";
 import { instructionChain, readInstruction, type InstructionFile } from "./files.ts";
 import { baselineIdentity } from "./baseline.ts";
+import { presetOwnsInstructions } from "./preset-owner.ts";
 
 export const name = "context-agent-instructions";
 
@@ -59,7 +60,7 @@ export function apply(ctx: Context, config: Config): void {
     for (const file of chain.files) {
       ctx.contextAssembler.registerRule({
         id: `agent-instructions:${rootTag(file.root)}:${file.display}`,
-        // 对外身份沿用上游那两样：kind 让客户端标签与按 kind 认领的消费方（上游的实验性约束收集）认得这是
+        // 对外身份沿用上游那两样（skill 面相反，用我们自己的 kind）：kind 让客户端标签与按 kind 认领的消费方认得这是
         // 工作区指令；`baseline` 与 `baselineIdentity` 让上游的认领判据（kind + baseline===true + 身份相等）
         // 认这份条目就是基线，于是它不再注入自己那条模板。`changes` 留空——上游那套按文件做 reconciliation
         // 的记录我们不做（一条文件一条 id）。
@@ -70,7 +71,10 @@ export function apply(ctx: Context, config: Config): void {
           baselineIdentity: identity,
           changes: [],
         }),
-        text: (target) => {
+        text: async (target) => {
+          // 这个会话的 preset 自己装了这一面（官方 `standard` / `ptc` / `cordis` 都装了上游那行）就让位：
+          // 同一份工作区指令只从一处到模型（见 [`preset-owner.ts`](./preset-owner.ts)）。
+          if (await presetOwnsInstructions(ctx, target)) return "";
           const current = chains.get(target);
           if (current === undefined || !current.files.some((entry) => entry.path === file.path))
             return "";

package/src/agent-instructions/preset-owner.ts

@@ -0,0 +1,70 @@
+/**
+ * 「这个会话的 preset 行清单里装了上游 `agent-instructions` 吗」——装了就让位，这一面归 preset。
+ *
+ * 为什么要有这条判据：官方 web-app 把 `agent-instructions` 从 host 平面设成 `disabled`、交给 preset 的行清单
+ * （[`web-app/cordis.patch.yml:546`](../../../vendor/deepseek-harness/packages/bundle/web-app/cordis.patch.yml) 与
+ * `presets/*.patch.yml`）。本部署保留官方 preset 整套，于是**同一个会话**里 preset 平面的上游行与 host 平面的
+ * 我们都会注入：一步里两条 AGENTS.md，而模型无法把后一条理解成"作废前一条"（两条的幂等键不同）。
+ *
+ * 方向：**我们让位**，不是上游认领我们。上游 `agent-instructions` 的认领判据只看它**看得见**的东西
+ * （本步 claimed 的消息 + 会话 surface：
+ * [`agent-instructions/src/index.ts:46-63`](../../../vendor/deepseek-harness/packages/context/agent-instructions/src/index.ts)），
+ * 第 1 步两侧都在各自算注入，谁也算不出对方那一条，所以"由上游认领"救不了首步的重复
+ * （`baselineIdentity` 那份身份管的是另一件事，见 [`baseline.ts`](./baseline.ts)）。
+ *
+ * 判据取**行清单里的模块名**而不是行 id：行 id 在 preset 的 `config.plugins` 里是自由的，模块名才是"哪一面的
+ * 提供者"。`enabled === true` 表示这一行在这个代际真的装着；`'conditional'`（`!!js` 读不出）按"没装"处理——
+ * 读不出就不敢让位，宁可我们提供。
+ */
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+// 只用它的类型：`ctx.agentPresets` 的形状来自上游注册表的声明合并，装不上时这里读到 undefined。
+import type {} from "@deepseek-ai/dsh-agent-preset-registry";
+
+/** 上游那一行的模块名：与 `presets/*.patch.yml` 里写的一字不差。 */
+const UPSTREAM_MODULE = "@deepseek-ai/dsh-agent-instructions";
+
+/** 会话 → 它当前的 preset。preset 变了（空白窗口里换 preset）就整份重算。 */
+const decided = new WeakMap<Agent, { preset: string; owns: Promise<boolean> }>();
+
+/**
+ * 该会话的 preset 自己提供了工作区指令这一面吗。
+ * @param ctx - 能解析到注册表的上下文（能力自己的 apply ctx）。
+ * @param agent - 要判的会话。
+ * @returns 行清单里有上游那一行且它是启用的。
+ */
+export function presetOwnsInstructions(ctx: Context, agent: Agent): Promise<boolean> {
+  const registry = registryOf(ctx);
+  if (registry === undefined) return Promise.resolve(false);
+  const preset = registry.composedPreset(agent.ctx);
+  // 没挂 preset（子代理还没 join、没装注册表的部署、测试里的假 standing scope）：这一面归我们。
+  if (preset === undefined) return Promise.resolve(false);
+
+  const cached = decided.get(agent);
+  if (cached?.preset === preset) return cached.owns;
+
+  const owns = registry
+    .compositionInventory()
+    .then((inventory) =>
+      inventory.some(
+        (composition) =>
+          composition.id === preset &&
+          composition.rows.some(
+            (row) => row.moduleName === UPSTREAM_MODULE && row.enabled === true,
+          ),
+      ),
+    )
+    // 读不出来就当我们提供：缺内容比重复更糟，而"读不出来"只可能来自坏掉的注册表。
+    .catch(() => false);
+  decided.set(agent, { preset, owns });
+  return owns;
+}
+
+/** 注册表可能压根没装（没有 preset 的部署形态）；`ctx.get` 在不提供时读到 undefined。 */
+function registryOf(ctx: Context): Context["agentPresets"] | undefined {
+  try {
+    return ctx.get("agentPresets") as Context["agentPresets"] | undefined;
+  } catch {
+    return undefined;
+  }
+}

package/src/assembler/channel.ts

@@ -52,7 +52,7 @@ export interface PromptRuleDeclaration {
   readonly id: string;
   readonly text: (agent: Agent) => string | Promise<string>;
   /**
-   * 这条规则的对外身份。接管上游那两面（工作区指令 / skill 目录）按上游 kind 发消息，好让按 kind 认领的
+   * 这条规则的对外身份。工作区指令那一面按上游 kind 发消息（skill 面相反，用我们自己的 kind），好让按 kind 认领的
    * 消费方（客户端标签、上游的实验性约束收集）认得出来；不声明就是通道自己的 `context-assembler`。
    * 幂等键仍是 `id`（`reminderMessage` 会把它塞进 source）。
    */
@@ -81,7 +81,10 @@ export class ContextAssembler extends Service {
   private readonly suppressed = new Set<string>();
   private readonly skills = new Map<string, RegisteredSkill>();
   private readonly states = new WeakMap<Agent, AgentState>();
-  /** 不要 instruction 类注入（规则块）的会话；内容块（技能正文、引用材料）不受它管。 */
+  /**
+   * 不要 instruction 类注入的会话（模式说了 `instructions: false`）：常驻正文、规则块与降级 section 都不进。
+   * 按需 skill 不受它管（那是模型自己加载），引用材料也不经通道。
+   */
   private readonly withoutInstructions = new WeakSet<Agent>();
 
   /** 本会话的模式收窄（白名单）：投影层的过滤不碰注册表，注册表上看不出"谁能用"。 */
@@ -137,7 +140,7 @@ export class ContextAssembler extends Service {
    * 本步要注入的条目：键 → 已渲染好的正文（规则块或内容块）。
    * `sections` 来自本步装配，`rules` 与 `auto` skill 正文在这里现算。
    */
-  /** 这个会话不要 instruction 类的规则块（模式说了 `instructions: false`）。 */
+  /** 这个会话要不要 instruction 类注入（模式说了 `instructions: false` 就是不要，见 {@link withoutInstructions}）。 */
   setInstructions(agent: Agent, on: boolean): void {
     if (on) this.withoutInstructions.delete(agent);
     else this.withoutInstructions.add(agent);
@@ -184,16 +187,37 @@ export class ContextAssembler extends Service {
     return this.declarations.get(name)?.content(agent);
   }
 
+  /** 一个 skill 在这个会话能不能被用到：声明了 `requires` 时至少一个工具在模式收窄内。 */
+  private reachable(
+    declaration: PromptSkillDeclaration,
+    scope: ((tool: string) => boolean) | undefined,
+  ): boolean {
+    const requires = declaration.requires;
+    if (requires === undefined || requires.length === 0) return true;
+    // 没有收窄（没装模式的部署）就是全可见。
+    if (scope === undefined) return true;
+    return requires.some((tool) => scope(tool));
+  }
+
   async collect(agent: Agent): Promise<Map<string, PromptEntry>> {
     const entries = new Map<string, PromptEntry>();
-    for (const declaration of this.declarations.values()) {
-      if ((declaration.injection ?? "on-demand") !== "auto") continue;
-      const body = declaration.content(agent);
-      // 常驻送达的 skill 正文与按需加载同一形态：内容块，不是规则块。
-      if (body.length > 0)
-        entries.set(declaration.name, { text: renderVirtualSkill(declaration.name, body) });
-    }
+    const scope = this.toolScopes.get(agent);
+    // 这一档开关管**一切 instruction 类送达**：常驻正文（内容块）、规则块、降级 section。按需 skill 照常注册
+    // （模型自己调 `skill` 才拿到正文，那已不是"注入"）；用户手打 `@` 引用带进来的材料走
+    // `@morlay/dsh-reference` 的 pre-step，不经这里。
     const instructionsOff = this.withoutInstructions.has(agent);
+    if (!instructionsOff) {
+      for (const declaration of this.declarations.values()) {
+        if ((declaration.injection ?? "on-demand") !== "auto") continue;
+        // 常驻正文也跟随工具可见性：它声明的 `requires` 工具在这个会话一个都不可用，正文就不该注入
+        // （与 skill 目录那侧的 `hiddenSkills` 同一判据；通道不碰 tools 注册表，只用模式收窄那一份）。
+        if (!this.reachable(declaration, scope)) continue;
+        const body = declaration.content(agent);
+        // 常驻送达的 skill 正文与按需加载同一形态：内容块，不是规则块。
+        if (body.length > 0)
+          entries.set(declaration.name, { text: renderVirtualSkill(declaration.name, body) });
+      }
+    }
     for (const declaration of this.rules.values()) {
       if (instructionsOff) break;
       // 注入路径不能被任何一个内容提供者拖死：文本是异步算的（技能目录要读注册表、工作区指令要读文件），

package/src/assembler/reminder.ts

@@ -14,7 +14,16 @@ export const RULES_SECTION = "assembler:rules";
 /** 通道自己的条目形态（注入方没声明 source 时的默认）：规则块，幂等键是 id。 */
 export interface PromptReminderSource {
   kind: "context-assembler";
-  form: "instructions";
+  /**
+   * 条目形态：`instructions` 是规则块；`catalog` 是"带清单的目录"（客户端按 `entries` 列条目，
+   * 而不是读正文）。
+   */
+  form: "instructions" | "catalog";
+  /**
+   * `catalog` 形态发布的那份清单。**只有我们自己发布的目录**用它：上游 `tool-skill` 的账本扫法
+   * 只认它自己的 `kind`，所以这里的 kind 必须是我们自己的（见 [`skill-catalog`](../skill-catalog/index.ts)）。
+   */
+  entries?: readonly { readonly name: string; readonly description: string }[];
   /** 条目 id：同 id 的最新一条取代更早的同 id 条目。本插件早先落库的消息没有它。 */
   id?: string;
 }
@@ -27,7 +36,7 @@ declare module "@deepseek-ai/dsh-llm" {
 
 /**
  * 这条消息是不是通道注入的条目——判据是 source 里的幂等键，而不是 kind：接管上游那两面的条目
- * 用上游 kind（`agent-instructions` / `skill-catalog`），幂等必须照样认。
+ * 接管工作区指令那一面的条目用上游 kind（`agent-instructions`），幂等必须照样认。
  */
 export function promptEntryIdOf(source: MessageSource): string | undefined {
   const id = (source as { readonly id?: unknown }).id;
@@ -79,7 +88,7 @@ export function latestReminderText(agent: Agent, id: string): string | undefined
 
 /**
  * 注入一条提醒：`text` 是已渲染好的完整正文（规则块或内容块），`key` 是它的幂等键。
- * `source` 声明这条消息对外的身份——接管上游那两面用上游 kind，我们自己的条目留默认。
+ * `source` 声明这条消息对外的身份——工作区指令那一面用上游 kind，我们自己的条目留默认。
  */
 export function reminderMessage(key: string, text: string, source?: MessageSource): UserMessage {
   return createUserMessage({

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。