dsh-sessions-manager 3.5.0 → 3.5.2

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 { basename, dirname as dirname2, isAbsolute, join as join4 } from "node:path";
-import { readFileSync as readFileSync4 } from "node:fs";
+import { mkdir as mkdir5, readFile as readFile3, realpath, rename as rename5, stat as stat2, unlink as unlink2, writeFile as writeFile5 } from "node:fs/promises";
+import { basename as basename2, dirname as dirname2, isAbsolute, join as join6 } from "node:path";
+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 (_) {
-    }
-  }
-  return starts;
+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 { 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
@@ -102,87 +136,106 @@ function summarizeToolArguments(name2, rawArguments) {
   }
   return JSON.stringify(rest).slice(0, MAX_TOOL_ARG);
 }
-function renderSessionMarkdown(meta, events, options = {}) {
+function createMarkdownFold(out, header, options) {
   const includeReasoning = options.includeReasoning === true;
   const includeToolResults = options.includeToolResults === true;
-  const header = meta && typeof meta === "object" ? meta : {};
-  const list = Array.isArray(events) ? events : [];
   let title = typeof header.title === "string" && header.title.trim() ? header.title.trim() : null;
-  for (const ev of list) {
-    const data = ev && ev.data;
-    if (ev && ev.type === "session/title" && data && typeof data.title === "string" && data.title.trim()) {
-      title = data.title.trim();
-    }
-  }
-  const front = ["---"];
-  if (title) front.push(`title: ${yamlString(title)}`);
-  if (typeof header.id === "string" && header.id) front.push(`sessionId: ${yamlString(header.id)}`);
-  if (typeof header.cwd === "string" && header.cwd) front.push(`cwd: ${yamlString(header.cwd)}`);
-  const created = isoTime(header.createdAt);
-  if (created) front.push(`createdAt: ${created}`);
-  const exported = isoTime(options.exportedAt);
-  if (exported) front.push(`exportedAt: ${exported}`);
-  front.push("---");
-  const out = [front.join("\n")];
-  if (title) out.push("", `# ${title}`);
   let turn = null;
-  for (const ev of list) {
-    if (!ev || typeof ev !== "object") continue;
-    const data = ev.data && typeof ev.data === "object" ? ev.data : {};
-    const type = ev.type;
-    if (type === "turn/start") {
-      const next = Number.isInteger(data.turn) ? data.turn : null;
-      if (next !== null && next !== turn) {
-        turn = next;
-        out.push("", `## \u7B2C ${turn} \u8F6E`);
-      }
-      continue;
-    }
-    if (type === "user/message") {
-      const blocks = blocksOf(data.content);
-      const text = textFromBlocks(blocks);
-      const images = imageCountOf(blocks);
-      if (!text && images === 0) continue;
-      out.push("", "### \u7528\u6237", "");
-      if (text) out.push(text);
-      for (let i = 0; i < images; i++) out.push("", `![\u56FE\u7247 ${i + 1}](attachment)`);
-      continue;
-    }
-    if (type === "assistant/message") {
-      const message = data.message && typeof data.message === "object" ? data.message : {};
-      const blocks = blocksOf(message.content);
-      const text = textFromBlocks(blocks);
-      const reasoning = includeReasoning ? reasoningFromBlocks(blocks) : "";
-      if (!text && !reasoning) continue;
-      out.push("", "### \u52A9\u624B", "");
-      if (reasoning) out.push("> \u601D\u8003\uFF1A" + reasoning.split("\n").join("\n> "), "");
-      if (text) out.push(text);
-      continue;
-    }
-    if (type === "tool/call") {
-      const name2 = typeof data.name === "string" && data.name ? data.name : "tool";
-      const summary = summarizeToolArguments(name2, data.arguments);
-      out.push("", `### \u5DE5\u5177\u8C03\u7528\uFF1A\`${name2}\``, "");
-      out.push(summary ? "```\n" + summary + "\n```" : "\uFF08\u65E0\u53C2\u6570\uFF09");
-      continue;
-    }
-    if (type === "tool/result" && includeToolResults) {
-      const message = data.message && typeof data.message === "object" ? data.message : {};
-      const blocks = blocksOf(message.content);
-      let text = "";
-      for (const block of blocks) {
-        if (block.type === "tool-result") text = textFromBlocks(blocksOf(block.content));
-      }
-      if (text) out.push("", "<details><summary>\u5DE5\u5177\u7ED3\u679C</summary>", "", "```\n" + text.slice(0, 2e3) + "\n```", "", "</details>");
-    }
-  }
-  out.push("");
-  return out.join("\n");
+  return {
+    get title() {
+      return title;
+    },
+    // The last session/title event wins — DSH may retitle a session later on.
+    add(events) {
+      const list = Array.isArray(events) ? events : [];
+      for (const ev of list) {
+        if (!ev || typeof ev !== "object") continue;
+        const data = ev.data && typeof ev.data === "object" ? ev.data : {};
+        const type = ev.type;
+        if (type === "session/title" && data && typeof data.title === "string" && data.title.trim()) {
+          title = data.title.trim();
+          continue;
+        }
+        if (type === "turn/start") {
+          const next = Number.isInteger(data.turn) ? data.turn : null;
+          if (next !== null && next !== turn) {
+            turn = next;
+            out.push("", `## \u7B2C ${turn} \u8F6E`);
+          }
+          continue;
+        }
+        if (type === "user/message") {
+          const blocks = blocksOf(data.content);
+          const text = textFromBlocks(blocks);
+          const images = imageCountOf(blocks);
+          if (!text && images === 0) continue;
+          out.push("", "### \u7528\u6237", "");
+          if (text) out.push(text);
+          for (let i = 0; i < images; i++) out.push("", `![\u56FE\u7247 ${i + 1}](attachment)`);
+          continue;
+        }
+        if (type === "assistant/message") {
+          const message = data.message && typeof data.message === "object" ? data.message : {};
+          const blocks = blocksOf(message.content);
+          const text = textFromBlocks(blocks);
+          const reasoning = includeReasoning ? reasoningFromBlocks(blocks) : "";
+          if (!text && !reasoning) continue;
+          out.push("", "### \u52A9\u624B", "");
+          if (reasoning) out.push("> \u601D\u8003\uFF1A" + reasoning.split("\n").join("\n> "), "");
+          if (text) out.push(text);
+          continue;
+        }
+        if (type === "tool/call") {
+          const name2 = typeof data.name === "string" && data.name ? data.name : "tool";
+          const summary = summarizeToolArguments(name2, data.arguments);
+          out.push("", `### \u5DE5\u5177\u8C03\u7528\uFF1A\`${name2}\``, "");
+          out.push(summary ? "```\n" + summary + "\n```" : "\uFF08\u65E0\u53C2\u6570\uFF09");
+          continue;
+        }
+        if (type === "tool/result" && includeToolResults) {
+          const message = data.message && typeof data.message === "object" ? data.message : {};
+          const blocks = blocksOf(message.content);
+          let text = "";
+          for (const block of blocks) {
+            if (block.type === "tool-result") text = textFromBlocks(blocksOf(block.content));
+          }
+          if (text) out.push("", "<details><summary>\u5DE5\u5177\u7ED3\u679C</summary>", "", "```\n" + text.slice(0, 2e3) + "\n```", "", "</details>");
+        }
+      }
+    }
+  };
+}
+function createSessionMarkdownBuilder(meta, options = {}) {
+  const header = meta && typeof meta === "object" ? meta : {};
+  const body = [];
+  const fold = createMarkdownFold(body, header, options);
+  return {
+    addEvents(events) {
+      fold.add(events);
+    },
+    finish(metaOverride) {
+      const effective = metaOverride && typeof metaOverride === "object" ? metaOverride : header;
+      const title = fold.title;
+      const front = ["---"];
+      if (title) front.push(`title: ${yamlString(title)}`);
+      if (typeof effective.id === "string" && effective.id) front.push(`sessionId: ${yamlString(effective.id)}`);
+      if (typeof effective.cwd === "string" && effective.cwd) front.push(`cwd: ${yamlString(effective.cwd)}`);
+      const created = isoTime(effective.createdAt);
+      if (created) front.push(`createdAt: ${created}`);
+      const exported = isoTime(options.exportedAt);
+      if (exported) front.push(`exportedAt: ${exported}`);
+      front.push("---");
+      const doc = [front.join("\n")];
+      if (title) doc.push("", `# ${title}`);
+      doc.push(...body, "");
+      return doc.join("\n");
+    }
+  };
 }
 
 // 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 +263,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 +356,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 +412,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);
     }
@@ -414,20 +467,28 @@ function createAutoArchiveStore(options = {}) {
 // src/session-meta-cache.js
 var DEFAULT_TTL_MS = 5 * 60 * 1e3;
 var DEFAULT_MAX = 4e3;
-function fingerprintOf(stat2) {
-  if (!stat2 || typeof stat2 !== "object") return null;
-  const mtimeMs = stat2.mtimeMs;
-  const size = stat2.size;
+var REVISION_PREFIX = "rev:";
+function fingerprintOf(stat3) {
+  if (!stat3 || typeof stat3 !== "object") return null;
+  if (typeof stat3.revision === "string" && stat3.revision.length > 0) {
+    return REVISION_PREFIX + stat3.revision;
+  }
+  const mtimeMs = stat3.mtimeMs;
+  const size = stat3.size;
   if (typeof mtimeMs !== "number" || !Number.isFinite(mtimeMs) || mtimeMs <= 0) return null;
   if (typeof size !== "number" || !Number.isFinite(size) || size < 0) return null;
   return `${Math.floor(mtimeMs)}:${size}`;
 }
-function isFresh(entry, stat2, now, ttlMs = DEFAULT_TTL_MS) {
+function isPersistableFingerprint(fingerprint) {
+  return typeof fingerprint === "string" && fingerprint !== "" && !fingerprint.startsWith(REVISION_PREFIX);
+}
+function isFresh(entry, stat3, now, ttlMs = DEFAULT_TTL_MS) {
   if (!entry) return false;
-  const fp = fingerprintOf(stat2);
+  const fp = fingerprintOf(stat3);
   if (!fp) return false;
   if (entry.fingerprint !== fp) return false;
   if (typeof entry.at !== "number") return false;
+  if (fp.startsWith(REVISION_PREFIX)) return true;
   return now - entry.at <= ttlMs;
 }
 function partitionByCache(ids, statsById, cache, now = Date.now(), ttlMs = DEFAULT_TTL_MS) {
@@ -435,8 +496,8 @@ function partitionByCache(ids, statsById, cache, now = Date.now(), ttlMs = DEFAU
   const missing = [];
   for (const id of ids) {
     const entry = cache && cache.get(String(id));
-    const stat2 = statsById && statsById.get(String(id));
-    if (isFresh(entry, stat2, now, ttlMs) && entry && entry.meta) {
+    const stat3 = statsById && statsById.get(String(id));
+    if (isFresh(entry, stat3, now, ttlMs) && entry && entry.meta) {
       cached.set(String(id), entry.meta);
     } else {
       missing.push(String(id));
@@ -452,10 +513,10 @@ function createSessionMetaCache(opts = {}) {
   let misses = 0;
   return {
     // 命中返回 meta，未命中/无法校验返回 null。
-    get(id, stat2) {
+    get(id, stat3) {
       const key = String(id);
       const entry = map.get(key);
-      if (isFresh(entry, stat2, Date.now(), ttlMs)) {
+      if (isFresh(entry, stat3, Date.now(), ttlMs)) {
         hits++;
         map.delete(key);
         map.set(key, entry);
@@ -464,9 +525,9 @@ function createSessionMetaCache(opts = {}) {
       misses++;
       return null;
     },
-    set(id, stat2, meta) {
+    set(id, stat3, meta) {
       if (!meta) return null;
-      const fp = fingerprintOf(stat2);
+      const fp = fingerprintOf(stat3);
       if (!fp) return null;
       const key = String(id);
       map.delete(key);
@@ -512,7 +573,8 @@ function normalizeEntry(raw) {
   const createdAt = typeof raw.createdAt === "number" ? raw.createdAt : null;
   const fingerprint = typeof raw.fingerprint === "string" && raw.fingerprint ? raw.fingerprint : null;
   const updatedAt = typeof raw.updatedAt === "number" ? raw.updatedAt : 0;
-  if (!fingerprint || !title && !cwd) return null;
+  if (!fingerprint || fingerprint.startsWith("rev:")) return null;
+  if (!title && !cwd) return null;
   return { title, cwd, createdAt, fingerprint, updatedAt };
 }
 function normalizeTitleIndex(raw) {
@@ -605,6 +667,19 @@ function createTitleIndexStore({ dir, file }) {
 }
 
 // src/compat/persistence.js
+var DEFAULT_CHUNK = 400;
+var MAX_CHUNKS = 2e4;
+function normalizeReadResult(events) {
+  if (Array.isArray(events)) return events;
+  if (events && typeof events[Symbol.iterator] === "function") return [...events];
+  return [];
+}
+async function closeQuietly(handle) {
+  try {
+    if (handle && typeof handle.close === "function") await handle.close();
+  } catch (e) {
+  }
+}
 function asHeader(value) {
   if (!value || typeof value !== "object") return null;
   const candidate = value.header && typeof value.header === "object" ? value.header : value;
@@ -620,7 +695,7 @@ function normalizePersistenceEntry(value) {
     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
+    revision: snapshot && typeof snapshot.revision === "string" && snapshot.revision ? snapshot.revision : null
   };
 }
 function normalizePersistenceList(values) {
@@ -629,44 +704,112 @@ function normalizePersistenceList(values) {
 }
 function createPersistenceAdapter(service) {
   if (!service || typeof service.list !== "function") throw new TypeError("sessionPersistence.list is required");
+  const hasStat = typeof service.stat === "function";
+  const kind = typeof service.open === "function" ? "session-handle" : "legacy";
   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 : []
-      };
+  async function statSession(id) {
+    if (!hasStat) return null;
+    const snapshot = await service.stat(id);
+    return snapshot ? normalizePersistenceEntry(snapshot) : null;
+  }
+  async function readChunk(handle, offset, length, signal) {
+    if (signal && signal.aborted) {
+      const error = new Error("\u4F1A\u8BDD\u8BFB\u53D6\u5DF2\u53D6\u6D88");
+      error.code = "DSM_READ_ABORTED";
+      throw error;
     }
+    const events = await handle.read(offset, length, signal ? { signal } : void 0);
+    return normalizeReadResult(events);
+  }
+  async function readChunks(id, { offset = 0, chunkSize = DEFAULT_CHUNK, signal, onEvents }) {
     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 {
-      }
+      await closeQuietly(handle);
       throw new Error("DSH \u8FD4\u56DE\u4E86\u65E0\u6548\u7684 SessionHandle");
     }
+    let cursor = Number.isSafeInteger(offset) && offset >= 0 ? offset : 0;
+    let total = 0;
     try {
-      const events = await handle.read(offset);
+      for (let round = 0; round < MAX_CHUNKS; round++) {
+        const events = await readChunk(handle, cursor, chunkSize, signal);
+        if (events.length === 0) break;
+        cursor += events.length;
+        total += events.length;
+        if (onEvents) await onEvents(events, { offset: cursor - events.length, total });
+        if (events.length < chunkSize) break;
+      }
+    } finally {
+      await closeQuietly(handle);
+    }
+    return {
+      meta: handle.header || handle.meta || null,
+      inheritedEventCount: Number.isSafeInteger(handle.inheritedEventCount) ? handle.inheritedEventCount : 0,
+      eventCount: total
+    };
+  }
+  async function inspectSession(id, opts = {}) {
+    const chunkSize = Number.isSafeInteger(opts.chunkSize) && opts.chunkSize > 0 ? opts.chunkSize : DEFAULT_CHUNK;
+    if (typeof service.open === "function") {
+      if (opts.signal && opts.signal.aborted) {
+        const error = new Error("\u4F1A\u8BDD\u8BFB\u53D6\u5DF2\u53D6\u6D88");
+        error.code = "DSM_READ_ABORTED";
+        throw error;
+      }
+      return readChunks(id, { offset: opts.offset || 0, chunkSize, signal: opts.signal, onEvents: opts.onEvents });
+    }
+    if (typeof service.readFrom !== "function") throw new Error("\u5F53\u524D DSH \u6301\u4E45\u5316\u670D\u52A1\u4E0D\u652F\u6301\u8BFB\u53D6\u4F1A\u8BDD");
+    if (opts.signal && opts.signal.aborted) {
+      const error = new Error("\u4F1A\u8BDD\u8BFB\u53D6\u5DF2\u53D6\u6D88");
+      error.code = "DSM_READ_ABORTED";
+      throw error;
+    }
+    const result = await service.readFrom(id, opts.offset || 0);
+    const events = normalizeReadResult(result && result.events);
+    if (opts.onEvents && events.length) await opts.onEvents(events, { offset: opts.offset || 0, total: events.length });
+    return {
+      meta: result && result.meta ? result.meta : null,
+      inheritedEventCount: result && Number.isSafeInteger(result.inheritedEventCount) ? result.inheritedEventCount : 0,
+      eventCount: events.length
+    };
+  }
+  async function readSession(id, offset = 0) {
+    if (typeof service.readFrom === "function") {
+      const result = await service.readFrom(id, offset);
       return {
-        meta: handle.header || handle.meta || null,
-        inheritedEventCount: Number.isSafeInteger(handle.inheritedEventCount) ? handle.inheritedEventCount : 0,
-        events: Array.isArray(events) ? events : [...events || []]
+        meta: result && result.meta ? result.meta : null,
+        inheritedEventCount: result && Number.isSafeInteger(result.inheritedEventCount) ? result.inheritedEventCount : 0,
+        events: result && Array.isArray(result.events) ? result.events : []
       };
-    } finally {
-      await handle.close();
     }
+    const events = [];
+    const summary = await readChunks(id, { offset, onEvents: (batch) => {
+      events.push(...batch);
+    } });
+    return {
+      meta: summary.meta,
+      inheritedEventCount: summary.inheritedEventCount,
+      events
+    };
   }
   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 };
+  async function locateVerified(header) {
+    if (typeof service.locate === "function") {
+      try {
+        const loc = service.locate(header);
+        if (loc && typeof loc.path === "string") return { path: loc.path, sessionDir: null };
+      } catch (e) {
+      }
+    }
+    const artifacts = await locateSessionArtifacts(service, header);
+    return artifacts ? { path: artifacts.logPath, sessionDir: artifacts.sessionDir } : null;
+  }
+  return { kind, listEntries, readSession, inspectSession, statSession, locate, locateVerified, hasStat };
 }
 
 // src/compat/capabilities.js
@@ -677,17 +820,34 @@ 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 handleEraRoot = !!(handleApi && persistence && typeof persistence.root === "string" && persistence.root.length > 0);
+  const canVerifyExistence = !!(handleApi || legacyRead || persistence && typeof persistence.stat === "function");
+  const readOk = legacyRead || handleApi;
   const workspaceInternals = !!(workspaceRegistry && workspaceRegistry.headers && workspaceRegistry.sessionPaths && typeof workspaceRegistry.replaceHeaderIndex === "function");
+  const matrix = {
+    readInspection: action(readOk, "\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"),
+    softTrash: action(readOk, "\u5F53\u524D DSH \u65E0\u6CD5\u8BFB\u53D6\u4F1A\u8BDD\uFF0C\u4E0D\u80FD\u5B89\u5168\u79FB\u5165\u56DE\u6536\u7AD9"),
+    // 恢复不再无条件宣称可用：必须能校验底层会话仍存在（stat 或 list），
+    // 否则恢复只会制造一条指向已消失日志的僵尸条目。
+    restoreIndexedSession: action(canVerifyExistence, "\u5F53\u524D DSH \u65E0\u6CD5\u6821\u9A8C\u5E95\u5C42\u4F1A\u8BDD\u662F\u5426\u5B58\u5728\uFF0C\u4E0D\u80FD\u5B89\u5168\u6062\u590D"),
+    physicalPurge: action(
+      !handleApi && legacyLocate || handleApi && handleEraRoot && canVerifyExistence,
+      handleApi && !handleEraRoot ? "\u65E0\u6CD5\u4ECE\u5F53\u524D DSH \u540E\u7AEF\u786E\u8BA4\u4F1A\u8BDD\u5B58\u50A8\u6839\u76EE\u5F55\uFF0C\u5DF2\u505C\u6B62\u7269\u7406\u5220\u9664\u4EE5\u4FDD\u62A4\u6570\u636E\u5B89\u5168" : "\u5F53\u524D DSH \u7248\u672C\u5C1A\u672A\u63D0\u4F9B\u7ECF\u8FC7\u9A8C\u8BC1\u7684\u5B89\u5168\u6C38\u4E45\u5220\u9664\u80FD\u529B\uFF1B\u79FB\u5165\u56DE\u6536\u7AD9\u4E0D\u4F1A\u91CA\u653E\u78C1\u76D8\u7A7A\u95F4"
+    ),
+    relocateSession: action(
+      !handleApi && legacyRead && legacyLocate && workspaceInternals || handleApi && handleEraRoot && readOk && workspaceInternals,
+      handleApi && !workspaceInternals ? "\u5F53\u524D DSH \u672A\u63D0\u4F9B\u5DE5\u4F5C\u533A\u6CE8\u518C\u8868\u5185\u90E8\u7ED3\u6784\uFF0C\u8DE8\u5DE5\u4F5C\u533A\u79FB\u52A8\u540E\u65E0\u6CD5\u5373\u65F6\u5237\u65B0\u5206\u7EC4" : handleApi && !handleEraRoot ? "\u65E0\u6CD5\u4ECE\u5F53\u524D DSH \u540E\u7AEF\u786E\u8BA4\u4F1A\u8BDD\u5B58\u50A8\u6839\u76EE\u5F55\uFF0C\u5DF2\u505C\u6B62\u79FB\u52A8\u4EE5\u4FDD\u62A4\u6570\u636E\u5B89\u5168" : "\u5F53\u524D DSH \u7248\u672C\u5C1A\u672A\u63D0\u4F9B\u7ECF\u8FC7\u9A8C\u8BC1\u7684\u8DE8\u5DE5\u4F5C\u533A\u8FC1\u79FB\u80FD\u529B"
+    )
+  };
+  matrix.read = matrix.readInspection;
+  matrix.trash = matrix.softTrash;
+  matrix.restoreTrash = matrix.restoreIndexedSession;
+  matrix.purge = matrix.physicalPurge;
+  matrix.move = matrix.relocateSession;
   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")
-    }
+    actions: matrix
   };
 }
 function requireCapability(capabilities, name2) {
@@ -699,12 +859,273 @@ function requireCapability(capabilities, name2) {
   throw error;
 }
 
+// src/path-guard.js
+function splitSegments(target) {
+  return String(target).replace(/[\\/]+$/, "").split(/[\\/]/).filter((seg) => seg.length > 0);
+}
+function stripDriveLetter(segments) {
+  return segments.length > 0 && /^[A-Za-z]:$/.test(segments[0]) ? segments.slice(1) : segments;
+}
+function pathOwnsSession(target, sid) {
+  if (typeof target !== "string" || target.length === 0) return false;
+  if (typeof sid !== "string" || sid.length === 0) return false;
+  const segments = stripDriveLetter(splitSegments(target));
+  if (segments.length === 0) return false;
+  const file = segments[segments.length - 1];
+  if (segments.length >= 2 && segments[segments.length - 2] === sid) return true;
+  if (file.includes(sid)) {
+    const ID_CHAR = /[A-Za-z0-9_-]/;
+    let from = 0;
+    while (true) {
+      const at = file.indexOf(sid, from);
+      if (at < 0) return false;
+      const before = at > 0 ? file[at - 1] : "";
+      const after = at + sid.length < file.length ? file[at + sid.length] : "";
+      if (!(before && ID_CHAR.test(before)) && !(after && ID_CHAR.test(after))) return true;
+      from = at + 1;
+    }
+  }
+  return false;
+}
+
+// src/handle-era-ops.js
+import { mkdir as mkdir4, readFile as readFile2, rename as rename4, rm, unlink, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+
+// src/handle-era-paths.js
+import { readdir, stat } from "node:fs/promises";
+import { basename, join as join4 } from "node:path";
+var GENERATION_LOG_RE = /^session\.v\d+\.jsonl(\.zst(d)?)?$/;
+function isSafeChar(ch) {
+  return ch !== "~" && /^[A-Za-z0-9._-]$/.test(ch);
+}
+function projectKeyFor(cwd) {
+  const s = String(cwd);
+  if (s.length === 0) throw new Error("cannot encode an empty project path");
+  let readable = "";
+  let separatorRun = false;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (ch === "/" || ch === "\\" || ch === ":") {
+      if (!separatorRun) readable += "-";
+      separatorRun = true;
+    } else if (isSafeChar(ch)) {
+      readable += ch;
+      separatorRun = false;
+    } else {
+      readable += "~" + s.charCodeAt(i).toString(16).toUpperCase().padStart(4, "0");
+      separatorRun = false;
+    }
+  }
+  return "--" + (readable.replace(/^-+/, "") || "root").slice(0, 251) + "--";
+}
+function encodeSegmentFor(raw) {
+  const s = String(raw);
+  if (s.length === 0) throw new Error("cannot encode an empty path segment");
+  if (s === ".") return "~002E";
+  if (s === "..") return "~002E~002E";
+  let out = "";
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    out += isSafeChar(ch) ? ch : "~" + s.charCodeAt(i).toString(16).toUpperCase().padStart(4, "0");
+  }
+  return out;
+}
+function resolveSessionRoot(sp) {
+  const root = sp && typeof sp === "object" ? sp.root : void 0;
+  return typeof root === "string" && root.length > 0 ? root : null;
+}
+function deriveSessionDir(root, cwd, id) {
+  const project = cwd === void 0 || cwd === null || cwd === "" ? join4(root, "_no-cwd") : join4(root, projectKeyFor(cwd));
+  return join4(project, encodeSegmentFor(id));
+}
+async function locateSessionArtifacts2(sp, header) {
+  const root = resolveSessionRoot(sp);
+  if (!root || !header || header.id == null) return null;
+  const sid = String(header.id);
+  let sessionDir;
+  try {
+    sessionDir = deriveSessionDir(root, header.cwd, sid);
+  } catch (e) {
+    return null;
+  }
+  if (basename(sessionDir) !== encodeSegmentFor(sid)) return null;
+  let entries;
+  try {
+    const st = await stat(sessionDir);
+    if (!st.isDirectory()) return null;
+    entries = await readdir(sessionDir);
+  } catch (e) {
+    return null;
+  }
+  const generationFiles = entries.filter((name2) => GENERATION_LOG_RE.test(name2));
+  if (generationFiles.length === 0) return null;
+  generationFiles.sort((a, b) => {
+    const va = Number((a.match(/^session\.v(\d+)\./) || [])[1] || 0);
+    const vb = Number((b.match(/^session\.v(\d+)\./) || [])[1] || 0);
+    return vb - va;
+  });
+  const logPath = join4(sessionDir, generationFiles[0]);
+  if (!pathOwnsSession(logPath, sid)) return null;
+  return {
+    root,
+    projectDir: join4(root, header.cwd === void 0 || header.cwd === null || header.cwd === "" ? "_no-cwd" : projectKeyFor(header.cwd)),
+    sessionDir,
+    logPath,
+    generationFiles
+  };
+}
+
+// src/handle-era-ops.js
+var MOVE_BATCH = 400;
+function conflictError(message) {
+  const error = new Error(message);
+  error.status = 409;
+  error.code = "DSM_SESSION_BUSY";
+  return error;
+}
+function failureText(e) {
+  return `${e && e.name || ""} ${e && e.message || e}`;
+}
+function isAlreadyOwned(e) {
+  return /already owned/i.test(failureText(e));
+}
+function isAlreadyExists(e) {
+  return /already exists/i.test(failureText(e));
+}
+async function closeQuietly2(handle) {
+  try {
+    if (handle && typeof handle.close === "function") await handle.close();
+  } catch (e) {
+  }
+}
+async function ensureNoActiveWriter(sp, sid) {
+  let handle = null;
+  try {
+    handle = await sp.open(sid, "write");
+  } catch (e) {
+    if (isAlreadyOwned(e)) throw conflictError("\u8BE5\u4F1A\u8BDD\u6B63\u5728\u8FDB\u884C\u4E2D\uFF08\u5B58\u5728\u6D3B\u8DC3\u5199\u5165\uFF09\uFF0C\u8BF7\u5148\u5207\u6362\u5230\u522B\u7684\u4F1A\u8BDD\u518D\u64CD\u4F5C\u3002");
+    throw e;
+  }
+  await closeQuietly2(handle);
+}
+async function purgeSessionArtifacts(sp, sid, header) {
+  const artifacts = await locateSessionArtifacts2(sp, header);
+  if (!artifacts) {
+    const error = new Error("\u65E0\u6CD5\u5B9A\u4F4D\u8BE5\u4F1A\u8BDD\u7684\u7269\u7406\u65E5\u5FD7\u76EE\u5F55\uFF0C\u5DF2\u505C\u6B62\u6C38\u4E45\u5220\u9664");
+    error.status = 409;
+    throw error;
+  }
+  let writer = null;
+  try {
+    writer = await sp.open(sid, "write");
+  } catch (e) {
+    if (isAlreadyOwned(e)) throw conflictError("\u8BE5\u4F1A\u8BDD\u6B63\u5728\u8FDB\u884C\u4E2D\uFF08\u5B58\u5728\u6D3B\u8DC3\u5199\u5165\uFF09\uFF0C\u65E0\u6CD5\u5F7B\u5E95\u5220\u9664\u3002");
+    throw e;
+  }
+  await closeQuietly2(writer);
+  writer = null;
+  try {
+    await rm(artifacts.sessionDir, { recursive: true, force: true });
+  } catch (e) {
+    const error = new Error("\u5220\u9664\u4F1A\u8BDD\u65E5\u5FD7\u5931\u8D25\uFF1A" + String(e && e.message || e));
+    error.status = 500;
+    throw error;
+  }
+  if (typeof sp.stat === "function") {
+    const after = await sp.stat(sid).catch(() => void 0);
+    if (after) {
+      const error = new Error("\u5220\u9664\u540E\u5B98\u65B9 stat \u4ECD\u80FD\u770B\u5230\u8BE5\u4F1A\u8BDD\uFF0C\u5DF2\u4E2D\u6B62\uFF08\u76EE\u5F55\u53EF\u80FD\u88AB\u5E76\u53D1\u91CD\u5EFA\uFF09");
+      error.status = 500;
+      throw error;
+    }
+  }
+  return artifacts;
+}
+async function relocateRewrittenBackup({ sid, canonical, backupPath, artifacts }) {
+  const original = await readFile2(backupPath);
+  const frames = scanZstdFrames(original).frames;
+  if (frames.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 !== frames.length) throw new Error("\u79FB\u52A8\u540E\u6821\u9A8C\u5931\u8D25\uFF1A\u4F1A\u8BDD\u65E5\u5FD7\u5E27\u6570\u53D1\u751F\u53D8\u5316");
+  if (!original.subarray(frames[0].end).equals(rewritten.subarray(rewrittenFrames[0].end))) {
+    throw new Error("\u79FB\u52A8\u540E\u6821\u9A8C\u5931\u8D25\uFF1A\u4F1A\u8BDD\u4E8B\u4EF6\u5185\u5BB9\u53D1\u751F\u53D8\u5316");
+  }
+  const targetDir = deriveSessionDir(artifacts.root, canonical, sid);
+  await mkdir4(targetDir, { recursive: true });
+  const staged = join5(targetDir, `.move-stage-${process.pid}-${Date.now()}`);
+  await writeFile4(staged, rewritten, { mode: 384 });
+  await rename4(staged, join5(targetDir, artifacts.generationFiles[0]));
+  return targetDir;
+}
+async function moveSessionToCwd({ sp, sid, header, canonical, events = [], inheritedEventCount = 0 }) {
+  const artifacts = await locateSessionArtifacts2(sp, header);
+  if (!artifacts) {
+    const error = new Error("\u65E0\u6CD5\u5B9A\u4F4D\u8BE5\u4F1A\u8BDD\u7684\u7269\u7406\u65E5\u5FD7\uFF0C\u5DF2\u505C\u6B62\u79FB\u52A8");
+    error.status = 409;
+    throw error;
+  }
+  await ensureNoActiveWriter(sp, sid);
+  const newHeader = Object.assign({}, header, { cwd: canonical });
+  const firstSeq = events.length ? Number(events[0].seq) : 0;
+  const replay = firstSeq !== 0 ? events.map((event, index) => ({ ...event, seq: index })) : events;
+  const createOptions = header.isSeeded && Number.isSafeInteger(inheritedEventCount) && inheritedEventCount > 0 ? { inheritedEventCount } : void 0;
+  const backupPath = `${artifacts.logPath}.move-backup-${process.pid}-${Date.now()}`;
+  await rename4(artifacts.logPath, backupPath);
+  let writer = null;
+  try {
+    try {
+      writer = await sp.create(newHeader, createOptions);
+      for (let i = 0; i < replay.length; i += MOVE_BATCH) {
+        await writer.append(replay.slice(i, i + MOVE_BATCH));
+      }
+      await writer.flush();
+      await writer.close();
+      writer = null;
+    } catch (e) {
+      if (isAlreadyExists(e)) {
+        await relocateRewrittenBackup({ sid, canonical, backupPath, artifacts });
+      } else {
+        throw e;
+      }
+    }
+    if (typeof sp.stat !== "function") throw new Error("\u79FB\u52A8\u540E\u65E0\u6CD5\u6821\u9A8C\uFF1A\u540E\u7AEF\u672A\u63D0\u4F9B stat");
+    const after = await sp.stat(sid);
+    if (!after || !after.header || after.header.cwd !== canonical) {
+      throw new Error("\u79FB\u52A8\u540E\u6821\u9A8C\u5931\u8D25\uFF1A\u4F1A\u8BDD\u5DE5\u4F5C\u76EE\u5F55\u672A\u6B63\u786E\u66F4\u65B0");
+    }
+    if (Number.isSafeInteger(after.eventCount) && events.length > 0 && after.eventCount !== events.length) {
+      throw new Error(`\u79FB\u52A8\u540E\u6821\u9A8C\u5931\u8D25\uFF1A\u4E8B\u4EF6\u6570\u4E0D\u4E00\u81F4\uFF08\u6E90 ${events.length}\uFF0C\u526F\u672C ${after.eventCount}\uFF09`);
+    }
+  } catch (e) {
+    await closeQuietly2(writer);
+    try {
+      await rm(deriveSessionDir(artifacts.root, canonical, sid), { recursive: true, force: true });
+    } catch (_) {
+    }
+    try {
+      await rename4(backupPath, artifacts.logPath);
+    } catch (_) {
+    }
+    if (e && e.status) throw e;
+    const error = new Error("\u79FB\u52A8\u4F1A\u8BDD\u65E5\u5FD7\u5931\u8D25\uFF1A" + String(e && e.message || e));
+    error.status = 500;
+    throw error;
+  }
+  try {
+    await unlink(backupPath);
+  } catch (e) {
+  }
+  return { sessionDir: deriveSessionDir(artifacts.root, canonical, sid) };
+}
+
 // src/index.js
 var name = "dsh-sessions-manager";
 var inject = ["webServer", "workspaceRegistry", "sessionPersistence", "sessionQuery", "storageDomain"];
 var MAX_TITLE = 80;
-var TRASH_DIR = process.env.DSH_SESSIONS_MANAGER_TRASH_DIR || join4(homedir3(), ".dsh", "sessions-manager-trash");
-var TRASH_INDEX = join4(TRASH_DIR, "index.json");
+var TRASH_DIR = process.env.DSH_SESSIONS_MANAGER_TRASH_DIR || join6(homedir3(), ".dsh", "sessions-manager-trash");
+var TRASH_INDEX = join6(TRASH_DIR, "index.json");
 var TRASH_SCHEMA_VERSION = 2;
 var DEFAULT_TRASH_SETTINGS = Object.freeze({ retentionDays: 0 });
 var FETCH_TOOL_RE = /search|fetch|download|browse/i;
@@ -718,6 +1139,21 @@ function json(res, value, status = 200) {
 function errorStatus(error) {
   return error && Number.isInteger(error.status) ? error.status : 500;
 }
+function createLimiter(max) {
+  let active = 0;
+  const queue = [];
+  return async function run(fn) {
+    if (active >= max) await new Promise((resolve) => queue.push(resolve));
+    active++;
+    try {
+      return await fn();
+    } finally {
+      active--;
+      const next = queue.shift();
+      if (next) next();
+    }
+  };
+}
 async function readJsonBody(req) {
   const chunks = [];
   let total = 0;
@@ -791,7 +1227,7 @@ function apply(ctx) {
   const dom = () => ctx.storageDomain.get("workspace");
   const authorityTitleCache = /* @__PURE__ */ new Map();
   const metaCache = createSessionMetaCache();
-  const titleIndex = createTitleIndexStore({ dir: TRASH_DIR, file: join4(TRASH_DIR, "title-index.json") });
+  const titleIndex = createTitleIndexStore({ dir: TRASH_DIR, file: join6(TRASH_DIR, "title-index.json") });
   async function hydrateFromPersist(ids, statsById) {
     const hits = /* @__PURE__ */ new Map();
     if (!ids || !ids.length) return hits;
@@ -802,10 +1238,11 @@ function apply(ctx) {
       return hits;
     }
     for (const id of ids) {
-      const stat2 = statsById.get(id);
+      const stat3 = statsById.get(id);
       const entry = store && store[id];
-      if (!stat2 || !entry) continue;
-      const fp = fingerprintOf(stat2);
+      if (!stat3 || !entry) continue;
+      const fp = fingerprintOf(stat3);
+      if (!isPersistableFingerprint(fp)) continue;
       if (fp && entry.fingerprint === fp) {
         hits.set(id, { title: entry.title, cwd: entry.cwd, createdAt: entry.createdAt });
       }
@@ -818,7 +1255,7 @@ function apply(ctx) {
     const now = Date.now();
     for (const [id, meta] of decoded) {
       const fp = fingerprintOf(statsById.get(id));
-      if (!fp) continue;
+      if (!isPersistableFingerprint(fp)) continue;
       batch[id] = { title: meta.title, cwd: meta.cwd, createdAt: meta.createdAt, fingerprint: fp, updatedAt: now };
     }
     if (!Object.keys(batch).length) return;
@@ -897,26 +1334,42 @@ function apply(ctx) {
   }
   async function resolveOne(id, usage, opts = {}) {
     const key = String(id);
-    const statInfo = usage ? { mtimeMs: usage.mtimeById.get(key), size: usage.sizeById.get(key) } : null;
+    const statInfo = usage ? (usage.statsById ? usage.statsById.get(key) : null) || { mtimeMs: usage.mtimeById && usage.mtimeById.get(key), size: usage.sizeById && usage.sizeById.get(key) } : null;
     const cached = metaCache.get(key, statInfo);
     if (cached) return buildItem(key, cached, usage, opts.exposeUsage);
     let meta = { title: null, cwd: null, createdAt: null };
+    if (opts.listHeader) {
+      if (typeof opts.listHeader.cwd === "string") meta.cwd = opts.listHeader.cwd;
+      if (opts.listHeader.createdAt != null) meta.createdAt = opts.listHeader.createdAt;
+    }
     if (opts.preloaded !== void 0) {
-      meta = metaFromSnapshot(unwrapSnapshot(opts.preloaded));
+      const projected = metaFromSnapshot(unwrapSnapshot(opts.preloaded));
+      if (projected.title) meta.title = projected.title;
+      if (!meta.cwd && projected.cwd) meta.cwd = projected.cwd;
+      if (!meta.createdAt && projected.createdAt) meta.createdAt = projected.createdAt;
     } else if (typeof sq.readTitleSnapshot === "function") {
       try {
-        meta = metaFromSnapshot(await sq.readTitleSnapshot(id));
+        const projected = metaFromSnapshot(await sq.readTitleSnapshot(id));
+        if (projected.title) meta.title = projected.title;
+        if (!meta.cwd && projected.cwd) meta.cwd = projected.cwd;
+        if (!meta.createdAt && projected.createdAt) meta.createdAt = projected.createdAt;
       } catch (e) {
       }
     }
-    if (!meta.title || !meta.cwd) {
+    const projectionAvailable = typeof sq.readTitleSnapshot === "function" || typeof sq.readTitleSnapshots === "function";
+    if (!meta.cwd || !meta.title && !projectionAvailable) {
       try {
-        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;
+        let foldedTitle = null;
+        const summary = await persistence.inspectSession(key, {
+          onEvents: (events) => {
+            if (!foldedTitle) foldedTitle = foldTitle(events);
+          }
+        });
+        if (summary && summary.meta) {
+          if (!meta.cwd) meta.cwd = summary.meta.cwd || null;
+          if (!meta.createdAt) meta.createdAt = summary.meta.createdAt || null;
         }
-        if (!meta.title && Array.isArray(r.events)) meta.title = foldTitle(r.events);
+        if (!meta.title && foldedTitle) meta.title = foldedTitle;
       } catch (e2) {
       }
     }
@@ -924,11 +1377,12 @@ function apply(ctx) {
     if (opts.collectDecoded && statInfo) opts.collectDecoded(key, meta);
     return buildItem(key, meta, usage, opts.exposeUsage);
   }
-  async function collectUsage(preloadedHeaders) {
+  async function collectUsage(preloadedEntries) {
     const sizeById = /* @__PURE__ */ new Map();
     const mtimeById = /* @__PURE__ */ new Map();
+    const statsById = /* @__PURE__ */ new Map();
     let entries = null;
-    if (Array.isArray(preloadedHeaders)) entries = preloadedHeaders;
+    if (Array.isArray(preloadedEntries)) entries = preloadedEntries;
     else {
       try {
         entries = await persistence.listEntries();
@@ -943,19 +1397,27 @@ function apply(ctx) {
         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 && typeof entry.revision === "string" && entry.revision) {
+          if (Number.isFinite(entry.sizeBytes)) sizeById.set(id, Number(entry.sizeBytes));
+          statsById.set(id, { revision: entry.revision });
+          return;
+        }
         if (entry && Number.isFinite(entry.sizeBytes)) sizeById.set(id, Number(entry.sizeBytes));
         try {
           const loc = persistence.locate(header);
           if (!loc || typeof loc.path !== "string" || !loc.path) return;
-          const st = await stat(loc.path);
+          const st = await stat2(loc.path);
           if (!st) return;
           if (typeof st.size === "number") sizeById.set(id, st.size);
-          if (typeof st.mtimeMs === "number" && st.mtimeMs > 0) mtimeById.set(id, Math.floor(st.mtimeMs));
+          if (typeof st.mtimeMs === "number" && st.mtimeMs > 0) {
+            mtimeById.set(id, Math.floor(st.mtimeMs));
+            statsById.set(id, { mtimeMs: Math.floor(st.mtimeMs), size: typeof st.size === "number" ? st.size : void 0 });
+          }
         } catch (e) {
         }
       }));
     }
-    return { sizeById, mtimeById };
+    return { sizeById, mtimeById, statsById, hasActivityData: mtimeById.size > 0 };
   }
   async function restoreOne(sid) {
     requireSessionId(sid);
@@ -975,7 +1437,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);
     }
@@ -984,10 +1446,10 @@ function apply(ctx) {
     return (await readTrashStore()).items;
   }
   async function writeTrashStore(store) {
-    await mkdir4(TRASH_DIR, { recursive: true });
-    const tmp = join4(TRASH_DIR, `.index-${process.pid}-${Date.now()}.tmp`);
-    await writeFile4(tmp, JSON.stringify(normalizeTrashStore(store), null, 2), { encoding: "utf8", mode: 384 });
-    await rename4(tmp, TRASH_INDEX);
+    await mkdir5(TRASH_DIR, { recursive: true });
+    const tmp = join6(TRASH_DIR, `.index-${process.pid}-${Date.now()}.tmp`);
+    await writeFile5(tmp, JSON.stringify(normalizeTrashStore(store), null, 2), { encoding: "utf8", mode: 384 });
+    await rename5(tmp, TRASH_INDEX);
   }
   function mutateTrash(mutator) {
     const operation = trashMutation.then(async () => {
@@ -1030,10 +1492,28 @@ function apply(ctx) {
         title = header.title || header.meta && header.meta.title || null;
       }
       if (!title) {
-        const r = await persistence.readSession(sid, 0);
-        if (r && r.meta) {
-          if (!cwd) cwd = r.meta.cwd;
-          title = foldTitle(r.events);
+        if (typeof sq.readTitleSnapshot === "function") {
+          try {
+            const snap = unwrapSnapshot(await sq.readTitleSnapshot(sid));
+            if (snap && snap.title && snap.title.title) title = String(snap.title.title);
+            if (snap && snap.session) {
+              if (!cwd) cwd = snap.session.cwd || null;
+            }
+          } catch (e) {
+          }
+        }
+      }
+      if (!title) {
+        try {
+          let folded = null;
+          const summary = await persistence.inspectSession(sid, {
+            onEvents: (events) => {
+              if (!folded) folded = foldTitle(events);
+            }
+          });
+          if (summary && summary.meta && !cwd) cwd = summary.meta.cwd || null;
+          title = folded;
+        } catch (e) {
         }
       }
     } catch (e) {
@@ -1062,20 +1542,96 @@ function apply(ctx) {
     });
     return { ok: true, trashed: true };
   }
+  async function verifyTrashRestore(sid) {
+    const sessions = ctx.get("sessions");
+    if (sessions && sessions.get && sessions.get(sid)) {
+      return { ok: true, workspaceGone: false, verified: true };
+    }
+    let exists = false;
+    let header = null;
+    try {
+      const stat3 = await persistence.statSession(sid);
+      if (stat3) {
+        exists = true;
+        header = stat3.header;
+      }
+    } catch (e) {
+    }
+    if (!exists) {
+      try {
+        const entries = await persistence.listEntries();
+        const found = entries.find((entry2) => entry2.id === sid);
+        if (found) {
+          exists = true;
+          header = found.header;
+        }
+      } catch (e) {
+      }
+    }
+    if (!exists) {
+      const store2 = await readTrashStore();
+      if (store2.purgedSessionIds.map(String).includes(sid)) {
+        return { ok: false, status: 410, code: "DSM_SESSION_PURGED", message: "\u8BE5\u4F1A\u8BDD\u5DF2\u5F7B\u5E95\u5220\u9664\uFF0C\u65E0\u6CD5\u4ECE\u56DE\u6536\u7AD9\u6062\u590D" };
+      }
+      return { ok: false, status: 409, code: "DSM_SESSION_MISSING", message: "\u5E95\u5C42\u4F1A\u8BDD\u5DF2\u4E0D\u5B58\u5728\uFF08\u53EF\u80FD\u88AB\u5916\u90E8\u5220\u9664\u6216\u91CD\u5EFA\uFF09\uFF0C\u65E0\u6CD5\u6062\u590D" };
+    }
+    let verified = false;
+    const store = await readTrashStore();
+    const entry = store.items.find((t) => String(t.sessionId) === sid);
+    let originalPath = entry && typeof entry.originalPath === "string" ? entry.originalPath : null;
+    if (!originalPath && header) {
+      const loc = persistence.locate(header);
+      if (loc && typeof loc.path === "string") originalPath = loc.path;
+    }
+    if (originalPath) {
+      const existsOnDisk = await stat2(originalPath).then(() => true).catch(() => false);
+      if (!existsOnDisk) {
+        return { ok: false, status: 409, code: "DSM_SESSION_LOG_MISSING", message: "\u56DE\u6536\u7AD9\u7D22\u5F15\u4ECD\u8BB0\u5F55\u8BE5\u4F1A\u8BDD\uFF0C\u4F46\u5176\u65E5\u5FD7\u6587\u4EF6\u5DF2\u6D88\u5931\uFF08\u53EF\u80FD\u88AB\u5916\u90E8\u79FB\u52A8\u6216\u5220\u9664\uFF09" };
+      }
+      verified = true;
+    }
+    let workspaceGone = false;
+    const cwd = header && header.cwd || entry && entry.cwd || null;
+    if (cwd) {
+      try {
+        workspaceGone = !w.list().some((ent) => ent.path === cwd);
+      } catch (e) {
+        workspaceGone = false;
+      }
+    }
+    return { ok: true, workspaceGone, verified };
+  }
   async function restoreFromTrash(sid) {
     requireSessionId(sid);
+    requireCapability(capabilities, "restoreIndexedSession");
+    let outcome = null;
     await mutateTrash(async (store) => {
       const entry = store.items.find((t) => String(t.sessionId) === sid);
       if (!entry) {
-        const error = new Error("\u56DE\u6536\u7AD9\u4E2D\u627E\u4E0D\u5230\u8BE5\u4F1A\u8BDD");
+        if (store.purgedSessionIds.map(String).includes(sid)) {
+          const error2 = new Error("\u8BE5\u4F1A\u8BDD\u5DF2\u5F7B\u5E95\u5220\u9664\uFF0C\u65E0\u6CD5\u4ECE\u56DE\u6536\u7AD9\u6062\u590D");
+          error2.status = 410;
+          error2.code = "DSM_SESSION_PURGED";
+          throw error2;
+        }
+        const error = new Error("\u56DE\u6536\u7AD9\u4E2D\u627E\u4E0D\u5230\u8BE5\u4F1A\u8BDD\uFF08\u53EF\u80FD\u5DF2\u6062\u590D\u8FC7\uFF09");
         error.status = 404;
+        error.code = "DSM_TRASH_NOT_FOUND";
+        throw error;
+      }
+      const verification = await verifyTrashRestore(sid);
+      if (!verification.ok) {
+        const error = new Error(verification.message);
+        error.status = verification.status;
+        error.code = verification.code;
         throw error;
       }
       if (entry.wasArchived === false) await restoreOne(sid);
       store.items = store.items.filter((t) => String(t.sessionId) !== sid);
       store.purgedSessionIds = store.purgedSessionIds.filter((id) => id !== sid);
+      outcome = { ok: true, restored: true, workspaceGone: verification.workspaceGone, verified: verification.verified };
     });
-    return { ok: true, restored: true };
+    return outcome || { ok: true, restored: true };
   }
   async function purgeFromTrash(sid) {
     requireSessionId(sid);
@@ -1102,7 +1658,7 @@ function apply(ctx) {
         error.status = 409;
         throw error;
       }
-      const targetOwnsSession = target && (basename(dirname2(target)) === sid || basename(target).includes(sid));
+      const targetOwnsSession = pathOwnsSession(target, 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");
         error.status = 409;
@@ -1124,9 +1680,11 @@ function apply(ctx) {
         error.status = 409;
         throw error;
       }
-      if (target) {
+      if (target && persistence.kind === "session-handle" && locatedHeader) {
+        await purgeSessionArtifacts(sp, sid, locatedHeader);
+      } else if (target) {
         try {
-          await unlink(target);
+          await unlink2(target);
         } catch (e) {
           if (e && e.code !== "ENOENT") throw new Error("\u5220\u9664\u6587\u4EF6\u5931\u8D25\uFF1A" + String(e && e.message || e));
         }
@@ -1196,8 +1754,8 @@ function apply(ctx) {
   async function moveTargetWorkspace(rawPath) {
     if (typeof rawPath !== "string" || !rawPath.trim()) throw new Error("\u7F3A\u5C11\u76EE\u6807\u5DE5\u4F5C\u533A\u8DEF\u5F84");
     let p = String(rawPath).trim();
-    if (p.startsWith("~/")) p = join4(homedir3(), p.slice(2));
-    if (!isAbsolute(p)) p = join4(homedir3(), p);
+    if (p.startsWith("~/")) p = join6(homedir3(), p.slice(2));
+    if (!isAbsolute(p)) p = join6(homedir3(), p);
     let canonical = null;
     try {
       canonical = await realpath(p);
@@ -1205,10 +1763,10 @@ function apply(ctx) {
       canonical = null;
     }
     if (canonical === null) {
-      await mkdir4(p, { recursive: true });
+      await mkdir5(p, { recursive: true });
       canonical = await realpath(p);
     }
-    return { canonical, entity: await w.create(canonical, basename(canonical) || "workspace") };
+    return { canonical, entity: await w.create(canonical, basename2(canonical) || "workspace") };
   }
   async function moveOne(sid, targetPath) {
     requireCapability(capabilities, "move");
@@ -1243,14 +1801,43 @@ 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 });
-        await rename4(oldPath, backupPath);
-        await rewriteFrame0Cwd(backupPath, canonical);
-        await rename4(backupPath, newPath);
+        await mkdir5(dirname2(newPath), { recursive: true });
+        try {
+          await stat2(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 rename5(oldPath, backupPath);
+        const original = await readFile3(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 writeFile5(stagedPath, rewritten, { mode: 384 });
+        await rename5(stagedPath, newPath);
+        destinationInstalled = true;
+        await unlink2(backupPath);
       } catch (e) {
         try {
-          await rename4(backupPath, oldPath);
+          await unlink2(stagedPath);
+        } catch (_) {
+        }
+        if (destinationInstalled) {
+          try {
+            await unlink2(newPath);
+          } catch (_) {
+          }
+        }
+        try {
+          await rename5(backupPath, oldPath);
         } catch (_) {
         }
         if (e && e.code !== "ENOENT") throw e;
@@ -1274,7 +1861,21 @@ function apply(ctx) {
       }
       return null;
     };
-    if (isOpen) {
+    if (persistence.kind === "session-handle") {
+      const stat1 = await persistence.statSession(sid);
+      if (stat1 && stat1.revision) {
+        const stat22 = await persistence.statSession(sid);
+        if (stat22 && stat22.revision !== stat1.revision) {
+          throw new Error("\u8BE5\u4F1A\u8BDD\u5728\u79FB\u52A8\u51C6\u5907\u671F\u95F4\u53D1\u751F\u4E86\u53D8\u5316\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002");
+        }
+      }
+      try {
+        await moveSessionToCwd({ sp, sid, header: meta, canonical, events, inheritedEventCount: r.inheritedEventCount });
+      } catch (e) {
+        if (e && e.status) throw e;
+        throw new Error("\u79FB\u52A8\u4F1A\u8BDD\u65E5\u5FD7\u5931\u8D25\uFF1A" + String(e && e.message || e));
+      }
+    } else if (isOpen) {
       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);
@@ -1296,7 +1897,7 @@ function apply(ctx) {
         const backupPath = oldPath ? `${oldPath}.move-backup-${Date.now()}` : null;
         if (backupPath) {
           try {
-            await rename4(oldPath, backupPath);
+            await rename5(oldPath, backupPath);
           } catch (e) {
             if (e && e.code !== "ENOENT") throw new Error("\u79FB\u52A8\u5931\u8D25\uFF1A\u65E0\u6CD5\u5907\u4EFD\u65E7\u7684\u4F1A\u8BDD\u65E5\u5FD7");
           }
@@ -1304,7 +1905,7 @@ function apply(ctx) {
         const restore = async () => {
           if (backupPath) {
             try {
-              await rename4(backupPath, oldPath);
+              await rename5(backupPath, oldPath);
             } catch (_) {
             }
           }
@@ -1318,7 +1919,7 @@ function apply(ctx) {
           }
           if (backupPath) {
             try {
-              await unlink(backupPath);
+              await unlink2(backupPath);
             } catch (e) {
             }
           }
@@ -1413,7 +2014,7 @@ function apply(ctx) {
     }
     return out;
   }
-  async function allSessionItems(opts = {}) {
+  async function allSessionItemsDetailed(opts = {}) {
     let entries = [];
     let headersOk = false;
     try {
@@ -1423,6 +2024,7 @@ function apply(ctx) {
     } catch (e) {
       entries = [];
     }
+    const entryById = new Map(entries.map((entry) => [entry.id, entry]));
     let live = ctx.get("sessions");
     const ids = entries.map((entry) => entry.id);
     if (live) {
@@ -1437,7 +2039,11 @@ function apply(ctx) {
     let hiddenIds = /* @__PURE__ */ new Set();
     try {
       const store = await readTrashStore();
-      hiddenIds = /* @__PURE__ */ new Set([...store.items.map((t) => String(t.sessionId)), ...store.purgedSessionIds.map(String)]);
+      const present = new Set(ids);
+      hiddenIds = /* @__PURE__ */ new Set([
+        ...store.items.map((t) => String(t.sessionId)),
+        ...store.purgedSessionIds.map(String).filter((id) => !present.has(id))
+      ]);
     } catch (e) {
     }
     const visibleIds = ids.filter((id) => !hiddenIds.has(id));
@@ -1450,8 +2056,11 @@ function apply(ctx) {
     const currentArchived = new Set((await archivedState().catch(() => ({ archivedSessionIds: [] }))).archivedSessionIds || []);
     const items = [];
     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 statsById = new Map(visibleIds.map((id) => [
+      id,
+      usage.statsById && usage.statsById.get(id) || { mtimeMs: usage.mtimeById.get(id), size: usage.sizeById.get(id) }
+    ]));
+    const { missing } = metaCache.partition(visibleIds, statsById);
     const persisted = await hydrateFromPersist(missing, statsById);
     for (const [id, meta] of persisted) metaCache.set(id, statsById.get(id), meta);
     const stillMissing = missing.filter((id) => !persisted.has(id));
@@ -1462,11 +2071,15 @@ function apply(ctx) {
     };
     const CHUNK = 6;
     for (let i = 0; i < visibleIds.length; i += CHUNK) {
-      const res2 = await Promise.all(visibleIds.slice(i, i + CHUNK).map((id) => resolveOne(id, usage, {
-        exposeUsage: !!(opts && opts.usage),
-        preloaded: snapshotById.has(id) ? snapshotById.get(id) : void 0,
-        collectDecoded
-      })));
+      const res2 = await Promise.all(visibleIds.slice(i, i + CHUNK).map((id) => {
+        const entry = entryById.get(id);
+        return resolveOne(id, usage, {
+          exposeUsage: !!(opts && opts.usage),
+          listHeader: entry ? entry.header : null,
+          preloaded: snapshotById.has(id) ? snapshotById.get(id) : void 0,
+          collectDecoded
+        });
+      }));
       for (const it of res2) items.push({ ...it, archived: currentArchived.has(it.sessionId) });
     }
     persistDecoded(decoded, statsById);
@@ -1477,7 +2090,10 @@ function apply(ctx) {
     }
     for (const it of items) it.starred = starredSet.has(String(it.sessionId));
     if (headersOk) await gcStars(ids);
-    return items;
+    return { items, usage };
+  }
+  async function allSessionItems(opts = {}) {
+    return (await allSessionItemsDetailed(opts)).items;
   }
   async function buildStorage(opts = {}) {
     const items = await allSessionItems({ usage: true });
@@ -1493,7 +2109,15 @@ function apply(ctx) {
     if (!(opts && opts.force) && autoArchive.isFresh(store, now)) {
       return { ok: true, skipped: "throttled", archived: 0, lastRunAt: store.lastRunAt, lastArchivedCount: store.lastArchivedCount };
     }
-    const items = await allSessionItems({ usage: true });
+    const { items, usage } = await allSessionItemsDetailed({ usage: true });
+    if (!usage.hasActivityData) {
+      return {
+        ok: true,
+        skipped: "no-activity-data",
+        archived: 0,
+        note: "\u5F53\u524D DSH \u7248\u672C\u672A\u63D0\u4F9B\u53EF\u9760\u7684\u6700\u540E\u6D3B\u8DC3\u65F6\u95F4\uFF0C\u81EA\u52A8\u5F52\u6863\u5DF2\u8DF3\u8FC7\uFF1B\u4E0D\u4F1A\u57FA\u4E8E\u731C\u6D4B\u5F52\u6863\u4EFB\u4F55\u4F1A\u8BDD\u3002"
+      };
+    }
     const candidates = pickInactiveCandidates(items, {
       inactiveDays: days,
       skipStarred: store.settings.skipStarred,
@@ -1532,9 +2156,14 @@ function apply(ctx) {
     } catch (e) {
     }
     const store = await readTrashStore();
+    const present = new Set(ids);
+    const activeTombstones = store.purgedSessionIds.map(String).filter((id) => !present.has(id));
     if (ids.length) {
       const usage = await collectUsage(entries);
-      const statsById = new Map(ids.map((id) => [id, { mtimeMs: usage.mtimeById.get(id), size: usage.sizeById.get(id) }]));
+      const statsById = new Map(ids.map((id) => [
+        id,
+        usage.statsById && usage.statsById.get(id) || { mtimeMs: usage.mtimeById.get(id), size: usage.sizeById.get(id) }
+      ]));
       const { cached, missing } = metaCache.partition(ids, statsById);
       const persisted = await hydrateFromPersist(missing, statsById);
       for (const [id, meta] of persisted) metaCache.set(id, statsById.get(id), meta);
@@ -1547,8 +2176,13 @@ function apply(ctx) {
       for (const id of ids) {
         let meta = cached.get(id) || persisted.get(id) || null;
         if (!meta) {
+          const entry = entries.find((e) => e.id === id);
           const snapshot = snapshotById.has(id) ? snapshotById.get(id) : typeof sq.readTitleSnapshot === "function" ? await sq.readTitleSnapshot(id).catch(() => null) : null;
           const next = metaFromSnapshot(snapshot);
+          if (entry && entry.header) {
+            if (!next.cwd && typeof entry.header.cwd === "string") next.cwd = entry.header.cwd;
+            if (!next.createdAt && entry.header.createdAt != null) next.createdAt = entry.header.createdAt;
+          }
           metaCache.set(id, statsById.get(id), next);
           if (statsById.get(id)) collectDecoded(id, next);
           meta = next;
@@ -1560,38 +2194,14 @@ function apply(ctx) {
     return {
       titles: Object.fromEntries(authorityTitleCache),
       trashedSessionIds: store.items.map((item) => String(item.sessionId)),
-      purgedSessionIds: store.purgedSessionIds.map(String)
+      purgedSessionIds: activeTombstones
     };
   }
-  async function buildDetails(sid) {
+  async function buildDetails(sid, signal) {
     const sessions = ctx.get("sessions");
     const live = sessions && sessions.get(sid);
     let meta = null;
-    let events = [];
-    if (live !== void 0) {
-      meta = live && live.header || null;
-      try {
-        events = Array.isArray(live.events) ? [...live.events] : [];
-      } catch (e) {
-        events = [];
-      }
-    } else {
-      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 = 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;
-      }
-    } catch (e) {
-      sizeBytes = null;
-    }
-    let lastTime = typeof meta.createdAt === "number" ? meta.createdAt : 0;
+    let lastTime = 0;
     const fileSet = /* @__PURE__ */ new Map();
     const stats = {
       turns: 0,
@@ -1605,7 +2215,7 @@ function apply(ctx) {
     };
     const turnSeen = /* @__PURE__ */ new Set();
     const stepSeen = /* @__PURE__ */ new Set();
-    for (const ev of events) {
+    const absorb = (ev) => {
       if (ev && typeof ev.time === "number" && ev.time > lastTime) lastTime = ev.time;
       const d = ev && ev.data && typeof ev.data === "object" ? ev.data : {};
       const type = ev && ev.type;
@@ -1652,12 +2262,44 @@ function apply(ctx) {
           break;
         }
       }
+    };
+    if (live !== void 0) {
+      meta = live && live.header || null;
+      try {
+        (Array.isArray(live.events) ? [...live.events] : []).forEach(absorb);
+      } catch (e) {
+      }
+    } else {
+      const summary = await persistence.inspectSession(sid, { signal, onEvents: (batch) => {
+        for (const ev of batch) absorb(ev);
+      } });
+      if (!summary || !summary.meta) throw new Error("\u627E\u4E0D\u5230\u8BE5\u4F1A\u8BDD\u7684\u8BB0\u5F55\uFF08\u4F1A\u8BDD\u4E0D\u5B58\u5728\uFF09");
+      meta = summary.meta;
     }
     stats.turns = turnSeen.size;
     stats.steps = stepSeen.size;
+    let sizeBytes = null;
+    if (live === void 0) {
+      try {
+        const stat3 = await persistence.statSession(sid);
+        if (stat3 && Number.isFinite(stat3.sizeBytes)) sizeBytes = stat3.sizeBytes;
+      } catch (e) {
+      }
+    }
+    if (sizeBytes === null) {
+      try {
+        const loc = persistence.locate(meta);
+        if (loc && typeof loc.path === "string" && loc.path) {
+          const st = await stat2(loc.path);
+          if (st && typeof st.size === "number") sizeBytes = st.size;
+        }
+      } catch (e) {
+        sizeBytes = null;
+      }
+    }
     if (stats.fetches.length > MAX_FETCHES) stats.fetches = stats.fetches.slice(0, MAX_FETCHES);
     const fileEntries = [...fileSet.entries()].slice(0, MAX_FILES * 2);
-    const exists = await Promise.all(fileEntries.map(([p]) => stat(p).then(() => true).catch(() => false)));
+    const exists = await Promise.all(fileEntries.map(([p]) => stat2(p).then(() => true).catch(() => false)));
     const files = fileEntries.filter((_, i) => exists[i]).map(([path, tool]) => ({ path, tool })).slice(0, MAX_FILES);
     const lineage = {
       parentSessionId: meta && typeof meta.parentSession === "string" ? meta.parentSession : null,
@@ -1693,7 +2335,7 @@ function apply(ctx) {
       sessionId: sid,
       sizeBytes,
       createdAt: meta && typeof meta.createdAt === "number" ? meta.createdAt : null,
-      updatedAt: lastTime || null,
+      updatedAt: Math.max(lastTime || 0, meta && typeof meta.createdAt === "number" ? meta.createdAt : 0) || null,
       files,
       stats,
       lineage
@@ -1726,7 +2368,13 @@ function apply(ctx) {
           } catch (e) {
           }
           const trashStore = await readTrashStore();
-          const hidden = /* @__PURE__ */ new Set([...trashStore.items.map((item) => String(item.sessionId)), ...trashStore.purgedSessionIds.map(String)]);
+          const present = /* @__PURE__ */ new Set([
+            ...materialized,
+            ...ids.map(String),
+            ...live && typeof live.list === "function" ? live.list().map((s) => String(s.id)) : []
+          ]);
+          const tombstones = trashStore.purgedSessionIds.map(String).filter((id) => !present.has(id));
+          const hidden = /* @__PURE__ */ new Set([...trashStore.items.map((item) => String(item.sessionId)), ...tombstones]);
           const idStrs = ids.map(String).filter((id) => !hidden.has(id) && (materialized.has(id) || live && live.get(id)));
           wsByPath = {};
           try {
@@ -1859,7 +2507,7 @@ function apply(ctx) {
             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);
+            const exists = await stat2(item.originalPath).then(() => true).catch(() => false);
             return { sessionId: item.sessionId, status: exists ? "ok" : "missing", originalPath: item.originalPath };
           }));
           json(res, {
@@ -1963,6 +2611,7 @@ function apply(ctx) {
         }
       }
     }));
+    const exportLimiter = createLimiter(2);
     disposers.push(ctx.webServer.register({
       kind: "exact",
       path: "/archived-sessions/export-md",
@@ -1971,13 +2620,23 @@ function apply(ctx) {
           const url = new URL(req.url, "http://localhost");
           const sid = url.searchParams.get("sessionId");
           requireSessionId(sid);
-          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;
-            throw error;
-          }
-          const md = renderSessionMarkdown({ ...r.meta, id: sid }, r.events || []);
+          const ac = new AbortController();
+          res.on("close", () => {
+            if (!res.writableEnded) ac.abort();
+          });
+          const md = await exportLimiter(async () => {
+            const builder = createSessionMarkdownBuilder({ id: sid });
+            const summary = await persistence.inspectSession(sid, {
+              signal: ac.signal,
+              onEvents: (batch) => builder.addEvents(batch)
+            });
+            if (!summary || !summary.meta) {
+              const error = new Error("\u65E0\u6CD5\u8BFB\u53D6\u8BE5\u4F1A\u8BDD\u7684\u65E5\u5FD7");
+              error.status = 404;
+              throw error;
+            }
+            return builder.finish({ ...summary.meta, id: sid });
+          });
           res.writeHead(200, {
             "content-type": "text/markdown; charset=utf-8",
             "content-disposition": `attachment; filename="dsh-session-${sid}.md"`,
@@ -2077,7 +2736,11 @@ function apply(ctx) {
           const body = await readJsonBody(req);
           const sid = body && typeof body.sessionId === "string" ? body.sessionId : null;
           if (!sid) return json(res, { ok: false, error: "missing sessionId" }, 400);
-          json(res, await buildDetails(sid));
+          const ac = new AbortController();
+          res.on("close", () => {
+            if (!res.writableEnded) ac.abort();
+          });
+          json(res, await buildDetails(sid, ac.signal));
         } catch (e) {
           json(res, { error: String(e && e.message || e) }, e && e.status ? e.status : 500);
         }