dsh-skill-tag 0.1.10 → 0.1.13

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 }, [
@@ -1112,6 +1309,98 @@ window.__ModuleLoader__.load({
 		const listRow = { display: "flex", alignItems: "center", gap: "8px", padding: "5px 2px", borderBottom: "1px solid var(--theme-border,#222)", fontSize: "12px" };
 		const monoStyle = { fontFamily: "ui-monospace,monospace" };
 
+		// ── 「一键下发」确认框（工作区版专用） ───────────────────────────
+		//
+		// 两步式（preview → push），因为这是**批量破坏性**操作：
+		//   · 打开时先 preview，看清"未配置 N 个 / 已配置 M 个"再决定；
+		//   · 默认只下发未配置的（overwrite=false）；
+		//   · 要覆盖已配置的必须勾选复选框（overwrite=true）；
+		//   · 工作区为空时明确警告「下发后这些对话将掌握全部技能」。
+		function PushToConversationsDialog({ workspaceId, workspaceEmpty, busy, onClose, onDone }) {
+			const [loading, setLoading] = react.useState(true);
+			const [info, setInfo] = react.useState(null);
+			const [err, setErr] = react.useState(null);
+			const [overwrite, setOverwrite] = react.useState(false);
+			const [running, setRunning] = react.useState(false);
+
+			react.useEffect(() => {
+				let alive = true;
+				(async () => {
+					try {
+						const d = await apiPost("/workspaces/push-preview", { workspaceId });
+						if (!d?.ok) throw new Error(d?.error ?? "预览失败");
+						if (alive) setInfo(d);
+					} catch (e) {
+						if (alive) setErr(String(e?.message ?? e));
+					} finally {
+						if (alive) setLoading(false);
+					}
+				})();
+				return () => { alive = false; };
+			}, [workspaceId]);
+
+			const fresh = info?.fresh ?? [];
+			const configured = info?.configured ?? [];
+			const targetCount = fresh.length + (overwrite ? configured.length : 0);
+			const isEmpty = info?.workspaceEmpty ?? workspaceEmpty;
+
+			const run = async () => {
+				setRunning(true);
+				try {
+					const d = await apiPost("/workspaces/push", { workspaceId, overwrite });
+					if (!d?.ok) throw new Error(d?.error ?? "下发失败");
+					onDone(d);
+				} catch (e) {
+					setErr(String(e?.message ?? e));
+				} finally {
+					setRunning(false);
+				}
+			};
+
+			const rowStyle = { display: "flex", gap: "8px", alignItems: "center", padding: "4px 0", fontSize: "12px" };
+			return react.createElement("div", { style: overlayStyle, onMouseDown: (e) => { if (e.target === e.currentTarget) onClose(); } },
+				react.createElement("div", { style: { ...modalBox, width: "600px" }, onClick: (e) => e.stopPropagation() }, [
+					react.createElement("div", { key: "h", style: { display: "flex", justifyContent: "space-between", alignItems: "center", marginBottom: "10px" } }, [
+						react.createElement("strong", { key: "t" }, "下发到该工作区下的所有对话"),
+						react.createElement("button", { key: "x", style: btn, onClick: onClose }, "✕"),
+					]),
+					loading && react.createElement("div", { key: "l", style: { color: "#888", padding: "14px 0" } }, "正在统计受影响的对话…"),
+					err && react.createElement("div", { key: "e", style: { color: "#e74c3c", padding: "8px 0" } }, err),
+					!loading && !err && info && react.createElement(react.Fragment, { key: "body" }, [
+						// 工作区为空时：必须让用户看见"这等于全部技能"
+						isEmpty && react.createElement("div", { key: "warn", style: { background: "rgba(230,126,34,0.14)", border: "1px solid rgba(230,126,34,0.45)", borderRadius: "8px", padding: "8px 10px", marginBottom: "10px", color: "#e67e22", fontSize: "12px" } },
+							"⚠ 当前工作区的标签条件为空、且没有手动添加/禁用的技能。下发后这些对话会变成「空条件 = 掌握全部技能」。"),
+						react.createElement("div", { key: "sum", style: { fontSize: "12px", marginBottom: "8px", lineHeight: 1.7 } }, [
+							react.createElement("div", { key: "a" }, `该工作区下共 ${info.total ?? 0} 个对话`),
+							react.createElement("div", { key: "b", style: { color: "#2ecc71" } }, `· 从未配置过：${fresh.length} 个（默认下发）`),
+							react.createElement("div", { key: "c", style: { color: "#888" } }, `· 已有自己的配置：${configured.length} 个（默认跳过）`),
+						]),
+						configured.length > 0 && react.createElement("label", { key: "ow", style: { ...rowStyle, cursor: "pointer", padding: "6px 0", borderTop: "1px solid var(--theme-border,#222)" } }, [
+							react.createElement("input", {
+								key: "c", type: "checkbox", checked: overwrite,
+								"data-skill-tag-push-overwrite": "1",
+								onChange: (e) => setOverwrite(e.target.checked),
+							}),
+							react.createElement("span", { key: "t", style: { color: "#e67e22" } },
+								`同时覆盖那 ${configured.length} 个已有配置的对话（会抹掉它们各自的调整）`),
+						]),
+						react.createElement("div", { key: "cnt", style: { fontSize: "12px", color: "#888", marginTop: "8px" } },
+							targetCount === 0
+								? "没有需要下发的对话。勾选上面的复选框可以覆盖已配置的对话。"
+								: `将实际写入 ${targetCount} 个对话`),
+					]),
+					react.createElement("div", { key: "f", style: { display: "flex", justifyContent: "flex-end", gap: "8px", marginTop: "14px" } }, [
+						react.createElement("button", { key: "c", style: btn, disabled: running, onClick: onClose }, "取消"),
+						react.createElement("button", {
+							key: "go", style: { ...btn, background: "#e67e22", color: "#fff", borderColor: "#e67e22" },
+							disabled: running || busy || loading || !!err || targetCount === 0,
+							"data-skill-tag-push-confirm": "1",
+							onClick: () => void run(),
+						}, running ? "下发中…" : `确认下发（${targetCount}）`),
+					]),
+				]),
+			);
+		}
 		// ── 双列主界面（工作区版 / 对话版共用） ─────────────────────────
 		//
 		// 两个作用域的唯一差别是四组端点 + 一个「继承工作区配置」按钮：
@@ -1158,6 +1447,8 @@ window.__ModuleLoader__.load({
 			const [pickOpen, setPickOpen] = react.useState(false);
 			const [disabledOpen, setDisabledOpen] = react.useState(false);
 			const [tagOfSkill, setTagOfSkill] = react.useState(null);
+			/** 「一键下发」确认框（只在工作区版用） */
+			const [pushOpen, setPushOpen] = react.useState(false);
 			/** 右列技能搜索词（对话版 / 工作区版共用；只影响列表显示，不影响下发结果） */
 			const [skillSearch, setSkillSearch] = react.useState("");
 
@@ -1275,6 +1566,14 @@ window.__ModuleLoader__.load({
 								key: "set", style: btn, disabled: busy,
 								onClick: () => setSettingsOpen(true),
 							}, "tag 设置"),
+							// 「一键下发」只在工作区版出现：把当前工作区配置推给该工作区下所有对话。
+							// 与对话版的「继承」是同一个数据动作，区别是批量 + 带选择性覆盖。
+							!scope.isConv && react.createElement("button", {
+								key: "push", style: { ...btn, color: "#e67e22" }, disabled: busy,
+								title: "把本工作区的标签条件 / 手动添加 / 禁用一次性下发到该工作区下的所有对话",
+								"data-skill-tag-push": "1",
+								onClick: () => setPushOpen(true),
+							}, "下发到所有对话"),
 							// 「继承工作区配置」只在对话版出现：把当前工作区的三件套整体搬过来
 							scope.isConv && react.createElement("button", {
 								key: "inh", style: { ...btn, color: "#3498db" }, disabled: busy,
@@ -1376,6 +1675,25 @@ window.__ModuleLoader__.load({
 						},
 					}),
 
+					// ── 弹窗：一键下发到所有对话（工作区版） ──
+					!scope.isConv && pushOpen && react.createElement(PushToConversationsDialog, {
+						key: "push",
+						workspaceId: scope.id,
+						workspaceEmpty: !view.hasFilter && (ws?.manualSkills ?? []).length === 0 && (ws?.disabledSkills ?? []).length === 0,
+						busy,
+						onClose: () => setPushOpen(false),
+						onDone: (d) => {
+							setPushOpen(false);
+							// 服务端返回的是 id 数组（updated / overwritten），界面只关心条数
+							const n = (v) => (Array.isArray(v) ? v.length : (typeof v === "number" ? v : 0));
+							const parts = ["已下发 " + n(d.updated) + " 个对话"];
+							if (n(d.overwritten)) parts.push("其中覆盖 " + n(d.overwritten) + " 个");
+							if (n(d.skipped)) parts.push("跳过 " + n(d.skipped) + " 个已有配置的");
+							setNotice(parts.join("，"));
+							void load();
+						},
+					}),
+
 					// ── 弹窗：被禁用的技能 ──
 					disabledOpen && react.createElement(DisabledSkillsDialog, {
 						key: "dis",
@@ -1708,6 +2026,8 @@ window.__ModuleLoader__.load({
 			workspaceIdOfRowKey, isWorkspaceMenu, manage, manageSet,
 			manageScope, registerComposerEntry,
 			skillPathOf, RevealButton, ownedTagsFirst,
+			// 失效技能判定（三处界面共用同一套口径，单独测）
+			staleSetOf, tagHasStale, partitionStaleSkills, STALE_COLOR,
 		};
 		return module.exports;
 	},

package/lib/index.js

@@ -952,6 +952,14 @@ export async function apply(ctx, config) {
 				const entity = registry?.get?.(workspaceId);
 				return entity?.path ?? null;
 			},
+			// 工作区 id → 该工作区下的会话 id 列表（「一键下发」要知道发给谁）。
+			// 宿主把归属记在 workspace entity 的 sessionIds 上（dsh-workspace）。
+			(workspaceId) => {
+				const registry = getWorkspaceRegistry(ctx);
+				const entity = registry?.get?.(workspaceId);
+				const ids = entity?.sessionIds;
+				return Array.isArray(ids) ? [...ids] : [];
+			},
 		);
 	} else {
 		ctx.logger?.warn?.("[skill-tag] webServer missing — settings API not mounted");

package/package.json

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

package/src/api.js

@@ -33,8 +33,11 @@ function wsShape(ws) {
  * @param {((workspaceId: string) => string|null) | null} [resolveWorkspacePath]
  *        工作区 id → 目录路径（宿主 workspaceRegistry entity.path）。用于把
  *        项目级技能根目录扫进来；为 null 时只能用插件自己记录过的 path。
+ * @param {((workspaceId: string) => string[]) | null} [resolveWorkspaceSessions]
+ *        工作区 id → 该工作区下的会话 id 列表（宿主 workspaceRegistry entity.sessionIds）。
+ *        「一键下发」要知道发给谁；为 null 时退回对话自己记录的 sourceWorkspaceId。
  */
-export function createApiHandler(services, log, listSkills = null, resolveWorkspaceId = null, resolveWorkspacePath = null) {
+export function createApiHandler(services, log, listSkills = null, resolveWorkspaceId = null, resolveWorkspacePath = null, resolveWorkspaceSessions = null) {
 	const json = (res, code, obj) => {
 		res.writeHead(code, { "content-type": "application/json; charset=utf-8" });
 		res.end(JSON.stringify(obj));
@@ -205,6 +208,20 @@ export function createApiHandler(services, log, listSkills = null, resolveWorksp
 		};
 	}
 
+	/**
+	 * 工作区配置是否"全空"（无条件 + 无手动 + 无禁用）。
+	 * 下发全空配置 = 让对话掌握全部技能，必须在界面上明确警告。
+	 */
+	function isEmptyWorkspaceConfig(ws) {
+		if (!ws) return true;
+		const ors = (ws.config?.orTags ?? []).length;
+		const groups = (ws.config?.andGroups ?? []).length;
+		const expr = String(ws.expression ?? "").trim();
+		return ors === 0 && groups === 0 && expr === ""
+			&& (ws.manualSkills ?? []).length === 0
+			&& (ws.disabledSkills ?? []).length === 0;
+	}
+
 	/** 对话绑定到哪个工作区（优先宿主 registry，其次对话自己记录的）。 */
 	function workspaceIdForConversation(conversationId) {
 		const conv = services.conversations.get(conversationId);
@@ -229,7 +246,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 自己拉起文件管理器。
@@ -464,6 +520,52 @@ export function createApiHandler(services, log, listSkills = null, resolveWorksp
 				});
 			}
 
+			// ── 「一键下发工作区配置到该工作区下所有对话」 ────────────────
+			//
+			// 动机：工作区配置改完，散落的对话各自为政。逐个点「继承」太麻烦，
+			// 于是提供一个批量下发。但**批量破坏性操作必须有护栏**：
+			//   · preview（GET/POST /workspaces/push-preview）只试算，不写；
+			//   · push 默认 overwrite=false，只填「从未配置过」的对话；
+			//   · 已配置的对话必须显式 overwrite=true 才覆盖（界面二次勾选确认）。
+			//
+			// 这是 0.1.9 那轮修复的直接延续：用户改的东西不能被无差别覆盖。
+			if ((path === "/workspaces/push-preview" || path === "/workspaces/push") && (method === "GET" || method === "POST")) {
+				const wid = q("workspaceId");
+				if (!wid) return json(res, 400, { ok: false, error: "缺少 workspaceId" });
+				// 该工作区下的对话：宿主 sessionIds 是权威来源。
+				// resolveWorkspaceSessions 没注入时退回对话自己记录的 sourceWorkspaceId。
+				let ids = [];
+				if (typeof resolveWorkspaceSessions === "function") {
+					try { ids = resolveWorkspaceSessions(wid) ?? []; } catch { ids = []; }
+				}
+				if (!Array.isArray(ids)) ids = [];
+				// 并入已存在的 own.sourceWorkspaceId 指向本工作区的对话（宿主列表可能不含历史会话）
+				for (const c of services._caches.conversations.values()) {
+					if (c?.own?.sourceWorkspaceId === wid) ids.push(c.conversationId);
+				}
+				ids = [...new Set(ids.filter(Boolean))];
+
+				if (path === "/workspaces/push-preview") {
+					const preview = services.conversations.previewPushWorkspace(ids);
+					const ws = services.workspaces.get(wid);
+					return json(res, 200, {
+						ok: true,
+						workspaceId: wid,
+						...preview,
+						// 工作区当前是否为空（空 = 下发等于"掌握全部技能"，界面要明确警告）
+						workspaceEmpty: isEmptyWorkspaceConfig(ws),
+					});
+				}
+
+				const overwrite = body?.overwrite === true;
+				try {
+					const out = await services.conversations.pushWorkspaceToConversations(wid, ids, { overwrite });
+					return json(res, 200, { ok: true, workspaceId: wid, ...out });
+				} catch (error) {
+					return json(res, 400, { ok: false, error: String(error?.message ?? error) });
+				}
+			}
+			
 			// ── 「对话 → 管理标签」双列界面 ────────────────────────────────
 			// 对话拥有**自己的**配置快照（own）：标签条件 + 手动添加 + 禁用。
 			// 工作区配置不会自动流入对话，除非：新建对话（自动继承一次）或
@@ -525,13 +627,13 @@ 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) {
+export function mountApi(ctx, services, listSkills = null, resolveWorkspaceId = null, resolveWorkspacePath = null, resolveWorkspaceSessions = null) {
 	ctx.effect(
 		() =>
 			ctx.webServer.register({
 				kind: "prefix",
 				path: "/skill-tag/api",
-				handler: createApiHandler(services, ctx.logger, listSkills, resolveWorkspaceId, resolveWorkspacePath),
+				handler: createApiHandler(services, ctx.logger, listSkills, resolveWorkspaceId, resolveWorkspacePath, resolveWorkspaceSessions),
 			}),
 		"skill-tag: api",
 	);

package/src/service.js

@@ -701,6 +701,54 @@ export function createServices(repo, opts = {}) {
 			return Boolean(conversations.get(conversationId)?.own);
 		},
 
+		/**
+		 * 「一键下发到工作区下所有对话」：把工作区当前三件套批量写进一批对话的 own。
+		 *
+		 * 与 inheritFromWorkspace 的区别是**批量**且带**选择性覆盖**：
+		 *   overwrite=false（默认）→ 只填 own 为 null 的对话（从未配置过）；
+		 *   overwrite=true          → 连已配置的也一起覆盖（界面要求二次确认）。
+		 *
+		 * 为什么默认不覆盖：已配置的对话要么是出生时继承的快照，要么是用户手工
+		 * 调过的。无差别覆盖会抹掉用户意志 —— 0.1.9 那次修复的核心教训。
+		 *
+		 * @param {string} workspaceId
+		 * @param {string[]} conversationIds 该工作区下的对话（由宿主 sessionIds 解析）
+		 * @param {{overwrite?: boolean}} [opts]
+		 * @returns {Promise<{updated: string[], skipped: string[], overwritten: string[]}>}
+		 */
+		async pushWorkspaceToConversations(workspaceId, conversationIds, opts = {}) {
+			const overwrite = opts.overwrite === true;
+			const ws = workspaces.get(workspaceId);
+			if (!ws) throw new Error(`workspace '${workspaceId}' not found`);
+			const updated = [];
+			const skipped = [];
+			const overwritten = [];
+			for (const cid of [...new Set(conversationIds ?? [])].filter(Boolean)) {
+				const conv = await this.ensureOwn(cid);
+				const hadOwn = Boolean(conv.own);
+				if (hadOwn && !overwrite) { skipped.push(cid); continue; }
+				conv.own = ownConfigFromWorkspace(ws);
+				if (!conv.inherited.workspaceId) conv.inherited.workspaceId = ws.workspaceId;
+				await repo.putConversation(serializeConversation(conv));
+				updated.push(cid);
+				if (hadOwn) overwritten.push(cid);
+			}
+			return { updated, skipped, overwritten };
+		},
+
+		/**
+		 * 试算「一键下发」会影响哪些对话（不写任何数据）。
+		 * 界面在确认框里展示这个结果，用户看清范围再决定。
+		 */
+		previewPushWorkspace(conversationIds) {
+			const fresh = [];
+			const configured = [];
+			for (const cid of [...new Set(conversationIds ?? [])].filter(Boolean)) {
+				(this.isConfigured(cid) ? configured : fresh).push(cid);
+			}
+			return { fresh, configured, total: fresh.length + configured.length };
+		},
+
 		/** 对话自己的配置快照（只读视图；保证字段完整） */
 		own(conversationId) {
 			const conv = conversations.get(conversationId);