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

package/README.md

@@ -26,12 +26,16 @@
 ——它是模式那一层的收口行，由 [`@morlay/dsh-session-mode`](../../profile/dsh-session-mode/README.md) 的 patch 与模式定义
 一起装（行 id 与 name 归本包的 `scopeRow()`，单一 home）。
 
+装一次不等于每次都注入：这两条面各自按**会话**判归谁——`agent-instructions` 在预设自带那一行时**让位**，
+`skill-catalog` 反过来把同名工具注册进 agent 自己那一层**抢面**（见下面两节）。所以 `capabilities` 不在装配期
+按模式裁。
+
 工具说明（汉化 / 精简 / 用法分组）也不在这里：它归
 [`@morlay/dsh-agent-toolkit`](../../profile/dsh-agent-toolkit/README.md)，同样在 profile 平面装一次。
 
 ## 装配形态
 
-本包是 bundle：`cordis.patch.yml` 由 [`tool/patch.ts`](./tool/patch.ts) 从 [`src/rows.ts`](./src/rows.ts) 渲染，
+本包是 bundle：`cordis.patch.yml` 由 [`src/rows.ts`](./src/rows.ts) 从 [`src/rows.ts`](./src/rows.ts) 渲染，
 `rows` 出口导出同一份清单。`dsh.profile.bundles` 列出本包即装一次，**服务全局共享、不隔离**；模式的收口是
 另一行（`scopeRow()`：工具白名单 / instruction / 动态快照），别的包的行（工具说明、skill 目录）直接 `inject`
 同一份通道。
@@ -47,7 +51,7 @@
 全局通道）。本包只做上下文重排。
 
 引用展开不住在这里：它不依赖 `ctx.contextAssembler`（`inject` 只有 `skills`），也没有「读文件 + 字节预算」
-以外与组装出口共享的东西，所以独立成包、由 [`@morlay/better-session`](../../session/better-session/cordis.patch.yml)
+以外与组装出口共享的东西，所以独立成包、由 [`@morlay/better-session`](../../bundles/better-session/cordis.patch.yml)
 装配（见 [ADR-引用展开拆成独立包](../../../.agents/adrs/20260923-引用展开拆成独立包并按profile装配.md)）。
 
 **每个出口仍是独立的 cordis 插件**（各自的 `apply` 与 `inject`）——这一点是硬要求：合成单入口会让 `inject`
@@ -79,23 +83,42 @@ user 消息注入（每条按文本幂等，只有变化的那条重发）。
 `$DSH_HOME/AGENTS.md` 加项目根到 cwd 的逐级 `AGENTS.md` / `AGENTS.local.md`，**一条文件一条 id**
 （`agent-instructions:<根标识>:<文件>`，根标识是根目录的 8 位摘要——同进程两个项目根的同名文件因此不会互相
 顶掉），文件变化时只重发变了的那一份。取代上游 `@deepseek-ai/dsh-agent-instructions`（host 那行由上游
-web-app bundle 自己设在装配层；我们那份由本包的组装出口在 profile 平面装）。
+web-app bundle 自己设在装配层；我们那份由本包的组装出口在 profile 平面装）——**在该会话的 preset 行清单没有
+上游那一行时**。
 
+- **preset 自带那一行时让位**：官方 `standard` / `ptc` / `cordis` 的 preset 行清单里有
+  `@deepseek-ai/dsh-agent-instructions`（`minimal` 没有），装上的会话由 preset 侧注入，这一条一条都不注入；
+  `chat` 挂的 `minimal` 会话仍由我们提供。判据与理由见
+  [ADR-工作区指令让位skill面由通道抢面](./.agents/adrs/20260929-工作区指令让位skill面由通道抢面.md)。
 - **不跟踪 `read`/`write`/`edit`**：上游靠 touch 上浮触发刷新；本部署的 `AGENTS.md` 几乎不变，按
   `mtime:size` 对账足够。
 - **超预算可见**：单文件超过 `maxBytes` 时截断并留一行提示，不静默丢内容。
 - **与上游的 baseline 认领对齐**：`source` 带 `kind: "agent-instructions"` + `baseline: true` +
-  `baselineIdentity`（身份与上游 `workspaceBaselineIdentity` 逐字相等）。少了后两样会出一个只在真会话里
-  看得见的毛病：**同会话切到另一套装配后出现两条 AGENTS.md**——上游认为基线不存在，再注入一条自己的模板
-  （"Use them as guidance…"），两条口径矛盾且模型无法理解为覆盖。
+  `baselineIdentity`（身份与上游 `workspaceBaselineIdentity` 逐字相等）。上游的认领判据只看本步 claimed 的
+  消息与会话 surface，所以它救不了首步两侧同时注入（那由让位管），但管得住另一件事：**我们注入过基线的历史
+  会话在 preset 会话里恢复时**，上游认得出那条、不再补一份自己的模板（"Use them as guidance…"）。
 - 配置：`instructionFileCandidates` / `localInstructionFileCandidates`（覆盖成只读 `AGENTS*`，不含 CLAUDE
   系列）、`maxBytes`（65536）、`dshHome`。
 
 ## skill-catalog
 
 `skill-catalog` 规则块（`<available_skills>`，一行 `名字: 摘要`，只列模型可调用的 skill）加模型侧 `skill`
-工具。取代上游 `@deepseek-ai/dsh-tool-skill`（`skill-filesystem` 保留——它提供 skill 发现）。目录变更走
-同 id 覆盖；`auto` 的 skill 不进目录（正文已随提示送达）。
+工具。取代上游 `@deepseek-ai/dsh-tool-skill`（`skill-filesystem` 保留——它提供 skill 发现）。目录变更走同 id
+覆盖；`auto` 的 skill 不进目录（正文已随提示送达）。
+
+**这一面归通道**（工作区指令那一面相反，是让位）：`skill` 工具按**会话**注册进 agent 自己那一层，最近的一层
+赢，遮蔽 preset 那份；上游的目录发布判据是"它自己注册的那个工具是本会话可见的那个"，被遮蔽之后它不发目录，
+目录由我们发布。要点：
+
+- 目录那条注入消息的 **kind 是我们自己的**（`context-assembler` + `form: "catalog"` + `entries`）。上游把任何
+  `kind: "skill-catalog"` 且条目可读的消息当成它自己的账本：kind 用它的，它会在首步删掉我们这条、在有可见
+  目录之后补一条"没有可用 skill"把目录顶掉（它文档里的 visibility-loss 语义）。`form` 与 `entries` 照旧，
+  客户端那张条目表不受影响；注入行的标签变成 `context-assembler`。
+- 按会话注册随 agent 收回；这一行重挂（HMR / 设置面）时不再重复注册同一份定义。
+- `chat`（挂 `minimal`，没有上游那一行）：工具与目录同样是我们提供的，但它的模式定义不收这两样
+  （`instructions: false`、白名单里没有 `skill`）——白名单把它挡在模型目录外，执行层 guard 拒绝调用。
+
+取舍与上游判据见 [ADR-工作区指令让位skill面由通道抢面](./.agents/adrs/20260929-工作区指令让位skill面由通道抢面.md)。
 
 ## 工具说明（不在这个包里）
 
@@ -106,7 +129,8 @@ web-app bundle 自己设在装配层；我们那份由本包的组装出口在 p
 ## scope
 
 按会话收口的出口（行 id `context-assembler-scope`）：工具白名单（装配期投影 + 执行层 guard + 与工具同源的
-`tool:<工具名>` 说明 section，三侧同判据）、`instructions`（关掉规则块与降级 section）、`runtimeContext`
+`tool:<工具名>` 说明 section，三侧同判据）、`instructions`（关掉一切 instruction 类送达：常驻组正文、规则块
+与降级 section；按需 skill 与 `@` 引用材料不受它管）、`runtimeContext`
 （关掉沙箱 / 审批那两条动态快照，按 scope 抑制）。
 
 **定义由消费方推给它**，它自己不认识"模式"：`ctx.sessionToolScope.apply(agent, mode)` 是唯一入口，落在该

package/dist/{agent-instructions-BNEiZl0P.mjs → agent-instructions-CIgUVIeo.mjs}

@@ -121,6 +121,40 @@ async function baselineIdentity(cwd) {
 	});
 }
 //#endregion
+//#region src/agent-instructions/preset-owner.ts
+/** 上游那一行的模块名：与 `presets/*.patch.yml` 里写的一字不差。 */
+const UPSTREAM_MODULE = "@deepseek-ai/dsh-agent-instructions";
+/** 会话 → 它当前的 preset。preset 变了（空白窗口里换 preset）就整份重算。 */
+const decided = /* @__PURE__ */ new WeakMap();
+/**
+* 该会话的 preset 自己提供了工作区指令这一面吗。
+* @param ctx - 能解析到注册表的上下文（能力自己的 apply ctx）。
+* @param agent - 要判的会话。
+* @returns 行清单里有上游那一行且它是启用的。
+*/
+function presetOwnsInstructions(ctx, agent) {
+	const registry = registryOf(ctx);
+	if (registry === void 0) return Promise.resolve(false);
+	const preset = registry.composedPreset(agent.ctx);
+	if (preset === void 0) 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) {
+	try {
+		return ctx.get("agentPresets");
+	} catch {
+		return;
+	}
+}
+//#endregion
 //#region src/agent-instructions/index.ts
 var agent_instructions_exports = /* @__PURE__ */ __exportAll({
 	Config: () => Config$1,
@@ -170,7 +204,8 @@ function apply(ctx, config) {
 				baselineIdentity: identity,
 				changes: []
 			}),
-			text: (target) => {
+			text: async (target) => {
+				if (await presetOwnsInstructions(ctx, target)) return "";
 				const current = chains.get(target);
 				if (current === void 0 || !current.files.some((entry) => entry.path === file.path)) return "";
 				return readInstruction(file, cache, maxBytes);

package/dist/agent-instructions.mjs

@@ -1,2 +1,2 @@
-import { a as name, i as inject, r as apply, t as Config } from "./agent-instructions-BNEiZl0P.mjs";
+import { a as name, i as inject, r as apply, t as Config } from "./agent-instructions-CIgUVIeo.mjs";
 export { Config, apply, inject, name };

package/dist/{assembler-_F9urbPj.mjs → assembler-CDMIBAi8.mjs}

@@ -13,7 +13,7 @@ const REMINDER_CLOSE = "</system-reminder>";
 const RULES_SECTION = "assembler:rules";
 /**
 * 这条消息是不是通道注入的条目——判据是 source 里的幂等键，而不是 kind：接管上游那两面的条目
-* 用上游 kind（`agent-instructions` / `skill-catalog`），幂等必须照样认。
+* 接管工作区指令那一面的条目用上游 kind（`agent-instructions`），幂等必须照样认。
 */
 function promptEntryIdOf(source) {
 	const id = source.id;
@@ -53,7 +53,7 @@ function latestReminderText(agent, id) {
 }
 /**
 * 注入一条提醒：`text` 是已渲染好的完整正文（规则块或内容块），`key` 是它的幂等键。
-* `source` 声明这条消息对外的身份——接管上游那两面用上游 kind，我们自己的条目留默认。
+* `source` 声明这条消息对外的身份——工作区指令那一面用上游 kind，我们自己的条目留默认。
 */
 function reminderMessage(key, text, source) {
 	return createUserMessage({
@@ -89,7 +89,10 @@ var ContextAssembler = class extends Service {
 	suppressed = /* @__PURE__ */ new Set();
 	skills = /* @__PURE__ */ new Map();
 	states = /* @__PURE__ */ new WeakMap();
-	/** 不要 instruction 类注入（规则块）的会话；内容块（技能正文、引用材料）不受它管。 */
+	/**
+	* 不要 instruction 类注入的会话（模式说了 `instructions: false`）：常驻正文、规则块与降级 section 都不进。
+	* 按需 skill 不受它管（那是模型自己加载），引用材料也不经通道。
+	*/
 	withoutInstructions = /* @__PURE__ */ new WeakSet();
 	/** 本会话的模式收窄（白名单）：投影层的过滤不碰注册表，注册表上看不出"谁能用"。 */
 	toolScopes = /* @__PURE__ */ new WeakMap();
@@ -137,7 +140,7 @@ var ContextAssembler = class extends Service {
 	* 本步要注入的条目：键 → 已渲染好的正文（规则块或内容块）。
 	* `sections` 来自本步装配，`rules` 与 `auto` skill 正文在这里现算。
 	*/
-	/** 这个会话不要 instruction 类的规则块（模式说了 `instructions: false`）。 */
+	/** 这个会话要不要 instruction 类注入（模式说了 `instructions: false` 就是不要，见 {@link withoutInstructions}）。 */
 	setInstructions(agent, on) {
 		if (on) this.withoutInstructions.delete(agent);
 		else this.withoutInstructions.add(agent);
@@ -179,14 +182,23 @@ var ContextAssembler = class extends Service {
 	contentFor(name, agent) {
 		return this.declarations.get(name)?.content(agent);
 	}
+	/** 一个 skill 在这个会话能不能被用到：声明了 `requires` 时至少一个工具在模式收窄内。 */
+	reachable(declaration, scope) {
+		const requires = declaration.requires;
+		if (requires === void 0 || requires.length === 0) return true;
+		if (scope === void 0) return true;
+		return requires.some((tool) => scope(tool));
+	}
 	async collect(agent) {
 		const entries = /* @__PURE__ */ new Map();
-		for (const declaration of this.declarations.values()) {
+		const scope = this.toolScopes.get(agent);
+		const instructionsOff = this.withoutInstructions.has(agent);
+		if (!instructionsOff) for (const declaration of this.declarations.values()) {
 			if ((declaration.injection ?? "on-demand") !== "auto") continue;
+			if (!this.reachable(declaration, scope)) continue;
 			const body = declaration.content(agent);
 			if (body.length > 0) entries.set(declaration.name, { text: renderVirtualSkill(declaration.name, body) });
 		}
-		const instructionsOff = this.withoutInstructions.has(agent);
 		for (const declaration of this.rules.values()) {
 			if (instructionsOff) break;
 			const text = await withTimeout(declaration.text(agent), CONTENT_TIMEOUT_MS);

package/dist/assembler.d.mts

@@ -1,2 +1,2 @@
-import { a as name, c as InjectionMode, d as PromptSkillDeclaration, f as DEFAULT_KEEP, i as inject, l as PromptEntry, m as DEFAULT_SUPPRESS, n as apply, o as renderVirtualSkill, p as DEFAULT_REPLACE, s as ContextAssembler, t as Config, u as PromptRuleDeclaration } from "./index-BGkeEaQA.mjs";
+import { a as name, c as InjectionMode, d as PromptSkillDeclaration, f as DEFAULT_KEEP, i as inject, l as PromptEntry, m as DEFAULT_SUPPRESS, n as apply, o as renderVirtualSkill, p as DEFAULT_REPLACE, s as ContextAssembler, t as Config, u as PromptRuleDeclaration } from "./index-zhmD45A9.mjs";
 export { Config, ContextAssembler, DEFAULT_KEEP, DEFAULT_REPLACE, DEFAULT_SUPPRESS, type InjectionMode, type PromptEntry, type PromptRuleDeclaration, type PromptSkillDeclaration, apply, inject, name, renderVirtualSkill };

package/dist/assembler.mjs

@@ -1,2 +1,2 @@
-import { a as name, c as DEFAULT_SUPPRESS, i as inject, l as ContextAssembler, n as apply, o as DEFAULT_KEEP, s as DEFAULT_REPLACE, t as Config, u as renderVirtualSkill } from "./assembler-_F9urbPj.mjs";
+import { a as name, c as DEFAULT_SUPPRESS, i as inject, l as ContextAssembler, n as apply, o as DEFAULT_KEEP, s as DEFAULT_REPLACE, t as Config, u as renderVirtualSkill } from "./assembler-CDMIBAi8.mjs";
 export { Config, ContextAssembler, DEFAULT_KEEP, DEFAULT_REPLACE, DEFAULT_SUPPRESS, apply, inject, name, renderVirtualSkill };

package/dist/{index-BGkeEaQA.d.mts → index-zhmD45A9.d.mts}

@@ -68,7 +68,7 @@ interface PromptRuleDeclaration {
   readonly id: string;
   readonly text: (agent: Agent) => string | Promise<string>;
   /**
-   * 这条规则的对外身份。接管上游那两面（工作区指令 / skill 目录）按上游 kind 发消息，好让按 kind 认领的
+   * 这条规则的对外身份。工作区指令那一面按上游 kind 发消息（skill 面相反，用我们自己的 kind），好让按 kind 认领的
    * 消费方（客户端标签、上游的实验性约束收集）认得出来；不声明就是通道自己的 `context-assembler`。
    * 幂等键仍是 `id`（`reminderMessage` 会把它塞进 source）。
    */
@@ -96,7 +96,10 @@ declare class ContextAssembler extends Service {
   private readonly suppressed;
   private readonly skills;
   private readonly states;
-  /** 不要 instruction 类注入（规则块）的会话；内容块（技能正文、引用材料）不受它管。 */
+  /**
+   * 不要 instruction 类注入的会话（模式说了 `instructions: false`）：常驻正文、规则块与降级 section 都不进。
+   * 按需 skill 不受它管（那是模型自己加载），引用材料也不经通道。
+   */
   private readonly withoutInstructions;
   /** 本会话的模式收窄（白名单）：投影层的过滤不碰注册表，注册表上看不出"谁能用"。 */
   private readonly toolScopes;
@@ -113,7 +116,7 @@ declare class ContextAssembler extends Service {
    * 本步要注入的条目：键 → 已渲染好的正文（规则块或内容块）。
    * `sections` 来自本步装配，`rules` 与 `auto` skill 正文在这里现算。
    */
-  /** 这个会话不要 instruction 类的规则块（模式说了 `instructions: false`）。 */
+  /** 这个会话要不要 instruction 类注入（模式说了 `instructions: false` 就是不要，见 {@link withoutInstructions}）。 */
   setInstructions(agent: Agent, on: boolean): void;
   /**
    * 本会话的**工具收窄**（模式白名单）：投影层只过滤装配结果、不碰工具注册表，所以"谁能用"这件事
@@ -137,6 +140,8 @@ declare class ContextAssembler extends Service {
    * 路径（接管的 `skill` 工具）要用这里重新算一次，才和 `auto` 正文一样跟着工具走。
    */
   contentFor(name: string, agent: Agent | undefined): string | undefined;
+  /** 一个 skill 在这个会话能不能被用到：声明了 `requires` 时至少一个工具在模式收窄内。 */
+  private reachable;
   collect(agent: Agent): Promise<Map<string, PromptEntry>>;
   private sectionsOf;
   /**
@@ -159,7 +164,19 @@ declare module "@deepseek-ai/cordis" {
 /** 通道自己的条目形态（注入方没声明 source 时的默认）：规则块，幂等键是 id。 */
 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;
 }

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { t as index_d_exports } from "./agent-instructions.mjs";
-import { r as index_d_exports$1 } from "./index-BGkeEaQA.mjs";
+import { r as index_d_exports$1 } from "./index-zhmD45A9.mjs";
 import { t as index_d_exports$2 } from "./scope.mjs";
 import { t as index_d_exports$3 } from "./skill-catalog.mjs";
 import z from "@deepseek-ai/schemastery";

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { n as agent_instructions_exports } from "./agent-instructions-BNEiZl0P.mjs";
-import { r as assembler_exports } from "./assembler-_F9urbPj.mjs";
+import { n as agent_instructions_exports } from "./agent-instructions-CIgUVIeo.mjs";
+import { r as assembler_exports } from "./assembler-CDMIBAi8.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";

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morlay/dsh-context-assembler",
-  "version": "0.0.1-alpha.3",
+  "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",
@@ -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-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",
+    "@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-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": {
-      "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/skill-catalog/index.ts

@@ -8,7 +8,7 @@ import { renderVirtualSkill } from "../assembler/index.ts";
 
 export const name = "context-skill-catalog";
 
-export const inject = ["skills", "tools", "contextAssembler"];
+export const inject = ["agents", "skills", "tools", "contextAssembler"];
 
 export const CATALOG_ID = "skill-catalog";
 
@@ -20,6 +20,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`）那种没有上游行的会话里也只有我们这一份。
  */
 export function apply(ctx: Context): void {
   /**
@@ -28,12 +35,42 @@ export function apply(ctx: Context): void {
    */
   const catalogEntries = new WeakMap<Agent, readonly { name: string; description: string }[]>();
 
+  // 同名工具只能有一个所有者：host 平面已经有人注册了 `skill`（装上游 `tool-skill` 的部署）就让给它，
+  // 我们只发布目录。我们的部署里 host 平面那一行是禁用的（preset 才装），所以走的是下面这条。
+  const skillTool = ctx.tools.get("skill") === undefined ? defineSkillTool(ctx) : undefined;
+  if (skillTool === undefined) {
+    ctx.logger.warn(
+      "context-skill-catalog: a `skill` tool is already registered; keeping the existing one and only publishing the catalog",
+    );
+  } else {
+    // 按会话注册：`register` 落到**调用它的那个 ctx** 的 scope 层（agent 自己那一层），随 agent 收回。
+    const install = (agent: Agent): void => {
+      // 本行重装（HMR / 设置面）时上次那份注册还在 agent 自己那一层（它随 agent 而不是随本行收回）：
+      // 同一份定义就不要再注册一次——同一层重复注册会抛（`dsh-scope` 的 `NamedEntries.insert`）。
+      if (ctx.tools.get("skill", agent) === skillTool) return;
+      try {
+        agent.ctx.tools.register(skillTool);
+      } catch (error) {
+        // agent 自己那一层被更具体的注册占了：让开（它自己会发目录），我们这一份注册不上。
+        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,
-    // 对外身份沿用上游 kind：客户端标签与按 kind 认领的消费方认得这是技能目录，`entries` 就是
-    // 目录行里发布的那份清单（非模型消费者照它列条目）。
+    // 对外身份**用我们自己的 kind**（不是上游那个 `skill-catalog`）：目录的正文与条目都由我们发布，而上游
+    // `tool-skill` 的目录监听器把任何 `kind: 'skill-catalog'` 且条目可读的消息都当成**它自己的**账本
+    // （`catalogMessage` / `catalogHistory`），于是它会删掉我们这一条（首步：`!history.published &&
+    // skills.length === 0` 那条分支）或者补一条"没有可用 skill"的空目录把它顶掉（它有可见目录之后）。
+    // 形态仍是它认得的 `catalog`（`entries` 是客户端列条目的那份清单），只是 kind 归我们——
+    // 它的两个扫法都只看 kind，于是本会话里它彻底闭嘴。
     source: (agent) => ({
-      kind: "skill-catalog",
+      kind: "context-assembler",
       form: "catalog",
       entries: catalogEntries.get(agent) ?? [],
     }),
@@ -79,21 +116,11 @@ export function apply(ctx: Context): void {
       ].join("\n");
     },
   });
-
-  // 同名工具只能有一个所有者：host 层的 `tool-skill` 行由 patch 禁用，但万一没禁掉（上游改了行 id、
-  // 或别的 bundle 又插了一份），重复注册会让 tools/change 抖动甚至让 session 创建失败——所以先看清
-  // 注册表里有没有，有就让给对方，我们只负责目录。
-  if (ctx.tools.get("skill") !== undefined) {
-    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: Context): void {
-  const skillTool = defineTool({
+/** 一份工具定义，按会话注册进每个 agent 的自己那一层（同一个定义对象，判据里的同一性靠它）。 */
+function defineSkillTool(ctx: Context): ReturnType<typeof defineTool> {
+  return defineTool({
     name: "skill",
     description: "按需加载 skill 的完整说明。",
     parameters: {
@@ -169,7 +196,6 @@ function registerSkillTool(ctx: Context): void {
       };
     },
   });
-  ctx.tools.register(skillTool);
 }
 
 function clamp(text: string, max: number): string {

package/cordis.patch.yml

@@ -1,9 +0,0 @@
-# 本文件由 packages/context/dsh-context-assembler/tool/patch.ts 生成，请勿手工编辑
-- insert:
-    - id: context-assembler
-      name: "@morlay/dsh-context-assembler"
-      config:
-        capabilities:
-          - assembler
-          - agent-instructions
-          - skill-catalog

package/tool/patch.ts

@@ -1,43 +0,0 @@
-import { writeFile } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { entryListSchema } from "@deepseek-ai/cordis-plugin-include";
-import yaml from "js-yaml";
-import { PATCH_ROWS } from "../src/rows.ts";
-
-/**
- * bundle patch 的真源：把 {@link PATCH_ROWS}（`src/rows.ts` 那一份清单）写成 `cordis.patch.yml`。
- *
- * 本包有两种采用方式（见 `src/rows.ts`）：`dsh.profile.bundles` 直接列出本包时用这份 patch；由
- * preset 引用时走 preset 自己的行清单——**同一份真源**，不会两边漂移。
- */
-
-export const PATCH_FILE = "cordis.patch.yml";
-
-const HEADER = `# 本文件由 packages/context/dsh-context-assembler/tool/patch.ts 生成，请勿手工编辑
-`;
-
-export function renderPatch(): string {
-  const body = yaml.dump([...PATCH_ROWS], {
-    schema: entryListSchema,
-    lineWidth: -1,
-    quotingType: '"',
-  });
-  return `${HEADER}${body}`;
-}
-
-/** 把 bundle patch 落到包根：它是发布产物的一部分（`files` 里有它，装配按出口解析）。 */
-export async function generatePatch(): Promise<string> {
-  const path = join(resolve(dirname(fileURLToPath(import.meta.url)), ".."), PATCH_FILE);
-  await writeFile(path, renderPatch());
-  return path;
-}
-
-/** tsdown 的 `build:done` 钩子：每次构建重写 `cordis.patch.yml`，入库的那份因此永远等于 `PATCH_ROWS`。 */
-export function patchHooks(): { "build:done": () => Promise<void> } {
-  return {
-    "build:done": async () => {
-      process.stdout.write(`generated ${await generatePatch()}\n`);
-    },
-  };
-}