@morlay/dsh-context-assembler 0.0.2 → 0.0.3

package/README.md

@@ -1,181 +1,36 @@
 # @morlay/dsh-context-assembler
 
-提示词注入能力组：**一个包四个能力**——主出口是组装插件（所以装配面只有一行），各能力另有子出口可单独装；
-能力名就是子出口名。装配行是 `@morlay/dsh-context-assembler`（组装）或 `@morlay/dsh-context-assembler/<capability>`（单个），
-见 [`src/rows.ts` 的 `contextChannel()`](./src/rows.ts)。引用展开原先也在这个包里，
-现在独立成 [`@morlay/dsh-reference`](../dsh-reference/README.md)（它只挂 `agent/pre-step`、不依赖通道）。
+提示词通道：**装配结果上的文本转换**（`replace` / `suppress`）与**降级 section 的按步送达**（本步没留在系统提示词
+里的 section 改以 reminder 紧随用户消息送达，压缩后的重试再补投一次）。**不给扩展点**：没有注册面，也不接管任何
+"面"——工作区指令与技能目录用官方行（`@deepseek-ai/dsh-agent-instructions` / `@deepseek-ai/dsh-tool-skill`）自己的
+注入方式。按会话的工具收口与三个注入开关（`instructions` / 技能目录 / 动态快照）**不在本包**：收口的输入是模式定义、
+唯一消费者也是模式，所以它住在 [`@morlay/dsh-session-mode`](../../profile/dsh-session-mode/README.md)。
 
-| 出口                   | 行 id / 插件 name                                         | 做什么                                                                       |
-| ---------------------- | --------------------------------------------------------- | ---------------------------------------------------------------------------- |
-| `.`                    | `context-assembler`（插件 name `context-assembler-tree`） | **组装出口**：按 config 决定装哪些能力、各带什么参数（缺省即四套能力）       |
-| `./assembler`          | `context-assembler`                                       | 注入通道：唯一渲染者与唯一覆盖判定处，发布 `ctx.contextAssembler`            |
-| `./agent-instructions` | `context-agent-instructions`                              | 工作区指令链（`$DSH_HOME/AGENTS.md` + 项目根到 cwd 逐级）                    |
-| `./skill-catalog`      | `context-skill-catalog`                                   | skill 目录规则块 + 模型侧 `skill` 工具                                       |
-| `./scope`              | `context-assembler-scope`                                 | 按会话收口：工具白名单、instruction 总开关、动态快照开关（模式把定义推给它） |
+## 用法
 
-规则、id 表与分层的 home 在 [上下文注入规则](./.agents/designs/20260921-上下文注入规则.md)；术语见
-[本包 CONTEXT](./.agents/CONTEXT.md)。
-
-## 装配
-
-`dsh.profile.bundles` 列出本包即装**一次**：`cordis.patch.yml` 是一行组装出口（显式给三项能力：通道本体、
-`agent-instructions`、`skill-catalog`；config 的 `capabilities` 缺省是全部四项）。**不做隔离**——工具说明
-（[`@morlay/dsh-agent-toolkit`](../../profile/dsh-agent-toolkit/README.md) 的 `guidance`）这类消费者住在别的包里，
-隔离会把它们挡在组外（行停在 waiting，不报错）；理由见
-[ADR 通道作为全局服务装配不隔离](./.agents/adrs/20260923-通道作为全局服务装配不隔离.md)。`scope` **不在这份 patch 里**
-——它是模式那一层的收口行，由 [`@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` 由 [`src/rows.ts`](./src/rows.ts) 从 [`src/rows.ts`](./src/rows.ts) 渲染，
-`rows` 出口导出同一份清单。`dsh.profile.bundles` 列出本包即装一次，**服务全局共享、不隔离**；模式的收口是
-另一行（`scopeRow()`：工具白名单 / instruction / 动态快照），别的包的行（工具说明、skill 目录）直接 `inject`
-同一份通道。
-
-## 为什么合成一个包
-
-这 4 个能力**总是一起装配**（通道在装配平面装一份、不隔离：注入方住在别的包里，隔离会把它们挡在组外），
-注入方**全都只用通道的类型与服务面**。包边界在这里只是演进留下的：合成一个包之后，加一个能力 = 加一个子出口，装配面不动
-（组装出口按 config 装它）。
-
-工具说明（汉化精简 + 用法分组）也不住在这里：它管的是"工具怎么被讲清楚"，与工具的清单同源，
-现在归 [`@morlay/dsh-agent-toolkit`](../../profile/dsh-agent-toolkit/README.md)（它也 `inject` 通道，装的是同一份
-全局通道）。本包只做上下文重排。
-
-引用展开不住在这里：它不依赖 `ctx.contextAssembler`（`inject` 只有 `skills`），也没有「读文件 + 字节预算」
-以外与组装出口共享的东西，所以独立成包、由 [`@morlay/better-session`](../../bundles/better-session/cordis.patch.yml)
-装配（见 [ADR-引用展开拆成独立包](../../../.agents/adrs/20260923-引用展开拆成独立包并按profile装配.md)）。
-
-**每个出口仍是独立的 cordis 插件**（各自的 `apply` 与 `inject`）——这一点是硬要求：合成单入口会让 `inject`
-变成并集（`agents, contextAssembler, skills, systemPrompt, tools`），任何一个可选搭档缺席都拖垮整包。
-
-## assembler
-
-注入的唯一通道。system prompt 里只留 `keep`（部署 persona + 覆盖规则），其余 section 按处置分流：丢弃
-（平台说明）、改写（两段中文文案）、或降级成规则块；pre-step 时把要送的内容逐条以 `<system-reminder>`
-user 消息注入（每条按文本幂等，只有变化的那条重发）。
-
-| 声明                                  | 到达方式                                                                         |
-| ------------------------------------- | -------------------------------------------------------------------------------- |
-| `registerSkill` + `on-demand`         | 注册成模型可用 skill：目录常驻一行摘要，正文由 `skill` 工具加载                  |
-| `registerSkill` + `auto`              | 正文随 reminder 常驻；skill 标 `modelInvocable: false`（用户仍可 `skill:` 引用） |
-| `registerRule({ id, text, source? })` | 规则块，幂等键是 `id`；`source` 声明对外身份                                     |
-| `replaceSection` / `suppressSection`  | 装配结果上的文本改写 / 丢弃                                                      |
-| `setInstructions` / `restrictTools`   | 按会话登记模式的两处收口（不要 instruction / 工具白名单）                        |
-| `visibleTools(agent, registered)`     | 合成该会话的工具可见性：注册表可见 × 已登记的白名单（目录与组正文共用）          |
-| `hiddenSkills(visible)`               | 声明了 `requires` 而入口工具一个都不可见的 skill 名                              |
-
-配置（`keep` / `suppress` / `replace`）的默认值在 [`src/assembler/defaults.ts`](./src/assembler/defaults.ts)。
-**全局一份、不隔离**：模式差异由 `context-assembler-scope` 登记（`setInstructions` / `restrictTools`）收口，跨包的
-消费者（工具说明、技能目录）直接 `inject` 同一份通道（见
-[ADR 通道作为全局服务装配不隔离](./.agents/adrs/20260923-通道作为全局服务装配不隔离.md)）。
-
-## agent-instructions
-
-`$DSH_HOME/AGENTS.md` 加项目根到 cwd 的逐级 `AGENTS.md` / `AGENTS.local.md`，**一条文件一条 id**
-（`agent-instructions:<根标识>:<文件>`，根标识是根目录的 8 位摘要——同进程两个项目根的同名文件因此不会互相
-顶掉），文件变化时只重发变了的那一份。取代上游 `@deepseek-ai/dsh-agent-instructions`（host 那行由上游
-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` 逐字相等）。上游的认领判据只看本步 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 不进目录（正文已随提示送达）。
-
-**这一面归通道**（工作区指令那一面相反，是让位）：`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)。
-
-## 工具说明（不在这个包里）
-
-工具的汉化精简与用法分组归 [`@morlay/dsh-agent-toolkit`](../../profile/dsh-agent-toolkit/README.md) 的 `guidance` 出口：
-族索引（加一个工具改一族）、组 skill、短描述投影、丢弃清单都在那边。它 `inject` 通道，装的是同一份全局通道
-——本包只提供它们要用的通道，不碰工具怎么讲。
-
-## scope
-
-按会话收口的出口（行 id `context-assembler-scope`）：工具白名单（装配期投影 + 执行层 guard + 与工具同源的
-`tool:<工具名>` 说明 section，三侧同判据）、`instructions`（关掉一切 instruction 类送达：常驻组正文、规则块
-与降级 section；按需 skill 与 `@` 引用材料不受它管）、`runtimeContext`
-（关掉沙箱 / 审批那两条动态快照，按 scope 抑制）。
-
-**定义由消费方推给它**，它自己不认识"模式"：`ctx.sessionToolScope.apply(agent, mode)` 是唯一入口，落在该
-agent 的 `ctx` 上（抑制器、guard 都在那里），同一个 agent 再 apply 一次就是换一份——旧的 effect 树收回、按新
-的装一遍。它解决的是"模式只能决定加什么、管不了 host 平面"：`dsh.profile.bundles` 打开的包（工具行、
-实验性的 Agent Teams）在 host 平面插行，对所有会话一视同仁；模式要表达"我只有这几个工具、一条提示词都不要"
-时，唯一与来源无关的做法是在会话语义上收口。
-
-白名单同时登记给通道（`restrictTools`）：技能目录与用法组正文按 `visibleTools` 收口，所以被收窄的工具既不在
-目录、也不会被讲——注册表里"装着"不等于这个会话"能用"。
-
-## 装配
-
-**profile 平面**：`dsh.profile.bundles` 列出本包即装一次，`cordis.patch.yml` 就是一行组装出口：
+装配面只有一行：包根（`@morlay/dsh-context-assembler`）就是通道本体，config 是 `keep` / `suppress` / `replace` 的
+缺省。行清单的真源是 [`src/rows.ts`](./src/rows.ts)（`contextChannel()`，经 `./rows` 出口供装配层引用），本部署把它
+渲染进 [`@morlay/session-mode-profile`](../../bundles/session-mode-profile/cordis.patch.yml) 的 patch：
 
 ```yaml
 - insert:
     - id: context-assembler
       name: "@morlay/dsh-context-assembler"
-      config:
-        capabilities: [assembler, agent-instructions, skill-catalog]
-```
-
-**模式平面**：收口那一行（不带 config——模式定义在 `session-mode` 行的 `config.modes` 里）由
-[`@morlay/dsh-session-mode`](../../profile/dsh-session-mode/README.md) 的 patch 装，通道由 profile 那份共享：
-
-```yaml
-- id: context-assembler-scope
-  name: "@morlay/dsh-context-assembler/scope"
 ```
 
-几点硬要求：
+| 出口     | 行 id / 插件 name         | 做什么                                                                                                                           |
+| -------- | ------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
+| `.`      | `context-assembler`       | 通道本体：装配结果上的文本转换 + 降级 section 的按步送达，发布 `ctx.contextAssembler`；config 是 `keep` / `suppress` / `replace` |
+| `./rows` | —（不是插件，只出那一行） | `contextChannel()`，装配层据此渲染 patch                                                                                         |
 
-- **每个能力仍是独立的 cordis 插件**（组装出口只是 `ctx.plugin()` 装它们），各自带自己的 `inject`；合成单入口会让
-  `inject` 变并集，一个可选搭档缺席就拖垮整包。
-- **通道不做隔离**：消费者跨包（`@morlay/dsh-agent-toolkit` 的工具说明、本包的技能目录），隔离会把它们挡在组外
-  （行停在 waiting）；模式差异改由 `context-assembler-scope` 登记给通道，见
-  [ADR 通道作为全局服务装配不隔离](./.agents/adrs/20260923-通道作为全局服务装配不隔离.md)。真装配的判据是
-  `pnpm exec tsx packages/desktop/dsh-desktop-host/tool/verify-session-mode.mts`（装配层可见一份、收口行装上、
-  官方 agent preset 不在）。
-- **子出口仍可单独装配**（`@morlay/dsh-context-assembler/assembler` 等）：同一些插件，只是默认走组装出口。
+**通道全局一份、不隔离**：消费者（[`@morlay/dsh-tool-guidance` 的包根](../../profile/dsh-tool-guidance/README.md)，
+以及把 `instructions` 开关拨过来的 `dsh-session-mode` 收口）住在别的包里，隔离会让它们解析不到服务（行停在 waiting，
+不报错）。模式差异不在通道上表达：通道只认按 agent 推来的那一个开关（`setInstructions`），收口与模式定义都在
+`@morlay/dsh-session-mode` 里。
 
-## 维护注意
+工具说明（汉化精简 + 用法分组）不在这个包里：它归 [`@morlay/dsh-tool-guidance`](../../profile/dsh-tool-guidance/README.md)
+（包根即运行时），对通道的依赖只剩 `suppressSection` 一处；引用展开也是独立包
+[`@morlay/dsh-reference`](../dsh-reference/README.md)（它不依赖通道服务）。
 
-- 测试落点在 `src/__tests__/<capability>/`（根 vitest 的 include 是 `packages/**/src/__tests__/**`，所以不能
-  按能力就近放 `src/<capability>/__tests__/`）。
-- 读上游文件的覆盖性测试用 `process.cwd()`（vitest 从仓库根跑），不要按文件深度算相对路径。
-- 新增一个能力：加 `src/<capability>/`，再把它登记进 `src/index.ts` 的 `CAPABILITIES`（子出口与 tsdown 入口一起加）；装配面不动。
+规则与 id 见[设计 上下文注入规则](./.agents/designs/20260921-上下文注入规则.md)；本包留什么、三份默认清单的归属见
+[设计 通道只做转换](./.agents/designs/20260929-通道只做转换.md)。

package/dist/index.d.mts

@@ -1,25 +1,45 @@
-import { t as index_d_exports } from "./agent-instructions.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";
-import { Context } from "@deepseek-ai/cordis";
+import { Context, Service } from "@deepseek-ai/cordis";
+import { Agent } from "@deepseek-ai/dsh-agent";
+//#region src/defaults.d.ts
+declare const DEFAULT_KEEP: readonly string[];
+declare const DEFAULT_SUPPRESS: readonly string[];
+declare const DEFAULT_REPLACE: Readonly<Record<string, string>>;
+//#endregion
+//#region src/channel.d.ts
+declare class ContextAssembler extends Service {
+  private readonly replacements;
+  private readonly suppressed;
+  private readonly states;
+  private readonly withoutInstructions;
+  constructor(ctx: Context);
+  replaceSection(name: string, text: string): () => void;
+  suppressSection(name: string): () => void;
+  isSuppressed(name: string): boolean;
+  replacement(name: string): string | undefined;
+  setInstructions(agent: Agent, on: boolean): void;
+  collect(agent: Agent): Map<string, string>;
+  private sectionsOf;
+  sync(agent: Agent, input: {
+    readonly sections: ReadonlyMap<string, string>;
+  }): void;
+  private stateOf;
+}
+declare module "@deepseek-ai/cordis" {
+  interface Context {
+    contextAssembler: ContextAssembler;
+  }
+}
+//#endregion
 //#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;
+declare const name = "context-assembler";
+declare const inject: string[];
 interface Config {
-  /** 装哪些能力（名字即子出口名）；缺省全部——标准模式要完整的一套。未知名字在装载时报错。 */
-  capabilities?: string[];
-  /** 各能力自己的 config，按能力名给（例如 `{ scope: { allowTools: [...] } }`）。 */
-  options?: Record<string, Record<string, unknown>>;
+  keep?: string[];
+  suppress?: string[];
+  replace?: Record<string, string>;
 }
 declare const Config: z<Config>;
 declare function apply(ctx: Context, config: Config): void;
 //#endregion
-export { Capability, Config, apply, name };
+export { Config, ContextAssembler, DEFAULT_KEEP, DEFAULT_REPLACE, DEFAULT_SUPPRESS, apply, inject, name };

package/dist/index.mjs

@@ -1,29 +1,194 @@
-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";
-//#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
+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/reminder.ts
+const REMINDER_OPEN = "<system-reminder";
+const REMINDER_CLOSE = "</system-reminder>";
+const RULES_SECTION = "assembler:rules";
+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}`;
+}
+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 : "";
+	}
+}
+function reminderMessage(key, text) {
+	return createUserMessage({
+		content: [{
+			type: "text",
+			text
+		}],
+		source: {
+			kind: "context-assembler",
+			form: "instructions",
+			id: key
+		}
+	});
+}
+//#endregion
+//#region src/channel.ts
+var ContextAssembler = class extends Service {
+	replacements = /* @__PURE__ */ new Map();
+	suppressed = /* @__PURE__ */ new Set();
+	states = /* @__PURE__ */ new WeakMap();
+	withoutInstructions = /* @__PURE__ */ new WeakSet();
+	constructor(ctx) {
+		super(ctx, "contextAssembler");
+	}
+	replaceSection(name, text) {
+		this.replacements.set(name, text);
+		return () => {
+			if (this.replacements.get(name) === text) this.replacements.delete(name);
+		};
+	}
+	suppressSection(name) {
+		this.suppressed.add(name);
+		return () => {
+			this.suppressed.delete(name);
+		};
+	}
+	isSuppressed(name) {
+		return this.suppressed.has(name);
+	}
+	replacement(name) {
+		return this.replacements.get(name);
+	}
+	setInstructions(agent, on) {
+		if (on) this.withoutInstructions.delete(agent);
+		else this.withoutInstructions.add(agent);
+	}
+	collect(agent) {
+		const entries = /* @__PURE__ */ new Map();
+		if (this.withoutInstructions.has(agent)) return entries;
+		for (const [id, text] of this.sectionsOf(agent)) entries.set(id, renderReminder(id, text));
+		return entries;
+	}
+	sectionsOf(agent) {
+		return this.states.get(agent)?.sections ?? /* @__PURE__ */ new Map();
+	}
+	sync(agent, input) {
+		this.stateOf(agent).sections = input.sections;
+	}
+	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;
+	}
+};
+//#endregion
+//#region src/defaults.ts
+const DEFAULT_KEEP = [
+	PERSONA_PREFIX_SECTION,
+	PERSONA_SUFFIX_SECTION,
+	RULES_SECTION
+];
+const DEFAULT_SUPPRESS = [
+	"harness:identity",
+	"harness:source",
+	"app:web-surface",
+	"tool:lsp",
+	"tool:pty",
+	"tool:session-query",
+	"tool:cordis",
+	"tool:ralph"
+];
+const DEFAULT_REPLACE = {
+	"context:file-reference": "以 @ 开头的词是用户显式引用的工作区路径，相对于工作区根。结尾带斜杠表示目录：需要时列目录内容。其余是文件：需要内容时用 read 工具读取，不要在读取前声称自己已经看过。用 @\"...\" 括住含空格的路径。",
+	"ui:deliverable-file-references": "成功创建或修改文件后，在最终回复里点明主要产物。除命令、配置表达式与代码块之外，每处提到已存在的文件都要链到它的完整路径（相对工作目录或绝对路径）；已知行号时在目标后加 `#L24` 或 `#L24-L30`。链接文本用文件名或清晰别名，只加够区分的父目录，不要把完整路径放进标签；默认只用文件名，需要精确位置时在标签后接 `:24` 或 `:24–30`（不带 `#` 或 `L`）。"
 };
-const CAPABILITY_NAMES = Object.keys(CAPABILITIES);
+//#endregion
+//#region src/rules.ts
+const RULES_TEXT = ["system-reminder 与 skill_content 块是本系统提示词的一部分，持续有效：同一条内容的最新一条取代更早的（带 id 的块以 id 为准，其余按来源），不同来源互不影响。", "skill_content 是要遵循的技能说明（随请求送来的与你后来加载的一样），file_content 是本步引用的文件内容。"].join("");
+//#endregion
+//#region src/index.ts
+const name = "context-assembler";
+const RULES_ORDER = 1;
+const inject = ["systemPrompt"];
 const Config = z.object({
-	capabilities: z.array(z.string()).default([...CAPABILITY_NAMES]),
-	options: z.any().default({})
+	keep: z.array(z.string()).default([...DEFAULT_KEEP]),
+	suppress: z.array(z.string()).default([...DEFAULT_SUPPRESS]),
+	replace: z.dict(z.string()).default({ ...DEFAULT_REPLACE })
 });
 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] ?? {});
-	}
+	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) ?? 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 = 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, text]) => reminderMessage(key, text)))
+		};
+	});
+	ctx.on("agent/request-error", async ({ agent, signal }, next) => {
+		const action = await next();
+		if (action?.kind !== "retry" || signal.aborted) return action;
+		for (const [key, text] of pendingEntries(agent, channel)) agent.session.append("user/message", reminderMessage(key, text), { surfaceOp: "append" });
+		return action;
+	}, { prepend: true });
+}
+function sectionId(name) {
+	return `section:${name}`;
+}
+function pendingEntries(agent, channel) {
+	return [...channel.collect(agent)].filter(([key, text]) => latestReminderText(agent, key) !== text).toSorted(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
 }
 //#endregion
-export { Config, apply, name };
+export { Config, ContextAssembler, DEFAULT_KEEP, DEFAULT_REPLACE, DEFAULT_SUPPRESS, apply, inject, name };

package/dist/rows.d.mts

@@ -1,48 +1,10 @@
 //#region src/rows.d.ts
-/**
- * 本包作为 **bundle** 的行清单：`dsh.profile.bundles` 列出本包时由它渲染成 `cordis.patch.yml`。
- *
- * 通道装在 host 平面，整份部署共享一套注入。**不做隔离**——工具说明
- * （`@morlay/dsh-agent-toolkit/guidance`，在别的包里）与 skill 目录这类消费者都在别的行上
- * `inject` 它，隔离会把它们挡在组外（行停在 waiting，不报错）。
- *
- * 本包自己的 bundle 只装通道（`PATCH_ROWS`）。模式的收口是另一行（`scopeRow()`），它由
- * [`@morlay/dsh-session-mode`](../../../profile/dsh-session-mode/README.md) 的 patch 与模式定义一起装——
- * 那一行的 config 就是模式清单。
- */
-/** 组装出口（包根）就是那个"按 config 装能力"的插件。 */
 declare const CONTEXT_PACKAGE = "@morlay/dsh-context-assembler";
-/** 一行 plugin entry（本模块只描述形状，类型由消费方自己那份行类型决定）。 */
 interface ContextRow {
   readonly id: string;
   readonly name: string;
   readonly config?: Readonly<Record<string, unknown>>;
 }
-/**
- * 通道那一行：包的主出口是**组装插件**——按 config 决定装哪些能力、各带什么参数，所以装配面
- * 只有这一行，组成与各能力的 config 都归包内（缺省即完整的一套；`chat` 用它裁剪）。
- */
-declare function contextChannel(config?: Readonly<Record<string, unknown>>): ContextRow;
-/**
- * 模式收口那一行：`scope` 出口按 `ctx.sessionModes` 的模式定义收口（工具白名单、instruction 总开关、
- * 动态快照开关）。
- *
- * 行 id 用全名 `context-assembler-scope`：它的搭档是同一份装配里的 `context-assembler`（通道），两个 id 放在
- * 一起才看得出这一行属于哪个包、做什么——`context-scope` 那种短名会被误当成 `ctx.contextScope` 之类的服务。
- *
- * 行本身**不带 config**：装哪些模式、每个模式收什么，都由 `session-mode` 行的 `config.modes` 决定，
- * 这一行只把它落到会话上（`inject` `sessionModes`，由
- * [`@morlay/dsh-session-mode`](../../../profile/dsh-session-mode/README.md) 的 patch 插一行）。
- */
-declare function scopeRow(): ContextRow;
-/**
- * bundle patch 的行清单：只有通道一行（模式收口那一行归 `session-mode` 的 patch 装）。
- *
- * 形态是 `insert`：这些行由本包提供给 host 平面。写成 `- id: x` 那种"改已有行"的形态时，装配期找不到
- * 目标行（只 warn 后跳过），通道根本没装上，引用它的行停在 waiting。
- */
-declare const PATCH_ROWS: readonly {
-  readonly insert: readonly ContextRow[];
-}[];
+declare function contextChannel(): ContextRow;
 //#endregion
-export { CONTEXT_PACKAGE, ContextRow, PATCH_ROWS, contextChannel, scopeRow };
+export { CONTEXT_PACKAGE, ContextRow, contextChannel };

package/dist/rows.mjs

@@ -1,55 +1,10 @@
 //#region src/rows.ts
-/**
-* 本包作为 **bundle** 的行清单：`dsh.profile.bundles` 列出本包时由它渲染成 `cordis.patch.yml`。
-*
-* 通道装在 host 平面，整份部署共享一套注入。**不做隔离**——工具说明
-* （`@morlay/dsh-agent-toolkit/guidance`，在别的包里）与 skill 目录这类消费者都在别的行上
-* `inject` 它，隔离会把它们挡在组外（行停在 waiting，不报错）。
-*
-* 本包自己的 bundle 只装通道（`PATCH_ROWS`）。模式的收口是另一行（`scopeRow()`），它由
-* [`@morlay/dsh-session-mode`](../../../profile/dsh-session-mode/README.md) 的 patch 与模式定义一起装——
-* 那一行的 config 就是模式清单。
-*/
-/** 组装出口（包根）就是那个"按 config 装能力"的插件。 */
 const CONTEXT_PACKAGE = "@morlay/dsh-context-assembler";
-/**
-* 通道那一行：包的主出口是**组装插件**——按 config 决定装哪些能力、各带什么参数，所以装配面
-* 只有这一行，组成与各能力的 config 都归包内（缺省即完整的一套；`chat` 用它裁剪）。
-*/
-function contextChannel(config) {
+function contextChannel() {
 	return {
 		id: "context-assembler",
-		name: CONTEXT_PACKAGE,
-		...config === void 0 ? {} : { config }
+		name: CONTEXT_PACKAGE
 	};
 }
-/**
-* 模式收口那一行：`scope` 出口按 `ctx.sessionModes` 的模式定义收口（工具白名单、instruction 总开关、
-* 动态快照开关）。
-*
-* 行 id 用全名 `context-assembler-scope`：它的搭档是同一份装配里的 `context-assembler`（通道），两个 id 放在
-* 一起才看得出这一行属于哪个包、做什么——`context-scope` 那种短名会被误当成 `ctx.contextScope` 之类的服务。
-*
-* 行本身**不带 config**：装哪些模式、每个模式收什么，都由 `session-mode` 行的 `config.modes` 决定，
-* 这一行只把它落到会话上（`inject` `sessionModes`，由
-* [`@morlay/dsh-session-mode`](../../../profile/dsh-session-mode/README.md) 的 patch 插一行）。
-*/
-function scopeRow() {
-	return {
-		id: "context-assembler-scope",
-		name: "@morlay/dsh-context-assembler/scope"
-	};
-}
-/**
-* bundle patch 的行清单：只有通道一行（模式收口那一行归 `session-mode` 的 patch 装）。
-*
-* 形态是 `insert`：这些行由本包提供给 host 平面。写成 `- id: x` 那种"改已有行"的形态时，装配期找不到
-* 目标行（只 warn 后跳过），通道根本没装上，引用它的行停在 waiting。
-*/
-const PATCH_ROWS = [{ insert: [contextChannel({ capabilities: [
-	"assembler",
-	"agent-instructions",
-	"skill-catalog"
-] })] }];
 //#endregion
-export { CONTEXT_PACKAGE, PATCH_ROWS, contextChannel, scopeRow };
+export { CONTEXT_PACKAGE, contextChannel };

package/locale/en.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "Context Assembler",
-    "description": "Prompt-injection capability set: the single injection channel plus workspace instructions, skill catalog and the scope gate that narrows tools per session mode."
+    "description": "The prompt channel: text conversion on the assembly result (replace / suppress) plus per-step delivery of demoted sections. The per-session scope gate (tool allow / deny lists, injection switches) lives in @morlay/dsh-session-mode."
   }
 }

package/locale/zh.json

@@ -1,6 +1,6 @@
 {
   "meta": {
-    "title": "注入能力组",
-    "description": "提示词注入能力组：唯一注入通道，以及工作区指令、skill 目录与模式收口。"
+    "title": "上下文装配通道",
+    "description": "提示词通道：装配结果上的文本转换（replace / suppress）与降级 section 的按步送达；模式收口（工具白名单与黑名单、注入开关）归 @morlay/dsh-session-mode。"
   }
 }