dsh-sessions-manager 3.4.2 → 3.5.1

package/lib/index.js

@@ -1,32 +1,67 @@
 // src/index.js
-import { mkdir as mkdir4, realpath, rename as rename4, stat, unlink, writeFile as writeFile4 } from "node:fs/promises";
+import { mkdir as mkdir4, readFile as readFile2, realpath, rename as rename4, stat, unlink, writeFile as writeFile4 } from "node:fs/promises";
 import { basename, dirname as dirname2, isAbsolute, join as join4 } from "node:path";
-import { readFileSync as readFileSync4 } from "node:fs";
+import { readFileSync as readFileSync3 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 
 // src/zstd-frame.js
 import zlib from "node:zlib";
-import { readFileSync, writeFileSync } from "node:fs";
 var ZSTD_MAGIC = 4247762216;
 var CHECKSUM_OPTS = { params: { [zlib.constants.ZSTD_c_checksumFlag]: 1 } };
-function findZstdFrameStarts(buf) {
-  const starts = [];
-  for (let i = 0; i + 4 <= buf.length; i++) {
-    if (buf.readUInt32LE(i) !== ZSTD_MAGIC) continue;
-    try {
-      const out = zlib.zstdDecompressSync(buf.subarray(i, i + Math.min(buf.length - i, 1e6)));
-      if (out.length > 0) starts.push(i);
-    } catch (_) {
+function scanZstdFrames(buf, maxFrames = Number.POSITIVE_INFINITY) {
+  const frames = [];
+  let offset = 0;
+  while (offset < buf.length) {
+    const start = offset;
+    if (buf.length - offset < 4) return { frames, tornStart: start };
+    if (buf.readUInt32LE(offset) !== ZSTD_MAGIC) {
+      throw new Error(`\u4F1A\u8BDD\u65E5\u5FD7\u683C\u5F0F\u5F02\u5E38\uFF08\u5B57\u8282 ${offset} \u7684 zstd magic \u65E0\u6548\uFF09`);
+    }
+    offset += 4;
+    if (offset === buf.length) return { frames, tornStart: start };
+    const descriptor = buf.readUInt8(offset++);
+    if ((descriptor & 24) !== 0) throw new Error(`\u4F1A\u8BDD\u65E5\u5FD7\u683C\u5F0F\u5F02\u5E38\uFF08\u5B57\u8282 ${offset - 1} \u4F7F\u7528\u4FDD\u7559\u5E27\u5934\u4F4D\uFF09`);
+    const contentSizeFlag = descriptor >>> 6;
+    const singleSegment = (descriptor & 32) !== 0;
+    const checksum = (descriptor & 4) !== 0;
+    const dictionaryFlag = descriptor & 3;
+    const dictionaryBytes = dictionaryFlag === 3 ? 4 : dictionaryFlag;
+    const contentSizeBytes = contentSizeFlag === 0 ? singleSegment ? 1 : 0 : 1 << contentSizeFlag;
+    const remainingHeaderBytes = (singleSegment ? 0 : 1) + dictionaryBytes + contentSizeBytes;
+    if (buf.length - offset < remainingHeaderBytes) return { frames, tornStart: start };
+    offset += remainingHeaderBytes;
+    for (; ; ) {
+      if (buf.length - offset < 3) return { frames, tornStart: start };
+      const blockHeader = buf.readUIntLE(offset, 3);
+      offset += 3;
+      const lastBlock = (blockHeader & 1) !== 0;
+      const blockType = blockHeader >>> 1 & 3;
+      const blockSize = blockHeader >>> 3;
+      if (blockType === 3) throw new Error(`\u4F1A\u8BDD\u65E5\u5FD7\u683C\u5F0F\u5F02\u5E38\uFF08\u5B57\u8282 ${offset - 3} \u4F7F\u7528\u4FDD\u7559\u5757\u7C7B\u578B\uFF09`);
+      const payloadBytes = blockType === 1 ? 1 : blockSize;
+      if (buf.length - offset < payloadBytes) return { frames, tornStart: start };
+      offset += payloadBytes;
+      if (lastBlock) break;
+    }
+    if (checksum) {
+      if (buf.length - offset < 4) return { frames, tornStart: start };
+      offset += 4;
     }
+    frames.push({ start, end: offset });
+    if (frames.length === maxFrames) return { frames };
   }
-  return starts;
+  return { frames };
 }
-function rewriteFrame0Cwd(filePath, newCwd) {
-  const buf = readFileSync(filePath);
-  const starts = findZstdFrameStarts(buf);
-  if (starts.length === 0) throw new Error("\u4F1A\u8BDD\u65E5\u5FD7\u683C\u5F0F\u5F02\u5E38\uFF08\u65E0 zstd \u5E27\uFF09");
-  const end0 = starts.length > 1 ? starts[1] : buf.length;
-  const frame0 = buf.subarray(starts[0], end0);
+function firstFrame(buf) {
+  const scan = scanZstdFrames(buf, 1);
+  const frame = scan.frames[0];
+  if (!frame) throw new Error("\u4F1A\u8BDD\u65E5\u5FD7\u683C\u5F0F\u5F02\u5E38\uFF08\u65E0\u5B8C\u6574 zstd \u5E27\uFF09");
+  return frame;
+}
+function rewriteFrame0CwdInMemory(buf, newCwd) {
+  const frame = firstFrame(buf);
+  const end0 = frame.end;
+  const frame0 = buf.subarray(frame.start, end0);
   const text = zlib.zstdDecompressSync(frame0).toString("utf8");
   const nl = text.indexOf("\n");
   const line = nl >= 0 ? text.slice(0, nl) : text;
@@ -34,11 +69,10 @@ function rewriteFrame0Cwd(filePath, newCwd) {
   if (obj.type !== "session") {
     throw new Error(`\u4F1A\u8BDD\u65E5\u5FD7\u683C\u5F0F\u5F02\u5E38\uFF08\u5E270 \u4E0D\u662F session header\uFF0C\u5B9E\u9645 type=${obj.type}\uFF09`);
   }
-  if (obj.cwd === newCwd) return;
   obj.cwd = newCwd;
   const newFrame0 = zlib.zstdCompressSync(JSON.stringify(obj) + "\n", CHECKSUM_OPTS);
   const rest = buf.subarray(end0);
-  writeFileSync(filePath, Buffer.concat([newFrame0, rest]));
+  return Buffer.concat([newFrame0, rest]);
 }
 
 // src/markdown.js
@@ -182,7 +216,7 @@ function renderSessionMarkdown(meta, events, options = {}) {
 
 // src/star-index.js
 import { mkdir, rename, writeFile } from "node:fs/promises";
-import { readFileSync as readFileSync2 } from "node:fs";
+import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 var STAR_SCHEMA_VERSION = 3;
@@ -210,7 +244,7 @@ function createStarIndex(options = {}) {
   let mutation = Promise.resolve();
   async function read() {
     try {
-      return normalizeStarStore(JSON.parse(readFileSync2(indexPath, "utf8")));
+      return normalizeStarStore(JSON.parse(readFileSync(indexPath, "utf8")));
     } catch {
       return normalizeStarStore(null);
     }
@@ -303,7 +337,7 @@ function aggregateStorage(items, options = {}) {
 
 // src/auto-archive.js
 import { mkdir as mkdir2, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
-import { readFileSync as readFileSync3 } from "node:fs";
+import { readFileSync as readFileSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { join as join2 } from "node:path";
 var AUTO_ARCHIVE_SCHEMA_VERSION = 4;
@@ -359,7 +393,7 @@ function createAutoArchiveStore(options = {}) {
   let mutation = Promise.resolve();
   async function read() {
     try {
-      return normalizeAutoArchiveStore(JSON.parse(readFileSync3(indexPath, "utf8")));
+      return normalizeAutoArchiveStore(JSON.parse(readFileSync2(indexPath, "utf8")));
     } catch {
       return normalizeAutoArchiveStore(null);
     }
@@ -604,6 +638,101 @@ function createTitleIndexStore({ dir, file }) {
   };
 }
 
+// src/compat/persistence.js
+function asHeader(value) {
+  if (!value || typeof value !== "object") return null;
+  const candidate = value.header && typeof value.header === "object" ? value.header : value;
+  return candidate.id == null ? null : candidate;
+}
+function normalizePersistenceEntry(value) {
+  const header = asHeader(value);
+  if (!header) return null;
+  const snapshot = value && value.header === header ? value : null;
+  return {
+    header,
+    snapshot,
+    id: String(header.id),
+    sizeBytes: snapshot && Number.isFinite(snapshot.sizeBytes) ? Number(snapshot.sizeBytes) : null,
+    eventCount: snapshot && Number.isSafeInteger(snapshot.eventCount) ? snapshot.eventCount : null,
+    revision: snapshot ? snapshot.revision : null
+  };
+}
+function normalizePersistenceList(values) {
+  if (!Array.isArray(values)) return [];
+  return values.map(normalizePersistenceEntry).filter(Boolean);
+}
+function createPersistenceAdapter(service) {
+  if (!service || typeof service.list !== "function") throw new TypeError("sessionPersistence.list is required");
+  async function listEntries(options) {
+    return normalizePersistenceList(await service.list(options));
+  }
+  async function readSession(id, offset = 0) {
+    if (typeof service.readFrom === "function") {
+      const result = await service.readFrom(id, offset);
+      return {
+        meta: result && result.meta ? result.meta : null,
+        inheritedEventCount: result && Number.isSafeInteger(result.inheritedEventCount) ? result.inheritedEventCount : 0,
+        events: result && Array.isArray(result.events) ? result.events : []
+      };
+    }
+    if (typeof service.open !== "function") throw new Error("\u5F53\u524D DSH \u6301\u4E45\u5316\u670D\u52A1\u4E0D\u652F\u6301\u8BFB\u53D6\u4F1A\u8BDD");
+    const handle = await service.open(id, "read");
+    if (!handle || typeof handle.read !== "function" || typeof handle.close !== "function") {
+      try {
+        if (handle && typeof handle.close === "function") await handle.close();
+      } catch {
+      }
+      throw new Error("DSH \u8FD4\u56DE\u4E86\u65E0\u6548\u7684 SessionHandle");
+    }
+    try {
+      const events = await handle.read(offset);
+      return {
+        meta: handle.header || handle.meta || null,
+        inheritedEventCount: Number.isSafeInteger(handle.inheritedEventCount) ? handle.inheritedEventCount : 0,
+        events: Array.isArray(events) ? events : [...events || []]
+      };
+    } finally {
+      await handle.close();
+    }
+  }
+  function locate(header) {
+    if (typeof service.locate === "function") return service.locate(header);
+    return null;
+  }
+  const kind = typeof service.open === "function" ? "session-handle" : "legacy";
+  return { kind, listEntries, readSession, locate };
+}
+
+// src/compat/capabilities.js
+function action(available, reason = null) {
+  return { available: !!available, reason: available ? null : reason };
+}
+function detectCapabilities({ persistence, workspaceRegistry }) {
+  const handleApi = !!(persistence && typeof persistence.open === "function");
+  const legacyRead = !!(persistence && typeof persistence.readFrom === "function");
+  const legacyLocate = !!(persistence && (typeof persistence.locate === "function" || persistence.backend && typeof persistence.backend.locate === "function"));
+  const workspaceInternals = !!(workspaceRegistry && workspaceRegistry.headers && workspaceRegistry.sessionPaths && typeof workspaceRegistry.replaceHeaderIndex === "function");
+  return {
+    persistence: handleApi ? "session-handle" : "legacy",
+    actions: {
+      read: action(legacyRead || handleApi, "\u5F53\u524D DSH \u672A\u63D0\u4F9B\u53EF\u8BC6\u522B\u7684\u4F1A\u8BDD\u8BFB\u53D6\u63A5\u53E3"),
+      archive: action(!!(workspaceRegistry && typeof workspaceRegistry.archiveSession === "function"), "\u5F53\u524D DSH \u672A\u63D0\u4F9B\u5F52\u6863\u63A5\u53E3"),
+      trash: action(legacyRead || handleApi, "\u5F53\u524D DSH \u65E0\u6CD5\u8BFB\u53D6\u4F1A\u8BDD\uFF0C\u4E0D\u80FD\u5B89\u5168\u79FB\u5165\u56DE\u6536\u7AD9"),
+      restoreTrash: action(true),
+      purge: action(!handleApi && legacyLocate, "\u5F53\u524D DSH \u7248\u672C\u5C1A\u672A\u63D0\u4F9B\u7ECF\u8FC7\u9A8C\u8BC1\u7684\u5B89\u5168\u6C38\u4E45\u5220\u9664\u80FD\u529B"),
+      move: action(!handleApi && legacyRead && legacyLocate && workspaceInternals, "\u5F53\u524D DSH \u7248\u672C\u5C1A\u672A\u63D0\u4F9B\u7ECF\u8FC7\u9A8C\u8BC1\u7684\u8DE8\u5DE5\u4F5C\u533A\u8FC1\u79FB\u80FD\u529B")
+    }
+  };
+}
+function requireCapability(capabilities, name2) {
+  const value = capabilities && capabilities.actions && capabilities.actions[name2];
+  if (value && value.available) return;
+  const error = new Error(value && value.reason || `\u5F53\u524D\u73AF\u5883\u4E0D\u652F\u6301 ${name2}`);
+  error.status = 409;
+  error.code = "DSM_CAPABILITY_UNAVAILABLE";
+  throw error;
+}
+
 // src/index.js
 var name = "dsh-sessions-manager";
 var inject = ["webServer", "workspaceRegistry", "sessionPersistence", "sessionQuery", "storageDomain"];
@@ -690,6 +819,8 @@ function foldTitle(events) {
 function apply(ctx) {
   const w = ctx.workspaceRegistry;
   const sp = ctx.sessionPersistence;
+  const persistence = createPersistenceAdapter(sp);
+  const capabilities = detectCapabilities({ persistence: sp, workspaceRegistry: w });
   const sq = ctx.sessionQuery;
   const dom = () => ctx.storageDomain.get("workspace");
   const authorityTitleCache = /* @__PURE__ */ new Map();
@@ -814,7 +945,7 @@ function apply(ctx) {
     }
     if (!meta.title || !meta.cwd) {
       try {
-        const r = await sp.readFrom(id, 0);
+        const r = await persistence.readSession(id, 0);
         if (r.meta) {
           if (!meta.cwd) meta.cwd = r.meta.cwd || null;
           if (!meta.createdAt) meta.createdAt = r.meta.createdAt || null;
@@ -830,23 +961,25 @@ function apply(ctx) {
   async function collectUsage(preloadedHeaders) {
     const sizeById = /* @__PURE__ */ new Map();
     const mtimeById = /* @__PURE__ */ new Map();
-    let headers = null;
-    if (Array.isArray(preloadedHeaders)) headers = preloadedHeaders;
+    let entries = null;
+    if (Array.isArray(preloadedHeaders)) entries = preloadedHeaders;
     else {
       try {
-        headers = await sp.list();
+        entries = await persistence.listEntries();
       } catch (e) {
-        headers = [];
+        entries = [];
       }
     }
-    if (!Array.isArray(headers)) headers = [];
+    if (!Array.isArray(entries)) entries = [];
     const CHUNK = 8;
-    for (let i = 0; i < headers.length; i += CHUNK) {
-      await Promise.all(headers.slice(i, i + CHUNK).map(async (header) => {
-        const id = header && header.id != null ? String(header.id) : null;
+    for (let i = 0; i < entries.length; i += CHUNK) {
+      await Promise.all(entries.slice(i, i + CHUNK).map(async (entry) => {
+        const header = entry && entry.header ? entry.header : entry;
+        const id = entry && entry.id != null ? String(entry.id) : header && header.id != null ? String(header.id) : null;
         if (!id) return;
+        if (entry && Number.isFinite(entry.sizeBytes)) sizeById.set(id, Number(entry.sizeBytes));
         try {
-          const loc = sp.locate(header);
+          const loc = persistence.locate(header);
           if (!loc || typeof loc.path !== "string" || !loc.path) return;
           const st = await stat(loc.path);
           if (!st) return;
@@ -876,7 +1009,7 @@ function apply(ctx) {
   }
   async function readTrashStore() {
     try {
-      return normalizeTrashStore(JSON.parse(readFileSync4(TRASH_INDEX, "utf8")));
+      return normalizeTrashStore(JSON.parse(readFileSync3(TRASH_INDEX, "utf8")));
     } catch (e) {
       return normalizeTrashStore(null);
     }
@@ -918,17 +1051,20 @@ function apply(ctx) {
     let cwd = null;
     let title = null;
     let removedPath = null;
+    let persistenceEntry = null;
     try {
-      const headers = await sp.list();
-      header = headers.find((h) => String(h.id) === sid) || null;
+      const entries = await persistence.listEntries();
+      const found = entries.find((entry) => entry.id === sid) || null;
+      persistenceEntry = found;
+      header = found ? found.header : null;
       if (header) {
-        const loc = sp.locate(header);
+        const loc = persistence.locate(header);
         if (loc && typeof loc.path === "string") removedPath = loc.path;
         cwd = header.cwd || null;
         title = header.title || header.meta && header.meta.title || null;
       }
       if (!title) {
-        const r = await sp.readFrom(sid, 0);
+        const r = await persistence.readSession(sid, 0);
         if (r && r.meta) {
           if (!cwd) cwd = r.meta.cwd;
           title = foldTitle(r.events);
@@ -949,7 +1085,7 @@ function apply(ctx) {
         cwd: cwd || null,
         header: header || null,
         originalPath: removedPath || null,
-        sizeBytes: header && typeof header.size === "number" ? header.size : null,
+        sizeBytes: persistenceEntry && Number.isFinite(persistenceEntry.sizeBytes) ? persistenceEntry.sizeBytes : null,
         wasArchived: archived,
         deletedAt: Date.now()
       };
@@ -977,6 +1113,7 @@ function apply(ctx) {
   }
   async function purgeFromTrash(sid) {
     requireSessionId(sid);
+    requireCapability(capabilities, "purge");
     let purged = false;
     await mutateTrash(async (store) => {
       const entry = store.items.find((t) => String(t.sessionId) === sid);
@@ -987,13 +1124,18 @@ function apply(ctx) {
       }
       let target = null;
       try {
-        const headers = await sp.list();
-        const current = headers.find((h) => String(h.id) === sid);
-        const located = current && sp.locate(current);
+        const entries = await persistence.listEntries();
+        const current = entries.find((entry2) => entry2.id === sid);
+        const located = current && persistence.locate(current.header);
         if (located && typeof located.path === "string") target = located.path;
       } catch (e) {
       }
       if (!target && typeof entry.originalPath === "string") target = entry.originalPath;
+      if (!target) {
+        const error = new Error("\u65E0\u6CD5\u786E\u8BA4\u8BE5\u4F1A\u8BDD\u7684\u7269\u7406\u65E5\u5FD7\u4F4D\u7F6E\uFF0C\u5DF2\u505C\u6B62\u6C38\u4E45\u5220\u9664");
+        error.status = 409;
+        throw error;
+      }
       const targetOwnsSession = target && (basename(dirname2(target)) === sid || basename(target).includes(sid));
       if (target && !targetOwnsSession) {
         const error = new Error("\u65E5\u5FD7\u8DEF\u5F84\u4E0E\u4F1A\u8BDD ID \u4E0D\u5339\u914D\uFF0C\u5DF2\u505C\u6B62\u6C38\u4E45\u5220\u9664");
@@ -1069,6 +1211,7 @@ function apply(ctx) {
     return (await readTrashStore()).settings;
   }
   async function cleanupExpiredTrash() {
+    if (!capabilities.actions.purge.available) return 0;
     const store = await readTrashStore();
     const days = store.settings.retentionDays;
     if (!days) return 0;
@@ -1102,11 +1245,12 @@ function apply(ctx) {
     return { canonical, entity: await w.create(canonical, basename(canonical) || "workspace") };
   }
   async function moveOne(sid, targetPath) {
+    requireCapability(capabilities, "move");
     const activeId = getActiveSessionId(ctx);
     if (activeId != null && String(activeId) === String(sid)) {
       throw new Error("\u8BE5\u4F1A\u8BDD\u5F53\u524D\u5904\u4E8E\u6253\u5F00\u72B6\u6001\uFF0C\u8BF7\u5148\u5207\u6362\u5230\u522B\u7684\u4F1A\u8BDD\u518D\u79FB\u52A8\u3002");
     }
-    const r = await sp.readFrom(sid, 0);
+    const r = await persistence.readSession(sid, 0);
     if (!r || !r.meta) throw new Error("\u65E0\u6CD5\u8BFB\u53D6\u8BE5\u4F1A\u8BDD\u7684\u65E5\u5FD7");
     const meta = r.meta;
     const events = r.events;
@@ -1133,12 +1277,41 @@ function apply(ctx) {
       const newPath = locatePath(newHeaderObj);
       if (!oldPath || !newPath || oldPath === newPath) return false;
       const backupPath = `${oldPath}.move-backup-${Date.now()}`;
+      const stagedPath = `${newPath}.move-stage-${process.pid}-${Date.now()}`;
+      let destinationInstalled = false;
       try {
         await mkdir4(dirname2(newPath), { recursive: true });
+        try {
+          await stat(newPath);
+          throw new Error("\u79FB\u52A8\u5931\u8D25\uFF1A\u76EE\u6807\u4F4D\u7F6E\u5DF2\u5B58\u5728\u540C\u540D\u4F1A\u8BDD\u65E5\u5FD7");
+        } catch (e) {
+          if (e && e.code !== "ENOENT") throw e;
+        }
         await rename4(oldPath, backupPath);
-        await rewriteFrame0Cwd(backupPath, canonical);
-        await rename4(backupPath, newPath);
+        const original = await readFile2(backupPath);
+        const originalFrames = scanZstdFrames(original).frames;
+        if (originalFrames.length === 0) throw new Error("\u79FB\u52A8\u524D\u6821\u9A8C\u5931\u8D25\uFF1A\u4F1A\u8BDD\u65E5\u5FD7\u6CA1\u6709\u5B8C\u6574 zstd \u5E27");
+        const rewritten = rewriteFrame0CwdInMemory(original, canonical);
+        const rewrittenFrames = scanZstdFrames(rewritten).frames;
+        if (rewrittenFrames.length !== originalFrames.length) throw new Error("\u79FB\u52A8\u540E\u6821\u9A8C\u5931\u8D25\uFF1A\u4F1A\u8BDD\u65E5\u5FD7\u5E27\u6570\u53D1\u751F\u53D8\u5316");
+        const originalTail = original.subarray(originalFrames[0].end);
+        const rewrittenTail = rewritten.subarray(rewrittenFrames[0].end);
+        if (!originalTail.equals(rewrittenTail)) throw new Error("\u79FB\u52A8\u540E\u6821\u9A8C\u5931\u8D25\uFF1A\u4F1A\u8BDD\u4E8B\u4EF6\u5185\u5BB9\u53D1\u751F\u53D8\u5316");
+        await writeFile4(stagedPath, rewritten, { mode: 384 });
+        await rename4(stagedPath, newPath);
+        destinationInstalled = true;
+        await unlink(backupPath);
       } catch (e) {
+        try {
+          await unlink(stagedPath);
+        } catch (_) {
+        }
+        if (destinationInstalled) {
+          try {
+            await unlink(newPath);
+          } catch (_) {
+          }
+        }
         try {
           await rename4(backupPath, oldPath);
         } catch (_) {
@@ -1165,7 +1338,7 @@ function apply(ctx) {
       return null;
     };
     if (isOpen) {
-      await relocateLog(meta, newHeader);
+      if (!await relocateLog(meta, newHeader)) throw new Error("\u79FB\u52A8\u5931\u8D25\uFF1A\u65E0\u6CD5\u786E\u8BA4\u4F1A\u8BDD\u65E5\u5FD7\u5DF2\u8FC1\u79FB\u5230\u76EE\u6807\u5DE5\u4F5C\u533A");
       try {
         const st = sp.states && sp.states.get && sp.states.get(sid);
         if (st && st.meta) st.meta = Object.assign({}, st.meta, { cwd: canonical });
@@ -1181,7 +1354,7 @@ function apply(ctx) {
         oldPath = null;
       }
       if (typeof sp.create !== "function" || typeof sp.append !== "function") {
-        await relocateLog(meta, newHeader);
+        if (!await relocateLog(meta, newHeader)) throw new Error("\u79FB\u52A8\u5931\u8D25\uFF1A\u65E0\u6CD5\u786E\u8BA4\u4F1A\u8BDD\u65E5\u5FD7\u5DF2\u8FC1\u79FB\u5230\u76EE\u6807\u5DE5\u4F5C\u533A");
       } else {
         const backupPath = oldPath ? `${oldPath}.move-backup-${Date.now()}` : null;
         if (backupPath) {
@@ -1202,7 +1375,7 @@ function apply(ctx) {
         try {
           await sp.create(newHeader);
           await sp.append(sid, events);
-          const check = await sp.readFrom(sid, 0);
+          const check = await persistence.readSession(sid, 0);
           if (!check || !check.meta || check.meta.cwd !== canonical) {
             throw new Error("\u79FB\u52A8\u540E\u6821\u9A8C\u5931\u8D25\uFF1A\u4F1A\u8BDD\u5DE5\u4F5C\u76EE\u5F55\u672A\u6B63\u786E\u66F4\u65B0");
           }
@@ -1215,7 +1388,7 @@ function apply(ctx) {
         } catch (e) {
           if (ALREADY_EXISTS_RE.test(String(e && e.message || e))) {
             await restore();
-            await relocateLog(meta, newHeader);
+            if (!await relocateLog(meta, newHeader)) throw new Error("\u79FB\u52A8\u5931\u8D25\uFF1A\u65E0\u6CD5\u786E\u8BA4\u4F1A\u8BDD\u65E5\u5FD7\u5DF2\u8FC1\u79FB\u5230\u76EE\u6807\u5DE5\u4F5C\u533A");
           } else {
             await restore();
             throw new Error("\u79FB\u52A8\u4F1A\u8BDD\u65E5\u5FD7\u5931\u8D25\uFF1A" + String(e && e.message || e));
@@ -1261,14 +1434,14 @@ function apply(ctx) {
   async function reindexRegistry() {
     const reg = w;
     if (!reg || typeof reg.replaceHeaderIndex !== "function") return false;
-    let headers = null;
+    let entries = null;
     try {
-      headers = await sp.list();
+      entries = await persistence.listEntries();
     } catch (e) {
-      headers = null;
+      entries = null;
     }
-    if (!headers || !Array.isArray(headers)) return false;
-    await reg.replaceHeaderIndex(headers);
+    if (!entries || !Array.isArray(entries)) return false;
+    await reg.replaceHeaderIndex(entries.map((entry) => entry.header));
     if (typeof reg.rebuildEntities === "function") reg.rebuildEntities();
     return true;
   }
@@ -1304,17 +1477,17 @@ function apply(ctx) {
     return out;
   }
   async function allSessionItems(opts = {}) {
-    let headers = [];
+    let entries = [];
     let headersOk = false;
     try {
-      headers = await sp.list();
-      headersOk = Array.isArray(headers);
-      if (!headersOk) headers = [];
+      entries = await persistence.listEntries();
+      headersOk = Array.isArray(entries);
+      if (!headersOk) entries = [];
     } catch (e) {
-      headers = [];
+      entries = [];
     }
     let live = ctx.get("sessions");
-    const ids = headers.map((h) => String(h.id));
+    const ids = entries.map((entry) => entry.id);
     if (live) {
       try {
         live.list().forEach((s) => {
@@ -1339,7 +1512,7 @@ function apply(ctx) {
     }
     const currentArchived = new Set((await archivedState().catch(() => ({ archivedSessionIds: [] }))).archivedSessionIds || []);
     const items = [];
-    const usage = await collectUsage(headers);
+    const usage = await collectUsage(entries);
     const statsById = new Map(visibleIds.map((id) => [id, { mtimeMs: usage.mtimeById.get(id), size: usage.sizeById.get(id) }]));
     const { cached, missing } = metaCache.partition(visibleIds, statsById);
     const persisted = await hydrateFromPersist(missing, statsById);
@@ -1405,14 +1578,14 @@ function apply(ctx) {
   }
   async function sidebarAuthority() {
     const ids = [];
-    let headers = [];
+    let entries = [];
     try {
-      headers = await sp.list();
+      entries = await persistence.listEntries();
     } catch (e) {
-      headers = [];
+      entries = [];
     }
-    if (!Array.isArray(headers)) headers = [];
-    for (const header of headers) ids.push(String(header.id));
+    if (!Array.isArray(entries)) entries = [];
+    for (const entry of entries) ids.push(entry.id);
     const sessions = ctx.get("sessions");
     try {
       if (sessions) sessions.list().forEach((session) => {
@@ -1423,7 +1596,7 @@ function apply(ctx) {
     }
     const store = await readTrashStore();
     if (ids.length) {
-      const usage = await collectUsage(headers);
+      const usage = await collectUsage(entries);
       const statsById = new Map(ids.map((id) => [id, { mtimeMs: usage.mtimeById.get(id), size: usage.sizeById.get(id) }]));
       const { cached, missing } = metaCache.partition(ids, statsById);
       const persisted = await hydrateFromPersist(missing, statsById);
@@ -1466,14 +1639,14 @@ function apply(ctx) {
         events = [];
       }
     } else {
-      const r = await sp.readFrom(sid, 0);
+      const r = await persistence.readSession(sid, 0);
       if (!r || !r.meta) throw new Error("\u627E\u4E0D\u5230\u8BE5\u4F1A\u8BDD\u7684\u8BB0\u5F55\uFF08\u4F1A\u8BDD\u4E0D\u5B58\u5728\uFF09");
       meta = r.meta;
       events = Array.isArray(r.events) ? r.events : [];
     }
     let sizeBytes = null;
     try {
-      const loc = sp.locate(meta);
+      const loc = persistence.locate(meta);
       if (loc && typeof loc.path === "string" && loc.path) {
         const st = await stat(loc.path);
         if (st && typeof st.size === "number") sizeBytes = st.size;
@@ -1558,7 +1731,8 @@ function apply(ctx) {
     const subagentSet = /* @__PURE__ */ new Set();
     try {
       if (typeof sp.list === "function") {
-        for (const h of await sp.list()) {
+        for (const entry of await persistence.listEntries()) {
+          const h = entry.header;
           if (String(h.parentSession) !== String(sid)) continue;
           if (h.origin === "subagent") subagentSet.add(h.id);
           else childrenSet.add(h.id);
@@ -1595,6 +1769,11 @@ function apply(ctx) {
         authorityTitleCache.set(String(session.id), event.data.title);
       }
     }));
+    disposers.push(ctx.webServer.register({
+      kind: "exact",
+      path: "/archived-sessions/capabilities",
+      handler: async (req, res) => json(res, capabilities)
+    }));
     disposers.push(ctx.webServer.register({
       kind: "exact",
       path: "/archived-sessions/list",
@@ -1605,8 +1784,8 @@ function apply(ctx) {
           let materialized = /* @__PURE__ */ new Set();
           let live = ctx.get("sessions");
           try {
-            const headers = await sp.list();
-            materialized = new Set(headers.map((h) => String(h.id)));
+            const entries = await persistence.listEntries();
+            materialized = new Set(entries.map((entry) => entry.id));
           } catch (e) {
           }
           const trashStore = await readTrashStore();
@@ -1657,12 +1836,12 @@ function apply(ctx) {
             try {
               results.push({ sessionId: sid, ok: true, ...await restoreOne(sid) });
             } catch (e) {
-              results.push({ sessionId: sid, ok: false, error: String(e && e.message || e) });
+              results.push({ sessionId: sid, ok: false, code: e && e.code, error: String(e && e.message || e) });
             }
           }
           json(res, { ok: true, restored: results.filter((r) => r.ok).length, results });
         } catch (e) {
-          json(res, { ok: false, error: String(e && e.message || e) }, 500);
+          json(res, { ok: false, code: e && e.code, error: String(e && e.message || e) }, errorStatus(e));
         }
       }
     }));
@@ -1701,7 +1880,7 @@ function apply(ctx) {
           }
           json(res, { ok: true, deleted: results.filter((r) => r.ok).length, results });
         } catch (e) {
-          json(res, { ok: false, error: String(e && e.message || e) }, 500);
+          json(res, { ok: false, code: e && e.code, error: String(e && e.message || e) }, errorStatus(e));
         }
       }
     }));
@@ -1740,11 +1919,19 @@ function apply(ctx) {
         try {
           const items = await readTrash();
           const results = await Promise.all(items.map(async (item) => {
-            let exists = false;
-            if (typeof item.originalPath === "string") exists = await stat(item.originalPath).then(() => true).catch(() => false);
-            return { sessionId: item.sessionId, status: exists ? "ok" : "missing", originalPath: item.originalPath || null };
+            if (typeof item.originalPath !== "string" || !item.originalPath) {
+              return { sessionId: item.sessionId, status: "unverified", originalPath: null };
+            }
+            const exists = await stat(item.originalPath).then(() => true).catch(() => false);
+            return { sessionId: item.sessionId, status: exists ? "ok" : "missing", originalPath: item.originalPath };
           }));
-          json(res, { ok: true, healthy: results.filter((r) => r.status === "ok").length, missing: results.filter((r) => r.status === "missing").length, results });
+          json(res, {
+            ok: true,
+            healthy: results.filter((r) => r.status === "ok").length,
+            missing: results.filter((r) => r.status === "missing").length,
+            unverified: results.filter((r) => r.status === "unverified").length,
+            results
+          });
         } catch (e) {
           json(res, { ok: false, error: String(e && e.message || e) }, errorStatus(e));
         }
@@ -1762,7 +1949,7 @@ function apply(ctx) {
           metaCache.invalidate(sid);
           json(res, out);
         } catch (e) {
-          json(res, { ok: false, error: String(e && e.message || e) }, 500);
+          json(res, { ok: false, code: e && e.code, error: String(e && e.message || e) }, errorStatus(e));
         }
       }
     }));
@@ -1780,7 +1967,7 @@ function apply(ctx) {
           });
           json(res, out);
         } catch (e) {
-          json(res, { ok: false, error: String(e && e.message || e) }, 500);
+          json(res, { ok: false, code: e && e.code, error: String(e && e.message || e) }, errorStatus(e));
         }
       }
     }));
@@ -1805,7 +1992,7 @@ function apply(ctx) {
           }
           json(res, { ok: true, purged: results.filter((r) => r.ok).length, results });
         } catch (e) {
-          json(res, { ok: false, error: String(e && e.message || e) }, 500);
+          json(res, { ok: false, code: e && e.code, error: String(e && e.message || e) }, errorStatus(e));
         }
       }
     }));
@@ -1847,7 +2034,7 @@ function apply(ctx) {
           const url = new URL(req.url, "http://localhost");
           const sid = url.searchParams.get("sessionId");
           requireSessionId(sid);
-          const r = await sp.readFrom(sid, 0);
+          const r = await persistence.readSession(sid, 0);
           if (!r || !r.meta) {
             const error = new Error("\u65E0\u6CD5\u8BFB\u53D6\u8BE5\u4F1A\u8BDD\u7684\u65E5\u5FD7");
             error.status = 404;
@@ -1905,7 +2092,7 @@ function apply(ctx) {
           }
           json(res, { sessionId: sid, ...moved });
         } catch (e) {
-          json(res, { ok: false, error: String(e && e.message || e) }, 500);
+          json(res, { ok: false, code: e && e.code, error: String(e && e.message || e) }, errorStatus(e));
         }
       }
     }));