@morlay/dsh-context-assembler 0.0.2 → 0.0.3

package/src/agent-instructions/baseline.ts

@@ -1,75 +0,0 @@
-import { stat } from "node:fs/promises";
-import { dirname, join, relative, resolve } from "node:path";
-import { Config as UpstreamConfig } from "@deepseek-ai/dsh-agent-instructions";
-
-/**
- * 上游 baseline 身份：`@deepseek-ai/dsh-agent-instructions` 用它在会话 surface 上认领"基线已注入"。
- *
- * 为什么我们要算它：接管那面之后，我们注入的条目**沿用上游 kind**（客户端「上下文注入」标签与按 kind
- * 认领的消费方才认得这是工作区指令），但只沿用一半不够——上游的认领判据是
- * `source.kind === 'agent-instructions' && source.baseline === true` 且 `baselineIdentity` 与它自己算出的
- * identity **逐字相等**。少这两样，上游（官方 preset 自己装的那行）就认为基线不存在，于是**再注入一条**：
- * 同会话切到官方 preset 后会同时存在两条 AGENTS.md——一条是这份正文、一条是上游模板（"Use them as
- * guidance…"），口径互相矛盾，而模型无法把后一条理解成"作废前一条"（两条来源的幂等键不同）。
- *
- * 身份要与上游逐字对齐，但它的 `resolveConfig` / `workspaceBaselineIdentity` / `findProjectRoot` **不在包
- * 出口面**（发布包 `files` 只有 `lib/index.js` 与声明），所以这里复刻它的形状：默认值取自**导出的
- * `Config` schema**（跟随上游默认值演进），字段名与顺序照它的 `workspaceBaselineIdentity` 抄一份；
- * `baseline.spec.ts` 用上游 `./src/*` 出口的真函数比对，防这份复刻悄悄漂移。
- *
- * 配置基线是 base bundle 给那行的 `maxBytes: 65536`（其余取 schema 默认）——与它同源，身份才相等。
- */
-const BASE_MAX_BYTES = 65_536;
-
-/** 上游那行的身份基线：与 `packages/bundle/base/cordis.patch.yml` 的 `agent-instructions` 行 config 同源。 */
-export const UPSTREAM_BASELINE_CONFIG = { maxBytes: BASE_MAX_BYTES } as const;
-
-interface BaselineConfig {
-  readonly projectRootMarkers: string[];
-  readonly maxBytes: number;
-  readonly maxSourceBytes: number;
-  readonly instructionFileCandidates: string[];
-  readonly localInstructionFileCandidates: string[];
-}
-
-/** schema 调用会把缺省项补齐，所以这里拿到的是上游 schema 的实际默认值。 */
-function resolveBaselineConfig(): BaselineConfig {
-  return UpstreamConfig({ ...UPSTREAM_BASELINE_CONFIG }) as unknown as BaselineConfig;
-}
-
-/** 上游 `findProjectRoot` 的语义：向上找第一个带标记的目录，找不到就用 cwd。 */
-async function projectRootOf(cwd: string, markers: readonly string[]): Promise<string> {
-  let current = resolve(cwd);
-  for (;;) {
-    for (const marker of markers) {
-      if (await exists(join(current, marker))) return current;
-    }
-    const parent = dirname(current);
-    if (parent === current) return resolve(cwd);
-    current = parent;
-  }
-}
-
-async function exists(path: string): Promise<boolean> {
-  try {
-    await stat(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/** 一个会话的 baseline 身份；cwd 或项目根变了就是另一份身份（上游语义）。 */
-export async function baselineIdentity(cwd: string): Promise<string> {
-  const config = resolveBaselineConfig();
-  const projectRoot = await projectRootOf(cwd, config.projectRootMarkers);
-  // 字段顺序与上游 `workspaceBaselineIdentity` 一致：它比较的是 JSON 字符串，顺序也参与。
-  return JSON.stringify({
-    projectRoot: relative(cwd, projectRoot),
-    projectRootMarkers: config.projectRootMarkers,
-    maxBytes: config.maxBytes,
-    maxSourceBytes: config.maxSourceBytes,
-    instructionFileCandidates: config.instructionFileCandidates,
-    localInstructionFileCandidates: config.localInstructionFileCandidates,
-  });
-}

package/src/agent-instructions/files.ts

@@ -1,117 +0,0 @@
-import { readFile, stat } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-
-/** 一条要注入的指令文件：`display` 进 id 与正文，`path` 用来读，`root` 区分同名文件。 */
-export interface InstructionFile {
-  /** 该文件所属的根（项目根或 `$DSH_HOME`）：规则块 id 靠它区分不同根下的同名文件。 */
-  readonly root: string;
-  readonly display: string;
-  readonly path: string;
-}
-
-export interface WorkspaceOptions {
-  readonly instructionFileCandidates: readonly string[];
-  readonly localInstructionFileCandidates: readonly string[];
-  readonly dshHome: string;
-}
-
-/** 从 cwd 逐级向上找项目根（含标记目录的那一级）。 */
-async function projectRoot(cwd: string, marker = ".git"): Promise<string | undefined> {
-  let current = resolve(cwd);
-  for (;;) {
-    const found = await stat(join(current, marker)).then(
-      () => true,
-      () => false,
-    );
-    if (found) return current;
-    const parent = dirname(current);
-    if (parent === current) return undefined;
-    current = parent;
-  }
-}
-
-function abbreviateHome(path: string): string {
-  const home = homedir();
-  return path.startsWith(`${home}/`) ? `~${path.slice(home.length)}` : path;
-}
-
-/**
- * 工作区指令链：用户全局 `$DSH_HOME/AGENTS.md`，再从项目根到 cwd 的每一级目录取
- * 基础文件与本地 overlay。顺序由宽泛到具体——具体的在后面，与"更具体的优先"一致。
- */
-export async function instructionChain(
-  cwd: string,
-  options: WorkspaceOptions,
-): Promise<InstructionFile[]> {
-  const files: InstructionFile[] = [];
-  const global = join(options.dshHome, "AGENTS.md");
-  if (await isFile(global))
-    files.push({ root: options.dshHome, display: abbreviateHome(global), path: global });
-
-  const root = (await projectRoot(cwd)) ?? resolve(cwd);
-  const levels: string[] = [];
-  let current = resolve(cwd);
-  for (;;) {
-    levels.unshift(current);
-    if (current === root) break;
-    const parent = dirname(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  for (const level of levels) {
-    for (const name of [
-      ...options.instructionFileCandidates,
-      ...options.localInstructionFileCandidates,
-    ]) {
-      const path = join(level, name);
-      if (await isFile(path)) files.push({ root, display: relativeDisplay(root, path), path });
-    }
-  }
-  return files;
-}
-
-function relativeDisplay(root: string, path: string): string {
-  const rel = path.slice(root.length + 1);
-  return rel.length === 0 ? path : rel;
-}
-
-async function isFile(path: string): Promise<boolean> {
-  const info = await stat(path).then(
-    (value) => value,
-    () => undefined,
-  );
-  return info?.isFile() === true;
-}
-
-/** 读一个指令文件；按 `mtimeMs:size` 缓存，未变就不重读。 */
-export async function readInstruction(
-  file: InstructionFile,
-  cache: Map<string, { stamp: string; text: string }>,
-  maxBytes: number,
-): Promise<string> {
-  const info = await stat(file.path).then(
-    (value) => value,
-    () => undefined,
-  );
-  if (info?.isFile() !== true) {
-    cache.delete(file.path);
-    return "";
-  }
-  const stamp = `${String(info.mtimeMs)}:${String(info.size)}`;
-  const cached = cache.get(file.path);
-  if (cached?.stamp === stamp) return cached.text;
-  const raw = await readFile(file.path, "utf8").catch(() => "");
-  const text = budget(raw, file.display, maxBytes);
-  cache.set(file.path, { stamp, text });
-  return text;
-}
-
-/** 单文件超出预算时截断并留一行可见提示（不静默丢内容）。 */
-function budget(text: string, display: string, maxBytes: number): string {
-  if (Buffer.byteLength(text, "utf8") <= maxBytes) return text.trimEnd();
-  const kept = Buffer.from(text, "utf8").subarray(0, maxBytes).toString("utf8");
-  const lastBreak = kept.lastIndexOf("\n");
-  const body = (lastBreak > 0 ? kept.slice(0, lastBreak) : kept).trimEnd();
-  return `${body}\n\n(Workspace instruction budget ${String(maxBytes)} bytes: ${display} is truncated.)`;
-}

package/src/agent-instructions/index.ts

@@ -1,111 +0,0 @@
-import { createHash } from "node:crypto";
-import { resolve } from "node:path";
-import type { Context } from "@deepseek-ai/cordis";
-import type { Agent } from "@deepseek-ai/dsh-agent";
-import type {} from "@deepseek-ai/dsh-agent-instructions";
-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";
-
-export const inject = ["agents", "contextAssembler"];
-
-export interface Config {
-  /** 每级目录的基础指令文件名。 */
-  instructionFileCandidates?: string[];
-  /** 基础文件之后加载的本地 overlay 名。 */
-  localInstructionFileCandidates?: string[];
-  /** 单个指令文件的渲染上限（字节）。 */
-  maxBytes?: number;
-  /** 用户全局指令所在目录（默认 `$DSH_HOME` 或 `~/.dsh`）。 */
-  dshHome?: string;
-}
-
-export const Config: z<Config> = z.object({
-  instructionFileCandidates: z.array(z.string()).default(["AGENTS.md"]),
-  localInstructionFileCandidates: z.array(z.string()).default(["AGENTS.local.md"]),
-  maxBytes: z.number().default(65536),
-  dshHome: z.string().default(process.env["DSH_HOME"] ?? ""),
-});
-
-/** 一个会话的指令链：路径集合与它所属的 cwd。 */
-const chains = new WeakMap<Agent, { cwd: string; files: InstructionFile[] }>();
-
-/**
- * 工作区指令：一条文件一个规则块（id 为 `agent-instructions:<根标识>:<文件>`），文件变化时正文变、按 id 覆盖。
- *
- * 与上游 `agent-instructions` 的差别：不做 read/write/edit 的 touch 跟踪（本部署的 `AGENTS.md`
- * 几乎不变），只在每步按 `mtime:size` 对账；一份文件一条 id，于是变化只重发变了的那一份。
- */
-export function apply(ctx: Context, config: Config): void {
-  const options = {
-    instructionFileCandidates: config.instructionFileCandidates ?? ["AGENTS.md"],
-    localInstructionFileCandidates: config.localInstructionFileCandidates ?? ["AGENTS.local.md"],
-    dshHome:
-      config.dshHome === undefined || config.dshHome === "" ? defaultDshHome() : config.dshHome,
-  };
-  const maxBytes = config.maxBytes ?? 65536;
-  const cache = new Map<string, { stamp: string; text: string }>();
-
-  const install = async (agent: Agent): Promise<void> => {
-    if (chains.has(agent)) return;
-    const cwd = agent.session.header.cwd === undefined ? process.cwd() : agent.session.header.cwd;
-    const chain = { cwd, files: await instructionChain(cwd, options) };
-    chains.set(agent, chain);
-    // 上游认领判据要的身份：缺它，上游（官方 preset 自己装的那行）会以为基线不存在，再注入一条自己的模板。
-    const identity = await baselineIdentity(cwd);
-    for (const file of chain.files) {
-      ctx.contextAssembler.registerRule({
-        id: `agent-instructions:${rootTag(file.root)}:${file.display}`,
-        // 对外身份沿用上游那两样（skill 面相反，用我们自己的 kind）：kind 让客户端标签与按 kind 认领的消费方认得这是
-        // 工作区指令；`baseline` 与 `baselineIdentity` 让上游的认领判据（kind + baseline===true + 身份相等）
-        // 认这份条目就是基线，于是它不再注入自己那条模板。`changes` 留空——上游那套按文件做 reconciliation
-        // 的记录我们不做（一条文件一条 id）。
-        source: () => ({
-          kind: "agent-instructions",
-          form: "instructions",
-          baseline: true,
-          baselineIdentity: identity,
-          changes: [],
-        }),
-        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 "";
-          return readInstruction(file, cache, maxBytes);
-        },
-      });
-    }
-  };
-
-  ctx.on("agent/created", ({ agent }) => {
-    void install(agent).catch((error: unknown) => {
-      ctx.logger.warn(`context-agent-instructions: ${String(error)}`);
-    });
-  });
-  for (const agent of ctx.agents.list()) {
-    void install(agent).catch((error: unknown) => {
-      ctx.logger.warn(`context-agent-instructions: ${String(error)}`);
-    });
-  }
-}
-
-function defaultDshHome(): string {
-  const home = process.env["HOME"] ?? "~";
-  return resolve(process.env["DSH_HOME"] ?? `${home}/.dsh`);
-}
-
-/**
- * 规则块 id 里的根标识：规则声明是**全局按 id 覆盖**的，而 `display` 只是根内相对路径——
- * 同进程里两个项目根都有 `AGENTS.md` 时，不带根标识的 id 会互相顶掉（后注册者覆盖前者，
- * 前者此后读到空正文）。8 位摘要够唯一，又不把绝对路径塞进提示词 id。
- */
-function rootTag(root: string): string {
-  return createHash("sha256").update(root).digest("hex").slice(0, 8);
-}

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

@@ -1,70 +0,0 @@
-/**
- * 「这个会话的 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

@@ -1,309 +0,0 @@
-import type { Agent } from "@deepseek-ai/dsh-agent";
-import { Service, type Context } from "@deepseek-ai/cordis";
-import type { MessageSource } from "@deepseek-ai/dsh-llm";
-import { renderReminder, renderVirtualSkill } from "./reminder.ts";
-
-/** 正文到达模型的方式：自动注入，或等模型按需加载。 */
-export type InjectionMode = "auto" | "on-demand";
-
-/**
- * 一条按 skill 形态声明的注入：正文是本仓库维护的文案。
- *
- * 正文与 agent 无关（工具集在装配期就定了），所以 skill 在装配期注册一次、全局可见。
- */
-export interface PromptSkillDeclaration {
-  /** kebab-case：skill 名，也是注入条目的 id。 */
-  readonly name: string;
-  readonly title: string;
-  /** 目录行摘要：讲清什么时候该加载它。 */
-  readonly description: string;
-  /**
-   * 正文按**会话**生成：模式可能只给一部分工具，正文要跟着修剪（不该讲用不到的工具）。
-   * 不传 agent（装配期注册 skill 时）返回不过滤的完整版。
-   */
-  readonly content: (agent?: Agent) => string;
-  /**
-   * 这个 skill 赖以成立的**入口工具**（任一存在即可，不是全部）。都不可见时它不该出现在该会话的技能
-   * 目录里——"不能用 skill 工具就没有技能目录"是同一个道理：技能也跟着工具走。
-   *
-   * 缺省语义就是"一个都不在就藏起来"；声明方要自己挑入口，别把组内所有可能的工具都倒进来
-   * （子代理控制行与团队插件会提供同名工具，全集当判据会把不该出现的 skill 留下）。
-   */
-  readonly requires?: readonly string[];
-  /** 缺省 `on-demand`：只有正文确有必要常驻时才写 `auto`。 */
-  readonly injection?: InjectionMode;
-}
-
-interface RegisteredSkill {
-  readonly digest: string;
-  readonly dispose: () => void;
-}
-
-interface AgentState {
-  /** 本步装配降级出来的 section 条目：id → 正文（未渲染信封）。 */
-  sections: ReadonlyMap<string, string>;
-}
-
-/**
- * 一条规则块声明：系统级信息（工作区指令、skill 目录），文本按 id 幂等注入、同 id 覆盖。
- * 文本可以是异步的（skill 目录要读 skill 注册表）。
- */
-export interface PromptRuleDeclaration {
-  readonly id: string;
-  readonly text: (agent: Agent) => string | Promise<string>;
-  /**
-   * 这条规则的对外身份。工作区指令那一面按上游 kind 发消息（skill 面相反，用我们自己的 kind），好让按 kind 认领的
-   * 消费方（客户端标签、上游的实验性约束收集）认得出来；不声明就是通道自己的 `context-assembler`。
-   * 幂等键仍是 `id`（`reminderMessage` 会把它塞进 source）。
-   */
-  readonly source?: (agent: Agent) => MessageSource;
-}
-
-/** 一条待注入的条目：正文已渲染好，`source` 是它声明给外部的身份。 */
-export interface PromptEntry {
-  readonly text: string;
-  readonly source?: MessageSource;
-}
-
-/**
- * 注入通道：调用方声明「什么内容、怎么到达模型」，这里负责到达方式。
- *
- * - `on-demand`：注册成模型可用 skill（进 skill 目录，正文按需加载）；
- * - `auto`：正文自动注入 reminder（注册成 skill 但标 `modelInvocable: false`，因为已经常驻）；
- * - `replaceSection` / `suppressSection`：装配结果上的文本改写与丢弃。
- *
- * 覆盖语义（同 id 最新取代更早）由系统提示词里的声明说明一次，见 [`rules.ts`](./rules.ts)。
- */
-export class ContextAssembler extends Service {
-  private readonly declarations = new Map<string, PromptSkillDeclaration>();
-  private readonly rules = new Map<string, PromptRuleDeclaration>();
-  private readonly overrides = new Map<string, (agent: Agent) => string | undefined>();
-  private readonly suppressed = new Set<string>();
-  private readonly skills = new Map<string, RegisteredSkill>();
-  private readonly states = new WeakMap<Agent, AgentState>();
-  /**
-   * 不要 instruction 类注入的会话（模式说了 `instructions: false`）：常驻正文、规则块与降级 section 都不进。
-   * 按需 skill 不受它管（那是模型自己加载），引用材料也不经通道。
-   */
-  private readonly withoutInstructions = new WeakSet<Agent>();
-
-  /** 本会话的模式收窄（白名单）：投影层的过滤不碰注册表，注册表上看不出"谁能用"。 */
-  private readonly toolScopes = new WeakMap<Agent, (tool: string) => boolean>();
-
-  /** `host` 是构造期那个根 ctx：`skills` 的访问权限挂在插件的 inject 声明上，不能依赖访问者 ctx。 */
-  constructor(private readonly host: Context) {
-    super(host, "contextAssembler");
-  }
-
-  registerSkill(declaration: PromptSkillDeclaration): () => void {
-    this.declarations.set(declaration.name, declaration);
-    this.refreshSkills();
-    return () => {
-      if (this.declarations.get(declaration.name) !== declaration) return;
-      this.declarations.delete(declaration.name);
-      this.refreshSkills();
-    };
-  }
-
-  registerRule(declaration: PromptRuleDeclaration): () => void {
-    this.rules.set(declaration.id, declaration);
-    return () => {
-      if (this.rules.get(declaration.id) === declaration) this.rules.delete(declaration.id);
-    };
-  }
-
-  replaceSection(name: string, text: (agent: Agent) => string | undefined): () => void {
-    this.overrides.set(name, text);
-    return () => {
-      if (this.overrides.get(name) === text) this.overrides.delete(name);
-    };
-  }
-
-  suppressSection(name: string): () => void {
-    this.suppressed.add(name);
-    return () => {
-      this.suppressed.delete(name);
-    };
-  }
-
-  isSuppressed(name: string): boolean {
-    return this.suppressed.has(name);
-  }
-
-  /** 装配结果上该 section 要换成的文本；undefined 表示原样保留。 */
-  replacement(name: string, agent: Agent | undefined): string | undefined {
-    const override = this.overrides.get(name);
-    return override === undefined || agent === undefined ? undefined : override(agent);
-  }
-
-  /**
-   * 本步要注入的条目：键 → 已渲染好的正文（规则块或内容块）。
-   * `sections` 来自本步装配，`rules` 与 `auto` skill 正文在这里现算。
-   */
-  /** 这个会话要不要 instruction 类注入（模式说了 `instructions: false` 就是不要，见 {@link withoutInstructions}）。 */
-  setInstructions(agent: Agent, on: boolean): void {
-    if (on) this.withoutInstructions.delete(agent);
-    else this.withoutInstructions.add(agent);
-  }
-
-  /**
-   * 本会话的**工具收窄**（模式白名单）：投影层只过滤装配结果、不碰工具注册表，所以"谁能用"这件事
-   * 必须在通道上登记，技能目录与组正文才收得住。与 {@link setInstructions} 同形——谓词由模式那一行给
-   * （`context-scope`），通道自己不碰 `tools` 服务。
-   */
-  restrictTools(agent: Agent, allowed: (tool: string) => boolean): void {
-    this.toolScopes.set(agent, allowed);
-  }
-
-  /**
-   * 本会话的工具可见性：调用方给出的注册表可见性 × 已登记的模式收窄。技能目录与组正文共用它，
-   * 免得同一套判据在几处各写一遍。
-   */
-  visibleTools(agent: Agent, registered: (tool: string) => boolean): (tool: string) => boolean {
-    const allowed = this.toolScopes.get(agent);
-    return allowed === undefined ? registered : (tool) => registered(tool) && allowed(tool);
-  }
-
-  /**
-   * 该会话看不到的 skill 名：声明了 `requires` 而依赖的工具一个都不可见。
-   *
-   * 目录由 `context-skill-catalog` 渲染，它把工具可见性作为谓词传进来（通道不碰 tools 服务）。
-   */
-  hiddenSkills(visible: (tool: string) => boolean): ReadonlySet<string> {
-    const hidden = new Set<string>();
-    for (const [name, declaration] of this.declarations) {
-      const requires = declaration.requires;
-      if (requires === undefined || requires.length === 0) continue;
-      if (!requires.some(visible)) hidden.add(name);
-    }
-    return hidden;
-  }
-
-  /**
-   * 该 skill 按会话修剪后的正文：注册表只能存一份（技能注册是装配期一次、全局可见），所以按需加载
-   * 路径（接管的 `skill` 工具）要用这里重新算一次，才和 `auto` 正文一样跟着工具走。
-   */
-  contentFor(name: string, agent: Agent | undefined): string | undefined {
-    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>();
-    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;
-      // 注入路径不能被任何一个内容提供者拖死：文本是异步算的（技能目录要读注册表、工作区指令要读文件），
-      // 谁卡住都不该让人等在这里——超时或抛错都按"这条没有内容"处理。
-      const text = await withTimeout(declaration.text(agent), CONTENT_TIMEOUT_MS);
-      if (text.length > 0) {
-        entries.set(declaration.id, {
-          text: renderReminder(declaration.id, text),
-          ...(declaration.source === undefined ? {} : { source: declaration.source(agent) }),
-        });
-      }
-    }
-    if (!instructionsOff) {
-      for (const [id, text] of this.sectionsOf(agent)) {
-        entries.set(id, { text: renderReminder(id, text) });
-      }
-    }
-    return entries;
-  }
-
-  private sectionsOf(agent: Agent): ReadonlyMap<string, string> {
-    return this.states.get(agent)?.sections ?? new Map();
-  }
-
-  /**
-   * 每步装配调一次：记下本步降级出来的 section 文本，供下一步注入。
-   */
-  sync(agent: Agent, input: { readonly sections: ReadonlyMap<string, string> }): void {
-    this.stateOf(agent).sections = input.sections;
-  }
-
-  /** skill 注册（装配期一次，全局可见）：正文没变的不重注册。 */
-  private refreshSkills(agent?: Agent): void {
-    for (const [name, declaration] of this.declarations) {
-      const content = declaration.content(agent);
-      const modelInvocable = (declaration.injection ?? "on-demand") === "on-demand";
-      const digest = `${modelInvocable ? "model" : "auto"}\u0000${declaration.description}\u0000${content}`;
-      const current = this.skills.get(name);
-      if (current?.digest === digest) continue;
-      current?.dispose();
-      const dispose = this.host.skills.register({
-        name,
-        description: declaration.description,
-        content,
-        source: "runtime",
-        invocation: { modelInvocable, userInvocable: true },
-      });
-      this.skills.set(name, { digest, dispose });
-    }
-    for (const [name, registered] of this.skills) {
-      if (this.declarations.has(name)) continue;
-      registered.dispose();
-      this.skills.delete(name);
-    }
-  }
-
-  private stateOf(agent: Agent): AgentState {
-    const existing = this.states.get(agent);
-    if (existing !== undefined) return existing;
-    const state: AgentState = { sections: new Map() };
-    this.states.set(agent, state);
-    return state;
-  }
-}
-
-declare module "@deepseek-ai/cordis" {
-  interface Context {
-    contextAssembler: ContextAssembler;
-  }
-}
-
-/** 一条注入内容的取用上限：超过就按"没有内容"处理，不阻塞这一轮请求。 */
-const CONTENT_TIMEOUT_MS = 2000;
-
-async function withTimeout(work: string | Promise<string>, ms: number): Promise<string> {
-  if (typeof work === "string") return work;
-  const settled = Promise.resolve(work).catch(() => "");
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const expiry = new Promise<string>((resolve) => {
-    timer = setTimeout(() => {
-      resolve("");
-    }, ms);
-  });
-  try {
-    return await Promise.race([settled, expiry]);
-  } finally {
-    if (timer !== undefined) clearTimeout(timer);
-  }
-}