dsh-skill-tag 0.1.10 → 0.1.12

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

@@ -208,3 +208,58 @@ mattpocock 的 25 个、archify 的 `archify`。
    不是模拟模型视野。
 2. `scope`：设置页没有 agent，只能拿 global 层。当前是「设置页列 global + 自扫描，
    对话页列该对话 agent 的真实集合」这种分区口径。
+## 8. 刷新技能列表 / 失效关联（2026-10-31）
+
+### 8.1 症状
+
+把 `mattpocock-skills-dsh` 插件 disable 之后，技能确实从模型视野里消失了，
+但本插件的界面**仍然认为它们在**，数字也不降。
+
+### 8.2 为什么没自动刷新
+
+两层原因，都不是"缓存没清"：
+
+1. **服务端本来就是实时的**。`GET /skills` 每次都重新问宿主 `ctx.skills.snapshot()`
+   + 补一次自扫描，没有任何缓存层。连问两次结果完全一致。
+2. **前端把"幽灵技能"也算进了计数**。`skillLinks` 表里存的是**历史关联记录**，
+   技能消失后这些记录不会自己消失（这是对的：插件只是被临时关闭，不该丢掉
+   用户手工打的标签）。旧实现在 `SkillTagPage` 里把它们并进 `names`：
+
+```js
+// 旧实现：先扫描结果，再补"只存在连接记录"的幽灵
+for (const l of links) if (!seen.has(l.skillId)) names.push({ name: l.skillId, ghost: true });
+// …然后 `技能 (${names.length})` ← 幽灵也被数进去了
+```
+
+本机实测：真实 82 个 + 幽灵 25 个（全部来自被 disable 的 mattpocock 插件）=
+界面显示 **107**。所以"刷新按钮"必须同时解决**计数口径**，否则点了数字还是不变。
+
+### 8.3 改动
+
+| 位置 | 改动 |
+| --- | --- |
+| `src/api.js` `GET /skills` | 额外返回 `stale: [{skillId, tagIds}]` —— 有标签关联但这次发现不到的技能。**只报告，不删**。 |
+| `src/api.js` `POST /skills/purge-stale` | 只删这些失效关联。发现结果为 **0 时直接 409 拒绝**（`NO_SKILLS`），避免宿主未就绪时把全部关联当成失效。支持 `skillIds` 白名单只删勾选的。 |
+| `lib/client.js` `Section` | 新增 state `stale`；新增 `refreshSkills()`（重新拉 `/state` + `/skills`）与 `purgeStale()`（二次确认后调 purge）。 |
+| `lib/client.js` 主页面 | 导航栏加「刷新技能列表」；有 stale 时顶部橙色提示条 + 「清理失效关联」。 |
+| `lib/client.js` `SkillTagPage` | **计数只算真实技能**：`技能 (N)` + `· 失效 M`；失效项在左列下方单列（带删除线、不显示 📁）；选中失效技能时给解释条。 |
+
+### 8.4 为什么不自动删
+
+关联是用户手工打的标签。插件被临时关闭 ≠ 用户放弃这些标签 —— 重新启用后
+应该恢复。所以：**默认只标记，删除必须显式点击**，且点击时列出前 8 个名字
+并说明"重新启用插件后需要重新打标签"。
+
+### 8.5 验收
+
+```
+1. 关掉贡献技能的插件 → 点「刷新技能列表」
+   → 「技能 (N)」降到真实值；橙色条显示「有 25 个技能仍有标签关联，但当前发现不到」
+2. 重新打开插件 → 再点刷新
+   → 数字回升，橙色条消失，之前的标签关联**原样恢复**（因为一条都没删）
+3. 点「清理失效关联」→ 二次确认 → 关联被删，橙色条消失
+   → 再打开插件时这些技能不再带标签（预期行为，有文案提示）
+```
+
+测试：`tests/__page-render.mjs`（6 条渲染断言）+ `tests/conversation.test.mjs`
+（4 条 API 断言，含"GET 不删数据"与"发现为 0 时拒绝执行"两条保护性断言）。

package/lib/client.js

@@ -49,6 +49,44 @@ window.__ModuleLoader__.load({
 				+ `${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
 		}
 
+		// ── 失效技能（stale）的判定与分区 ──────────────────────────────
+		//
+		// 「失效」= 有标签关联，但**这次发现不到**（通常是贡献它的插件被关闭）。
+		// 服务端在 GET /skills 里把这类记录放在 stale 数组里报告，不删数据。
+		//
+		// 三处界面共用这一套判定，保证口径一致：
+		//   · skill 联系 tag（技能清单）：失效项置底 + 标红
+		//   · 主页面标签列表（TagList）：含失效技能的**标签名**标红
+		//   · tag 联系 skill（左列标签）：同上；右列技能列表失效项置底 + 标红
+
+		/** 失效技能名集合（来自 /skills 的 stale 报告）。 */
+		function staleSetOf(state) {
+			return new Set((state?.stale ?? []).map((s) => s?.skillId).filter(Boolean));
+		}
+
+		/** 这个标签是否含至少一个失效技能（决定标签名要不要标红）。 */
+		function tagHasStale(links, tagId, staleSet) {
+			if (!staleSet || staleSet.size === 0) return false;
+			return (links ?? []).some((l) => (l.tagIds ?? []).includes(tagId) && staleSet.has(l.skillId));
+		}
+
+		/**
+		 * 技能名分区：存活在前、失效在后，**各分区内部保持原顺序**。
+		 * 稳定分区（不是排序），所以用户看到的相对次序不会因为标红而跳动。
+		 * @param {Array<{skillId:string}|string>} items
+		 * @param {Set<string>} staleSet
+		 * @param {(x:any)=>string} nameOf
+		 */
+		function partitionStaleSkills(items, staleSet, nameOf = (x) => (typeof x === "string" ? x : x?.skillId)) {
+			const alive = [];
+			const stale = [];
+			for (const it of items ?? []) (staleSet.has(nameOf(it)) ? stale : alive).push(it);
+			return { alive, stale };
+		}
+
+		/** 失效技能的统一配色（与「全局删除」的红一致，但更暗一点，避免抢眼）。 */
+		const STALE_COLOR = "#e74c3c";
+
 		// zoneOf: §7 four-zone classification of a conversation tag entry.
 		function zoneOf(entry) {
 			if (entry.blocked) return "blocked";
@@ -178,6 +216,9 @@ window.__ModuleLoader__.load({
 		function Section() {
 			const [state, setState] = react.useState({
 				loading: true, error: null, data: null, skills: [],
+				// stale = 有标签关联、但当前发现不到的技能（贡献它的插件被关了）。
+				// 只标记，不自动删除 —— 用户显式点「清理失效关联」才动数据。
+				stale: [],
 				newTagName: "", busy: false, notice: null,
 				// sub-page routing: "main" | "links" | "skilltags" | "templates"
 				view: "main",
@@ -203,6 +244,7 @@ window.__ModuleLoader__.load({
 						error: d?.ok ? null : JSON.stringify(d),
 						data: d?.ok ? d : null,
 						skills: sk?.ok ? sk.skills : [],
+						stale: sk?.ok ? (sk.stale ?? []) : [],
 					}));
 				} catch (e) {
 					setState((s) => ({ ...s, loading: false, error: String(e), data: null }));
@@ -224,6 +266,42 @@ window.__ModuleLoader__.load({
 				}
 			}, [reload]);
 
+			/**
+			 * 刷新技能列表：重新问宿主一次当前真正可见的技能。
+			 * 用于「贡献技能的插件被关掉/打开」之后同步界面 —— 这类技能不落在任何
+			 * 文件系统根里，只能靠宿主注册表发现，插件启动后不会自动感知变化。
+			 */
+			const refreshSkills = react.useCallback(async () => {
+				setState((s) => ({ ...s, busy: true, notice: null }));
+				try {
+					await reload();
+					setState((s) => ({ ...s, busy: false, notice: `技能列表已刷新：${(s.skills ?? []).length} 个可见技能` }));
+				} catch (e) {
+					setState((s) => ({ ...s, busy: false, notice: "刷新失败: " + (e?.message ?? e) }));
+				}
+			}, [reload]);
+
+			/**
+			 * 清理失效关联（显式、可取消）：只删「有标签、但当前发现不到」的记录。
+			 * 服务端在发现结果为空时会拒绝执行（避免宿主未就绪时误删全部）。
+			 */
+			const purgeStale = react.useCallback(async () => {
+				const list = state.stale ?? [];
+				if (list.length === 0) return;
+				const names = list.map((s) => s.skillId);
+				const preview = names.slice(0, 8).join("\u3001") + (names.length > 8 ? ` 等 ${names.length} 个` : "");
+				if (!window.confirm(`清理 ${names.length} 条失效关联？\n\n${preview}\n\n这些技能当前发现不到（通常是贡献它的插件被关闭）。清理后它们的标签关联会删除；若之后重新启用那个插件，需要重新打标签。`)) return;
+				setState((s) => ({ ...s, busy: true, notice: null }));
+				try {
+					const d = await apiPost("/skills/purge-stale", { skillIds: names });
+					if (!d?.ok) throw new Error(d?.error ?? JSON.stringify(d));
+					await reload();
+					setState((s) => ({ ...s, busy: false, notice: `已清理 ${d.count ?? 0} 条失效关联` }));
+				} catch (e) {
+					setState((s) => ({ ...s, busy: false, notice: "清理失败: " + (e?.message ?? e) }));
+				}
+			}, [state.stale, reload]);
+
 			const { loading, error, data, busy, notice } = state;
 			if (loading) return react.createElement("div", { style: pad }, "加载中…");
 			if (error) return react.createElement("div", { style: pad }, "加载失败: " + error);
@@ -259,7 +337,32 @@ window.__ModuleLoader__.load({
 					react.createElement("button", {
 						style: { ...btn, padding: "6px 16px", fontSize: "13px" },
 						onClick: () => setState((s) => ({ ...s, view: "templates", tplId: null, tplIsNew: false, tplName: "", tplExpression: "" })),
-					}, "编辑标签组")),
+					}, "编辑标签组"),
+					// 刷新技能列表：贡献技能的插件被关闭/打开后界面不会自动感知，
+					// 这里显式重新问宿主一次（这类技能不落在任何文件系统根里）。
+					react.createElement("button", {
+						key: "refresh",
+						style: { ...btn, padding: "6px 16px", fontSize: "13px" },
+						disabled: busy,
+						title: "重新向宿主查询当前真正可用的技能（插件被关闭后用它同步列表）",
+						"data-skill-tag-refresh": "1",
+						onClick: () => void refreshSkills(),
+					}, "刷新技能列表")),
+				// 失效关联提示条：有标签、但当前发现不到的技能。
+				// 只提示不自动删；给一个显式清理入口（点击会二次确认）。
+				!loading && (state.stale ?? []).length > 0 && react.createElement("div", {
+					key: "stale",
+					style: { background: "rgba(230,126,34,0.12)", border: "1px solid rgba(230,126,34,0.4)", borderRadius: "8px", padding: "8px 10px", marginBottom: "12px", fontSize: "12px", color: "#e67e22", display: "flex", gap: "10px", alignItems: "center", flexWrap: "wrap" },
+				}, [
+					react.createElement("span", { key: "t", style: { flex: 1 } },
+						`有 ${(state.stale ?? []).length} 个技能仍有标签关联，但当前发现不到（通常是贡献它的插件被关闭）。`),
+					react.createElement("button", {
+						key: "p",
+						style: { ...btn, padding: "2px 10px", fontSize: "12px", color: "#e67e22" },
+						disabled: busy,
+						"data-skill-tag-purge": "1",
+						onClick: () => void purgeStale(),
+					}, "清理失效关联")]),
 				react.createElement(TagCreateForm, { key: "create", state, setState, act, busy }),
 				react.createElement(TagList, { key: "list", data, act, busy, state, setState }),
 			]);
@@ -295,6 +398,8 @@ window.__ModuleLoader__.load({
 			const links = data.skillLinks ?? [];
 			const workspaces = data.workspaces ?? [];
 			const catalog = state.skills ?? [];
+			// 失效技能集合：决定"哪些标签名要标红"以及"展开后哪些名字置底标红"。
+			const staleSet = staleSetOf(state);
 			// 每个标签默认折叠，只显示数量；点「▸」才展开下面的技能名。
 			// 本机 96 个技能 / 34 个标签，全展开会让这一页变成几百行的墙。
 			const open = state.openTags ?? {};
@@ -307,6 +412,9 @@ window.__ModuleLoader__.load({
 				tags.length === 0 && react.createElement("div", { key: "empty", style: { color: "#888" } }, "暂无标签"),
 				...tags.map((t) => {
 					const skills = links.filter((l) => l.tagIds.includes(t.tagId)).map((l) => l.skillId);
+					// 标签内技能分区：存活在前、失效在后（分区稳定，内部保序）
+					const split = partitionStaleSkills(skills, staleSet, (x) => x);
+					const hasStale = split.stale.length > 0;
 					const usedBy = workspaces.filter((w) => (w.config?.orTags ?? []).includes(t.tagId) || (w.config?.andGroups ?? []).some((g) => g.tagIds.includes(t.tagId))).map((w) => w.workspaceId);
 					const isOpen = !!open[t.tagId];
 					return react.createElement("div", { key: t.tagId, style: { padding: "4px 0", borderBottom: "1px solid var(--theme-border,#222)" } }, [
@@ -320,12 +428,21 @@ window.__ModuleLoader__.load({
 									"data-skill-tag-toggle": t.tagId,
 									onClick: () => toggleOpen(t.tagId),
 								}, isOpen ? "▾" : "▸"),
-							react.createElement("span", { key: "n", style: { fontWeight: 500 } }, t.name),
+							// 标签名：含失效技能时标红（图二/图三的要求 —— 只标红标签本身，
+							// 让用户一眼看出"这个标签关联到了已消失的技能"）。
+							react.createElement("span", {
+								key: "n",
+								style: { fontWeight: 500, ...(hasStale ? { color: STALE_COLOR } : {}) },
+								title: hasStale ? `该标签含 ${split.stale.length} 个失效技能（当前发现不到）` : undefined,
+								"data-skill-tag-stale-tag": hasStale ? t.tagId : undefined,
+							}, t.name),
 							react.createElement("span", { key: "id", style: { color: "#888", fontSize: "11px" } }, t.tagId),
 							react.createElement("span", {
 								key: "cnt", style: { color: "#888", fontSize: "11px" },
 								"data-skill-tag-count": t.tagId,
-							}, skills.length === 0 ? "无 Skill 关联" : `${skills.length} 个 Skill`),
+							}, skills.length === 0
+								? "无 Skill 关联"
+								: `${skills.length} 个 Skill` + (hasStale ? `（${split.stale.length} 失效）` : "")),
 							react.createElement("button", {
 								key: "del", style: { ...btn, color: "#e74c3c" }, disabled: busy,
 								onClick: () => {
@@ -336,10 +453,18 @@ window.__ModuleLoader__.load({
 						]),
 						// 展开后才列出技能（每行仍带「打开文件夹」，这里也是"列出 skill 的界面"）
 						isOpen && skills.length > 0 && react.createElement("div", { key: "sk", style: { display: "flex", gap: "6px", alignItems: "center", flexWrap: "wrap", fontSize: "11px", color: "#888", padding: "4px 0 2px 22px" } }, [
-							...skills.map((sid, i) => react.createElement("span", { key: sid + i, style: { display: "inline-flex", gap: "2px", alignItems: "center" } }, [
+							// 存活技能在前
+							...split.alive.map((sid, i) => react.createElement("span", { key: sid + i, style: { display: "inline-flex", gap: "2px", alignItems: "center" } }, [
 								sid,
 								react.createElement(RevealButton, { key: "rev", skillName: sid, path: skillPathOf(catalog, sid), label: "📁", style: { padding: "0 4px", fontSize: "10px" } }),
 							])),
+							// 失效技能置底：标红、删除线、不给 📁（本机没有该文件，点了必然失败）
+							...split.stale.map((sid, i) => react.createElement("span", {
+								key: "st" + i,
+								style: { display: "inline-flex", gap: "2px", alignItems: "center", color: STALE_COLOR, textDecoration: "line-through" },
+								title: "失效技能：当前发现不到（通常是贡献它的插件被关闭）。标签关联仍保留。",
+								"data-skill-tag-stale-skill": sid,
+							}, [sid])),
 						]),
 					]);
 				}),
@@ -414,7 +539,10 @@ window.__ModuleLoader__.load({
 			const sel = tags.find((t) => t.tagId === selId) ?? null;
 			const tagMatch = (t) => !state.tagSearch.trim() || t.name.toLowerCase().includes(state.tagSearch.trim().toLowerCase());
 			const skillMatch = (s) => !state.skillSearch.trim() || s.skillId.toLowerCase().includes(state.skillSearch.trim().toLowerCase());
+			// 失效技能集合：标签名标红 + 右列技能列表分区（存活在前、失效置底标红）
+			const staleSet = staleSetOf(state);
 			const linkedSkills = skillsLinkedTo(links, selId).filter(skillMatch);
+			const linkedSplit = partitionStaleSkills(linkedSkills, staleSet);
 			const createTag = async () => {
 				const name = state.newTagName.trim();
 				if (!name) return;
@@ -451,12 +579,18 @@ window.__ModuleLoader__.load({
 							tags.filter(tagMatch).length === 0 && react.createElement("div", { key: "e", style: { color: "#888", fontSize: "12px", padding: "6px 2px" } }, "无匹配标签"),
 							...tags.filter(tagMatch).map((t) => {
 								const n = links.filter((l) => l.tagIds.includes(t.tagId)).length;
+								// 含失效技能的标签：只把**标签名**标红（图三的要求），其余样式不变
+								const hasStale = tagHasStale(links, t.tagId, staleSet);
 								return react.createElement("div", {
 									key: t.tagId, style: t.tagId === selId ? selRowStyle : rowStyle,
 									onClick: () => setState((s) => ({ ...s, linkTagId: t.tagId })),
-									title: "点击选中",
+									title: hasStale ? "该标签含失效技能（当前发现不到），点开可见" : "点击选中",
 								}, [
-									react.createElement("span", { key: "n", style: { fontWeight: t.tagId === selId ? 600 : 400, flex: 1, cursor: "pointer" } }, t.name),
+									react.createElement("span", {
+										key: "n",
+										style: { fontWeight: t.tagId === selId ? 600 : 400, flex: 1, cursor: "pointer", ...(hasStale ? { color: STALE_COLOR } : {}) },
+										"data-skill-tag-stale-tag": hasStale ? t.tagId : undefined,
+									}, t.name),
 									react.createElement("span", { key: "c", style: { color: "#888", fontSize: "11px" } }, n ? `${n} skill` : ""),
 									react.createElement("button", {
 										key: "del", style: { ...btn, color: "#e74c3c", padding: "1px 8px" }, disabled: busy,
@@ -494,7 +628,8 @@ window.__ModuleLoader__.load({
 							}),
 							react.createElement("div", { key: "rows", style: { maxHeight: "340px", overflowY: "auto" } }, [
 								linkedSkills.length === 0 && react.createElement("div", { key: "e", style: { color: "#888", fontSize: "12px", padding: "6px 2px" } }, "该标签暂未关联任何 Skill"),
-								...linkedSkills.map((s) => {
+								// 存活技能在前
+								...linkedSplit.alive.map((s) => {
 									const ghost = !skills.some((x) => x.name === s.skillId);
 									return react.createElement("div", { key: s.skillId, style: rowStyle, title: ghost ? "未在本机扫描到(关联仍生效)" : "" }, [
 										react.createElement("span", { key: "n", style: { flex: 1 } }, s.skillId + (ghost ? " *" : "")),
@@ -505,6 +640,20 @@ window.__ModuleLoader__.load({
 										}, "移除"),
 									]);
 								}),
+								// 失效技能置底：名字标红 + 删除线；不给 📁（本机没有该文件）
+								...linkedSplit.stale.map((s) => react.createElement("div", {
+									key: "st" + s.skillId,
+									style: { ...rowStyle, opacity: 0.85 },
+									title: "失效技能：当前发现不到（通常是贡献它的插件被关闭）。标签关联仍保留。",
+									"data-skill-tag-stale-skill": s.skillId,
+								}, [
+									react.createElement("span", { key: "n", style: { flex: 1, color: STALE_COLOR, textDecoration: "line-through" } }, s.skillId),
+									// 仍允许移除（用户可能就是想清掉它）
+									react.createElement("button", {
+										key: "rm", style: { ...btn, color: "#e67e22", padding: "1px 8px" }, disabled: busy,
+										onClick: () => void removeSkill(s.skillId),
+									}, "移除"),
+								])),
 							]),
 							react.createElement("div", { key: "add", style: { display: "flex", gap: "8px", marginTop: "10px", paddingTop: "8px", borderTop: "1px solid var(--theme-border,#222)" } }, [
 								react.createElement("button", {
@@ -533,11 +682,18 @@ window.__ModuleLoader__.load({
 			const scanned = state.skills ?? [];
 			const selName = state.linkSkillName;
 
-			// 技能清单：先扫描结果（按名字），再补上"只存在连接记录"的幽灵技能
+			// 技能清单：**只列当前真正存在的技能**（scanned = 这次刷新发现到的）。
+			//
+			// 2026-10-31 改：此前会把"只存在连接记录"的幽灵技能也算进 `技能 (N)`，
+			// 于是关掉贡献技能的插件后，数字仍然不变（本机 82 真 + 25 幽灵 = 107）。
+			// 现在幽灵单独归类为 stale，计数只算真技能 —— 用户说的"更新列表和数目"。
 			const names = [];
 			const seen = new Set();
 			for (const s of scanned) { if (s?.name && !seen.has(s.name)) { names.push({ name: s.name, ghost: false }); seen.add(s.name); } }
-			for (const l of links) { if (!seen.has(l.skillId)) { names.push({ name: l.skillId, ghost: true }); seen.add(l.skillId); } }
+			const stale = (state.stale ?? []).filter((s) => s?.skillId && !seen.has(s.skillId));
+			const staleIds = new Set(stale.map((s) => s.skillId));
+			// 已选中但当前失效的技能：仍然显示，否则右侧会突然空白且没有解释。
+			const selIsStale = Boolean(selName && staleIds.has(selName));
 			const match = (n) => !state.skillPickSearch.trim() || n.toLowerCase().includes(state.skillPickSearch.trim().toLowerCase());
 			const shown = names.filter((n) => match(n.name));
 
@@ -567,12 +723,28 @@ window.__ModuleLoader__.load({
 					react.createElement("button", { key: "back", style: btn, disabled: busy, onClick: () => setState((s) => ({ ...s, view: "main", linkSkillName: null })) }, "← 返回"),
 					react.createElement("h3", { key: "t", style: { margin: 0 } }, "skill 联系 tag"),
 					selName && react.createElement("span", { key: "cur", style: { color: "#888", fontSize: "12px" } }, `当前技能: ${selName}`),
+					// 刷新技能列表：插件关停/启用后手动同步（服务端每次都是实时查询，
+					// 这里只是把前端那份缓存重新拉一遍）。
+					react.createElement("button", {
+						key: "refresh",
+						style: { ...btn, marginLeft: "auto" },
+						disabled: busy,
+						title: "重新向宿主查询当前真正可用的技能",
+						"data-skill-tag-refresh": "1",
+						onClick: () => void refreshSkills(),
+					}, "刷新技能列表"),
 				]),
 				notice && react.createElement("div", { key: "n", style: noteStyle }, notice),
+				// 选中了一个当前已经失效的技能：右侧标签仍可看/可改，但要讲清原因。
+				selIsStale && react.createElement("div", {
+					key: "staleSel",
+					style: { background: "rgba(230,126,34,0.12)", border: "1px solid rgba(230,126,34,0.4)", borderRadius: "8px", padding: "6px 10px", marginBottom: "10px", fontSize: "12px", color: "#e67e22" },
+				}, `「${selName}」当前发现不到（通常是贡献它的插件被关闭）。标签关联仍保留，重新启用插件后自动恢复可见。`),
 				react.createElement("div", { key: "cols", style: { display: "flex", gap: "12px", alignItems: "flex-start" } }, [
 					// ── 左列：技能 ──────────────────────────────────────────
 					react.createElement("div", { key: "left", style: colStyle }, [
-						react.createElement("div", { key: "lt", style: { fontWeight: 600, marginBottom: "6px" } }, `技能 (${names.length})`),
+						react.createElement("div", { key: "lt", style: { fontWeight: 600, marginBottom: "6px" } },
+							`技能 (${names.length})` + (stale.length ? ` · 失效 ${stale.length}` : "")),
 						react.createElement("input", {
 							key: "search", style: { ...input, width: "100%", marginBottom: "6px" }, placeholder: "搜索技能…",
 							value: state.skillPickSearch, onChange: (e) => setState((s) => ({ ...s, skillPickSearch: e.target.value })),
@@ -593,6 +765,31 @@ window.__ModuleLoader__.load({
 								]);
 							}),
 						]),
+						// 失效技能单列：只在有标签关联、但当前发现不到时出现。
+						// 位置固定在最底部（图一的要求），名字标红 + 删除线；
+						// 计数不算进上面的「技能 (N)」；默认不删，给一个显式清理入口。
+						stale.length > 0 && react.createElement("div", { key: "staleBox", style: { marginTop: "10px", paddingTop: "8px", borderTop: "1px solid var(--theme-border,#222)" } }, [
+							react.createElement("div", { key: "h", style: { display: "flex", alignItems: "center", gap: "8px", fontSize: "12px", color: "#e67e22", marginBottom: "4px" } }, [
+								react.createElement("span", { key: "t", style: { flex: 1 } }, `失效 ${stale.length} 个（有标签关联，但当前发现不到）`),
+								react.createElement("button", {
+									key: "p",
+									style: { ...btn, padding: "1px 8px", fontSize: "11px", color: "#e67e22" },
+									disabled: busy,
+									"data-skill-tag-purge": "1",
+									onClick: () => void purgeStale(),
+								}, "清理失效关联")]),
+							...stale.slice(0, 30).map((s) => react.createElement("div", {
+								key: s.skillId,
+								style: { ...rowStyle, cursor: "pointer" },
+								title: "失效技能：当前发现不到（通常是贡献它的插件被关闭）。点击查看它保留的标签关联。",
+								"data-skill-tag-stale-skill": s.skillId,
+								onClick: () => setState((st) => ({ ...st, linkSkillName: s.skillId })),
+							}, [
+								react.createElement("span", { key: "n", style: { flex: 1, color: STALE_COLOR, textDecoration: "line-through" } }, s.skillId),
+								react.createElement("span", { key: "c", style: { fontSize: "11px" } }, `${(s.tagIds ?? []).length} tag`),
+							])),
+							stale.length > 30 && react.createElement("div", { key: "more", style: { color: "#888", fontSize: "11px", padding: "2px 4px" } }, `…还有 ${stale.length - 30} 个`),
+						]),
 					]),
 					// ── 右列：该技能的标签 ──────────────────────────────────
 					react.createElement("div", { key: "right", style: colStyle }, [
@@ -1708,6 +1905,8 @@ window.__ModuleLoader__.load({
 			workspaceIdOfRowKey, isWorkspaceMenu, manage, manageSet,
 			manageScope, registerComposerEntry,
 			skillPathOf, RevealButton, ownedTagsFirst,
+			// 失效技能判定（三处界面共用同一套口径，单独测）
+			staleSetOf, tagHasStale, partitionStaleSkills, STALE_COLOR,
 		};
 		return module.exports;
 	},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-skill-tag",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "给 DSH 的技能（skill）打标签，用一条布尔表达式在「工作区 / 对话」两级选出要下发给模型的技能子集",
   "type": "module",
   "main": "lib/index.js",

package/src/api.js

@@ -229,7 +229,46 @@ export function createApiHandler(services, log, listSkills = null, resolveWorksp
 						workspaceId: q("workspaceId") ?? null,
 					})) ?? []
 					: [];
-				return json(res, 200, { ok: true, skills });
+				// stale = 有标签关联、但这次发现不到的技能（通常是贡献它的插件被关了）。
+				// 只**报告**，不删：见 /skills/purge-stale 的注释。
+				const live = new Set(skills.map((s) => (typeof s === "string" ? s : s?.name)));
+				const stale = [...services._caches.skillLinks.values()]
+					.filter((l) => !live.has(l.skillId))
+					.map((l) => ({ skillId: l.skillId, tagIds: [...(l.tagIds ?? [])] }));
+				return json(res, 200, { ok: true, skills, stale });
+			}
+			// ── 「刷新技能列表」+「清理失效关联」 ─────────────────────────────
+			//
+			// 场景：某些技能由**别的插件**贡献（provider 注册进 ctx.skills，根本不落在
+			// 任何文件系统根里）。那个插件被 disable 之后，技能立刻消失，但插件这边
+			// 的 skillLinks 记录还留着 —— 界面上就表现为"技能还在、数字偏大"。
+			//
+			// 这里的口径：
+			//   GET  /skills            → 实时问宿主，顺带算出 stale（失效关联）
+			//   POST /skills/purge-stale → 只删这些失效关联记录（用户在界面上显式点）
+			//
+			// 为什么不在 GET 里顺手删：关联是用户手工打的标签，插件的临时缺席不等于
+			// 用户放弃它。默认只标记，删除必须显式触发。
+			if (path === "/skills/purge-stale" && method === "POST") {
+				const live = new Set(
+					((listSkills ? await listSkills(q("cwd") ?? undefined, {
+						conversationId: q("conversationId") ?? null,
+						workspaceId: q("workspaceId") ?? null,
+					}) : []) ?? []).map((s) => (typeof s === "string" ? s : s?.name)),
+				);
+				// 发现结果为空 = 宿主没就绪，此时"全是失效"是误判，绝不动数据。
+				if (live.size === 0) {
+					return json(res, 409, { ok: false, code: "NO_SKILLS", error: "当前发现到 0 个技能，拒绝清理（可能是宿主未就绪）" });
+				}
+				const wanted = Array.isArray(body?.skillIds) ? new Set(body.skillIds.map(String)) : null;
+				const removed = [];
+				for (const link of [...services._caches.skillLinks.values()]) {
+					if (live.has(link.skillId)) continue;          // 还活着 → 不动
+					if (wanted && !wanted.has(link.skillId)) continue; // 用户只勾了部分
+					removed.push(link.skillId);
+				}
+				for (const skillId of removed) await services.tags.unlinkSkill(skillId);
+				return json(res, 200, { ok: true, removed, count: removed.length });
 			}
 			// ── 「打开技能所在文件夹」 ─────────────────────────────────────
 			// 宿主没有暴露 shell/reveal 能力，由 src/reveal.js 自己拉起文件管理器。