dsh-skill-tag 0.1.8 → 0.1.12

package/README.md

@@ -20,8 +20,8 @@ office * plugin       # 只要 office 包带来的、且是插件相关
 | **全局标签** | 建/改名/删除标签，标签之间无层级 |
 | **标签组模板** | 把表达式存成模板（`前端组`、`只留本机技能`…），可复用、可求值 |
 | **布尔表达式** | `+`=OR、`*`=AND、`*` 优先、支持括号；改标签名会自动改写所有引用它的表达式 |
-| **工作区级筛选** | 每个工作区一套条件，只把命中的技能下发给该工作区的对话 |
-| **对话级筛选** | 每个对话可以有**自己的**快照，独立于所属工作区；可一键「继承工作区配置」 |
+| **工作区级筛选** | 每个工作区一套条件，作为该工作区**新建对话**的初始模板；改工作区不影响已存在的对话 |
+| **对话级筛选** | 每个对话有**自己的**快照：新建时继承一次，之后冻结；未配置过的对话 = 空条件 = 全部技能；可一键「继承工作区配置」重新拉取 |
 | **禁用 / 手动添加** | 在标签命中之外额外放行某个技能，或强行屏蔽某个（即使它命中） |
 | **技能 ↔ 标签双向编辑** | 「tag 联系 skill」和「skill 联系 tag」两个方向都能改 |
 | **打开技能所在文件夹** | 任何列出技能的地方都有 📁 按钮，一点即在文件管理器里定位 |

package/docs//345/257/271/350/257/235/347/256/241/347/220/206/346/240/207/347/255/276.md

@@ -20,10 +20,35 @@
 | 对话自己的禁用/手动添加 | **存在对话自己身上**（每对话独立，不影响工作区、不影响其他对话） |
 | 继承的覆盖范围 | **标签条件 + 手动添加 + 禁用，整体覆盖**（不是合并） |
 | 可见性规则 | 与工作区版相同：空条件 = 全部技能；有条件 = 标签命中 ∪ 手动添加 − 被禁用 |
+| 打开管理标签 | **纯读，不写入任何配置**（2026-10-31 修正，见 §1.1） |
 
 > **解耦原则**：对话一旦有了自己的配置快照（`own`），它就是这个对话的权威口径，
 > 哪怕这份快照是"空的"——空代表用户主动清空过条件，此时再跟着工作区漂移就是错的。
-> 见 `lib/index.js` 的 `effectiveSkillsConfig(own, ws)`。
+> 见 `lib/index.js` 的 `effectiveSkillsConfig(own)`。
+
+### 1.1 三种对话的统一口径（2026-10-31 用户确认）
+
+运行时只存在三种对话，判定与行为如下：
+
+| # | 类型 | 判据 | `own` | 可见技能 | 工作区再改时 |
+| --- | --- | --- | --- | --- | --- |
+| ① | 插件**安装前**就存在 | `session.header.createdAt < installed_at` | 保持 `null` | 空条件 = **全部技能** | 不受影响 |
+| ② | 刚创建的新对话 | 首次被观察时 `createdAt >= installed_at` | 出生时继承一次 | 继承工作区三件套 | 不再跟随 |
+| ③ | 安装后创建、已存在一阵 | 同 ②，但已播过种 | 已冻结 | 冻结值不变 | 不受影响 |
+
+**两条不变量**（改代码时不可破坏）：
+
+1. **`own` 只在两个时刻写入**：出生播种、用户点「继承工作区配置」。
+   用户手动编辑（tag 设置 / 手动添加 / 禁用）也算显式写入，但只动已有快照。
+   **打开「管理标签（对话）」不是写入时机** —— 旧实现会在这里用当前工作区播种，
+   导致"看一眼就被冻结"，且冻结值取决于点开的先后顺序。
+2. **`own === null` 的语义固定为「从未配置过 = 空条件 = 掌握全部技能」**，
+   运行时**绝不**回退到工作区实时配置。工作区退化为「新建对话的初始模板 +
+   继承按钮的数据源」，不再实时下发。
+
+`installed_at` 存在 `sync_meta` 表（键 `installed_at`），本版首次运行时写入、永不覆盖。
+判定用 `createdAt` 而不是 `agent/created` 事件 —— 宿主对**恢复**已有会话同样会发该事件
+（`dsh-agent` 的 `announce(agent, "startup")` 是唯一路径），事件本身区分不了新建与打开。
 
 ---
 
@@ -52,10 +77,15 @@ conversationRecord = z.object({
 ```
 
 `own` 是**新增且独立**的一份快照，不复用 `config`（后者是旧的四区派生结果），
-以免与既有「对话标签」逻辑互相污染。`own` 缺失的历史行由 `ensureOwn()` 补：
+以免与既有「对话标签」逻辑互相污染。
+
+**`own` 缺失时不再补任何东西**（2026-10-31 起）：
+
+- `ensureOwn()` 只保证对话行存在，**不写 own**；
+- 打开「管理标签（对话）」仍是纯读；
+- 只有 `seedOwnOnBirth()`（出生）与 `inheritFromWorkspace()`（用户点继承）会写入。
 
-- 有绑定工作区 → 用工作区当前配置**播种**（= 默认继承，只发生一次）
-- 没绑定工作区 → 空快照（`emptyOwnConfig()`）
+历史行 `own === null` 就保持 `null`，运行时按「空条件 = 全部技能」处理。
 
 ### 2.2 领域函数（`src/domain/conv.js`）
 
@@ -245,14 +275,10 @@ ctx.inject(["commandUi"], (scope) => scope.effect(() => scope.commandUi.register
 `lib/index.js` 的 `refreshBySession(sessionId, cwd)` → `recomputeDenials(...)`：
 
 ```js
-const convId   = sessionId;                       // 对话主键 = sessionId
-const own      = conv?.own ?? null;
-const wsId     = own?.sourceWorkspaceId
-              ?? workspaceIdOfSession(registry, sessionId)
-              ?? workspaceIdOfPath(registry, cwd)     // ← 第一轮兜底，见 5.1
-              ?? conv?.inherited?.workspaceId;
-const effective = effectiveSkillsConfig(own, ws); // own 优先，即使空快照
-const candidates = candidatesFor({                // ← 不绕 conversations.candidates()
+const convId   = sessionId;                 // 对话主键 = sessionId
+const own      = conv?.own ?? null;          // 只认 own，**不解析工作区**
+const effective = effectiveSkillsConfig(own); // own 为 null → 空条件（全部技能）
+const candidates = candidatesFor({           // ← 不绕 conversations.candidates()
   skillTagLinks: links, config: effective.config, active: activeTagsOf(effective.config),
 });
 const denied    = workspaceDeniedSkills({ ...effective, universe, candidates });
@@ -360,12 +386,12 @@ ctx.on("domain/changed", (change) => {
 | # | 情况 | 期望行为 |
 | --- | --- | --- |
 | 1 | 新建对话且绑定了工作区 | 自动继承一次工作区的条件/手动/禁用 |
-| 2 | 新建对话但没绑工作区 | 空快照（无条件 = 全部技能） |
-| 3 | 工作区后来改了配置 | 已存在的对话**不跟随**（只有点继承才拉取） |
+| 2 | 新建对话但没绑工作区 | `own` 保持 `null`（= 无条件 = 全部技能） |
+| 3 | 工作区后来改了配置 | 已存在的对话**不跟随**（只有点继承才拉取）；未配置过的也不跟随 |
 | 4 | 点「继承工作区配置」 | 整体覆盖条件+手动+禁用（不是合并），工作区不受影响 |
 | 5 | 对话没有任何工作区可继承 | HTTP 400「没有可继承的工作区」+ 界面提示 |
-| 6 | 历史对话（无 `own` 字段）首次打开 | `ensureOwn(cid, wid)` 播种一次并落库 |
-| 7 | 历史对话且没有工作区 | 补空快照并落库 |
+| 6 | 历史对话（无 `own` 字段）首次打开 | **纯读，不播种**；`own` 仍是 `null` |
+| 7 | 历史对话且没有工作区 | 同上，不写数据 |
 | 8 | 表达式为空 | 合法（无条件），不报 `EMPTY`，可直接保存 |
 | 9 | 表达式只有空格 | 同 8（`trim()` 后为空） |
 | 10 | 表达式非法（`A+`） | 保存按钮禁用 + 错误「定位 第N字符」；HTTP 400 |
@@ -413,16 +439,21 @@ ctx.on("domain/changed", (change) => {
 | B14 | 工作区后续改动不流入已存在的对话 | 同上 |
 | B15 | 继承整体覆盖三件套、且不回写工作区 | 同上 |
 | B16 | 两对话配置互相隔离 | 同上 |
-| B17 | 落盘跨实例恢复、历史行补快照 | 同上 |
+| B17 | 落盘跨实例恢复 / 历史行打开后 own 仍为 null | 同上 |
 | B18 | HTTP 全链路（读→继承→改条件→加技能→禁用→恢复） | 同上最后一项 |
 | B19 | 无工作区时继承返回 400 | 同上 |
-| B20 | `effectiveSkillsConfig` 的四种情形（own 优先/空快照/退回 ws/都无） | `tests/runtime.test.mjs` |
+| B20 | `effectiveSkillsConfig`：own 优先 / null → 空条件（**不退回工作区**） | `tests/runtime.test.mjs` |
 | B21 | `workspaceIdOfSession` / `workspaceIdOfPath` 正常与异常 | 同上 |
 | B22 | `getWorkspaceRegistry` 只走 `ctx.get`，不碰 `ctx.workspaceRegistry` 属性 | `tests/runtime.test.mjs` |
 | B23 | 服务缺失 / 属性访问抛异常时 `getWorkspaceRegistry` 返回 `null`，不抛 | 同上 |
 | B24 | `apply()` 在无 `workspaceRegistry` 的最小 cordis 面不抛 | 同上 |
 | B25 | **`domain/changed` 监听器内部抛错不得逃逸**（否则 host 直接崩） | 同上 |
 | B26 | `createFilterProvider` 上游抛错 → `list` 回 `[]`、`get` 回 `undefined` | 同上 |
+| B27 | 出生播种幂等：已有 own 绝不覆盖；工作区不存在时不写 | `tests/conversation.test.mjs` |
+| B28 | 改标签名 → 所有对话快照的表达式同步改写 | 同上 |
+| B29 | 全局删标签 → 对话快照不留悬空 tagId | 同上 |
+| B30 | `installed_at` 首次写入后永不覆盖、跨实例恢复 | 同上 |
+| B31 | 界面：从未配置显示「尚未配置过」；表达式失效显示只读提示 | `tests/__conv-render.mjs` |
 | B27 | `createUpstreamAdapter` 的扫描/host 各自挂掉时仍返回另一边 | 同上 |
 | B28 | **新对话首次 `list()` 就必须已过滤**（`ensureFresh` 在读路径上被调用） | 同上（变异验证：去掉则红） |
 | B29 | `ensureFresh` 抛错时降级沿用旧集合，不冒回宿主 | 同上 |

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

@@ -33,7 +33,60 @@ window.__ModuleLoader__.load({
 			return r.json();
 		}
 
-		// ── pure view-model helpers (unit-tested via tests/ui.test.mjs) ─
+		// ── pure view-model helpers ────────────────────────────────────
+		//
+		// fmtLocalTime：把服务端存的 ISO-8601（**始终是 UTC，带 Z**）渲染成本地
+		// 时间。曾经这里直接 `String(iso).replace("T", " ").slice(0, 19)`——
+		// slice(0,19) 把结尾的 Z 连同时区信息一起切掉了，于是 UTC 被当成本地
+		// 时间显示，东八区整整偏 8 小时（"凌晨 2 点"其实是上午 10 点）。
+		// 一律走 Date 解析 + 本地字段拼接，不做字符串截断。
+		function fmtLocalTime(iso) {
+			if (iso === null || iso === undefined || iso === "") return "";
+			const d = new Date(iso);
+			if (Number.isNaN(d.getTime())) return String(iso); // 非法值原样显示，不编造时间
+			const p = (n) => String(n).padStart(2, "0");
+			return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} `
+				+ `${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";
@@ -163,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",
@@ -188,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 }));
@@ -209,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);
@@ -244,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 }),
 			]);
@@ -280,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 ?? {};
@@ -292,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)" } }, [
@@ -305,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: () => {
@@ -321,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])),
 						]),
 					]);
 				}),
@@ -399,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;
@@ -436,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,
@@ -479,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 ? " *" : "")),
@@ -490,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", {
@@ -518,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));
 
@@ -552,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 })),
@@ -578,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 }, [
@@ -1222,6 +1434,10 @@ window.__ModuleLoader__.load({
 
 			const inheritedFrom = ws?.sourceWorkspaceId;
 			const inheritedAt = ws?.inheritedAt;
+			// configured：该对话是否有自己的配置快照（own）。false = 从未配置过。
+			// expressionIssue：服务端只读体检结果，用于提示「引用了已删除的标签」。
+			const configured = ws?.configured;
+			const expressionIssue = ws?.expressionIssue ?? null;
 
 			const body = () => {
 				if (loading) return react.createElement("div", { style: { color: "#888", padding: "20px 0" } }, "加载中…");
@@ -1237,11 +1453,19 @@ window.__ModuleLoader__.load({
 							"解析结果: " + parsed),
 						react.createElement("div", { key: "st", style: { color: "#888", fontSize: "11px", marginTop: "2px" } },
 							`状态: ${view.hasFilter ? "有条件筛选（严格子集）" : "无筛选（全部技能）"}`),
-						// 继承状态：让用户知道"这份条件是从哪来的、什么时候来的"
+						// 继承状态：让用户知道「这份条件是从哪来的、什么时候来的」
+						// configured=false（own 为 null）= 从未配置过 = 空条件 = 掌握全部技能。
+						// 这不是「继承来源 null」，而是「你还没配过」，所以单独一条文案。
 						scope.isConv && react.createElement("div", { key: "inh", style: { color: "#888", fontSize: "11px", marginTop: "2px" } },
-							inheritedFrom
-								? `继承来源: ${inheritedFrom}${inheritedAt ? " · " + String(inheritedAt).replace("T", " ").slice(0, 19) : ""}（改动不影响工作区）`
-								: "未继承任何工作区（当前为该对话独立配置）"),
+							configured === false
+								? "尚未配置过（未继承工作区；当前为空条件 = 掌握全部技能）"
+								: (inheritedFrom
+									? `继承来源: ${inheritedFrom}${inheritedAt ? " · " + fmtLocalTime(inheritedAt) : ""}（改动不影响工作区）`
+									: "该对话有独立配置（未继承工作区）")),
+						// 只读提示：已冻结的表达式引用了不存在的标签（旧版 bug 遗留）。
+						// 不自动修复 —— 数据是用户意志，告诉他原因即可。
+						scope.isConv && expressionIssue && !expressionIssue.ok && react.createElement("div", { key: "isq", style: { color: "#e67e22", fontSize: "11px", marginTop: "2px" } },
+							`⚠ 表达式引用了已不存在的标签（${expressionIssue.message}）。点「tag 设置」可重新选择；保存前需修正。`),
 						react.createElement("div", { key: "sp", style: { flex: 1 } }),
 						react.createElement("div", { key: "f", style: { display: "flex", gap: "8px", flexWrap: "wrap", paddingTop: "8px", borderTop: "1px solid var(--theme-border,#222)" } }, [
 							react.createElement("button", {
@@ -1681,6 +1905,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

@@ -294,24 +294,40 @@ export function computeDeniedSkillIds(wsConfig, allLinkedSkillIds, computeCandid
 /**
  * 运行时生效口径：这个会话到底按哪份配置筛技能？
  *
- *   own 存在 → 用对话自己的（「对话 → 管理标签」的独立配置）
- *   own 为空 → 退回所属工作区的（历史对话 / 从未配置过）
- *   两者都没有 → null（不筛）
+ *   own 存在 → 用它（「对话 → 管理标签」的独立配置，已冻结）
+ *   own 为空 → **空配置 = 掌握全部技能**，绝不回退到工作区实时配置
  *
- * own 一旦存在就是权威，哪怕它是"空快照"：那代表用户已经把这份配置与工作区
- * 解耦了（新建时继承过、或手动清空过），此时再跟着工作区漂移就是错的。
+ * ## 为什么不再回退工作区（2026-10-31 起的统一口径）
+ *
+ * 旧实现是 `pick(own) ?? pick(ws)`：own 为 null 的对话会实时跟着工作区走。
+ * 而 own 只有「打开过管理标签」或「点过继承」才会产生，于是同一个操作
+ * "改工作区标签"在不同对话上表现完全不同：
+ *
+ *   - 有 own（历史点开过）→ 冻结，不变；
+ *   - 无 own（从没点开过）→ 实时跟随，跟着改 ← 用户报告的 bug。
+ *
+ * 用户口径（三种对话）：
+ *   ① 插件安装前就存在        → 未配置过 = 空 = 全部技能，改工作区不影响
+ *   ② 刚创建的新对话          → 出生时继承一次工作区（own 被写入）
+ *   ③ 安装后创建、已存在一阵  → ②的 own 已冻结，工作区再改不影响
+ *
+ * 三者共同点：**own 一旦存在即权威；own 为 null 即"没有筛选"**。
+ * 工作区配置退化为「新建对话的初始模板 + 继承按钮的数据源」，不再实时下发。
  *
  * @param {{config?:object, manualSkills?:string[], disabledSkills?:string[]}|null} own
- * @param {{config?:object, manualSkills?:string[], disabledSkills?:string[]}|null} ws
- * @returns {{config:object, manualSkills:string[], disabledSkills:string[]}|null}
+ * @param {object|null} [_ws] 已废弃，仅为兼容既有调用签名；**不再参与计算**
+ * @returns {{config:object, manualSkills:string[], disabledSkills:string[]}}
  */
-export function effectiveSkillsConfig(own, ws) {
-	const pick = (src) => src && {
-		config: src.config ?? { orTags: [], andGroups: [] },
-		manualSkills: src.manualSkills ?? [],
-		disabledSkills: src.disabledSkills ?? [],
+export function effectiveSkillsConfig(own, _ws = null) {
+	if (!own) {
+		// 未配置过 → 空条件 → 全部技能（workspaceSkillView 对空 config 返回 universe）
+		return { config: { orTags: [], andGroups: [] }, manualSkills: [], disabledSkills: [] };
+	}
+	return {
+		config: own.config ?? { orTags: [], andGroups: [] },
+		manualSkills: own.manualSkills ?? [],
+		disabledSkills: own.disabledSkills ?? [],
 	};
-	return pick(own) ?? pick(ws) ?? null;
 }
 
 /**
@@ -583,6 +599,14 @@ export async function apply(ctx, config) {
 	const services = createServices(repo, { log: (m) => ctx.logger?.info?.(m) });
 	await services.ready();
 
+	// 里程碑：本版**首次运行**的时刻。三种对话口径的判定基准（见 maybeSeedOwn）。
+	// 幂等且永不覆盖：升级/重启不会把老对话误判成"新出生"。
+	try {
+		await services.meta.ensureInstalledAt();
+	} catch (error) {
+		ctx.logger?.warn?.(`[skill-tag] installed_at not recorded: ${error?.message ?? error}`);
+	}
+
 	// 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>
@@ -647,12 +671,73 @@ export async function apply(ctx, config) {
 		if (refreshing.has(sessionId)) return;
 		refreshing.add(sessionId);
 		try {
+			// 先判「是不是新出生的对话」并播种（只写一次）；再算拒绝集。
+			// 播种会写库 → 触发 domain/changed → 下一轮 recomputeDenials 用上 own。
+			await maybeSeedOwn(sessionId, cwd, scope);
 			await recomputeDenials(sessionId, cwd, scope);
 		} finally {
 			refreshing.delete(sessionId);
 		}
 	}
 
+
+	/**
+	 * 会话的创建时刻（毫秒）。宿主保证 session.header 恒存在且 createdAt 是
+	 * 非负安全整数（dsh-session/lib/types 校验），所以读不到只可能是极早期
+	 * 的空壳 agent —— 那种情况一律当作「看不了」，不播种（不写数据最安全）。
+	 * @returns {number|null}
+	 */
+	function sessionCreatedAt(agent) {
+		try {
+			const v = agent?.session?.header?.createdAt;
+			if (typeof v === "number" && Number.isFinite(v)) return v;
+			if (typeof v === "string") {
+				const t = Date.parse(v);
+				if (Number.isFinite(t)) return t;
+			}
+		} catch { /* header 取不到就当未知 */ }
+		return null;
+	}
+
+	/**
+	 * 「出生播种」：**只在新对话的第一次被观察到时**继承一次工作区配置。
+	 *
+	 * 三种对话口径（2026-10-31 用户确认）都靠这一个函数落地：
+	 *   ① 插件安装前就存在的对话 → createdAt < installed_at → 直接返回，
+	 *      own 永远保持 null → 空条件 → 掌握全部技能；
+	 *   ② 刚创建的新对话 → createdAt >= installed_at 且 own 为 null → 播种一次；
+	 *   ③ 安装后创建、已存在一阵的对话 → 出生时已播过种，own 存在 → 永不重播。
+	 *
+	 * 为什么用 createdAt 而不是 agent/created 事件：宿主对**恢复**已有会话同样
+	 * 发 agent/created（dsh-agent 的 announce(agent, startup) 是唯一路径），
+	 * 事件本身区分不了「新建」和「打开旧对话」。用 header 里的出生时刻才可靠。
+	 *
+	 * 幂等：seedOwnOnBirth 内部再看一次 own，已有配置绝不覆盖。
+	 */
+	async function maybeSeedOwn(sessionId, cwd, scope) {
+		if (!sessionId || !enabled) return;
+		try {
+			const installed = services.meta.installedAt();
+			if (!installed) return; // 里程碑还没写（极早期），下一轮再说
+			const bornAt = sessionCreatedAt(scope);
+			if (bornAt === null) return;
+			const installedMs = Date.parse(installed);
+			if (!Number.isFinite(installedMs)) return;
+			if (bornAt < installedMs) return; // ① 安装前就存在 → 永不播种
+			if (services.conversations.isConfigured(sessionId)) return; // ③ 已冻结
+			// 工作区解析：解析不到就先不写（留空 = 全部技能，语义与「没播」一致，
+			// 而且不会把对话钉死）。宿主是在会话跑起来**之后**才 attachSession 的，
+			// 出生瞬间常常还查不到，所以这里宁可等下一轮。
+			const registry = getWorkspaceRegistry(ctx);
+			const wsId = workspaceIdOfSession(registry, sessionId) ?? workspaceIdOfPath(registry, cwd) ?? null;
+			if (!wsId) return;
+			const seeded = await services.conversations.seedOwnOnBirth(sessionId, wsId);
+			if (seeded) ctx.logger?.info?.(`[skill-tag] own seeded on birth session=${sessionId} workspace=${wsId}`);
+		} catch (error) {
+			try { ctx.logger?.warn?.(`[skill-tag] maybeSeedOwn failed: ${error?.message ?? error}`); } catch { /* ignore */ }
+		}
+	}
+
 	async function recomputeDenials(sessionId, cwd, scope = null) {
 		const denied = deniedFor(sessionId);
 		const before = [...denied].join(",");
@@ -666,27 +751,15 @@ export async function apply(ctx, config) {
 				conv = services.conversations.get(convId);
 			}
 			const own = conv?.own ?? null;
-			const registry = getWorkspaceRegistry(ctx);
-			// 解析顺序（2026-10-20 补第 3 档）：
-			//   1. 对话自己记的继承来源——最权威，用户点过「继承」/新建时播种的
-			//   2. 宿主 registry 的 sessionIds 反查
-			//   3. **cwd → workspace.path 反查**（新加）
-			//   4. 对话记录里的 inherited.workspaceId（旧数据兜底）
+			// 生效口径（2026-10-31 统一）：**只看 own，永不回退到工作区实时配置**。
+			//
+			//   own 存在 → 该对话自己的冻结快照；
+			//   own 为 null → 从未配置过 = 空条件 = 掌握全部技能。
 			//
-			// 第 3 档是修「第一条消息不受控」的关键：宿主是在会话跑起来之后才
-			// `attachSession` 把 id 写进 workspace.sessionIds 的，而 agent 第一次
-			// `list()` 时那个 id 还不在里面 → 第 2 档返回 null → effective 为 null
-			// → 全部技能放行。cwd 在第一轮就已经可靠（provider options.cwd），
-			// 所以用路径兜底能把第一轮也纳管。
-			const wsId = own?.sourceWorkspaceId
-				?? workspaceIdOfSession(registry, sessionId)
-				?? workspaceIdOfPath(registry, cwd)
-				?? conv?.inherited?.workspaceId
-				?? null;
-			const ws = wsId ? services.workspaces.get(wsId) : null;
-			// 生效口径：对话自己的快照优先（own 存在即代表该对话有独立配置，
-			// 即使是"空快照"也是用户选择过/新建时继承过的结果）；否则退回工作区。
-			const effective = effectiveSkillsConfig(own, ws);
+			// 工作区只在两个地方还参与：出生播种（maybeSeedOwn）与「继承」按钮。
+			// 所以这里不再解析 ws，也不再需要 wsId。
+			const effective = effectiveSkillsConfig(own);
+			// 空配置 = 不筛 = denied 为空；仍然走一遍（禁用列表非空时还要生效）。
 			if (effective) {
 				let universe = [];
 				try {

package/package.json

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

package/src/api.js

@@ -158,6 +158,20 @@ export function createApiHandler(services, log, listSkills = null, resolveWorksp
 		};
 	}
 
+	/**
+	 * 该对话已保存的表达式是否仍然有效（引用的标签是否还存在）。
+	 * 只用于**提示**，绝不修改数据：被冻结的历史快照可能引用了已删除/改名的
+	 * 标签，用户有权保留原样，但保存时必须能看到原因。
+	 * @returns {{ok:boolean, message:string|null}}
+	 */
+	function ownExpressionIssue(c) {
+		const expr = String(c?.expression ?? "");
+		if (expr.trim() === "") return { ok: true, message: null };
+		const v = services.templates.validate(expr, { allowEmpty: true });
+		if (v.ok) return { ok: true, message: null };
+		return { ok: false, message: v.errors?.[0]?.message ?? "表达式非法" };
+	}
+
 	/**
 	 * 对话版双列界面的统一载荷（与 /workspaces/skills 同形，前端复用同一个面板）。
 	 */
@@ -172,12 +186,18 @@ export function createApiHandler(services, log, listSkills = null, resolveWorksp
 			ok: true,
 			conversationId,
 			workspaceId,
+			// configured=false 表示该对话**从未配置过**（own 为 null）：
+			// 语义是「空 = 掌握全部技能」，且界面上不该显示成"继承来源为 null"。
+			configured: services.conversations.isConfigured(conversationId),
 			expression: c?.expression ?? "",
 			config: c?.config ?? { orTags: [], andGroups: [] },
 			manualSkills: c?.manualSkills ?? [],
 			disabledSkills: c?.disabledSkills ?? [],
 			inheritedAt: c?.inheritedAt ?? null,
 			sourceWorkspaceId: c?.sourceWorkspaceId ?? null,
+			// 只读提示：已冻结的表达式引用了不存在的标签（旧版 bug 遗留）。
+			// 不自动修复 —— 数据是用户意志，界面上告诉他原因即可。
+			expressionIssue: ownExpressionIssue(c),
 			candidates: ctxInfo.candidates,
 			universe: ctxInfo.universe,
 			catalog: ctxInfo.catalog,
@@ -209,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 自己拉起文件管理器。
@@ -451,8 +510,10 @@ export function createApiHandler(services, log, listSkills = null, resolveWorksp
 			if (path === "/conversations/config" && (method === "GET" || method === "POST")) {
 				const cid = q("conversationId");
 				const wid = workspaceIdForConversation(cid);
-				// 历史对话第一次打开：用所属工作区播种一份快照（「默认继承」只发生一次）
-				await services.conversations.ensureOwn(cid, wid);
+				// 打开「管理标签（对话）」是**纯读**：只保证对话行存在，绝不播种 own。
+				// （旧实现在这里用当前工作区播种，导致"看一眼就被冻结"，且冻结值
+				//  取决于点开的先后顺序 —— 是「改工作区标签波及部分对话」的根因之一。）
+				await services.conversations.ensureOwn(cid);
 				return json(res, 200, await convPayload(cid, wid));
 			}
 			if (path === "/conversations/inherit" && method === "POST") {

package/src/service.js

@@ -48,6 +48,7 @@ export function createServices(repo, opts = {}) {
 	const templates = new Map();
 	const workspaces = new Map();
 	const conversations = new Map(); // conversationId -> live ConversationState
+	const syncMeta = new Map(); // key -> {key, rev, updatedAt}
 
 	async function loadAll() {
 		for (const [k, v] of await repo.listTags()) tags.set(k, v);
@@ -55,6 +56,7 @@ export function createServices(repo, opts = {}) {
 		for (const [k, v] of await repo.listTemplates()) templates.set(k, v);
 		for (const [k, v] of await repo.listWorkspaces()) workspaces.set(k, v);
 		for (const [k, v] of await repo.listConversations()) conversations.set(k, deserializeConversation(v));
+		for (const [k, v] of await repo.listSyncMeta()) syncMeta.set(k, v);
 		// 旧数据回填：历史模板只有 config、没有 expression —— 反推出表达式并回写，
 		// 保证"再次编辑必须回显"对存量数据同样成立。
 		try {
@@ -72,6 +74,50 @@ export function createServices(repo, opts = {}) {
 		}
 	}
 
+	// ── 对话快照（own）的联动维护 ────────────────────────────────────────
+	//
+	// own 是"冻结的配置"，但**标签实体本身**是全局的：改名/删除标签必须同步
+	// 写回 own，否则冻结住的表达式会指向一个不存在的标签名，用户下次打开
+	// 「tag 设置」就会看到"标签不存在"，且保存被拒。
+	//
+	// 注意这**不是**"自动继承工作区"：改的是标签的名字/存废，不是条件本身。
+	// 条件（哪些标签、手动列表、禁用列表）一律保持调用方原样。
+
+	/**
+	 * 对每个带 own 的对话快照应用一个纯变换，有实际变化才落库。
+	 * @param {(own: object) => string|null} transform 返回新表达式或 null 表示不改
+	 */
+	async function renameTagInOwnConfigs(transform) {
+		for (const [cid, conv] of conversations) {
+			if (!conv.own) continue;
+			const next = transform(conv.own);
+			if (typeof next !== "string" || next === conv.own.expression) continue;
+			conv.own.expression = next;
+			await repo.putConversation(serializeConversation(conv));
+		}
+	}
+
+	/**
+	 * 全局删除标签后，把该标签从每个对话快照的 config/expression 里摘掉。
+	 * 与 workspaces 的处理保持一致（domainRemoveTagEntirely + removeTagFromExpression），
+	 * 差别只是数据挂在 own 上。
+	 */
+	async function dropTagFromOwnConfigs(tagId, removedName) {
+		for (const [cid, conv] of conversations) {
+			if (!conv.own) continue;
+			let changed = false;
+			if (conv.own.config) {
+				domainRemoveTagEntirely(conv.own.config, tagId);
+				changed = true;
+			}
+			if (removedName && conv.own.expression) {
+				const next = removeTagFromExpression(conv.own.expression, removedName);
+				if (next !== conv.own.expression) { conv.own.expression = next; changed = true; }
+			}
+			if (changed) await repo.putConversation(serializeConversation(conv));
+		}
+	}
+
 	// ── TagStore (spec §4) ───────────────────────────────────────────────────
 	const tagStore = {
 		async create(tagId, name) {
@@ -113,6 +159,10 @@ export function createServices(repo, opts = {}) {
 						await repo.putWorkspace(ws);
 					}
 				}
+				// 对话自己的快照（own）也按名称引用 → 必须一并改写。
+				// 2026-10-31 补：此前只写 templates/workspaces，冻结的 own 会留下
+				// 指向旧名的表达式，下次打开「tag 设置」直接报"标签不存在"。
+				await renameTagInOwnConfigs((own) => renameTagInExpression(own.expression ?? "", oldName, newName));
 			}
 		},
 		list() { return [...tags.values()]; },
@@ -167,6 +217,11 @@ export function createServices(repo, opts = {}) {
 				}
 				await repo.putWorkspace(ws);
 			}
+			// 对话自己的快照（own）：同样摘除该标签。
+			// 2026-10-31 补：此前漏了这一段，导致 own.config 里残留已经删除的
+			// tagId（本机实测 3 条），而 hasFilter 仍为 true、candidates 变空
+			// → 那条对话会把**全部技能**都屏蔽掉，且界面上看不出原因。
+			await dropTagFromOwnConfigs(tagId, removedName);
 			// conversations: tag state + OR/AND + inherited groups + block/exempt records
 			for (const [cid, conv] of conversations) {
 				const removed = domainRemoveTagEntirely(conv.config, tagId);
@@ -177,7 +232,7 @@ export function createServices(repo, opts = {}) {
 				}
 				pruneGroups(conv.inherited.groups);
 				conv.inherited.groups = conv.inherited.groups.filter((g) => new Set(g.tagIds).size >= 2);
-				await repo.putConversation(serializeConversation({ ...conv, conversationId: cid }));
+				await repo.putConversation(serializeConversation(conv));
 			}
 			tags.delete(tagId);
 			await repo.deleteTag(tagId);
@@ -553,20 +608,53 @@ export function createServices(repo, opts = {}) {
 		return new Map([...tags.values()].map((t) => [t.tagId, t.name]));
 	}
 
+	// ── MetaService：插件级里程碑（当前只有 installed_at）────────────────
+	//
+	// installed_at = 本版**首次运行**的时刻，一旦写下永不改变。
+	// 三种对话的判定依赖它（见 lib/index.js seedOwnOnBirth）。
+	const INSTALLED_AT_KEY = "installed_at";
+	const metaService = {
+		/** 读已记录的安装时刻（ISO 字符串），没有则 null。 */
+		installedAt() {
+			return syncMeta.get(INSTALLED_AT_KEY)?.value ?? null;
+		},
+		/** 首次运行时写入；已有则原样返回（幂等，永不覆盖）。 */
+		async ensureInstalledAt(now = new Date().toISOString()) {
+			const existing = syncMeta.get(INSTALLED_AT_KEY);
+			if (existing?.value) return existing.value;
+			const rec = { key: INSTALLED_AT_KEY, rev: 1, updatedAt: now, value: now };
+			syncMeta.set(INSTALLED_AT_KEY, rec);
+			await repo.putSyncMeta(rec);
+			appLog?.(`[skill-tag] installed_at recorded: ${now}`);
+			return now;
+		},
+	};
+
 
 	// ── ConversationService (spec §7/§8) ─────────────────────────────────────
+	//
+	// 「own 只写一次」不变量（2026-10-31 统一口径）：
+	//
+	//   一条对话的 own 快照只允许在**两个**时刻产生：
+	//     ① 出生（新建对话 / 首次观察到 createdAt ≥ installedAt 的会话）→ 继承一次
+	//     ② 用户点「继承工作区配置」→ 覆盖
+	//
+	//   除此之外永不自动写入。尤其：**打开「管理标签（对话）」不是写入时机**
+	//   （旧实现会在打开瞬间用当前工作区播种，导致"看一眼就被冻结"，且冻结值
+	//   取决于看的先后顺序 —— 这就是 0.1.8 之前「改工作区标签有些对话会被改」
+	//   的根因之一）。
+	//
+	//   own === null 的语义固定为「从未配置过 = 空 = 掌握全部技能」，运行时
+	//   绝不再回退到工作区实时配置（见 lib/index.js effectiveSkillsConfig）。
 	const conversationService = {
-		/** §8.1 create-with-workspace init */
+		/** 新建对话（出生）：绑工作区则继承一次。 */
 		async create(conversationId, workspaceId = null) {
 			const conv = createConversationState();
 			conv.conversationId = conversationId;
-			conv.own = emptyOwnConfig();
 			if (workspaceId) {
 				const ws = workspaces.get(workspaceId);
 				if (!ws) throw new Error(`workspace '${workspaceId}' not found`);
 				initFromWorkspace(conv, ws.config, workspaceId);
-				// 新创建对话 = 自动继承工作区配置（用户口径：新建时才自动继承，
-				// 之后工作区再改不会波及本对话，要重新同步必须点「继承工作区配置」）
 				conv.own = ownConfigFromWorkspace(ws);
 			}
 			conversations.set(conversationId, conv);
@@ -576,26 +664,43 @@ export function createServices(repo, opts = {}) {
 		get(conversationId) { return conversations.get(conversationId); },
 
 		/**
-		 * 取（必要时创建）对话的配置快照 —— 历史行没有 own 字段。
-		 *
-		 * seedWorkspaceId：历史对话第一次被打开时，用它绑定的工作区**播种**一份
-		 * 快照（= 用户口径里的「默认继承」）。播种只发生一次：之后工作区再改，
-		 * 本对话不受影响；要重新同步只能点「继承工作区配置」按钮。
+		 * 取（必要时**建行**）对话记录。**不写 own**：own 只由出生播种与
+		 * 「继承工作区配置」写。历史对话第一次被打开时 own 仍是 null（= 全部技能），
+		 * 直到用户显式继承或编辑。
 		 */
-		async ensureOwn(conversationId, seedWorkspaceId = null) {
-			// 播种只在「新建这一行」时有意义：先看能不能拿到工作区记录，
-			// 拿不到就别硬绑（避免 create 抛错），退回空快照。
-			const seed = seedWorkspaceId ? workspaces.get(seedWorkspaceId) ?? null : null;
+		async ensureOwn(conversationId) {
 			let conv = conversations.get(conversationId);
-			// 与 /conversations/ensure 语义一致：不存在就建一个对话
-			if (!conv) conv = await this.create(conversationId, seed ? seedWorkspaceId : null);
-			if (!conv.own) {
-				conv.own = seed ? ownConfigFromWorkspace(seed) : emptyOwnConfig();
+			if (!conv) {
+				conv = createConversationState();
+				conv.conversationId = conversationId;
+				conversations.set(conversationId, conv);
 				await repo.putConversation(serializeConversation(conv));
 			}
 			return conv;
 		},
 
+		/**
+		 * 出生播种（幂等）：只在 own 为 null 且能解析到工作区时继承一次。
+		 * 调用方负责「是不是新出生」的判定（见 lib/index.js seedOwnOnBirth）。
+		 * @returns {Promise<boolean>} 是否真的播种了
+		 */
+		async seedOwnOnBirth(conversationId, workspaceId) {
+			if (!conversationId || !workspaceId) return false;
+			const ws = workspaces.get(workspaceId);
+			if (!ws) return false; // 工作区还没登记 → 留空，下次再说（留空 = 全部技能，与"没播种"一致）
+			const conv = await this.ensureOwn(conversationId);
+			if (conv.own) return false; // 已有配置，绝不覆盖
+			conv.own = ownConfigFromWorkspace(ws);
+			if (!conv.inherited.workspaceId) conv.inherited.workspaceId = ws.workspaceId;
+			await repo.putConversation(serializeConversation(conv));
+			return true;
+		},
+
+		/** 该对话是否已经有自己的配置快照（own 存在即"配置过"）。 */
+		isConfigured(conversationId) {
+			return Boolean(conversations.get(conversationId)?.own);
+		},
+
 		/** 对话自己的配置快照（只读视图；保证字段完整） */
 		own(conversationId) {
 			const conv = conversations.get(conversationId);
@@ -632,9 +737,20 @@ export function createServices(repo, opts = {}) {
 			return conv;
 		},
 
+		/**
+		 * 写路径专用：取对话并保证 own 是一个可编辑对象。
+		 * 只有**用户在对话页里动手编辑**才会走到这里 —— 这是除「出生」与
+		 * 「继承」之外的第三种合法写入时机（用户显式操作，不是自动同步）。
+		 */
+		async ownForEdit(conversationId) {
+			const conv = await this.ensureOwn(conversationId);
+			if (!conv.own) conv.own = emptyOwnConfig();
+			return conv;
+		},
+
 		/** 保存对话的标签条件表达式（空串 = 无条件 = 掌握全部技能）。 */
 		async setOwnExpression(conversationId, expression) {
-			const conv = await this.ensureOwn(conversationId);
+			const conv = await this.ownForEdit(conversationId);
 			const v = validateExpression(expression, { tags: [...tags.values()], allowEmpty: true });
 			if (!v.ok) {
 				const err = new Error(v.errors[0]?.message ?? "表达式非法");
@@ -650,7 +766,7 @@ export function createServices(repo, opts = {}) {
 
 		// ── 对话页右列：手动添加 / 禁用 / 恢复 ──────────────────────────
 		async addOwnManualSkill(conversationId, skillName) {
-			const conv = await this.ensureOwn(conversationId);
+			const conv = await this.ownForEdit(conversationId);
 			const name = String(skillName ?? "").trim();
 			if (!name) throw new Error("技能名不能为空");
 			if (conv.own.disabledSkills.includes(name)) throw new Error(`技能 '${name}' 已被禁用，请先恢复`);
@@ -659,13 +775,13 @@ export function createServices(repo, opts = {}) {
 			return conv;
 		},
 		async removeOwnManualSkill(conversationId, skillName) {
-			const conv = await this.ensureOwn(conversationId);
+			const conv = await this.ownForEdit(conversationId);
 			conv.own.manualSkills = conv.own.manualSkills.filter((s) => s !== skillName);
 			await repo.putConversation(serializeConversation(conv));
 			return conv;
 		},
 		async disableOwnSkill(conversationId, skillName) {
-			const conv = await this.ensureOwn(conversationId);
+			const conv = await this.ownForEdit(conversationId);
 			const name = String(skillName ?? "").trim();
 			if (!name) throw new Error("技能名不能为空");
 			conv.own.manualSkills = conv.own.manualSkills.filter((s) => s !== name);
@@ -674,7 +790,7 @@ export function createServices(repo, opts = {}) {
 			return conv;
 		},
 		async enableOwnSkill(conversationId, skillName) {
-			const conv = await this.ensureOwn(conversationId);
+			const conv = await this.ownForEdit(conversationId);
 			conv.own.disabledSkills = conv.own.disabledSkills.filter((s) => s !== skillName);
 			await repo.putConversation(serializeConversation(conv));
 			return conv;
@@ -794,11 +910,12 @@ export function createServices(repo, opts = {}) {
 		templates: templateStore,
 		workspaces: workspaceService,
 		conversations: conversationService,
+		meta: metaService,
 		ready: loadAll,
 		/** repository back-reference (api layer: template create) */
 		_repo: repo,
 		/** exposed for tests/inspection */
-		_caches: { tags, skillLinks, templates, workspaces, conversations },
+		_caches: { tags, skillLinks, templates, workspaces, conversations, syncMeta },
 	};
 }
 

package/src/storage/repository.js

@@ -21,6 +21,8 @@
  * @property {() => Promise<Map<string, any>>} listConversations
  * @property {(rec: any) => Promise<void>} putConversation
  * @property {(conversationId: string) => Promise<void>} deleteConversation
+ * @property {() => Promise<Map<string, any>>} listSyncMeta
+ * @property {(rec: any) => Promise<void>} putSyncMeta
  */
 
 // ── In-memory implementation (unit tests) ───────────────────────────────────
@@ -52,6 +54,8 @@ export function createMemoryRepository() {
 		async listConversations() { return new Map(t("conversations")); },
 		async putConversation(rec) { t("conversations").set(rec.conversationId, structuredClone(rec)); },
 		async deleteConversation(id) { t("conversations").delete(id); },
+		async listSyncMeta() { return new Map(t("sync_meta")); },
+		async putSyncMeta(rec) { t("sync_meta").set(rec.key, structuredClone(rec)); },
 	};
 }
 
@@ -92,6 +96,8 @@ export function createDshRepository(domain) {
 		async listConversations() { return rows("conversations"); },
 		async putConversation(rec) { await tables.conversations.put(rec.conversationId, rec); },
 		async deleteConversation(id) { await tables.conversations.delete(id); },
+		async listSyncMeta() { return rows("sync_meta"); },
+		async putSyncMeta(rec) { await tables["sync_meta"].put(rec.key, rec); },
 	};
 }
 

package/src/storage/schema.js

@@ -124,10 +124,20 @@ export const conversationRecord = z.object({
 		.nullable(),
 });
 
+// 同步元数据（键值小抽屉）。目前只放一个键：
+//   "installed_at" —— 本插件**本版首次运行**的时刻（ISO 字符串）。
+//
+// 用途（2026-10-31 三种对话口径）：判定一条对话属于「插件安装前就存在」还是
+// 「安装后新建」。判据是 session.header.createdAt（宿主保证恒存在）与
+// installed_at 的比较，而不是 agent/created 事件 —— 因为宿主对**恢复**已有
+// 会话同样会发 agent/created（dsh-agent 的 announce(agent, "startup")），
+// 事件本身无法区分"新建"与"打开旧对话"。
 export const syncMetaRecord = z.object({
 	key: z.string(),
 	rev: z.number().int().nonnegative(),
 	updatedAt: z.string(),
+	// 可选值载荷（旧行没有这个字段）
+	value: z.string().optional(),
 });
 
 // ── domain spec ─────────────────────────────────────────────────────────────