cc-viewer 1.7.12 → 1.7.13

package/dist/index.html

@@ -21,7 +21,7 @@
     // 整体显示大小已弃用 CSS zoom：Electron 改用 webFrame.setZoomFactor（首屏抢占见
     // electron/tab-content-preload.js），纯浏览器交由用户用浏览器自带快捷键缩放，故此处不再设 zoom。
   </script>
-  <script type="module" crossorigin src="./assets/index-QCUTFwkw.js"></script>
+  <script type="module" crossorigin src="./assets/index-DSTQIMmZ.js"></script>
   <link rel="modulepreload" crossorigin href="./assets/vendor-antd-DADYo_zg.js">
   <link rel="modulepreload" crossorigin href="./assets/vendor-codemirror-tF6HNoR6.js">
   <link rel="modulepreload" crossorigin href="./assets/vendor-mdxeditor-CFAmRN3Y.js">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-viewer",
-  "version": "1.7.12",
+  "version": "1.7.13",
   "description": "Claude Code logging, visualization, and management toolkit — launch a web viewer alongside Claude Code with full request/response tracing, proxy, and mobile support",
   "license": "MIT",
   "main": "server.js",

package/server/lib/log-management.js

@@ -4,6 +4,8 @@ import { join, sep, dirname, basename } from 'node:path';
 import { reconstructEntries } from './delta-reconstructor.js';
 import { sanitizePathComponent } from './v2/layout.js';
 import { listV2Sessions } from './v2/adapter.js';
+import { summarizeSessionPage } from './v2/session-list.js';
+import { listSessionIds } from './v2/replay.js';
 
 // wire-v2 S5 addressing (spec §12): 'v2:<project>/<session_id>' in every
 // existing ?file= parameter slot. Components must survive the same whitelist
@@ -122,6 +124,61 @@ export function listV2Logs(logDir, currentProjectName) {
   return { ...grouped, _currentProject: currentProjectName || '' };
 }
 
+/**
+ * Server-side paginated v2 log list for ONE project (2026-07-31). The modal
+ * only ever renders the current project's sessions, so instead of summarizing
+ * every session up front we page: enumerate session dirs (readdir — cheap),
+ * read each meta.json only for the startTs ordering + leader filter, sort
+ * newest-first, then run the EXPENSIVE summarize (journal fold + dir walk +
+ * prompts head) on just the `pageSize` sessions of the requested page — those
+ * go through the same row cache as listV2Sessions, so revisiting a page is
+ * ~1-3ms. Trade-off documented inline: `size==0` and `discard` verdicts live
+ * behind that summarize, so `total` is the pre-filter session count (the empty
+ * / quota-probe sessions are excluded as their pages are computed). For
+ * realistic data (empties + probes are a small minority) this keeps cold open
+ * at ~1 page of work instead of N.
+ *
+ * @returns {{items: Array, total: number, page: number, pageSize: number}}
+ *   items rows keep the exact listV2Logs shape {file, kind, timestamp, size, turns, preview}.
+ */
+export function listV2LogsPage(logDir, project, { page = 1, pageSize = 50 } = {}) {
+  const out = { items: [], total: 0, page, pageSize, _currentProject: project || '' };
+  if (!project) return out;
+  const projectDir = join(logDir, project);
+  if (!existsSync(projectDir)) return out;
+
+  // Cheap pass: order candidates by startTs without paying per-session folds.
+  const candidates = [];
+  for (const dirName of listSessionIds(projectDir)) {
+    let meta = null;
+    try { meta = JSON.parse(readFileSync(join(projectDir, 'sessions', dirName, 'meta.json'), 'utf-8')); } catch { /* journal is self-describing */ }
+    if (meta && meta.leader) continue; // teammate — folded into its leader's row
+    candidates.push({ dirName, startTs: (meta && meta.startTs) || '' });
+  }
+  // Newest first; dirName tiebreak matches listV2Logs' file tiebreak for stability.
+  candidates.sort((a, b) => b.startTs.localeCompare(a.startTs) || b.dirName.localeCompare(a.dirName));
+  out.total = candidates.length;
+
+  const start = (page - 1) * pageSize;
+  for (const c of candidates.slice(start, start + pageSize)) {
+    let s = null;
+    try { s = summarizeSessionPage(projectDir, c.dirName); } catch { continue; }
+    if (!s) continue;
+    if (s.leader) continue;
+    if (s.size === 0) continue;
+    if (s.discard) continue; // quota-probe orphans: never listed
+    out.items.push({
+      file: `v2:${project}/${s.sid}`,
+      kind: 'v2',
+      timestamp: compactLocalTs(s.startTs),
+      size: s.size,
+      turns: s.turns,
+      preview: s.preview || [],
+    });
+  }
+  return out;
+}
+
 /**
  * 1.7.0 v1 view: list legacy v1 `.jsonl` files, grouped per project — same row
  * shape as listV2Logs so LogTable renders both views unchanged. Every

package/server/lib/v2/adapter.js

@@ -27,16 +27,16 @@
 // (sessionId, seq) tie-break — field-equivalent to v1's "teammate writes the
 // leader's file".
 
-import { existsSync, readdirSync, readFileSync, statSync, openSync, readSync, closeSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { join, dirname, basename } from 'node:path';
 import { reportSwallowed } from '../error-report.js';
 import { isMainAgentRequest } from '../interceptor-core.js';
-import { readPromptsHead, collectPromptsFromEvents } from '../user-prompt-extract.js';
-import { readSession, readJsonlTolerant, listSessionIds } from './replay.js';
+import { readSession } from './replay.js';
 import { iterateJsonlLines } from './jsonl-read.js';
 import { isDiscardableSession } from './session-select.js';
-import { blobPath, isSupportedWireFormat, dirSizeSync } from './layout.js';
+import { blobPath, isSupportedWireFormat } from './layout.js';
 import { SingleFlight } from './singleflight.js';
+import { listV2Sessions } from './session-list.js';
 
 // Same stamping rules as the v1 interceptor (KEEP IN SYNC: server/interceptor.js
 // requestEntry construction) — recomputed from the journal's url, not from kind,
@@ -1056,109 +1056,8 @@ export async function streamV2WindowedEntries(sessionDir, opts, onEntry) {
 
 // ─── session listing (spec §12, list entry pulled forward from S6a) ─────────
 
-/** Bounded head read: parse the FIRST JSONL line of a file without loading the
- *  whole thing (a main conversation's opening snapshot can be multi-MB; the
- *  list only wants a preview). Returns null on any shortfall. */
-function readFirstJsonLine(path, budget = 256 * 1024) {
-  let fd;
-  try {
-    fd = openSync(path, 'r');
-    const buf = Buffer.alloc(budget);
-    const n = readSync(fd, buf, 0, budget, 0);
-    const head = buf.toString('utf-8', 0, n);
-    const nl = head.indexOf('\n');
-    if (nl <= 0) return null; // no complete first line inside the budget
-    return JSON.parse(head.slice(0, nl));
-  } catch {
-    return null;
-  } finally {
-    if (fd !== undefined) { try { closeSync(fd); } catch { /* already closed */ } }
-  }
-}
-
-/**
- * Summarize every session under LOG_DIR/<project>/ for the log list (spec §12).
- * Deliberately cheap: journal lines only (small) + a bounded head read of the
- * main conversation's first epoch for the preview — conversation bodies are
- * never loaded. Teammate linkage is surfaced via `leader` so the caller can
- * fold those sessions into their leader's view instead of double-listing.
- * @returns {Array<{sid, dir, startTs, leader, turns, size, preview}>}
- */
-export function listV2Sessions(projectDir) {
-  const out = [];
-  for (const sid of listSessionIds(projectDir)) {
-    try {
-      const dir = join(projectDir, 'sessions', sid);
-      if (!existsSync(join(dir, 'journal.jsonl'))) continue;
-      let meta = null;
-      try { meta = JSON.parse(readFileSync(join(dir, 'meta.json'), 'utf-8')); } catch { /* tolerated — journal is self-describing */ }
-      if (meta && meta.wireFormat != null && !isSupportedWireFormat(meta.wireFormat)) {
-        // Reader version gate (spec §14): don't list a session this build
-        // can't read — a garbage preview/turn-count is worse than absence.
-        reportSwallowed('v2-read.unsupported-wire-format', new Error(`${sid}: wireFormat=${meta.wireFormat}`));
-        continue;
-      }
-
-      // turns = main requests that completed (journal two-phase fold). The
-      // journal sentinel is checked in the same pass: per §14 the per-file
-      // sentinel WINS over meta.json, and readSession/adapter refuse such a
-      // session — listing it would show a phantom row that opens empty.
-      const reqKind = new Map();
-      let turns = 0;
-      let sentinelVersion = null;
-      let hasMainOrTeammate = false;
-      for (const line of readJsonlTolerant(join(dir, 'journal.jsonl'))) {
-        if (line.ph === 'req') {
-          reqKind.set(line.seq, line.kind);
-          if (line.kind === 'main' || line.kind === 'teammate') hasMainOrTeammate = true;
-        }
-        else if (line.ph === 'done' && reqKind.get(line.seq) === 'main') {
-          turns++;
-          reqKind.delete(line.seq); // fold duplicate done lines (§14)
-        } else if (line.ph === 'meta' && typeof line.wireFormat === 'number' && !isSupportedWireFormat(line.wireFormat)) {
-          sentinelVersion = line.wireFormat;
-          break;
-        }
-      }
-      if (sentinelVersion != null) {
-        reportSwallowed('v2-read.unsupported-wire-format', new Error(`${sid}: wireFormat=${sentinelVersion} (journal sentinel)`));
-        continue;
-      }
-
-      // preview = ALL user prompts of the session, from the prompts.jsonl
-      // display cache (written by V2Writer / the converter; bounded head read
-      // so the list stays O(budget) per session). Sessions predating the
-      // cache fall back to the first epoch's first line — routed through the
-      // shared extractor so command/caveat chrome never leaks into the row.
-      let preview = readPromptsHead(join(dir, 'prompts.jsonl'));
-      if (preview.length === 0) {
-        const first = readFirstJsonLine(join(dir, 'conversations', 'main', 'e0.jsonl'));
-        if (first && Array.isArray(first.msgs)) {
-          preview = collectPromptsFromEvents([first]);
-        }
-      }
-
-      out.push({
-        sid,
-        dir,
-        startTs: (meta && meta.startTs) || '',
-        leader: (meta && meta.leader) || null,
-        turns,
-        size: dirSizeSync(dir),
-        preview,
-        // Discardable-session verdict. KEEP IN SYNC: session-select.js
-        // isDiscardableSession is the canonical rule; this fold pre-computes
-        // it for free over the FULL journal (the canonical scan is 8MB-
-        // budgeted — intentional asymmetry, a first main sits at the head).
-        // When the fold says discard, the canonical predicate CONFIRMS it:
-        // readJsonlTolerant swallows an I/O error (Windows EBUSY/EPERM lock)
-        // into zero lines, which must KEEP the session, not hide it — the
-        // canonical path carries that error→keep direction (ioErrorResult).
-        // Main-bearing sessions never pay the extra read; probe journals are
-        // ~3 lines.
-        discard: !(meta && meta.leader) && !hasMainOrTeammate && isDiscardableSession(dir, meta),
-      });
-    } catch { /* one unreadable session must not break the list */ }
-  }
-  return out;
-}
+// listV2Sessions is re-exported from session-list.js (P0-A row cache, 2026-07-31).
+// The full per-session summarization logic (incl. the readFirstJsonLine preview
+// fallback) moved there; this re-export keeps the public API unchanged for all
+// callers (log-management.js, routes/im.js, tests).
+export { listV2Sessions };

package/server/lib/v2/convert-manager.js

@@ -10,6 +10,7 @@
 import { Worker } from 'node:worker_threads';
 import { join } from 'node:path';
 import { readConvertState } from './convert.js';
+import { _invalidate as _invalidateMigrationStatus } from './migrate-prompt.js';
 
 let _running = null; // { project, logDir, worker, startedAt, progress }
 let _lastError = null; // last worker-level failure (state file may lag on hard crashes)
@@ -36,7 +37,12 @@ export function startConvert(logDir, project) {
   worker.on('message', (msg) => {
     if (!msg || !_running || _running.worker !== worker) return;
     if (msg.type === 'progress') _running.progress = msg.progress;
-    else if (msg.type === 'final' && msg.error) _lastError = msg.error;
+    else if (msg.type === 'final') {
+      if (msg.error) _lastError = msg.error;
+      // A finished conversion immediately changes what migrationStatus returns
+      // for this project — drop the memo so the next call re-scans.
+      _invalidateMigrationStatus(_running.logDir, msg.project);
+    }
   });
   worker.on('error', (err) => {
     _lastError = String(err && err.message || err);

package/server/lib/v2/migrate-prompt.js

@@ -5,10 +5,23 @@
 // pending unless the convert state marks it done AT ITS CURRENT SIZE (the
 // converter's trust rule, convert.js), because the converter never deletes
 // v1 sources ("files exist" alone is not "migration needed").
+//
+// P0-B (2026-07-31): 10s TTL memo per (logDir, project). migrationStatus is
+// called on every SSE connect (events.js), every list refresh (logs.js), and
+// every workspace boot — each call stat-scans ALL v1 files of ALL projects.
+// The memo collapses repeat calls to a Map lookup. `now` is injectable for
+// tests (same house style as singleflight.js). Invalidation hook: the convert
+// manager calls _invalidate() when its worker posts {type:'final'} (bypasses
+// the 1s progress throttle), so a finished conversion is reflected immediately.
 import { statSync } from 'node:fs';
 import { join } from 'node:path';
 import { listV1Files, listConvertibleProjects, readConvertState } from './convert.js';
 
+const TTL_MS = 10_000;
+/** @type {Map<string, {value: object, expiresAt: number}>} */
+const _memo = new Map();
+let _now = Date.now;
+
 /** Pending v1 files + bytes of ONE project dir. */
 function pendingOf(projectDir) {
   const state = readConvertState(projectDir);
@@ -36,6 +49,8 @@ function pendingOf(projectDir) {
 /**
  * Migration status of one project (plus how many OTHER projects also have
  * pending v1 logs — the prompt mentions `ccv convert --all` for those).
+ * Memoized for TTL_MS per (logDir, project); see module header for the
+ * invalidation contract.
  * @param {string} logDir - LOG_DIR root
  * @param {string} project - project directory name ('' → not pending)
  * @returns {{pending: boolean, files: number, totalBytes: number, otherProjects: number}}
@@ -43,6 +58,9 @@ function pendingOf(projectDir) {
 export function migrationStatus(logDir, project) {
   const empty = { pending: false, files: 0, totalBytes: 0, otherProjects: 0 };
   if (!logDir || !project) return empty;
+  const cacheKey = `${logDir}\0${project}`;
+  const cached = _memo.get(cacheKey);
+  if (cached && _now() < cached.expiresAt) return cached.value;
   try {
     const { files, totalBytes } = pendingOf(join(logDir, project));
     let otherProjects = 0;
@@ -50,8 +68,28 @@ export function migrationStatus(logDir, project) {
       if (p === project) continue;
       if (pendingOf(join(logDir, p)).files > 0) otherProjects++;
     }
-    return { pending: files > 0, files, totalBytes, otherProjects };
+    const value = { pending: files > 0, files, totalBytes, otherProjects };
+    _memo.set(cacheKey, { value, expiresAt: _now() + TTL_MS });
+    return value;
   } catch {
     return empty;
   }
 }
+
+/** Drop the memo for one (or all) projects — called by the convert manager
+ *  when a conversion worker finishes, and by tests. */
+export function _invalidate(logDir, project) {
+  if (logDir === undefined) { _memo.clear(); return; }
+  _memo.delete(`${logDir}\0${project}`);
+}
+
+/** Test hook: replace the clock (pass `() => t`); call without args to restore. */
+export function _setNowForTest(fn) {
+  _now = fn || Date.now;
+}
+
+/** Test hook: drop all memoized entries. */
+export function _resetForTest() {
+  _memo.clear();
+  _now = Date.now;
+}

package/server/lib/v2/session-list.js

@@ -0,0 +1,276 @@
+// Wire Format v2 — session-row cache for the log list (P0-A, 2026-07-31).
+//
+// `GET /api/local-logs` re-scans every session on every call: full journal
+// fold, recursive dir walk, 256KB prompts head read, meta read — all sync,
+// all blocking the event loop. With 100+ sessions this costs seconds.
+//
+// The journal is append-only (the single write path is Journal.writeReq/
+// writeDone → AsyncWriteQueue.appendTo; creation is a one-time 'wx' sentinel;
+// no truncate/rename/unlink anywhere). Content changes land in the journal
+// LAST within a request (blobs → conversation → journal line → prompts), so
+// (size, mtimeMs) is an exact freshness key for everything up to the journal
+// line. prompts.jsonl is appended strictly AFTER the journal line (and is
+// backfilled without a journal write on crash-resume), so the freshness key
+// spans BOTH files: `journalSize:journalMtimeMs:promptsSize:promptsMtimeMs`.
+// A repeated key means identical row inputs; any content change bumps one of
+// the two stats.
+//
+// Cache shape: Map<projectDir, Map<sid, Row>> keyed by the project dir, with
+// per-sid rows keyed by the freshness pair above. Insertion-order eviction
+// caps the project map at MAX_PROJECTS. Rows are re-copied on return (see
+// copyRow) so callers can't mutate the cache.
+
+import { statSync, existsSync, readFileSync, openSync, readSync, closeSync } from 'node:fs';
+import { join } from 'node:path';
+import { listSessionIds, readJsonlTolerant } from './replay.js';
+import { readPromptsHead, collectPromptsFromEvents } from '../user-prompt-extract.js';
+import { isDiscardableSession } from './session-select.js';
+import { isSupportedWireFormat, dirSizeSync } from './layout.js';
+import { reportSwallowed } from '../error-report.js';
+
+const MAX_PROJECTS = 32;
+
+// ─── internal helpers (verbatim extraction from adapter.js) ──────────────────
+
+/** Bounded head read: parse the FIRST JSONL line of a file without loading the
+ *  whole thing (a main conversation's opening snapshot can be multi-MB; the
+ *  list only wants a preview). Returns null on any shortfall. */
+function readFirstJsonLine(path, budget = 256 * 1024) {
+  let fd;
+  try {
+    fd = openSync(path, 'r');
+    const buf = Buffer.alloc(budget);
+    const n = readSync(fd, buf, 0, budget, 0);
+    const head = buf.toString('utf-8', 0, n);
+    const nl = head.indexOf('\n');
+    if (nl <= 0) return null; // no complete first line inside the budget
+    return JSON.parse(head.slice(0, nl));
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined) { try { closeSync(fd); } catch { /* already closed */ } }
+  }
+}
+
+// ─── per-session summarization ───────────────────────────────────────────────
+
+/**
+ * Compute the summary row for one session dir. This is the exact logic that
+ * used to live inline in listV2Sessions (adapter.js). All gates and error
+ * directions are preserved verbatim:
+ *
+ *   - wireFormat gate (meta.json) → skip + reportSwallowed
+ *   - wireFormat gate (journal sentinel) → skip + reportSwallowed
+ *   - error→keep: journal stat failure skips the row, never caches
+ *   - discard short-circuit: !leader && !hasMainOrTeammate && isDiscardableSession()
+ *   - no "journal non-empty" guard — torn creation is tolerated as turns:0
+ *
+ * @returns {object|null} row {sid, dir, startTs, leader, turns, size, preview, discard}
+ *   or null if the session should be skipped
+ */
+function summarizeSession(projectDir, sid) {
+  const dir = join(projectDir, 'sessions', sid);
+  // Journal existence is the cheapest gate — a session dir without one is
+  // either torn at creation or not a session at all.
+  if (!existsSync(join(dir, 'journal.jsonl'))) return null;
+  let meta = null;
+  try { meta = JSON.parse(readFileSync(join(dir, 'meta.json'), 'utf-8')); } catch { /* tolerated — journal is self-describing */ }
+  if (meta && meta.wireFormat != null && !isSupportedWireFormat(meta.wireFormat)) {
+    // Reader version gate (spec §14): don't list a session this build
+    // can't read — a garbage preview/turn-count is worse than absence.
+    reportSwallowed('v2-read.unsupported-wire-format', new Error(`${sid}: wireFormat=${meta.wireFormat}`));
+    return null;
+  }
+
+  // turns = main requests that completed (journal two-phase fold). The
+  // journal sentinel is checked in the same pass: per §14 the per-file
+  // sentinel WINS over meta.json, and readSession/adapter refuse such a
+  // session — listing it would show a phantom row that opens empty.
+  const reqKind = new Map();
+  let turns = 0;
+  let sentinelVersion = null;
+  let hasMainOrTeammate = false;
+  for (const line of readJsonlTolerant(join(dir, 'journal.jsonl'))) {
+    if (line.ph === 'req') {
+      reqKind.set(line.seq, line.kind);
+      if (line.kind === 'main' || line.kind === 'teammate') hasMainOrTeammate = true;
+    }
+    else if (line.ph === 'done' && reqKind.get(line.seq) === 'main') {
+      turns++;
+      reqKind.delete(line.seq); // fold duplicate done lines (§14)
+    } else if (line.ph === 'meta' && typeof line.wireFormat === 'number' && !isSupportedWireFormat(line.wireFormat)) {
+      sentinelVersion = line.wireFormat;
+      break;
+    }
+  }
+  if (sentinelVersion != null) {
+    reportSwallowed('v2-read.unsupported-wire-format', new Error(`${sid}: wireFormat=${sentinelVersion} (journal sentinel)`));
+    return null;
+  }
+
+  // preview = ALL user prompts of the session, from the prompts.jsonl
+  // display cache (written by V2Writer / the converter; bounded head read
+  // so the list stays O(budget) per session). Sessions predating the
+  // cache fall back to the first epoch's first line — routed through the
+  // shared extractor so command/caveat chrome never leaks into the row.
+  let preview = readPromptsHead(join(dir, 'prompts.jsonl'));
+  if (preview.length === 0) {
+    const first = readFirstJsonLine(join(dir, 'conversations', 'main', 'e0.jsonl'));
+    if (first && Array.isArray(first.msgs)) {
+      preview = collectPromptsFromEvents([first]);
+    }
+  }
+
+  return {
+    sid,
+    dir,
+    startTs: (meta && meta.startTs) || '',
+    leader: (meta && meta.leader) || null,
+    turns,
+    size: dirSizeSync(dir),
+    preview,
+    // Discardable-session verdict. KEEP IN SYNC: session-select.js
+    // isDiscardableSession is the canonical rule; this fold pre-computes
+    // it for free over the FULL journal (the canonical scan is 8MB-
+    // budgeted — intentional asymmetry, a first main sits at the head).
+    // When the fold says discard, the canonical predicate CONFIRMS it:
+    // readJsonlTolerant swallows an I/O error (Windows EBUSY/EPERM lock)
+    // into zero lines, which must KEEP the session, not hide it — the
+    // canonical path carries that error→keep direction (ioErrorResult).
+    // Main-bearing sessions never pay the extra read; probe journals are
+    // ~3 lines.
+    discard: !(meta && meta.leader) && !hasMainOrTeammate && isDiscardableSession(dir, meta),
+  };
+}
+
+// ─── row cache ───────────────────────────────────────────────────────────────
+
+/** Map<projectDir, Map<sid, {key, row}>> — insertion-order eviction. */
+const _cache = new Map();
+
+function _evictProjects() {
+  while (_cache.size > MAX_PROJECTS) {
+    const oldest = _cache.keys().next().value;
+    _cache.delete(oldest);
+  }
+}
+
+/**
+ * Summarize every session under LOG_DIR/<project>/ for the log list (spec §12).
+ * Deliberately cheap: journal lines only (small) + a bounded head read of the
+ * main conversation's first epoch for the preview — conversation bodies are
+ * never loaded. Teammate linkage is surfaced via `leader` so the caller can
+ * fold those sessions into their leader's view instead of double-listing.
+ *
+ * Cached: repeat calls with unchanged journals return instantly (~1-3ms for
+ * 100 sessions, vs. seconds for a full rescan).
+ *
+ * @returns {Array<{sid, dir, startTs, leader, turns, size, preview, discard}>}
+ */
+export function listV2Sessions(projectDir) {
+  const sids = listSessionIds(projectDir);
+  const sidSet = new Set(sids); // O(1) prune lookups — sids.includes() per cached sid is O(N²)
+  let projectCache = _cache.get(projectDir);
+  if (!projectCache) {
+    projectCache = new Map();
+    _cache.set(projectDir, projectCache);
+    _evictProjects();
+  }
+  // Prune deleted/migrated sessions: a sid no longer in the readdir is gone.
+  for (const sid of projectCache.keys()) {
+    if (!sidSet.has(sid)) projectCache.delete(sid);
+  }
+  const out = [];
+  for (const sid of sids) {
+    try {
+      const dir = join(projectDir, 'sessions', sid);
+      let key;
+      try {
+        const jst = statSync(join(dir, 'journal.jsonl'));
+        // Freshness key spans journal AND prompts.jsonl: the display cache is
+        // appended strictly AFTER the journal line (v2-writer.js §5), so a list
+        // call landing between the two queue drains — or a crash-resume
+        // backfill that appends prompts without any journal write — must not
+        // freeze a pre-prompts preview under an unchanged journal key. Absent
+        // prompts use a placeholder: their first write always follows a journal
+        // append, except exactly that backfill path, which this key detects.
+        let pKey = '-:-';
+        try {
+          const pst = statSync(join(dir, 'prompts.jsonl'));
+          pKey = `${pst.size}:${pst.mtimeMs}`;
+        } catch { /* prompts.jsonl not written yet */ }
+        key = `${jst.size}:${jst.mtimeMs}:${pKey}`;
+      } catch {
+        continue; // journal unreadable → skip row, never cache
+      }
+      const cached = projectCache.get(sid);
+      if (cached && cached.key === key) {
+        out.push(copyRow(cached.row)); // defensive copy — callers must not mutate cache
+        continue;
+      }
+      const row = summarizeSession(projectDir, sid);
+      if (row) {
+        projectCache.set(sid, { key, row });
+        out.push(copyRow(row));
+      }
+      // row === null → session skipped (wireFormat gate, sentinel, etc.) — don't cache
+    } catch { /* one unreadable session must not break the list */ }
+  }
+  return out;
+}
+
+/** Copy a row for delivery: nested `preview` (array) and `leader` (object) are
+ *  re-copied so a caller mutating what it received can never poison the cache
+ *  entry shared by every viewer of the project. */
+function copyRow(row) {
+  return {
+    ...row,
+    ...(row.leader ? { leader: { ...row.leader } } : {}),
+    preview: [...row.preview],
+  };
+}
+
+/**
+ * Summarize ONE session for the paginated list (server-side paging, 2026-07-31).
+ * Same row + same cache as listV2Sessions: a key hit returns the cached row
+ * without re-folding the journal; a miss computes and stores it. The caller
+ * (listV2LogsPage) has already decided this sid is on the current page, so only
+ * these sessions ever pay the summarize cost.
+ *
+ * @returns {object|null} row {sid, dir, startTs, leader, turns, size, preview, discard}
+ *   or null if the session should be skipped (wireFormat gate, sentinel, no journal)
+ */
+export function summarizeSessionPage(projectDir, sid) {
+  const dir = join(projectDir, 'sessions', sid);
+  let key;
+  try {
+    const jst = statSync(join(dir, 'journal.jsonl'));
+    let pKey = '-:-';
+    try {
+      const pst = statSync(join(dir, 'prompts.jsonl'));
+      pKey = `${pst.size}:${pst.mtimeMs}`;
+    } catch { /* prompts.jsonl not written yet */ }
+    key = `${jst.size}:${jst.mtimeMs}:${pKey}`;
+  } catch {
+    return null; // journal unreadable → skip, never cache
+  }
+  let projectCache = _cache.get(projectDir);
+  if (!projectCache) {
+    projectCache = new Map();
+    _cache.set(projectDir, projectCache);
+    _evictProjects();
+  }
+  const cached = projectCache.get(sid);
+  if (cached && cached.key === key) return copyRow(cached.row);
+  const row = summarizeSession(projectDir, sid);
+  if (row) {
+    projectCache.set(sid, { key, row });
+    return copyRow(row);
+  }
+  return null; // skipped (wireFormat gate, sentinel, etc.) — don't cache
+}
+
+/** Test hook: drop all cached rows. */
+export function _resetForTest() {
+  _cache.clear();
+}

package/server/lib/v2/session-select.js

@@ -215,10 +215,10 @@ export function sessionHasMainOrTeammateReq(dir) {
  * the moment a dir gains its first main req, the predicate flips and every
  * surface picks it up on its next scan/poll.
  *
- * KEEP IN SYNC: adapter.js listV2Sessions pre-computes the same verdict
- * inline (hasMainOrTeammate inside its existing full journal fold — unbounded,
- * vs this predicate's 8MB budget; intentional asymmetry) and then CONFIRMS a
- * discard through this predicate so the error→keep direction is shared.
+ * KEEP IN SYNC: session-list.js summarizeSession pre-computes the same verdict
+ * inline (hasMainOrTeammate inside its full journal fold — unbounded, vs this
+ * predicate's 8MB budget; intentional asymmetry) and then CONFIRMS a discard
+ * through this predicate so the error→keep direction is shared.
  * Change the rule here and there together.
  *
  * @param {string} dir - absolute session dir