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

package/dist/assembler-_F9urbPj.mjs

@@ -0,0 +1,409 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import z from "@deepseek-ai/schemastery";
+import { Service } from "@deepseek-ai/cordis";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { PERSONA_PREFIX_SECTION, PERSONA_SUFFIX_SECTION } from "@deepseek-ai/dsh-system-prompt";
+//#region src/assembler/reminder.ts
+const REMINDER_OPEN = "<system-reminder";
+const REMINDER_CLOSE = "</system-reminder>";
+/**
+* 覆盖规则在系统提示词里声明一次（见 [`rules.ts`](./rules.ts)），所以每条 reminder 只带 id 与正文，
+* 不再重复解释"最新一条覆盖更早的"。
+*/
+const RULES_SECTION = "assembler:rules";
+/**
+* 这条消息是不是通道注入的条目——判据是 source 里的幂等键，而不是 kind：接管上游那两面的条目
+* 用上游 kind（`agent-instructions` / `skill-catalog`），幂等必须照样认。
+*/
+function promptEntryIdOf(source) {
+	const id = source.id;
+	return typeof id === "string" ? id : void 0;
+}
+function escapeFrameBody(body) {
+	return body.replaceAll(REMINDER_CLOSE, "<\\/system-reminder>");
+}
+function escapeAttr(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;");
+}
+function renderReminder(id, body) {
+	return `${REMINDER_OPEN} id="${escapeAttr(id)}">\n${escapeFrameBody(body)}\n${REMINDER_CLOSE}`;
+}
+/**
+* 虚拟 skill（运行时注册、没有资源目录）的正文形态：只有 `<skill_instructions>`，
+* 不渲染上游 `renderSkillContent` 的 `<skill_resources>`（那段对虚拟 skill 是噪音）。
+*/
+function renderVirtualSkill(name, content) {
+	return [
+		`<skill_content name="${escapeAttr(name)}">`,
+		"<skill_instructions>",
+		content,
+		"</skill_instructions>",
+		"</skill_content>"
+	].join("\n");
+}
+/** surface 上最近一条该 id 的 reminder 原文（含信封）；没有则 undefined。 */
+function latestReminderText(agent, id) {
+	for (const seq of agent.session.surface.nodes.toReversed()) {
+		const event = agent.session.eventAt(seq);
+		if (event?.type !== "user/message") continue;
+		if (promptEntryIdOf(event.data.source) !== id) continue;
+		const [block] = event.data.content;
+		return event.data.content.length === 1 && block?.type === "text" ? block.text : "";
+	}
+}
+/**
+* 注入一条提醒：`text` 是已渲染好的完整正文（规则块或内容块），`key` 是它的幂等键。
+* `source` 声明这条消息对外的身份——接管上游那两面用上游 kind，我们自己的条目留默认。
+*/
+function reminderMessage(key, text, source) {
+	return createUserMessage({
+		content: [{
+			type: "text",
+			text
+		}],
+		source: {
+			...source ?? {
+				kind: "context-assembler",
+				form: "instructions"
+			},
+			id: key
+		}
+	});
+}
+//#endregion
+//#region src/assembler/channel.ts
+/**
+* 注入通道：调用方声明「什么内容、怎么到达模型」，这里负责到达方式。
+*
+* - `on-demand`：注册成模型可用 skill（进 skill 目录，正文按需加载）；
+* - `auto`：正文自动注入 reminder（注册成 skill 但标 `modelInvocable: false`，因为已经常驻）；
+* - `replaceSection` / `suppressSection`：装配结果上的文本改写与丢弃。
+*
+* 覆盖语义（同 id 最新取代更早）由系统提示词里的声明说明一次，见 [`rules.ts`](./rules.ts)。
+*/
+var ContextAssembler = class extends Service {
+	host;
+	declarations = /* @__PURE__ */ new Map();
+	rules = /* @__PURE__ */ new Map();
+	overrides = /* @__PURE__ */ new Map();
+	suppressed = /* @__PURE__ */ new Set();
+	skills = /* @__PURE__ */ new Map();
+	states = /* @__PURE__ */ new WeakMap();
+	/** 不要 instruction 类注入（规则块）的会话；内容块（技能正文、引用材料）不受它管。 */
+	withoutInstructions = /* @__PURE__ */ new WeakSet();
+	/** 本会话的模式收窄（白名单）：投影层的过滤不碰注册表，注册表上看不出"谁能用"。 */
+	toolScopes = /* @__PURE__ */ new WeakMap();
+	/** `host` 是构造期那个根 ctx：`skills` 的访问权限挂在插件的 inject 声明上，不能依赖访问者 ctx。 */
+	constructor(host) {
+		super(host, "contextAssembler");
+		this.host = host;
+	}
+	registerSkill(declaration) {
+		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) {
+		this.rules.set(declaration.id, declaration);
+		return () => {
+			if (this.rules.get(declaration.id) === declaration) this.rules.delete(declaration.id);
+		};
+	}
+	replaceSection(name, text) {
+		this.overrides.set(name, text);
+		return () => {
+			if (this.overrides.get(name) === text) this.overrides.delete(name);
+		};
+	}
+	suppressSection(name) {
+		this.suppressed.add(name);
+		return () => {
+			this.suppressed.delete(name);
+		};
+	}
+	isSuppressed(name) {
+		return this.suppressed.has(name);
+	}
+	/** 装配结果上该 section 要换成的文本；undefined 表示原样保留。 */
+	replacement(name, agent) {
+		const override = this.overrides.get(name);
+		return override === void 0 || agent === void 0 ? void 0 : override(agent);
+	}
+	/**
+	* 本步要注入的条目：键 → 已渲染好的正文（规则块或内容块）。
+	* `sections` 来自本步装配，`rules` 与 `auto` skill 正文在这里现算。
+	*/
+	/** 这个会话不要 instruction 类的规则块（模式说了 `instructions: false`）。 */
+	setInstructions(agent, on) {
+		if (on) this.withoutInstructions.delete(agent);
+		else this.withoutInstructions.add(agent);
+	}
+	/**
+	* 本会话的**工具收窄**（模式白名单）：投影层只过滤装配结果、不碰工具注册表，所以"谁能用"这件事
+	* 必须在通道上登记，技能目录与组正文才收得住。与 {@link setInstructions} 同形——谓词由模式那一行给
+	* （`context-scope`），通道自己不碰 `tools` 服务。
+	*/
+	restrictTools(agent, allowed) {
+		this.toolScopes.set(agent, allowed);
+	}
+	/**
+	* 本会话的工具可见性：调用方给出的注册表可见性 × 已登记的模式收窄。技能目录与组正文共用它，
+	* 免得同一套判据在几处各写一遍。
+	*/
+	visibleTools(agent, registered) {
+		const allowed = this.toolScopes.get(agent);
+		return allowed === void 0 ? registered : (tool) => registered(tool) && allowed(tool);
+	}
+	/**
+	* 该会话看不到的 skill 名：声明了 `requires` 而依赖的工具一个都不可见。
+	*
+	* 目录由 `context-skill-catalog` 渲染，它把工具可见性作为谓词传进来（通道不碰 tools 服务）。
+	*/
+	hiddenSkills(visible) {
+		const hidden = /* @__PURE__ */ new Set();
+		for (const [name, declaration] of this.declarations) {
+			const requires = declaration.requires;
+			if (requires === void 0 || requires.length === 0) continue;
+			if (!requires.some(visible)) hidden.add(name);
+		}
+		return hidden;
+	}
+	/**
+	* 该 skill 按会话修剪后的正文：注册表只能存一份（技能注册是装配期一次、全局可见），所以按需加载
+	* 路径（接管的 `skill` 工具）要用这里重新算一次，才和 `auto` 正文一样跟着工具走。
+	*/
+	contentFor(name, agent) {
+		return this.declarations.get(name)?.content(agent);
+	}
+	async collect(agent) {
+		const entries = /* @__PURE__ */ new Map();
+		for (const declaration of this.declarations.values()) {
+			if ((declaration.injection ?? "on-demand") !== "auto") 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);
+			if (text.length > 0) entries.set(declaration.id, {
+				text: renderReminder(declaration.id, text),
+				...declaration.source === void 0 ? {} : { source: declaration.source(agent) }
+			});
+		}
+		if (!instructionsOff) for (const [id, text] of this.sectionsOf(agent)) entries.set(id, { text: renderReminder(id, text) });
+		return entries;
+	}
+	sectionsOf(agent) {
+		return this.states.get(agent)?.sections ?? /* @__PURE__ */ new Map();
+	}
+	/**
+	* 每步装配调一次：记下本步降级出来的 section 文本，供下一步注入。
+	*/
+	sync(agent, input) {
+		this.stateOf(agent).sections = input.sections;
+	}
+	/** skill 注册（装配期一次，全局可见）：正文没变的不重注册。 */
+	refreshSkills(agent) {
+		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);
+		}
+	}
+	stateOf(agent) {
+		const existing = this.states.get(agent);
+		if (existing !== void 0) return existing;
+		const state = { sections: /* @__PURE__ */ new Map() };
+		this.states.set(agent, state);
+		return state;
+	}
+};
+/** 一条注入内容的取用上限：超过就按"没有内容"处理，不阻塞这一轮请求。 */
+const CONTENT_TIMEOUT_MS = 2e3;
+async function withTimeout(work, ms) {
+	if (typeof work === "string") return work;
+	const settled = Promise.resolve(work).catch(() => "");
+	let timer;
+	const expiry = new Promise((resolve) => {
+		timer = setTimeout(() => {
+			resolve("");
+		}, ms);
+	});
+	try {
+		return await Promise.race([settled, expiry]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+//#endregion
+//#region src/assembler/defaults.ts
+/**
+* 留在系统提示词里的 section：部署级 persona（子 agent 在 agent 作用域注册的同名 persona 也命中）
+* 与覆盖规则声明（[`rules.ts`](./rules.ts)）。
+*/
+const DEFAULT_KEEP = [
+	PERSONA_PREFIX_SECTION,
+	PERSONA_SUFFIX_SECTION,
+	RULES_SECTION
+];
+/**
+* 不进提示词的 section。三类：
+*
+* 1. **harness 自带的开场白与平台运维说明**：`harness:identity`（"You are an AI agent powered by
+*    DeepSeek Harness."——身份由各模式的 persona 给，这句话在本部署里是噪音，且是英文）、
+*    `harness:source`（讲 dev server / HMR / 本地 checkout 位置）；
+* 2. 本部署不装配的工具的用法说明：`tool:lsp` / `tool:pty` / `tool:session-query` / `tool:cordis` /
+*    `tool:ralph`；
+* 3. `app:web-surface`（平台外壳说明）。
+*
+* 其余工具说明由各组的 `drops` 摘掉、要点由 toolkit 的 `guidance` 出口写进组正文，不在这一份里。
+*/
+const DEFAULT_SUPPRESS = [
+	"harness:identity",
+	"harness:source",
+	"app:web-surface",
+	"tool:lsp",
+	"tool:pty",
+	"tool:session-query",
+	"tool:cordis",
+	"tool:ralph"
+];
+/**
+* 改写成中文的两段上游说明（内容忠实原意）：`@` 引用路径的语义、输出里的文件链接规范。
+*
+* 这两段注册在 agent 层（`context:file-reference`）与 host 层（`ui:deliverable-file-references`），
+* 注册层不归我们——所以在装配结果上换文本（不移除：内容要保留）。
+*/
+const DEFAULT_REPLACE = {
+	"context:file-reference": "以 @ 开头的词是用户显式引用的工作区路径，相对于工作区根。结尾带斜杠表示目录：需要时列目录内容。其余是文件：需要内容时用 read 工具读取，不要在读取前声称自己已经看过。用 @\"...\" 括住含空格的路径。",
+	"ui:deliverable-file-references": "成功创建或修改文件后，在最终回复里点明主要产物。除命令、配置表达式与代码块之外，每处提到已存在的文件都要链到它的完整路径（相对工作目录或绝对路径）；已知行号时在目标后加 `#L24` 或 `#L24-L30`。链接文本用文件名或清晰别名，只加够区分的父目录，不要把完整路径放进标签；默认只用文件名，需要精确位置时在标签后接 `:24` 或 `:24–30`（不带 `#` 或 `L`）。"
+};
+//#endregion
+//#region src/assembler/rules.ts
+/**
+* 覆盖规则的声明文本：写进**系统提示词**（不在 reminder 里重复），所以每条 reminder 只带 id 与正文。
+*
+* 为什么放系统提示词而不是首条 reminder：它是固定文本（不随会话变，不付缓存代价），而且放在这里
+* 才是系统级规则该在的位置——首条 reminder 自身会被压缩、被覆盖，权威性更低。
+*/
+const RULES_TEXT = ["带 id 的 system-reminder 块是本系统提示词的一部分，持续有效：同 id 只有最新一条生效并取代更早的，不同 id 互不影响。", "skill_content 是要遵循的技能说明（随提示送来的与你后来加载的一样），file_content 是本步引用的文件内容。"].join("");
+//#endregion
+//#region src/assembler/index.ts
+var assembler_exports = /* @__PURE__ */ __exportAll({
+	Config: () => Config,
+	ContextAssembler: () => ContextAssembler,
+	DEFAULT_KEEP: () => DEFAULT_KEEP,
+	DEFAULT_REPLACE: () => DEFAULT_REPLACE,
+	DEFAULT_SUPPRESS: () => DEFAULT_SUPPRESS,
+	apply: () => apply,
+	inject: () => inject,
+	name: () => name,
+	renderVirtualSkill: () => renderVirtualSkill
+});
+const name = "context-assembler";
+/** 规则声明的位置：紧跟部署 persona（order 0），在任何降级内容之前。 */
+const RULES_ORDER = 1;
+const inject = ["systemPrompt", "skills"];
+const Config = z.object({
+	keep: z.array(z.string()).default([...DEFAULT_KEEP]),
+	suppress: z.array(z.string()).default([...DEFAULT_SUPPRESS]),
+	replace: z.dict(z.string()).default({ ...DEFAULT_REPLACE })
+});
+/**
+* 提示词注入的唯一通道：system prompt 里只留 `keep`，其余内容按声明的方式到达模型——
+* 降级为紧随用户消息的 reminder、或直接丢弃（写进按需 skill 正文是调用方自己的事）。
+*/
+function apply(ctx, config) {
+	const channel = new ContextAssembler(ctx);
+	const keep = new Set(config.keep ?? DEFAULT_KEEP);
+	for (const name of config.suppress ?? DEFAULT_SUPPRESS) channel.suppressSection(name);
+	for (const [name, text] of Object.entries(config.replace ?? DEFAULT_REPLACE)) channel.replaceSection(name, () => text);
+	ctx.systemPrompt.section({
+		name: RULES_SECTION,
+		order: RULES_ORDER,
+		text: RULES_TEXT
+	});
+	ctx.on("system-prompt/assemble", async (_assembly, context, next) => {
+		const result = await next();
+		const agent = context.agent;
+		const demoted = /* @__PURE__ */ new Map();
+		const sections = [];
+		let changed = false;
+		for (const section of result.sections) {
+			if (channel.isSuppressed(section.name)) {
+				changed = true;
+				continue;
+			}
+			const text = channel.replacement(section.name, agent) ?? section.text;
+			if (text !== section.text) changed = true;
+			if (keep.has(section.name) || text.length === 0) {
+				sections.push(text === section.text ? section : {
+					...section,
+					text
+				});
+				continue;
+			}
+			changed = true;
+			demoted.set(sectionId(section.name), text);
+		}
+		if (agent !== void 0) channel.sync(agent, { sections: demoted });
+		return changed ? {
+			...result,
+			sections
+		} : result;
+	});
+	ctx.on("agent/pre-step", async ({ agent, messages }, next) => {
+		const decision = await next();
+		if (decision.kind === "reject" || decision.messages.length === 0) return decision;
+		const pending = await pendingEntries(agent, channel);
+		if (pending.length === 0) return decision;
+		const claimedEnd = decision.messages.findLastIndex((message) => messages.includes(message));
+		return {
+			...decision,
+			messages: decision.messages.toSpliced(claimedEnd + 1, 0, ...pending.map(([key, entry]) => reminderMessage(key, entry.text, entry.source)))
+		};
+	});
+	ctx.on("agent/request-error", async ({ agent, signal }, next) => {
+		const action = await next();
+		if (action?.kind !== "retry" || signal.aborted) return action;
+		for (const [key, entry] of await pendingEntries(agent, channel)) agent.session.append("user/message", reminderMessage(key, entry.text, entry.source), { surfaceOp: "append" });
+		return action;
+	}, { prepend: true });
+}
+/** 降级 section 的条目 id：一条 section 一个 id，于是同一次变化只重发那一条。 */
+function sectionId(name) {
+	return `section:${name}`;
+}
+/** 本步要注入的条目：键相同且文本未变就不注入，按键字典序（顺序不随注册顺序抖动）。 */
+async function pendingEntries(agent, channel) {
+	return [...await channel.collect(agent)].filter(([key, entry]) => latestReminderText(agent, key) !== entry.text).toSorted(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+}
+//#endregion
+export { name as a, DEFAULT_SUPPRESS as c, inject as i, ContextAssembler as l, apply as n, DEFAULT_KEEP as o, assembler_exports as r, DEFAULT_REPLACE as s, Config as t, renderVirtualSkill as u };

package/dist/assembler.d.mts

@@ -0,0 +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";
+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

@@ -0,0 +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";
+export { Config, ContextAssembler, DEFAULT_KEEP, DEFAULT_REPLACE, DEFAULT_SUPPRESS, apply, inject, name, renderVirtualSkill };

package/dist/index-BGkeEaQA.d.mts

@@ -0,0 +1,196 @@
+import z from "@deepseek-ai/schemastery";
+import { Context, Service } from "@deepseek-ai/cordis";
+import { MessageSource } from "@deepseek-ai/dsh-llm";
+import { Agent } from "@deepseek-ai/dsh-agent";
+import "@deepseek-ai/dsh-session";
+//#region src/assembler/defaults.d.ts
+/**
+ * 留在系统提示词里的 section：部署级 persona（子 agent 在 agent 作用域注册的同名 persona 也命中）
+ * 与覆盖规则声明（[`rules.ts`](./rules.ts)）。
+ */
+declare const DEFAULT_KEEP: readonly string[];
+/**
+ * 不进提示词的 section。三类：
+ *
+ * 1. **harness 自带的开场白与平台运维说明**：`harness:identity`（"You are an AI agent powered by
+ *    DeepSeek Harness."——身份由各模式的 persona 给，这句话在本部署里是噪音，且是英文）、
+ *    `harness:source`（讲 dev server / HMR / 本地 checkout 位置）；
+ * 2. 本部署不装配的工具的用法说明：`tool:lsp` / `tool:pty` / `tool:session-query` / `tool:cordis` /
+ *    `tool:ralph`；
+ * 3. `app:web-surface`（平台外壳说明）。
+ *
+ * 其余工具说明由各组的 `drops` 摘掉、要点由 toolkit 的 `guidance` 出口写进组正文，不在这一份里。
+ */
+declare const DEFAULT_SUPPRESS: readonly string[];
+/**
+ * 改写成中文的两段上游说明（内容忠实原意）：`@` 引用路径的语义、输出里的文件链接规范。
+ *
+ * 这两段注册在 agent 层（`context:file-reference`）与 host 层（`ui:deliverable-file-references`），
+ * 注册层不归我们——所以在装配结果上换文本（不移除：内容要保留）。
+ */
+declare const DEFAULT_REPLACE: Readonly<Record<string, string>>;
+//#endregion
+//#region src/assembler/channel.d.ts
+/** 正文到达模型的方式：自动注入，或等模型按需加载。 */
+type InjectionMode = "auto" | "on-demand";
+/**
+ * 一条按 skill 形态声明的注入：正文是本仓库维护的文案。
+ *
+ * 正文与 agent 无关（工具集在装配期就定了），所以 skill 在装配期注册一次、全局可见。
+ */
+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;
+}
+/**
+ * 一条规则块声明：系统级信息（工作区指令、skill 目录），文本按 id 幂等注入、同 id 覆盖。
+ * 文本可以是异步的（skill 目录要读 skill 注册表）。
+ */
+interface PromptRuleDeclaration {
+  readonly id: string;
+  readonly text: (agent: Agent) => string | Promise<string>;
+  /**
+   * 这条规则的对外身份。接管上游那两面（工作区指令 / skill 目录）按上游 kind 发消息，好让按 kind 认领的
+   * 消费方（客户端标签、上游的实验性约束收集）认得出来；不声明就是通道自己的 `context-assembler`。
+   * 幂等键仍是 `id`（`reminderMessage` 会把它塞进 source）。
+   */
+  readonly source?: (agent: Agent) => MessageSource;
+}
+/** 一条待注入的条目：正文已渲染好，`source` 是它声明给外部的身份。 */
+interface PromptEntry {
+  readonly text: string;
+  readonly source?: MessageSource;
+}
+/**
+ * 注入通道：调用方声明「什么内容、怎么到达模型」，这里负责到达方式。
+ *
+ * - `on-demand`：注册成模型可用 skill（进 skill 目录，正文按需加载）；
+ * - `auto`：正文自动注入 reminder（注册成 skill 但标 `modelInvocable: false`，因为已经常驻）；
+ * - `replaceSection` / `suppressSection`：装配结果上的文本改写与丢弃。
+ *
+ * 覆盖语义（同 id 最新取代更早）由系统提示词里的声明说明一次，见 [`rules.ts`](./rules.ts)。
+ */
+declare class ContextAssembler extends Service {
+  private readonly host;
+  private readonly declarations;
+  private readonly rules;
+  private readonly overrides;
+  private readonly suppressed;
+  private readonly skills;
+  private readonly states;
+  /** 不要 instruction 类注入（规则块）的会话；内容块（技能正文、引用材料）不受它管。 */
+  private readonly withoutInstructions;
+  /** 本会话的模式收窄（白名单）：投影层的过滤不碰注册表，注册表上看不出"谁能用"。 */
+  private readonly toolScopes;
+  /** `host` 是构造期那个根 ctx：`skills` 的访问权限挂在插件的 inject 声明上，不能依赖访问者 ctx。 */
+  constructor(host: Context);
+  registerSkill(declaration: PromptSkillDeclaration): () => void;
+  registerRule(declaration: PromptRuleDeclaration): () => void;
+  replaceSection(name: string, text: (agent: Agent) => string | undefined): () => void;
+  suppressSection(name: string): () => void;
+  isSuppressed(name: string): boolean;
+  /** 装配结果上该 section 要换成的文本；undefined 表示原样保留。 */
+  replacement(name: string, agent: Agent | undefined): string | undefined;
+  /**
+   * 本步要注入的条目：键 → 已渲染好的正文（规则块或内容块）。
+   * `sections` 来自本步装配，`rules` 与 `auto` skill 正文在这里现算。
+   */
+  /** 这个会话不要 instruction 类的规则块（模式说了 `instructions: false`）。 */
+  setInstructions(agent: Agent, on: boolean): void;
+  /**
+   * 本会话的**工具收窄**（模式白名单）：投影层只过滤装配结果、不碰工具注册表，所以"谁能用"这件事
+   * 必须在通道上登记，技能目录与组正文才收得住。与 {@link setInstructions} 同形——谓词由模式那一行给
+   * （`context-scope`），通道自己不碰 `tools` 服务。
+   */
+  restrictTools(agent: Agent, allowed: (tool: string) => boolean): void;
+  /**
+   * 本会话的工具可见性：调用方给出的注册表可见性 × 已登记的模式收窄。技能目录与组正文共用它，
+   * 免得同一套判据在几处各写一遍。
+   */
+  visibleTools(agent: Agent, registered: (tool: string) => boolean): (tool: string) => boolean;
+  /**
+   * 该会话看不到的 skill 名：声明了 `requires` 而依赖的工具一个都不可见。
+   *
+   * 目录由 `context-skill-catalog` 渲染，它把工具可见性作为谓词传进来（通道不碰 tools 服务）。
+   */
+  hiddenSkills(visible: (tool: string) => boolean): ReadonlySet<string>;
+  /**
+   * 该 skill 按会话修剪后的正文：注册表只能存一份（技能注册是装配期一次、全局可见），所以按需加载
+   * 路径（接管的 `skill` 工具）要用这里重新算一次，才和 `auto` 正文一样跟着工具走。
+   */
+  contentFor(name: string, agent: Agent | undefined): string | undefined;
+  collect(agent: Agent): Promise<Map<string, PromptEntry>>;
+  private sectionsOf;
+  /**
+   * 每步装配调一次：记下本步降级出来的 section 文本，供下一步注入。
+   */
+  sync(agent: Agent, input: {
+    readonly sections: ReadonlyMap<string, string>;
+  }): void;
+  /** skill 注册（装配期一次，全局可见）：正文没变的不重注册。 */
+  private refreshSkills;
+  private stateOf;
+}
+declare module "@deepseek-ai/cordis" {
+  interface Context {
+    contextAssembler: ContextAssembler;
+  }
+}
+//#endregion
+//#region src/assembler/reminder.d.ts
+/** 通道自己的条目形态（注入方没声明 source 时的默认）：规则块，幂等键是 id。 */
+interface PromptReminderSource {
+  kind: "context-assembler";
+  form: "instructions";
+  /** 条目 id：同 id 的最新一条取代更早的同 id 条目。本插件早先落库的消息没有它。 */
+  id?: string;
+}
+declare module "@deepseek-ai/dsh-llm" {
+  interface MessageSourceMap {
+    "context-assembler": PromptReminderSource;
+  }
+}
+/**
+ * 虚拟 skill（运行时注册、没有资源目录）的正文形态：只有 `<skill_instructions>`，
+ * 不渲染上游 `renderSkillContent` 的 `<skill_resources>`（那段对虚拟 skill 是噪音）。
+ */
+declare function renderVirtualSkill(name: string, content: string): string;
+declare namespace index_d_exports {
+  export { Config, ContextAssembler, DEFAULT_KEEP, DEFAULT_REPLACE, DEFAULT_SUPPRESS, InjectionMode, PromptEntry, PromptRuleDeclaration, PromptSkillDeclaration, apply, inject, name, renderVirtualSkill };
+}
+declare const name = "context-assembler";
+declare const inject: string[];
+interface Config {
+  /** 留在系统提示词里的 section 名；其余非空 section 降级为 reminder。 */
+  keep?: string[];
+  /** 不进提示词的 section 名（部署级噪音）。 */
+  suppress?: string[];
+  /** 装配结果上改写的 section 文本（section 名 → 中文文案）。 */
+  replace?: Record<string, string>;
+}
+declare const Config: z<Config>;
+/**
+ * 提示词注入的唯一通道：system prompt 里只留 `keep`，其余内容按声明的方式到达模型——
+ * 降级为紧随用户消息的 reminder、或直接丢弃（写进按需 skill 正文是调用方自己的事）。
+ */
+declare function apply(ctx: Context, config: Config): void;
+//#endregion
+export { name as a, InjectionMode as c, PromptSkillDeclaration as d, DEFAULT_KEEP as f, inject as i, PromptEntry as l, DEFAULT_SUPPRESS as m, apply as n, renderVirtualSkill as o, DEFAULT_REPLACE as p, index_d_exports as r, ContextAssembler as s, Config as t, PromptRuleDeclaration as u };

package/dist/index.d.mts

@@ -0,0 +1,25 @@
+import { t as index_d_exports } from "./agent-instructions.mjs";
+import { r as index_d_exports$1 } from "./index-BGkeEaQA.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";
+import { Context } from "@deepseek-ai/cordis";
+//#region src/index.d.ts
+declare const name = "context-assembler-tree";
+declare const CAPABILITIES: {
+  readonly assembler: typeof index_d_exports$1;
+  readonly "agent-instructions": typeof index_d_exports;
+  readonly "skill-catalog": typeof index_d_exports$3;
+  readonly scope: typeof index_d_exports$2;
+};
+type Capability = keyof typeof CAPABILITIES;
+interface Config {
+  /** 装哪些能力（名字即子出口名）；缺省全部——标准模式要完整的一套。未知名字在装载时报错。 */
+  capabilities?: string[];
+  /** 各能力自己的 config，按能力名给（例如 `{ scope: { allowTools: [...] } }`）。 */
+  options?: Record<string, Record<string, unknown>>;
+}
+declare const Config: z<Config>;
+declare function apply(ctx: Context, config: Config): void;
+//#endregion
+export { Capability, Config, apply, name };

package/dist/index.mjs

@@ -0,0 +1,29 @@
+import { n as agent_instructions_exports } from "./agent-instructions-BNEiZl0P.mjs";
+import { r as assembler_exports } from "./assembler-_F9urbPj.mjs";
+import { a as scope_exports } from "./scope-CI-fNq5A.mjs";
+import { t as skill_catalog_exports } from "./skill-catalog.mjs";
+import z from "@deepseek-ai/schemastery";
+//#region src/index.ts
+const name = "context-assembler-tree";
+const CAPABILITIES = {
+	assembler: assembler_exports,
+	"agent-instructions": agent_instructions_exports,
+	"skill-catalog": skill_catalog_exports,
+	scope: scope_exports
+};
+const CAPABILITY_NAMES = Object.keys(CAPABILITIES);
+const Config = z.object({
+	capabilities: z.array(z.string()).default([...CAPABILITY_NAMES]),
+	options: z.any().default({})
+});
+function apply(ctx, config) {
+	const wanted = config.capabilities ?? CAPABILITY_NAMES;
+	const options = config.options ?? {};
+	for (const name of wanted) {
+		const capability = CAPABILITIES[name];
+		if (capability === void 0) throw new Error(`context: unknown capability "${name}"（可选：${CAPABILITY_NAMES.join(" / ")}）`);
+		ctx.plugin(capability, options[name] ?? {});
+	}
+}
+//#endregion
+export { Config, apply, name };