@chaoset/session-archive 0.1.0

package/README.md

@@ -0,0 +1,66 @@
+# @chaoset/session-archive
+
+DSH 插件：归档会话管理 —— 补上 DSH 缺失的"归档后半程"。
+
+web 侧边栏底部新增 **归档** 面板（🗂）：
+
+- **查看归档**：列出全部归档会话（标题、目录、创建/最后修改时间、体积、
+  运行状态），点击任意会话可展开**只读浏览**其完整聊天内容（用户/助手文本
+  消息）。
+- **一次多选批量操作**：
+  - **恢复归档**（unarchive）：把勾选的会话移回会话树，恢复其在原工作区的
+    位置（归档时保留的 slot 会计不被破坏）。
+  - **彻底删除**（delete）：删除勾选会话的持久化文件与归档记录。删除为
+    两段式确认（第一次点击进入确认态，4 秒内再次点击执行），避免误删。
+- 工具条提供**全选**、已选计数；**运行中**（live）的会话显示黄色徽标且
+  禁止勾选删除（请先停止会话）；列表随会话树变化自动可刷新（⟳）。
+
+## 安装
+
+```bash
+dsh plugin --profile web add @chaoset/session-archive
+```
+
+重启 web profile 后，侧边栏底部出现"归档"按钮。插件由两部分组成：host
+插件（归档读写/删除逻辑）与 web 客户端（面板 UI），随 `dsh.bundle.patch`
+自动激活。
+
+## 工作原理
+
+- **列表**：`workspaceRegistry.archivedSessionIds` ∩ `sessionPersistence.list()`，
+  标题从会话事件流折叠（最后一个 `session/title` 事件，与 dsh-session-title
+  同规则）；文件信息来自 `sessionPersistence.locate()` + `stat`。
+- **查看**：`sessionPersistence.readFrom(id, 0)` 只读解析会话事件，提取
+  文本消息（`user/message` / `assistant/message` 的 text 块），不做任何
+  写入/修复。
+- **删除**：live 会话拒绝；每个会话删除持久化文件与会话目录（`locate()`
+  定位）；最后从归档集合移除。归档集合没有官方移除 API，插件复用 registry
+  自身的串行化写入通道（`enqueueOperation → requireState → setState`，
+  与 `archiveSession` 同一路径）；若内部形状变化会自动降级为"仅删文件"，
+  归档列表按文件存在性过滤，功能不受影响。
+- **恢复**：仅从归档集合移除 id，会话数据不动，恢复后回到原工作区位置。
+
+## Remote API（`ctx.remote.sessionArchive`）
+
+| 方法 | 参数 | 返回 |
+| --- | --- | --- |
+| `list()` | — | `{ items: ArchiveRow[] }` |
+| `detail(sessionId)` | 会话 id | `{ sessionId, header, title, messageCount, messages, live }` |
+| `delete(sessionIds[])` | id 数组 | `{ deleted, failed, removedFromArchive }` |
+| `unarchive(sessionIds[])` | id 数组 | `{ restored, removedFromArchive }` |
+
+`ArchiveRow`：`{ sessionId, title, cwd, createdAt, updatedAt, size, live }`。
+
+## 配置
+
+config 字段（`cordis.patch.yml` 或 `~/.dsh/plugins/session-archive/config.json`）：
+
+- `detailMaxMessages`（默认 200）：查看时返回的最大消息条数。
+- `messagePreviewChars`（默认 2000）：单条消息预览的最大字符数。
+- `titleReadConcurrency`（默认 4）：列表加载时并发读取标题的并行度。
+
+## 限制
+
+- 运行中（live）的会话无法删除 —— 先停止会话再删除。
+- 无官方 unarchive API，恢复归档通过 registry 写入通道实现；若未来 DSH
+  提供官方 API，插件会切换过去（行为不变）。

package/client/client.cjs

@@ -0,0 +1,450 @@
+window.__ModuleLoader__.load({
+  id: "@chaoset/session-archive",
+  factory: (require) => {
+    var module = { exports: {} };
+    var exports = module.exports;
+    let react = require("react");
+
+    // ── 样式（注入 style 标签，复用 DSH 设计变量）────────────────────────
+    var css = [
+      ".sa_badge{width:100%;height:49px;color:var(--dsw-alias-label-primary);cursor:pointer;background:0 0;border:none;border-radius:12px;align-items:center;gap:8px;padding:0 8px 0 6px;font-family:inherit;font-size:14px;display:inline-flex;overflow:hidden}",
+      ".sa_badge:hover{background:var(--dsw-alias-interactive-bg-hover)}",
+      ".sa_badgeIcon{flex:none;font-size:15px;line-height:20px}",
+      ".sa_badgeLabel{text-overflow:ellipsis;white-space:nowrap;min-width:0;overflow:hidden}",
+      ".sa_badgeCount{color:var(--dsw-alias-label-tertiary);font-variant-numeric:tabular-nums;flex:none;margin-left:auto;font-size:12px;line-height:16px}",
+      ".sa_panel{z-index:30;border:1px solid var(--dsw-alias-border-l1);background:var(--dsw-alias-bg-base);width:440px;max-width:calc(100vw - 24px);max-height:62vh;box-shadow:var(--dsw-shadow-lv2);--dsh-scrollbar-thumb:var(--dsw-alias-scrollbar-bg-l2);--dsh-scrollbar-thumb-hover:var(--dsw-alias-scrollbar-hover-l2);border-radius:12px;flex-direction:column;display:flex;position:fixed;bottom:128px;left:12px;overflow:hidden}",
+      ".sa_header{box-sizing:border-box;border-bottom:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-base);flex:none;justify-content:space-between;align-items:center;min-height:44px;padding:8px 12px;display:flex}",
+      ".sa_title{color:var(--dsw-alias-label-primary);font-size:13px;font-weight:500;line-height:20px}",
+      ".sa_iconBtn{font:inherit;cursor:pointer;border:0;border-radius:8px;width:36px;height:36px;color:var(--dsw-alias-label-secondary,#666);background:0 0;display:inline-flex;align-items:center;justify-content:center;font-size:18px}",
+      ".sa_refresh{font:inherit;cursor:pointer;border:1px solid var(--dsw-alias-border-l1);border-radius:8px;min-height:36px;padding:5px 14px;font-size:13px;line-height:20px;background:var(--dsw-alias-bg-base);color:var(--dsw-alias-label-primary);display:inline-flex;align-items:center;gap:5px}",
+      ".sa_refresh:hover:not(:disabled){background:var(--dsw-alias-interactive-bg-hover)}",
+      ".sa_refresh:disabled{opacity:.4;cursor:default}",
+      ".sa_iconBtn:hover{background:var(--dsw-alias-interactive-bg-hover)}",
+      ".sa_iconBtn:disabled{opacity:.4;cursor:default}",
+      ".sa_toolbar{flex:none;border-bottom:1px solid var(--dsw-alias-border-l2);align-items:center;gap:8px;padding:8px 12px;display:flex;flex-wrap:wrap}",
+      ".sa_check{accent-color:var(--dsw-alias-label-primary);width:14px;height:14px;flex:none;cursor:pointer}",
+      ".sa_check:disabled{cursor:default;opacity:.45}",
+      ".sa_toolLabel{color:var(--dsw-alias-label-secondary);font-size:12px;line-height:18px;user-select:none;cursor:pointer;display:inline-flex;align-items:center;gap:6px}",
+      ".sa_count{color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px;flex:1}",
+      ".sa_action{font:inherit;cursor:pointer;border:1px solid var(--dsw-alias-border-l1);border-radius:6px;padding:3px 10px;font-size:12px;line-height:18px;background:var(--dsw-alias-bg-base);color:var(--dsw-alias-label-primary)}",
+      ".sa_action:hover:not(:disabled){background:var(--dsw-alias-interactive-bg-hover)}",
+      ".sa_action:disabled{opacity:.4;cursor:default}",
+      ".sa_actionDanger{border-color:transparent;background:var(--dsw-alias-state-error-primary);color:#fff}",
+      ".sa_actionDanger:hover:not(:disabled){background:var(--dsw-alias-state-error-primary)}",
+      ".sa_actionDanger:disabled{opacity:.4}",
+      ".sa_confirm{color:var(--dsw-alias-state-error-primary);border:1px solid var(--dsw-alias-state-error-primary);background:color-mix(in srgb,var(--dsw-alias-state-error-primary) 10%,transparent)}",
+      ".sa_body{flex:1;min-height:0;padding:4px 12px 12px;overflow-y:auto}",
+      ".sa_empty{color:var(--dsw-alias-label-tertiary);margin:24px 0;text-align:center;font-size:12px;line-height:18px}",
+      ".sa_error{color:var(--dsw-alias-state-error-primary);margin:8px 0;font-size:12px;line-height:18px}",
+      ".sa_rows{flex-direction:column;gap:8px;margin:0;padding:0;list-style:none;display:flex}",
+      ".sa_row{border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-base);border-radius:12px;flex-direction:column;gap:6px;padding:8px 10px;display:flex}",
+      ".sa_rowHead{align-items:center;gap:8px;display:flex}",
+      ".sa_rowTitle{min-width:0;color:var(--dsw-alias-label-primary);text-overflow:ellipsis;white-space:nowrap;flex:1;font-size:13px;font-weight:500;line-height:20px;overflow:hidden;cursor:pointer}",
+      ".sa_rowTitle:hover{text-decoration:underline}",
+      ".sa_live{background:var(--dsw-alias-state-warn-tertiary);color:var(--dsw-alias-state-warn-label);height:18px;border-radius:9px;flex:none;align-items:center;padding:0 6px;font-size:11px;line-height:18px;display:inline-flex}",
+      ".sa_rowMeta{color:var(--dsw-alias-label-tertiary);font-size:11px;line-height:16px;overflow-wrap:anywhere}",
+      ".sa_rowMeta code{font-family:var(--dsh-font-mono,monospace)}",
+      ".sa_rowFoot{justify-content:space-between;align-items:center;gap:8px;display:flex}",
+      ".sa_rowActions{flex:none;align-items:center;gap:8px;display:flex}",
+      ".sa_detail{border-top:1px dashed var(--dsw-alias-border-l2);padding-top:8px;flex-direction:column;gap:6px;display:flex;max-height:260px;overflow-y:auto}",
+      ".sa_msg{flex-direction:column;gap:2px;display:flex}",
+      ".sa_msgRole{color:var(--dsw-alias-label-tertiary);font-size:10px;line-height:14px;text-transform:uppercase;letter-spacing:.04em}",
+      ".sa_msgText{color:var(--dsw-alias-label-primary);white-space:pre-wrap;overflow-wrap:anywhere;font-size:12px;line-height:18px}",
+      ".sa_msgTextUser{color:var(--dsw-alias-label-secondary)}",
+      ".sa_busy{opacity:.55;pointer-events:none}"
+    ].join("");
+    var tagId = "@chaoset/session-archive/client.css";
+    if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=\"" + tagId + "\"]") === null) {
+      var tag = document.createElement("style");
+      tag.dataset.plugin = "@chaoset/session-archive";
+      tag.dataset.pluginCss = tagId;
+      tag.textContent = css;
+      document.head.appendChild(tag);
+    }
+
+    // ── 字典 ─────────────────────────────────────────────────────────────
+    const NS = "sidebar.sessionArchive";
+    const zh = {
+      badge: "归档",
+      panelTitle: "归档会话",
+      refresh: "刷新",
+      close: "关闭",
+      empty: "暂无归档会话。在会话列表的更多菜单中归档会话后会出现在这里。",
+      loadFailed: "加载归档列表失败",
+      selectAll: "全选",
+      selected: "已选 {n} 项",
+      restore: "恢复所选",
+      restoreDone: "已恢复 {n} 个会话",
+      restoreFailed: "恢复失败",
+      delete: "删除所选",
+      deleteConfirm: "再次点击确认删除",
+      deleteDone: "已删除 {n} 个会话",
+      deleteFailed: "部分删除失败：{n} 个",
+      confirmAll: "确认删除全部 {n} 个？",
+      noSelection: "请先勾选会话",
+      view: "查看",
+      collapse: "收起",
+      live: "运行中",
+      detailLoadFailed: "读取会话内容失败",
+      noneTitle: "（无标题）",
+      user: "用户",
+      assistant: "助手",
+      messages: "共 {n} 条消息",
+      noMessages: "（无文本消息）",
+      sizeBytes: "{n} B",
+      sizeKB: "{n} KB",
+      sizeMB: "{n} MB",
+      runningHint: "运行中的会话不能删除，请先停止"
+    };
+    const en = {
+      badge: "Archive",
+      panelTitle: "Archived sessions",
+      refresh: "Refresh",
+      close: "Close",
+      empty: "No archived sessions. Archive a session from its menu in the session list and it will show up here.",
+      loadFailed: "Failed to load archive list",
+      selectAll: "Select all",
+      selected: "{n} selected",
+      restore: "Restore",
+      restoreDone: "Restored {n} sessions",
+      restoreFailed: "Restore failed",
+      delete: "Delete",
+      deleteConfirm: "Click again to confirm delete",
+      deleteDone: "Deleted {n} sessions",
+      deleteFailed: "Some deletions failed: {n}",
+      confirmAll: "Delete all {n}?",
+      noSelection: "Select sessions first",
+      view: "View",
+      collapse: "Collapse",
+      live: "Running",
+      detailLoadFailed: "Failed to read session content",
+      noneTitle: "(no title)",
+      user: "User",
+      assistant: "Assistant",
+      messages: "{n} messages",
+      noMessages: "(no text messages)",
+      sizeBytes: "{n} B",
+      sizeKB: "{n} KB",
+      sizeMB: "{n} MB",
+      runningHint: "Running sessions cannot be deleted; stop them first"
+    };
+
+    // ── 工具函数 ─────────────────────────────────────────────────────────
+    function formatBytes(bytes, t) {
+      if (bytes < 1024) return t("sizeBytes").replace("{n}", String(bytes));
+      if (bytes < 1024 * 1024) return t("sizeKB").replace("{n}", (bytes / 1024).toFixed(1));
+      return t("sizeMB").replace("{n}", (bytes / (1024 * 1024)).toFixed(1));
+    }
+    function formatTime(ms) {
+      try { return new Date(ms).toLocaleString(); } catch { return String(ms); }
+    }
+    function shortId(id) {
+      return id.length > 12 ? id.slice(0, 12) + "…" : id;
+    }
+
+    // ── 归档面板 ─────────────────────────────────────────────────────────
+    function ArchivePanel(props) {
+      const t = props.t;
+      const call = props.call;
+      const rootRef = react.useRef(null);
+      const [open, setOpen] = react.useState(false);
+      const [items, setItems] = react.useState([]);
+      const [loading, setLoading] = react.useState(false);
+      const [error, setError] = react.useState(null);
+      const [selected, setSelected] = react.useState(new Set());
+      const [expanded, setExpanded] = react.useState(null);
+      const [details, setDetails] = react.useState(new Map());
+      const [detailLoading, setDetailLoading] = react.useState(new Set());
+      const [busy, setBusy] = react.useState(false);
+      const [confirmingDelete, setConfirmingDelete] = react.useState(false);
+      const [notice, setNotice] = react.useState(null);
+
+      const load = react.useCallback(async () => {
+        setLoading(true);
+        setError(null);
+        try {
+          const result = await call("list");
+          setItems(Array.isArray(result.items) ? result.items : []);
+        } catch (loadError) {
+          setError(t("loadFailed") + ": " + (loadError && loadError.message || loadError));
+        } finally {
+          setLoading(false);
+        }
+      }, [call, t]);
+
+      react.useEffect(() => {
+        if (open) load();
+      }, [open, load]);
+
+      react.useEffect(() => {
+        if (!open) return;
+        const onPointerDown = (event) => {
+          if (rootRef.current !== null && !rootRef.current.contains(event.target)) {
+            setOpen(false);
+          }
+        };
+        document.addEventListener("pointerdown", onPointerDown);
+        return () => document.removeEventListener("pointerdown", onPointerDown);
+      }, [open]);
+
+      const selectable = items.filter((item) => !item.live);
+      const allSelected = selectable.length > 0 && selectable.every((item) => selected.has(item.sessionId));
+
+      const toggleAll = (checked) => {
+        if (checked) {
+          setSelected(new Set(selectable.map((item) => item.sessionId)));
+        } else {
+          setSelected(new Set());
+        }
+      };
+      const toggleOne = (sessionId, checked) => {
+        setSelected((current) => {
+          const next = new Set(current);
+          if (checked) next.add(sessionId); else next.delete(sessionId);
+          return next;
+        });
+      };
+
+      const toggleDetail = (item) => {
+        if (expanded === item.sessionId) {
+          setExpanded(null);
+          return;
+        }
+        setExpanded(item.sessionId);
+        if (!details.has(item.sessionId)) {
+          setDetailLoading((current) => new Set(current).add(item.sessionId));
+          call("detail", item.sessionId).then((detail) => {
+            setDetails((current) => new Map(current).set(item.sessionId, detail));
+          }).catch((detailError) => {
+            setDetails((current) => new Map(current).set(item.sessionId, {
+              error: t("detailLoadFailed") + ": " + (detailError && detailError.message || detailError)
+            }));
+          }).finally(() => {
+            setDetailLoading((current) => {
+              const next = new Set(current);
+              next.delete(item.sessionId);
+              return next;
+            });
+          });
+        }
+      };
+
+      const runBatch = async (action, doneKey, failKey) => {
+        const ids = [...selected];
+        if (ids.length === 0) {
+          setNotice({ kind: "warn", text: t("noSelection") });
+          return;
+        }
+        setBusy(true);
+        setNotice(null);
+        try {
+          const result = await call(action, ids);
+          const doneIds = result.deleted || result.restored || [];
+          const n = doneIds.length;
+          if (result.failed && result.failed.length > 0) {
+            setNotice({ kind: "error", text: t(failKey).replace("{n}", String(result.failed.length)) });
+          } else {
+            setNotice({ kind: "ok", text: t(doneKey).replace("{n}", String(n)) });
+          }
+          if (doneIds.length > 0) {
+            const done = new Set(doneIds);
+            setItems((current) => current.filter((item) => !done.has(item.sessionId)));
+          }
+          setSelected(new Set());
+          setConfirmingDelete(false);
+          await load();
+        } catch (actionError) {
+          setNotice({ kind: "error", text: t(failKey).replace("{n}", "?") + ": " + (actionError && actionError.message || actionError) });
+        } finally {
+          setBusy(false);
+        }
+      };
+      const restoreSelected = () => runBatch("unarchive", "restoreDone", "restoreFailed");
+      const deleteSelected = () => {
+        if (!confirmingDelete) {
+          setConfirmingDelete(true);
+          window.setTimeout(() => setConfirmingDelete(false), 4000);
+          return;
+        }
+        runBatch("delete", "deleteDone", "deleteFailed");
+      };
+
+      const hasSelection = selected.size > 0;
+
+      return react.createElement(
+        "div",
+        { className: "sa_root", ref: rootRef },
+        react.createElement(
+          "button",
+          {
+            className: "sa_badge",
+            type: "button",
+            onClick: () => setOpen(!open),
+            "aria-expanded": open,
+            title: t("badge")
+          },
+          react.createElement("span", { className: "sa_badgeIcon", "aria-hidden": true }, "🗂"),
+          react.createElement("span", { className: "sa_badgeLabel" }, t("badge")),
+          react.createElement("span", { className: "sa_badgeCount" }, String(items.length))
+        ),
+        open ? react.createElement(
+          "div",
+          { className: "sa_panel" },
+          react.createElement(
+            "div",
+            { className: "sa_header" },
+            react.createElement("span", { className: "sa_title" }, t("panelTitle")),
+            react.createElement(
+              "span",
+              { style: { display: "inline-flex", gap: "6px", alignItems: "center" } },
+              react.createElement("button", { className: "sa_refresh", type: "button", title: t("refresh"), disabled: busy || loading, onClick: load }, t("refresh")),
+              react.createElement("button", { className: "sa_iconBtn", type: "button", title: t("close"), disabled: busy, onClick: () => setOpen(false) }, "✕")
+            )
+          ),
+          react.createElement(
+            "div",
+            { className: "sa_toolbar" },
+            react.createElement("label", { className: "sa_toolLabel" },
+              react.createElement("input", {
+                className: "sa_check",
+                type: "checkbox",
+                checked: allSelected,
+                disabled: busy || selectable.length === 0,
+                onChange: (e) => toggleAll(e.target.checked)
+              }),
+              t("selectAll")
+            ),
+            react.createElement("span", { className: "sa_count" }, t("selected").replace("{n}", String(selected.size))),
+            react.createElement("button", {
+              className: "sa_action",
+              type: "button",
+              disabled: busy || !hasSelection,
+              onClick: restoreSelected
+            }, t("restore")),
+            react.createElement("button", {
+              className: "sa_action " + (confirmingDelete ? "sa_actionDanger sa_confirm" : "sa_actionDanger"),
+              type: "button",
+              disabled: busy || !hasSelection,
+              onClick: deleteSelected
+            }, confirmingDelete ? t("deleteConfirm") : t("delete"))
+          ),
+          react.createElement(
+            "div",
+            { className: "sa_body" },
+            notice !== null ? react.createElement("p", { className: "sa_error" + (notice.kind === "ok" ? "" : ""), role: "status" }, notice.text) : null,
+            error !== null ? react.createElement("p", { className: "sa_error", role: "alert" }, error) : null,
+            loading && items.length === 0 ? react.createElement("p", { className: "sa_empty" }, "…") : null,
+            !loading && items.length === 0 && error === null ? react.createElement("p", { className: "sa_empty" }, t("empty")) : null,
+            items.length > 0 ? react.createElement(
+              "ul",
+              { className: "sa_rows" },
+              items.map((item) => {
+                const isExpanded = expanded === item.sessionId;
+                const detail = details.get(item.sessionId);
+                const detailPending = detailLoading.has(item.sessionId);
+                return react.createElement(
+                  "li",
+                  { className: "sa_row" + (busy ? " sa_busy" : ""), key: item.sessionId },
+                  react.createElement(
+                    "div",
+                    { className: "sa_rowHead" },
+                    react.createElement("input", {
+                      className: "sa_check",
+                      type: "checkbox",
+                      checked: selected.has(item.sessionId),
+                      disabled: busy || item.live,
+                      title: item.live ? t("runningHint") : void 0,
+                      onChange: (e) => toggleOne(item.sessionId, e.target.checked)
+                    }),
+                    react.createElement(
+                      "span",
+                      { className: "sa_rowTitle", onClick: () => toggleDetail(item), title: t("view") },
+                      item.title !== null && item.title !== void 0 && item.title !== "" ? item.title : t("noneTitle")
+                    ),
+                    item.live ? react.createElement("span", { className: "sa_live" }, t("live")) : null
+                  ),
+                  react.createElement("div", { className: "sa_rowMeta" },
+                    react.createElement("span", null, formatTime(item.updatedAt)),
+                    item.cwd !== null && item.cwd !== void 0 ? react.createElement("span", null, " · ", react.createElement("code", null, item.cwd)) : null,
+                    react.createElement("span", null, " · ", formatBytes(item.size, t))
+                  ),
+                  react.createElement(
+                    "div",
+                    { className: "sa_rowFoot" },
+                    react.createElement("span", { className: "sa_rowMeta" },
+                      react.createElement("code", null, shortId(item.sessionId)),
+                      detail !== void 0 && !detail.error && detail.messageCount !== void 0
+                        ? " · " + t("messages").replace("{n}", String(detail.messageCount))
+                        : null
+                    ),
+                    react.createElement(
+                      "div",
+                      { className: "sa_rowActions" },
+                      react.createElement("button", {
+                        className: "sa_action",
+                        type: "button",
+                        disabled: busy || detailPending,
+                        onClick: () => toggleDetail(item)
+                      }, isExpanded ? t("collapse") : t("view"))
+                    )
+                  ),
+                  isExpanded ? react.createElement(
+                    "div",
+                    { className: "sa_detail" },
+                    detailPending ? react.createElement("p", { className: "sa_empty" }, "…") : null,
+                    detail === void 0 ? null :
+                      detail.error !== void 0 ? react.createElement("p", { className: "sa_error" }, detail.error) :
+                      detail.messages.length === 0 ? react.createElement("p", { className: "sa_empty" }, t("noMessages")) :
+                      detail.messages.map((message, index) => react.createElement(
+                        "div",
+                        { className: "sa_msg", key: index },
+                        react.createElement("span", { className: "sa_msgRole" }, message.role === "user" ? t("user") : t("assistant") + " · " + formatTime(message.time)),
+                        react.createElement("span", { className: "sa_msgText" + (message.role === "user" ? " sa_msgTextUser" : "") }, message.text)
+                      ))
+                  ) : null
+                );
+              })
+            ) : null
+          )
+        ) : null
+      );
+    }
+
+    // ── 插件 apply ───────────────────────────────────────────────────────
+    // DSH 客户端的 remote.<ns> 服务不会自动生成：必须由客户端代码用
+    // ctx.remote.$mount(contribution) 显式挂载（官方 dsh-api-remotes 即如此）。
+    const inject = ["slots", "locale", "remote"];
+    const passthroughSchema = { parse: (value) => value };
+    const REMOTE_CONTRIBUTION = {
+      package: "@chaoset/session-archive",
+      descriptors: [
+        { id: "@chaoset/session-archive#sessionArchive/list", service: "sessionArchive", namespace: "sessionArchive", method: "list", invocation: { kind: "direct" }, parameters: [], result: { mode: "strict", typeSymbol: "sessionArchive/list:result", schema: passthroughSchema } },
+        { id: "@chaoset/session-archive#sessionArchive/detail", service: "sessionArchive", namespace: "sessionArchive", method: "detail", invocation: { kind: "direct" }, parameters: [{ name: "sessionId", wire: "sessionId", source: "json", codec: { mode: "strict", typeSymbol: "sessionArchive/detail:sessionId", schema: passthroughSchema } }], result: { mode: "strict", typeSymbol: "sessionArchive/detail:result", schema: passthroughSchema } },
+        { id: "@chaoset/session-archive#sessionArchive/delete", service: "sessionArchive", namespace: "sessionArchive", method: "delete", invocation: { kind: "direct" }, parameters: [{ name: "sessionIds", wire: "sessionIds", source: "json", codec: { mode: "strict", typeSymbol: "sessionArchive/delete:sessionIds", schema: passthroughSchema } }], result: { mode: "strict", typeSymbol: "sessionArchive/delete:result", schema: passthroughSchema } },
+        { id: "@chaoset/session-archive#sessionArchive/unarchive", service: "sessionArchive", namespace: "sessionArchive", method: "unarchive", invocation: { kind: "direct" }, parameters: [{ name: "sessionIds", wire: "sessionIds", source: "json", codec: { mode: "strict", typeSymbol: "sessionArchive/unarchive:sessionIds", schema: passthroughSchema } }], result: { mode: "strict", typeSymbol: "sessionArchive/unarchive:result", schema: passthroughSchema } }
+      ]
+    };
+    async function apply(ctx) {
+      const t = ctx.locale.bind(NS);
+      ctx.effect(() => ctx.locale.register(NS, { zh, en }), "session-archive: dictionaries");
+      await ctx.remote.$mount(REMOTE_CONTRIBUTION);
+      const archiveService = ctx.get("remote.sessionArchive");
+      if (archiveService === void 0) throw new Error("session-archive: remote.sessionArchive did not materialize after mount");
+      const call = (method, ...args) => archiveService[method](...args).then((result) => {
+        if (!result.ok) throw new Error(method + " failed: " + result.error.code + ": " + result.error.message);
+        return result.value;
+      });
+      ctx.slots.inject("sidebar.footer.action", () => ctx.slots.register({
+        name: "sidebar.footer.action",
+        id: "session-archive",
+        order: 20,
+        locale: NS,
+        inject: () => ({ call })
+      }, ArchivePanel));
+    }
+
+    exports.apply = apply;
+    exports.inject = inject;
+    return module.exports;
+  }
+});

package/cordis.patch.yml

@@ -0,0 +1,14 @@
+# @chaoset/session-archive bundle patch
+#
+# Installed automatically by:
+#   dsh plugin --profile <name> add @chaoset/session-archive
+#
+# This patch inserts the host plugin row. The package is also a normal npm
+# dependency of the profile; the `dsh.bundle.patch` manifest field makes DSH
+# treat it as a profile bundle layer. The web client part (sidebar archive
+# panel) activates automatically once the bundle is installed.
+
+- insert:
+    - id: session-archive
+      name: '@chaoset/session-archive'
+      config: {}

package/lib/config-store.mjs

@@ -0,0 +1,97 @@
+/**
+ * config-store — 插件配置持久化
+ *
+ * 配置文件位于 $DSH_HOME/plugins/<name>/config.json（默认 ~/.dsh，与
+ * file:// 部署模式共用）。生效顺序（后者覆盖前者）：
+ *   1. 插件内置默认值（DEFAULT_CONFIG）
+ *   2. cordis.patch.yml 传入的 config（安装时生成的默认块）
+ *   3. config.json（设置页 UI 保存，权威）
+ *
+ * 保存后通过 onUpdate 回调立即热更新运行中的配置（包装闭包读共享 state）。
+ * 写入采用随机临时文件 + fsync + rename，权限 0600；损坏 JSON 只告警并回退。
+ */
+
+import { randomUUID } from "node:crypto";
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { homedir } from "node:os";
+
+/**
+ * 创建配置存储。
+ * @param options - { name, defaults, patchConfig, onUpdate,
+ *   validate?: (partial) => void, warn?: (message) => void }
+ */
+export function createConfigStore(options) {
+  // 与 harness 的 DSH_HOME 约定保持一致：默认 ~/.dsh，可用 $DSH_HOME 覆盖。
+  const dshHome = process.env.DSH_HOME?.trim() ? resolve(process.env.DSH_HOME) : join(homedir(), ".dsh");
+  const file = join(dshHome, "plugins", options.name, "config.json");
+  const warn = options.warn ?? (() => {});
+  let readWarningShown = false;
+
+  function readJson() {
+    try {
+      if (!existsSync(file)) return {};
+      const parsed = JSON.parse(readFileSync(file, "utf8"));
+      if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+        readWarningShown = false;
+        return parsed;
+      }
+      if (!readWarningShown) {
+        readWarningShown = true;
+        warn(`config file ${file} must contain a JSON object; using empty config`);
+      }
+      return {};
+    } catch (error) {
+      if (!readWarningShown) {
+        readWarningShown = true;
+        warn(`failed to read config file ${file}: ${error?.message || error}; using empty config`);
+      }
+      return {};
+    }
+  }
+
+  /** 当前生效配置（默认 + patch + json 合并）。 */
+  function effective() {
+    return { ...options.defaults, ...options.patchConfig, ...readJson() };
+  }
+
+  /** 保存部分配置到 config.json 并触发热更新，返回新的生效配置。 */
+  function set(partial) {
+    if (partial === null || typeof partial !== "object" || Array.isArray(partial)) {
+      throw new TypeError("set expects a plain config object");
+    }
+    options.validate?.(partial);
+    const merged = { ...readJson(), ...partial };
+    mkdirSync(dirname(file), { recursive: true });
+
+    const tmp = `${file}.${process.pid}.${randomUUID()}.tmp`;
+    let fd;
+    try {
+      fd = openSync(tmp, "w", 0o600);
+      writeFileSync(fd, JSON.stringify(merged, null, 2) + "\n", "utf8");
+      fsyncSync(fd);
+      closeSync(fd);
+      fd = void 0;
+      renameSync(tmp, file);
+      // POSIX 目录项持久化（Windows 上目录句柄不可打开时忽略）。
+      try {
+        const dir = openSync(dirname(file), "r");
+        try { fsyncSync(dir); } finally { closeSync(dir); }
+      } catch {}
+    } catch (error) {
+      if (fd !== void 0) try { closeSync(fd); } catch {}
+      try { unlinkSync(tmp); } catch {}
+      throw error;
+    }
+
+    const next = { ...options.defaults, ...options.patchConfig, ...merged };
+    try {
+      options.onUpdate?.(merged, next);
+    } catch (error) {
+      warn(`onUpdate failed after config save: ${error?.message || error}`);
+    }
+    return next;
+  }
+
+  return { file, effective, set };
+}

package/lib/index.mjs

@@ -0,0 +1,267 @@
+/**
+ * session-archive — 归档会话管理插件（@chaoset/session-archive）
+ *
+ * 补上 DSH 缺失的"归档"后半程：web 侧边栏新增"归档"面板，可查看归档
+ * 会话（列表 + 会话内容只读浏览）、一次多选批量恢复归档（unarchive，
+ * 会话回到会话树原位置）或彻底删除归档（删除持久化文件与归档记录）。
+ *
+ * host 端全部逻辑基于官方 service 接口（workspaceRegistry /
+ * sessionPersistence / sessions），不依赖 dsh 内部实现：
+ *   1. list()       — archivedSessionIds ∩ sessionPersistence.list()，
+ *                     每条附带标题（从事件流折叠 session/title）、目录、
+ *                     创建时间、最后修改时间（文件 mtime）、体积与
+ *                     live 状态（会话仍在内存中运行时禁止删除）。
+ *   2. detail(id)   — readFrom(id, 0) 只读取会话事件：标题 + 文本消息
+ *                     （user/assistant），供面板"查看"展开。
+ *   3. delete(ids)  — 批量彻底删除：live 会话拒绝；逐个删除持久化文件
+ *                     （locate() 定位）+ 会话目录；最后从归档集合移除。
+ *   4. unarchive(ids) — 批量恢复：仅从归档集合移除（会话数据不动）。
+ *
+ * 归档集合（workspaceRegistry.archivedSessionIds）的移除没有官方 API，
+ * 这里复用 registry 自身的串行化写入通道（enqueueOperation → requireState
+ * → setState，与 archiveSession 相同的路径）；若 registry 内部形状变化，
+ * 自动降级为"仅删文件"，归档列表会以存在性过滤幽灵 id，功能仍正确。
+ *
+ * 本文件不依赖任何 dsh 内部包（纯 ESM + ctx.* service），可独立安装。
+ */
+
+import { stat, rm } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { createConfigStore } from './config-store.mjs';
+
+// remote 服务（侧边栏面板 UI 的读写）可选：typert-protocol 不可用时
+// 动态 import 失败，仅面板不可用，host 逻辑不注册（无其他消费者）。
+let SessionArchiveGateway = null;
+try {
+  ({ SessionArchiveGateway } = await import('./remote.mjs'));
+} catch (error) {
+  console.warn('session-archive: remote gateway unavailable: ' + (error && error.message || error));
+}
+
+export const name = 'session-archive';
+
+/** sessions 参与 inject：删除前必须能查询 live 会话（存在即拒绝删除）。 */
+export const inject = ['workspaceRegistry', 'sessionPersistence', 'sessions'];
+
+/** 默认配置。apply 时与 YAML 传入的 config 合并（cordis 不合并小写 config 导出）。 */
+const DEFAULT_CONFIG = {
+  /** detail() 返回的最大消息条数（超出仅计数）。 */
+  detailMaxMessages: 200,
+  /** 每条消息预览的最大字符数（超出截断加省略号）。 */
+  messagePreviewChars: 2000,
+  /** list() 时并发读取标题的最大并行数。 */
+  titleReadConcurrency: 4,
+};
+
+export const config = { ...DEFAULT_CONFIG };
+
+/** 并发限制器：最多 N 个任务并行，其余排队。 */
+function limitedConcurrency(limit, tasks) {
+  const results = new Array(tasks.length);
+  let cursor = 0;
+  const workers = Array.from({ length: Math.min(limit, tasks.length) }, async () => {
+    while (cursor < tasks.length) {
+      const at = cursor++;
+      results[at] = await tasks[at]();
+    }
+  });
+  return Promise.all(workers).then(() => results);
+}
+
+/** 从事件流折叠最新会话标题（与 dsh-session-title 相同的折叠规则）。 */
+function foldTitle(events) {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (event && event.type === 'session/title') {
+      const title = event.data && typeof event.data.title === 'string' ? event.data.title.trim() : '';
+      return title.length > 0 ? title : null;
+    }
+  }
+  return null;
+}
+
+/** 从一条消息（Message 结构）提取纯文本（text 块拼接，忽略图片/工具块）。 */
+function messageText(message, maxChars) {
+  if (!message || !Array.isArray(message.content)) return '';
+  let text = '';
+  for (const block of message.content) {
+    if (block && block.type === 'text' && typeof block.text === 'string') {
+      text += block.text;
+      if (text.length > maxChars) break;
+    }
+  }
+  return text.length > maxChars ? text.slice(0, maxChars) + '…' : text;
+}
+
+/**
+ * 构造归档管理 host 逻辑（绑定 ctx 与配置）。
+ * 只读操作失败各自容错：单个会话的标题/详情读取失败不拖垮列表。
+ */
+export function createArchiveHost(ctx, cfg) {
+  const registry = ctx.workspaceRegistry;
+  const persistence = ctx.sessionPersistence;
+
+  /** 会话是否仍在内存中运行（live）。 */
+  const isLive = (sessionId) => ctx.sessions.get(sessionId) !== undefined;
+
+  /** 从归档集合移除若干 id（恢复/删除共用），返回实际移除的 id。 */
+  async function removeFromArchiveSet(ids) {
+    const set = new Set(ids);
+    const canWrite =
+      registry !== undefined &&
+      typeof registry.enqueueOperation === 'function' &&
+      typeof registry.requireState === 'function' &&
+      typeof registry.setState === 'function';
+    if (!canWrite) return []; // 降级：仅删文件，列表按存在性过滤幽灵 id
+    let removedIds = [];
+    await registry.enqueueOperation(async () => {
+      const state = registry.requireState();
+      const current = Array.isArray(state.archivedSessionIds) ? state.archivedSessionIds : [];
+      removedIds = current.filter((id) => set.has(id));
+      const remaining = current.filter((id) => !set.has(id));
+      if (removedIds.length > 0) await registry.setState({ ...state, archivedSessionIds: remaining });
+    });
+    return removedIds;
+  }
+
+  /** 归档会话的文件信息（路径 + stat），会话文件缺失时返回 null。 */
+  async function fileInfo(header) {
+    try {
+      const location = persistence.locate(header);
+      if (location === undefined || typeof location.path !== 'string' || location.path.length === 0) return null;
+      const info = await stat(location.path);
+      return { path: location.path, size: info.size, mtimeMs: info.mtimeMs };
+    } catch {
+      return null;
+    }
+  }
+
+  /** 单个归档会话的展示行。标题读取失败回退 null（面板显示目录名）。 */
+  async function rowFor(sessionId, header) {
+    const file = await fileInfo(header);
+    let title = null;
+    try {
+      const { events } = await persistence.readFrom(sessionId, 0);
+      title = foldTitle(events);
+    } catch {}
+    return {
+      sessionId,
+      title,
+      cwd: header.cwd ?? null,
+      createdAt: header.createdAt,
+      updatedAt: file !== null ? file.mtimeMs : header.createdAt,
+      size: file !== null ? file.size : 0,
+      live: isLive(sessionId),
+    };
+  }
+
+  return {
+    /** 列出全部归档会话（存在性过滤：文件已删的幽灵归档记录不显示）。 */
+    async list() {
+      const rawArchived = typeof registry.archivedSessionIds === 'function' ? registry.archivedSessionIds() : registry.archivedSessionIds;
+      const archived = Array.isArray(rawArchived) ? rawArchived : [];
+      if (archived.length === 0) return { items: [] };
+      const headers = await persistence.list();
+      const byId = new Map(headers.map((header) => [header.id, header]));
+      const rows = [];
+      for (const sessionId of archived) {
+        const header = byId.get(sessionId);
+        if (header === undefined) continue; // 幽灵 id：会话文件已不存在
+        rows.push({ sessionId, header });
+      }
+      const items = await limitedConcurrency(cfg.titleReadConcurrency, rows.map(({ sessionId, header }) => () => rowFor(sessionId, header)));
+      return { items };
+    },
+
+    /** 读取一个归档会话的只读详情（标题 + 文本消息）。 */
+    async detail(sessionId) {
+      const { meta, events } = await persistence.readFrom(sessionId, 0);
+      const title = foldTitle(events);
+      const messages = [];
+      for (const event of events) {
+        if (event.type !== 'user/message' && event.type !== 'assistant/message') continue;
+        const text = messageText(event.data, cfg.messagePreviewChars);
+        if (text.length === 0) continue;
+        messages.push({
+          role: event.type === 'user/message' ? 'user' : 'assistant',
+          text,
+          time: event.time,
+        });
+        if (messages.length >= cfg.detailMaxMessages) break;
+      }
+      return {
+        sessionId,
+        header: {
+          cwd: meta.cwd ?? null,
+          createdAt: meta.createdAt,
+          parentSession: meta.parentSession ?? null,
+          agentPreset: meta.agentPreset ?? null,
+        },
+        title,
+        messageCount: messages.length,
+        messages,
+        live: isLive(sessionId),
+      };
+    },
+
+    /**
+     * 批量彻底删除归档会话。live 会话拒绝（先停止再删）；每个会话删除
+     * 持久化文件与会话目录；最后从归档集合移除并返回结果明细。
+     */
+    async deleteArchived(sessionIds) {
+      const unique = [...new Set(sessionIds)];
+      const deleted = [];
+      const failed = [];
+      for (const sessionId of unique) {
+        if (isLive(sessionId)) {
+          failed.push({ sessionId, reason: 'live' });
+          continue;
+        }
+        const headers = await persistence.list();
+        const header = headers.find((item) => item.id === sessionId);
+        if (header === undefined) {
+          // 会话文件已不存在：仅清理归档记录（幂等删除）。
+          deleted.push(sessionId);
+          continue;
+        }
+        const file = await fileInfo(header);
+        if (file === null) {
+          deleted.push(sessionId);
+          continue;
+        }
+        try {
+          await rm(file.path, { force: true });
+          await rm(dirname(file.path), { recursive: true, force: true });
+          deleted.push(sessionId);
+        } catch (error) {
+          failed.push({ sessionId, reason: error && error.message ? String(error.message) : 'delete-failed' });
+        }
+      }
+      const removedIds = deleted.length > 0 ? await removeFromArchiveSet(deleted) : [];
+      return { deleted, failed, removedFromArchive: removedIds.length };
+    },
+
+    /** 批量恢复归档会话（仅从归档集合移除，会话数据不动）。 */
+    async unarchive(sessionIds) {
+      const unique = [...new Set(sessionIds)];
+      const restored = await removeFromArchiveSet(unique);
+      return { restored, removedFromArchive: restored.length };
+    },
+  };
+}
+
+/** 插件 apply：注册远程服务（面板 UI 读写）。 */
+export function apply(ctx, config) {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  const store = createConfigStore({
+    name,
+    defaults: DEFAULT_CONFIG,
+    patchConfig: config,
+  });
+  ctx.effect(() => store.dispose?.(), 'session-archive: store');
+
+  if (SessionArchiveGateway !== null) {
+    ctx.plugin(SessionArchiveGateway, { host: createArchiveHost(ctx, cfg), serviceKey: 'sessionArchive' });
+  }
+  return store;
+}

package/lib/remote.mjs

@@ -0,0 +1,109 @@
+/**
+ * remote.mjs — 归档管理插件的远程服务（侧边栏归档面板通过 ctx.remote.sessionArchive 调用）
+ *
+ * DSH 的 Remote 装饰器是 ECMAScript 标准装饰器语法（Node 默认未启用），
+ * 这里用"手动构造装饰器上下文"的方式等价调用：Remote(name)(method, context)
+ * 把标记初始化器收集起来，在模块加载时用 Object.create 模拟实例执行
+ * （mark 以实例原型为准，与真实实例化等价）。
+ *
+ * typert-protocol 惰性加载：npm 模式从包内 node_modules 解析；file:// 模式
+ * （~/.dsh/plugins/）从 harness 的 profile 依赖树解析。两者都不可用时
+ * 模块加载失败，由 index.mjs 的动态 import 捕获——核心 host 逻辑照常注册，
+ * 仅侧边栏面板的远程读写不可用。
+ */
+
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+// @deepseek-ai/dsh-typert-protocol 是 ESM 包。Node 20 早期版本尚不支持
+// require(ESM)，因此统一用 import() 加载；fallback 时先用 createRequire
+// 解析出实际文件，再以 file URL 导入。
+async function loadTypert() {
+  try {
+    return await import("@deepseek-ai/dsh-typert-protocol");
+  } catch {}
+  const dshHome = process.env.DSH_HOME?.trim() ? resolve(process.env.DSH_HOME) : join(homedir(), ".dsh");
+  const candidates = [
+    join(dshHome, "profiles", "web", "package.json"),
+    join(dshHome, "profiles", "tui", "package.json"),
+    join(dshHome, "profiles", "headless", "package.json"),
+  ];
+  for (const base of candidates) {
+    try {
+      const resolved = createRequire(base).resolve("@deepseek-ai/dsh-typert-protocol");
+      return await import(pathToFileURL(resolved).href);
+    } catch {}
+  }
+  throw new Error("typert-protocol is unavailable (neither package deps nor harness profiles resolve it)");
+}
+
+const { Remote, TypertRemoteService } = await loadTypert();
+
+let pending = [];
+
+/** 手动标记一个类原型方法为 Remote 端点（等价 @Remote(exportName)）。 */
+function markRemoteMethod(proto, method, exportName) {
+  const initializers = [];
+  const context = {
+    kind: "method",
+    name: method,
+    private: false,
+    static: false,
+    addInitializer(fn) { initializers.push(fn); },
+  };
+  Remote(exportName ?? method)(proto[method], context);
+  pending.push({ initializers });
+}
+
+/** 执行收集到的标记（mark 以 Object.getPrototypeOf(this) 为原型）。 */
+function runPendingMarks(instance) {
+  const batch = pending;
+  pending = [];
+  for (const { initializers } of batch) {
+    for (const init of initializers) init.call(instance);
+  }
+}
+
+/**
+ * 归档管理远程服务：list 列出归档会话；detail 读取会话内容；
+ * delete 批量删除归档会话（文件 + 归档记录）；unarchive 批量恢复归档。
+ * 所有逻辑委托给 host 模块（lib/index.mjs 传入的 archiveHost）。
+ * @param ctx - 插件上下文。
+ * @param config - { host: archiveHost, serviceKey: 远程服务名 }。
+ */
+export class SessionArchiveGateway extends TypertRemoteService {
+  constructor(ctx, config) {
+    super(ctx, config.serviceKey);
+    runPendingMarks(this);
+    this.host = config.host;
+  }
+  list() {
+    return this.host.list();
+  }
+  detail(sessionId) {
+    if (typeof sessionId !== "string" || sessionId.length === 0) {
+      throw new TypeError("detail expects a session id string");
+    }
+    return this.host.detail(sessionId);
+  }
+  delete(sessionIds) {
+    if (!Array.isArray(sessionIds) || sessionIds.some((id) => typeof id !== "string")) {
+      throw new TypeError("delete expects an array of session id strings");
+    }
+    return this.host.deleteArchived(sessionIds);
+  }
+  unarchive(sessionIds) {
+    if (!Array.isArray(sessionIds) || sessionIds.some((id) => typeof id !== "string")) {
+      throw new TypeError("unarchive expects an array of session id strings");
+    }
+    return this.host.unarchive(sessionIds);
+  }
+}
+markRemoteMethod(SessionArchiveGateway.prototype, "list");
+markRemoteMethod(SessionArchiveGateway.prototype, "detail");
+markRemoteMethod(SessionArchiveGateway.prototype, "delete");
+markRemoteMethod(SessionArchiveGateway.prototype, "unarchive");
+// 模块加载时立即执行标记（Object.create 模拟实例；构造函数里的 runPendingMarks 幂等保留无害）。
+runPendingMarks(Object.create(SessionArchiveGateway.prototype));

package/lib/typert.host.js

@@ -0,0 +1,91 @@
+/**
+ * typert.host.js — 手写的 Typert host 工件（typert-loader 机制）。
+ *
+ * DSH 的 typert-loader 会为「导出 ./typert 的 loader 条目」把本工件注册进
+ * ctx.typert.local，于是 api-gateway 直接认领这些端点。这是官方扩展点：
+ * 不依赖 remote.mjs 的 Remote 装饰器 markers（markers 表是 typert-protocol
+ * 模块私有的 WeakMap，当插件从 profile 安装、typert-protocol 与 harness
+ * 各持一份模块实例时 markers 会丢失，SRC 认领为空，web 端报
+ * "transport failure ... HTTP 404"）。
+ *
+ * codec 使用最小透传 schema（{_zod, parse}）：typert-loader 的
+ * requireStrictCodec 只校验这两个字段，网关 decode/encode 走 parse 透传，
+ * 与 client.cjs 里 $mount 的透传描述符一致。
+ */
+
+const passthrough = (value) => value;
+const codec = (typeSymbol) => ({
+  mode: 'strict',
+  typeSymbol,
+  schema: { _zod: true, parse: passthrough },
+});
+
+export const TYPERT = {
+  package: '@chaoset/session-archive',
+  face: 'host',
+  schemas: [],
+  invocations: [
+    {
+      id: '@chaoset/session-archive#sessionArchive/list',
+      service: 'sessionArchive',
+      namespace: 'sessionArchive',
+      method: 'list',
+      invocation: { kind: 'direct' },
+      parameters: [],
+      result: codec('@chaoset/session-archive/types#ArchiveListResult'),
+      sourceLocation: { file: 'packages/session-archive/lib/remote.mjs', line: 1, column: 1 },
+    },
+    {
+      id: '@chaoset/session-archive#sessionArchive/detail',
+      service: 'sessionArchive',
+      namespace: 'sessionArchive',
+      method: 'detail',
+      invocation: { kind: 'direct' },
+      parameters: [
+        {
+          name: 'sessionId',
+          wire: 'sessionId',
+          source: 'json',
+          codec: codec('@chaoset/session-archive/types#SessionId'),
+        },
+      ],
+      result: codec('@chaoset/session-archive/types#ArchiveDetailResult'),
+      sourceLocation: { file: 'packages/session-archive/lib/remote.mjs', line: 1, column: 1 },
+    },
+    {
+      id: '@chaoset/session-archive#sessionArchive/delete',
+      service: 'sessionArchive',
+      namespace: 'sessionArchive',
+      method: 'delete',
+      invocation: { kind: 'direct' },
+      parameters: [
+        {
+          name: 'sessionIds',
+          wire: 'sessionIds',
+          source: 'json',
+          codec: codec('@chaoset/session-archive/types#SessionIdArray'),
+        },
+      ],
+      result: codec('@chaoset/session-archive/types#DeleteResult'),
+      sourceLocation: { file: 'packages/session-archive/lib/remote.mjs', line: 1, column: 1 },
+    },
+    {
+      id: '@chaoset/session-archive#sessionArchive/unarchive',
+      service: 'sessionArchive',
+      namespace: 'sessionArchive',
+      method: 'unarchive',
+      invocation: { kind: 'direct' },
+      parameters: [
+        {
+          name: 'sessionIds',
+          wire: 'sessionIds',
+          source: 'json',
+          codec: codec('@chaoset/session-archive/types#SessionIdArray'),
+        },
+      ],
+      result: codec('@chaoset/session-archive/types#UnarchiveResult'),
+      sourceLocation: { file: 'packages/session-archive/lib/remote.mjs', line: 1, column: 1 },
+    },
+  ],
+  model: { services: [], events: [], objects: [] },
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@chaoset/session-archive",
+  "version": "0.1.0",
+  "description": "DSH plugin: browse archived sessions, inspect their content, batch-restore or permanently delete them with multi-select",
+  "type": "module",
+  "license": "MIT",
+  "files": [
+    "lib",
+    "client",
+    "cordis.patch.yml",
+    "README.md"
+  ],
+  "exports": {
+    ".": "./lib/index.mjs",
+    "./client": "./client/client.cjs",
+    "./typert": "./lib/typert.host.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "slots",
+        "locale",
+        "remote"
+      ]
+    }
+  },
+  "optionalDependencies": {
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.0-rc.6"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "scripts": {
+    "test": "node ../../scripts/test.mjs",
+    "prepublishOnly": "npm test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/winliyou/dsh-plugins.git",
+    "directory": "packages/session-archive"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}