cc-viewer 1.6.348 → 1.7.0

package/server/lib/v2/verify.js

@@ -0,0 +1,233 @@
+// Wire Format v2 — S4 dual-write consistency verifier (plan gate methodology).
+//
+// Compares one v1 JSONL file against the v2 session dirs of the same project,
+// per request, on WIRE TRUTH:
+//   ① per-request wire-messages digest: v1 incremental delta reconstruction vs
+//     v2 mechanical replay (this is trajectory-grade — every intermediate
+//     state is compared, not just the cold final one);
+//   ② per-request tools/system content hash: v1 inline value hashed with the
+//     BlobStore formula vs the v2 journal's CAS ref (byte-equality by CAS);
+//   ③ teammate entries verified the same per-request way (v1's leader file
+//     holds them inline; v2 holds them in the teammate's own session dir —
+//     matching is by `${ts}|${url}`, so no re-join ordering is needed here);
+//   ④ inflight/error accounting: v1 keys that never completed vs v2
+//     req-without-done;
+//   ⑤ journal msgTo vs replayed length integrity (internal v2 consistency).
+//
+// v1-only requests are counted, not failed: history from before dual-write was
+// enabled (or while it was toggled off) legitimately has no v2 twin.
+//
+// KNOWN LIMITATION (review): the ① digest is built on the client-shared
+// messageFingerprint, which keys tool_result blocks on tool_use_id ONLY — a
+// divergence confined to tool_result BODY content between v1 and v2 collides
+// to identical digests and is invisible to this gate. The write side now uses
+// the content-aware fingerprintMsg for its judgement (conversation-store.js),
+// which removes the known producer of that divergence class; the residual risk
+// is a v2 bug that corrupts tool_result content while preserving ids.
+
+import { statSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { iterateRawEntriesAsync } from '../log-stream.js';
+import { createIncrementalReconstructor } from '../delta-reconstructor.js';
+import { listSessionIds, readSession, indexSession, messagesDigest, blobRefOf } from './replay.js';
+
+const MAX_REPORTED_DIFFS = 50;
+
+/**
+ * Verify one v1 file against its project's v2 sessions.
+ * @param {string} v1File - absolute path to a v1 .jsonl (its dirname is the project dir)
+ * @param {object} [opts]
+ * @param {string} [opts.projectDir] - override project dir (defaults to dirname(v1File))
+ * @param {string} [opts.sessionsDirName] - session-dir name under the project
+ *   dir; the offline converter verifies its staging area ('sessions-migrating')
+ *   before promoting. Defaults to the live 'sessions'.
+ * @param {(p: {entriesScanned: number}) => void} [opts.onProgress] - called
+ *   every 1000 scanned v1 entries and once after the scan completes, so a
+ *   long-running verify of one big file can surface live progress. Callback
+ *   errors are swallowed — progress must never break the verification.
+ * @returns {Promise<object>} report (see shape at the bottom)
+ */
+export async function verifyV1File(v1File, opts = {}) {
+  const projectDir = opts.projectDir || dirname(v1File);
+  const sessionsDirName = opts.sessionsDirName || 'sessions';
+  const onProgress = typeof opts.onProgress === 'function' ? opts.onProgress : null;
+
+  // ---- v2 side: index every session of the project --------------------------
+  // `${ts}|${url}` is NOT unique in real logs (same-millisecond countTokens
+  // bursts, §3.6 rotation twins) — keep ALL records per key and match each v1
+  // entry to its best unmatched candidate below (real-data finding 2026-07-14).
+  const v2Index = new Map(); // key → rec[]
+  const integrity = [];
+  const v2Sessions = [];
+  const unsupportedSessions = []; // reader version gate (spec §14): a session
+  // this build can't read means the gate has a coverage hole — FAIL, don't skip.
+  for (const sid of listSessionIds(projectDir, sessionsDirName)) {
+    const session = readSession(projectDir, sid, sessionsDirName);
+    // Report the session IDENTITY (UUID from meta), not the dir name — the dir
+    // is `<ts>_<uuid>` post task C; falls back to the dir name on torn meta.
+    v2Sessions.push((session.meta && session.meta.sessionId) || sid);
+    if (session.unsupported) {
+      unsupportedSessions.push({ sessionId: sid, wireFormat: session.wireFormat });
+      continue;
+    }
+    const { index, integrity: viol } = indexSession(session);
+    integrity.push(...viol);
+    for (const [key, recs] of index) {
+      const arr = v2Index.get(key);
+      if (arr) arr.push(...recs); else v2Index.set(key, [...recs]);
+    }
+  }
+
+  // ---- v1 side: stream, reconstruct incrementally, compare ------------------
+  const reconstructor = createIncrementalReconstructor();
+  const diffs = [];
+  const inflightV1 = new Set();   // keys seen only as inProgress
+  const counters = {
+    v1Completed: 0, v1Skipped: 0, matched: 0, v1Only: 0, v1DuplicateKey: 0,
+    heartbeatsV1: 0, countTokensV1: 0, teammateV1: 0, staleOrBroken: 0,
+  };
+  // Per-session suspicion tally, keyed by the v2 session dir name (the same
+  // value `listSessionIds` / the converter's promote loop iterate). UNCAPPED —
+  // unlike `diffs` (bounded by MAX_REPORTED_DIFFS for memory/reporting), this
+  // must hold EVERY suspect session so the converter can quarantine the full
+  // set; capping it would silently promote corrupt sessions past diff #50.
+  const suspectSessions = new Map(); // sessionId → { count, reasons: string[] }
+  const MAX_REASONS = 5;
+  const flagSession = (sessionId, reason) => {
+    if (!sessionId) return;
+    let rec = suspectSessions.get(sessionId);
+    if (!rec) suspectSessions.set(sessionId, rec = { count: 0, reasons: [] });
+    rec.count++;
+    if (rec.reasons.length < MAX_REASONS) rec.reasons.push(reason);
+  };
+  const addDiff = (d) => {
+    flagSession(d.sessionId, `${d.type}@seq${d.seq}`);
+    if (diffs.length < MAX_REPORTED_DIFFS) diffs.push(d);
+  };
+
+  const onScan = (raw) => {
+    let entry;
+    try { entry = JSON.parse(raw); } catch { return; }
+    if (entry.ccvRotationContext) return;
+    const key = `${entry.timestamp}|${entry.url}`;
+    if (entry.inProgress) { inflightV1.add(key); return; }
+    inflightV1.delete(key);
+
+    // Incremental reconstruction restores the full wire messages for delta
+    // entries (teammate/sub entries pass through untouched, already full).
+    reconstructor.reconstruct(entry);
+    if (entry._staleReorder || entry._reconstructBroken) { counters.staleOrBroken++; return; }
+    counters.v1Completed++;
+    if (entry.isHeartbeat) counters.heartbeatsV1++;
+    if (entry.isCountTokens) counters.countTokensV1++;
+    if (entry.teammate) counters.teammateV1++;
+
+    const candidates = v2Index.get(key);
+    if (!candidates) { counters.v1Only++; return; }
+    const v1Digest = entry.body && Array.isArray(entry.body.messages) ? messagesDigest(entry.body.messages) : null;
+    const unmatched = candidates.filter(c => !c._matched);
+    if (unmatched.length === 0) {
+      // Every v2 twin already consumed: this v1 line is a duplicate completed
+      // write of the same request (§3.6 rotation race) — count, don't fail.
+      counters.v1DuplicateKey++;
+      return;
+    }
+    // Best candidate: digest-equal first (same-key bursts carry different
+    // payloads — pairing by content avoids cross-matching twins), else FIFO.
+    const v2 = (v1Digest && unmatched.find(c => c.digest === v1Digest)) || unmatched[0];
+    counters.matched++;
+    v2._matched = true;
+
+    // ① wire-messages digest (skip heartbeats — no conversation on either side)
+    if (v2.conv && v1Digest != null) {
+      if (v1Digest !== v2.digest) {
+        addDiff({ type: 'messages-digest', sessionId: v2.sessionId, key, seq: v2.seq, conv: v2.conv, v1: v1Digest, v2: v2.digest, v1Len: entry.body.messages.length, v2Len: v2.len });
+      }
+    }
+    // ② tools/system CAS equality
+    const v1Tools = blobRefOf(entry.body && entry.body.tools);
+    const v1Sys = blobRefOf(entry.body && entry.body.system);
+    if (v1Tools !== v2.toolsRef) addDiff({ type: 'tools-ref', sessionId: v2.sessionId, key, seq: v2.seq, v1: v1Tools, v2: v2.toolsRef });
+    if (v1Sys !== v2.sysRef) addDiff({ type: 'system-ref', sessionId: v2.sessionId, key, seq: v2.seq, v1: v1Sys, v2: v2.sysRef });
+    // ③ teammate attribution
+    if (!!entry.teammate !== (v2.kind === 'teammate')) {
+      addDiff({ type: 'teammate-kind', sessionId: v2.sessionId, key, seq: v2.seq, v1: !!entry.teammate, v2: v2.kind });
+    }
+    // ④ completion accounting
+    if (!v2.done) addDiff({ type: 'missing-done', sessionId: v2.sessionId, key, seq: v2.seq });
+  };
+
+  // Single streaming pass (1MB chunks): verify must stay memory-bounded on
+  // 300MB soak files — no dedup map, no second pass (review P2).
+  let entriesScanned = 0;
+  for await (const raw of iterateRawEntriesAsync(v1File)) {
+    onScan(raw);
+    entriesScanned++;
+    if (onProgress && entriesScanned % 1000 === 0) {
+      try { onProgress({ entriesScanned }); } catch { /* progress must never break the verify */ }
+    }
+  }
+  if (onProgress) {
+    try { onProgress({ entriesScanned }); } catch { /* progress must never break the verify */ }
+  }
+
+  // v2 records never matched by any v1 entry in THIS file: only suspicious if
+  // their req/done both exist (a live v2-only write) — they may simply belong
+  // to another v1 segment (rotation), so count, don't fail.
+  let v2Unmatched = 0;
+  const v2ReqWithoutDone = [];
+  for (const [key, recs] of v2Index) {
+    for (const rec of recs) {
+      if (!rec._matched) v2Unmatched++;
+      if (!rec.done) v2ReqWithoutDone.push(key);
+    }
+  }
+
+  // Integrity violations and unsupported-wire sessions are collected during the
+  // v2-side indexing pass above (before `flagSession` exists), so fold them into
+  // the per-session tally here — they condemn a session just as a diff does.
+  for (const v of integrity) flagSession(v.sessionId, `integrity@seq${v.seq}`);
+  for (const u of unsupportedSessions) flagSession(u.sessionId, `unsupported:${u.wireFormat}`);
+
+  const fileSize = (() => { try { return statSync(v1File).size; } catch { return 0; } })();
+  const report = {
+    v1File,
+    projectDir,
+    fileSize,
+    v2Sessions,
+    counters: { ...counters, v2Requests: v2Index.size, v2Unmatched, v1InflightOnly: inflightV1.size, v2ReqWithoutDone: v2ReqWithoutDone.length },
+    diffs,
+    integrity,
+    unsupportedSessions,
+    // Complete (uncapped) set of suspect sessions for the converter to quarantine.
+    suspectSessions: [...suspectSessions.entries()].map(([sessionId, r]) => ({ sessionId, count: r.count, reasons: r.reasons })),
+    ok: diffs.length === 0 && integrity.length === 0 && unsupportedSessions.length === 0,
+  };
+  return report;
+}
+
+/** Human-readable one-screen rendering for the CLI. */
+export function renderReport(report) {
+  const c = report.counters;
+  const lines = [];
+  lines.push(`wire-v2 verify — ${report.v1File}`);
+  lines.push(`  project: ${report.projectDir}`);
+  lines.push(`  v2 sessions scanned: ${report.v2Sessions.length}, v2 requests indexed: ${c.v2Requests}`);
+  lines.push(`  v1 completed: ${c.v1Completed} (heartbeat ${c.heartbeatsV1}, countTokens ${c.countTokensV1}, teammate ${c.teammateV1}, stale/broken skipped ${c.staleOrBroken})`);
+  lines.push(`  matched: ${c.matched}   v1-only (no v2 twin — pre-dual-write history): ${c.v1Only}   v1-duplicate-key (rotation twins): ${c.v1DuplicateKey || 0}   v2-unmatched (other segments): ${c.v2Unmatched}`);
+  lines.push(`  inflight: v1-only ${c.v1InflightOnly}, v2 req-without-done ${c.v2ReqWithoutDone}`);
+  if (report.unsupportedSessions && report.unsupportedSessions.length > 0) {
+    lines.push(`  UNSUPPORTED WIRE FORMAT (reader version gate): ${report.unsupportedSessions.length}`);
+    for (const u of report.unsupportedSessions.slice(0, 10)) lines.push(`    ${u.sessionId} wireFormat=${u.wireFormat}`);
+  }
+  if (report.integrity.length > 0) {
+    lines.push(`  INTEGRITY VIOLATIONS (journal msgTo vs replay): ${report.integrity.length}`);
+    for (const v of report.integrity.slice(0, 10)) lines.push(`    ${v.sessionId} seq=${v.seq} conv=${v.conv} msgTo=${v.msgTo} replayed=${v.replayedLen}`);
+  }
+  if (report.diffs.length > 0) {
+    lines.push(`  DIFFS: ${report.diffs.length}${report.diffs.length >= 50 ? '+ (capped)' : ''}`);
+    for (const d of report.diffs.slice(0, 10)) lines.push(`    [${d.type}] seq=${d.seq} ${d.key}\n      v1=${JSON.stringify(d.v1)} v2=${JSON.stringify(d.v2)}`);
+  }
+  lines.push(report.ok ? '  RESULT: OK — zero diffs' : '  RESULT: FAILED');
+  return lines.join('\n');
+}

package/server/routes/events.js

@@ -1,10 +1,11 @@
 // SSE event stream + log-registration / resume / turn-end routes (moved verbatim from server.js).
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { LOG_FILE, _resumeState, resolveResumeChoice, _projectName } from '../interceptor.js';
+import { _projectName, getLiveLogSource, isContinuedLaunch } from '../interceptor.js';
 import { LOG_DIR } from '../../findcc.js';
-import { watchLogFile } from '../lib/log-watcher.js';
-import { countLogEntries, streamRawEntriesAsync, readPagedEntries } from '../lib/log-stream.js';
+import { streamRawEntriesAsync } from '../lib/log-stream.js';
+import { migrationStatus } from '../lib/v2/migrate-prompt.js';
+import { reportSwallowed } from '../lib/error-report.js';
 import { awaitDrainOrClose } from '../lib/sse-backpressure.js';
 import { enrichRawIfNeeded } from '../lib/enrich-plan-input.js';
 import { validateLogPath } from '../lib/log-management.js';
@@ -49,77 +50,6 @@ function turnEndNotify(req, res, parsedUrl, isLocal, deps) {
   });
 }
 
-// 注册新的日志文件进行 watch（供新进程复用旧服务时调用）
-function registerLog(req, res, parsedUrl, isLocal, deps) {
-  let body = '';
-  req.on('data', chunk => { body += chunk; if (body.length > deps.MAX_POST_BODY) req.destroy(); });
-  req.on('end', () => {
-    try {
-      const { logFile } = JSON.parse(body);
-      if (logFile && typeof logFile === 'string' && logFile.startsWith(LOG_DIR) && existsSync(logFile)) {
-        watchLogFile(deps.logWatcherOpts(logFile));
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ ok: true }));
-      } else {
-        res.writeHead(400, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Invalid log file path' }));
-      }
-    } catch {
-      res.writeHead(400, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'Invalid request body' }));
-    }
-  });
-}
-
-// 用户选择继续/新开日志
-function resumeChoice(req, res, parsedUrl, isLocal, deps) {
-  let body = '';
-  req.on('data', chunk => { body += chunk; if (body.length > deps.MAX_POST_BODY) req.destroy(); });
-  req.on('end', async () => {
-    try {
-      const { choice } = JSON.parse(body);
-      if (choice !== 'continue' && choice !== 'new') {
-        res.writeHead(400, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Invalid choice' }));
-        return;
-      }
-      const result = resolveResumeChoice(choice);
-      if (!result) {
-        res.writeHead(409, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Already resolved' }));
-        return;
-      }
-      // 重新 watch 最终的日志文件
-      watchLogFile(deps.logWatcherOpts(result.logFile));
-      // 广播 resume_resolved + full_reload
-      const resolvedData = JSON.stringify({ logFile: result.logFile });
-      deps.clients.forEach(client => {
-        try {
-          client.write(`event: resume_resolved\ndata: ${resolvedData}\n\n`);
-        } catch { }
-      });
-      // 流式分段广播 full_reload，避免全量加载 OOM
-      const reloadTotal = await countLogEntries(LOG_FILE);
-      deps.clients.forEach(client => {
-        try { client.write(`event: load_start\ndata: ${JSON.stringify({ total: reloadTotal, incremental: false })}\n\n`); } catch { }
-      });
-      await streamRawEntriesAsync(LOG_FILE, (raw) => {
-        deps.clients.forEach(client => {
-          try { client.write('event: load_chunk\ndata: ['); client.write(raw.replace(/\n/g, '')); client.write(']\n\n'); } catch { }
-        });
-      });
-      deps.clients.forEach(client => {
-        try { client.write(`event: load_end\ndata: {}\n\n`); } catch { }
-      });
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ ok: true, logFile: result.logFile }));
-    } catch {
-      res.writeHead(400, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'Invalid request body' }));
-    }
-  });
-}
-
 // SSE endpoint
 // 构造「有新版」徽标的 SSE 帧（pending = {version, source}）。pending 为空返回 null。
 // 抽成纯函数便于单测帧格式；events() 在新连接上调用它补推，使版本徽标跨刷新持续显示。
@@ -157,16 +87,22 @@ async function events(req, res, parsedUrl, isLocal, deps) {
     console.warn(`[server_config] SSE write failed (turnEndDebounceMs=${deps.turnEndDebounceMs}):`, err && err.message);
   }
 
-  // 如果有待决的 resume 选择，发送 resume_prompt 事件
-  if (_resumeState) {
-    res.write(`event: resume_prompt\ndata: ${JSON.stringify({ recentFileName: _resumeState.recentFileName })}\n\n`);
-  }
-
   // 补推「有新版」徽标：复用启动检查缓存的结果，让刷新/新标签页连上即恢复徽标。
   // 置于 deps.clients.push(res) 之前 → 新客户端仅得一份，不与一次性广播竞态。
   const updFrame = sseUpdateBadgeFrame(deps.pendingMajorUpdate);
   if (updFrame) res.write(updFrame);
 
+  // 1.7.0 迁移引导（P2）：当前项目仍有未转换的 v1 日志 → 连接即推 migrate_prompt。
+  // 是否弹窗由客户端决定（「不再提醒」偏好在客户端；continued=true 时无视 dismissed
+  // 再提醒一次——`-c` 续接的对话前半段在旧格式里，不迁移就看不到）。工作区切换后的
+  // 提示由 workspaces launch 路由对存量连接广播（本帧只覆盖新连接）。
+  try {
+    const mig = migrationStatus(LOG_DIR, _projectName || '');
+    if (mig.pending) {
+      res.write(`event: migrate_prompt\ndata: ${JSON.stringify({ ...mig, continued: isContinuedLaunch() })}\n\n`);
+    }
+  } catch (e) { reportSwallowed('sse.migrate_prompt', e); }
+
   // 增量加载参数：移动端带 since/cc/project 请求增量数据
   const sinceParam = parsedUrl.searchParams.get('since');
   const ccParam = parseInt(parsedUrl.searchParams.get('cc'), 10) || 0;
@@ -202,10 +138,15 @@ async function events(req, res, parsedUrl, isLocal, deps) {
   // ring=3 的容错意义：团队会话末尾常有连续 teammate 伪 mainAgent 条目，单记忆位会被
   // 挤掉真实 mainAgent；子串预过滤的理论误伤（键/值恰为 "teammate" 的真实条目）也由
   // 环内更早候选兜底。
+  // KEEP IN SYNC: server/lib/v2/adapter.js MAINAGENT_RING_DEPTH — on the v2 path
+  // the adapter's mainAgentRing (that depth) wholesale REPLACES this ring, so a
+  // mismatch would silently give v1 and v2 sessions different candidate depths.
   const MAINAGENT_SCAN_RING = 3;
   const mainAgentRawRing = [];
 
-  await streamRawEntriesAsync(LOG_FILE, async (raw) => {
+  // S6b: the cold-load source is the current v2 session dir when the v2
+  // writer is active (adapter stream), else the v1 file.
+  const coldLoadResult = await streamRawEntriesAsync(getLiveLogSource(), async (raw) => {
     // 直接发送原始 JSON 字符串，不做 parse/reconstruct/stringify
     // ExitPlanMode V2 空 input 的条目按需补全 plan / planFilePath，其它原样透传
     if (res.destroyed || !res.writable) return;
@@ -255,6 +196,14 @@ async function events(req, res, parsedUrl, isLocal, deps) {
 
   res.write(`event: load_end\ndata: {}\n\n`);
 
+  // S10a: v2 sources no longer invoke onScan (the two-pass window never
+  // stringifies out-of-window entries) — the adapter returns the newest-main
+  // raws as `mainAgentRing` instead. v1 sources still fill the ring via onScan.
+  if (Array.isArray(coldLoadResult?.mainAgentRing) && coldLoadResult.mainAgentRing.length > 0) {
+    mainAgentRawRing.length = 0;
+    mainAgentRawRing.push(...coldLoadResult.mainAgentRing);
+  }
+
   // Pass 1 入环的候选 newest-first 校验 + parse（≤K 次）。kv_cache 与 context_window
   // 各自取"最新一条能提供该值的真实 mainAgent"—— 与旧版逐条覆盖语义等价（环深度内）。
   for (let ri = mainAgentRawRing.length - 1; ri >= 0 && (!latestKvCache || !latestContextWindow); ri--) {
@@ -328,7 +277,7 @@ async function requests(req, res) {
   res.writeHead(200, { 'Content-Type': 'application/json' });
   res.write('[');
   let first = true;
-  await streamRawEntriesAsync(LOG_FILE, (raw) => {
+  await streamRawEntriesAsync(getLiveLogSource(), (raw) => {
     if (!first) res.write(',');
     res.write(enrichRawIfNeeded(raw));
     first = false;
@@ -337,57 +286,8 @@ async function requests(req, res) {
   res.end();
 }
 
-// 分页历史条目端点：移动端"加载更多"按需拉取
-// 支持可选 ?file= 参数指定目标文件（用于本地日志分页），默认使用活跃会话文件
-async function entriesPage(req, res, parsedUrl) {
-  const before = parsedUrl.searchParams.get('before');
-  const limitVal = Math.min(parseInt(parsedUrl.searchParams.get('limit'), 10) || 100, 500);
-  if (!before || isNaN(new Date(before).getTime())) {
-    res.writeHead(400, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ error: 'missing or invalid "before" parameter' }));
-    return;
-  }
-  const file = parsedUrl.searchParams.get('file');
-  let targetFile = LOG_FILE;
-  if (file) {
-    if (file.includes('..') || (!file.endsWith('.jsonl') && !file.endsWith('.jsonl.zip'))) {
-      res.writeHead(400, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'Invalid file name' }));
-      return;
-    }
-    try { validateLogPath(LOG_DIR, file); } catch (e) {
-      const status = e.code === 'NOT_FOUND' ? 404 : e.code === 'ACCESS_DENIED' ? 403 : 400;
-      res.writeHead(status, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: e.message }));
-      return;
-    }
-    targetFile = join(LOG_DIR, file);
-  }
-  try {
-    const result = await readPagedEntries(targetFile, { before, limit: limitVal });
-    // entries 是原始 JSON 字符串数组，parse 后返回给客户端
-    // ExitPlanMode V2 空 input 的条目用 enrichRawIfNeeded 在 raw 阶段补全
-    const entries = result.entries.map(raw => {
-      try { return JSON.parse(enrichRawIfNeeded(raw)); } catch { return null; }
-    }).filter(Boolean);
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({
-      entries,
-      hasMore: result.hasMore,
-      oldestTimestamp: result.oldestTimestamp,
-      count: entries.length,
-    }));
-  } catch (err) {
-    res.writeHead(500, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ error: err.message }));
-  }
-}
-
 export const eventsRoutes = [
   { method: 'POST', match: 'exact', path: '/api/turn-end-notify', handler: turnEndNotify },
-  { method: 'POST', match: 'exact', path: '/api/register-log', handler: registerLog },
-  { method: 'POST', match: 'exact', path: '/api/resume-choice', handler: resumeChoice },
   { method: 'GET', match: 'exact', path: '/events', handler: events },
   { method: 'GET', match: 'exact', path: '/api/requests', handler: requests },
-  { method: 'GET', match: 'exact', path: '/api/entries/page', handler: entriesPage },
 ];

package/server/routes/files-fs.js

@@ -8,7 +8,7 @@ import { homedir, tmpdir } from 'node:os';
 import { execFile, spawn } from 'node:child_process';
 import { bumpWorkspacesVersion } from '../lib/file-access-policy.js';
 import { validateImportDir } from '../lib/file-api.js';
-import { LOG_FILE, PROFILE_PATH, _projectName } from '../interceptor.js';
+import { PROFILE_PATH, _projectName, _logDir } from '../interceptor.js';
 import { LOG_DIR, getClaudeConfigDir } from '../../findcc.js';
 
 function upload(req, res, parsedUrl, isLocal, deps) {
@@ -844,7 +844,9 @@ function createDir(req, res, parsedUrl, isLocal, deps) {
 }
 
 function openLogDir(req, res) {
-  const dir = LOG_FILE ? dirname(LOG_FILE) : LOG_DIR;
+  // Project dir works for both formats (legacy v1 files and the v2 sessions/
+  // tree are siblings under it); LOG_DIR is the pre-workspace fallback.
+  const dir = _logDir || LOG_DIR;
   const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'explorer' : 'xdg-open';
   execFile(cmd, [dir], { windowsHide: true }, () => {});
   res.writeHead(200, { 'Content-Type': 'application/json' });

package/server/routes/im.js

@@ -21,6 +21,7 @@
 // reports its own in-process adapter (deps.im.getBridgeStatus) — that's what the manager probes.
 import { getDescriptor, loadConfig, loadState, saveConfig } from '../lib/im-config.js';
 import { findRecentLog } from '../lib/interceptor-core.js';
+import { listV2Sessions } from '../lib/v2/adapter.js';
 import { readSenders } from '../lib/im-senders.js';
 import { readImAppendSystem, writeImAppendSystem, buildImAppendSystemPreset, MAX_IM_APPEND_SYSTEM_CHARS } from '../lib/im-append-system.js';
 import { imDir } from '../lib/im-lock.js';
@@ -256,8 +257,16 @@ function imLogs(req, res, parsedUrl, isLocal, deps) {
   const project = `IM_${id}`;
   let latest = null;
   try {
-    const abs = findRecentLog(join(LOG_DIR, project), project); // 已排除 *_temp.jsonl
-    if (abs) latest = `${project}/${basename(abs)}`; // 相对 LOG_DIR，直接喂给 /api/local-log?file=
+    // wire-v2: prefer the newest v2 session (by meta.startTs, journal mtime as
+    // tie-break); fall back to legacy v1 files until they are migrated.
+    const sessions = listV2Sessions(join(LOG_DIR, project)).filter((s) => !s.leader);
+    if (sessions.length > 0) {
+      sessions.sort((a, b) => (a.startTs < b.startTs ? 1 : a.startTs > b.startTs ? -1 : 0));
+      latest = `v2:${project}/${sessions[0].sid}`; // 直接喂给 /api/local-log?file=
+    } else {
+      const abs = findRecentLog(join(LOG_DIR, project), project); // 已排除 *_temp.jsonl
+      if (abs) latest = `${project}/${basename(abs)}`; // 相对 LOG_DIR
+    }
   } catch { /* 无目录/无日志 → latest=null */ }
   res.writeHead(200, JSON_HEADERS);
   res.end(JSON.stringify({ project, latest }));