dsh-skill-tag 0.1.7 → 0.1.10

package/README.md

@@ -20,8 +20,8 @@ office * plugin       # 只要 office 包带来的、且是插件相关
 | **全局标签** | 建/改名/删除标签，标签之间无层级 |
 | **标签组模板** | 把表达式存成模板（`前端组`、`只留本机技能`…），可复用、可求值 |
 | **布尔表达式** | `+`=OR、`*`=AND、`*` 优先、支持括号；改标签名会自动改写所有引用它的表达式 |
-| **工作区级筛选** | 每个工作区一套条件，只把命中的技能下发给该工作区的对话 |
-| **对话级筛选** | 每个对话可以有**自己的**快照，独立于所属工作区；可一键「继承工作区配置」 |
+| **工作区级筛选** | 每个工作区一套条件，作为该工作区**新建对话**的初始模板；改工作区不影响已存在的对话 |
+| **对话级筛选** | 每个对话有**自己的**快照：新建时继承一次，之后冻结；未配置过的对话 = 空条件 = 全部技能；可一键「继承工作区配置」重新拉取 |
 | **禁用 / 手动添加** | 在标签命中之外额外放行某个技能，或强行屏蔽某个（即使它命中） |
 | **技能 ↔ 标签双向编辑** | 「tag 联系 skill」和「skill 联系 tag」两个方向都能改 |
 | **打开技能所在文件夹** | 任何列出技能的地方都有 📁 按钮，一点即在文件管理器里定位 |
@@ -30,23 +30,24 @@ office * plugin       # 只要 office 包带来的、且是插件相关
 ## 界面预览
 
 > 全部是真实实例截图（105 个技能 / 48 个标签 / 一个开了筛选的工作区），没有 mock。
-> 图片源文件在 `images/`（不进 npm 包，README 里用 raw 绝对地址，GitHub 与 npm 都能显示）。
+> 图片源文件在 `images/`（不进 npm 包，README 里用 jsDelivr 绝对地址，GitHub 与 npm 都能显示；
+> 之所以不走 `raw.githubusercontent.com`，是因为部分网络到该域名的 IPv6 不通，图片会间歇性加载失败）。
 
 ### 图 1 · 入口：会话行「…」→「管理标签」
 
-<img src="https://raw.githubusercontent.com/aawef/dsh-skill-manager-tags/main/images/session-menu.png" width="240" alt="会话行菜单里的管理标签入口">
+<img src="https://cdn.jsdelivr.net/gh/aawef/dsh-skill-manager-tags@main/images/session-menu.png" width="240" alt="会话行菜单里的管理标签入口">
 
 对话级的配置就挂在会话行的「…」菜单最下面，不用去翻设置页。
 
 ### 图 2 · 入口：命令面板里的 `/skill-tag-manage`
 
-<img src="https://raw.githubusercontent.com/aawef/dsh-skill-manager-tags/main/images/command-palette.png" width="820" alt="命令面板中的管理对话标签命令">
+<img src="https://cdn.jsdelivr.net/gh/aawef/dsh-skill-manager-tags@main/images/command-palette.png" width="820" alt="命令面板中的管理对话标签命令">
 
 在输入框敲 `/` 也能直接开「管理对话标签」——同一个界面，省一次点菜单。
 
 ### 图 3 · 打标签：设置 →「Skill 标签」
 
-<img src="https://raw.githubusercontent.com/aawef/dsh-skill-manager-tags/main/images/tag-settings.png" width="620" alt="Skill 标签管理页：新建标签、按来源分组的标签列表">
+<img src="https://cdn.jsdelivr.net/gh/aawef/dsh-skill-manager-tags@main/images/tag-settings.png" width="620" alt="Skill 标签管理页：新建标签、按来源分组的标签列表">
 
 三个页签分工明确：**tag 联系 skill**（一个标签包含哪些技能）、**skill 联系 tag**
 （一个技能拥有哪些标签）、**编辑标签组**（写表达式存模板）。
@@ -54,7 +55,7 @@ office * plugin       # 只要 office 包带来的、且是插件相关
 
 ### 图 4 · 一个技能看它身上有哪些标签
 
-<img src="https://raw.githubusercontent.com/aawef/dsh-skill-manager-tags/main/images/skill-to-tags.png" width="640" alt="skill 联系 tag：左列技能、右列标签勾选">
+<img src="https://cdn.jsdelivr.net/gh/aawef/dsh-skill-manager-tags@main/images/skill-to-tags.png" width="640" alt="skill 联系 tag：左列技能、右列标签勾选">
 
 左列 `技能 (105)` 每行标着它有几个标签；右边勾选**即时保存**，不用点确认。
 右列会把该技能**已有的标签排在列表最前面**（并保持它们原来的相对顺序），所以不用滚动
@@ -63,7 +64,7 @@ office * plugin       # 只要 office 包带来的、且是插件相关
 
 ### 图 5 · 工作区「管理标签」：左写条件，右就是下发名单
 
-<img src="https://raw.githubusercontent.com/aawef/dsh-skill-manager-tags/main/images/workspace-filter.png" width="900" alt="工作区管理标签双列界面">
+<img src="https://cdn.jsdelivr.net/gh/aawef/dsh-skill-manager-tags@main/images/workspace-filter.png" width="900" alt="工作区管理标签双列界面">
 
 左列是标签条件，下面实时显示**解析结果**和状态「有条件筛选（严格子集）」；
 右列 `技能 (54)` 就是该工作区下发给模型的全部技能，每行可以「查看 tag」「禁用」，
@@ -72,7 +73,7 @@ office * plugin       # 只要 office 包带来的、且是插件相关
 
 ### 图 6 · 对话「管理标签（对话）」：可以有自己的一份
 
-<img src="https://raw.githubusercontent.com/aawef/dsh-skill-manager-tags/main/images/conversation-filter.png" width="900" alt="对话级管理标签界面与继承来源">
+<img src="https://cdn.jsdelivr.net/gh/aawef/dsh-skill-manager-tags@main/images/conversation-filter.png" width="900" alt="对话级管理标签界面与继承来源">
 
 同一个工作区下的某个对话想单独收窄，就在这里改：它会记下**继承来源**与时间
 （`改动不影响工作区`），左下角一键「继承工作区配置」覆盖回来。

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/lib/client.js

@@ -33,7 +33,22 @@ 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())}`;
+		}
+
 		// zoneOf: §7 four-zone classification of a conversation tag entry.
 		function zoneOf(entry) {
 			if (entry.blocked) return "blocked";
@@ -1222,6 +1237,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 +1256,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", {

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.7",
+  "version": "0.1.10",
   "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,
@@ -451,8 +471,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 ─────────────────────────────────────────────────────────────