dsh-sessions-manager 3.5.4 → 3.6.1

package/lib/index.js

@@ -1,8 +1,8 @@
 // src/index.js
-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";
+import { mkdir as mkdir6, readFile as readFile3, readdir as readdir4, realpath, rename as rename6, rm as rm3, stat as stat4, unlink, writeFile as writeFile6 } from "node:fs/promises";
+import { basename as basename3, dirname as dirname3, isAbsolute, join as join8 } from "node:path";
+import { readFileSync as readFileSync4 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
 
 // src/zstd-frame.js
 import zlib from "node:zlib";
@@ -303,6 +303,138 @@ function createStarIndex(options = {}) {
   return { read, write, mutate, setStarred, removeIds, indexPath, dir };
 }
 
+// src/pending-moves.js
+import { readFileSync as readFileSync2 } from "node:fs";
+import { mkdir as mkdir2, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+var SCHEMA_VERSION = 1;
+var DEFAULT_DIR = process.env.DSH_SESSIONS_MANAGER_PENDING_DIR || process.env.DSH_SESSIONS_MANAGER_STAR_DIR || join2(homedir2(), ".dsh", "sessions-manager");
+var MAX_ITEMS = 50;
+var MAX_ATTEMPTS = 5;
+function isSafeId(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 200;
+}
+function normalizeStore(raw) {
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  const source = raw && Array.isArray(raw.items) ? raw.items : [];
+  for (const item of source) {
+    if (!item || !isSafeId(item.sessionId) || typeof item.targetPath !== "string" || item.targetPath.length === 0) continue;
+    if (seen.has(item.sessionId)) continue;
+    seen.add(item.sessionId);
+    items.push({
+      sessionId: String(item.sessionId),
+      targetPath: String(item.targetPath),
+      queuedAt: Number.isFinite(item.queuedAt) ? Number(item.queuedAt) : Date.now(),
+      attempts: Number.isSafeInteger(item.attempts) && item.attempts >= 0 ? Number(item.attempts) : 0
+    });
+    if (items.length >= MAX_ITEMS) break;
+  }
+  return { schemaVersion: SCHEMA_VERSION, items };
+}
+function createPendingMoveStore(options = {}) {
+  const dir = options.dir || DEFAULT_DIR;
+  const indexPath = options.indexPath || join2(dir, "pending-moves.json");
+  let mutation = Promise.resolve();
+  async function read() {
+    try {
+      return normalizeStore(JSON.parse(readFileSync2(indexPath, "utf8")));
+    } catch (e) {
+      return normalizeStore(null);
+    }
+  }
+  async function write(store) {
+    await mkdir2(dir, { recursive: true });
+    const tmp = join2(dir, `.pending-moves-${process.pid}-${Date.now()}.tmp`);
+    await writeFile2(tmp, JSON.stringify(normalizeStore(store), null, 2), { encoding: "utf8", mode: 384 });
+    await rename2(tmp, indexPath);
+  }
+  function mutate(mutator) {
+    const operation = mutation.then(async () => {
+      const store = await read();
+      const result = await mutator(store);
+      await write(store);
+      return result;
+    });
+    mutation = operation.catch(() => {
+    });
+    return operation;
+  }
+  return {
+    indexPath,
+    dir,
+    list: async () => (await read()).items,
+    has: async (sessionId) => (await read()).items.some((item) => item.sessionId === String(sessionId)),
+    queue: (sessionId, targetPath) => mutate((store) => {
+      if (!isSafeId(sessionId) || typeof targetPath !== "string" || targetPath.length === 0) return null;
+      const existing = store.items.find((item2) => item2.sessionId === String(sessionId));
+      if (existing) {
+        existing.targetPath = String(targetPath);
+        existing.attempts = 0;
+        return existing;
+      }
+      const item = { sessionId: String(sessionId), targetPath: String(targetPath), queuedAt: Date.now(), attempts: 0 };
+      store.items.push(item);
+      if (store.items.length > MAX_ITEMS) store.items.splice(0, store.items.length - MAX_ITEMS);
+      return item;
+    }),
+    remove: (sessionIds) => mutate((store) => {
+      const drop = new Set((Array.isArray(sessionIds) ? sessionIds : [sessionIds]).filter(isSafeId).map(String));
+      const before = store.items.length;
+      store.items = store.items.filter((item) => !drop.has(item.sessionId));
+      return before - store.items.length;
+    }),
+    bumpAttempts: (sessionId) => mutate((store) => {
+      const item = store.items.find((entry) => entry.sessionId === String(sessionId));
+      if (!item) return null;
+      item.attempts += 1;
+      if (item.attempts >= MAX_ATTEMPTS) {
+        store.items = store.items.filter((entry) => entry.sessionId !== item.sessionId);
+        return { dropped: true, attempts: item.attempts };
+      }
+      return { dropped: false, attempts: item.attempts };
+    })
+  };
+}
+
+// src/state-temp-sweep.js
+import { readdir, rm, stat } from "node:fs/promises";
+import { join as join3 } from "node:path";
+var TEMP_NAME_RE = /^\..+-\d+-\d+\.tmp$/;
+async function sweepStaleStateTemps(dirs, options = {}) {
+  const maxAgeMs = Number.isSafeInteger(options.maxAgeMs) && options.maxAgeMs >= 0 ? options.maxAgeMs : 36e5;
+  const now = Number.isFinite(options.now) ? options.now : Date.now();
+  let removed = 0;
+  for (const dir of Array.isArray(dirs) ? dirs : []) {
+    if (typeof dir !== "string" || dir.length === 0) continue;
+    let entries;
+    try {
+      entries = await readdir(dir);
+    } catch (e) {
+      continue;
+    }
+    for (const name2 of entries) {
+      if (!TEMP_NAME_RE.test(name2)) continue;
+      const path = join3(dir, name2);
+      let info;
+      try {
+        info = await stat(path);
+      } catch (e) {
+        continue;
+      }
+      if (!info.isFile()) continue;
+      if (now - info.mtimeMs < maxAgeMs) continue;
+      try {
+        await rm(path, { force: true });
+        removed++;
+      } catch (e) {
+      }
+    }
+  }
+  return removed;
+}
+
 // src/storage-stats.js
 var UNGROUPED_KEY = "__ungrouped__";
 function isFiniteSize(value) {
@@ -355,15 +487,15 @@ 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 readFileSync2 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { join as join2 } from "node:path";
+import { mkdir as mkdir3, rename as rename3, writeFile as writeFile3 } from "node:fs/promises";
+import { readFileSync as readFileSync3 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join4 } from "node:path";
 var AUTO_ARCHIVE_SCHEMA_VERSION = 4;
 var INACTIVE_DAY_OPTIONS = Object.freeze([0, 30, 60, 90]);
 var DAY_MS = 864e5;
 var RUN_INTERVAL_MS = DAY_MS;
-var DEFAULT_DIR = join2(homedir2(), ".dsh", "sessions-manager");
+var DEFAULT_DIR2 = join4(homedir3(), ".dsh", "sessions-manager");
 function normalizeAutoArchiveStore(raw) {
   const source = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
   const settings = source.settings && typeof source.settings === "object" ? source.settings : {};
@@ -407,21 +539,21 @@ function pickInactiveCandidates(items, options = {}) {
   return out;
 }
 function createAutoArchiveStore(options = {}) {
-  const dir = options.dir || process.env.DSH_SESSIONS_MANAGER_AUTO_ARCHIVE_DIR || DEFAULT_DIR;
-  const indexPath = options.indexPath || join2(dir, "auto-archive.json");
+  const dir = options.dir || process.env.DSH_SESSIONS_MANAGER_AUTO_ARCHIVE_DIR || DEFAULT_DIR2;
+  const indexPath = options.indexPath || join4(dir, "auto-archive.json");
   let mutation = Promise.resolve();
   async function read() {
     try {
-      return normalizeAutoArchiveStore(JSON.parse(readFileSync2(indexPath, "utf8")));
+      return normalizeAutoArchiveStore(JSON.parse(readFileSync3(indexPath, "utf8")));
     } catch {
       return normalizeAutoArchiveStore(null);
     }
   }
   async function write(store) {
-    await mkdir2(dir, { recursive: true });
-    const tmp = join2(dir, `.auto-archive-${process.pid}-${Date.now()}.tmp`);
-    await writeFile2(tmp, JSON.stringify(normalizeAutoArchiveStore(store), null, 2), { encoding: "utf8", mode: 384 });
-    await rename2(tmp, indexPath);
+    await mkdir3(dir, { recursive: true });
+    const tmp = join4(dir, `.auto-archive-${process.pid}-${Date.now()}.tmp`);
+    await writeFile3(tmp, JSON.stringify(normalizeAutoArchiveStore(store), null, 2), { encoding: "utf8", mode: 384 });
+    await rename3(tmp, indexPath);
   }
   function mutate(mutator) {
     const operation = mutation.then(async () => {
@@ -468,13 +600,13 @@ function createAutoArchiveStore(options = {}) {
 var DEFAULT_TTL_MS = 5 * 60 * 1e3;
 var DEFAULT_MAX = 4e3;
 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;
+function fingerprintOf(stat5) {
+  if (!stat5 || typeof stat5 !== "object") return null;
+  if (typeof stat5.revision === "string" && stat5.revision.length > 0) {
+    return REVISION_PREFIX + stat5.revision;
   }
-  const mtimeMs = stat3.mtimeMs;
-  const size = stat3.size;
+  const mtimeMs = stat5.mtimeMs;
+  const size = stat5.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}`;
@@ -482,9 +614,15 @@ function fingerprintOf(stat3) {
 function isPersistableFingerprint(fingerprint) {
   return typeof fingerprint === "string" && fingerprint !== "" && !fingerprint.startsWith(REVISION_PREFIX);
 }
-function isFresh(entry, stat3, now, ttlMs = DEFAULT_TTL_MS) {
+function persistFingerprintOf(stat5) {
+  const fp = fingerprintOf(stat5);
+  if (fp && isPersistableFingerprint(fp)) return fp;
+  if (stat5 && Number.isFinite(stat5.sizeBytes) && stat5.sizeBytes >= 0) return `sz:${stat5.sizeBytes}`;
+  return null;
+}
+function isFresh(entry, stat5, now, ttlMs = DEFAULT_TTL_MS) {
   if (!entry) return false;
-  const fp = fingerprintOf(stat3);
+  const fp = fingerprintOf(stat5);
   if (!fp) return false;
   if (entry.fingerprint !== fp) return false;
   if (typeof entry.at !== "number") return false;
@@ -496,8 +634,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 stat3 = statsById && statsById.get(String(id));
-    if (isFresh(entry, stat3, now, ttlMs) && entry && entry.meta) {
+    const stat5 = statsById && statsById.get(String(id));
+    if (isFresh(entry, stat5, now, ttlMs) && entry && entry.meta) {
       cached.set(String(id), entry.meta);
     } else {
       missing.push(String(id));
@@ -513,10 +651,10 @@ function createSessionMetaCache(opts = {}) {
   let misses = 0;
   return {
     // 命中返回 meta，未命中/无法校验返回 null。
-    get(id, stat3) {
+    get(id, stat5) {
       const key = String(id);
       const entry = map.get(key);
-      if (isFresh(entry, stat3, Date.now(), ttlMs)) {
+      if (isFresh(entry, stat5, Date.now(), ttlMs)) {
         hits++;
         map.delete(key);
         map.set(key, entry);
@@ -525,9 +663,9 @@ function createSessionMetaCache(opts = {}) {
       misses++;
       return null;
     },
-    set(id, stat3, meta) {
+    set(id, stat5, meta) {
       if (!meta) return null;
-      const fp = fingerprintOf(stat3);
+      const fp = fingerprintOf(stat5);
       if (!fp) return null;
       const key = String(id);
       map.delete(key);
@@ -562,8 +700,8 @@ function createSessionMetaCache(opts = {}) {
 }
 
 // src/title-persist-index.js
-import { mkdir as mkdir3, readFile, rename as rename3, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname, join as join3 } from "node:path";
+import { mkdir as mkdir4, readFile, rename as rename4, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname, join as join5 } from "node:path";
 var TITLE_INDEX_SCHEMA_VERSION = 1;
 var MAX_ENTRIES = 2e4;
 function normalizeEntry(raw) {
@@ -601,7 +739,7 @@ function mergeEntries(left, right) {
 function createTitleIndexStore({ dir, file }) {
   let cache = null;
   let chain = Promise.resolve();
-  const path = file || join3(dir, "title-index.json");
+  const path = file || join5(dir, "title-index.json");
   async function readRaw() {
     try {
       return normalizeTitleIndex(JSON.parse(await readFile(path, "utf8")));
@@ -636,10 +774,10 @@ function createTitleIndexStore({ dir, file }) {
       if (!Object.keys(right).length) return false;
       await enqueue(async (store) => {
         const next = mergeEntries(store, right);
-        await mkdir3(dirname(path), { recursive: true });
-        const tmp = join3(dirname(path), `.title-index-${process.pid}-${Date.now()}.tmp`);
-        await writeFile3(tmp, JSON.stringify({ schemaVersion: TITLE_INDEX_SCHEMA_VERSION, entries: next }), { encoding: "utf8", mode: 384 });
-        await rename3(tmp, path);
+        await mkdir4(dirname(path), { recursive: true });
+        const tmp = join5(dirname(path), `.title-index-${process.pid}-${Date.now()}.tmp`);
+        await writeFile4(tmp, JSON.stringify({ schemaVersion: TITLE_INDEX_SCHEMA_VERSION, entries: next }), { encoding: "utf8", mode: 384 });
+        await rename4(tmp, path);
         cache = next;
       });
       return true;
@@ -656,10 +794,10 @@ function createTitleIndexStore({ dir, file }) {
           }
         }
         if (!changed) return;
-        await mkdir3(dirname(path), { recursive: true });
-        const tmp = join3(dirname(path), `.title-index-${process.pid}-${Date.now()}.tmp`);
-        await writeFile3(tmp, JSON.stringify({ schemaVersion: TITLE_INDEX_SCHEMA_VERSION, entries: store }), { encoding: "utf8", mode: 384 });
-        await rename3(tmp, path);
+        await mkdir4(dirname(path), { recursive: true });
+        const tmp = join5(dirname(path), `.title-index-${process.pid}-${Date.now()}.tmp`);
+        await writeFile4(tmp, JSON.stringify({ schemaVersion: TITLE_INDEX_SCHEMA_VERSION, entries: store }), { encoding: "utf8", mode: 384 });
+        await rename4(tmp, path);
       });
       return true;
     }
@@ -667,8 +805,8 @@ function createTitleIndexStore({ dir, file }) {
 }
 
 // src/handle-era-paths.js
-import { readdir, stat } from "node:fs/promises";
-import { basename, join as join4 } from "node:path";
+import { readdir as readdir2, stat as stat2 } from "node:fs/promises";
+import { basename, join as join6 } from "node:path";
 
 // src/path-guard.js
 function splitSegments(target) {
@@ -700,7 +838,7 @@ function pathOwnsSession(target, sid) {
 }
 
 // src/handle-era-paths.js
-var GENERATION_LOG_RE = /^session\.v\d+\.jsonl(\.zst(d)?)?$/;
+var GENERATION_LOG_RE = /^session(\.v\d+)?\.jsonl(\.zst(d)?)?$/;
 function isSafeChar(ch) {
   return ch !== "~" && /^[A-Za-z0-9._-]$/.test(ch);
 }
@@ -741,8 +879,11 @@ function resolveSessionRoot(sp) {
   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));
+  const project = cwd === void 0 || cwd === null || cwd === "" ? join6(root, "_no-cwd") : join6(root, projectKeyFor(cwd));
+  return join6(project, encodeSegmentFor(id));
+}
+function generationVersionOf(name2) {
+  return Number((String(name2).match(/^session\.v(\d+)\./) || [])[1] || 0);
 }
 async function locateSessionArtifacts(sp, header) {
   const root = resolveSessionRoot(sp);
@@ -757,27 +898,26 @@ async function locateSessionArtifacts(sp, header) {
   if (basename(sessionDir) !== encodeSegmentFor(sid)) return null;
   let entries;
   try {
-    const st = await stat(sessionDir);
+    const st = await stat2(sessionDir);
     if (!st.isDirectory()) return null;
-    entries = await readdir(sessionDir);
+    entries = await readdir2(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]);
+  generationFiles.sort((a, b) => generationVersionOf(b) - generationVersionOf(a));
+  const logPath = join6(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)),
+    projectDir: join6(root, header.cwd === void 0 || header.cwd === null || header.cwd === "" ? "_no-cwd" : projectKeyFor(header.cwd)),
     sessionDir,
     logPath,
-    generationFiles
+    generationFiles,
+    // 最高代版本号：0 = legacy `session.jsonl[.zstd]`，≥1 = `session.vN.jsonl[.zstd]`。
+    // 上层用它判断「另一个目录里的同 id 副本是不是被取代的旧代」。
+    generationVersion: generationVersionOf(generationFiles[0])
   };
 }
 
@@ -785,9 +925,15 @@ async function locateSessionArtifacts(sp, header) {
 var DEFAULT_CHUNK = 400;
 var MAX_CHUNKS = 2e4;
 function normalizeReadResult(events) {
+  if (events === void 0 || events === null) return [];
   if (Array.isArray(events)) return events;
-  if (events && typeof events[Symbol.iterator] === "function") return [...events];
-  return [];
+  if (typeof events === "object" && Array.isArray(events.events)) return events.events;
+  if (typeof events[Symbol.iterator] === "function") return [...events];
+  const error = new Error(
+    "DSH \u4F1A\u8BDD\u8BFB\u53D6\u8FD4\u56DE\u4E86\u65E0\u6CD5\u8BC6\u522B\u7684\u7ED3\u6784\uFF08runtime \u63A5\u53E3\u53EF\u80FD\u5DF2\u53D8\u66F4\uFF09\uFF0C\u5DF2\u505C\u6B62\u89E3\u6790\u4EE5\u514D\u8BEF\u5224\u4E3A\u7A7A\uFF1A" + Object.prototype.toString.call(events)
+  );
+  error.code = "DSM_READ_SHAPE_UNKNOWN";
+  throw error;
 }
 async function closeQuietly(handle) {
   try {
@@ -975,9 +1121,80 @@ function requireCapability(capabilities, name2) {
 }
 
 // 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";
+import { mkdir as mkdir5, readFile as readFile2, readdir as readdir3, rename as rename5, rm as rm2, stat as stat3, writeFile as writeFile5 } from "node:fs/promises";
+import { basename as basename2, dirname as dirname2, join as join7 } from "node:path";
 var MOVE_BATCH = 400;
+var REAL_LOG_RE = /^session.*\.jsonl(\.zst(d)?)?$/;
+var MOVE_TEMP_RE = /\.move-(backup|stage)-/;
+var SESSION_LOCAL_JUNK_RE = /^(\.?session\.lock.*|\.lock.*|.*\.lock|.*\.tmp|.*\.stage|.*\.bak|\.DS_Store)$/;
+async function cleanSiblingCopies(root, sid, keepDir, keepVersion) {
+  let projects;
+  try {
+    projects = await readdir3(root, { withFileTypes: true });
+  } catch (e) {
+    return { removed: 0, superseded: [], real: [] };
+  }
+  let segment;
+  try {
+    segment = encodeSegmentFor(sid);
+  } catch (e) {
+    return { removed: 0, superseded: [], real: [] };
+  }
+  let removed = 0;
+  const superseded = [];
+  const real = [];
+  for (const ent of projects) {
+    if (!ent.isDirectory()) continue;
+    const candidate = join7(root, ent.name, segment);
+    if (keepDir && candidate === keepDir) continue;
+    let entries;
+    try {
+      const st = await stat3(candidate);
+      if (!st.isDirectory()) continue;
+      entries = await readdir3(candidate);
+    } catch (e) {
+      continue;
+    }
+    const logs = entries.filter((name2) => REAL_LOG_RE.test(name2) && !MOVE_TEMP_RE.test(name2));
+    if (logs.length === 0) {
+      try {
+        await rm2(candidate, { recursive: true, force: true });
+        removed++;
+      } catch (e) {
+      }
+      continue;
+    }
+    const highest = Math.max(...logs.map(generationVersionOf));
+    const onlyLogsAndLocalJunk = entries.every((name2) => REAL_LOG_RE.test(name2) && !MOVE_TEMP_RE.test(name2) || SESSION_LOCAL_JUNK_RE.test(name2));
+    if (Number.isSafeInteger(keepVersion) && highest < keepVersion && onlyLogsAndLocalJunk) {
+      try {
+        await rm2(candidate, { recursive: true, force: true });
+        superseded.push(candidate);
+      } catch (e) {
+        real.push(candidate);
+      }
+      continue;
+    }
+    real.push(candidate);
+  }
+  return { removed, superseded, real };
+}
+async function removeSourceDir(sessionDir) {
+  let entries;
+  try {
+    entries = await readdir3(sessionDir);
+  } catch (e) {
+    return { cleaned: true, leftover: [] };
+  }
+  try {
+    await rm2(sessionDir, { recursive: true, force: true });
+  } catch (e) {
+    return { cleaned: false, leftover: entries };
+  }
+  return { cleaned: true, leftover: [] };
+}
+var BUSY_MOVE_MESSAGE = "\u4F1A\u8BDD\u6B63\u88AB DSH \u6253\u5F00\uFF0C\u6682\u65F6\u65E0\u6CD5\u79FB\u52A8\uFF1B\u8BF7\u91CD\u542F DSH \u540E\u518D\u8BD5\u3002";
+var BUSY_PURGE_MESSAGE = "\u4F1A\u8BDD\u6B63\u88AB DSH \u6253\u5F00\uFF0C\u6682\u65F6\u65E0\u6CD5\u5F7B\u5E95\u5220\u9664\uFF1B\u8BF7\u91CD\u542F DSH \u540E\u518D\u8BD5\u3002";
 function conflictError(message) {
   const error = new Error(message);
   error.status = 409;
@@ -1004,7 +1221,7 @@ async function ensureNoActiveWriter(sp, sid) {
   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");
+    if (isAlreadyOwned(e)) throw conflictError(BUSY_MOVE_MESSAGE);
     throw e;
   }
   await closeQuietly2(handle);
@@ -1020,13 +1237,13 @@ async function purgeSessionArtifacts(sp, sid, header) {
   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");
+    if (isAlreadyOwned(e)) throw conflictError(BUSY_PURGE_MESSAGE);
     throw e;
   }
   await closeQuietly2(writer);
   writer = null;
   try {
-    await rm(artifacts.sessionDir, { recursive: true, force: true });
+    await rm2(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;
@@ -1042,8 +1259,8 @@ async function purgeSessionArtifacts(sp, sid, header) {
   }
   return artifacts;
 }
-async function relocateRewrittenBackup({ sid, canonical, backupPath, artifacts }) {
-  const original = await readFile2(backupPath);
+async function relocateRewrittenBackup({ sid, canonical, backupLogPath, artifacts }) {
+  const original = await readFile2(backupLogPath);
   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);
@@ -1053,26 +1270,66 @@ async function relocateRewrittenBackup({ sid, canonical, backupPath, artifacts }
     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]));
+  await mkdir5(targetDir, { recursive: true });
+  const staged = join7(targetDir, `.move-stage-${process.pid}-${Date.now()}`);
+  await writeFile5(staged, rewritten, { mode: 384 });
+  await rename5(staged, join7(targetDir, artifacts.generationFiles[0]));
   return targetDir;
 }
 async function moveSessionToCwd({ sp, sid, header, canonical, events = [], inheritedEventCount = 0 }) {
+  let probeError = null;
+  try {
+    await ensureNoActiveWriter(sp, sid);
+  } catch (e) {
+    if (e && e.status === 409) throw e;
+    probeError = e;
+  }
   const artifacts = await locateSessionArtifacts(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);
+  if (probeError) {
+    const error = new Error("\u65E0\u6CD5\u786E\u8BA4\u8BE5\u4F1A\u8BDD\u662F\u5426\u6B63\u88AB\u5199\u5165\uFF0C\u5DF2\u505C\u6B62\u79FB\u52A8\uFF1A" + String(probeError && probeError.message || probeError));
+    error.status = 409;
+    throw error;
+  }
+  const HEADER_ONLY_MAX = 4096;
+  if (events.length === 0) {
+    let sourceBytes = null;
+    try {
+      sourceBytes = (await stat3(artifacts.logPath)).size;
+    } catch (e) {
+      sourceBytes = null;
+    }
+    if (sourceBytes !== null && sourceBytes > HEADER_ONLY_MAX) {
+      const error = new Error(
+        `\u79FB\u52A8\u524D\u6821\u9A8C\u5931\u8D25\uFF1A\u6E90\u65E5\u5FD7\u6709 ${sourceBytes} \u5B57\u8282\u4F46\u8BFB\u5230 0 \u6761\u4E8B\u4EF6\uFF08\u8BFB\u53D6\u94FE\u8DEF\u5F02\u5E38\uFF09\uFF0C\u5DF2\u505C\u6B62\u79FB\u52A8\u4EE5\u514D\u4E22\u5931\u4F1A\u8BDD\u5185\u5BB9\u3002`
+      );
+      error.status = 409;
+      error.code = "DSM_MOVE_EMPTY_READ";
+      throw error;
+    }
+  }
+  const siblings = await cleanSiblingCopies(artifacts.root, sid, artifacts.sessionDir, artifacts.generationVersion);
+  if (siblings.real.length > 0) {
+    const error = new Error(
+      "\u65E0\u6CD5\u79FB\u52A8\uFF1A\u5728\u5176\u4ED6\u5DE5\u4F5C\u533A\u76EE\u5F55\u53D1\u73B0\u540C\u4E00\u4F1A\u8BDD\u7684\u65E5\u5FD7\u526F\u672C\uFF0C\u8BF7\u5148\u786E\u8BA4\u4FDD\u7559\u54EA\u4E00\u4EFD\uFF1A\n" + siblings.real.map((p) => "\xB7 " + p).join("\n")
+    );
+    error.status = 409;
+    error.code = "DSM_SESSION_DUP_LOG";
+    throw error;
+  }
   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);
+  const backupRoot = join7(dirname2(artifacts.root), "sessions-manager-move-backup");
+  const backupDir = join7(backupRoot, `${encodeSegmentFor(sid)}-${process.pid}-${Date.now()}`);
+  await mkdir5(backupRoot, { recursive: true });
+  const backupLogPath = join7(backupDir, basename2(artifacts.logPath));
+  await rename5(artifacts.sessionDir, backupDir);
   let writer = null;
   try {
     try {
@@ -1085,7 +1342,7 @@ async function moveSessionToCwd({ sp, sid, header, canonical, events = [], inher
       writer = null;
     } catch (e) {
       if (isAlreadyExists(e)) {
-        await relocateRewrittenBackup({ sid, canonical, backupPath, artifacts });
+        await relocateRewrittenBackup({ sid, canonical, backupLogPath, artifacts });
       } else {
         throw e;
       }
@@ -1101,11 +1358,15 @@ async function moveSessionToCwd({ sp, sid, header, canonical, events = [], inher
   } catch (e) {
     await closeQuietly2(writer);
     try {
-      await rm(deriveSessionDir(artifacts.root, canonical, sid), { recursive: true, force: true });
+      await rm2(deriveSessionDir(artifacts.root, canonical, sid), { recursive: true, force: true });
+    } catch (_) {
+    }
+    try {
+      await mkdir5(dirname2(artifacts.sessionDir), { recursive: true });
     } catch (_) {
     }
     try {
-      await rename4(backupPath, artifacts.logPath);
+      await rename5(backupDir, artifacts.sessionDir);
     } catch (_) {
     }
     if (e && e.status) throw e;
@@ -1113,19 +1374,53 @@ async function moveSessionToCwd({ sp, sid, header, canonical, events = [], inher
     error.status = 500;
     throw error;
   }
-  try {
-    await unlink(backupPath);
-  } catch (e) {
-  }
-  return { sessionDir: deriveSessionDir(artifacts.root, canonical, sid) };
+  const sourceCleanup = await removeSourceDir(backupDir);
+  return {
+    sessionDir: deriveSessionDir(artifacts.root, canonical, sid),
+    sourceCleanup,
+    reclaimedSiblings: siblings.superseded
+  };
+}
+
+// src/lineage.js
+var EMPTY_BASE = 190;
+function isEmptyLogSize(sizeBytes, cwd) {
+  if (!Number.isFinite(sizeBytes) || sizeBytes < 0) return false;
+  const cwdLen = typeof cwd === "string" ? cwd.length : 0;
+  return sizeBytes <= EMPTY_BASE + cwdLen;
+}
+var EMPTY_DECODE_LIMIT = 8192;
+var LIFECYCLE_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "session",
+  "permission/preset",
+  "sandbox/mode",
+  "approval/policy"
+]);
+function isEmptyEventTypes(types) {
+  if (!Array.isArray(types)) return false;
+  for (const t of types) {
+    if (typeof t !== "string" || !LIFECYCLE_EVENT_TYPES.has(t)) return false;
+  }
+  return true;
+}
+function classifyLineage(header, sizeBytes) {
+  if (!header || typeof header !== "object") return null;
+  const origin = header.origin === "subagent" ? "subagent" : null;
+  const parentSession = typeof header.parentSession === "string" && header.parentSession ? header.parentSession : null;
+  const delegationDepth = Number.isSafeInteger(header.delegationDepth) && header.delegationDepth > 0 ? header.delegationDepth : 0;
+  const empty = isEmptyLogSize(sizeBytes, header.cwd);
+  if (!origin && !parentSession && !empty) return null;
+  return { origin, parentSession, delegationDepth, empty };
 }
 
 // src/index.js
+var BUILD_STAMP = true ? "3.6.1+f0814a9e" : "dev";
 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 || join6(homedir3(), ".dsh", "sessions-manager-trash");
-var TRASH_INDEX = join6(TRASH_DIR, "index.json");
+var STATE_DIR = process.env.DSH_SESSIONS_MANAGER_STAR_DIR || join8(homedir4(), ".dsh", "sessions-manager");
+var TRASH_DIR = process.env.DSH_SESSIONS_MANAGER_TRASH_DIR || join8(homedir4(), ".dsh", "sessions-manager-trash");
+var TRASH_INDEX = join8(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;
@@ -1227,7 +1522,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: join6(TRASH_DIR, "title-index.json") });
+  const titleIndex = createTitleIndexStore({ dir: TRASH_DIR, file: join8(TRASH_DIR, "title-index.json") });
   async function hydrateFromPersist(ids, statsById) {
     const hits = /* @__PURE__ */ new Map();
     if (!ids || !ids.length) return hits;
@@ -1238,29 +1533,31 @@ function apply(ctx) {
       return hits;
     }
     for (const id of ids) {
-      const stat3 = statsById.get(id);
+      const stat5 = statsById.get(id);
       const entry = store && store[id];
-      if (!stat3 || !entry) continue;
-      const fp = fingerprintOf(stat3);
-      if (!isPersistableFingerprint(fp)) continue;
+      if (!stat5 || !entry) continue;
+      const fp = persistFingerprintOf(stat5);
+      if (!fp) continue;
       if (fp && entry.fingerprint === fp) {
         hits.set(id, { title: entry.title, cwd: entry.cwd, createdAt: entry.createdAt });
       }
     }
     return hits;
   }
-  function persistDecoded(decoded, statsById) {
+  async function persistDecoded(decoded, statsById) {
     if (!decoded || !decoded.size) return;
     const batch = {};
     const now = Date.now();
     for (const [id, meta] of decoded) {
-      const fp = fingerprintOf(statsById.get(id));
-      if (!isPersistableFingerprint(fp)) continue;
+      const fp = persistFingerprintOf(statsById.get(id));
+      if (!fp) continue;
       batch[id] = { title: meta.title, cwd: meta.cwd, createdAt: meta.createdAt, fingerprint: fp, updatedAt: now };
     }
     if (!Object.keys(batch).length) return;
-    titleIndex.merge(batch).catch(() => {
-    });
+    try {
+      await titleIndex.merge(batch);
+    } catch (e) {
+    }
   }
   function metaFromSnapshot(o) {
     let title = null, createdAt = null, cwd = null;
@@ -1332,50 +1629,63 @@ function apply(ctx) {
     }
     return base;
   }
-  async function resolveOne(id, usage, opts = {}) {
-    const key = String(id);
-    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) {
-      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 {
-        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) {
-      }
+  const EMPTY_META = { title: null, cwd: null, createdAt: null };
+  const WARM_CHUNK = 4;
+  const warmQueue = /* @__PURE__ */ new Map();
+  let warmRunning = false;
+  let warmKickTimer = null;
+  function scheduleWarm() {
+    if (warmKickTimer || warmRunning) return;
+    warmKickTimer = setTimeout(() => {
+      warmKickTimer = null;
+      runWarm();
+    }, 25);
+    if (typeof warmKickTimer.unref === "function") warmKickTimer.unref();
+  }
+  function enqueueWarm(ids, statsById, entryById) {
+    if (!ids || !ids.length) return;
+    for (const id of ids) {
+      const key = String(id);
+      const entry = entryById ? entryById.get(key) : null;
+      warmQueue.set(key, {
+        stat: statsById ? statsById.get(key) || null : null,
+        header: entry && entry.header || null
+      });
     }
-    const projectionAvailable = typeof sq.readTitleSnapshot === "function" || typeof sq.readTitleSnapshots === "function";
-    if (!meta.cwd || !meta.title && !projectionAvailable) {
-      try {
-        let foldedTitle = null;
-        const summary = await persistence.inspectSession(key, {
-          onEvents: (events) => {
-            if (!foldedTitle) foldedTitle = foldTitle(events);
+    scheduleWarm();
+  }
+  async function runWarm() {
+    if (warmRunning) return;
+    warmRunning = true;
+    try {
+      while (warmQueue.size) {
+        const batch = [...warmQueue.entries()].slice(0, WARM_CHUNK);
+        for (const [id] of batch) warmQueue.delete(id);
+        try {
+          const ids = batch.map(([id]) => id);
+          const snapshotById = await projectTitles(ids);
+          const decoded = /* @__PURE__ */ new Map();
+          const statsById = /* @__PURE__ */ new Map();
+          for (const [id, desc] of batch) {
+            const snapshot = snapshotById.has(id) ? snapshotById.get(id) : null;
+            const meta = metaFromSnapshot(snapshot);
+            if (desc.header) {
+              if (typeof desc.header.cwd === "string") meta.cwd = desc.header.cwd;
+              if (desc.header.createdAt != null) meta.createdAt = desc.header.createdAt;
+            }
+            metaCache.set(id, desc.stat, meta);
+            statsById.set(id, desc.stat);
+            if (desc.stat) decoded.set(id, meta);
           }
-        });
-        if (summary && summary.meta) {
-          if (!meta.cwd) meta.cwd = summary.meta.cwd || null;
-          if (!meta.createdAt) meta.createdAt = summary.meta.createdAt || null;
+          await persistDecoded(decoded, statsById);
+        } catch (e) {
         }
-        if (!meta.title && foldedTitle) meta.title = foldedTitle;
-      } catch (e2) {
+        await new Promise((resolve) => setImmediate(resolve));
       }
+    } finally {
+      warmRunning = false;
+      if (warmQueue.size) scheduleWarm();
     }
-    metaCache.set(key, statInfo, meta);
-    if (opts.collectDecoded && statInfo) opts.collectDecoded(key, meta);
-    return buildItem(key, meta, usage, opts.exposeUsage);
   }
   async function collectUsage(preloadedEntries) {
     const sizeById = /* @__PURE__ */ new Map();
@@ -1399,14 +1709,14 @@ function apply(ctx) {
         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 });
+          statsById.set(id, Number.isFinite(entry.sizeBytes) ? { revision: entry.revision, sizeBytes: Number(entry.sizeBytes) } : { 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 stat2(loc.path);
+          const st = await stat4(loc.path);
           if (!st) return;
           if (typeof st.size === "number") sizeById.set(id, st.size);
           if (typeof st.mtimeMs === "number" && st.mtimeMs > 0) {
@@ -1437,7 +1747,7 @@ function apply(ctx) {
   }
   async function readTrashStore() {
     try {
-      return normalizeTrashStore(JSON.parse(readFileSync3(TRASH_INDEX, "utf8")));
+      return normalizeTrashStore(JSON.parse(readFileSync4(TRASH_INDEX, "utf8")));
     } catch (e) {
       return normalizeTrashStore(null);
     }
@@ -1446,10 +1756,10 @@ function apply(ctx) {
     return (await readTrashStore()).items;
   }
   async function writeTrashStore(store) {
-    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);
+    await mkdir6(TRASH_DIR, { recursive: true });
+    const tmp = join8(TRASH_DIR, `.index-${process.pid}-${Date.now()}.tmp`);
+    await writeFile6(tmp, JSON.stringify(normalizeTrashStore(store), null, 2), { encoding: "utf8", mode: 384 });
+    await rename6(tmp, TRASH_INDEX);
   }
   function mutateTrash(mutator) {
     const operation = trashMutation.then(async () => {
@@ -1463,7 +1773,10 @@ function apply(ctx) {
     return operation;
   }
   const stars = createStarIndex();
+  const pendingMoves = createPendingMoveStore();
   const autoArchive = createAutoArchiveStore();
+  sweepStaleStateTemps([STATE_DIR, TRASH_DIR], {}).catch(() => {
+  });
   async function gcStars(validIds) {
     try {
       const store = await stars.read();
@@ -1550,10 +1863,10 @@ function apply(ctx) {
     let exists = false;
     let header = null;
     try {
-      const stat3 = await persistence.statSession(sid);
-      if (stat3) {
+      const stat5 = await persistence.statSession(sid);
+      if (stat5) {
         exists = true;
-        header = stat3.header;
+        header = stat5.header;
       }
     } catch (e) {
     }
@@ -1584,7 +1897,7 @@ function apply(ctx) {
       if (loc && typeof loc.path === "string") originalPath = loc.path;
     }
     if (originalPath) {
-      const existsOnDisk = await stat2(originalPath).then(() => true).catch(() => false);
+      const existsOnDisk = await stat4(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" };
       }
@@ -1697,7 +2010,7 @@ function apply(ctx) {
         await purgeSessionArtifacts(sp, sid, locatedHeader);
       } else if (target) {
         try {
-          await unlink2(target);
+          await unlink(target);
         } catch (e) {
           if (e && e.code !== "ENOENT") throw new Error("\u5220\u9664\u6587\u4EF6\u5931\u8D25\uFF1A" + String(e && e.message || e));
         }
@@ -1730,8 +2043,10 @@ function apply(ctx) {
       purged = true;
     });
     if (!purged) throw new Error("\u5F7B\u5E95\u5220\u9664\u5931\u8D25");
-    stars.removeIds([sid]).catch(() => {
-    });
+    try {
+      await stars.removeIds([sid]);
+    } catch (e) {
+    }
     return { ok: true, purged: true };
   }
   async function trashSettings(next) {
@@ -1767,8 +2082,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 = join6(homedir3(), p.slice(2));
-    if (!isAbsolute(p)) p = join6(homedir3(), p);
+    if (p.startsWith("~/")) p = join8(homedir4(), p.slice(2));
+    if (!isAbsolute(p)) p = join8(homedir4(), p);
     let canonical = null;
     try {
       canonical = await realpath(p);
@@ -1776,16 +2091,19 @@ function apply(ctx) {
       canonical = null;
     }
     if (canonical === null) {
-      await mkdir5(p, { recursive: true });
+      await mkdir6(p, { recursive: true });
       canonical = await realpath(p);
     }
-    return { canonical, entity: await w.create(canonical, basename2(canonical) || "workspace") };
+    return { canonical, entity: await w.create(canonical, basename3(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 error = new Error("\u4F1A\u8BDD\u6B63\u88AB DSH \u6253\u5F00\uFF0C\u6682\u65F6\u65E0\u6CD5\u79FB\u52A8\uFF1B\u8BF7\u91CD\u542F DSH \u540E\u518D\u8BD5\u3002");
+      error.status = 409;
+      error.code = "DSM_SESSION_BUSY";
+      throw error;
     }
     const r = await persistence.readSession(sid, 0);
     if (!r || !r.meta) throw new Error("\u65E0\u6CD5\u8BFB\u53D6\u8BE5\u4F1A\u8BDD\u7684\u65E5\u5FD7");
@@ -1805,6 +2123,7 @@ function apply(ctx) {
       }
     }
     const newHeader = Object.assign({}, meta, { cwd: canonical });
+    const moveNotes = [];
     const live = ctx.get("sessions");
     const liveObj = live && live.get && live.get(sid);
     const isOpen = !!liveObj;
@@ -1817,14 +2136,14 @@ function apply(ctx) {
       const stagedPath = `${newPath}.move-stage-${process.pid}-${Date.now()}`;
       let destinationInstalled = false;
       try {
-        await mkdir5(dirname2(newPath), { recursive: true });
+        await mkdir6(dirname3(newPath), { recursive: true });
         try {
-          await stat2(newPath);
+          await stat4(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);
+        await rename6(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");
@@ -1834,23 +2153,25 @@ function apply(ctx) {
         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);
+        await writeFile6(stagedPath, rewritten, { mode: 384 });
+        await rename6(stagedPath, newPath);
         destinationInstalled = true;
-        await unlink2(backupPath);
+        await unlink(backupPath);
+        const keptInSource = await cleanupMovedSourceDir(dirname3(oldPath));
+        if (keptInSource.length > 0) moveNotes.push(`\u6E90\u76EE\u5F55\u672A\u80FD\u6E05\u7406\u5E72\u51C0\uFF08\u6B8B\u7559 ${keptInSource.join("\u3001")}\uFF09\uFF0C\u82E5\u540E\u7EED\u79FB\u52A8\u62A5\u201Cduplicate\u201D\u8BF7\u624B\u52A8\u6E05\u7A7A\u8BE5\u76EE\u5F55\u3002`);
       } catch (e) {
         try {
-          await unlink2(stagedPath);
+          await unlink(stagedPath);
         } catch (_) {
         }
         if (destinationInstalled) {
           try {
-            await unlink2(newPath);
+            await unlink(newPath);
           } catch (_) {
           }
         }
         try {
-          await rename5(backupPath, oldPath);
+          await rename6(backupPath, oldPath);
         } catch (_) {
         }
         if (e && e.code !== "ENOENT") throw e;
@@ -1874,6 +2195,20 @@ function apply(ctx) {
       }
       return null;
     };
+    const cleanupMovedSourceDir = async (dir) => {
+      let entries = null;
+      try {
+        entries = await readdir4(dir);
+      } catch (e) {
+        return [];
+      }
+      try {
+        await rm3(dir, { recursive: true, force: true });
+      } catch (e) {
+        return entries;
+      }
+      return [];
+    };
     if (persistence.kind === "session-handle") {
       const stat1 = await persistence.statSession(sid);
       if (stat1 && stat1.revision) {
@@ -1883,7 +2218,13 @@ function apply(ctx) {
         }
       }
       try {
-        await moveSessionToCwd({ sp, sid, header: meta, canonical, events, inheritedEventCount: r.inheritedEventCount });
+        const movedHandle = await moveSessionToCwd({ sp, sid, header: meta, canonical, events, inheritedEventCount: r.inheritedEventCount });
+        if (movedHandle && Array.isArray(movedHandle.reclaimedSiblings) && movedHandle.reclaimedSiblings.length > 0) {
+          moveNotes.push(`\u5DF2\u987A\u5E26\u56DE\u6536 ${movedHandle.reclaimedSiblings.length} \u5904\u88AB\u53D6\u4EE3\u7684\u65E7\u4EE3\u65E5\u5FD7\u526F\u672C\uFF08\u5386\u53F2\u79FB\u52A8\u6B8B\u7559\uFF09\uFF0C\u907F\u514D\u540C\u4E00\u4F1A\u8BDD\u5728\u591A\u76EE\u5F55\u91CD\u590D\u3002`);
+        }
+        if (movedHandle && movedHandle.sourceCleanup && movedHandle.sourceCleanup.cleaned === false) {
+          moveNotes.push(`\u6E90\u76EE\u5F55\u672A\u80FD\u6E05\u7406\u5E72\u51C0\uFF08\u6B8B\u7559 ${movedHandle.sourceCleanup.leftover.join("\u3001")}\uFF09\uFF0C\u82E5\u540E\u7EED\u79FB\u52A8\u62A5\u201Cduplicate\u201D\u8BF7\u624B\u52A8\u6E05\u7A7A\u8BE5\u76EE\u5F55\u3002`);
+        }
       } 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));
@@ -1910,7 +2251,7 @@ function apply(ctx) {
         const backupPath = oldPath ? `${oldPath}.move-backup-${Date.now()}` : null;
         if (backupPath) {
           try {
-            await rename5(oldPath, backupPath);
+            await rename6(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");
           }
@@ -1918,7 +2259,7 @@ function apply(ctx) {
         const restore = async () => {
           if (backupPath) {
             try {
-              await rename5(backupPath, oldPath);
+              await rename6(backupPath, oldPath);
             } catch (_) {
             }
           }
@@ -1932,10 +2273,14 @@ function apply(ctx) {
           }
           if (backupPath) {
             try {
-              await unlink2(backupPath);
+              await unlink(backupPath);
             } catch (e) {
             }
           }
+          if (oldPath) {
+            const keptInSource = await cleanupMovedSourceDir(dirname3(oldPath));
+            if (keptInSource.length > 0) moveNotes.push(`\u6E90\u76EE\u5F55\u672A\u80FD\u6E05\u7406\u5E72\u51C0\uFF08\u6B8B\u7559 ${keptInSource.join("\u3001")}\uFF09\uFF0C\u82E5\u540E\u7EED\u79FB\u52A8\u62A5\u201Cduplicate\u201D\u8BF7\u624B\u52A8\u6E05\u7A7A\u8BE5\u76EE\u5F55\u3002`);
+          }
         } catch (e) {
           if (ALREADY_EXISTS_RE.test(String(e && e.message || e))) {
             await restore();
@@ -1979,9 +2324,107 @@ function apply(ctx) {
       moved: true,
       workspaceId: target.id,
       workspaceTitle: target.title,
-      workspacePath: canonical
+      workspacePath: canonical,
+      ...moveNotes.length > 0 ? { notes: moveNotes } : {}
     };
   }
+  const QUEUE_NOTE = "\u5DF2\u6392\u961F\uFF1A\u8BE5\u4F1A\u8BDD\u6B63\u88AB DSH \u6253\u5F00\uFF08\u5199\u6240\u6709\u6743\u53EA\u5728 DSH \u9000\u51FA\u65F6\u91CA\u653E\uFF09\u3002\u91CD\u542F DSH \u65F6\u4F1A\u81EA\u52A8\u5B8C\u6210\uFF0C\u8BF7\u5148\u522B\u6253\u5F00\u5B83\u3002";
+  function isBusyError(e) {
+    if (!e) return false;
+    if (e.code === "DSM_SESSION_BUSY") return true;
+    const text = String(e && e.message || e);
+    return /正被 DSH 打开|already owned/i.test(text);
+  }
+  async function moveOrQueue(sid, targetPath) {
+    try {
+      return await moveOne(sid, targetPath);
+    } catch (e) {
+      if (!isBusyError(e)) throw e;
+      await pendingMoves.queue(sid, targetPath);
+      return { ok: true, moved: false, queued: true, notes: [QUEUE_NOTE] };
+    }
+  }
+  const BOOT_WARMUP_MS = 3e4;
+  const bootedAt = Date.now();
+  let queueRunning = false;
+  async function runPendingMoves(reason) {
+    if (queueRunning) return { ran: false, moved: 0, kept: 0 };
+    queueRunning = true;
+    let moved = 0;
+    const notes = [];
+    try {
+      const items = await pendingMoves.list();
+      for (const item of items) {
+        try {
+          await moveOne(item.sessionId, item.targetPath);
+          await pendingMoves.remove([item.sessionId]);
+          metaCache.invalidate(item.sessionId);
+          moved++;
+          notes.push(`\u6392\u961F\u4E2D\u7684\u79FB\u52A8\u5DF2\u5B8C\u6210\uFF1A${String(item.sessionId).slice(0, 18)}\u2026`);
+        } catch (e) {
+          if (isBusyError(e)) continue;
+          if (Date.now() - bootedAt < BOOT_WARMUP_MS) continue;
+          const bumped = await pendingMoves.bumpAttempts(item.sessionId);
+          if (bumped && bumped.dropped) notes.push(`\u6392\u961F\u4E2D\u7684\u79FB\u52A8\u591A\u6B21\u5931\u8D25\u5DF2\u653E\u5F03\uFF1A${String(item.sessionId).slice(0, 18)}\u2026\uFF08${String(e && e.message || e)}\uFF09`);
+        }
+      }
+      if (moved > 0) {
+        try {
+          await reindexRegistry();
+        } catch (e) {
+        }
+      }
+    } finally {
+      queueRunning = false;
+    }
+    if (notes.length > 0) {
+      try {
+        for (const n of notes) console.warn("[dsh-sessions-manager] " + n);
+      } catch (e) {
+      }
+    }
+    void reason;
+    return { ran: true, moved, kept: (await pendingMoves.list()).length };
+  }
+  const queueEffect = typeof ctx.effect === "function" ? ctx.effect.bind(ctx) : ((fn) => {
+    fn();
+  });
+  if (typeof ctx.on === "function") {
+    queueEffect(() => ctx.on("session/disposed", (session) => {
+      const id = session && session.id != null ? String(session.id) : null;
+      if (!id) return;
+      pendingMoves.has(id).then((queued) => {
+        if (!queued) return;
+        const t = setTimeout(() => {
+          runPendingMoves("session-disposed").catch(() => {
+          });
+        }, 500);
+        if (t && typeof t.unref === "function") t.unref();
+      }).catch(() => {
+      });
+    }));
+  }
+  queueEffect(() => {
+    const timers = [0, 1e3, 3e3, 6e3, 12e3, 3e4].map((ms) => {
+      const t = setTimeout(() => {
+        runPendingMoves(ms === 0 ? "startup" : `startup+${ms}`).catch(() => {
+        });
+      }, ms);
+      if (t && typeof t.unref === "function") t.unref();
+      return t;
+    });
+    const tickTimer = setInterval(() => {
+      pendingMoves.list().then((items) => {
+        if (items.length > 0) return runPendingMoves("tick");
+      }).catch(() => {
+      });
+    }, 12e4);
+    if (tickTimer && typeof tickTimer.unref === "function") tickTimer.unref();
+    return () => {
+      for (const t of timers) clearTimeout(t);
+      clearInterval(tickTimer);
+    };
+  });
   async function reindexRegistry() {
     const reg = w;
     if (!reg || typeof reg.replaceHeaderIndex !== "function") return false;
@@ -2067,35 +2510,48 @@ function apply(ctx) {
       wsByPath = {};
     }
     const currentArchived = new Set((await archivedState().catch(() => ({ archivedSessionIds: [] }))).archivedSessionIds || []);
-    const items = [];
     const usage = await collectUsage(entries);
     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 { cached, missing } = metaCache.partition(visibleIds, statsById);
     const persisted = await hydrateFromPersist(missing, statsById);
-    for (const [id, meta] of persisted) metaCache.set(id, statsById.get(id), meta);
+    for (const [id, meta] of persisted) {
+      const entry = entryById.get(id);
+      const header = entry && entry.header ? entry.header : null;
+      metaCache.set(id, statsById.get(id), {
+        title: meta.title,
+        cwd: header && typeof header.cwd === "string" && header.cwd ? header.cwd : meta.cwd,
+        createdAt: header && header.createdAt != null ? header.createdAt : meta.createdAt
+      });
+    }
     const stillMissing = missing.filter((id) => !persisted.has(id));
-    const snapshotById = await projectTitles(stillMissing);
-    const decoded = /* @__PURE__ */ new Map();
-    const collectDecoded = (id, meta) => {
-      decoded.set(id, meta);
-    };
-    const CHUNK = 6;
-    for (let i = 0; i < visibleIds.length; i += CHUNK) {
-      const res2 = await Promise.all(visibleIds.slice(i, i + CHUNK).map((id) => {
+    if (stillMissing.length) enqueueWarm(stillMissing, statsById, entryById);
+    const items = [];
+    for (const id of visibleIds) {
+      let meta = metaCache.get(id, statsById.get(id)) || persisted.get(id) || null;
+      if (!meta) {
+        meta = { title: null, cwd: null, createdAt: null };
         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) });
+        const header = entry && entry.header ? entry.header : null;
+        if (header) {
+          if (typeof header.cwd === "string") meta.cwd = header.cwd;
+          if (header.createdAt != null) meta.createdAt = header.createdAt;
+        }
+      }
+      const it = buildItem(id, meta, usage, !!(opts && opts.usage));
+      items.push({ ...it, archived: currentArchived.has(it.sessionId) });
+    }
+    if (opts && opts.onlyArchived) {
+      const archivedItems = [];
+      for (const it of items) {
+        if (!it.archived) continue;
+        const { archived: _drop, ...rest } = it;
+        archivedItems.push(rest);
+      }
+      return { items: archivedItems, usage };
     }
-    persistDecoded(decoded, statsById);
     let starredSet = /* @__PURE__ */ new Set();
     try {
       starredSet = new Set((await stars.read()).starredSessionIds);
@@ -2173,43 +2629,82 @@ function apply(ctx) {
     const activeTombstones = store.purgedSessionIds.map(String).filter((id) => !present.has(id));
     if (ids.length) {
       const usage = await collectUsage(entries);
+      const entryById = new Map(entries.map((entry) => [entry.id, entry]));
       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);
+      for (const [id, meta] of persisted) {
+        const entry = entryById.get(id);
+        const header = entry && entry.header ? entry.header : null;
+        metaCache.set(id, statsById.get(id), {
+          title: meta.title,
+          cwd: header && typeof header.cwd === "string" && header.cwd ? header.cwd : meta.cwd,
+          createdAt: header && header.createdAt != null ? header.createdAt : meta.createdAt
+        });
+      }
       const rest = missing.filter((id) => !persisted.has(id));
-      const snapshotById = await projectTitles(rest);
-      const decoded = /* @__PURE__ */ new Map();
-      const collectDecoded = (id, meta) => {
-        decoded.set(id, meta);
-      };
+      if (rest.length) enqueueWarm(rest, statsById, entryById);
       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;
-        }
+        const meta = metaCache.get(id, statsById.get(id)) || persisted.get(id) || null;
         if (meta && meta.title) authorityTitleCache.set(id, String(meta.title));
       }
-      persistDecoded(decoded, statsById);
     }
+    const lineage = {};
+    for (const entry of entries) {
+      const info = classifyLineage(entry.header, entry.sizeBytes);
+      if (info) lineage[entry.id] = info;
+    }
+    await refineEmptyLineage(lineage, entries);
     return {
       titles: Object.fromEntries(authorityTitleCache),
       trashedSessionIds: store.items.map((item) => String(item.sessionId)),
-      purgedSessionIds: activeTombstones
+      purgedSessionIds: activeTombstones,
+      lineage
     };
   }
+  const emptyScanCache = /* @__PURE__ */ new Map();
+  async function refineEmptyLineage(lineage, entries) {
+    if (!persistence || typeof persistence.inspectSession !== "function") return;
+    for (const entry of entries) {
+      const size = entry && Number.isFinite(entry.sizeBytes) ? entry.sizeBytes : null;
+      if (size === null || size > EMPTY_DECODE_LIMIT) continue;
+      const id = String(entry.id);
+      let scanned = emptyScanCache.get(id);
+      if (!scanned || scanned.sizeBytes !== size) {
+        let isEmpty = false;
+        try {
+          const types = [];
+          await persistence.inspectSession(id, { onEvents: (batch) => {
+            for (const ev of batch || []) if (types.length < 64) types.push(ev && ev.type);
+          } });
+          isEmpty = isEmptyEventTypes(types);
+        } catch (e) {
+          isEmpty = false;
+        }
+        scanned = { sizeBytes: size, empty: isEmpty };
+        emptyScanCache.set(id, scanned);
+      }
+      if (scanned.empty) {
+        const info = lineage[id] || (lineage[id] = { origin: null, parentSession: null, delegationDepth: 0, empty: false });
+        info.empty = true;
+      } else if (lineage[id]) {
+        const info = lineage[id];
+        info.empty = false;
+        if (!info.origin && !info.parentSession) delete lineage[id];
+      }
+    }
+    const live = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      const size = entry && Number.isFinite(entry.sizeBytes) ? entry.sizeBytes : null;
+      if (size !== null && size <= EMPTY_DECODE_LIMIT) live.add(String(entry.id));
+    }
+    for (const key of emptyScanCache.keys()) {
+      if (!live.has(key)) emptyScanCache.delete(key);
+    }
+  }
   async function buildDetails(sid, signal) {
     const sessions = ctx.get("sessions");
     const live = sessions && sessions.get(sid);
@@ -2294,8 +2789,8 @@ function apply(ctx) {
     let sizeBytes = null;
     if (live === void 0) {
       try {
-        const stat3 = await persistence.statSession(sid);
-        if (stat3 && Number.isFinite(stat3.sizeBytes)) sizeBytes = stat3.sizeBytes;
+        const stat5 = await persistence.statSession(sid);
+        if (stat5 && Number.isFinite(stat5.sizeBytes)) sizeBytes = stat5.sizeBytes;
       } catch (e) {
       }
     }
@@ -2303,7 +2798,7 @@ function apply(ctx) {
       try {
         const loc = persistence.locate(meta);
         if (loc && typeof loc.path === "string" && loc.path) {
-          const st = await stat2(loc.path);
+          const st = await stat4(loc.path);
           if (st && typeof st.size === "number") sizeBytes = st.size;
         }
       } catch (e) {
@@ -2312,7 +2807,7 @@ function apply(ctx) {
     }
     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]) => stat2(p).then(() => true).catch(() => false)));
+    const exists = await Promise.all(fileEntries.map(([p]) => stat4(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,
@@ -2364,7 +2859,7 @@ function apply(ctx) {
     disposers.push(ctx.webServer.register({
       kind: "exact",
       path: "/archived-sessions/capabilities",
-      handler: async (req, res) => json(res, capabilities)
+      handler: async (req, res) => json(res, { ...capabilities, buildStamp: BUILD_STAMP })
     }));
     disposers.push(ctx.webServer.register({
       kind: "exact",
@@ -2395,12 +2890,10 @@ function apply(ctx) {
           } catch (e) {
             wsByPath = {};
           }
-          const items = [];
-          const CHUNK = 6;
-          for (let i = 0; i < idStrs.length; i += CHUNK) {
-            const res2 = await Promise.all(idStrs.slice(i, i + CHUNK).map((id) => resolveOne(id)));
-            items.push.apply(items, res2);
-          }
+          const wanted = new Set(idStrs);
+          const detailed = await allSessionItemsDetailed();
+          const items = detailed.items.filter((it) => wanted.has(String(it.sessionId)) && it.archived);
+          for (const it of items) delete it.archived;
           json(res, { items });
         } catch (e) {
           json(res, { error: String(e && e.message || e) }, 500);
@@ -2520,7 +3013,7 @@ function apply(ctx) {
             if (typeof item.originalPath !== "string" || !item.originalPath) {
               return { sessionId: item.sessionId, status: "unverified", originalPath: null };
             }
-            const exists = await stat2(item.originalPath).then(() => true).catch(() => false);
+            const exists = await stat4(item.originalPath).then(() => true).catch(() => false);
             return { sessionId: item.sessionId, status: exists ? "ok" : "missing", originalPath: item.originalPath };
           }));
           json(res, {
@@ -2561,8 +3054,10 @@ function apply(ctx) {
           if (!sid) return json(res, { ok: false, error: "missing sessionId" }, 400);
           const out = await purgeFromTrash(sid);
           metaCache.invalidate(sid);
-          titleIndex.remove([sid]).catch(() => {
-          });
+          try {
+            await titleIndex.remove([sid]);
+          } catch (e) {
+          }
           json(res, out);
         } catch (e) {
           json(res, { ok: false, code: e && e.code, error: String(e && e.message || e) }, errorStatus(e));
@@ -2582,7 +3077,7 @@ function apply(ctx) {
             try {
               results.push({ sessionId: sid, ok: true, ...await purgeFromTrash(sid) });
               metaCache.invalidate(sid);
-              titleIndex.remove([sid]).catch(() => {
+              await titleIndex.remove([sid]).catch(() => {
               });
             } catch (e) {
               results.push({ sessionId: sid, ok: false, error: String(e && e.message || e) });
@@ -2672,6 +3167,108 @@ function apply(ctx) {
         }
       }
     }));
+    disposers.push(ctx.webServer.register({
+      kind: "exact",
+      path: "/archived-sessions/lineage-tree",
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req);
+          const rootId = body && typeof body.sessionId === "string" ? body.sessionId : "";
+          if (!rootId || !isSafeSessionId2(rootId)) return json(res, { error: "missing sessionId" }, 400);
+          const headerById = /* @__PURE__ */ new Map();
+          const sizeById = /* @__PURE__ */ new Map();
+          const trashedIds = /* @__PURE__ */ new Set();
+          let purgedIds = [];
+          const persistedIds = /* @__PURE__ */ new Set();
+          try {
+            const store = await readTrashStore();
+            for (const item of store.items) trashedIds.add(String(item.sessionId));
+            purgedIds = store.purgedSessionIds.map(String);
+          } catch (e) {
+          }
+          const addHeader = (h, sizeBytes) => {
+            if (!h || h.id == null) return;
+            const id = String(h.id);
+            if (headerById.has(id) || trashedIds.has(id)) return;
+            headerById.set(id, {
+              parentSession: h.parentSession != null ? String(h.parentSession) : null,
+              subagent: h.origin === "subagent",
+              delegationDepth: Number.isFinite(h.delegationDepth) ? h.delegationDepth : null,
+              createdAt: typeof h.createdAt === "number" ? h.createdAt : null
+            });
+            if (Number.isFinite(sizeBytes)) sizeById.set(id, sizeBytes);
+          };
+          try {
+            for (const entry of await persistence.listEntries()) {
+              addHeader(entry.header, entry.sizeBytes);
+              if (entry && entry.id != null) persistedIds.add(String(entry.id));
+            }
+          } catch (e) {
+          }
+          const liveIds = /* @__PURE__ */ new Set();
+          const live = ctx.get("sessions");
+          try {
+            if (live && typeof live.list === "function") {
+              live.list().forEach((s) => {
+                liveIds.add(String(s.id));
+                addHeader(s.header, void 0);
+              });
+            }
+          } catch (e) {
+          }
+          for (const id of purgedIds) {
+            if (!persistedIds.has(id)) headerById.delete(id);
+          }
+          const kidsOf = /* @__PURE__ */ new Map();
+          for (const [id, h] of headerById) {
+            if (!h.subagent || !h.parentSession) continue;
+            if (!kidsOf.has(h.parentSession)) kidsOf.set(h.parentSession, []);
+            kidsOf.get(h.parentSession).push(id);
+          }
+          const MAX_NODES = 500;
+          let nodeCount = 0;
+          const build = (id, depth, visited) => {
+            nodeCount++;
+            const h = headerById.get(id) || {};
+            const childVisited = new Set(visited);
+            childVisited.add(id);
+            const kidIds = nodeCount >= MAX_NODES ? [] : (kidsOf.get(id) || []).filter((k) => !childVisited.has(k));
+            return {
+              sessionId: id,
+              parentSession: h.parentSession || null,
+              delegationDepth: h.delegationDepth,
+              depth,
+              createdAt: h.createdAt || null,
+              sizeBytes: sizeById.has(id) ? sizeById.get(id) : null,
+              live: liveIds.has(id),
+              title: null,
+              children: kidIds.map((k) => build(k, depth + 1, childVisited))
+            };
+          };
+          const nodes = (kidsOf.get(rootId) || []).map((k) => build(k, 1, /* @__PURE__ */ new Set([rootId])));
+          const allIds = [rootId];
+          const walk = (n) => {
+            allIds.push(n.sessionId);
+            n.children.forEach(walk);
+          };
+          nodes.forEach(walk);
+          const titles = await projectTitles(allIds);
+          const titleOf = (id) => {
+            const snap = titles.get(id);
+            const m = snap ? metaFromSnapshot(snap) : null;
+            return m && m.title || null;
+          };
+          const fill = (n) => {
+            n.title = titleOf(n.sessionId);
+            n.children.forEach(fill);
+          };
+          nodes.forEach(fill);
+          json(res, { parent: { sessionId: rootId, title: titleOf(rootId) }, nodes });
+        } catch (e) {
+          json(res, { error: String(e && e.message || e) }, errorStatus(e));
+        }
+      }
+    }));
     disposers.push(ctx.webServer.register({
       kind: "exact",
       path: "/archived-sessions/workspaces",
@@ -2693,7 +3290,8 @@ function apply(ctx) {
           const target = body && typeof body.targetPath === "string" ? body.targetPath : null;
           if (!sid) return json(res, { ok: false, error: "missing sessionId" }, 400);
           if (!target) return json(res, { ok: false, error: "missing targetPath" }, 400);
-          const moved = await moveOne(sid, target);
+          const moved = await moveOrQueue(sid, target);
+          if (moved.queued) return json(res, { sessionId: sid, ...moved });
           metaCache.invalidate(sid);
           try {
             await reindexRegistry();
@@ -2705,6 +3303,74 @@ function apply(ctx) {
         }
       }
     }));
+    disposers.push(ctx.webServer.register({
+      kind: "exact",
+      path: "/archived-sessions/move-many",
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req);
+          const ids = Array.isArray(body && body.sessionIds) ? [...new Set(body.sessionIds.filter((x) => typeof x === "string" && x))] : [];
+          const target = body && typeof body.targetPath === "string" ? body.targetPath : null;
+          if (!ids.length) return json(res, { ok: false, error: "missing sessionIds" }, 400);
+          if (!target) return json(res, { ok: false, error: "missing targetPath" }, 400);
+          let moved = 0;
+          const failed = [];
+          const queued = [];
+          for (const sid of ids) {
+            try {
+              const r = await moveOrQueue(sid, target);
+              if (r && r.queued) {
+                queued.push(sid);
+                continue;
+              }
+              metaCache.invalidate(sid);
+              moved++;
+            } catch (e) {
+              const err = e && e.code ? { sessionId: sid, error: String(e && e.message || e), code: e.code } : { sessionId: sid, error: String(e && e.message || e) };
+              failed.push(err);
+            }
+          }
+          try {
+            await reindexRegistry();
+          } catch (e) {
+          }
+          json(res, {
+            moved,
+            failed,
+            ...queued.length > 0 ? { queued, notes: [`${queued.length} \u4E2A\u4F1A\u8BDD\u5DF2\u6392\u961F\uFF08\u6B63\u88AB DSH \u6253\u5F00\uFF09\uFF0C\u91CD\u542F DSH \u540E\u4F1A\u81EA\u52A8\u5B8C\u6210\uFF1B\u91CD\u542F\u540E\u8BF7\u5148\u522B\u6253\u5F00\u5B83\u4EEC\u3002`] } : {}
+          });
+        } catch (e) {
+          json(res, { ok: false, code: e && e.code, error: String(e && e.message || e) }, errorStatus(e));
+        }
+      }
+    }));
+    disposers.push(ctx.webServer.register({
+      kind: "exact",
+      path: "/archived-sessions/pending-moves",
+      handler: async (req, res) => {
+        try {
+          const items = await pendingMoves.list();
+          json(res, { items: items.map((i) => ({ sessionId: i.sessionId, targetPath: i.targetPath, queuedAt: i.queuedAt, attempts: i.attempts })) });
+        } catch (e) {
+          json(res, { error: String(e && e.message || e) }, 500);
+        }
+      }
+    }));
+    disposers.push(ctx.webServer.register({
+      kind: "exact",
+      path: "/archived-sessions/pending-moves/cancel",
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req);
+          const ids = parseIds(body);
+          if (!ids || ids.length === 0) return json(res, { ok: false, error: "missing sessionIds" }, 400);
+          const removed = await pendingMoves.remove(ids);
+          json(res, { ok: true, removed });
+        } catch (e) {
+          json(res, { ok: false, error: String(e && e.message || e) }, errorStatus(e));
+        }
+      }
+    }));
     disposers.push(ctx.webServer.register({
       kind: "exact",
       path: "/archived-sessions/archive",