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

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/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/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 };

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`);
-    },
-  };
-}