@morlay/dsh-session-mode 0.0.5 → 0.0.7

package/README.md

@@ -1,8 +1,8 @@
 # @morlay/dsh-session-mode
 
-**模式 = agent preset 的会话级扩展**：每个模式给这个会话加六样东西——一段 persona、一组工具名单（允许哪些、
-另外禁掉哪些）、一份 policy 名单（哪些上游裁决规则生效）、instruction / 技能目录 / 动态快照三个开关，外加可选的
-默认模型。模式**不绑 preset**：行清单（工具 / 命令 / 压缩 / 委派）由会话挂着
+**模式 = agent preset 的会话级扩展**：每个模式给这个会话加六样东西——一段 persona、两组按名收窄的名单（工具与技能
+各自允许哪些、另外禁掉哪些）、一份 policy 名单（哪些上游裁决规则生效）、instruction / 技能目录 / 动态快照三个开关，
+外加可选的默认模型。模式**不绑 preset**：行清单（工具 / 命令 / 压缩 / 委派）由会话挂着
 的那份 preset 提供，本部署用官方 shipped `standard`（registry 的默认由官方 web-app 给，我们不覆盖）；
 `config.modes.<id>.preset` 是可选声明，写了才会在切模式时把 preset 切过去。模式清单与默认值就是本行的 `config.modes`：真源在
 [`src/mode-sources.ts`](./src/mode-sources.ts)，行 config 由 [`src/rows.ts`](./src/rows.ts) 渲染；**模式不是 Cordis
@@ -10,7 +10,8 @@
 与 `GET/POST /session-mode`，且只在**空白会话**成立。
 
 **按会话收口也在这个包里**（[`src/scope.ts`](./src/scope.ts)，模式行内部持有、不发布服务）：工具目录与
-`tool:<工具名>` section 按同一份合成结果过滤、执行层 guard 挂在该 agent 的 ctx 上、三个开关
+`tool:<工具名>` section 按同一份合成结果过滤、执行层 guard 挂在该 agent 的 ctx 上（同一份 guard 也按名拒 `skill`
+工具要加载的那一件技能）、技能目录按技能名单删掉被拒的那几行、三个开关
 （`instructions` / `skills` / `runtimeContext`）按会话生效——其中 `instructions: false` 与 `skills: false` 是在
 `agent/pre-step` 上**丢掉官方两条注入面**（工作区指令、技能目录）。取舍见
 [设计 抑制官方注入面](./.agents/designs/20260929-抑制官方注入面.md)。
@@ -42,7 +43,9 @@
         persona:
           prefix: 你是一个助手。……
         allowTools: [ask_user_question, web_search, web_fetch] # 留空 = 不设收窄（用 preset 的全部工具）
-        denyTools: [] # 黑名单：从上面那份里减掉；两份同时命中时以这里为准（deny 优先）
+        denyTools: [load_workspace_dependencies] # 黑名单：从上面那份里减掉；两份同时命中时以这里为准（deny 优先）
+        allowSkills: [] # 技能白名单：留空 = 不设收窄（技能注册表里有什么就用什么）
+        denySkills: [office-docx, office-pptx, office-xlsx] # 技能黑名单：不进技能目录，`skill` 工具加载它也被拒
         instructions: false # 丢掉官方工作区指令的注入，并关掉通道自己的降级注入
         skills: false # 显式丢掉官方技能目录的注入；**本部署不写这一项**——推导已给出同一个值（见下）
         runtimeContext: false # 动态快照（沙箱策略、审批策略）
@@ -54,6 +57,18 @@
 就要技能目录（`allowTools` 留空即"全部"，所以只有 `denyTools` 能把它推成 `false`）。本部署两个模式都不写它：
 `coding` 留空名单 → `true`，`chat` 的三件里没有 `skill` → `false`。要"工具收窄但目录照旧列"就显式写 `skills: true`。
 
+技能名单（`allowSkills` / `denySkills`）收的是**技能名**，与工具名单同一套合成规则（`allowSkills` 留空 = 不设收窄，
+两份同时命中时 deny 优先），收窄落在两处：`skill-catalog` 那条消息的**正文**（删掉 ``- `<名字>`: <说明>`` 那几行；
+`source.entries` 是官方发布的记录、也是官方判"目录变没变"的输入，**不动它**）与 `skill` 工具的**调用参数**（拒的是
+它这次要加载的那一件，工具本身的可见性仍归 `allowTools`）。**不碰注册表**：技能照旧注册着，收的是"模型看到什么、
+能加载什么"。本部署用它收官方 Office 面——那三件技能由桌面宿主代码 `ctx.plugin` 挂载（不是 entry 行，profile 层
+停不掉），于是 `coding` 按名排除它们，`load_workspace_dependencies` 那件工具同样进 `denyTools`。
+
+代价与失效方式：正文删行认的是官方渲染形状（``- `<名字>`:`` 行首）。上游改了这个形状时那**一条目录消息整条不动**
+（宁可多列一个名字，也不删错行），并打一条点名告警——那是这条名单面唯一的失灵信号。技能名是模型可见契约，跟着
+上游改名走。日志与页面读到的是官方那份**完整**结构化名单，收窄只在模型可见的正文上——这是刻意的：官方按那份名单
+的 digest 判目录要不要重发，改了它会每一步都重发一条目录。
+
 写错在装载时就拒绝：`default` 必须在清单里且声明 `main`、`role` 不能是空数组、`defaultModel` 要给全 `provider` 与
 `model`、`allowPolicies` / `denyPolicies` 里的名字必须是上游那两条 waterfall（`fs/write-intent` /
 `fs/edit-intent`）。改动等 Loader 重挂这一行生效，已运行会话不自动换定义。

package/dist/client.cjs

@@ -16762,14 +16762,14 @@ window.__ModuleLoader__.load({
 			document.head.appendChild(tag);
 		}
 		var SessionModeSeat_module_css_default = {
-			"seatLabel": "dDMF8q_seatLabel",
 			"itemName": "dDMF8q_itemName",
+			"seatIcon": "dDMF8q_seatIcon",
 			"seat": "dDMF8q_seat",
+			"seatLabel": "dDMF8q_seatLabel",
 			"itemDesc": "dDMF8q_itemDesc",
+			"chevron": "dDMF8q_chevron",
 			"item": "dDMF8q_item",
-			"menuAnchor": "dDMF8q_menuAnchor",
-			"seatIcon": "dDMF8q_seatIcon",
-			"chevron": "dDMF8q_chevron"
+			"menuAnchor": "dDMF8q_menuAnchor"
 		};
 		//#endregion
 		//#region src/client/SessionModeSeat.tsx

package/dist/index.d.cts

@@ -23,6 +23,8 @@ interface SessionMode {
   readonly persona: SessionModePersona;
   readonly allowTools: string[];
   readonly denyTools: string[];
+  readonly allowSkills: string[];
+  readonly denySkills: string[];
   readonly allowPolicies: string[];
   readonly denyPolicies: string[];
   readonly instructions: boolean;

package/dist/index.d.mts

@@ -23,6 +23,8 @@ interface SessionMode {
   readonly persona: SessionModePersona;
   readonly allowTools: string[];
   readonly denyTools: string[];
+  readonly allowSkills: string[];
+  readonly denySkills: string[];
   readonly allowPolicies: string[];
   readonly denyPolicies: string[];
   readonly instructions: boolean;

package/dist/index.mjs

@@ -54,6 +54,14 @@ const modeSchema = z$1.object({
 		zh: "这个模式不用的工具（黑名单）：从 `allowTools` 定下的那份里减掉（`allowTools` 留空就是从全部里减）。留空 = 一条都不禁；同时命中两份名单时以这里为准。",
 		en: "Tools this mode must not use (deny list): subtracted from whatever `allowTools` settled on (with an empty `allowTools`, from everything). Empty denies nothing; a name in both lists is denied."
 	})),
+	allowSkills: z$1.array(z$1.string()).default([]).description(localized({
+		zh: "这个模式能用的技能；其余既不进技能目录，`skill` 工具加载它也被拒。**留空就是不设收窄**：技能注册表里有什么就用什么。",
+		en: "Skills this mode may use; everything else leaves the skill catalog and loading it through the `skill` tool is refused. Leave it empty to narrow nothing: the session then sees every skill the registry carries."
+	})),
+	denySkills: z$1.array(z$1.string()).default([]).description(localized({
+		zh: "这个模式不用的技能（黑名单）：从 `allowSkills` 定下的那份里减掉（`allowSkills` 留空就是从全部里减）。留空 = 一条都不禁；同时命中两份名单时以这里为准。",
+		en: "Skills this mode must not use (deny list): subtracted from whatever `allowSkills` settled on (with an empty `allowSkills`, from everything). Empty denies nothing; a name in both lists is denied."
+	})),
 	allowPolicies: z$1.array(z$1.string()).default([]).description(localized({
 		zh: "上游 policy 规则的生效白名单（`fs/write-intent` / `fs/edit-intent`）：留空 = 全部规则照旧生效；有值 = 只有列出的生效，其余的被绕过。",
 		en: "Allow list of upstream policy rules that stay in force (`fs/write-intent` / `fs/edit-intent`): empty keeps every rule; when set, only the listed ones stay, and the others are bypassed."
@@ -135,24 +143,69 @@ const DENYLISTED = (toolName, modeName) => `${toolName} 被「${modeName}」的
 function refusalOf(toolName, modeName, denial) {
 	return denial === "denylisted" ? DENYLISTED(toolName, modeName) : OUT_OF_SCOPE(toolName, modeName);
 }
+const SKILL_OUT_OF_SCOPE = (skillName, modeName) => `${skillName} 不在「${modeName}」的技能白名单里，加载它不会有结果；按当前模式可用的技能完成任务，或让用户切到别的模式。`;
+const SKILL_DENYLISTED = (skillName, modeName) => `${skillName} 被「${modeName}」的技能黑名单排除，加载它不会有结果；按当前模式可用的技能完成任务，或让用户切到别的模式。`;
+function skillRefusalOf(skillName, modeName, denial) {
+	return denial === "denylisted" ? SKILL_DENYLISTED(skillName, modeName) : SKILL_OUT_OF_SCOPE(skillName, modeName);
+}
 const TOOL_SECTION_PREFIX = "tool:";
-function gateOf(definition) {
-	const deny = new Set(definition.denyTools);
-	const allow = definition.allowTools.length === 0 ? void 0 : new Set(definition.allowTools);
-	if (allow === void 0 && deny.size === 0) return void 0;
+const SKILL_TOOL_NAME = "skill";
+function gateOfNames(allow, deny) {
+	const denied = new Set(deny);
+	const allowed = allow.length === 0 ? void 0 : new Set(allow);
+	if (allowed === void 0 && denied.size === 0) return void 0;
 	return {
-		allow,
-		deny
+		allow: allowed,
+		deny: denied
 	};
 }
-function denialOf(gate, toolName) {
-	if (gate.deny.has(toolName)) return "denylisted";
-	if (gate.allow !== void 0 && !gate.allow.has(toolName)) return "not-allowlisted";
+function denialOf(gate, name) {
+	if (gate.deny.has(name)) return "denylisted";
+	if (gate.allow !== void 0 && !gate.allow.has(name)) return "not-allowlisted";
 }
 function kindOf(message) {
 	const kind = message.source.kind;
 	return typeof kind === "string" ? kind : void 0;
 }
+const CATALOG_LINE = /^- `([^`]+)`: /u;
+function narrowCatalog(message, gate, warn) {
+	const source = message.source;
+	if (source.kind !== "skill-catalog") return void 0;
+	const entries = source.entries;
+	const denied = new Set(entries.map((entry) => entry.name).filter((name) => denialOf(gate, name) !== void 0));
+	if (denied.size === 0) return void 0;
+	const [block, ...rest] = message.content;
+	if (block?.type !== "text" || rest.length > 0) {
+		warn(`skill catalog message is not one text block; denied skills stay listed: ${[...denied].join(", ")}`);
+		return;
+	}
+	const removed = /* @__PURE__ */ new Set();
+	const lines = block.text.split("\n").filter((line) => {
+		const match = CATALOG_LINE.exec(line);
+		if (match === null) return true;
+		const name = match[1] ?? "";
+		if (!denied.has(name)) return true;
+		removed.add(name);
+		return false;
+	});
+	const missing = [...denied].filter((name) => !removed.has(name));
+	if (missing.length > 0) {
+		warn(`skill catalog lines not recognized; denied skills stay listed: ${missing.join(", ")}`);
+		return;
+	}
+	return {
+		...message,
+		content: [{
+			...block,
+			text: lines.join("\n")
+		}]
+	};
+}
+function skillNameOf(arguments_) {
+	if (typeof arguments_ !== "object" || arguments_ === null) return void 0;
+	const name = arguments_.name;
+	return typeof name === "string" && name.length > 0 ? name : void 0;
+}
 var SessionScope = class {
 	applied = /* @__PURE__ */ new WeakMap();
 	ctx;
@@ -175,30 +228,54 @@ var SessionScope = class {
 			if (decision.kind !== "enter") return decision;
 			const applied = this.applied.get(payload.agent);
 			if (applied === void 0) return decision;
-			const kept = decision.messages.filter((message) => {
+			let changed = false;
+			const kept = [];
+			for (const message of decision.messages) {
 				const kind = kindOf(message);
-				if (kind === "agent-instructions") return applied.instructions;
-				if (kind === "skill-catalog") return applied.skills;
-				return true;
-			});
-			return kept.length === decision.messages.length ? decision : {
+				if (kind === "agent-instructions") {
+					if (applied.instructions) kept.push(message);
+					else changed = true;
+					continue;
+				}
+				if (kind === "skill-catalog") {
+					if (!applied.skills) {
+						changed = true;
+						continue;
+					}
+					const narrowed = applied.skillGate === void 0 ? void 0 : narrowCatalog(message, applied.skillGate, (line) => this.ctx.logger.warn(`session-mode: ${line}`));
+					if (narrowed === void 0) kept.push(message);
+					else {
+						changed = true;
+						kept.push(narrowed);
+					}
+					continue;
+				}
+				kept.push(message);
+			}
+			return changed ? {
 				...decision,
 				messages: kept
-			};
+			} : decision;
 		}, { prepend: true });
 	}
 	apply(agent, definition) {
 		const previous = this.applied.get(agent);
 		if (previous !== void 0) previous.dispose();
-		const gate = gateOf(definition);
+		const gate = gateOfNames(definition.allowTools, definition.denyTools);
+		const skillGate = gateOfNames(definition.allowSkills, definition.denySkills);
 		const dispose = agent.ctx.effect(() => {
 			const stoppers = [];
 			if (definition.runtimeContext === false) stoppers.push(agent.ctx.systemPrompt.suppressRuntimeContext());
 			const fiber = agent.ctx.inject(["tools"], (scope) => {
-				if (gate === void 0) return;
+				if (gate === void 0 && skillGate === void 0) return;
 				scope.tools.guard((exec) => {
-					const denial = denialOf(gate, exec.name);
-					return denial === void 0 ? void 0 : refusalOf(exec.name, definition.name, denial);
+					const denial = gate === void 0 ? void 0 : denialOf(gate, exec.name);
+					if (denial !== void 0) return refusalOf(exec.name, definition.name, denial);
+					if (skillGate === void 0 || exec.name !== SKILL_TOOL_NAME) return void 0;
+					const skillName = skillNameOf(exec.arguments);
+					if (skillName === void 0) return void 0;
+					const skillDenial = denialOf(skillGate, skillName);
+					return skillDenial === void 0 ? void 0 : skillRefusalOf(skillName, definition.name, skillDenial);
 				});
 			});
 			return [...stoppers, () => fiber.dispose()];
@@ -206,6 +283,7 @@ var SessionScope = class {
 		this.channel()?.setInstructions(agent, definition.instructions);
 		this.applied.set(agent, {
 			gate,
+			skillGate,
 			instructions: definition.instructions,
 			skills: definition.skills,
 			dispose
@@ -421,6 +499,8 @@ var SessionModes = class extends Service {
 			name: mode.name,
 			allowTools: mode.allowTools,
 			denyTools: mode.denyTools,
+			allowSkills: mode.allowSkills,
+			denySkills: mode.denySkills,
 			instructions: mode.instructions,
 			skills: mode.skills ?? derivedSkills(mode),
 			runtimeContext: mode.runtimeContext

package/dist/rows.mjs

@@ -11,6 +11,12 @@ const MODE_SOURCES = [{
 	description: "功能完整的编码 Agent：文件、Shell、检索、联网等工具常驻，其余用法说明按需加载。",
 	persona: CODING_PERSONA,
 	role: ["main", "subagent"],
+	denyTools: ["load_workspace_dependencies"],
+	denySkills: [
+		"office-docx",
+		"office-pptx",
+		"office-xlsx"
+	],
 	denyPolicies: ["fs/edit-intent"]
 }, {
 	id: "chat",
@@ -34,6 +40,8 @@ function list(values) {
 function modeConfig(source) {
 	const allowTools = list(source.allowTools);
 	const denyTools = list(source.denyTools);
+	const allowSkills = list(source.allowSkills);
+	const denySkills = list(source.denySkills);
 	const allowPolicies = list(source.allowPolicies);
 	const denyPolicies = list(source.denyPolicies);
 	return {
@@ -44,6 +52,8 @@ function modeConfig(source) {
 		...source.persona === void 0 ? {} : { persona: { ...source.persona } },
 		...allowTools === void 0 ? {} : { allowTools },
 		...denyTools === void 0 ? {} : { denyTools },
+		...allowSkills === void 0 ? {} : { allowSkills },
+		...denySkills === void 0 ? {} : { denySkills },
 		...allowPolicies === void 0 ? {} : { allowPolicies },
 		...denyPolicies === void 0 ? {} : { denyPolicies },
 		...source.instructions === void 0 ? {} : { instructions: source.instructions },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morlay/dsh-session-mode",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Session modes for dsh: coding / chat as data — a mode is a persona plus its tool lists, its upstream policy lists, its instruction / skill-catalog / runtime-context switches and an optional default model. The host applies the current mode to each session, and the chip in the composer sits beside the official agent-preset entry, which stays.",
   "keywords": [
     "dsh",
@@ -59,6 +59,7 @@
     "@deepseek-ai/dsh-session-projection": "0.2.0-rc.2",
     "@deepseek-ai/dsh-skill": "0.2.0-rc.2",
     "@deepseek-ai/dsh-system-prompt": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-tool-skill": "0.2.0-rc.2",
     "@deepseek-ai/dsh-tools": "0.2.0-rc.2",
     "@morlay/dsh-client-ui-primitives": "0.0.7",
     "@morlay/dsh-context-assembler": "0.0.5",

package/src/index.ts

@@ -389,12 +389,14 @@ export class SessionModes extends Service {
         for (const dispose of disposers) dispose();
       },
     });
-    // 收口要的那几项按模式定义整份推过去：`name` / `allowTools` / `denyTools` / 三个开关。`skills` 缺省时在这里
+    // 收口要的那几项按模式定义整份推过去：`name` / 两份工具名单 / 两份技能名单 / 三个开关。`skills` 缺省时在这里
     // 按这份定义自己的工具名单推导（见 `derivedSkills`）——收口那一侧只认解析后的布尔。
     this.scope.apply(agent, {
       name: mode.name,
       allowTools: mode.allowTools,
       denyTools: mode.denyTools,
+      allowSkills: mode.allowSkills,
+      denySkills: mode.denySkills,
       instructions: mode.instructions,
       skills: mode.skills ?? derivedSkills(mode),
       runtimeContext: mode.runtimeContext,

package/src/mode-sources.ts

@@ -20,6 +20,10 @@ export interface ModeSource {
   readonly allowTools?: readonly string[];
   // 这个模式不用的工具（黑名单）：从 `allowTools` 定的那份里减掉（deny 优先）。
   readonly denyTools?: readonly string[];
+  // 这个模式能用的技能；**可选**，不写（留空）就是不设收窄——技能注册表里有什么就用什么。
+  readonly allowSkills?: readonly string[];
+  // 这个模式不用的技能（黑名单）：从 `allowSkills` 定的那份里减掉（deny 优先）。
+  readonly denySkills?: readonly string[];
   // 上游 policy 规则的生效白名单：**可选**，不写（留空）= 全部规则生效。
   readonly allowPolicies?: readonly PolicyName[];
   // 上游 policy 规则的黑名单：列出的规则禁用（它在上游那条 waterfall 上的裁决被绕过）。
@@ -69,7 +73,11 @@ export const MODE_SOURCES: readonly ModeSource[] = [
     // 用户可选，也允许作为子代理的 mode（子代理默认继承父 mode，不看角色；这里是"可被指定"的候选集）。
     role: ["main", "subagent"],
     // 不写 `allowTools`：不设收窄——这个会话用它挂着的 preset 提供的全部工具（抄一份清单只会与行清单漂移）。
-    // 不写 `denyTools`：一件工具都不禁。
+    // 只排除一件工具：官方 Office 组合（宿主代码挂载，profile 层停不掉它的行）里那个载荷查询。
+    denyTools: ["load_workspace_dependencies"],
+    // 官方 Office 技能的三个名字同样按会话排除：技能目录里不列它们，`skill` 工具加载它们也被拒。
+    // 名单是技能名这一层的模型可见契约（官方 `skill-office` 的 `SKILL_NAMES`），跟着上游改名走。
+    denySkills: ["office-docx", "office-pptx", "office-xlsx"],
     //
     // `denyPolicies` 只禁 `fs/edit-intent`（上游那条"先读后改"）：改文件不再要求先读过——写路径上的
     // `fs/write-intent`（陈旧版本 CAS 那层安全网）照旧生效，那正是这条配置不写成"两条都禁"的理由。

package/src/modes.ts

@@ -51,6 +51,12 @@ export interface SessionMode {
   // 这个模式**不用**哪些工具（黑名单）：从 `allowTools` 定下的那份里减掉（`allowTools` 留空时就是从全部里减）。
   // 留空表示不禁任何工具。同时命中两份名单时以这里为准（deny 优先）。
   readonly denyTools: string[];
+  // 这个模式能用哪些**技能**；其余的既不进技能目录，`skill` 工具加载它也被拒。**留空表示不设收窄**：技能注册表
+  // 里有什么就用什么（官方 `skill-office` 那类由宿主代码挂载的技能也在这份"全部"里）。
+  readonly allowSkills: string[];
+  // 这个模式**不用**哪些技能（黑名单）：从 `allowSkills` 定下的那份里减掉（`allowSkills` 留空时就是从全部里减）。
+  // 留空表示不禁任何技能；同时命中两份名单时以这里为准（deny 优先）。
+  readonly denySkills: string[];
   // 上游 policy 规则的**生效白名单**：留空（或不写）表示全部规则照旧生效；有值表示只有列出的那些生效，
   // 其余的按 `denyPolicies` 那一套被绕过。名单见 `POLICY_NAMES`。空数组与不写同义。
   readonly allowPolicies: string[];
@@ -198,6 +204,24 @@ const modeSchema: z<SessionMode> = z.object({
         en: "Tools this mode must not use (deny list): subtracted from whatever `allowTools` settled on (with an empty `allowTools`, from everything). Empty denies nothing; a name in both lists is denied.",
       }),
     ),
+  allowSkills: z
+    .array(z.string())
+    .default([])
+    .description(
+      localized({
+        zh: "这个模式能用的技能；其余既不进技能目录，`skill` 工具加载它也被拒。**留空就是不设收窄**：技能注册表里有什么就用什么。",
+        en: "Skills this mode may use; everything else leaves the skill catalog and loading it through the `skill` tool is refused. Leave it empty to narrow nothing: the session then sees every skill the registry carries.",
+      }),
+    ),
+  denySkills: z
+    .array(z.string())
+    .default([])
+    .description(
+      localized({
+        zh: "这个模式不用的技能（黑名单）：从 `allowSkills` 定下的那份里减掉（`allowSkills` 留空就是从全部里减）。留空 = 一条都不禁；同时命中两份名单时以这里为准。",
+        en: "Skills this mode must not use (deny list): subtracted from whatever `allowSkills` settled on (with an empty `allowSkills`, from everything). Empty denies nothing; a name in both lists is denied.",
+      }),
+    ),
   allowPolicies: z
     .array(z.string())
     .default([])
@@ -298,6 +322,10 @@ interface Validated {
         readonly allowTools?: readonly string[];
         // 留空合法：不禁任何工具；与 `allowTools` 同时命中合法（deny 优先）。
         readonly denyTools?: readonly string[];
+        // 留空合法：不设技能收窄。
+        readonly allowSkills?: readonly string[];
+        // 留空合法：不禁任何技能；与 `allowSkills` 同时命中合法（deny 优先）。
+        readonly denySkills?: readonly string[];
         // 留空合法：全部规则生效。
         readonly allowPolicies?: readonly string[];
         // 留空合法：一条都不禁；与 `allowPolicies` 同时命中合法（deny 优先）。

package/src/rows.ts

@@ -24,6 +24,8 @@ function list<T>(values: readonly T[] | undefined): readonly T[] | undefined {
 function modeConfig(source: ModeSource): Record<string, unknown> {
   const allowTools = list(source.allowTools);
   const denyTools = list(source.denyTools);
+  const allowSkills = list(source.allowSkills);
+  const denySkills = list(source.denySkills);
   const allowPolicies = list(source.allowPolicies);
   const denyPolicies = list(source.denyPolicies);
   return {
@@ -35,9 +37,12 @@ function modeConfig(source: ModeSource): Record<string, unknown> {
     ...(source.persona === undefined ? {} : { persona: { ...source.persona } }),
     // 四份名单都是可选的：不写（或写成空数组）就是这个键不进 config，schema 默认空数组。
     // `allowTools` 不写 = 不设收窄；`denyTools` 不写 = 一件都不禁（两份同配时 deny 优先）；
+    // `allowSkills` / `denySkills` 同一套语义，收的是技能名（技能目录与 `skill` 工具两处一起收）；
     // `allowPolicies` 不写 = 全部上游 policy 规则生效；`denyPolicies` 不写 = 一条都不禁。
     ...(allowTools === undefined ? {} : { allowTools }),
     ...(denyTools === undefined ? {} : { denyTools }),
+    ...(allowSkills === undefined ? {} : { allowSkills }),
+    ...(denySkills === undefined ? {} : { denySkills }),
     ...(allowPolicies === undefined ? {} : { allowPolicies }),
     ...(denyPolicies === undefined ? {} : { denyPolicies }),
     ...(source.instructions === undefined ? {} : { instructions: source.instructions }),

package/src/scope.ts

@@ -18,6 +18,9 @@
 import { type Context } from "@deepseek-ai/cordis";
 import type { Agent, PreStepDecision } from "@deepseek-ai/dsh-agent";
 import type { UserMessage } from "@deepseek-ai/dsh-llm";
+// 技能目录那条消息的 `source` 形状由官方 `tool-skill` 行声明（`MessageSourceMap` 的合并扩展）：这里只借它的类型，
+// 认它仍是按 `kind` 字符串读——运行期不依赖那一行在场。
+import type {} from "@deepseek-ai/dsh-tool-skill";
 // 通道的服务声明（`ctx.contextAssembler`）住在 `@morlay/dsh-context-assembler` 的包根上；那是可选搭档，
 // 所以只借它的类型，取服务仍按"可能没有"处理。
 import type {} from "@morlay/dsh-context-assembler";
@@ -30,6 +33,10 @@ export interface SessionScopeDefinition {
   readonly allowTools: readonly string[];
   // 这个会话明确排除的工具。与 `allowTools` 同时命中一个名字时**黑名单优先**（拒，且文案说黑名单）。
   readonly denyTools: readonly string[];
+  // 这个会话能用的技能；其余既不进技能目录，`skill` 工具加载它也被拒。**留空表示不设白名单**——起点是全部技能。
+  readonly allowSkills: readonly string[];
+  // 这个会话明确排除的技能。与 `allowSkills` 同时命中一个名字时**黑名单优先**（拒，且文案说黑名单）。
+  readonly denySkills: readonly string[];
   // 这个会话要不要 instruction 类注入（`false` → 丢掉官方 `agent-instructions` 的注入，并关通道的降级注入）。
   readonly instructions: boolean;
   // 这个会话要不要技能目录（`false` → 丢掉官方 `skill-catalog` 的注入）。
@@ -53,28 +60,45 @@ function refusalOf(toolName: string, modeName: string, denial: Denial): string {
     : OUT_OF_SCOPE(toolName, modeName);
 }
 
+// 技能被拒的两类原因：同一套白名单 / 黑名单语义，文案换到技能面（拒绝加载某一件技能，而不是某个工具）。
+const SKILL_OUT_OF_SCOPE = (skillName: string, modeName: string): string =>
+  `${skillName} 不在「${modeName}」的技能白名单里，加载它不会有结果；按当前模式可用的技能完成任务，或让用户切到别的模式。`;
+
+const SKILL_DENYLISTED = (skillName: string, modeName: string): string =>
+  `${skillName} 被「${modeName}」的技能黑名单排除，加载它不会有结果；按当前模式可用的技能完成任务，或让用户切到别的模式。`;
+
+function skillRefusalOf(skillName: string, modeName: string, denial: Denial): string {
+  return denial === "denylisted"
+    ? SKILL_DENYLISTED(skillName, modeName)
+    : SKILL_OUT_OF_SCOPE(skillName, modeName);
+}
+
 // 单个工具的说明 section 名前缀：`tool:<工具名>`（`tools:` 那类是聚合块，不归收口管）。
 const TOOL_SECTION_PREFIX = "tool:";
 
-// 一次收口**合成**出来的工具面：最终可用 = (白名单留空 ? 全部 : 白名单) − 黑名单。
-// `undefined` 表示不过滤（两条名单都空）——装配投影、section 过滤与执行 guard 三处都读同一个合成结果。
-type ToolGate = {
-  // undefined = 不设白名单（全部工具都是起点）。
+// 加载技能的那个官方工具名：官方 `tool-skill` 行的注册名，本包不 import 那一行（依赖面只到服务），所以按字符串读
+// ——与 `kindOf` 读官方注入面同一做法。
+const SKILL_TOOL_NAME = "skill";
+
+// 一次收口**合成**出来的一份名单面：最终可用 = (白名单留空 ? 全部 : 白名单) − 黑名单。工具面与技能面同形：
+// 两处（装配投影 / 执行 guard）都读同一个合成结果。
+type NameGate = {
+  // undefined = 不设白名单（全部都是起点）。
   readonly allow: ReadonlySet<string> | undefined;
   readonly deny: ReadonlySet<string>;
 };
 
-function gateOf(definition: SessionScopeDefinition): ToolGate | undefined {
-  const deny = new Set(definition.denyTools);
-  const allow = definition.allowTools.length === 0 ? undefined : new Set(definition.allowTools);
-  if (allow === undefined && deny.size === 0) return undefined;
-  return { allow, deny };
+function gateOfNames(allow: readonly string[], deny: readonly string[]): NameGate | undefined {
+  const denied = new Set(deny);
+  const allowed = allow.length === 0 ? undefined : new Set(allow);
+  if (allowed === undefined && denied.size === 0) return undefined;
+  return { allow: allowed, deny: denied };
 }
 
-// 判定一个工具名：`undefined` = 放行，否则是被拒的原因（黑名单先判，于是 deny 优先）。
-function denialOf(gate: ToolGate, toolName: string): Denial | undefined {
-  if (gate.deny.has(toolName)) return "denylisted";
-  if (gate.allow !== undefined && !gate.allow.has(toolName)) return "not-allowlisted";
+// 判定一个名字：`undefined` = 放行，否则是被拒的原因（黑名单先判，于是 deny 优先）。
+function denialOf(gate: NameGate, name: string): Denial | undefined {
+  if (gate.deny.has(name)) return "denylisted";
+  if (gate.allow !== undefined && !gate.allow.has(name)) return "not-allowlisted";
   return undefined;
 }
 
@@ -85,10 +109,67 @@ function kindOf(message: UserMessage): string | undefined {
   return typeof kind === "string" ? kind : undefined;
 }
 
+// 技能目录正文里的条目行：`- \`<技能名>\`: <说明>`（官方 `tool-skill` 的渲染形状）。只认行首这一种，
+// 认不出的行一律原样留着——宁可多列，不可把别的东西删掉。
+const CATALOG_LINE = /^- `([^`]+)`: /u;
+
+// 按技能名单收窄一条 `skill-catalog` 消息：正文删掉被拒技能那几行，`source.entries` 同步剔除。
+// `undefined` = 这条消息不用动（名单没排除它任何一项，或者形状认不出）。
+function narrowCatalog(
+  message: UserMessage,
+  gate: NameGate,
+  warn: (line: string) => void,
+): UserMessage | undefined {
+  const source = message.source;
+  if (source.kind !== "skill-catalog") return undefined;
+  const entries = source.entries;
+  const denied = new Set(
+    entries.map((entry) => entry.name).filter((name) => denialOf(gate, name) !== undefined),
+  );
+  if (denied.size === 0) return undefined;
+
+  const [block, ...rest] = message.content;
+  if (block?.type !== "text" || rest.length > 0) {
+    warn(
+      `skill catalog message is not one text block; denied skills stay listed: ${[...denied].join(", ")}`,
+    );
+    return undefined;
+  }
+  const removed = new Set<string>();
+  const lines = block.text.split("\n").filter((line) => {
+    const match = CATALOG_LINE.exec(line);
+    if (match === null) return true;
+    const name = match[1] ?? "";
+    if (!denied.has(name)) return true;
+    removed.add(name);
+    return false;
+  });
+  // 上游渲染形状漂移：正文里没定位到这些名字。这一条**整条不动**（正文与结构化名单保持一致：宁可多列，
+  // 不可出现"正文里有、名单里没有"的分叉），但要点出来——这条名单面就靠这行告警才不算静默失灵。
+  const missing = [...denied].filter((name) => !removed.has(name));
+  if (missing.length > 0) {
+    warn(`skill catalog lines not recognized; denied skills stay listed: ${missing.join(", ")}`);
+    return undefined;
+  }
+  // **只改正文**，`source.entries` 原样留着：官方 `tool-skill` 用那份结构化名单的 digest 判断"目录变没变"
+  // （`catalogHistory` 从会话日志里读它），改了它 digest 就永远对不上，于是每一步都重发一条目录。
+  // 收窄是"模型看到什么"，不是"官方发布过什么"：日志里留的是官方发布的完整名单，模型可见面由正文承担。
+  return { ...message, content: [{ ...block, text: lines.join("\n") }] };
+}
+
+// `skill` 工具调用的技能名：参数形状是官方那一行的 `{ name: string }`，认不出就不判（那是别人的工具）。
+function skillNameOf(arguments_: unknown): string | undefined {
+  if (typeof arguments_ !== "object" || arguments_ === null) return undefined;
+  const name = (arguments_ as { readonly name?: unknown }).name;
+  return typeof name === "string" && name.length > 0 ? name : undefined;
+}
+
 // 一个 agent 当前装着的那一份：`apply` 时解析好的开关（抑制面读它）。
 interface Applied {
   // 两条名单都空 = 不过滤（装配期与执行层都放行）。
-  readonly gate: ToolGate | undefined;
+  readonly gate: NameGate | undefined;
+  // 技能面的名单：与工具面同形，`undefined` = 不设收窄（目录照旧、`skill` 工具不按名判）。
+  readonly skillGate: NameGate | undefined;
   readonly instructions: boolean;
   readonly skills: boolean;
   // 收回这一份在 `agent.ctx` 上的注册（抑制器与执行层 guard）。
@@ -122,7 +203,7 @@ export class SessionScope {
     });
 
     // 两个抑制面：官方 `agent-instructions`（工作区指令）与官方 `skill-catalog`（技能目录）都在装配投影之外自己
-    // 往这条瀑布里 append，所以只有在这里丢掉它们的条目。
+    // 往这条瀑布里 append，所以只有在这里丢掉它们的条目（技能名单则在这里把目录按名收窄）。
     //
     // `prepend` 是必需的：官方那两行比本行早注册（会话挂着的 preset 先于 host 平面），瀑布里先注册的是**外层**，
     // 站在它们后面就看不到、也丢不掉它们 append 的条目——只有抢在最外层（`await next()` 之后再收）才拿得到最终
@@ -135,15 +216,36 @@ export class SessionScope {
         const applied = this.applied.get(payload.agent);
         // 没收过口的会话一律不动。
         if (applied === undefined) return decision;
-        const kept = decision.messages.filter((message) => {
+        let changed = false;
+        const kept: UserMessage[] = [];
+        for (const message of decision.messages) {
           const kind = kindOf(message);
-          if (kind === "agent-instructions") return applied.instructions;
-          if (kind === "skill-catalog") return applied.skills;
-          return true;
-        });
-        return kept.length === decision.messages.length
-          ? decision
-          : { ...decision, messages: kept };
+          if (kind === "agent-instructions") {
+            if (applied.instructions) kept.push(message);
+            else changed = true;
+            continue;
+          }
+          if (kind === "skill-catalog") {
+            if (!applied.skills) {
+              changed = true;
+              continue;
+            }
+            const narrowed =
+              applied.skillGate === undefined
+                ? undefined
+                : narrowCatalog(message, applied.skillGate, (line) =>
+                    this.ctx.logger.warn(`session-mode: ${line}`),
+                  );
+            if (narrowed === undefined) kept.push(message);
+            else {
+              changed = true;
+              kept.push(narrowed);
+            }
+            continue;
+          }
+          kept.push(message);
+        }
+        return changed ? { ...decision, messages: kept } : decision;
       },
       { prepend: true },
     );
@@ -153,8 +255,9 @@ export class SessionScope {
   apply(agent: Agent, definition: SessionScopeDefinition): void {
     const previous = this.applied.get(agent);
     if (previous !== undefined) previous.dispose();
-    // 两条名单都空 = 不过滤：没有守卫要装，装配期也一路放行。
-    const gate = gateOf(definition);
+    // 两份名单都空 = 不过滤：没有守卫要装，装配期也一路放行。
+    const gate = gateOfNames(definition.allowTools, definition.denyTools);
+    const skillGate = gateOfNames(definition.allowSkills, definition.denySkills);
 
     // 落在 `agent.ctx` 上的那两件用一个 effect 装：动态快照抑制是 scope 层的一次注册；执行层 guard 要等
     // `tools` 激活才装得上（`inject` 的回调），它挂在那个 inject fiber 下，所以收回时连 fiber 一起收。
@@ -166,10 +269,19 @@ export class SessionScope {
       }
       // 必须落在 `agent.ctx` 上才是这个会话的作用域。
       const fiber = agent.ctx.inject(["tools"], (scope) => {
-        if (gate === undefined) return;
+        if (gate === undefined && skillGate === undefined) return;
         scope.tools.guard((exec) => {
-          const denial = denialOf(gate, exec.name);
-          return denial === undefined ? undefined : refusalOf(exec.name, definition.name, denial);
+          // 工具面：按名判这个工具本身能不能用。
+          const denial = gate === undefined ? undefined : denialOf(gate, exec.name);
+          if (denial !== undefined) return refusalOf(exec.name, definition.name, denial);
+          // 技能面：`skill` 工具本身照旧可用，被收窄的是它这次要加载的那一件技能。
+          if (skillGate === undefined || exec.name !== SKILL_TOOL_NAME) return undefined;
+          const skillName = skillNameOf(exec.arguments);
+          if (skillName === undefined) return undefined;
+          const skillDenial = denialOf(skillGate, skillName);
+          return skillDenial === undefined
+            ? undefined
+            : skillRefusalOf(skillName, definition.name, skillDenial);
         });
       });
       return [...stoppers, () => fiber.dispose()];
@@ -180,6 +292,7 @@ export class SessionScope {
 
     this.applied.set(agent, {
       gate,
+      skillGate,
       instructions: definition.instructions,
       skills: definition.skills,
       dispose,