dsh-sessions-manager 3.6.1 → 3.7.0

package/src/index.js

@@ -14,17 +14,21 @@ import { homedir } from 'node:os'
 import { rewriteFrame0CwdInMemory, scanZstdFrames } from './zstd-frame.js'
 import { createSessionMarkdownBuilder } from './markdown.js'
 import { createStarIndex } from './star-index.js'
+import { createTagIndex } from './tag-index.js'
+import { createSavedFilters } from './saved-filters.js'
 import { createPendingMoveStore } from './pending-moves.js'
+import { createMoveNoticeStore } from './move-notices.js'
 import { sweepStaleStateTemps } from './state-temp-sweep.js'
 import { aggregateStorage } from './storage-stats.js'
 import { createAutoArchiveStore, pickInactiveCandidates } from './auto-archive.js'
-import { createSessionMetaCache, persistFingerprintOf } from './session-meta-cache.js'
+import { createSessionMetaCache, fingerprintOf, persistFingerprintOf } from './session-meta-cache.js'
 import { createTitleIndexStore } from './title-persist-index.js'
+import { createEmptyScanStore } from './empty-scan-index.js'
 import { createPersistenceAdapter } from './compat/persistence.js'
 import { detectCapabilities, requireCapability } from './compat/capabilities.js'
 import { pathOwnsSession } from './path-guard.js'
 import { purgeSessionArtifacts, moveSessionToCwd } from './handle-era-ops.js'
-import { classifyLineage, isEmptyEventTypes, EMPTY_DECODE_LIMIT } from './lineage.js'
+import { classifyLineage, emptyScanCandidate, isEmptyEventTypes, EMPTY_DECODE_LIMIT } from './lineage.js'
 
 // 构建指纹：build.mjs 以 define 在编译期注入；直接以源码运行（测试）时为 'dev'。
 // 用途：capabilities 带出 buildStamp，一眼判断「运行中的 host 是不是这份构建」——
@@ -36,7 +40,8 @@ export const name = 'dsh-sessions-manager'
 export const inject = ['webServer', 'workspaceRegistry', 'sessionPersistence', 'sessionQuery', 'storageDomain']
 
 const MAX_TITLE = 80
-// 插件自有状态目录（星标 / 自动归档 / 标题索引共用）。与 star-index.js、auto-archive.js
+// 插件自有状态目录（星标 / 标签 / 保存筛选 / 自动归档 / 标题索引共用）。与 star-index.js、
+// tag-index.js、auto-archive.js
 // 的默认目录保持一致，环境变量同名，便于测试注入。
 const STATE_DIR = process.env.DSH_SESSIONS_MANAGER_STAR_DIR || join(homedir(), '.dsh', 'sessions-manager')
 // Recycle bin (回收站): normal deletes land here instead of being erased.
@@ -135,20 +140,8 @@ 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
-}
+// foldTitle（v3.6.1 删除路径的兜底折叠）随 v3.6.2 #7 的「删除路径零解码」一并
+// 移除；标题折叠逻辑的权威实现现在是 runtime 投影（src/index.js projectTitlesStatus）。
 
 export function apply(ctx) {
   const w = ctx.workspaceRegistry
@@ -166,6 +159,10 @@ export function apply(ctx) {
   // 仍要全库解码。索引按同样的 (mtime, size) 指纹存解码结果，指纹没变的会话
   // 重启后也直接复用。见 src/title-persist-index.js。
   const titleIndex = createTitleIndexStore({ dir: TRASH_DIR, file: join(TRASH_DIR, 'title-index.json') })
+  // T1（3.7.0）：空白精判结论的持久层。只有**真解码成功**的判定落盘（unknown
+  // 与失败兜底都不是结论），sz 指纹 + 14 天 TTL 双闸门防「同尺寸原地改写」。
+  const emptyIndex = createEmptyScanStore({ dir: TRASH_DIR })
+  const EMPTY_VERDICT_TTL_MS = 14 * 24 * 3600 * 1000
 
   // P4：对「内存缓存未命中」的会话查持久索引，指纹一致才可信。
   // 返回 Map<id, meta>；调用方应把命中条目回填 metaCache 并从 missing 里剔除。
@@ -184,7 +181,10 @@ export function apply(ctx) {
       // 从不落盘，导致每次重启都全量重新解码）。
       const fp = persistFingerprintOf(stat)
       if (!fp) continue
-      if (fp && entry.fingerprint === fp) {
+      // v3.6.2 #1：title 为 null 的条目必须是「投影确实成功过」（resolved）才可信。
+      // v3.6.1 把投影失败当结果落盘的污染条目（null 标题、无标记）在这里被丢弃，
+      // 调用方按未命中处理 → 重新入队预热，索引自愈。
+      if (entry.fingerprint === fp && (entry.title || entry.resolved)) {
         hits.set(id, { title: entry.title, cwd: entry.cwd, createdAt: entry.createdAt })
       }
     }
@@ -197,14 +197,18 @@ export function apply(ctx) {
   // 且"响应已返回但索引没落盘"时进程若恰好退出就会丢条目。
   // 指纹用 persistFingerprintOf：legacy 文件指纹 + handle 世代 sz(sizeBytes) 指纹
   // 都可跨重启；rev: 指纹仍被排除（实例内 opaque token，issue #8）。
+  // v3.6.2 #1：decoded 的值是 { meta, resolved } —— resolved=false（投影失败）
+  // 的条目绝不落盘；null 标题只有 resolved=true 才允许（否则读取端会当污染丢弃）。
   async function persistDecoded(decoded, statsById) {
     if (!decoded || !decoded.size) return
     const batch = {}
     const now = Date.now()
-    for (const [id, meta] of decoded) {
+    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 }
+      batch[id] = { title: meta.title, cwd: meta.cwd, createdAt: meta.createdAt, fingerprint: fp, updatedAt: now, resolved: 1 }
     }
     if (!Object.keys(batch).length) return
     try { await titleIndex.merge(batch) } catch (e) { /* 索引写失败不影响本次响应 */ }
@@ -276,8 +280,9 @@ export function apply(ctx) {
       workspaceGone: !!(cwd && !ws),
       hasWorkspace: !!cwd,
     }
-    // sizeBytes / updatedAt 只在需要的路由（存储分析 / 自动归档）里带上：
-    // 它们本就来自 usage，附带输出对列表渲染无益。
+    // sizeBytes / updatedAt 只在需要的路由里带出（存储分析 / 自动归档 / 会话
+    // 列表——3.7.0 起列表也要：分支组时间回退键读 updatedAt）。它们本就来自
+    // usage，只是 payload 体积，不引入任何解码。
     if (exposeUsage && usage) {
       if (usage.sizeById && usage.sizeById.has(key)) base.sizeBytes = usage.sizeById.get(key)
       if (usage.mtimeById && usage.mtimeById.has(key)) base.updatedAt = usage.mtimeById.get(key)
@@ -308,6 +313,73 @@ export function apply(ctx) {
   let warmRunning = false
   let warmKickTimer = null
 
+  // v3.6.2 #1：投影失败的三态处理（issue #8 审计）。旧实现把「投影失败」和
+  // 「会话真没标题」混为同一个 null → 失败被写进缓存/持久索引，跨重启固化成
+  // 永久占位且永不重试。现在：
+  //   - resolved（fulfilled，title 可以是 null = 事实无标题）→ 正常入缓存+落盘；
+  //   - failed（rejected / 批量异常 / 结果缺条）→ 不缓存、不落盘，按 id 计数退避。
+  // 退避：15s×2^n 递增，最多 WARM_MAX_ATTEMPTS 次；此后 parked 一小时后再探一次
+  // （坏日志长期停摆时不至于永久静默）。日志指纹任何变化都清零计数重新武装。
+  const WARM_MAX_ATTEMPTS = 5
+  const warmFail = new Map() // id → { count, fp, nextAt }
+
+  function warmFpOf(stat) {
+    return fingerprintOf(stat) || persistFingerprintOf(stat)
+  }
+
+  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 now = Date.now()
+    return rec.nextAt > now ? rec.nextAt - now : 0
+  }
+
+  function warmMarkFailure(id, stat, header) {
+    const rec = warmFail.get(id) || { count: 0, fp: null, nextAt: 0 }
+    rec.count += 1
+    rec.fp = warmFpOf(stat) || rec.fp
+    // 退避到点后由 scheduleWarmRetry 原样重新入队（含本轮的 stat/header 快照）。
+    if (stat) rec.stat = stat
+    if (header) rec.header = header
+    const backoff = rec.count >= WARM_MAX_ATTEMPTS
+      ? 60 * 60 * 1000
+      : Math.min(5 * 60 * 1000, 15 * 1000 * Math.pow(2, rec.count))
+    rec.nextAt = Date.now() + backoff
+    warmFail.set(id, rec)
+  }
+
+  // 队列里还有「未放弃」的活 → 侧栏/面板应缩短轮询节拍（client 消费）。
+  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
+  }
+
+  // 退避到点的条目由一个 unref 定时器重新入队（每轮只挂最近的一个）。
+  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
+      // 到点的条目重新入队（enqueue 时会重新校验 blocked/fp）。
+      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)
@@ -317,15 +389,50 @@ export function apply(ctx) {
 
   function enqueueWarm(ids, statsById, entryById) {
     if (!ids || !ids.length) return
+    // 无投影 API 的 runtime：预热注定无果，不入队（占位行为退回「列表不带标题」
+    // 的诚实形态，而不是让退避定时器永远转下去）。
+    if (!warmHasApi) return
     for (const id of ids) {
       const key = String(id)
+      const stat = statsById ? (statsById.get(key) || null) : null
+      // #9：任何指纹都算不出来的会话（live 未落盘等）既进不了内存缓存也进不了
+      // 持久索引——投影结果注定无处安放，每轮轮询重复入队只是白烧 CPU（churn）。
+      // 跳过；这类行的标题由 DSH 自己的 live 渲染保证。
+      const fp = warmFpOf(stat)
+      if (!fp) continue
+      // #1：仍在失败退避窗口内的条目不重复入队（runWarm 会按 blocked 跳过）。
+      const blockedMs = warmBlocked(key, fp)
       const entry = entryById ? entryById.get(key) : null
+      const rec = warmFail.get(key)
+      if (rec) { rec.stat = stat || rec.stat; if (entry) rec.header = entry.header || rec.header }
+      if (blockedMs > 0) continue
       warmQueue.set(key, {
-        stat: statsById ? (statsById.get(key) || null) : null,
+        stat,
         header: (entry && entry.header) || null,
       })
     }
-    scheduleWarm()
+    if (warmQueue.size) scheduleWarm()
+    scheduleWarmRetry()
+  }
+
+  // #7：软删除时标题可能还没预热出来（回收站条目落一条 title:null 的诚实记录），
+  // 之后任何一轮 warm 解出该会话标题就补写进回收站索引——只补空标题，
+  // 绝不覆盖已有值。回收站渲染端（t.title || t.sessionId）随下次拉取自然更新。
+  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() {
@@ -337,12 +444,18 @@ export function apply(ctx) {
         for (const [id] of batch) warmQueue.delete(id)
         try {
           const ids = batch.map(([id]) => id)
-          const snapshotById = await projectTitles(ids)
+          const resultById = await projectTitlesStatus(ids)
           const decoded = new Map()
           const statsById = new Map()
           for (const [id, desc] of batch) {
-            const snapshot = snapshotById.has(id) ? snapshotById.get(id) : null
-            const meta = metaFromSnapshot(snapshot)
+            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)
             // cwd/createdAt 永远以最新 list header 为权威（投影的 session 头可能
             // 陈旧；移动会话后尤其如此），投影只负责标题。
             if (desc.header) {
@@ -351,9 +464,11 @@ export function apply(ctx) {
             }
             metaCache.set(id, desc.stat, meta)
             statsById.set(id, desc.stat)
-            if (desc.stat) decoded.set(id, meta)
+            decoded.set(id, { meta, resolved: true })
           }
           await persistDecoded(decoded, statsById)
+          // #7：回收站条目删除时可能没有标题（软删除只记录）；预热解出来后补写。
+          await backfillTrashTitles(decoded)
         } catch (e) { /* 单批失败不影响后续批次：索引/缓存只是加速器 */ }
         // 批间让步：保证宿主事件循环（RPC/心跳/其他插件）始终可调度。
         await new Promise((resolve) => setImmediate(resolve))
@@ -362,6 +477,7 @@ export function apply(ctx) {
       warmRunning = false
       // 预热期间又有新请求入队 → 再排一轮。
       if (warmQueue.size) scheduleWarm()
+      scheduleWarmRetry()
     }
   }
 
@@ -467,9 +583,18 @@ export function apply(ctx) {
   // when the session is really gone (purge, or externally removed; the latter
   // is caught by gcStars during list builds).
   const stars = createStarIndex()
+  // 标签（3.7.0，schema v4）：与星标同型、同状态目录（tags.json）。纯用户元数据，
+  // rename/merge/delete 只重写标签文档，永不触碰会话本体（方案 §1.3 红线）。
+  const tags = createTagIndex()
+  // 保存的筛选（schema v1，saved-filters.json）：filters 为不透明 JSON，host
+  // 只限条数/名称/序列化体积，绝不解析其内容。
+  const savedFilters = createSavedFilters()
   // 待移动队列：会话被占用（DSH 打开中）时登记，等它释放后自动完成移动。
   // 见 src/pending-moves.js 的模块注释（0.1.5 单写者锁没有公共释放 API）。
   const pendingMoves = createPendingMoveStore()
+  // T2：排队移动的后台终局（完成/放弃）落成持久通知，sidebar-state 带出、
+  // client 弹出后 ack 清除。独立于队列文件（终局与队列项同生死，挂条目上观察不到）。
+  const moveNotices = createMoveNoticeStore()
   // Auto-archive settings live in their own schema-v4 store, off by default.
   const autoArchive = createAutoArchiveStore()
   // 启动清扫：进程在「写临时文件 → rename」之间被杀会留下 .<name>-<pid>-<ts>.tmp
@@ -485,6 +610,17 @@ export function apply(ctx) {
     } catch (e) { /* best-effort */ }
   }
 
+  // 标签的会话侧引用同样要 GC：会话被外部移除（不在 list 基线里）时，
+  // assignments 里的键会变成永远列不出来的幽灵。与 gcStars 同挂点、同信任条件。
+  async function gcTags(validIds) {
+    try {
+      const store = await tags.read()
+      const valid = new Set(validIds.map(String))
+      const gone = Object.keys(store.assignments).filter((id) => !valid.has(id))
+      if (gone.length) await tags.removeIds(gone)
+    } catch (e) { /* best-effort */ }
+  }
+
   // Soft-delete one session: record it in the recycle-bin index but KEEP its
   // log in the original workspace directory. Moving the file out (and detaching
   // it from the workspace) orphaned the session into DSH's "未分组" group and
@@ -514,25 +650,21 @@ export function apply(ctx) {
         title = header.title || (header.meta && header.meta.title) || null
       }
       if (!title) {
-        // 标题兜底优先走单会话标题投影（快照级，不读日志）；投影也没有时才
-        // 分块解码日志折叠标题（inspectSession 分块，不整本驻留内存）。
-        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) { /* fall through */ }
-        }
-      }
-      if (!title) {
+        // v3.6.2 #7：删除路径**绝不**做标题投影/分块解码——issue #8 的教训：
+        // 大日志上单条兜底投影也是整本解压，删除 = 秒级卡宿主。只消费现成缓存：
+        // metaCache（用 list 快照算指纹）→ 持久索引 → 侧栏权威缓存。都没有就存
+        // null（诚实占位，不再把 cwd/裸 id 冒充标题永久写进回收站），
+        // 后台预热解出标题后由 backfillTrashTitles 补写。
         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) : undefined }
+            : (removedPath ? await stat(removedPath).then((st) => ({ mtimeMs: st.mtimeMs, size: st.size })) : null)
+          if (delStat) {
+            const m = metaCache.get(sid, delStat) || (await hydrateFromPersist([sid], new Map([[sid, delStat]]))).get(sid)
+            if (m && m.title) title = String(m.title)
+          }
         } catch (e) { /* best-effort */ }
+        if (!title) { const at = authorityTitleCache.get(sid); if (at) title = String(at) }
       }
     } catch (e) { /* best-effort */ }
     // Record in the trash index only — the log stays in its workspace dir.
@@ -544,7 +676,9 @@ export function apply(ctx) {
     const archived = await mutateArchived((list) => ({ next: null, value: list.includes(sid) })).catch(() => false)
     await mutateTrash((store) => {
       const entry = {
-        sessionId: sid, title: title || cwd || sid, cwd: cwd || null,
+        // v3.6.2 #7：不再把 cwd/裸 id 冒充标题永久定格——存 null，预热解出后
+        // backfillTrashTitles 补写；渲染端（t.title || t.sessionId）自然降级。
+        sessionId: sid, title: title || null, cwd: cwd || null,
         header: header || null, originalPath: removedPath || null,
         sizeBytes: persistenceEntry && Number.isFinite(persistenceEntry.sizeBytes) ? persistenceEntry.sizeBytes : null,
         wasArchived: archived, deletedAt: Date.now(),
@@ -763,6 +897,10 @@ export function apply(ctx) {
     // 状态目录清理 → `ENOTEMPTY: rmdir .../state`（全量测试里约 1/4 概率偶发失败）。
     // 而且"删除成功"不该早于状态落盘：进程恰好在此刻退出就会留下指向已删会话的星标。
     try { await stars.removeIds([sid]) } catch (e) { /* 星标清理失败不阻塞删除结果 */ }
+    // 标签 assignments 同理（S4 教训位）：清理必须 await、不得浮动写——purgeFromTrash
+    // 是唯一的彻底删除收口（trash/purge、trash/purge-many、到期清理都经过它），
+    // 在这里落盘即覆盖所有路径，且"删除成功"不早于状态落盘。
+    try { await tags.removeIds([sid]) } catch (e) { /* 标签清理失败不阻塞删除结果 */ }
     return { ok: true, purged: true }
   }
 
@@ -1115,11 +1253,17 @@ export function apply(ctx) {
           metaCache.invalidate(item.sessionId)
           moved++
           notes.push(`排队中的移动已完成：${String(item.sessionId).slice(0, 18)}…`)
+          // T2：通知落盘失败不吞掉移动结果本身（队列项已删，回滚代价不值——
+          // 保留 console.warn 作最后兜底，这是刻意接受的静默缺口）。
+          try { await moveNotices.append({ kind: 'moved', sessionId: item.sessionId, targetPath: item.targetPath, at: Date.now() }) } catch (e) { /* best-effort */ }
         } catch (e) {
           if (isBusyError(e)) continue // 仍被占用：留在队列里，等下一次触发
           if (Date.now() - bootedAt < BOOT_WARMUP_MS) continue // boot 期未就绪：不记失败
           const bumped = await pendingMoves.bumpAttempts(item.sessionId)
-          if (bumped && bumped.dropped) notes.push(`排队中的移动多次失败已放弃：${String(item.sessionId).slice(0, 18)}…（${String((e && e.message) || e)}）`)
+          if (bumped && bumped.dropped) {
+            notes.push(`排队中的移动多次失败已放弃：${String(item.sessionId).slice(0, 18)}…（${String((e && e.message) || e)}）`)
+            try { await moveNotices.append({ kind: 'abandoned', sessionId: item.sessionId, targetPath: item.targetPath, at: Date.now(), attempts: bumped.attempts, reason: String((e && e.message) || e).split('\n')[0] }) } catch (err) { /* best-effort */ }
+          }
         }
       }
       if (moved > 0) { try { await reindexRegistry() } catch (e) { /* best-effort */ } }
@@ -1210,24 +1354,53 @@ export function apply(ctx) {
     })
   }
 
-  // 批量投影：一次调用把多条会话的标题/header 拿出来，避免逐条触发整本解码。
-  // 老 runtime 没有 readTitleSnapshots 时返回空 Map，调用方自然回退到逐条投影
-  // （功能不受影响，只是少了这层优化——插件不能假设对方的 runtime 版本）。
-  async function projectTitles(ids) {
+  // 批量投影（v3.6.2 #1 三态版）。返回 Map<id, { resolved, snapshot|null }>：
+  //   resolved=true  —— fulfilled 快照（title 可能为 null：会话真的没标题，
+  //                     这是事实，可以缓存/落盘）；
+  //   resolved=false —— rejected / 批量异常 / 结果缺条 / 无投影 API。
+  // 调用方（runWarm）只缓存 resolved 的条目；失败的进退避重试，绝不落盘——
+  // 否则「一次失败」被固化为跨重启的永久占位（v3.6.1 审计 #1）。
+  const warmHasApi = typeof sq.readTitleSnapshots === 'function' || typeof sq.readTitleSnapshot === 'function'
+
+  async function projectTitlesStatus(ids) {
     const out = 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 })
+        })
+        // 结果数组短于请求（runtime 行为异常）→ 缺的条目按失败处理。
+        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
   }
 
+  // 兼容旧调用点（暂无）：保留名字不导出，避免误用回「失败即 null」的旧语义。
+
   // opts.usage: expose sizeBytes + updatedAt on each item (storage analysis and
   // the auto-archive sweep need them; the panel list does not).
   //
@@ -1319,12 +1492,28 @@ export function apply(ctx) {
       }
       return { items: archivedItems, usage }
     }
-    // Annotate stars; GC only when we have a trustworthy id baseline, so a
+    // Annotate stars & tags; GC only when we have a trustworthy id baseline, so a
     // failing sp.list() can never wipe the whole index.
     let starredSet = new Set()
-    try { starredSet = new Set((await stars.read()).starredSessionIds) } catch (e) {}
-    for (const it of items) it.starred = starredSet.has(String(it.sessionId))
+    let tagIdsBySession = new Map()
+    try {
+      starredSet = new Set((await stars.read()).starredSessionIds)
+      // Same one-shot read as stars: tag ids are plain metadata, no decoding.
+      // Filter dangling tagIds against the live definitions so a half-deleted
+      // tag can never leak into a rendered row.
+      const tagStore = await tags.read()
+      const knownTagIds = new Set(tagStore.tags.map((t) => t.id))
+      for (const [sid, list] of Object.entries(tagStore.assignments)) {
+        const kept = list.filter((id) => knownTagIds.has(id))
+        if (kept.length) tagIdsBySession.set(sid, kept)
+      }
+    } catch (e) {}
+    for (const it of items) {
+      it.starred = starredSet.has(String(it.sessionId))
+      it.tags = tagIdsBySession.get(String(it.sessionId)) || []
+    }
     if (headersOk) await gcStars(ids)
+    if (headersOk) await gcTags(ids)
     return { items, usage }
   }
 
@@ -1432,78 +1621,143 @@ export function apply(ctx) {
         if (meta && meta.title) authorityTitleCache.set(id, String(meta.title))
       }
     }
-    // 血缘分类（issue #6）：结构分类（子代理 / fork 分支）来自 list snapshot
-    // 的 header，零解码；空白判定见下方 refineEmptyLineage（0.1.3 起体积法
-    // 失效，改为事件类型精判）。普通顶层非空会话不产生条目，payload 最小。
+    // 血缘分类（issue #6 + T1/3.7.0）：结构分类（子代理 / fork 分支）来自 list
+    // snapshot 的 header，零解码。空白（empty）是**三态**：null=未知（等后台
+    // refine 队列精判）、true/false=已判定（来自进程内缓存或 empty-scan 持久层，
+    // sz 指纹一致 + 14 天 TTL 内才可信）。请求路径零解码承诺由此完整成立：
+    // 超过解码上限的日志「必有内容」按事实直接给 false；legacy 无 sizeBytes
+    // 观测 → 永不候选、恒未知（与旧行为一致）。普通会话只在真判空时建条目，
+    // 「误隐藏」在结构上不可能来自体积法（该路径已整体退役）。
     const lineage = {}
+    const refineWanted = []
+    let emptyStore = null
+    try { emptyStore = await emptyIndex.entries() } catch (e) { emptyStore = null }
+    const nowTs = Date.now()
     for (const entry of entries) {
-      const info = classifyLineage(entry.header, entry.sizeBytes)
-      if (info) lineage[entry.id] = info
+      const id = String(entry.id)
+      const size = entry && Number.isFinite(entry.sizeBytes) ? entry.sizeBytes : null
+      const candidate = emptyScanCandidate(size)
+      let verdict = null
+      if (!candidate) {
+        if (size !== null) verdict = false // 超出解码上限 = 必有内容（事实，不是猜测）
+      } else {
+        const mem = emptyScanCache.get(id)
+        if (mem && mem.sizeBytes === size) {
+          verdict = !!mem.empty
+        } else {
+          const rec = emptyStore && emptyStore[id]
+          if (rec && rec.fingerprint === `sz:${size}` && nowTs - (rec.updatedAt || 0) <= EMPTY_VERDICT_TTL_MS) {
+            verdict = rec.empty === 1
+            emptyScanCache.set(id, { sizeBytes: size, empty: verdict })
+          }
+        }
+        if (verdict === null && refineCapable() && !refineQueue.has(id)) refineWanted.push({ id, sizeBytes: size })
+      }
+      const info = classifyLineage(entry.header)
+      if (info) lineage[id] = { origin: info.origin, parentSession: info.parentSession, delegationDepth: info.delegationDepth, empty: verdict }
+      else if (verdict === true) lineage[id] = { origin: null, parentSession: null, delegationDepth: 0, empty: true }
     }
-    await refineEmptyLineage(lineage, entries)
-    return {
+    enqueueRefine(refineWanted)
+    // 缓存只保留「本轮仍是候选」的会话，防止 Map 随历史会话无限增长。
+    for (const key of emptyScanCache.keys()) {
+      const rec = emptyScanCache.get(key)
+      if (!rec || !emptyScanCandidate(rec.sizeBytes)) emptyScanCache.delete(key)
+    }
+    const payload = {
       titles: Object.fromEntries(authorityTitleCache),
       trashedSessionIds: store.items.map((item) => String(item.sessionId)),
       purgedSessionIds: activeTombstones,
       lineage,
+      // v3.6.2：还有预热/退避重试在途 → client 缩短轮询节拍，预热一完成就把
+      // 补齐的标题送回（含面板自动刷新）。无预热 API 时恒 false，绝不假忙。
+      warmPending: warmPendingNow(),
+      // T1：空白精判后台队列是否还有活。无精判能力（旧 runtime 无 inspect 通道）
+      // 时恒 false——永久 busy 会让 client 疯轮询，这是唯一现实的假忙陷阱。
+      refinePending: refinePendingNow(),
     }
+    // T2：有未确认的排队移动终局才带出（空则省略字段——与「普通会话不产生条目」
+    // 同风格的载荷最小化；旧 client 对未知字段天然忽略）。
+    try {
+      const noticeRows = await moveNotices.list()
+      if (noticeRows.length) payload.moveNotices = noticeRows
+    } catch (e) { /* 通知通道坏了不影响侧栏主数据 */ }
+    return payload
   }
 
-  // 空会话判定缓存：id → { sizeBytes, empty }。日志没变（sizeBytes 相同）
-  // 就不重复解码——authority 会被侧栏高频轮询，缓存让它保持在近零成本。
+  // 空会话判定缓存（进程内）：id → { sizeBytes, empty }。日志没变（sizeBytes
+  // 相同）就不重复解码；T1 之后它只是 emptyIndex 持久层之上的热缓存。
   const emptyScanCache = new Map()
 
-  // 0.1.3 空会话精判（事件类型法，见 lineage.js）：体积阈值对新格式失效
-  // （头部扩容 + 恒存生命周期帧），改为对「压缩体积 ≤ EMPTY_DECODE_LIMIT」
-  // 的候选走官方 inspectSession 解码，按事件类型判定。超过上限的日志必有
-  // 内容，直接跳过（维持体积法/结构分类的结果）。解码失败按「非空」处理：
-  // 宁可漏判一个空会话，不能把有内容的会话错标成空。
-  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) {
-        // 结构分类没建条目的普通会话也要补上（0.1.3 空会话 header 无血缘字段，
-        // classifyLineage 对它们返回 null）。
-        const info = lineage[id] || (lineage[id] = { origin: null, parentSession: null, delegationDepth: 0, empty: false })
-        info.empty = true
-      } else if (lineage[id]) {
-        // 旧体积法在小日志上的假阳性（如 alpha.2 单事件日志）在这里纠正；
-        // 纠正后若无任何血缘结构，条目整个撤掉，维持「普通会话不产生条目」。
-        const info = lineage[id]
-        info.empty = false
-        if (!info.origin && !info.parentSession) delete lineage[id]
-      }
-    }
-    // 缓存只保留「本轮仍参与判定」的会话：已彻底删除或日志膨胀超过解码
-    // 上限的条目不再有用，淘汰掉防止 Map 随历史会话无限增长。
-    const live = 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))
+  // T1（3.7.0）：空白精判彻底移出请求路径。v3.6.2 的「预算+限流」只是过渡——
+  // 冷启动（缓存全空）时首拍仍要为精判解码，这正是「⑂ 分支」等零解码血缘被
+  // 挡在 return 之前的最后一块捆绑。现在：sidebar-state 先回三态数据，未判定
+  // 的候选进这条与 runWarm 同型的后台队列（REFINE_CHUNK=2、批间 setImmediate
+  // 让步、成功结论落盘、失败只在进程内按「非空」兜底且**不落盘**——宁可漏判
+  // 一个空白，不能把有内容的会话错标成空，也不能把失败固化成跨重启的结论）。
+  const REFINE_CHUNK = 2
+  const refineQueue = new Map()
+  let refineRunning = false
+  let refineKickTimer = null
+
+  function refineCapable() {
+    return !!persistence && typeof persistence.inspectSession === 'function'
+  }
+
+  function refinePendingNow() {
+    return !!(refineRunning || refineQueue.size)
+  }
+
+  function scheduleRefine() {
+    if (refineKickTimer || refineRunning || !refineQueue.size) return
+    refineKickTimer = setTimeout(() => { refineKickTimer = null; runRefine() }, 25)
+    if (typeof refineKickTimer.unref === 'function') refineKickTimer.unref()
+  }
+
+  function enqueueRefine(items) {
+    if (!items || !items.length || !refineCapable()) return
+    for (const { id, sizeBytes } of items) {
+      if (emptyScanCache.has(id) && emptyScanCache.get(id).sizeBytes === sizeBytes) continue
+      refineQueue.set(id, { sizeBytes })
     }
-    for (const key of emptyScanCache.keys()) {
-      if (!live.has(key)) emptyScanCache.delete(key)
+    scheduleRefine()
+  }
+
+  async function runRefine() {
+    if (refineRunning) return
+    refineRunning = true
+    try {
+      while (refineQueue.size) {
+        const batch = [...refineQueue.entries()].slice(0, REFINE_CHUNK)
+        for (const [id] of batch) refineQueue.delete(id)
+        const persistBatch = {}
+        for (const [id, desc] of batch) {
+          try {
+            const types = []
+            await persistence.inspectSession(id, { onEvents: (b) => {
+              for (const ev of b || []) if (types.length < 64) types.push(ev && ev.type)
+            } })
+            const isEmpty = isEmptyEventTypes(types)
+            emptyScanCache.set(id, { sizeBytes: desc.sizeBytes, empty: isEmpty })
+            persistBatch[id] = { empty: isEmpty ? 1 : 0, fingerprint: `sz:${desc.sizeBytes}`, updatedAt: Date.now() }
+          } catch (e) {
+            // 失败兜底：非空（止 churn），但只进内存，不落盘。
+            emptyScanCache.set(id, { sizeBytes: desc.sizeBytes, empty: false })
+          }
+        }
+        if (Object.keys(persistBatch).length) {
+          try { await emptyIndex.merge(persistBatch) } catch (e) { /* 持久层只是加速器 */ }
+        }
+        // 批间让步：与 runWarm 同一纪律，绝不让后台精判独占宿主事件循环。
+        await new Promise((resolve) => setImmediate(resolve))
+      }
+    } finally {
+      refineRunning = false
+      if (refineQueue.size) scheduleRefine()
     }
   }
 
   // 聚合一条会话的详情（磁盘占用 / 轮次·步数·消息数 / 工具统计 / fetch /
-  // write/edit 文件 / 血统 parent/children/subagents）。live 与持久化会话都可读。
+  // write/edit 文件 / 血缘 parent/children/subagents）。live 与持久化会话都可读。
   // 所有统计对未知事件类型容错；fetch 与 files 做上限截断，files 用 stat 过滤
   // 磁盘上已不存在的路径，避免详情面板列出已删除文件。
   // 持久化会话走 inspectSession 分块折叠：大日志不再整本驻留内存（0.1.3-alpha
@@ -1855,6 +2109,7 @@ export function apply(ctx) {
           metaCache.invalidate(sid)
           // 彻底删除：持久标题索引里的条目一并清掉（issue #1 P4）。
           try { await titleIndex.remove([sid]) } catch (e) { /* 索引清理失败不阻塞删除结果 */ }
+            try { await emptyIndex.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))
@@ -1872,7 +2127,7 @@ 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); await titleIndex.remove([sid]).catch(() => {}) }
+            try { results.push({ sessionId: sid, ok: true, ...(await purgeFromTrash(sid)) }); metaCache.invalidate(sid); await titleIndex.remove([sid]).catch(() => {}); await emptyIndex.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 })
@@ -1888,7 +2143,10 @@ export function apply(ctx) {
       path: '/archived-sessions/sessions',
       handler: async (req, res) => {
         try {
-          json(res, { items: await allSessionItems() })
+          // usage:true：updatedAt(=日志文件 mtime) 随行带出——3.7.0 分支聚拢的
+          // createdAt 缺失回退键（logic.branchTimeKey）。collectUsage 本就在
+          // allSessionItemsDetailed 内无条件执行，成本≈纯 payload 增加。
+          json(res, { items: await allSessionItems({ usage: true }), warmPending: warmPendingNow() })
         } catch (e) {
           json(res, { error: String((e && e.message) || e) }, 500)
         }
@@ -1907,11 +2165,145 @@ export function apply(ctx) {
           if ((!ids || ids.length === 0) && body && typeof body.sessionId === 'string') {
             ids = isSafeSessionId(body.sessionId) ? [body.sessionId] : null
           }
-          if (!ids || ids.length === 0) return json(res, { ok: false, error: 'missing sessionId' }, 400)
+          if (!ids || ids.length === 0) return json(res, { ok: false, code: 'DSM_STAR_SESSION_INVALID', error: 'missing sessionId' }, 400)
           const starredSessionIds = await stars.setStarred(ids, starred)
           json(res, { ok: true, starredSessionIds })
         } catch (e) {
-          json(res, { ok: false, error: String((e && e.message) || e) }, errorStatus(e))
+          // 3.7.0：补 code 字段（响应形状向后兼容，只增字段）——新路由全部带 code，
+          // 星标不应是例外。
+          json(res, { ok: false, code: e && e.code, error: String((e && e.message) || e) }, errorStatus(e))
+        }
+      },
+    }))
+
+    // ---- Tags (标签, schema v4) — one route one action, same shape as star/set.
+    // Pure user metadata: these routes never create/modify/delete a session.
+    disposers.push(ctx.webServer.register({
+      kind: 'exact',
+      path: '/archived-sessions/tags/list',
+      handler: async (req, res) => {
+        try {
+          const { tags: tagList, assignments } = await tags.list()
+          json(res, { ok: true, tags: tagList, assignments })
+        } 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/tags/create',
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req)
+          const tag = await tags.create(body && body.name)
+          json(res, { ok: true, tag })
+        } 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/tags/rename',
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req)
+          await tags.rename(body && body.id, body && body.name)
+          json(res, { ok: true })
+        } 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/tags/merge',
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req)
+          await tags.merge(body && body.fromId, body && body.toId)
+          json(res, { ok: true })
+        } 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/tags/delete',
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req)
+          await tags.removeTag(body && body.id)
+          json(res, { ok: true })
+        } 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/tags/set',
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req)
+          const sid = body && body.sessionId
+          if (!isSafeSessionId(sid)) {
+            return json(res, { ok: false, code: 'DSM_TAG_SESSION_INVALID', error: 'missing/invalid sessionId' }, 400)
+          }
+          const assignments = await tags.setTags(sid, body && body.tagIds)
+          json(res, { ok: true, assignments })
+        } catch (e) {
+          json(res, { ok: false, code: e && e.code, error: String((e && e.message) || e) }, errorStatus(e))
+        }
+      },
+    }))
+
+    // ---- Saved filters (保存筛选, schema v1) --------------------------------
+    disposers.push(ctx.webServer.register({
+      kind: 'exact',
+      path: '/archived-sessions/filters/list',
+      handler: async (req, res) => {
+        try {
+          json(res, { ok: true, items: await savedFilters.list() })
+        } 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/filters/save',
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req)
+          const item = await savedFilters.save(body && body.name, body && body.filters)
+          json(res, { ok: true, item })
+        } 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/filters/delete',
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req)
+          const ids = body && Array.isArray(body.ids) ? body.ids : null
+          if (!ids || ids.length === 0) return json(res, { ok: false, code: 'DSM_FILTER_IDS_INVALID', error: 'missing ids' }, 400)
+          const removed = await savedFilters.remove(ids)
+          json(res, { ok: true, removed })
+        } catch (e) {
+          json(res, { ok: false, code: e && e.code, error: String((e && e.message) || e) }, errorStatus(e))
         }
       },
     }))
@@ -1975,7 +2367,8 @@ export function apply(ctx) {
     // 子代理血缘树（管理视图数据面）：给定父会话，返回 origin==='subagent'
     // 的递归子树。DSH 原生目录（ui-subagent）只读，这里补管理能力的数据来源。
     // 只读官方 header 血缘字段（parentSession/origin/delegationDepth/createdAt），
-    // 标题走既有批量投影（readTitleSnapshots），零整本日志解码。
+    // 标题走 v3.6.2 的纯缓存读取（metaCache/持久索引/权威缓存），未命中入后台
+    // 预热、本轮返回 null；请求路径零解码。
     // live 标记 = 会话在内存里活着（正在运行或已打开）：批量清理必须跳过。
     disposers.push(ctx.webServer.register({
       kind: 'exact',
@@ -2011,9 +2404,29 @@ export function apply(ctx) {
             })
             if (Number.isFinite(sizeBytes)) sizeById.set(id, sizeBytes)
           }
+          // v3.6.2 #4：标题只读缓存（metaCache → 持久索引 → 权威缓存），未命中
+          // 入后台预热、本轮返回 null。旧实现在请求路径直调 projectTitles——
+          // 展开一个 N 子树的父会话 = N 次整本解码同步在请求路径上（issue #8
+          // 要消灭的形态在本路由的残留）。这里顺手记下指纹与原始 header，供
+          // 缓存读取与 enqueueWarm 使用。
+          const lineageStats = new Map()
+          const lineageHeaders = 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 })
+                // 只有 handle 世代（snapshot 带 revision）才建 stats；legacy 的列表快照
+                // 本就没有这些观测，其标题经 sidebarAuthority 的 authorityTitleCache
+                // 兜住。刻意不在这里合成 sz-only stat——会和列表构建的 mtime:size
+                // 指纹在同一索引里乒乓覆盖，引发交替重复解码。
+                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) { /* best-effort */ }
@@ -2061,11 +2474,19 @@ export function apply(ctx) {
           const allIds = [rootId]
           const walk = (n) => { allIds.push(n.sessionId); n.children.forEach(walk) }
           nodes.forEach(walk)
-          const titles = await projectTitles(allIds)
+          // v3.6.2 #4：缓存读取 + 预热入队，请求路径零解码。#12：标题按
+          // MAX_TITLE 截断，与列表输出口径一致。
+          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) + '…' : 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); n.children.forEach(fill) }
           nodes.forEach(fill)
@@ -2189,6 +2610,24 @@ export function apply(ctx) {
       },
     }))
 
+    // T2：ack 已展示的排队移动通知（尽力清理；失败无害，client 端 localStorage
+    // 已见集合负责多 tab 去重，7 天 TTL 兜底）。
+    disposers.push(ctx.webServer.register({
+      kind: 'exact',
+      path: '/archived-sessions/pending-moves/notices/ack',
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req)
+          const ids = body && Array.isArray(body.ids) ? body.ids : null
+          if (!ids || !ids.length) return json(res, { ok: false, error: 'missing ids' }, 400)
+          const removed = await moveNotices.ack(ids)
+          json(res, { ok: true, removed })
+        } catch (e) {
+          json(res, { ok: false, error: String((e && e.message) || e) }, errorStatus(e))
+        }
+      },
+    }))
+
     // Archive (hide) one session.
     disposers.push(ctx.webServer.register({
       kind: 'exact',