dsh-sessions-manager 3.4.1 → 3.5.0

package/src/index.js

@@ -16,7 +16,10 @@ import { renderSessionMarkdown } from './markdown.js'
 import { createStarIndex } from './star-index.js'
 import { aggregateStorage } from './storage-stats.js'
 import { createAutoArchiveStore, pickInactiveCandidates } from './auto-archive.js'
-import { createSessionMetaCache } from './session-meta-cache.js'
+import { createSessionMetaCache, fingerprintOf } from './session-meta-cache.js'
+import { createTitleIndexStore } from './title-persist-index.js'
+import { createPersistenceAdapter } from './compat/persistence.js'
+import { detectCapabilities, requireCapability } from './compat/capabilities.js'
 
 
 export const name = 'dsh-sessions-manager'
@@ -121,6 +124,8 @@ function foldTitle(events) {
 export function apply(ctx) {
   const w = ctx.workspaceRegistry
   const sp = ctx.sessionPersistence
+  const persistence = createPersistenceAdapter(sp)
+  const capabilities = detectCapabilities({ persistence: sp, workspaceRegistry: w })
   const sq = ctx.sessionQuery
   const dom = () => ctx.storageDomain.get('workspace')
   const authorityTitleCache = new Map()
@@ -128,6 +133,44 @@ export function apply(ctx) {
   // 见 src/session-meta-cache.js 的说明：列表构建原本每条会话都要整本解压日志，
   // 这个缓存让「日志没变」的会话直接跳过解码。
   const metaCache = createSessionMetaCache()
+  // 持久标题索引（冷启动加速）：metaCache 是进程内的，重启即空——第一次列表
+  // 仍要全库解码。索引按同样的 (mtime, size) 指纹存解码结果，指纹没变的会话
+  // 重启后也直接复用。见 src/title-persist-index.js。
+  const titleIndex = createTitleIndexStore({ dir: TRASH_DIR, file: join(TRASH_DIR, 'title-index.json') })
+
+  // P4：对「内存缓存未命中」的会话查持久索引，指纹一致才可信。
+  // 返回 Map<id, meta>；调用方应把命中条目回填 metaCache 并从 missing 里剔除。
+  async function hydrateFromPersist(ids, statsById) {
+    const hits = new Map()
+    if (!ids || !ids.length) return hits
+    let store
+    try { store = await titleIndex.entries() } catch (e) { return hits }
+    for (const id of ids) {
+      const stat = statsById.get(id)
+      const entry = store && store[id]
+      if (!stat || !entry) continue
+      const fp = fingerprintOf(stat)
+      if (fp && entry.fingerprint === fp) {
+        hits.set(id, { title: entry.title, cwd: entry.cwd, createdAt: entry.createdAt })
+      }
+    }
+    return hits
+  }
+
+  // 把本批真正解码出的元数据异步回写持久索引（fire-and-forget：索引只是
+  // 加速器，写失败不影响响应，队列内部已串行化 + 原子替换）。
+  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 (!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(() => {})
+  }
 
   // 从投影快照里抽出元数据；快照缺失/异常时返回零值 meta（调用方决定兜底）。
   function metaFromSnapshot(o) {
@@ -230,7 +273,7 @@ export function apply(ctx) {
     // 且结果同样会进缓存，下一次列表就不会再走一遍）。
     if (!meta.title || !meta.cwd) {
       try {
-        const r = await sp.readFrom(id, 0)
+        const r = await persistence.readSession(id, 0)
         if (r.meta) {
           if (!meta.cwd) meta.cwd = r.meta.cwd || null
           if (!meta.createdAt) meta.createdAt = r.meta.createdAt || null
@@ -239,6 +282,8 @@ export function apply(ctx) {
       } catch (e2) { /* keep what we have */ }
     }
     metaCache.set(key, statInfo, meta)
+    // 本条是「真解码」出来的：交给调用方回写持久标题索引（P4 冷启动加速）。
+    if (opts.collectDecoded && statInfo) opts.collectDecoded(key, meta)
     return buildItem(key, meta, usage, opts.exposeUsage)
   }
 
@@ -254,17 +299,19 @@ export function apply(ctx) {
   async function collectUsage(preloadedHeaders) {
     const sizeById = new Map()
     const mtimeById = new Map()
-    let headers = null
-    if (Array.isArray(preloadedHeaders)) headers = preloadedHeaders
-    else { try { headers = await sp.list() } catch (e) { headers = [] } }
-    if (!Array.isArray(headers)) headers = []
+    let entries = null
+    if (Array.isArray(preloadedHeaders)) entries = preloadedHeaders
+    else { try { entries = await persistence.listEntries() } catch (e) { entries = [] } }
+    if (!Array.isArray(entries)) entries = []
     const CHUNK = 8
-    for (let i = 0; i < headers.length; i += CHUNK) {
-      await Promise.all(headers.slice(i, i + CHUNK).map(async (header) => {
-        const id = header && header.id != null ? String(header.id) : null
+    for (let i = 0; i < entries.length; i += CHUNK) {
+      await Promise.all(entries.slice(i, i + CHUNK).map(async (entry) => {
+        const header = entry && entry.header ? entry.header : entry
+        const id = entry && entry.id != null ? String(entry.id) : (header && header.id != null ? String(header.id) : null)
         if (!id) return
+        if (entry && Number.isFinite(entry.sizeBytes)) sizeById.set(id, Number(entry.sizeBytes))
         try {
-          const loc = sp.locate(header)
+          const loc = persistence.locate(header)
           if (!loc || typeof loc.path !== 'string' || !loc.path) return
           const st = await stat(loc.path)
           if (!st) return
@@ -352,17 +399,20 @@ export function apply(ctx) {
     let cwd = null
     let title = null
     let removedPath = null
+    let persistenceEntry = null
     try {
-      const headers = await sp.list()
-      header = headers.find((h) => String(h.id) === sid) || null
+      const entries = await persistence.listEntries()
+      const found = entries.find((entry) => entry.id === sid) || null
+      persistenceEntry = found
+      header = found ? found.header : null
       if (header) {
-        const loc = sp.locate(header)
+        const loc = persistence.locate(header)
         if (loc && typeof loc.path === 'string') removedPath = loc.path
         cwd = header.cwd || null
         title = header.title || (header.meta && header.meta.title) || null
       }
       if (!title) {
-        const r = await sp.readFrom(sid, 0)
+        const r = await persistence.readSession(sid, 0)
         if (r && r.meta) { if (!cwd) cwd = r.meta.cwd; title = foldTitle(r.events) }
       }
     } catch (e) { /* best-effort */ }
@@ -377,7 +427,7 @@ export function apply(ctx) {
       const entry = {
         sessionId: sid, title: title || cwd || sid, cwd: cwd || null,
         header: header || null, originalPath: removedPath || null,
-        sizeBytes: header && typeof header.size === 'number' ? header.size : null,
+        sizeBytes: persistenceEntry && Number.isFinite(persistenceEntry.sizeBytes) ? persistenceEntry.sizeBytes : null,
         wasArchived: archived, deletedAt: Date.now(),
       }
       const at = store.items.findIndex((t) => String(t.sessionId) === sid)
@@ -410,18 +460,24 @@ export function apply(ctx) {
   // the original workspace dir) and detach it from any workspace so DSH drops it.
   async function purgeFromTrash(sid) {
     requireSessionId(sid)
+    requireCapability(capabilities, 'purge')
     let purged = false
     await mutateTrash(async (store) => {
       const entry = store.items.find((t) => String(t.sessionId) === sid)
       if (!entry) { const error = new Error('回收站中找不到该会话'); error.status = 404; throw error }
       let target = null
       try {
-        const headers = await sp.list()
-        const current = headers.find((h) => String(h.id) === sid)
-        const located = current && sp.locate(current)
+        const entries = await persistence.listEntries()
+        const current = entries.find((entry) => entry.id === sid)
+        const located = current && persistence.locate(current.header)
         if (located && typeof located.path === 'string') target = located.path
       } catch (e) {}
       if (!target && typeof entry.originalPath === 'string') target = entry.originalPath
+      if (!target) {
+        const error = new Error('无法确认该会话的物理日志位置，已停止永久删除')
+        error.status = 409
+        throw error
+      }
       // JSONL persistence stores logs as
       //   .../<sessionId>/session.jsonl.zstd
       // Older backends may instead include the id in the filename itself.
@@ -491,6 +547,7 @@ export function apply(ctx) {
   }
 
   async function cleanupExpiredTrash() {
+    if (!capabilities.actions.purge.available) return 0
     const store = await readTrashStore()
     const days = store.settings.retentionDays
     if (!days) return 0
@@ -526,6 +583,7 @@ export function apply(ctx) {
   }
 
   async function moveOne(sid, targetPath) {
+    requireCapability(capabilities, 'move')
     // Only block the *active* conversation. ctx.sessions keeps instantiated
     // sessions alive after you switch away, so the old check (sessions.get(sid))
     // wrongly rejected every opened session — you could never move one you'd
@@ -536,7 +594,7 @@ export function apply(ctx) {
     if (activeId != null && String(activeId) === String(sid)) {
       throw new Error('该会话当前处于打开状态，请先切换到别的会话再移动。')
     }
-    const r = await sp.readFrom(sid, 0)
+    const r = await persistence.readSession(sid, 0)
     if (!r || !r.meta) throw new Error('无法读取该会话的日志')
     const meta = r.meta
     const events = r.events
@@ -620,7 +678,7 @@ export function apply(ctx) {
       // disk, and WorkspaceEntity.sessionIds filters by that exact cwd. A bare
       // rename would leave frame0 pointing at the old workspace, so reindex /
       // restart would keep attributing the session to the wrong workspace.
-      await relocateLog(meta, newHeader)
+      if (!await relocateLog(meta, newHeader)) throw new Error('移动失败：无法确认会话日志已迁移到目标工作区')
       // Redirect the persistence state's cwd so future appends land in newPath.
       try {
         const st = sp.states && sp.states.get && sp.states.get(sid)
@@ -642,7 +700,7 @@ export function apply(ctx) {
 
       if (typeof sp.create !== 'function' || typeof sp.append !== 'function') {
         // No create primitive: must relocate the existing log directly.
-        await relocateLog(meta, newHeader)
+        if (!await relocateLog(meta, newHeader)) throw new Error('移动失败：无法确认会话日志已迁移到目标工作区')
       } else {
         const backupPath = oldPath ? `${oldPath}.move-backup-${Date.now()}` : null
         if (backupPath) { try { await rename(oldPath, backupPath) } catch (e) { if (e && e.code !== 'ENOENT') throw new Error('移动失败：无法备份旧的会话日志') } }
@@ -650,7 +708,7 @@ export function apply(ctx) {
         try {
           await sp.create(newHeader)
           await sp.append(sid, events)
-          const check = await sp.readFrom(sid, 0)
+          const check = await persistence.readSession(sid, 0)
           if (!check || !check.meta || check.meta.cwd !== canonical) {
             throw new Error('移动后校验失败：会话工作目录未正确更新')
           }
@@ -660,7 +718,7 @@ export function apply(ctx) {
             // Collision: the session is already materialized in states (archived
             // or previously opened). Fall back to physically relocating the log.
             await restore()
-            await relocateLog(meta, newHeader)
+            if (!await relocateLog(meta, newHeader)) throw new Error('移动失败：无法确认会话日志已迁移到目标工作区')
           } else {
             await restore()
             throw new Error('移动会话日志失败：' + String((e && e.message) || e))
@@ -722,10 +780,10 @@ export function apply(ctx) {
   async function reindexRegistry() {
     const reg = w
     if (!reg || typeof reg.replaceHeaderIndex !== 'function') return false
-    let headers = null
-    try { headers = await sp.list() } catch (e) { headers = null }
-    if (!headers || !Array.isArray(headers)) return false
-    await reg.replaceHeaderIndex(headers)
+    let entries = null
+    try { entries = await persistence.listEntries() } catch (e) { entries = null }
+    if (!entries || !Array.isArray(entries)) return false
+    await reg.replaceHeaderIndex(entries.map((entry) => entry.header))
     if (typeof reg.rebuildEntities === 'function') reg.rebuildEntities()
     return true
   }
@@ -779,15 +837,15 @@ export function apply(ctx) {
   //      是元数据缓存能否跳过整本解码的前提，收益远大于成本
   //   3. 未命中缓存的会话走**一次**批量投影（sq.readTitleSnapshots），而不是逐条
   async function allSessionItems(opts = {}) {
-    let headers = []
+    let entries = []
     let headersOk = false
     try {
-      headers = await sp.list()
-      headersOk = Array.isArray(headers)
-      if (!headersOk) headers = []
-    } catch (e) { headers = [] }
+      entries = await persistence.listEntries()
+      headersOk = Array.isArray(entries)
+      if (!headersOk) entries = []
+    } catch (e) { entries = [] }
     let live = ctx.get('sessions')
-    const ids = headers.map((h) => String(h.id))
+    const ids = entries.map((entry) => entry.id)
     if (live) { try { live.list().forEach((s) => { const sid = String(s.id); if (!ids.includes(sid)) ids.push(sid) }) } catch (e) { /* ignore */ } }
     // Exclude sessions already moved to the recycle bin (软删除): they live in
     // 回收站, not in 会话管理, so the panel won't re-list them after a delete.
@@ -801,11 +859,17 @@ export function apply(ctx) {
     try { for (const ent of w.list()) wsByPath[ent.path] = ent } catch (e) { wsByPath = {} }
     const currentArchived = new Set((await archivedState().catch(() => ({ archivedSessionIds: [] }))).archivedSessionIds || [])
     const items = []
-    const usage = await collectUsage(headers)
+    const usage = await collectUsage(entries)
     // 先按指纹把「缓存命中」与「需要解码」分开，只对后者做批量投影。
     const statsById = new Map(visibleIds.map((id) => [id, { mtimeMs: usage.mtimeById.get(id), size: usage.sizeById.get(id) }]))
     const { cached, missing } = metaCache.partition(visibleIds, statsById)
-    const snapshotById = await projectTitles(missing)
+    // P4：missing 里先查持久标题索引（冷启动跳过整本解码），命中的回填内存缓存。
+    const persisted = await hydrateFromPersist(missing, statsById)
+    for (const [id, meta] of persisted) metaCache.set(id, statsById.get(id), meta)
+    const stillMissing = missing.filter((id) => !persisted.has(id))
+    const snapshotById = await projectTitles(stillMissing)
+    const decoded = new Map()
+    const collectDecoded = (id, meta) => { decoded.set(id, meta) }
     const CHUNK = 6
     for (let i = 0; i < visibleIds.length; i += CHUNK) {
       // Arrow wrapper on purpose: Array#map passes (value, index, array), and
@@ -813,9 +877,11 @@ export function apply(ctx) {
       const res2 = await Promise.all(visibleIds.slice(i, i + CHUNK).map((id) => resolveOne(id, usage, {
         exposeUsage: !!(opts && opts.usage),
         preloaded: snapshotById.has(id) ? snapshotById.get(id) : undefined,
+        collectDecoded,
       })))
       for (const it of res2) items.push({ ...it, archived: currentArchived.has(it.sessionId) })
     }
+    persistDecoded(decoded, statsById)
     // Annotate stars; GC only when we have a trustworthy id baseline, so a
     // failing sp.list() can never wipe the whole index.
     let starredSet = new Set()
@@ -878,30 +944,38 @@ export function apply(ctx) {
   // 既不会陈旧也不会回到「每次全量解码」。
   async function sidebarAuthority() {
     const ids = []
-    let headers = []
-    try { headers = await sp.list() } catch (e) { headers = [] }
-    if (!Array.isArray(headers)) headers = []
-    for (const header of headers) ids.push(String(header.id))
+    let entries = []
+    try { entries = await persistence.listEntries() } catch (e) { entries = [] }
+    if (!Array.isArray(entries)) entries = []
+    for (const entry of entries) ids.push(entry.id)
     const sessions = ctx.get('sessions')
     try { if (sessions) sessions.list().forEach((session) => { const sid = String(session.id); if (!ids.includes(sid)) ids.push(sid) }) } catch (e) {}
     const store = await readTrashStore()
     if (ids.length) {
-      const usage = await collectUsage(headers)
+      const usage = await collectUsage(entries)
       const statsById = new Map(ids.map((id) => [id, { mtimeMs: usage.mtimeById.get(id), size: usage.sizeById.get(id) }]))
       const { cached, missing } = metaCache.partition(ids, statsById)
-      const snapshotById = await projectTitles(missing)
+      // P4：与列表构建共用持久标题索引，冷启动零解码。
+      const persisted = await hydrateFromPersist(missing, statsById)
+      for (const [id, meta] of persisted) metaCache.set(id, statsById.get(id), meta)
+      const rest = missing.filter((id) => !persisted.has(id))
+      const snapshotById = await projectTitles(rest)
+      const decoded = new Map()
+      const collectDecoded = (id, meta) => { decoded.set(id, meta) }
       for (const id of ids) {
-        let meta = cached.get(id) || null
+        let meta = cached.get(id) || persisted.get(id) || null
         if (!meta) {
           const snapshot = snapshotById.has(id)
             ? snapshotById.get(id)
             : (typeof sq.readTitleSnapshot === 'function' ? await sq.readTitleSnapshot(id).catch(() => null) : null)
           const next = metaFromSnapshot(snapshot)
           metaCache.set(id, statsById.get(id), next)
+          if (statsById.get(id)) collectDecoded(id, next)
           meta = next
         }
         if (meta && meta.title) authorityTitleCache.set(id, String(meta.title))
       }
+      persistDecoded(decoded, statsById)
     }
     return {
       titles: Object.fromEntries(authorityTitleCache),
@@ -923,7 +997,7 @@ export function apply(ctx) {
       meta = (live && live.header) || null
       try { events = Array.isArray(live.events) ? [...live.events] : [] } catch (e) { events = [] }
     } else {
-      const r = await sp.readFrom(sid, 0)
+      const r = await persistence.readSession(sid, 0)
       if (!r || !r.meta) throw new Error('找不到该会话的记录（会话不存在）')
       meta = r.meta
       events = Array.isArray(r.events) ? r.events : []
@@ -932,7 +1006,7 @@ export function apply(ctx) {
     try {
       // rc.8 的 sessionPersistence 后端没有 artifactInfo；用 locate(meta) 拿日志
       // 文件真实路径后 stat 出字节数（磁盘占用）。
-      const loc = sp.locate(meta)
+      const loc = persistence.locate(meta)
       if (loc && typeof loc.path === 'string' && loc.path) {
         const st = await stat(loc.path)
         if (st && typeof st.size === 'number') sizeBytes = st.size
@@ -1005,7 +1079,8 @@ export function apply(ctx) {
     const subagentSet = new Set()
     try {
       if (typeof sp.list === 'function') {
-        for (const h of await sp.list()) {
+        for (const entry of await persistence.listEntries()) {
+          const h = entry.header
           if (String(h.parentSession) !== String(sid)) continue
           if (h.origin === 'subagent') subagentSet.add(h.id); else childrenSet.add(h.id)
         }
@@ -1041,6 +1116,12 @@ export function apply(ctx) {
       }
     }))
 
+    disposers.push(ctx.webServer.register({
+      kind: 'exact',
+      path: '/archived-sessions/capabilities',
+      handler: async (req, res) => json(res, capabilities),
+    }))
+
     disposers.push(ctx.webServer.register({
       kind: 'exact',
       path: '/archived-sessions/list',
@@ -1053,8 +1134,8 @@ export function apply(ctx) {
           let materialized = new Set()
           let live = ctx.get('sessions')
           try {
-            const headers = await sp.list()
-            materialized = new Set(headers.map((h) => String(h.id)))
+            const entries = await persistence.listEntries()
+            materialized = new Set(entries.map((entry) => entry.id))
           } catch (e) { /* best-effort */ }
           const trashStore = await readTrashStore()
           const hidden = new Set([...trashStore.items.map((item) => String(item.sessionId)), ...trashStore.purgedSessionIds.map(String)])
@@ -1100,11 +1181,11 @@ export function apply(ctx) {
           const results = []
           for (const sid of ids) {
             try { results.push({ sessionId: sid, ok: true, ...(await restoreOne(sid)) }) }
-            catch (e) { results.push({ sessionId: sid, ok: false, error: String((e && e.message) || e) }) }
+            catch (e) { results.push({ sessionId: sid, ok: false, code: e && e.code, error: String((e && e.message) || e) }) }
           }
           json(res, { ok: true, restored: results.filter((r) => r.ok).length, results })
         } catch (e) {
-          json(res, { ok: false, error: String((e && e.message) || e) }, 500)
+          json(res, { ok: false, code: e && e.code, error: String((e && e.message) || e) }, errorStatus(e))
         }
       },
     }))
@@ -1143,7 +1224,7 @@ export function apply(ctx) {
           }
           json(res, { ok: true, deleted: results.filter((r) => r.ok).length, results })
         } catch (e) {
-          json(res, { ok: false, error: String((e && e.message) || e) }, 500)
+          json(res, { ok: false, code: e && e.code, error: String((e && e.message) || e) }, errorStatus(e))
         }
       },
     }))
@@ -1188,11 +1269,19 @@ export function apply(ctx) {
         try {
           const items = await readTrash()
           const results = await Promise.all(items.map(async (item) => {
-            let exists = false
-            if (typeof item.originalPath === 'string') exists = await stat(item.originalPath).then(() => true).catch(() => false)
-            return { sessionId: item.sessionId, status: exists ? 'ok' : 'missing', originalPath: item.originalPath || null }
+            if (typeof item.originalPath !== 'string' || !item.originalPath) {
+              return { sessionId: item.sessionId, status: 'unverified', originalPath: null }
+            }
+            const exists = await stat(item.originalPath).then(() => true).catch(() => false)
+            return { sessionId: item.sessionId, status: exists ? 'ok' : 'missing', originalPath: item.originalPath }
           }))
-          json(res, { ok: true, healthy: results.filter((r) => r.status === 'ok').length, missing: results.filter((r) => r.status === 'missing').length, results })
+          json(res, {
+            ok: true,
+            healthy: results.filter((r) => r.status === 'ok').length,
+            missing: results.filter((r) => r.status === 'missing').length,
+            unverified: results.filter((r) => r.status === 'unverified').length,
+            results,
+          })
         } catch (e) {
           json(res, { ok: false, error: String((e && e.message) || e) }, errorStatus(e))
         }
@@ -1211,7 +1300,7 @@ export function apply(ctx) {
           metaCache.invalidate(sid)
           json(res, out)
         } catch (e) {
-          json(res, { ok: false, error: String((e && e.message) || e) }, 500)
+          json(res, { ok: false, code: e && e.code, error: String((e && e.message) || e) }, errorStatus(e))
         }
       },
     }))
@@ -1226,9 +1315,11 @@ export function apply(ctx) {
           if (!sid) return json(res, { ok: false, error: 'missing sessionId' }, 400)
           const out = await purgeFromTrash(sid)
           metaCache.invalidate(sid)
+          // 彻底删除：持久标题索引里的条目一并清掉（issue #1 P4）。
+          titleIndex.remove([sid]).catch(() => {})
           json(res, out)
         } catch (e) {
-          json(res, { ok: false, error: String((e && e.message) || e) }, 500)
+          json(res, { ok: false, code: e && e.code, error: String((e && e.message) || e) }, errorStatus(e))
         }
       },
     }))
@@ -1243,12 +1334,12 @@ export function apply(ctx) {
           if (!ids || ids.length === 0) return json(res, { ok: false, error: 'missing sessionIds' }, 400)
           const results = []
           for (const sid of ids) {
-            try { results.push({ sessionId: sid, ok: true, ...(await purgeFromTrash(sid)) }); metaCache.invalidate(sid) }
+            try { results.push({ sessionId: sid, ok: true, ...(await purgeFromTrash(sid)) }); metaCache.invalidate(sid); titleIndex.remove([sid]).catch(() => {}) }
             catch (e) { results.push({ sessionId: sid, ok: false, error: String((e && e.message) || e) }) }
           }
           json(res, { ok: true, purged: results.filter((r) => r.ok).length, results })
         } catch (e) {
-          json(res, { ok: false, error: String((e && e.message) || e) }, 500)
+          json(res, { ok: false, code: e && e.code, error: String((e && e.message) || e) }, errorStatus(e))
         }
       },
     }))
@@ -1298,7 +1389,7 @@ export function apply(ctx) {
           const url = new URL(req.url, 'http://localhost')
           const sid = url.searchParams.get('sessionId')
           requireSessionId(sid)
-          const r = await sp.readFrom(sid, 0)
+          const r = await persistence.readSession(sid, 0)
           if (!r || !r.meta) {
             const error = new Error('无法读取该会话的日志')
             error.status = 404
@@ -1365,7 +1456,7 @@ export function apply(ctx) {
           try { await reindexRegistry() } catch (e) { /* best-effort */ }
           json(res, { sessionId: sid, ...moved })
         } catch (e) {
-          json(res, { ok: false, error: String((e && e.message) || e) }, 500)
+          json(res, { ok: false, code: e && e.code, error: String((e && e.message) || e) }, errorStatus(e))
         }
       },
     }))
@@ -1440,7 +1531,10 @@ export function apply(ctx) {
 
     // Auto-archive settings. A plain read (no patch keys) doubles as the lazy
     // sweep trigger — that is how the once-a-day cleanup gets a chance to run
-    // without a background timer.
+    // without a background timer. The sweep runs in the background so opening
+    // the panel never waits on it (P5, issue #1): the sweep itself already
+    // reuses the metadata caches, and this keeps the settings read latency
+    // independent of library size.
     disposers.push(ctx.webServer.register({
       kind: 'exact',
       path: '/archived-sessions/auto-archive/settings',
@@ -1450,10 +1544,20 @@ export function apply(ctx) {
           const patch = {}
           if (body && Object.prototype.hasOwnProperty.call(body, 'inactiveDays')) patch.inactiveDays = body.inactiveDays
           if (body && Object.prototype.hasOwnProperty.call(body, 'skipStarred')) patch.skipStarred = body.skipStarred
-          const settings = Object.keys(patch).length
+          const isPatch = Object.keys(patch).length > 0
+          const settings = isPatch
             ? await autoArchive.update(patch)
             : (await autoArchive.read()).settings
-          const sweep = await autoArchiveSweep()
+          let sweep
+          if (isPatch) {
+            // 显式保存设置：保持「保存即生效」的同步 sweep（含刚启用时的首次归档）。
+            sweep = await autoArchiveSweep()
+          } else {
+            // 面板打开的纯读取：sweep 转后台执行，打开延迟与库大小解耦
+            //（P5，issue #1）。sweep 本身已复用元数据缓存 + 持久标题索引。
+            void autoArchiveSweep().catch(() => {})
+            sweep = { triggered: true }
+          }
           const store = await autoArchive.read()
           json(res, {
             ok: true,

package/src/title-persist-index.js

@@ -0,0 +1,137 @@
+// title-persist-index.js — 会话标题/元数据的**磁盘**小索引（P4，issue #1）。
+//
+// metaCache（session-meta-cache.js）解决的是「进程内重复解码」；本模块解决
+// 的是冷启动：插件重启后内存缓存为空，第一次列表构建仍要全库解码一次。
+// 把解码出的元数据连同文件指纹原子写进一个 JSON 索引，重启后列表只需
+// 一次索引读 + 指纹比对，指纹没变的会话零解码。
+//
+// 结构仿 trash 的原子写索引：{ schemaVersion, entries: { [sessionId]: entry } }
+// entry = { title, cwd, createdAt, fingerprint, updatedAt }
+//   fingerprint 即 session-meta-cache.js 的 fingerprintOf(stat) 产出
+//   （"<mtimeMs>:<size>"），比对一致即可信任条目内容。
+//
+// 写入时机由调用方决定（列表构建收尾批量回写、purge 时清理），本模块只
+// 提供：读取缓存、合并写入（串行化 + 原子替换）、按 id 删除。任何文件
+// 损坏都按空索引处理，绝不阻塞列表构建。
+//
+// 单实例假设：一个进程内只 apply 一个插件实例（生产即如此），实例间的
+// 内存副本不互相同步——跨「重启」以落盘内容为准（测试亦按此断言）。
+
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+
+export const TITLE_INDEX_SCHEMA_VERSION = 1
+
+const MAX_ENTRIES = 20000
+
+// 条目只保留可序列化且对列表有用的字段；指纹缺失的条目无法校验，直接丢弃——
+// 宁可下次重解码，也不能把无法失效的数据当真。
+export function normalizeEntry(raw) {
+  if (!raw || typeof raw !== 'object') return null
+  const title = typeof raw.title === 'string' ? raw.title : null
+  const cwd = typeof raw.cwd === 'string' ? raw.cwd : null
+  const createdAt = typeof raw.createdAt === 'number' ? raw.createdAt : null
+  const fingerprint = typeof raw.fingerprint === 'string' && raw.fingerprint ? raw.fingerprint : null
+  const updatedAt = typeof raw.updatedAt === 'number' ? raw.updatedAt : 0
+  if (!fingerprint || (!title && !cwd)) return null
+  return { title, cwd, createdAt, fingerprint, updatedAt }
+}
+
+export function normalizeTitleIndex(raw) {
+  const entries = {}
+  if (raw && typeof raw === 'object' && raw.entries && typeof raw.entries === 'object') {
+    for (const [id, entry] of Object.entries(raw.entries)) {
+      if (typeof id !== 'string' || !id || id.length > 200) continue
+      const normalized = normalizeEntry(entry)
+      if (normalized) entries[id] = normalized
+    }
+  }
+  return { schemaVersion: TITLE_INDEX_SCHEMA_VERSION, entries }
+}
+
+// 纯合并：right 覆盖 left 同 id 条目；截断到 MAX_ENTRIES（保留 updatedAt 新的）。
+export function mergeEntries(left, right) {
+  const merged = { ...left }
+  for (const [id, entry] of Object.entries(right)) merged[id] = entry
+  const ids = Object.keys(merged)
+  if (ids.length > MAX_ENTRIES) {
+    ids.sort((a, b) => (merged[a].updatedAt || 0) - (merged[b].updatedAt || 0))
+    for (const id of ids.slice(0, ids.length - MAX_ENTRIES)) delete merged[id]
+  }
+  return merged
+}
+
+export function createTitleIndexStore({ dir, file }) {
+  let cache = null
+  let chain = Promise.resolve()
+  const path = file || join(dir, 'title-index.json')
+
+  async function readRaw() {
+    try {
+      return normalizeTitleIndex(JSON.parse(await readFile(path, 'utf8')))
+    } catch (e) {
+      return normalizeTitleIndex(null)
+    }
+  }
+
+  // 所有写操作串行化（仿 trash 的 mutate 队列），避免并发 merge 互相覆盖。
+  function enqueue(mutator) {
+    const operation = chain.then(async () => {
+      const store = cache || (cache = (await readRaw()).entries)
+      await mutator(store)
+      return store
+    })
+    chain = operation.catch(() => {})
+    return operation
+  }
+
+  return {
+    // 只读：内存优先，未加载过才落盘一次。绝不抛错。
+    async entries() {
+      if (cache) return cache
+      cache = (await readRaw()).entries
+      return cache
+    },
+    // 批量合并写入（原子替换）。失败静默：索引只是加速器，坏了下次重解码。
+    async merge(batch) {
+      const right = {}
+      for (const [id, entry] of Object.entries(batch || {})) {
+        const normalized = normalizeEntry(entry)
+        if (normalized) right[String(id)] = normalized
+      }
+      if (!Object.keys(right).length) return false
+      await enqueue(async (store) => {
+        const next = mergeEntries(store, right)
+        await mkdir(dirname(path), { recursive: true })
+        const tmp = join(dirname(path), `.title-index-${process.pid}-${Date.now()}.tmp`)
+        await writeFile(tmp, JSON.stringify({ schemaVersion: TITLE_INDEX_SCHEMA_VERSION, entries: next }), { encoding: 'utf8', mode: 0o600 })
+        await rename(tmp, path)
+        cache = next
+      })
+      return true
+    },
+    async remove(ids) {
+      const wanted = new Set((ids || []).map(String))
+      if (!wanted.size) return false
+      await enqueue(async (store) => {
+        let changed = false
+        for (const id of wanted) {
+          if (id in store) { delete store[id]; changed = true }
+        }
+        if (!changed) return
+        await mkdir(dirname(path), { recursive: true })
+        const tmp = join(dirname(path), `.title-index-${process.pid}-${Date.now()}.tmp`)
+        await writeFile(tmp, JSON.stringify({ schemaVersion: TITLE_INDEX_SCHEMA_VERSION, entries: store }), { encoding: 'utf8', mode: 0o600 })
+        await rename(tmp, path)
+      })
+      return true
+    },
+  }
+}
+
+// 判定持久条目能否当作当前日志的解码结果：指纹一致即可（与内存缓存同一标准）。
+export function persistEntryUsable(entry, stat) {
+  const normalized = normalizeEntry(entry)
+  if (!normalized || !stat) return null
+  return normalized.fingerprint === stat.fingerprint ? normalized : null
+}