dsh-agent-persona 0.1.5 → 0.1.7

package/CHANGELOG.md

@@ -4,6 +4,49 @@ All notable changes to this project are documented here.
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.7] - 2026-10-23
+
+### Fixed
+
+- **开关的 toast 只讲自己那件事。** 提示文案原来只对两个显示开关按 `patch` 取，其余一律按
+  `next.autosave` 计算，于是拨动「禁止模型改写人设文件」或「保存人设版本历史」时弹出来的是
+  「编辑后自动保存」——一个这次根本没碰的开关的话。现在每个偏好各有一条按方向分岔的句子
+  （`PREF_STATUS`），键从 `patch` 上读，未知键退化成「已保存」。
+- **同一句提示连拨两次也会再弹一次。** toast 原来用固定 `key`，第二次拨回同一状态时 React 复用
+  同一个组件实例：文案一样、key 一样，定时器继续走，屏幕上看不到新提示。现在 `status` 每次写入都
+  推进一个 `statusSeq`，toast 按它做 key，重复的句子也会重新挂载。这也是「开启没反应、关闭才弹」
+  的成因之一：两个方向的文案本来就相同，第二次写入被吞掉了。
+- 顺带把「关闭自动保存」的文案从「已关闭：编辑后自动保存」改成「已关闭：改完要自己点保存」。原文案
+  在关闭状态下仍然宣称会自动保存。
+
+## [0.1.6] - 2026-10-22
+
+### Added
+
+- **人设版本历史（可选开关）。** 设置页新增「保存人设版本历史」，默认关闭。打开后每次保存正文都会
+  追加一条 diff 到 `personas.history.json`（与主存储同目录、0600）：相等行只记行数，变更行原文保留，
+  因此一条记录的成本约等于这次改动本身，而不是整份正文。
+- 编辑器底部新增「版本历史」按钮：左侧列出版本（时间、`+a / −r`、首个改动行），右侧显示该版相对上一版的
+  逐行 diff（红删绿增，未改动段折叠成行数）。「恢复到此版本」把选中版本写回当前人设，并且恢复本身也记成
+  一条新记录，所以恢复错了还能再回滚。
+- 新 RPC：`listVersions` / `versionDiff` / `restoreVersion`（远程产物由 `npm run generate:remote` 生成）。
+- 链式存储：第一条版本作为 base 快照，之后每版只在上一版上重放 diff；超过 `MAX_VERSIONS`（200）时把最旧的
+  几条折进 base，保证保留下来的版本仍可逐条重放。每条记录带内容 sha 摘要，历史被手改或损坏时重放会报错
+  而不是静默给出别的正文。
+
+### Changed
+
+- README 里的截图全部重作为动图（设置列表、卡片编辑、版本历史演示、会话页「人设」标签），
+  都取自 0.1.6 的实机操作：版本历史那张演示「打开 → 选较早版本 → 恢复」的完整回路。
+  同时去掉了与动图重复的静态 `versions.png`。
+- 兼容性不变：仍按 0.1.5 的适配结论跑在 DSH `0.2.1-rc.2` 上（`dshReleases` 里的
+  `0.1.5-rc.1` / `0.1.5-rc.2` / `0.2.0-rc.2` / `0.2.1-rc.2` 标记不需要改动）。
+
+### Notes
+
+- 历史只记正文，不记名称、启用状态与适用范围；关掉开关后不再写新记录，已有历史仍可查看与恢复。
+- 版本历史是独立于守卫的开关：守卫管的是「工具不许改存储」，历史管的是「改了就留痕」，两者互不依赖。
+
 ## [0.1.5] - 2026-10-20
 
 ### Changed

package/README.md

@@ -37,7 +37,7 @@
 | **会话视图** | 对话页顶部的 **人设** 标签 | 看这条会话命中了哪条人设、**实际发出去的 system prompt**（渲染/源码两视图），以及就地管理全部人设 |
 | **侧边栏卡片** | dsh-better-sidebar 的右侧栏 | 把上面那个「人设」页面挂进右侧栏（需要装了该插件） |
 
-四个偏好开关（`编辑后自动保存` / `在对话页显示「人设」标签` / `注册到 dsh-better-sidebar` / `禁止模型改写人设文件`）
+五个偏好开关（`编辑后自动保存` / `在对话页显示「人设」标签` / `注册到 dsh-better-sidebar` / `禁止模型改写人设文件` / `保存人设版本历史`）
 都在**设置 → Agent 人设**页里，并且这个页面**不受这些开关影响** —— 关掉「对话页显示」或「注册到 dsh-better-sidebar」后，
 回到这里就能重新打开。本插件不在**设置 → 通用设置**里添加任何条目；鼠标停在开关上会给出每个开关的完整说明。
 
@@ -83,7 +83,7 @@ dsh plugin --profile web remove dsh-agent-persona            # 卸载
 
 ## 用起来
 
-![人设列表](https://raw.githubusercontent.com/Awoodwhale/dsh-agent-persona/main/docs/images/settings-list.png)
+![人设列表](https://raw.githubusercontent.com/Awoodwhale/dsh-agent-persona/main/docs/images/settings-list.gif)
 
 点 **新建人设** → 在「适用范围」里加行，选工作区或会话 → 写正文 → 打开启用开关 → 保存。
 
@@ -99,7 +99,21 @@ dsh plugin --profile web remove dsh-agent-persona            # 卸载
 
 展开一张卡是这样：
 
-![展开编辑](https://raw.githubusercontent.com/Awoodwhale/dsh-agent-persona/main/docs/images/settings-editor.png)
+![展开编辑](https://raw.githubusercontent.com/Awoodwhale/dsh-agent-persona/main/docs/images/settings-editor.gif)
+
+### 版本历史（可选）
+
+打开设置页的 **保存人设版本历史**，之后每次保存都会把这次的正文改动记成一条 diff（写在
+`personas.history.json`）。编辑器底部的 **版本历史** 按钮打开对比窗口：
+
+![版本历史演示](https://raw.githubusercontent.com/Awoodwhale/dsh-agent-persona/main/docs/images/versions.gif)
+
+- **只记正文**：名称、启用状态、适用范围不参与版本，改这些不会产生一条记录。
+- **每条都是 diff**：相等行只记行数，只有真正改动的行才存原文，所以一百条版本也远小于一百份正文。
+- **恢复**：选中任意一条点「恢复到此版本」写回正文；恢复动作本身也记一条，恢复错了还能再回滚。
+- **链式重放**：第一条版本作为基准快照，之后逐条重放；超过 200 条时把最旧的几条折进基准，
+  保留下来的版本仍可逐条打开。每条记录带内容摘要，历史文件被手改坏时重放会报错，不会给出别的正文。
+- 关掉开关只是停止记录，已有历史仍可查看与恢复。
 
 ### 看这条会话聊了什么
 
@@ -113,7 +127,7 @@ dsh plugin --profile web remove dsh-agent-persona            # 卸载
 
 ### 对话页的「人设」标签
 
-![会话视图](https://raw.githubusercontent.com/Awoodwhale/dsh-agent-persona/main/docs/images/view-persona.png)
+![会话视图](https://raw.githubusercontent.com/Awoodwhale/dsh-agent-persona/main/docs/images/view-persona.gif)
 
 选中一条会话后，对话页顶部有 **人设 / 提示词 / 管理** 三个面板：
 
@@ -124,7 +138,7 @@ dsh plugin --profile web remove dsh-agent-persona            # 卸载
   没有命中任何人设时，这里显示的就是 DSH 原生注入的 prompt —— 不做任何特殊处理。
 - **管理**：与设置页同一套卡片（新建、启用/停用、编辑、排序、复制、删除），就地管理。
 
-### 四个偏好
+### 五个偏好
 
 | 开关 | 默认 | 含义 | 生效时机 |
 |---|---|---|---|

package/README_EN.md

@@ -95,7 +95,7 @@ overwritten — uninstalling only removes the plugin.
 
 ## Using it
 
-![persona list](https://raw.githubusercontent.com/Awoodwhale/dsh-agent-persona/main/docs/images/settings-list.png)
+![persona list](https://raw.githubusercontent.com/Awoodwhale/dsh-agent-persona/main/docs/images/settings-list.gif)
 
 **New persona** → add rows under reach, pick a workspace or a session → write the body → switch it on → save.
 
@@ -109,7 +109,22 @@ overwritten — uninstalling only removes the plugin.
 
 An expanded card — name, state, the default switch, injection mode, the reach rules, the body and the footer:
 
-![expanded card](https://raw.githubusercontent.com/Awoodwhale/dsh-agent-persona/main/docs/images/settings-editor.png)
+![expanded card](https://raw.githubusercontent.com/Awoodwhale/dsh-agent-persona/main/docs/images/settings-editor.gif)
+
+### Version history (opt-in)
+
+Turn on **Save persona version history** in Settings and every save records the text change as a diff in
+`personas.history.json`. The version-history button in the editor toolbar opens the comparison:
+
+![version history demo](https://raw.githubusercontent.com/Awoodwhale/dsh-agent-persona/main/docs/images/versions.gif)
+
+- **Text only**: name, enabled flag and targets are not versioned.
+- **Diffs, not snapshots**: equal runs are stored as line counts; only changed lines keep their text.
+- **Restore**: pick any version and restore it; the restore itself is recorded, so it can be undone too.
+- **Chained replay**: the first text is the base snapshot, later versions replay on top of it; past 200
+  versions the oldest are folded into the base. A content hash per record makes a hand-edited history fail
+  loudly instead of restoring different text.
+- Turning the switch off stops recording; existing history stays readable and restorable.
 
 ### Reading what a session actually said
 
@@ -125,7 +140,7 @@ replies on the left.
 
 ### The 人设 tab on a conversation
 
-![session view](https://raw.githubusercontent.com/Awoodwhale/dsh-agent-persona/main/docs/images/view-persona.png)
+![session view](https://raw.githubusercontent.com/Awoodwhale/dsh-agent-persona/main/docs/images/view-persona.gif)
 
 **人设 / 提示词 / 管理**:
 
@@ -136,7 +151,7 @@ replies on the left.
   persona matched it shows DSH's own prompt verbatim.
 - **管理** — the same cards as the settings page, in place.
 
-### The four preferences
+### The five preferences
 
 | Switch | Default | Meaning | Takes effect |
 |---|---|---|---|
@@ -144,6 +159,7 @@ replies on the left.
 | 在对话页显示「人设」标签 | on | Register the conversation view or not | Immediately (registered/unregistered at runtime) |
 | 注册到 dsh-better-sidebar | on | Register the card with the sidebar plugin | Immediately; **not shown at all when that plugin is absent** |
 | 禁止模型改写人设文件 | on | Refuse the model's file and shell tools any write to or removal of the persona store (reads still work); with it off the model can edit it directly | Immediately, on the next tool call |
+| 保存人设版本历史 | off | Record every text change as a diff in `personas.history.json`, so any version can be compared and restored | Immediately, on the next save |
 
 Preferences live in the persona file's `prefs` field — not in the browser — so they share the data's scope. The
 browser keeps only a mirror, used to decide at load whether to register the views.

package/lib/client.js

@@ -44,7 +44,10 @@
       method("sessionPrompt", withInput()),
       method("tunePersona", withInput()),
       method("listModels", []),
-      method("savePrefs", withInput())
+      method("savePrefs", withInput()),
+      method("listVersions", withInput()),
+      method("versionDiff", withInput()),
+      method("restoreVersion", withInput())
     ]
   };
 
@@ -226,10 +229,21 @@
           return { ...DEFAULT_PREFS };
         }
       };
-      const prefStatus = (next, patch) => "showTab" in patch || "showSidebar" in patch ? "\u5DF2\u4FDD\u5B58\uFF1A\u5DF2\u7ACB\u5373\u751F\u6548" : next.autosave === true ? "\u5DF2\u5F00\u542F\uFF1A\u7F16\u8F91\u540E\u505C\u6B62\u8F93\u5165\u7EA6 1 \u79D2\u5373\u81EA\u52A8\u4FDD\u5B58" : "\u5DF2\u5173\u95ED\uFF1A\u7F16\u8F91\u540E\u81EA\u52A8\u4FDD\u5B58";
+      const PREF_STATUS = {
+        autosave: (on) => on ? "\u5DF2\u5F00\u542F\uFF1A\u7F16\u8F91\u540E\u505C\u6B62\u8F93\u5165\u7EA6 1 \u79D2\u5373\u81EA\u52A8\u4FDD\u5B58" : "\u5DF2\u5173\u95ED\uFF1A\u6539\u5B8C\u8981\u81EA\u5DF1\u70B9\u4FDD\u5B58",
+        showTab: (on) => on ? "\u5DF2\u663E\u793A\u300C\u4EBA\u8BBE\u300D\u6807\u7B7E\uFF08\u5237\u65B0\u9875\u9762\u540E\u51FA\u73B0\uFF09" : "\u5DF2\u9690\u85CF\u300C\u4EBA\u8BBE\u300D\u6807\u7B7E\uFF08\u5237\u65B0\u9875\u9762\u540E\u751F\u6548\uFF09",
+        showSidebar: (on) => on ? "\u5DF2\u6CE8\u518C\u5230 dsh-better-sidebar" : "\u5DF2\u4ECE dsh-better-sidebar \u6CE8\u9500",
+        guard: (on) => on ? "\u5DF2\u5F00\u542F\uFF1A\u6A21\u578B\u7684\u5199\u5165\u4E0E\u547D\u4EE4\u5DE5\u5177\u4E0D\u80FD\u518D\u6539\u4EBA\u8BBE\u5B58\u50A8" : "\u5DF2\u5173\u95ED\uFF1A\u6A21\u578B\u53EF\u4EE5\u76F4\u63A5\u6539\u5199\u4EBA\u8BBE\u5B58\u50A8",
+        history: (on) => on ? "\u5DF2\u5F00\u542F\uFF1A\u6BCF\u6B21\u4FDD\u5B58\u90FD\u4F1A\u8BB0\u4E00\u6761\u7248\u672C\u5386\u53F2" : "\u5DF2\u5173\u95ED\uFF1A\u4E0D\u518D\u8BB0\u65B0\u7248\u672C\uFF0C\u5DF2\u6709\u5386\u53F2\u4ECD\u53EF\u67E5\u770B\u4E0E\u6062\u590D"
+      };
+      const prefStatus = (patch) => {
+        const key = Object.keys(patch ?? {}).find((name) => Object.prototype.hasOwnProperty.call(PREF_STATUS, name));
+        if (key === void 0) return "\u5DF2\u4FDD\u5B58";
+        return PREF_STATUS[key](patch[key] === true);
+      };
       const persistPrefs = (api, unwrap, current, patch, report) => {
         const next = writePrefs({ ...current, ...patch });
-        report({ prefs: next, status: prefStatus(next, patch) });
+        report({ prefs: next, status: prefStatus(patch) });
         syncSidebarModule();
         if (api === void 0 || typeof api.savePrefs !== "function") return next;
         void api.savePrefs(next).then((result) => {
@@ -723,6 +737,22 @@
 @media (prefers-reduced-motion: reduce) {
   [data-plugin="dsh-agent-persona"] * { transition: none !important; }
 }
+
+.wsp-versions { display: flex; flex-direction: column; gap: 12px; max-height: 58vh; }
+.wsp-versions-list { display: flex; flex-direction: row; gap: 8px; overflow-x: auto; padding-bottom: 4px; }
+.wsp-version-row { display: flex; flex-direction: column; gap: 2px; text-align: left; min-width: 150px; max-width: 150px; padding: 8px 10px; border-radius: 8px; border: 1px solid var(--wsp-line); background: transparent; color: inherit; cursor: pointer; font: inherit; }
+.wsp-version-row:hover { border-color: var(--wsp-line-strong); }
+.wsp-version-row.is-active { border-color: var(--dsw-alias-brand-primary, #4f8cff); background: var(--dsw-alias-bg-l2, rgba(79, 140, 255, 0.08)); }
+.wsp-version-title { font-size: 13px; font-weight: 600; }
+.wsp-version-meta { font-size: 11px; opacity: 0.72; font-variant-numeric: tabular-nums; }
+.wsp-version-preview { font-size: 11px; opacity: 0.6; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+.wsp-versions-diff { display: flex; flex-direction: column; gap: 8px; min-width: 0; overflow: hidden; }
+.wsp-diff-head { font-size: 12px; opacity: 0.75; font-variant-numeric: tabular-nums; }
+.wsp-diff-body { overflow: auto; border: 1px solid var(--wsp-line); border-radius: 8px; padding: 8px 0; background: var(--wsp-line-soft); font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 12px; line-height: 1.55; }
+.wsp-diff-line { padding: 0 10px; white-space: pre-wrap; word-break: break-word; }
+.wsp-diff-add { background: rgba(46, 160, 67, 0.16); }
+.wsp-diff-del { background: rgba(248, 81, 73, 0.14); }
+.wsp-diff-skip { padding: 2px 10px; opacity: 0.5; font-size: 11px; }
 `;
       let styleElement;
       const injectStyles = () => {
@@ -1153,6 +1183,11 @@
             dropIndex: void 0,
             history: void 0,
             historyBusy: void 0,
+            versions: void 0,
+            versionsBusy: "",
+            versionsError: "",
+            versionDiff: void 0,
+            versionIndex: void 0,
             models: [],
             model: "",
             tuneOpen: false,
@@ -1163,6 +1198,10 @@
             busy: "",
             error: "",
             status: "",
+            // Bumped on every status write. The toast is keyed on it, so the same sentence twice in a
+            // row (toggling one switch off and on again) remounts instead of silently extending the
+            // toast that is already on screen.
+            statusSeq: 0,
             transfer: void 0
           };
           this.mounted = false;
@@ -1171,8 +1210,15 @@
           this.importTextRef = React.createRef();
           this.importHighlightRef = React.createRef();
           this.importTimer = void 0;
+          this.statusSeq = 0;
           this.onChange = (patch) => {
-            if (this.mounted) this.setState(patch);
+            if (!this.mounted) return;
+            if (patch !== null && typeof patch === "object" && "status" in patch) {
+              this.statusSeq += 1;
+              this.setState({ ...patch, statusSeq: this.statusSeq });
+              return;
+            }
+            this.setState(patch);
           };
           this.onKeyDown = (event) => {
             if (!(event.metaKey || event.ctrlKey) || String(event.key).toLowerCase() !== "s") return;
@@ -1323,6 +1369,55 @@
           }
           return items;
         }
+        /** Version history: list, diff, restore. Opt-in through the settings switch. */
+        async openVersions(id) {
+          const api = this.api();
+          if (api === void 0 || typeof api.listVersions !== "function") {
+            this.onChange({ versionsError: "\u8FD9\u4E2A\u7248\u672C\u8FD8\u6CA1\u6709\u7248\u672C\u5386\u53F2\u63A5\u53E3\uFF1A\u8BF7\u66F4\u65B0\u63D2\u4EF6\u540E\u91CD\u542F dsh web" });
+            return;
+          }
+          this.onChange({ versionsBusy: "list", versionsError: "", versions: { id }, versionDiff: void 0, versionIndex: void 0 });
+          try {
+            const data = this.unwrap(await api.listVersions({ id }));
+            this.onChange({ versionsBusy: "", versions: data });
+            await this.readVersion((data?.versions?.length ?? 0) - 1);
+          } catch (error) {
+            this.onChange({ versionsBusy: "", versions: void 0, versionsError: String(error && error.message || error) });
+          }
+        }
+        /** Load one version's diff; the modal swaps its right pane. */
+        async readVersion(index) {
+          const api = this.api();
+          const versions = this.state.versions;
+          if (api === void 0 || versions === void 0 || index < 0) return;
+          this.onChange({ versionsBusy: "diff", versionIndex: index, versionsError: "" });
+          try {
+            const diff = this.unwrap(await api.versionDiff({ id: versions.id, index }));
+            this.onChange({ versionsBusy: "", versionDiff: diff });
+          } catch (error) {
+            this.onChange({ versionsBusy: "", versionDiff: void 0, versionsError: String(error && error.message || error) });
+          }
+        }
+        /** Put one version back as the persona text (itself recorded as a new version). */
+        async restoreVersion(index) {
+          const api = this.api();
+          const versions = this.state.versions;
+          if (api === void 0 || versions === void 0) return;
+          this.onChange({ versionsBusy: "restore", versionsError: "" });
+          try {
+            const view = this.unwrap(await api.restoreVersion({ id: versions.id, index }));
+            const found = (view?.personas ?? []).find((item) => item.id === versions.id);
+            this.onChange({
+              view,
+              versionsBusy: "",
+              status: view?.notice ?? "\u5DF2\u6062\u590D",
+              draft: this.state.openId === versions.id && found !== void 0 ? this.draftFrom(found) : this.state.draft
+            });
+            await this.openVersions(versions.id);
+          } catch (error) {
+            this.onChange({ versionsBusy: "", versionsError: String(error && error.message || error) });
+          }
+        }
         /** Read a session's recent messages so the user can recognise it. */
         async openHistory(sessionId) {
           const api = this.api();
@@ -2267,6 +2362,14 @@ ${state.proposal.trim()}
                 h("div", { className: "wsp-foot", key: "foot" }, [
                   h("span", { className: "wsp-caption", key: "c" }, `${draft2.text.length} \u5B57 \xB7 \u2318/Ctrl+S \u4FDD\u5B58`),
                   h("div", { className: "wsp-actions", key: "a" }, [
+                    this.state.prefs?.history === true ? h(Button, {
+                      key: "ver",
+                      variant: "ghost",
+                      size: "sm",
+                      disabled: busy,
+                      title: "\u67E5\u770B\u8FD9\u6761\u4EBA\u8BBE\u7684\u7248\u672C\u5386\u53F2",
+                      onClick: () => void this.openVersions(draft2.id)
+                    }, "\u7248\u672C\u5386\u53F2") : null,
                     h(Button, { key: "dup", variant: "ghost", size: "sm", disabled: busy, onClick: () => void this.duplicate(draft2.id) }, "\u590D\u5236"),
                     state.confirmDelete === draft2.id ? h(Button, { key: "del2", variant: "ghost", size: "sm", className: "wsp-icon-btn-danger", disabled: busy, onClick: () => void this.remove(draft2.id) }, "\u786E\u8BA4\u5220\u9664") : h(Button, {
                       key: "del",
@@ -2391,7 +2494,10 @@ ${state.proposal.trim()}
             }
           }, [h(IconPlusOutline16, { key: "i" }), h("span", { key: "t" }, busy ? "\u6B63\u5728\u65B0\u5EFA\u2026" : "\u65B0\u5EFA\u4EBA\u8BBE")])];
           const status = state.error !== "" ? h("div", { className: "wsp-status wsp-status-err", key: "st", "aria-live": "polite" }, state.error) : state.status === "" ? null : h(Toast, {
-            key: "st",
+            // Keyed on the sequence, not on a constant: a repeated sentence has to mount a fresh
+            // toast. With a fixed key React reuses the instance, its dismiss timer keeps running,
+            // and the second flip of a switch produced no toast at all.
+            key: `st-${String(state.statusSeq)}`,
             text: state.status,
             icon: h(IconCheckOutline14, {}),
             onDone: () => this.onChange({ status: "" })
@@ -2501,6 +2607,13 @@ ${state.proposal.trim()}
               label: "\u7981\u6B62\u6A21\u578B\u6539\u5199\u4EBA\u8BBE\u6587\u4EF6",
               hint: "\u6253\u5F00\u540E\uFF0C\u6A21\u578B\u7684\u6587\u4EF6\u4E0E\u547D\u4EE4\u5DE5\u5177\u4E0D\u80FD\u5199\u5165\u6216\u5220\u9664\u4EBA\u8BBE\u5B58\u50A8\uFF08personas.json \u53CA\u5176\u5907\u4EFD\uFF09\uFF1B\u8BFB\u53D6\u4E0D\u53D7\u5F71\u54CD\u3002\u5173\u6389\u540E\u6A21\u578B\u5C31\u80FD\u76F4\u63A5\u6539\u5B83\u3002\u8FD9\u662F\u884C\u4E3A\u5C42\u9762\u7684\u9650\u5236\uFF0C\u4E0D\u662F\u5B89\u5168\u8FB9\u754C\uFF1A\u672C\u673A\u4E0A\u7684\u5176\u5B83\u7A0B\u5E8F\u4ECD\u53EF\u4FEE\u6539\u3002",
               onChange: (next) => this.setPref({ guard: next })
+            }),
+            h(Switch, {
+              key: "history",
+              checked: prefs.history === true,
+              label: "\u4FDD\u5B58\u4EBA\u8BBE\u7248\u672C\u5386\u53F2",
+              hint: "\u6253\u5F00\u540E\u6BCF\u6B21\u4FDD\u5B58\u90FD\u4F1A\u628A\u8FD9\u6B21\u7684\u6B63\u6587\u6539\u52A8\u8BB0\u6210\u4E00\u6761 diff\uFF08\u53E6\u5B58 personas.history.json\uFF09\uFF0C\u53EF\u4EE5\u5728\u7F16\u8F91\u5668\u7684\u300C\u7248\u672C\u5386\u53F2\u300D\u91CC\u5BF9\u6BD4\uFF0C\u5E76\u628A\u4EFB\u610F\u4E00\u6761\u6062\u590D\u6210\u5F53\u524D\u6B63\u6587\u3002\u53EA\u8BB0\u6B63\u6587\uFF0C\u4E0D\u8BB0\u540D\u79F0\u4E0E\u8303\u56F4\u3002",
+              onChange: (next) => this.setPref({ history: next })
             })
           ]);
           const pendingDelete = state.confirmDelete === void 0 || state.confirmDelete === null ? void 0 : personas.find((item) => item.id === state.confirmDelete);
@@ -2515,6 +2628,69 @@ ${state.proposal.trim()}
               h(Button, { key: "ok", variant: "primary", size: "sm", disabled: busy, onClick: () => void this.remove(pendingDelete.id) }, "\u5220\u9664")
             ])
           }, h("div", { className: "wsp-card-note" }, `\u540D\u79F0\uFF1A${pendingDelete.name}\u3000\xB7\u3000${pendingDelete.chars} \u5B57\u3000\xB7\u3000${pendingDelete.targets?.length ?? 0} \u6761\u9002\u7528\u8303\u56F4`));
+          const versionsState = state.versions;
+          const diffState = state.versionDiff;
+          const versionRows = versionsState === void 0 ? [] : [...versionsState.versions ?? []].reverse();
+          const diffLines = [];
+          if (diffState !== void 0) {
+            for (const op of diffState.ops ?? []) {
+              if (op.t === "=") {
+                diffLines.push(h("div", { className: "wsp-diff-skip", key: `s${diffLines.length}` }, `\u22EF ${op.n} \u884C\u672A\u6539\u52A8`));
+                continue;
+              }
+              for (const line of op.lines ?? []) {
+                diffLines.push(h("div", {
+                  className: `wsp-diff-line ${op.t === "+" ? "wsp-diff-add" : "wsp-diff-del"}`,
+                  key: `d${diffLines.length}`
+                }, `${op.t === "+" ? "+" : "\u2212"} ${line === "" ? " " : line}`));
+              }
+            }
+          }
+          const versionsModal = versionsState === void 0 && state.versionsError === "" ? null : h(Modal, {
+            key: "versions",
+            open: true,
+            onClose: () => this.onChange({ versions: void 0, versionDiff: void 0, versionsError: "", versionIndex: void 0 }),
+            title: `\u7248\u672C\u5386\u53F2${versionsState?.name === void 0 ? "" : ` \xB7 ${versionsState.name}`}`,
+            description: "\u6BCF\u6B21\u4FDD\u5B58\u8BB0\u4E00\u6761\u6B63\u6587 diff\u3002\u6062\u590D\u4F1A\u628A\u9009\u4E2D\u7684\u7248\u672C\u5199\u56DE\u5F53\u524D\u4EBA\u8BBE\uFF0C\u5E76\u4F5C\u4E3A\u4E00\u6761\u65B0\u8BB0\u5F55\uFF0C\u6240\u4EE5\u6062\u590D\u672C\u8EAB\u4E5F\u80FD\u518D\u56DE\u6EDA\u3002",
+            footer: h("div", { className: "wsp-form-actions" }, [
+              h(Button, {
+                key: "close",
+                variant: "outline",
+                size: "sm",
+                onClick: () => this.onChange({ versions: void 0, versionDiff: void 0, versionsError: "", versionIndex: void 0 })
+              }, "\u5173\u95ED"),
+              h(Button, {
+                key: "restore",
+                variant: "primary",
+                size: "sm",
+                disabled: state.versionsBusy !== "" || state.versionIndex === void 0 || diffState === void 0,
+                onClick: () => void this.restoreVersion(state.versionIndex)
+              }, state.versionsBusy === "restore" ? "\u6062\u590D\u4E2D\u2026" : "\u6062\u590D\u5230\u6B64\u7248\u672C")
+            ])
+          }, h("div", { className: "wsp-versions" }, [
+            h("div", { className: "wsp-versions-list", key: "l" }, versionRows.length === 0 ? h("div", { className: "wsp-card-note" }, state.versionsError !== "" ? state.versionsError : "\u8FD8\u6CA1\u6709\u5386\u53F2\u7248\u672C\uFF1A\u5148\u5728\u5F00\u5173\u91CC\u6253\u5F00\u300C\u4FDD\u5B58\u4EBA\u8BBE\u7248\u672C\u5386\u53F2\u300D\uFF0C\u7136\u540E\u4FDD\u5B58\u4E00\u6B21\u6B63\u6587\u3002") : versionRows.map((version) => h("button", {
+              type: "button",
+              key: version.index,
+              className: `wsp-version-row${state.versionIndex === version.index ? " is-active" : ""}`,
+              onClick: () => void this.readVersion(version.index)
+            }, [
+              h("span", { className: "wsp-version-title", key: "t" }, `\u7B2C ${version.index + 1} \u7248`),
+              h(
+                "span",
+                { className: "wsp-version-meta", key: "m" },
+                `${String(version.at).replace("T", " ").slice(5, 19)}\u3000+${version.added} / \u2212${version.removed}`
+              ),
+              h("span", { className: "wsp-version-preview", key: "p" }, version.preview || "\uFF08\u65E0\u53EF\u663E\u793A\u7684\u6539\u52A8\u884C\uFF09")
+            ]))),
+            h("div", { className: "wsp-versions-diff", key: "d" }, diffState === void 0 ? h("div", { className: "wsp-card-note" }, "\u5DE6\u4FA7\u9009\u4E00\u4E2A\u7248\u672C\uFF0C\u8FD9\u91CC\u663E\u793A\u5B83\u76F8\u5BF9\u4E0A\u4E00\u7248\u7684\u6539\u52A8\u3002") : [
+              h(
+                "div",
+                { className: "wsp-diff-head", key: "h" },
+                `${String(diffState.at).replace("T", " ").slice(0, 19)}\u3000\xB7\u3000${diffState.action === "restore" ? "\u6062\u590D" : diffState.action === "create" ? "\u65B0\u5EFA" : "\u4FEE\u6539"}\u3000\xB7\u3000+${diffState.added} / \u2212${diffState.removed}`
+              ),
+              h("div", { className: "wsp-diff-body", key: "b" }, diffLines)
+            ])
+          ]));
           const health = view?.storeHealth;
           const healthNote = health === void 0 || health.status === "ok" ? null : h("div", {
             className: `wsp-alert wsp-alert-${health.status}`,
@@ -2621,7 +2797,7 @@ ${state.proposal.trim()}
               ])
             ])
           ]));
-          return h("div", rootProps, [header, healthNote, prefsRow, transferRow, searchRow, hiddenNote, conflictNotice, h("div", { className: "wsp-cards", key: "cards" }, cards), status, historyModal, confirmModal, importModal]);
+          return h("div", rootProps, [header, healthNote, prefsRow, transferRow, searchRow, hiddenNote, conflictNotice, h("div", { className: "wsp-cards", key: "cards" }, cards), status, historyModal, confirmModal, versionsModal, importModal]);
         }
       }
       const inject = ["slots", "remote", "connection"];

package/lib/endpoints.d.ts

@@ -11,6 +11,6 @@ export declare const RPC_PACKAGE = "dsh-agent-persona";
  */
 export declare const RPC_SERVICE = "agentPersona";
 export declare const RPC_CHANNEL = "/agent-persona";
-export declare const RPC_ENDPOINTS: readonly ['listPersonas', 'savePersona', 'deletePersona', 'movePersona', 'duplicatePersona', 'reorderPersona', 'listTargets', 'sessionHistory', 'sessionPrompt', 'tunePersona', 'listModels', 'savePrefs'];
+export declare const RPC_ENDPOINTS: readonly ['listPersonas', 'savePersona', 'deletePersona', 'movePersona', 'duplicatePersona', 'reorderPersona', 'listTargets', 'sessionHistory', 'sessionPrompt', 'tunePersona', 'listModels', 'savePrefs', 'listVersions', 'versionDiff', 'restoreVersion'];
 /** The three reads that take no argument. Everything else receives one JSON object. */
 export declare const RPC_NO_INPUT: readonly ['listPersonas', 'listTargets', 'listModels'];

package/lib/endpoints.js

@@ -24,6 +24,9 @@ export const RPC_ENDPOINTS = [
     'tunePersona',
     'listModels',
     'savePrefs',
+    'listVersions',
+    'versionDiff',
+    'restoreVersion',
 ];
 /** The three reads that take no argument. Everything else receives one JSON object. */
 export const RPC_NO_INPUT = ['listPersonas', 'listTargets', 'listModels'];

package/lib/index.d.ts

@@ -89,6 +89,8 @@ export declare const normalizePrefs: (raw: any) => {
     showTab: boolean;
     showSidebar: boolean;
     guard: boolean;
+    /** Opt-in version history: off by default, because it writes a second file on every save. */
+    history: boolean;
 };
 /** Filename-safe local timestamp for a store backup. */
 export declare const backupStamp: (now?: Date) => string;
@@ -108,6 +110,45 @@ export declare const backupStoreFile: (storePath: any, stamp: any) => string;
  */
 export declare const personaStoreGuardReason: (execution: any, storePath: any) => string;
 export declare const sanitizePersona: (text: any, warn?: () => void) => string;
+/**
+ * Opt-in per-persona version history.
+ *
+ * Every save stores the diff against the previous text (equal runs as counts, changed lines verbatim),
+ * so one record costs about as much as the edit rather than the whole document. The first version of a
+ * persona is kept as a base snapshot; every later version is reconstructed by replaying the diffs from
+ * that base. A hash per entry makes a corrupted or hand-edited history fail loudly instead of restoring
+ * the wrong text.
+ */
+export declare const HISTORY_VERSION = 1;
+/** Versions kept per persona; the oldest are folded into the base snapshot when the cap is hit. */
+export declare const MAX_VERSIONS = 200;
+export declare const historyPathFor: (storePath: any) => any;
+/**
+ * Line diff between two texts, as a sequence of equal/removed/added runs.
+ *
+ * Longest-common-subsequence over lines, with the shared prefix and suffix stripped first. That keeps the
+ * usual "edit one paragraph" case cheap; a pathological rewrite falls back to one remove+add pair, which
+ * is still a correct (if coarse) diff.
+ */
+export declare const diffLines: (beforeText: any, afterText: any) => any[];
+/**
+ * Replay a diff onto a text. Equal runs count lines from the current text (their content is not stored, which
+ * is what keeps a record small); removals are checked against it so a mismatched history throws instead of
+ * silently producing a different document.
+ */
+export declare const applyDiff: (text: any, ops: any) => string;
+/** `+n / -m` summary used by the list row. */
+export declare const diffStats: (ops: any) => {
+    added: number;
+    removed: number;
+};
+/** Current text of one stored version (index 0 is the oldest kept version). */
+export declare const versionTextAt: (entryState: any, index: any) => any;
+/**
+ * Record one new version. `before` is the text the persona had, `after` the text it now has.
+ * Returns false when the history is off or nothing changed.
+ */
+export declare const recordVersion: (history: any, personaId: any, before: any, after: any, action: any, now?: string) => boolean;
 /**
  * Does one target claim this subject?
  * @param target - normalized target record.

package/lib/index.js

@@ -50,6 +50,7 @@ import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import Schema from '@deepseek-ai/schemastery';
 import { RPC_ENDPOINTS } from './endpoints.js';
 import { chmodSync, copyFileSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { basename, dirname, join, resolve } from 'node:path';
@@ -171,6 +172,8 @@ export const normalizePrefs = (raw) => ({
     showTab: raw?.showTab !== false,
     showSidebar: raw?.showSidebar !== false,
     guard: raw?.guard !== false,
+    /** Opt-in version history: off by default, because it writes a second file on every save. */
+    history: raw?.history === true,
 });
 /**
  * Read the store. A missing file is a normal first run and stays silent; a file that exists but cannot be
@@ -300,6 +303,236 @@ export const sanitizePersona = (text, warn = () => { }) => {
         warn(`persona text references unsupported prompt variables (${[...new Set(dropped)].join(', ')}); rendered as plain text`);
     return out;
 };
+// ─────────────────────────────────────────────────────────── version history
+/**
+ * Opt-in per-persona version history.
+ *
+ * Every save stores the diff against the previous text (equal runs as counts, changed lines verbatim),
+ * so one record costs about as much as the edit rather than the whole document. The first version of a
+ * persona is kept as a base snapshot; every later version is reconstructed by replaying the diffs from
+ * that base. A hash per entry makes a corrupted or hand-edited history fail loudly instead of restoring
+ * the wrong text.
+ */
+export const HISTORY_VERSION = 1;
+/** Versions kept per persona; the oldest are folded into the base snapshot when the cap is hit. */
+export const MAX_VERSIONS = 200;
+export const historyPathFor = (storePath) => join(dirname(storePath), 'personas.history.json');
+const splitLines = (text) => String(text ?? '').split('\n');
+/**
+ * Line diff between two texts, as a sequence of equal/removed/added runs.
+ *
+ * Longest-common-subsequence over lines, with the shared prefix and suffix stripped first. That keeps the
+ * usual "edit one paragraph" case cheap; a pathological rewrite falls back to one remove+add pair, which
+ * is still a correct (if coarse) diff.
+ */
+export const diffLines = (beforeText, afterText) => {
+    const a = splitLines(beforeText);
+    const b = splitLines(afterText);
+    let head = 0;
+    while (head < a.length && head < b.length && a[head] === b[head])
+        head += 1;
+    let tail = 0;
+    while (tail < a.length - head && tail < b.length - head && a[a.length - 1 - tail] === b[b.length - 1 - tail])
+        tail += 1;
+    const midA = a.slice(head, a.length - tail);
+    const midB = b.slice(head, b.length - tail);
+    const ops = [];
+    const pushEqual = (n) => {
+        if (n <= 0)
+            return;
+        const last = ops[ops.length - 1];
+        if (last?.t === '=')
+            last.n += n;
+        else
+            ops.push({ t: '=', n });
+    };
+    pushEqual(head);
+    const n = midA.length;
+    const m = midB.length;
+    if (n > 0 && m > 0 && n * m <= 4_000_000) {
+        // DP table over the changed middle only.
+        const width = m + 1;
+        const table = new Uint32Array((n + 1) * width);
+        for (let i = n - 1; i >= 0; i -= 1) {
+            for (let j = m - 1; j >= 0; j -= 1) {
+                table[i * width + j] = midA[i] === midB[j]
+                    ? table[(i + 1) * width + j + 1] + 1
+                    : Math.max(table[(i + 1) * width + j], table[i * width + j + 1]);
+            }
+        }
+        let i = 0;
+        let j = 0;
+        let equal = 0;
+        const flushEqual = () => {
+            pushEqual(equal);
+            equal = 0;
+        };
+        while (i < n && j < m) {
+            if (midA[i] === midB[j]) {
+                equal += 1;
+                i += 1;
+                j += 1;
+                continue;
+            }
+            flushEqual();
+            if (table[(i + 1) * width + j] >= table[i * width + j + 1]) {
+                const last = ops[ops.length - 1];
+                if (last?.t === '-')
+                    last.lines.push(midA[i]);
+                else
+                    ops.push({ t: '-', lines: [midA[i]] });
+                i += 1;
+            }
+            else {
+                const last = ops[ops.length - 1];
+                if (last?.t === '+')
+                    last.lines.push(midB[j]);
+                else
+                    ops.push({ t: '+', lines: [midB[j]] });
+                j += 1;
+            }
+        }
+        flushEqual();
+        if (i < n)
+            ops.push({ t: '-', lines: midA.slice(i) });
+        if (j < m)
+            ops.push({ t: '+', lines: midB.slice(j) });
+    }
+    else if (n > 0 || m > 0) {
+        if (n > 0)
+            ops.push({ t: '-', lines: midA.slice() });
+        if (m > 0)
+            ops.push({ t: '+', lines: midB.slice() });
+    }
+    pushEqual(tail);
+    return ops;
+};
+/**
+ * Replay a diff onto a text. Equal runs count lines from the current text (their content is not stored, which
+ * is what keeps a record small); removals are checked against it so a mismatched history throws instead of
+ * silently producing a different document.
+ */
+export const applyDiff = (text, ops) => {
+    const lines = splitLines(text);
+    const out = [];
+    let at = 0;
+    for (const op of Array.isArray(ops) ? ops : []) {
+        if (op?.t === '=') {
+            const n = Math.max(0, Number(op.n) || 0);
+            for (let k = 0; k < n; k += 1) {
+                if (at >= lines.length)
+                    throw new Error('版本历史损坏：相等的行超出当前文本');
+                out.push(lines[at]);
+                at += 1;
+            }
+        }
+        else if (op?.t === '-') {
+            const gone = Array.isArray(op.lines) ? op.lines : [];
+            for (const line of gone) {
+                if (lines[at] !== line)
+                    throw new Error('版本历史损坏：删除的行与当前文本不一致');
+                at += 1;
+            }
+        }
+        else if (op?.t === '+') {
+            for (const line of Array.isArray(op.lines) ? op.lines : [])
+                out.push(line);
+        }
+    }
+    while (at < lines.length) {
+        out.push(lines[at]);
+        at += 1;
+    }
+    return out.join('\n');
+};
+/** `+n / -m` summary used by the list row. */
+export const diffStats = (ops) => {
+    let added = 0;
+    let removed = 0;
+    for (const op of Array.isArray(ops) ? ops : []) {
+        if (op?.t === '+')
+            added += op.lines.length;
+        if (op?.t === '-')
+            removed += op.lines.length;
+    }
+    return { added, removed };
+};
+const readHistory = (storePath, warn) => {
+    const file = historyPathFor(storePath);
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        if (parsed && typeof parsed === 'object' && parsed.personas && typeof parsed.personas === 'object') {
+            return { version: HISTORY_VERSION, personas: parsed.personas };
+        }
+    }
+    catch (error) {
+        if (error?.code !== 'ENOENT')
+            warn(`could not read the version history; starting a fresh one`, error);
+    }
+    return { version: HISTORY_VERSION, personas: {} };
+};
+const persistFile = (file, text, mode) => {
+    mkdirSync(dirname(file), { recursive: true });
+    const tmp = `${file}.tmp-${process.pid}`;
+    writeFileSync(tmp, text, { mode });
+    renameSync(tmp, file);
+};
+const writeHistory = (storePath, history, warn) => {
+    const file = historyPathFor(storePath);
+    try {
+        mkdirSync(dirname(file), { recursive: true });
+        persistFile(file, `${JSON.stringify(history)}\n`, 0o600);
+    }
+    catch (error) {
+        warn(`could not write the version history`, error);
+    }
+};
+/** Current text of one stored version (index 0 is the oldest kept version). */
+export const versionTextAt = (entryState, index) => {
+    const state = entryState;
+    if (!state || typeof state.base !== 'string')
+        throw new Error('这条人设还没有版本历史');
+    const versions = Array.isArray(state.versions) ? state.versions : [];
+    if (!Number.isInteger(index) || index < 0 || index >= versions.length)
+        throw new Error('版本不存在');
+    let text = state.base;
+    for (let k = 0; k <= index; k += 1)
+        text = applyDiff(text, versions[k].ops);
+    return text;
+};
+/**
+ * Record one new version. `before` is the text the persona had, `after` the text it now has.
+ * Returns false when the history is off or nothing changed.
+ */
+export const recordVersion = (history, personaId, before, after, action, now = new Date().toISOString()) => {
+    const beforeText = String(before ?? '');
+    const afterText = String(after ?? '');
+    if (beforeText === afterText)
+        return false;
+    const ops = diffLines(beforeText, afterText);
+    const stats = diffStats(ops);
+    let state = history.personas[personaId];
+    if (state === undefined || typeof state.base !== 'string') {
+        state = { base: beforeText, baseAt: now, versions: [] };
+        history.personas[personaId] = state;
+    }
+    state.versions.push({
+        at: now,
+        action,
+        ops,
+        added: stats.added,
+        removed: stats.removed,
+        hash: createHash('sha256').update(afterText, 'utf8').digest('hex').slice(0, 16),
+        size: Buffer.byteLength(afterText, 'utf8'),
+    });
+    // Fold the oldest versions into the base once the cap is hit, so every kept version stays replayable.
+    while (state.versions.length > MAX_VERSIONS) {
+        const [oldest] = state.versions.splice(0, 1);
+        state.base = applyDiff(state.base, oldest.ops);
+        state.baseAt = oldest.at;
+    }
+    return true;
+};
 // ─────────────────────────────────────────────────────────── matching
 const regexCache = new Map();
 const compile = (value) => {
@@ -1073,6 +1306,33 @@ class WorkspacePersonaService extends TypertRemoteService {
             return { error: `savePersona failed: ${String((error && error.stack) || error)}` };
         }
     }
+    /** Version list for one persona (opt-in history). */
+    async listVersions(input) {
+        try {
+            return this.runtime.listVersions(input);
+        }
+        catch (error) {
+            return { error: `listVersions failed: ${String((error && error.stack) || error)}` };
+        }
+    }
+    /** One stored version with its diff. */
+    async versionDiff(input) {
+        try {
+            return this.runtime.versionDiff(input);
+        }
+        catch (error) {
+            return { error: `versionDiff failed: ${String((error && error.stack) || error)}` };
+        }
+    }
+    /** Restore a stored version as the current persona text. */
+    async restoreVersion(input) {
+        try {
+            return this.runtime.restoreVersion(input);
+        }
+        catch (error) {
+            return { error: `restoreVersion failed: ${String((error && error.stack) || error)}` };
+        }
+    }
     /** Remove one persona. */
     async deletePersona(input) {
         try {
@@ -1401,8 +1661,90 @@ export function apply(ctx, config = {}) {
             targets,
         };
     };
+    /** Read + write the history file around one mutation; a disabled switch costs nothing. */
+    const historyEnabled = () => currentStore().prefs?.history === true;
+    const recordIfEnabled = (personaId, before, after, action) => {
+        if (!historyEnabled() || personaId === undefined)
+            return;
+        const history = readHistory(storePath, warn);
+        if (!recordVersion(history, personaId, before, after, action))
+            return;
+        writeHistory(storePath, history, warn);
+    };
     const runtime = {
         view,
+        /** Version list for one persona (newest first for display, indices stay oldest-first). */
+        listVersions(input) {
+            const id = typeof input?.id === 'string' ? input.id : '';
+            const persona = currentStore().personas.find((item) => item.id === id);
+            if (persona === undefined)
+                throw new Error('人设不存在（可能已被删除）');
+            const history = readHistory(storePath, warn);
+            const state = history.personas[id];
+            const versions = Array.isArray(state?.versions) ? state.versions : [];
+            return {
+                id,
+                name: persona.name,
+                enabled: historyEnabled(),
+                baseAt: state?.baseAt ?? '',
+                max: MAX_VERSIONS,
+                current: persona.text,
+                versions: versions.map((version, index) => ({
+                    index,
+                    at: version.at,
+                    action: version.action,
+                    added: version.added,
+                    removed: version.removed,
+                    size: version.size,
+                    preview: (version.ops ?? []).find((op) => op.t === '+')?.lines?.[0] ?? '',
+                })),
+            };
+        },
+        /** One version with the text it produced and the diff against the version before it. */
+        versionDiff(input) {
+            const id = typeof input?.id === 'string' ? input.id : '';
+            const persona = currentStore().personas.find((item) => item.id === id);
+            if (persona === undefined)
+                throw new Error('人设不存在（可能已被删除）');
+            const history = readHistory(storePath, warn);
+            const state = history.personas[id];
+            const index = Number(input?.index);
+            const version = state?.versions?.[index];
+            if (version === undefined)
+                throw new Error('版本不存在');
+            const after = versionTextAt(state, index);
+            const before = index === 0 ? state.base : versionTextAt(state, index - 1);
+            return {
+                id,
+                index,
+                at: version.at,
+                action: version.action,
+                added: version.added,
+                removed: version.removed,
+                ops: version.ops,
+                before,
+                after,
+                current: persona.text,
+            };
+        },
+        /** Put a stored version back as the persona text; the restore itself is recorded as a new version. */
+        restoreVersion(input) {
+            const current = reload();
+            const id = typeof input?.id === 'string' ? input.id : '';
+            const persona = current.personas.find((item) => item.id === id);
+            if (persona === undefined)
+                throw new Error('人设不存在（可能已被删除）');
+            const history = readHistory(storePath, warn);
+            const text = versionTextAt(history.personas[id], Number(input?.index));
+            const before = persona.text;
+            persona.text = text;
+            commit(current);
+            recordIfEnabled(id, before, text, 'restore');
+            info(`restored persona "${persona.name}" to version ${String(input?.index)}`);
+            const result = view();
+            result.notice = `已恢复到第 ${Number(input?.index) + 1} 个版本`;
+            return result;
+        },
         /** Merge preferences into the store; every field is optional so one switch can be saved. */
         savePrefs(input) {
             const current = reload();
@@ -1414,6 +1756,8 @@ export function apply(ctx, config = {}) {
         save(input) {
             const next = normalizeInput(input);
             const current = reload();
+            const beforeText = next.id === undefined ? '' : (current.personas.find((item) => item.id === next.id)?.text ?? '');
+            const created = next.id === undefined;
             let persona;
             if (next.id === undefined) {
                 persona = { id: newId(), name: next.name, enabled: next.enabled, fallback: next.fallback, text: next.text, mode: next.mode, targets: next.targets };
@@ -1447,6 +1791,8 @@ export function apply(ctx, config = {}) {
                 }
             }
             commit(current);
+            if (next.text !== beforeText)
+                recordIfEnabled(persona.id, beforeText, next.text, created ? 'create' : 'update');
             const result = view();
             if (released.length > 0) {
                 result.notice = `「${persona.name}」现在是默认人设；「${released.join('」「')}」已取消默认`;

package/lib/remote.js

@@ -51,5 +51,8 @@ export const RPC_REMOTE = {
         method("tunePersona", withInput()),
         method("listModels", []),
         method("savePrefs", withInput()),
+        method("listVersions", withInput()),
+        method("versionDiff", withInput()),
+        method("restoreVersion", withInput()),
     ],
 };

package/lib/typert.js

@@ -40,6 +40,9 @@ export const TYPERT = {
                     { name: "tunePersona", kind: "method", signature: "(input: unknown): Promise<unknown>" },
                     { name: "listModels", kind: "method", signature: "(): Promise<unknown>" },
                     { name: "savePrefs", kind: "method", signature: "(input: unknown): Promise<unknown>" },
+                    { name: "listVersions", kind: "method", signature: "(input: unknown): Promise<unknown>" },
+                    { name: "versionDiff", kind: "method", signature: "(input: unknown): Promise<unknown>" },
+                    { name: "restoreVersion", kind: "method", signature: "(input: unknown): Promise<unknown>" },
                 ],
                 types: [],
             },
@@ -219,5 +222,53 @@ export const TYPERT = {
             ],
             result: result("Json"),
         },
+        {
+            id: `dsh-agent-persona#agentPersona/listVersions`,
+            service: "agentPersona",
+            namespace: "agentPersona",
+            method: "listVersions",
+            invocation: direct,
+            parameters: [
+                {
+                    name: "input",
+                    wire: "input",
+                    source: "json",
+                    codec: jsonCodec("Json"),
+                },
+            ],
+            result: result("Json"),
+        },
+        {
+            id: `dsh-agent-persona#agentPersona/versionDiff`,
+            service: "agentPersona",
+            namespace: "agentPersona",
+            method: "versionDiff",
+            invocation: direct,
+            parameters: [
+                {
+                    name: "input",
+                    wire: "input",
+                    source: "json",
+                    codec: jsonCodec("Json"),
+                },
+            ],
+            result: result("Json"),
+        },
+        {
+            id: `dsh-agent-persona#agentPersona/restoreVersion`,
+            service: "agentPersona",
+            namespace: "agentPersona",
+            method: "restoreVersion",
+            invocation: direct,
+            parameters: [
+                {
+                    name: "input",
+                    wire: "input",
+                    source: "json",
+                    codec: jsonCodec("Json"),
+                },
+            ],
+            result: result("Json"),
+        },
     ],
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-agent-persona",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Workspace personas for DeepSeek Harness (DSH): create many system-prompt personas and scope each one by workspace path or session id (exact / prefix / regex / contains), managed from a Web settings page with Markdown editing and AI tuning.",
   "type": "module",
   "main": "lib/index.js",