npm - dsh-agent-persona - Versions diffs - 0.1.5 → 0.1.6 - Mend

dsh-agent-persona 0.1.5 → 0.1.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/CHANGELOG.md CHANGED Viewed

@@ -4,6 +4,34 @@ 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.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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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())
     ]
   };
@@ -723,6 +726,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 +1172,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,
@@ -1323,6 +1347,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 +2340,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",
@@ -2501,6 +2582,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 +2603,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 +2772,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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "dsh-agent-persona",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "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",