dsh-skill-tag 0.1.17 → 0.1.19

package/docs//346/212/200/350/203/275/345/217/221/347/216/260/344/270/216/345/256/277/344/270/273/345/257/271/351/275/220.md

@@ -181,6 +181,20 @@ tagging-skills 那 17 个长期漏网的原因（详见 `deny-shadow-覆盖率.m
 再发 —— 一个不合法候选会让**整个** `provider.list()` 抛错，宿主随即丢弃本插件的
 全部贡献（日志 `skill provider "skill-tag" skipped`），比漏一个更糟。
 
+**两段都要校验（2026-11-12，issue #6）**。上面这条当时只堵了「`denied` 里看不见
+的名字」那一段，**看得见的**那一段（照抄上游 summary）一直没校验，于是扫盘带进来的
+脏名字能原样发出去。触发链：`src/skill-scan.js` 把技能根下裸放的 `README-官方技能说明.md`
+当成技能（名字取文件名去 `.md`）→ 进 universe → `denied = universe − visible` 里也有它 →
+第一段照抄发射 → 宿主 `validateCandidate` 抛错 → **所有对话**每轮都失败，报
+`returned invalid skill name`。
+
+现在两层纵深防御：
+
+- `src/skill-scan.js`：根级裸放 `.md` **必须有 frontmatter** 才算技能，名字非 kebab-case
+  一律跳过 —— 与宿主 `discoverRoot` / `parseSkillFile` 同口径（宿主对同样的文件打的是
+  `skill file ... ignored: invalid skill name`）。
+- `lib/index.js`：第一段与第二段都过 `isSkillName()`，兜住任何别的来源漏进来的脏名字。
+
 ## 5. 约束（踩过的坑）
 
 - **cordis 服务必须声明式注入**：`export const inject` 里没有的服务，读 `ctx.xxx`

package/lib/index.js

@@ -31,7 +31,6 @@ const PROVIDER_NAME = "skill-tag";
 /** 影子候选的 source（宿主要求是字符串，且只用于展示/排序以外的标识）。 */
 const PROVIDER_SOURCE = "skill-tag";
 
-const ON = { modelInvocable: true, userInvocable: true };
 const DENY = { modelInvocable: false, userInvocable: false };
 
 /**
@@ -101,8 +100,15 @@ export function createFilterProvider(sessionId, upstream, denied, ensureFresh, l
 			// 还是上游那份，影子只换掉 invocation 与 provider，右列能看出"它被屏蔽了"。
 			const shadows = [];
 			const emitted = new Set();
+			const invalid = new Set();
 			for (const summary of summaries) {
 				if (!summary || !denied.has(summary.name)) continue;
+				// 看得见 ≠ 合法（2026-11-12，issue #6）：扫盘会把技能根下裸放的
+				// `README-官方技能说明.md` 这类文件当成技能，名字取文件名去 `.md`。
+				// 旧实现只在第二段校验，这一段整条照抄 → 非法名字原样发出去 →
+				// 宿主 validateCandidate 抛错 → 整个 provider 作废 → **所有对话**
+				// 报 "returned invalid skill name" 且每轮都失败。两段都必须校验。
+				if (!isSkillName(summary.name)) { invalid.add(summary.name); continue; }
 				shadows.push({
 					...summary,
 					provider: PROVIDER_NAME,
@@ -123,10 +129,9 @@ export function createFilterProvider(sessionId, upstream, denied, ensureFresh, l
 			// 修法：屏蔽是**按名字**生效的，不需要知道那名字长什么样 —— 看不见的
 			// 名字直接造一条最小合法候选，就能在近层整条覆盖上游那份。
 			let backfilled = 0;
-			const invalid = [];
 			for (const name of denied) {
 				if (emitted.has(name)) continue;
-				if (!isSkillName(name)) { invalid.push(name); continue; }
+				if (!isSkillName(name)) { invalid.add(name); continue; }
 				shadows.push({
 					name,
 					description: `[blocked by skill-tag] ${name}`,
@@ -148,8 +153,8 @@ export function createFilterProvider(sessionId, upstream, denied, ensureFresh, l
 							+ ` shadowed=${emitted.size} backfilled=${backfilled}`
 							+ `${upstream.lastDegraded === true ? " hostSnapshot=skipped(nested)" : ""}`);
 					}
-					if (invalid.length > 0) {
-						logWarn(`[skill-tag] denied names skipped (not kebab-case): ${invalid.slice(0, 8).join(", ")}`);
+					if (invalid.size > 0) {
+						logWarn(`[skill-tag] names skipped (not kebab-case): ${[...invalid].slice(0, 8).join(", ")}`);
 					}
 				} catch { /* 观测不得影响主路径 */ }
 			}
@@ -553,6 +558,22 @@ export function getWorkspaceRegistry(ctx) {
 	return null;
 }
 
+/**
+ * 安全取宿主 connection 服务（Host/Origin 与浏览器鉴权）。
+ * 与 getWorkspaceRegistry 同理：走 ctx.get 探测，不写进 inject，缺席时返回 null。
+ * @param {object} ctx cordis context
+ * @returns {object|null}
+ */
+function getConnection(ctx) {
+	try {
+		if (typeof ctx?.get === "function") {
+			const svc = ctx.get("connection");
+			if (svc) return svc;
+		}
+	} catch { /* 未装载 */ }
+	return null;
+}
+
 /**
  * 会话 → 工作区 id 的解析（宿主 workspaceRegistry 是唯一权威来源）。
  *
@@ -596,8 +617,6 @@ export function workspaceIdOfPath(registry, cwd) {
 
 // ── Wiring ───────────────────────────────────────────────────────────────────
 
-const controls = new Set();
-
 export const name = "dsh-skill-tag";
 
 export const inject = ["skills", "agents", "storageDomain", "webServer"];
@@ -612,17 +631,44 @@ export async function apply(ctx, config) {
 	const enabled = config?.enabled !== false;
 
 	// 1. Persistence: open our storage domain; close on dispose (§12).
+	//
+	// 关闭必须排在在飞的刷新之后。Cordis 的 fiber 卸载是**兄弟 disposer 并发**
+	// （vendor/cordis fiber.ts:720 `Promise.all(this._disposables...)`），所以如果
+	// domain.close() 和仍在跑的 refreshSession 同时执行，后者会撞上
+	// DomainError("closed")。做法：一个共享的 inflight 登记表 + 先停接收新工作、
+	// 再等已接受的结算、最后才 close。
+	const inflight = new Set();
+	let shuttingDown = false;
+
+	/** 登记一个在飞的异步任务，dispose 时会等它结算。 */
+	function track(promise) {
+		const p = Promise.resolve(promise).catch(() => {}).finally(() => inflight.delete(p));
+		inflight.add(p);
+		return p;
+	}
+
+	//
+	// storageDomain 在 inject 里声明为强依赖，但这里仍保留缺席兜底：单测与
+	// 极简 cordis 面（runtime.test.mjs）会直接构造不带该服务的 ctx 调 apply，
+	// 兜底保证"缺可选服务不崩溃"这条既有契约不破。真宿主里 inject 会先挡住
+	// 激活，这条分支不会走到，但它守的是另一条约束。
 	let repo;
 	if (ctx.storageDomain) {
 		const domain = await ctx.storageDomain.open(skillTagDomain);
 		// cordis effect semantics (cordis lib/index.js:1142): the thunk runs NOW and
 		// its RETURNED function becomes the dispose hook — so return the closer,
 		// never call it here. `() => domain.close()` would close the domain at setup.
-		ctx.effect(() => () => domain.close());
+		//
+		// 顺序：先置 shuttingDown（拒绝新的刷新）→ 等在飞的结算 → 再关 domain。
+		// 这样消费者（读路径、HTTP handler）始终跑在还活着的 domain 上。
+		ctx.effect(() => () => {
+			shuttingDown = true;
+			return Promise.allSettled([...inflight]).then(() => domain.close());
+		});
 		repo = createDshRepository(domain);
 		ctx.logger?.info?.("[skill-tag] storage domain 'skill_tag' opened");
 	} else {
-		// host planes without storageDomain (unit tests, non-persistent runs)
+		// 测试面 / 无存储宿主：退回内存仓库，行为可跑但不持久化。
 		const { createMemoryRepository } = await import("../src/storage/repository.js");
 		repo = createMemoryRepository();
 		ctx.logger?.warn?.("[skill-tag] storageDomain service missing — running in-memory");
@@ -643,6 +689,14 @@ export async function apply(ctx, config) {
 	// 3. Session→denied-skill-names live map. Denials derive from the boolean
 	//    config + per-conversation four-zone state (§11). Recomputed on demand.
 	const sessionDenials = new Map(); // sessionId -> Set<string>
+
+	// 每个 agent 注册 provider 时拿到的 control，用于配置变更后 invalidate。
+	//
+	// 这张表**不能**放模块顶层：模块级 Set 的身份来自模块加载而非 fiber，
+	// 插件重载后新旧实例共用同一份，且 agent 销毁时旧 control 留在里面，
+	// 之后每次 recomputeDenials 都要对已释放的对象白调一次 invalidate()。
+	// 放这里 + 按 agent 删除，生命周期才跟 apply 一致。
+	const controls = new Set();
 	function deniedFor(sessionId) {
 		let set = sessionDenials.get(sessionId);
 		if (!set) { set = new Set(); sessionDenials.set(sessionId, set); }
@@ -701,6 +755,7 @@ export async function apply(ctx, config) {
 	const refreshing = new Set();
 	async function refreshBySession(sessionId, cwd, scope = null) {
 		if (!sessionId) return;
+		if (shuttingDown) return; // 卸载中：不要再动即将关闭的 domain
 		if (refreshing.has(sessionId)) return;
 		refreshing.add(sessionId);
 		try {
@@ -846,11 +901,14 @@ export async function apply(ctx, config) {
 			const denied = deniedFor(sessionId);
 			// agent 侧的 cwd 兜底（provider options.cwd 优先，见 createFilterProvider）
 			const agentCwd = agent.session?.header?.cwd ?? agent.session?.cwd;
-			ctx.effect(() =>
-				agent.ctx.effect(() =>
+			// 每个 agent 持有自己那份 control，便于销毁时精确摘除。
+			let ownControl = null;
+			ctx.effect(() => {
+				const outerDispose = agent.ctx.effect(() =>
 					skills.registerProvider((control) => {
 						try {
 							controls.add(control);
+							ownControl = control;
 						} catch { /* 控制面已释放 */ }
 						return createFilterProvider(sessionId, upstream, denied, async (options) => {
 							// 读路径上按需刷新：新对话的第一次 list() 也必须已过滤，
@@ -861,8 +919,14 @@ export async function apply(ctx, config) {
 							await refreshBySession(sessionId, options?.cwd ?? agentCwd, agent);
 						}, (message) => ctx.logger?.warn?.(message));
 					}),
-				),
-			);
+				);
+				// 清理顺序：先摘 control（不再对它 invalidate），再撤 provider。
+				return () => {
+					if (ownControl !== null) controls.delete(ownControl);
+					ownControl = null;
+					return outerDispose();
+				};
+			});
 			ctx.logger?.info?.(`[skill-tag] attached per-agent provider, session=${sessionId}`);
 		} catch (error) {
 			ctx.logger?.error?.("[skill-tag] agent provider attach failed", error);
@@ -895,6 +959,13 @@ export async function apply(ctx, config) {
 
 	ctx.effect(() => () => { controls.clear(); sessionDenials.clear(); });
 
+	// 会话销毁即回收该会话的拒绝集。缺这条时 Map 只增不减：每开一个对话就多
+	// 一条 Set，关掉也不删，长跑进程按会话数无界增长。
+	ctx.on("session/disposed", (session) => {
+		const sessionId = sessionIdOfAgent({ session }) ?? session?.id;
+		if (sessionId) sessionDenials.delete(sessionId);
+	});
+
 	// 4b. 把「给技能打标签」这份手册注册成一个真实的 skill。
 	// 别人装上本插件后，他们的 agent 在 /skills 里就能看到 `tagging-skills`，
 	// 从而照着它给自己的技能打标签 —— 这是 m05073 要求的「可移植」落点：
@@ -941,9 +1012,13 @@ export async function apply(ctx, config) {
 	ctx.on("domain/changed", (change) => {
 		try {
 			if (change?.domain !== "skill_tag") return;
+			// 卸载中不再接新刷新：这些刷新会去读写正在关闭的 domain。
+			if (shuttingDown) return;
 			for (const agent of ctx.get("agents")?.list?.() ?? []) {
-				// refreshSession 自己已 async + try/catch，这里再包一层防同步抛出
-				try { void refreshSession(agent); } catch { /* ignore */ }
+				// refreshSession 自己已 async + try/catch，这里再包一层防同步抛出。
+				// 用 track() 登记：原先的 `void refreshSession(agent)` 没有 owner，
+				// 卸载时既不等它结算也不取消它。
+				try { track(refreshSession(agent)); } catch { /* ignore */ }
 			}
 		} catch (error) {
 			try {
@@ -953,8 +1028,9 @@ export async function apply(ctx, config) {
 	});
 
 	// 6. Settings-page API (host half of the UI; client half in lib/client.js).
-	//    Guarded: test planes may lack webServer.
-	if (ctx.webServer && typeof ctx.webServer.register === "function") {
+	//    与 storageDomain 同理：webServer 虽是 inject 里的强依赖，测试面会构造
+	//    不带它的 ctx，所以保留缺席守卫，保证 apply 在最小面上不抛。
+	if (typeof ctx.webServer?.register === "function") {
 		// listSkills(cwd): 技能发现。设置页没有 cwd → 只扫用户级根目录；
 		// 「管理标签」浮层知道自己在哪个工作区/对话，于是传 cwd 把项目级技能也扫进来。
 		mountApi(
@@ -993,9 +1069,13 @@ export async function apply(ctx, config) {
 				const ids = entity?.sessionIds;
 				return Array.isArray(ids) ? [...ids] : [];
 			},
+			// Host/Origin + 浏览器鉴权。webServer 只做路由匹配、不查来源，
+			// 不传它就等于任意外部页面都能跨源调用这些写端点。
+			getConnection(ctx),
 		);
 	} else {
-		ctx.logger?.warn?.("[skill-tag] webServer missing — settings API not mounted");
+		// 强依赖缺席只可能是测试面（真宿主里 inject 会挡住激活）。
+		ctx.logger?.warn?.("[skill-tag] webServer.register unavailable — settings API not mounted");
 	}
 
 	ctx.logger?.info?.("[skill-tag] apply() complete", {

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Skill tags",
+    "description": "Tags DSH skills and uses one boolean expression to pick, per workspace and per conversation, which subset of skills is handed to the model."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "技能标签",
+    "description": "给 DSH 的技能打标签，用一条布尔表达式在「工作区 / 对话」两级选出要下发给模型的技能子集。"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-skill-tag",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "给 DSH 的技能（skill）打标签，用一条布尔表达式在「工作区 / 对话」两级选出要下发给模型的技能子集",
   "type": "module",
   "main": "lib/index.js",
@@ -23,13 +23,15 @@
   "exports": {
     ".": "./lib/index.js",
     "./client": "./lib/client.js",
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./locale/*.json": "./locale/*.json"
   },
   "files": [
     "lib",
     "src",
     "skills",
     "tools",
+    "locale/*.json",
     "cordis.patch.yml",
     "README.md",
     "LICENSE",

package/src/api.js

@@ -57,26 +57,55 @@ function wsShape(ws) {
  *        工作区 id → 该工作区下的会话 id 列表（宿主 workspaceRegistry entity.sessionIds）。
  *        「一键下发」要知道发给谁；为 null 时退回对话自己记录的 sourceWorkspaceId。
  */
-export function createApiHandler(services, log, listSkills = null, resolveWorkspaceId = null, resolveWorkspacePath = null, resolveWorkspaceSessions = null) {
+export function createApiHandler(services, log, listSkills = null, resolveWorkspaceId = null, resolveWorkspacePath = null, resolveWorkspaceSessions = null, connection = null) {
 	const json = (res, code, obj) => {
 		res.writeHead(code, { "content-type": "application/json; charset=utf-8" });
 		res.end(JSON.stringify(obj));
 	};
+	const MAX_BODY = 1_000_000;
 	const readBody = (req) =>
 		new Promise((resolve, reject) => {
 			let data = "";
+			let settled = false;
 			req.on("data", (c) => {
+				if (settled) return;
 				data += c;
-				if (data.length > 1_000_000) reject(new Error("body too large"));
+				// 超限必须停：原实现 reject 之后仍继续累积字符串，
+				// 等于把「拒绝」写成了「慢慢吃满内存」。
+				if (data.length > MAX_BODY) {
+					settled = true;
+					req.destroy?.();
+					reject(new Error("body too large"));
+				}
+			});
+			req.on("end", () => {
+				if (!settled) { settled = true; resolve(data); }
+			});
+			req.on("error", (e) => {
+				if (!settled) { settled = true; reject(e); }
 			});
-			req.on("end", () => resolve(data));
-			req.on("error", reject);
 		});
 
 	return async function handler(req, res) {
 		const url = new URL(req.url ?? "/", "http://localhost");
 		const path = url.pathname.replace(/^\/skill-tag\/api/, "") || "/";
 		const method = req.method ?? "GET";
+
+		// 先过宿主 Connection 的 Host/Origin 与浏览器鉴权。webServer 本身不做任何
+		// 来源检查，不接这道防线的话，任意网页都能跨源调这些端点：写操作走
+		// mode:'no-cors' 的 simple request 不需要预检，读不到响应但写入已生效。
+		const rejection = connection?.requestRejection?.({ headers: req.headers });
+		if (rejection !== undefined) return json(res, rejection, { ok: false, error: "rejected" });
+
+		// 写操作必须是 JSON：挡掉 text/plain 的跨源 simple request（它不触发预检），
+		// 也让浏览器的跨源请求先走 CORS 预检。
+		if (method === "POST" || method === "PUT") {
+			const type = String(req.headers?.["content-type"] ?? "").toLowerCase();
+			if (!type.startsWith("application/json")) {
+				return json(res, 415, { ok: false, error: "content-type must be application/json" });
+			}
+		}
+
 		let body = {};
 		if (method === "POST" || method === "PUT") {
 			try {
@@ -439,7 +468,7 @@ export function createApiHandler(services, log, listSkills = null, resolveWorksp
 
 			// ── 「管理标签」双列界面 ───────────────────────────────────────
 			// 左列 = 标签条件（表达式）；右列 = 该工作区掌握/禁用的技能。
-			if (path === "/workspaces/expression" && (method === "POST" || method === "GET")) {
+			if (path === "/workspaces/expression" && method === "POST") {
 				// 保存左列表达式（空串 = 清空条件 = 回到"全部技能"）
 				const out = await services.workspaces.setExpression(q("workspaceId"), q("expression") ?? "");
 				return json(res, 200, { ok: true, workspace: wsShape(out.record), validation: out.validation });
@@ -571,7 +600,7 @@ export function createApiHandler(services, log, listSkills = null, resolveWorksp
 			//   · 已配置的对话必须显式 overwrite=true 才覆盖（界面二次勾选确认）。
 			//
 			// 这是 0.1.9 那轮修复的直接延续：用户改的东西不能被无差别覆盖。
-			if ((path === "/workspaces/push-preview" || path === "/workspaces/push") && (method === "GET" || method === "POST")) {
+			if ((path === "/workspaces/push-preview" || path === "/workspaces/push") && method === "POST") {
 				const wid = q("workspaceId");
 				if (!wid) return json(res, 400, { ok: false, error: "缺少 workspaceId" });
 				// 该工作区下的对话：**宿主 sessionIds 是唯一权威来源**。
@@ -627,7 +656,7 @@ export function createApiHandler(services, log, listSkills = null, resolveWorksp
 			// 对话拥有**自己的**配置快照（own）：标签条件 + 手动添加 + 禁用。
 			// 工作区配置不会自动流入对话，除非：新建对话（自动继承一次）或
 			// 用户点了「继承工作区配置」按钮。
-			if (path === "/conversations/config" && (method === "GET" || method === "POST")) {
+			if (path === "/conversations/config" && method === "POST") {
 				const cid = q("conversationId");
 				const wid = workspaceIdForConversation(cid);
 				// 打开「管理标签（对话）」是**纯读**：只保证对话行存在，绝不播种 own。
@@ -683,14 +712,19 @@ export function createApiHandler(services, log, listSkills = null, resolveWorksp
 	};
 }
 
-/** Mount the handler on a cordis ctx (inject webServer). */
-export function mountApi(ctx, services, listSkills = null, resolveWorkspaceId = null, resolveWorkspacePath = null, resolveWorkspaceSessions = null) {
+/**
+ * Mount the handler on a cordis ctx (inject webServer).
+ *
+ * connection 用来做 Host/Origin 与浏览器鉴权：webServer 自身只做路由匹配，
+ * 不做任何来源检查。它可能缺席（无浏览器组合），那时 handler 会跳过校验。
+ */
+export function mountApi(ctx, services, listSkills = null, resolveWorkspaceId = null, resolveWorkspacePath = null, resolveWorkspaceSessions = null, connection = null) {
 	ctx.effect(
 		() =>
 			ctx.webServer.register({
 				kind: "prefix",
 				path: "/skill-tag/api",
-				handler: createApiHandler(services, ctx.logger, listSkills, resolveWorkspaceId, resolveWorkspacePath, resolveWorkspaceSessions),
+				handler: createApiHandler(services, ctx.logger, listSkills, resolveWorkspaceId, resolveWorkspacePath, resolveWorkspaceSessions, connection),
 			}),
 		"skill-tag: api",
 	);

package/src/skill-scan.js

@@ -70,6 +70,17 @@ function collectRoot(dir, depth, root, out) {
 	}
 }
 
+/**
+ * 合法技能名：kebab-case，与宿主 @deepseek-ai/dsh-skill 的 SKILL_NAME 同一正则。
+ *
+ * 为什么扫描器也要过这一关（2026-11-12，issue #6）：扫描结果会进 universe，
+ * 于是 denied = universe − visible 里也会出现它；只要这个名字非法，宿主
+ * validateCandidate 就会抛错、整个 provider 作废、**所有对话**都跑不下去。
+ * 宿主自己的文件系统 provider 早就这么做了（`skill file ... ignored: invalid
+ * skill name`），自扫描必须同口径，否则插件会把宿主本来就不认的名字当成技能。
+ */
+const SKILL_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+
 function pushSkill(out, mdPath, root, disabled, fallbackName) {
 	let fm = null;
 	try {
@@ -77,8 +88,15 @@ function pushSkill(out, mdPath, root, disabled, fallbackName) {
 	} catch {
 		return; // unreadable file — skip
 	}
+	// 裸放的根级 .md（flat skill）与宿主同口径：**必须有 frontmatter**。
+	// 没有 frontmatter 的 .md 只是一份普通文档（README、笔记…），不是技能；
+	// 旧实现会用文件名凭空造一个技能名，正是 issue #6 的来源。
+	const isFlat = fallbackName !== undefined;
+	if (isFlat && fm === null) return;
 	const name = fm?.name || fallbackName || path.basename(path.dirname(mdPath));
 	if (!name) return;
+	// 非法名字宁可丢掉：它既进不了宿主注册表，还会炸掉整批候选。
+	if (!SKILL_NAME_RE.test(name)) return;
 	out.push({
 		name,
 		description: fm?.description ?? "",