dsh-sessions-manager 3.6.0 → 3.6.2

package/lib/index.js

@@ -614,6 +614,12 @@ function fingerprintOf(stat5) {
 function isPersistableFingerprint(fingerprint) {
   return typeof fingerprint === "string" && fingerprint !== "" && !fingerprint.startsWith(REVISION_PREFIX);
 }
+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(stat5);
@@ -696,7 +702,7 @@ function createSessionMetaCache(opts = {}) {
 // src/title-persist-index.js
 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 TITLE_INDEX_SCHEMA_VERSION = 2;
 var MAX_ENTRIES = 2e4;
 function normalizeEntry(raw) {
   if (!raw || typeof raw !== "object") return null;
@@ -705,9 +711,13 @@ 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;
+  const resolved = raw.resolved === true || raw.resolved === 1;
   if (!fingerprint || fingerprint.startsWith("rev:")) return null;
   if (!title && !cwd) return null;
-  return { title, cwd, createdAt, fingerprint, updatedAt };
+  if (!title && !resolved) return null;
+  const entry = { title, cwd, createdAt, fingerprint, updatedAt };
+  if (resolved) entry.resolved = 1;
+  return entry;
 }
 function normalizeTitleIndex(raw) {
   const entries = {};
@@ -1408,7 +1418,7 @@ function classifyLineage(header, sizeBytes) {
 }
 
 // src/index.js
-var BUILD_STAMP = true ? "3.6.0 built 2026-09-10T09:47:49.428Z" : "dev";
+var BUILD_STAMP = true ? "3.6.2+e36dc3fc" : "dev";
 var name = "dsh-sessions-manager";
 var inject = ["webServer", "workspaceRegistry", "sessionPersistence", "sessionQuery", "storageDomain"];
 var MAX_TITLE = 80;
@@ -1493,20 +1503,6 @@ function getActiveSessionId(context) {
   }
   return null;
 }
-function foldTitle(events) {
-  let found = null;
-  let firstUser = null;
-  for (const ev of events) {
-    if (ev.type === "session/title" && ev.data && typeof ev.data.title === "string" && ev.data.title.length) {
-      found = ev.data.title;
-    }
-    if (firstUser === null && ev.type === "user/message" && ev.data && Array.isArray(ev.data.content)) {
-      const txt = ev.data.content.filter((b) => b && b.type === "text").map((b) => b.text).filter(Boolean).join(" ").trim();
-      if (txt) firstUser = txt;
-    }
-  }
-  return found || firstUser || null;
-}
 function apply(ctx) {
   const w = ctx.workspaceRegistry;
   const sp = ctx.sessionPersistence;
@@ -1530,9 +1526,9 @@ function apply(ctx) {
       const stat5 = statsById.get(id);
       const entry = store && store[id];
       if (!stat5 || !entry) continue;
-      const fp = fingerprintOf(stat5);
-      if (!isPersistableFingerprint(fp)) continue;
-      if (fp && entry.fingerprint === fp) {
+      const fp = persistFingerprintOf(stat5);
+      if (!fp) continue;
+      if (entry.fingerprint === fp && (entry.title || entry.resolved)) {
         hits.set(id, { title: entry.title, cwd: entry.cwd, createdAt: entry.createdAt });
       }
     }
@@ -1542,10 +1538,12 @@ function apply(ctx) {
     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;
-      batch[id] = { title: meta.title, cwd: meta.cwd, createdAt: meta.createdAt, fingerprint: fp, updatedAt: now };
+    for (const [id, pack] of decoded) {
+      if (!pack || !pack.resolved) continue;
+      const meta = pack.meta;
+      const fp = persistFingerprintOf(statsById.get(id));
+      if (!fp) continue;
+      batch[id] = { title: meta.title, cwd: meta.cwd, createdAt: meta.createdAt, fingerprint: fp, updatedAt: now, resolved: 1 };
     }
     if (!Object.keys(batch).length) return;
     try {
@@ -1623,50 +1621,153 @@ 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;
+  const WARM_MAX_ATTEMPTS = 5;
+  const warmFail = /* @__PURE__ */ new Map();
+  function warmFpOf(stat5) {
+    return fingerprintOf(stat5) || persistFingerprintOf(stat5);
+  }
+  function warmBlocked(id, fp) {
+    const rec = warmFail.get(id);
+    if (!rec) return 0;
+    if (fp && rec.fp && rec.fp !== fp) {
+      warmFail.delete(id);
+      return 0;
     }
-    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);
+    const now = Date.now();
+    return rec.nextAt > now ? rec.nextAt - now : 0;
+  }
+  function warmMarkFailure(id, stat5, header) {
+    const rec = warmFail.get(id) || { count: 0, fp: null, nextAt: 0 };
+    rec.count += 1;
+    rec.fp = warmFpOf(stat5) || rec.fp;
+    if (stat5) rec.stat = stat5;
+    if (header) rec.header = header;
+    const backoff = rec.count >= WARM_MAX_ATTEMPTS ? 60 * 60 * 1e3 : Math.min(5 * 60 * 1e3, 15 * 1e3 * Math.pow(2, rec.count));
+    rec.nextAt = Date.now() + backoff;
+    warmFail.set(id, rec);
+  }
+  function warmPendingNow() {
+    if (!warmHasApi) return false;
+    if (warmRunning || warmQueue.size) return true;
+    for (const rec of warmFail.values()) if (rec.nextAt > Date.now()) return true;
+    return false;
+  }
+  let warmRetryTimer = null;
+  function scheduleWarmRetry() {
+    if (warmRetryTimer) return;
+    let soonest = 0;
+    for (const rec of warmFail.values()) {
+      const wait = rec.nextAt - Date.now();
+      if (wait <= 0) {
+        soonest = 1;
+        break;
+      }
+      if (!soonest || wait < soonest) soonest = wait;
+    }
+    if (!soonest) return;
+    warmRetryTimer = setTimeout(() => {
+      warmRetryTimer = null;
+      const now = Date.now();
+      for (const [id, rec] of warmFail) {
+        if (rec.nextAt <= now && !warmQueue.has(id)) warmQueue.set(id, { stat: rec.stat || null, header: rec.header || null });
+      }
+      if (warmQueue.size) scheduleWarm();
+    }, soonest);
+    if (typeof warmRetryTimer.unref === "function") warmRetryTimer.unref();
+  }
+  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;
+    if (!warmHasApi) return;
+    for (const id of ids) {
+      const key = String(id);
+      const stat5 = statsById ? statsById.get(key) || null : null;
+      const fp = warmFpOf(stat5);
+      if (!fp) continue;
+      const blockedMs = warmBlocked(key, fp);
+      const entry = entryById ? entryById.get(key) : null;
+      const rec = warmFail.get(key);
+      if (rec) {
+        rec.stat = stat5 || rec.stat;
+        if (entry) rec.header = entry.header || rec.header;
+      }
+      if (blockedMs > 0) continue;
+      warmQueue.set(key, {
+        stat: stat5,
+        header: entry && entry.header || null
+      });
+    }
+    if (warmQueue.size) scheduleWarm();
+    scheduleWarmRetry();
+  }
+  async function backfillTrashTitles(decoded) {
+    if (!decoded || !decoded.size) return;
+    try {
+      const items = await readTrash();
+      const worth = items.some((t) => !t.title && decoded.get(String(t.sessionId)) && decoded.get(String(t.sessionId)).meta && decoded.get(String(t.sessionId)).meta.title);
+      if (!worth) return;
+      await mutateTrash((store) => {
+        for (const item of store.items) {
+          if (item.title) continue;
+          const pack = decoded.get(String(item.sessionId));
+          const t = pack && pack.meta && pack.meta.title;
+          if (t) item.title = String(t);
+        }
+      });
+    } catch (e) {
+    }
+  }
+  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 resultById = await projectTitlesStatus(ids);
+          const decoded = /* @__PURE__ */ new Map();
+          const statsById = /* @__PURE__ */ new Map();
+          for (const [id, desc] of batch) {
+            const r = resultById.get(id);
+            if (!r || !r.resolved) {
+              warmMarkFailure(id, desc.stat, desc.header);
+              continue;
+            }
+            warmFail.delete(id);
+            const meta = metaFromSnapshot(r.snapshot || null);
+            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);
+            decoded.set(id, { meta, resolved: true });
           }
-        });
-        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);
+          await backfillTrashTitles(decoded);
+        } catch (e) {
         }
-        if (!meta.title && foldedTitle) meta.title = foldedTitle;
-      } catch (e2) {
+        await new Promise((resolve) => setImmediate(resolve));
       }
+    } finally {
+      warmRunning = false;
+      if (warmQueue.size) scheduleWarm();
+      scheduleWarmRetry();
     }
-    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();
@@ -1690,7 +1791,7 @@ 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));
@@ -1785,30 +1886,19 @@ function apply(ctx) {
         cwd = header.cwd || null;
         title = header.title || header.meta && header.meta.title || null;
       }
-      if (!title) {
-        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;
+          const delStat = persistenceEntry && typeof persistenceEntry.revision === "string" && persistenceEntry.revision ? { revision: persistenceEntry.revision, sizeBytes: Number.isFinite(persistenceEntry.sizeBytes) ? Number(persistenceEntry.sizeBytes) : void 0 } : removedPath ? await stat4(removedPath).then((st) => ({ mtimeMs: st.mtimeMs, size: st.size })) : null;
+          if (delStat) {
+            const m = metaCache.get(sid, delStat) || (await hydrateFromPersist([sid], /* @__PURE__ */ new Map([[sid, delStat]]))).get(sid);
+            if (m && m.title) title = String(m.title);
+          }
         } catch (e) {
         }
+        if (!title) {
+          const at = authorityTitleCache.get(sid);
+          if (at) title = String(at);
+        }
       }
     } catch (e) {
     }
@@ -1820,8 +1910,10 @@ function apply(ctx) {
     const archived = await mutateArchived((list) => ({ next: null, value: list.includes(sid) })).catch(() => false);
     await mutateTrash((store) => {
       const entry = {
+        // v3.6.2 #7：不再把 cwd/裸 id 冒充标题永久定格——存 null，预热解出后
+        // backfillTrashTitles 补写；渲染端（t.title || t.sessionId）自然降级。
         sessionId: sid,
-        title: title || cwd || sid,
+        title: title || null,
         cwd: cwd || null,
         header: header || null,
         originalPath: removedPath || null,
@@ -2436,19 +2528,50 @@ function apply(ctx) {
       return { next: null, value: { ok: true, archived: true } };
     });
   }
-  async function projectTitles(ids) {
+  const warmHasApi = typeof sq.readTitleSnapshots === "function" || typeof sq.readTitleSnapshot === "function";
+  async function projectTitlesStatus(ids) {
     const out = /* @__PURE__ */ new Map();
+    const markAll = (resolved) => {
+      for (const id of ids) out.set(String(id), { resolved, snapshot: null });
+    };
     if (!ids || !ids.length) return out;
-    if (typeof sq.readTitleSnapshots !== "function") return out;
-    try {
-      const results = await sq.readTitleSnapshots(ids);
-      if (!Array.isArray(results)) return out;
-      results.forEach((result, index) => {
-        const id = String(ids[index]);
-        out.set(id, unwrapSnapshot(result));
-      });
-    } catch (e) {
+    if (!warmHasApi) {
+      markAll(false);
+      return out;
+    }
+    if (typeof sq.readTitleSnapshots === "function") {
+      let results = null;
+      try {
+        results = await sq.readTitleSnapshots(ids);
+      } catch (e) {
+        results = null;
+      }
+      if (Array.isArray(results)) {
+        results.forEach((result, index) => {
+          const id = String(ids[index]);
+          if (result && result.status === "fulfilled") out.set(id, { resolved: true, snapshot: unwrapSnapshot(result) });
+          else if (result && result.status === "rejected") out.set(id, { resolved: false, snapshot: null });
+          else if (result) out.set(id, { resolved: true, snapshot: unwrapSnapshot(result) });
+          else out.set(id, { resolved: false, snapshot: null });
+        });
+        for (const id of ids) if (!out.has(String(id))) out.set(String(id), { resolved: false, snapshot: null });
+        return out;
+      }
+    }
+    if (typeof sq.readTitleSnapshot === "function") {
+      for (const raw of ids) {
+        const id = String(raw);
+        try {
+          const r = await sq.readTitleSnapshot(id);
+          if (r && r.status === "rejected") out.set(id, { resolved: false, snapshot: null });
+          else out.set(id, { resolved: true, snapshot: unwrapSnapshot(r) });
+        } catch (e) {
+          out.set(id, { resolved: false, snapshot: null });
+        }
+      }
+      return out;
     }
+    markAll(false);
     return out;
   }
   async function allSessionItemsDetailed(opts = {}) {
@@ -2491,35 +2614,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 };
     }
-    await persistDecoded(decoded, statsById);
     let starredSet = /* @__PURE__ */ new Set();
     try {
       starredSet = new Set((await stars.read()).starredSessionIds);
@@ -2597,36 +2733,28 @@ 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));
       }
-      await persistDecoded(decoded, statsById);
     }
     const lineage = {};
     for (const entry of entries) {
@@ -2638,40 +2766,53 @@ function apply(ctx) {
       titles: Object.fromEntries(authorityTitleCache),
       trashedSessionIds: store.items.map((item) => String(item.sessionId)),
       purgedSessionIds: activeTombstones,
-      lineage
+      lineage,
+      // v3.6.2：还有预热/退避重试在途 → client 缩短轮询节拍，预热一完成就把
+      // 补齐的标题送回（含面板自动刷新）。无预热 API 时恒 false，绝不假忙。
+      warmPending: warmPendingNow()
     };
   }
   const emptyScanCache = /* @__PURE__ */ new Map();
+  const REFINE_BUDGET = 40;
+  function applyEmptyScan(lineage, id, empty) {
+    if (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];
+    }
+  }
   async function refineEmptyLineage(lineage, entries) {
     if (!persistence || typeof persistence.inspectSession !== "function") return;
+    const limiter = createLimiter(4);
+    const todo = [];
     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 scanned = emptyScanCache.get(id);
+      if (scanned && scanned.sizeBytes === size) {
+        applyEmptyScan(lineage, id, scanned.empty);
+        continue;
       }
+      if (todo.length < REFINE_BUDGET) todo.push({ id, size });
     }
+    await Promise.all(todo.map(({ id, size }) => limiter(async () => {
+      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;
+      }
+      emptyScanCache.set(id, { sizeBytes: size, empty: isEmpty });
+      applyEmptyScan(lineage, id, isEmpty);
+    })));
     const live = /* @__PURE__ */ new Set();
     for (const entry of entries) {
       const size = entry && Number.isFinite(entry.sizeBytes) ? entry.sizeBytes : null;
@@ -2866,12 +3007,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);
@@ -3072,7 +3211,7 @@ function apply(ctx) {
       path: "/archived-sessions/sessions",
       handler: async (req, res) => {
         try {
-          json(res, { items: await allSessionItems() });
+          json(res, { items: await allSessionItems(), warmPending: warmPendingNow() });
         } catch (e) {
           json(res, { error: String(e && e.message || e) }, 500);
         }
@@ -3176,9 +3315,18 @@ function apply(ctx) {
             });
             if (Number.isFinite(sizeBytes)) sizeById.set(id, sizeBytes);
           };
+          const lineageStats = /* @__PURE__ */ new Map();
+          const lineageHeaders = /* @__PURE__ */ new Map();
           try {
             for (const entry of await persistence.listEntries()) {
               addHeader(entry.header, entry.sizeBytes);
+              const eid = entry && entry.id != null ? String(entry.id) : null;
+              if (eid) {
+                lineageHeaders.set(eid, { header: entry && entry.header || null });
+                if (entry && typeof entry.revision === "string" && entry.revision) {
+                  lineageStats.set(eid, Number.isFinite(entry.sizeBytes) ? { revision: entry.revision, sizeBytes: Number(entry.sizeBytes) } : { revision: entry.revision });
+                }
+              }
               if (entry && entry.id != null) persistedIds.add(String(entry.id));
             }
           } catch (e) {
@@ -3230,11 +3378,17 @@ function apply(ctx) {
             n.children.forEach(walk);
           };
           nodes.forEach(walk);
-          const titles = await projectTitles(allIds);
+          const lineageIds = allIds.map(String);
+          const { cached: lineageCached, missing: lineageMissing } = metaCache.partition(lineageIds, lineageStats);
+          const lineagePersisted = await hydrateFromPersist(lineageMissing, lineageStats);
+          for (const [id, meta] of lineagePersisted) metaCache.set(id, lineageStats.get(id), meta);
+          const lineageRest = lineageMissing.filter((id) => !lineagePersisted.has(id));
+          if (lineageRest.length) enqueueWarm(lineageRest, lineageStats, lineageHeaders);
+          const truncateTitle = (t) => t ? t.length > MAX_TITLE ? t.slice(0, MAX_TITLE) + "\u2026" : t : null;
           const titleOf = (id) => {
-            const snap = titles.get(id);
-            const m = snap ? metaFromSnapshot(snap) : null;
-            return m && m.title || null;
+            const key = String(id);
+            const m = lineageCached.get(key) || lineagePersisted.get(key);
+            return truncateTitle(m && m.title || authorityTitleCache.get(key) || null);
           };
           const fill = (n) => {
             n.title = titleOf(n.sessionId);