@morlay/dsh-context-assembler 0.0.1 → 0.0.3

package/dist/assembler.d.mts

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

package/dist/assembler.mjs

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

package/dist/index-zhmD45A9.d.mts

@@ -1,213 +0,0 @@
-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>;
-  /**
-   * 这条规则的对外身份。工作区指令那一面按上游 kind 发消息（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 类注入的会话（模式说了 `instructions: false`）：常驻正文、规则块与降级 section 都不进。
-   * 按需 skill 不受它管（那是模型自己加载），引用材料也不经通道。
-   */
-  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` 就是不要，见 {@link withoutInstructions}）。 */
-  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;
-  /** 一个 skill 在这个会话能不能被用到：声明了 `requires` 时至少一个工具在模式收窄内。 */
-  private reachable;
-  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";
-  /**
-   * 条目形态：`instructions` 是规则块；`catalog` 是"带清单的目录"（客户端按 `entries` 列条目，
-   * 而不是读正文）。
-   */
-  form: "instructions" | "catalog";
-  /**
-   * `catalog` 形态发布的那份清单。**只有我们自己发布的目录**用它：上游 `tool-skill` 的账本扫法
-   * 只认它自己的 `kind`，所以这里的 kind 必须是我们自己的（见 [`skill-catalog`](../skill-catalog/index.ts)）。
-   */
-  entries?: readonly {
-    readonly name: string;
-    readonly description: string;
-  }[];
-  /** 条目 id：同 id 的最新一条取代更早的同 id 条目。本插件早先落库的消息没有它。 */
-  id?: string;
-}
-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/rolldown-runtime-D7D4PA-g.mjs

@@ -1,13 +0,0 @@
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-//#endregion
-export { __exportAll as t };

package/dist/scope.d.mts

@@ -1,41 +0,0 @@
-import z from "@deepseek-ai/schemastery";
-import { Context, Service } from "@deepseek-ai/cordis";
-import { Agent } from "@deepseek-ai/dsh-agent";
-declare namespace index_d_exports {
-  export { Config, SessionToolScope, SessionToolScopeMode, apply, inject, name };
-}
-declare const name = "context-assembler-scope";
-/** 收口要的服务；`sessionToolScope` 由本行自己发布，`tools` 的 guard 挂在每个 agent 的 ctx 上。 */
-declare const inject: string[];
-/** 本行不吃 config：要收成什么样由消费方在 `apply` 时给。 */
-declare const Config: z<Schemastery.ObjectS<{}>, Schemastery.ObjectT<{}>, "plain">;
-/** 一次收口的全部输入：模式定义里本出口用到的那几项。 */
-interface SessionToolScopeMode {
-  /** 拒绝对话时用的模式名。 */
-  readonly name: string;
-  /** 这个会话能用的工具；其余既不进目录，调用也被拒。 */
-  readonly allowTools: readonly string[];
-  /** 缺省为要；`false` 表示这个会话不要任何 instruction 类注入。 */
-  readonly instructions?: boolean | undefined;
-  /** 缺省为要；`false` 表示这个会话不要动态快照。 */
-  readonly runtimeContext?: boolean | undefined;
-}
-declare module "@deepseek-ai/cordis" {
-  interface Context {
-    sessionToolScope: SessionToolScope;
-  }
-}
-/** 按会话收口工具与注入的服务。 */
-declare class SessionToolScope extends Service {
-  private readonly applied;
-  constructor(ctx: Context);
-  /**
-   * 把某个会话收口到这份定义上（同一个 agent 再调就是换一份）。
-   * @param agent - 目标会话的 agent。
-   * @param mode - 收口的全部输入。
-   */
-  apply(agent: Agent, mode: SessionToolScopeMode): void;
-}
-declare function apply(ctx: Context): void;
-//#endregion
-export { Config, SessionToolScope, SessionToolScopeMode, apply, inject, name, index_d_exports as t };

package/dist/scope.mjs

@@ -1,102 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import z from "@deepseek-ai/schemastery";
-import { Service } from "@deepseek-ai/cordis";
-//#region src/scope/index.ts
-/**
-* 按**会话**收口：工具白名单、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 全部收回，再按新的装一遍。
-*/
-var scope_exports = /* @__PURE__ */ __exportAll({
-	Config: () => Config,
-	SessionToolScope: () => SessionToolScope,
-	apply: () => apply,
-	inject: () => inject,
-	name: () => name
-});
-const name = "context-assembler-scope";
-/** 收口要的服务；`sessionToolScope` 由本行自己发布，`tools` 的 guard 挂在每个 agent 的 ctx 上。 */
-const inject = ["tools", "systemPrompt"];
-/** 本行不吃 config：要收成什么样由消费方在 `apply` 时给。 */
-const Config = z.object({});
-const OUT_OF_SCOPE = (toolName, modeName) => `${toolName} 不在「${modeName}」的工具范围内，用它不会有结果；按当前模式提供的工具完成任务，或让用户切到别的模式。`;
-/** 单个工具的说明 section 名前缀：`tool:<工具名>`（`tools:` 那类是聚合块，不归白名单管）。 */
-const TOOL_SECTION_PREFIX = "tool:";
-/** 通道是可选的搭档：没有它就没有 instruction 可关、也没人收窄技能目录，工具目录与执行 guard 照常生效。 */
-function channelOf(ctx) {
-	try {
-		return ctx.get("contextAssembler");
-	} catch {
-		return;
-	}
-}
-/** 按会话收口工具与注入的服务。 */
-var SessionToolScope = class extends Service {
-	applied = /* @__PURE__ */ new WeakMap();
-	constructor(ctx) {
-		super(ctx, "sessionToolScope");
-		ctx.on("system-prompt/assemble", async (_assembly, context, next) => {
-			const agent = context.agent;
-			const applied = agent === void 0 ? void 0 : this.applied.get(agent);
-			if (applied === void 0) return next();
-			const allow = new Set(applied.mode.allowTools);
-			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))
-			};
-		});
-	}
-	/**
-	* 把某个会话收口到这份定义上（同一个 agent 再调就是换一份）。
-	* @param agent - 目标会话的 agent。
-	* @param mode - 收口的全部输入。
-	*/
-	apply(agent, mode) {
-		const previous = this.applied.get(agent);
-		if (previous !== void 0) previous.dispose();
-		const allow = new Set(mode.allowTools);
-		const dispose = agent.ctx.effect(() => {
-			const stoppers = [];
-			if (mode.runtimeContext === false) stoppers.push(agent.ctx.systemPrompt.suppressRuntimeContext());
-			const fiber = agent.ctx.inject(["tools"], (scope) => {
-				scope.tools.guard((exec) => allow.has(exec.name) ? void 0 : OUT_OF_SCOPE(exec.name, mode.name));
-			});
-			return [...stoppers, () => fiber.dispose()];
-		}, "sessionToolScope: per-session gate");
-		const channel = channelOf(this.ctx);
-		channel?.setInstructions(agent, mode.instructions !== false);
-		channel?.restrictTools(agent, (tool) => allow.has(tool));
-		this.applied.set(agent, {
-			mode,
-			dispose
-		});
-	}
-};
-function apply(ctx) {
-	new SessionToolScope(ctx);
-}
-//#endregion
-export { Config, SessionToolScope, apply, inject, name, scope_exports as t };

package/dist/skill-catalog.d.mts

@@ -1,23 +0,0 @@
-import { Context } from "@deepseek-ai/cordis";
-declare namespace index_d_exports {
-  export { CATALOG_ID, apply, inject, name };
-}
-declare const name = "context-skill-catalog";
-declare const inject: string[];
-declare const CATALOG_ID = "skill-catalog";
-/**
- * skill 目录 + `skill` 工具：目录是规则块（一行名字 + 摘要），正文按需加载。
- *
- * 目录只列模型可调用的 skill；`auto` 的 skill 标 `modelInvocable: false`，所以它不出现在目录里
- * （它的正文已经随提示送达）。工具的渲染用通道的虚拟 skill 形态，不带 `<skill_resources>`。
- *
- * **这一面归通道**（工作区指令那一面相反，是让位给 preset）：官方 preset 自己装了上游 `tool-skill`，那份
- * 注册在 preset 的 scope 层；我们把 `skill` 工具按会话注册进 **agent 自己那一层**——它最靠里，同名注册遮蔽
- * 继承来的那一份（[`core/tools/src/index.ts:1185-1207`](../../../vendor/deepseek-harness/packages/core/tools/src/index.ts)），
- * 于是模型看到的是我们的工具（中文描述 + 按会话修剪的正文）。上游的目录发布判据是"它自己注册的那个工具是
- * 本会话可见的那个"（[`skill/tool-skill/src/index.ts:213-236`](../../../vendor/deepseek-harness/packages/skill/tool-skill/src/index.ts)），
- * 被遮蔽之后它闭嘴，目录由我们发布；`minimal`（`chat`）那种没有上游行的会话里也只有我们这一份。
- */
-declare function apply(ctx: Context): void;
-//#endregion
-export { CATALOG_ID, apply, inject, name, index_d_exports as t };

package/dist/skill-catalog.mjs

@@ -1,206 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { u as renderVirtualSkill } from "./assembler-CDMIBAi8.mjs";
-import { isModelInvocable, isSkillName } from "@deepseek-ai/dsh-skill";
-import { defineTool } from "@deepseek-ai/dsh-tools";
-//#region src/skill-catalog/index.ts
-var skill_catalog_exports = /* @__PURE__ */ __exportAll({
-	CATALOG_ID: () => CATALOG_ID,
-	apply: () => apply,
-	inject: () => inject,
-	name: () => name
-});
-const name = "context-skill-catalog";
-const inject = [
-	"agents",
-	"skills",
-	"tools",
-	"contextAssembler"
-];
-const CATALOG_ID = "skill-catalog";
-/** 目录行里的描述长度上限（上游默认同值）。 */
-const DESCRIPTION_MAX_LENGTH = 500;
-/**
-* skill 目录 + `skill` 工具：目录是规则块（一行名字 + 摘要），正文按需加载。
-*
-* 目录只列模型可调用的 skill；`auto` 的 skill 标 `modelInvocable: false`，所以它不出现在目录里
-* （它的正文已经随提示送达）。工具的渲染用通道的虚拟 skill 形态，不带 `<skill_resources>`。
-*
-* **这一面归通道**（工作区指令那一面相反，是让位给 preset）：官方 preset 自己装了上游 `tool-skill`，那份
-* 注册在 preset 的 scope 层；我们把 `skill` 工具按会话注册进 **agent 自己那一层**——它最靠里，同名注册遮蔽
-* 继承来的那一份（[`core/tools/src/index.ts:1185-1207`](../../../vendor/deepseek-harness/packages/core/tools/src/index.ts)），
-* 于是模型看到的是我们的工具（中文描述 + 按会话修剪的正文）。上游的目录发布判据是"它自己注册的那个工具是
-* 本会话可见的那个"（[`skill/tool-skill/src/index.ts:213-236`](../../../vendor/deepseek-harness/packages/skill/tool-skill/src/index.ts)），
-* 被遮蔽之后它闭嘴，目录由我们发布；`minimal`（`chat`）那种没有上游行的会话里也只有我们这一份。
-*/
-function apply(ctx) {
-	/**
-	* 本会话上次算出的目录条目：`source` 是同步的、正文是异步的，两者共用这一次计算的结果
-	* （`collect` 里先算正文再取 source）。
-	*/
-	const catalogEntries = /* @__PURE__ */ new WeakMap();
-	const skillTool = ctx.tools.get("skill") === void 0 ? defineSkillTool(ctx) : void 0;
-	if (skillTool === void 0) ctx.logger.warn("context-skill-catalog: a `skill` tool is already registered; keeping the existing one and only publishing the catalog");
-	else {
-		const install = (agent) => {
-			if (ctx.tools.get("skill", agent) === skillTool) return;
-			try {
-				agent.ctx.tools.register(skillTool);
-			} catch (error) {
-				ctx.logger.warn(`context-skill-catalog: ${String(error)}`);
-			}
-		};
-		ctx.on("agent/created", ({ agent }) => {
-			install(agent);
-		});
-		for (const agent of ctx.agents.list()) install(agent);
-	}
-	ctx.contextAssembler.registerRule({
-		id: CATALOG_ID,
-		source: (agent) => ({
-			kind: "context-assembler",
-			form: "catalog",
-			entries: catalogEntries.get(agent) ?? []
-		}),
-		text: async (agent) => {
-			const noCatalog = () => {
-				catalogEntries.delete(agent);
-				return "";
-			};
-			const visible = ctx.contextAssembler.visibleTools(agent, (tool) => ctx.tools.get(tool, agent) !== void 0);
-			if (!visible("skill")) return noCatalog();
-			const snapshot = await ctx.skills.snapshot({
-				cwd: agent.session.header.cwd,
-				scope: agent
-			});
-			if (!snapshot.complete) return noCatalog();
-			const hidden = ctx.contextAssembler.hiddenSkills(visible);
-			const skills = snapshot.skills.filter(isModelInvocable).filter((skill) => !hidden.has(skill.name));
-			if (skills.length === 0) return noCatalog();
-			const entries = skills.map((skill) => ({
-				name: skill.name,
-				description: clamp(skill.description, DESCRIPTION_MAX_LENGTH)
-			}));
-			catalogEntries.set(agent, entries);
-			return [
-				"<available_skills>",
-				...entries.map((entry) => `- ${entry.name}: ${entry.description}`),
-				"</available_skills>",
-				"",
-				"任务与某个 skill 说明匹配时，先加载它再行事。"
-			].join("\n");
-		}
-	});
-}
-/** 一份工具定义，按会话注册进每个 agent 的自己那一层（同一个定义对象，判据里的同一性靠它）。 */
-function defineSkillTool(ctx) {
-	return defineTool({
-		name: "skill",
-		description: "按需加载 skill 的完整说明。",
-		parameters: { name: {
-			type: "string",
-			required: true,
-			description: "技能目录里的 skill 名。"
-		} },
-		output: {
-			schema: {
-				type: "object",
-				additionalProperties: false,
-				properties: {
-					name: {
-						type: "string",
-						required: true
-					},
-					provider: {
-						type: "string",
-						required: true
-					},
-					resourceBase: { oneOf: [
-						{
-							type: "object",
-							additionalProperties: false,
-							properties: {
-								kind: {
-									type: "string",
-									required: true,
-									const: "directory"
-								},
-								path: {
-									type: "string",
-									required: true
-								}
-							}
-						},
-						{
-							type: "object",
-							additionalProperties: false,
-							properties: {
-								kind: {
-									type: "string",
-									required: true,
-									const: "url"
-								},
-								url: {
-									type: "string",
-									required: true
-								}
-							}
-						},
-						{
-							type: "object",
-							additionalProperties: false,
-							properties: {
-								kind: {
-									type: "string",
-									required: true,
-									const: "opaque"
-								},
-								description: {
-									type: "string",
-									required: true
-								}
-							}
-						}
-					] },
-					content: {
-						type: "string",
-						required: true
-					}
-				}
-			},
-			render: (_args, value) => [{
-				type: "text",
-				text: renderVirtualSkill(value.name, value.content)
-			}]
-		},
-		async execute(args, exec) {
-			if (!isSkillName(args.name)) throw new Error(`invalid skill name "${args.name}"`);
-			const lookup = {
-				cwd: exec.agent?.session.header.cwd,
-				signal: exec.signal,
-				scope: exec.agent
-			};
-			const skill = await ctx.skills.get(args.name, lookup);
-			if (skill === void 0) throw new Error(`skill "${args.name}" is unknown or no longer available`);
-			if (!isModelInvocable(skill)) throw new Error(`skill "${args.name}" is not available for model invocation`);
-			const content = ctx.contextAssembler.contentFor(skill.name, exec.agent) ?? skill.content;
-			return {
-				name: skill.name,
-				provider: skill.provider,
-				content
-			};
-		},
-		presentCall(args) {
-			return {
-				card: "generic",
-				title: `Load skill ${args.name}`,
-				kind: "read",
-				rawInput: args.name
-			};
-		}
-	});
-}
-function clamp(text, max) {
-	return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
-}
-//#endregion
-export { CATALOG_ID, apply, inject, name, skill_catalog_exports as t };