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

package/dist/rolldown-runtime-D7D4PA-g.mjs

@@ -0,0 +1,13 @@
+//#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/rows.d.mts

@@ -0,0 +1,46 @@
+//#region src/rows.d.ts
+/**
+ * 本包作为 **bundle** 的行清单：`dsh.profile.bundles` 列出本包时由它渲染成 `cordis.patch.yml`。
+ *
+ * 通道装在 host 平面，整份部署共享一套注入。**不做隔离**——工具说明
+ * （`@morlay/dsh-agent-toolkit/guidance`，在别的包里）与 skill 目录这类消费者都在别的行上
+ * `inject` 它，隔离会把它们挡在组外（行停在 waiting，不报错）。
+ *
+ * preset 只装 `scopeRow()`（模式的开关）：它 `inject` 通道，`ctx.get("contextAssembler")` 在 agent
+ * 子树里可达，不需要另装一份通道。
+ */
+/** 组装出口（包根）就是那个"按 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` 出口按 preset 配（工具白名单、instruction 总开关、动态快照开关）。
+ *
+ * 通道在 profile 平面装一次，这一行只按模式收口（它 `inject` `contextAssembler`，
+ * `ctx.get("contextAssembler")` 在 agent 子树里可达）。
+ */
+declare function scopeRow(config?: Readonly<Record<string, unknown>>): {
+  readonly id: string;
+  readonly name: string;
+  readonly config?: Readonly<Record<string, unknown>>;
+};
+/**
+ * bundle patch 的行清单：通道一行（`scope` 是模式的开关，由 preset 装 `scopeRow()`）。
+ *
+ * 形态是 `insert`：这些行由本包提供给 host 平面。写成 `- id: x` 那种"改已有行"的形态时，装配期找不到
+ * 目标行（只 warn 后跳过），通道根本没装上，引用它的行停在 waiting。
+ */
+declare const PATCH_ROWS: readonly {
+  readonly insert: readonly ContextRow[];
+}[];
+//#endregion
+export { CONTEXT_PACKAGE, ContextRow, PATCH_ROWS, contextChannel, scopeRow };

package/dist/rows.mjs

@@ -0,0 +1,50 @@
+//#region src/rows.ts
+/**
+* 本包作为 **bundle** 的行清单：`dsh.profile.bundles` 列出本包时由它渲染成 `cordis.patch.yml`。
+*
+* 通道装在 host 平面，整份部署共享一套注入。**不做隔离**——工具说明
+* （`@morlay/dsh-agent-toolkit/guidance`，在别的包里）与 skill 目录这类消费者都在别的行上
+* `inject` 它，隔离会把它们挡在组外（行停在 waiting，不报错）。
+*
+* preset 只装 `scopeRow()`（模式的开关）：它 `inject` 通道，`ctx.get("contextAssembler")` 在 agent
+* 子树里可达，不需要另装一份通道。
+*/
+/** 组装出口（包根）就是那个"按 config 装能力"的插件。 */
+const CONTEXT_PACKAGE = "@morlay/dsh-context-assembler";
+/**
+* 通道那一行：包的主出口是**组装插件**——按 config 决定装哪些能力、各带什么参数，所以装配面
+* 只有这一行，组成与各能力的 config 都归包内（缺省即完整的一套；`chat` 用它裁剪）。
+*/
+function contextChannel(config) {
+	return {
+		id: "context-assembler",
+		name: CONTEXT_PACKAGE,
+		...config === void 0 ? {} : { config }
+	};
+}
+/**
+* 模式开关那一行：`scope` 出口按 preset 配（工具白名单、instruction 总开关、动态快照开关）。
+*
+* 通道在 profile 平面装一次，这一行只按模式收口（它 `inject` `contextAssembler`，
+* `ctx.get("contextAssembler")` 在 agent 子树里可达）。
+*/
+function scopeRow(config) {
+	return {
+		id: "context-scope",
+		name: "@morlay/dsh-context-assembler/scope",
+		...config === void 0 ? {} : { config }
+	};
+}
+/**
+* bundle patch 的行清单：通道一行（`scope` 是模式的开关，由 preset 装 `scopeRow()`）。
+*
+* 形态是 `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 };

package/dist/scope-CI-fNq5A.mjs

@@ -0,0 +1,104 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import z from "@deepseek-ai/schemastery";
+import "@deepseek-ai/cordis";
+//#region ../../../vendor/deepseek-harness/packages/core/scope/lib/index.js
+/**
+* Scoped-context primitive: mint a Cordis context that tags registrations with
+* an opaque identity and build routing-only event carriers for that identity.
+*
+* @module @deepseek-ai/dsh-scope
+*/
+/** Context tag written by {@link createScope}. */
+const kScope = Symbol("dsh.scope");
+/**
+* The enclosing scope of each key. One relation powers both directions of
+* scope nesting: registration views inherit DOWN the chain (a child scope
+* sees its ancestors' layers — {@link ScopedLayers}), and event admission
+* extends UP it (a listener tagged with an ancestor receives events dispatched
+* to a descendant key — {@link scopeTarget}).
+*/
+const scopeParents = /* @__PURE__ */ new WeakMap();
+/**
+* The chain from a key to its root ancestor.
+* @param key - the starting key, or `undefined` for the empty chain.
+* @returns keys nearest-first: `[key, parent, grandparent, …]`.
+*/
+function scopeChainOf(key) {
+	const chain = [];
+	for (let cursor = key; cursor !== void 0; cursor = scopeParents.get(cursor)) chain.push(cursor);
+	return chain;
+}
+/**
+* Read the nearest scope tag inherited by a context.
+* @param ctx - context to inspect.
+* @returns its scope key, or `undefined` for an unscoped context.
+*/
+function scopeOf(ctx) {
+	return ctx[kScope];
+}
+//#endregion
+//#region src/scope/index.ts
+var scope_exports = /* @__PURE__ */ __exportAll({
+	Config: () => Config,
+	apply: () => apply,
+	inject: () => inject,
+	name: () => name
+});
+const name = "context-scope";
+const inject = ["tools", "systemPrompt"];
+const Config = z.object({
+	allowTools: z.array(z.string()).default([]),
+	instructions: z.boolean().default(true),
+	runtimeContext: z.boolean().default(true)
+});
+const OUT_OF_SCOPE = (toolName) => `${toolName} 不在本模式的工具范围内，用它不会有结果；按当前模式提供的工具完成任务，或让用户切到别的模式。`;
+/** 单个工具的说明 section 名前缀：`tool:<工具名>`（`tools:` 那类是聚合块，不归白名单管）。 */
+const TOOL_SECTION_PREFIX = "tool:";
+/**
+* 把某个 preset 的工具收成"只有这些"。
+*
+* 为什么需要它：preset composition 只能决定"加什么"，管不了 host 层——`dsh.profile.bundles` 打开的
+* bundle（例如实验性的 Agent Teams）会在 host 层插工具行与 section，对所有 preset 一视同仁。模式想
+* 表达"我只有这几个工具、一条提示词都不要"时，唯一与来源无关的做法是收口"有什么"。
+*
+* 为什么不是 `tools.restrict()`：它会改动可见工具集，从而触发 `tools/change`；上游 `tool-subagent`
+* 正是用该事件做 composition reconcile——两边互相触发会变成装配风暴。这里用投影过滤加执行层 guard：
+* 既不碰注册表、也不发事件。
+*/
+function apply(ctx, config) {
+	const allow = new Set(config.allowTools ?? []);
+	if (allow.size === 0) throw new Error("context-scope: `allowTools` must name at least one tool; omit the row instead of mounting an empty scope");
+	const presetKey = scopeOf(ctx);
+	const scoped = /* @__PURE__ */ new WeakSet();
+	if (config.runtimeContext === false) ctx.systemPrompt.suppressRuntimeContext();
+	const belongs = (agent) => {
+		if (presetKey === void 0) return true;
+		const key = scopeOf(agent.ctx);
+		return key !== void 0 && scopeChainOf(key).includes(presetKey);
+	};
+	/** 每个会话只做一次：拨提示词开关，并挂上执行层白名单。 */
+	const scopeOnce = (agent) => {
+		if (scoped.has(agent) || !belongs(agent)) return;
+		scoped.add(agent);
+		try {
+			const channel = ctx.get("contextAssembler");
+			if (config.instructions === false) channel?.setInstructions(agent, false);
+			channel?.restrictTools(agent, (tool) => allow.has(tool));
+		} catch {}
+		agent.ctx.inject(["tools"], () => {
+			agent.ctx.tools.guard((exec) => allow.has(exec.name) ? void 0 : OUT_OF_SCOPE(exec.name));
+		});
+	};
+	ctx.on("system-prompt/assemble", async (_assembly, context, next) => {
+		const agent = context.agent;
+		if (agent !== void 0) scopeOnce(agent);
+		const result = await next();
+		return {
+			...result,
+			sections: result.sections.filter((section) => section.name.startsWith(TOOL_SECTION_PREFIX) ? allow.has(section.name.slice(5)) : true),
+			tools: result.tools.filter((tool) => allow.has(tool.name))
+		};
+	});
+}
+//#endregion
+export { scope_exports as a, name as i, apply as n, inject as r, Config as t };

package/dist/scope.d.mts

@@ -0,0 +1,47 @@
+import z from "@deepseek-ai/schemastery";
+import { Context } from "@deepseek-ai/cordis";
+declare namespace index_d_exports {
+  export { Config, apply, inject, name };
+}
+declare const name = "context-scope";
+declare const inject: string[];
+interface Config {
+  /**
+   * 只保留这些工具；其余（含 host 层 bundle 加进来的）既不进模型目录，调用不了，它们自己注册的说明
+   * section（`tool:<工具名>`）也不留在提示词里。
+   */
+  allowTools?: string[];
+  /**
+   * 是否要 instruction 类的注入（工作区指令、技能目录、用法正文那类规则块）。缺省要；
+   * `false` 表示这个模式不要任何 instructions——对话模式就是它。
+   *
+   * 关的是**规则块与降级 section**（通道的 `setInstructions`）；内容块（`auto` 组正文、引用材料）
+   * 不受这个开关管，要靠对应的注入方自己不注册（chat 同时给了 `groups: false`）。
+   * 注意这与工具白名单是两件事：工具没给，跟着它的注入本来就该自己关（见各注入包对 requires 的判断）；
+   * 这里是"连与工具无关的 instruction 也不要"的总开关。
+   */
+  instructions?: boolean;
+  /**
+   * 是否要 runtime context（动态快照：文件沙箱策略、审批策略）。缺省要；`false` 表示这个模式不要它们
+   * ——对话模式没有文件与 shell 工具，"能改工作区哪些文件、要不要走审批"对它全是噪音。
+   *
+   * 抑制是**按 scope** 的（上游按装配的 scope 链查抑制器），所以本行装在 preset 子树里就只作用于这个
+   * 模式的会话；它只挡注入，不改任何提供方的行为（沙箱该怎么判还怎么判）。
+   */
+  runtimeContext?: boolean;
+}
+declare const Config: z<Config>;
+/**
+ * 把某个 preset 的工具收成"只有这些"。
+ *
+ * 为什么需要它：preset composition 只能决定"加什么"，管不了 host 层——`dsh.profile.bundles` 打开的
+ * bundle（例如实验性的 Agent Teams）会在 host 层插工具行与 section，对所有 preset 一视同仁。模式想
+ * 表达"我只有这几个工具、一条提示词都不要"时，唯一与来源无关的做法是收口"有什么"。
+ *
+ * 为什么不是 `tools.restrict()`：它会改动可见工具集，从而触发 `tools/change`；上游 `tool-subagent`
+ * 正是用该事件做 composition reconcile——两边互相触发会变成装配风暴。这里用投影过滤加执行层 guard：
+ * 既不碰注册表、也不发事件。
+ */
+declare function apply(ctx: Context, config: Config): void;
+//#endregion
+export { Config, apply, inject, name, index_d_exports as t };

package/dist/scope.mjs

@@ -0,0 +1,2 @@
+import { i as name, n as apply, r as inject, t as Config } from "./scope-CI-fNq5A.mjs";
+export { Config, apply, inject, name };

package/dist/skill-catalog.d.mts

@@ -0,0 +1,16 @@
+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>`。
+ */
+declare function apply(ctx: Context): void;
+//#endregion
+export { CATALOG_ID, apply, inject, name, index_d_exports as t };

package/dist/skill-catalog.mjs

@@ -0,0 +1,184 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { u as renderVirtualSkill } from "./assembler-_F9urbPj.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 = [
+	"skills",
+	"tools",
+	"contextAssembler"
+];
+const CATALOG_ID = "skill-catalog";
+/** 目录行里的描述长度上限（上游默认同值）。 */
+const DESCRIPTION_MAX_LENGTH = 500;
+/**
+* skill 目录 + `skill` 工具：目录是规则块（一行名字 + 摘要），正文按需加载。
+*
+* 目录只列模型可调用的 skill；`auto` 的 skill 标 `modelInvocable: false`，所以它不出现在目录里
+* （它的正文已经随提示送达）。工具的渲染用通道的虚拟 skill 形态，不带 `<skill_resources>`。
+*/
+function apply(ctx) {
+	/**
+	* 本会话上次算出的目录条目：`source` 是同步的、正文是异步的，两者共用这一次计算的结果
+	* （`collect` 里先算正文再取 source）。
+	*/
+	const catalogEntries = /* @__PURE__ */ new WeakMap();
+	ctx.contextAssembler.registerRule({
+		id: CATALOG_ID,
+		source: (agent) => ({
+			kind: "skill-catalog",
+			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");
+		}
+	});
+	if (ctx.tools.get("skill") !== void 0) ctx.logger.warn("context-skill-catalog: a `skill` tool is already registered; keeping the existing one and only publishing the catalog");
+	else registerSkillTool(ctx);
+}
+function registerSkillTool(ctx) {
+	const skillTool = 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
+			};
+		}
+	});
+	ctx.tools.register(skillTool);
+}
+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 };

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Context Assembler",
+    "description": "Prompt-injection capability set: the single injection channel plus workspace instructions, skill catalog, tool-usage guidance and the per-mode scope gate."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "注入能力组",
+    "description": "提示词注入能力组：唯一注入通道，以及工作区指令、skill 目录、工具用法分组与模式收口。"
+  }
+}

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@morlay/dsh-context-assembler",
+  "version": "0.0.1-alpha.2",
+  "description": "Prompt-injection capability set for dsh: the single channel (context assembler) plus the injectors it carries — workspace instructions, skill catalog, tool-usage guidance, and the per-mode scope gate. Reference expansion is its own package (@morlay/dsh-reference).",
+  "keywords": [
+    "context",
+    "dsh",
+    "dsh-plugin",
+    "injection",
+    "system-prompt"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/morlay/dsh-plugin.git"
+  },
+  "files": [
+    "locale/*.json",
+    "dist",
+    "src",
+    "tool",
+    "cordis.patch.yml",
+    "!**/__tests__"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./assembler": "./dist/assembler.mjs",
+    "./agent-instructions": "./dist/agent-instructions.mjs",
+    "./skill-catalog": "./dist/skill-catalog.mjs",
+    "./scope": "./dist/scope.mjs",
+    "./package.json": "./package.json",
+    "./rows": "./dist/rows.mjs",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./locale/*.json": "./locale/*.json"
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "3.18.4"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "4.0.4",
+    "@deepseek-ai/cordis-plugin-include": "1.0.9",
+    "@deepseek-ai/dsh-agent": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-agent-instructions": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-agent-loop": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-agent-loop-testkit": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-commands": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-compaction-basic": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-fs": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-llm": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-scope": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-session": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-session-persistence-jsonl": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-skill": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-skill-filesystem": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-system-prompt": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-token-meter": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-tool-skill": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-tools": "0.1.7-alpha.2",
+    "@morlay/session-rdb": "0.0.21-alpha.7",
+    "@types/js-yaml": "^4.0.9",
+    "@types/mdast": "^4.0.4",
+    "js-yaml": "^4.1.0"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "4.0.4",
+    "@deepseek-ai/dsh-agent": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-agent-instructions": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-commands": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-fs": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-llm": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-session": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-skill": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-system-prompt": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-tools": "0.1.7-alpha.2"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "scripts": {
+    "build": "pnpm exec tsdown"
+  }
+}

package/src/agent-instructions/baseline.ts

@@ -0,0 +1,75 @@
+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,
+  });
+}