@tonyclaw/agent-inspector 4.0.1 → 4.0.3

package/src/proxy/store.ts

@@ -1,1773 +0,0 @@
-import {
-  existsSync,
-  createReadStream,
-  createWriteStream,
-  readdirSync,
-  statSync,
-  type WriteStream,
-} from "node:fs";
-import { open, unlink, rename } from "node:fs/promises";
-import { readdir as readdirCallback } from "node:fs/promises";
-import { createInterface } from "node:readline";
-import { Buffer } from "node:buffer";
-import { dirname, join } from "node:path";
-import {
-  appendLogEntry,
-  resolveLogDir,
-  logger,
-  runWithFlushedLogWriteLock,
-  runWithLogWriteLock,
-} from "./logger";
-import { getChunksDir } from "./chunkStorage";
-import {
-  addToIndex,
-  createLogIndexEntryMetadata,
-  findInIndex,
-  flushIndex,
-  getNextLogId,
-  getCurrentLogFile,
-  listFilteredIndexEntries,
-  listIndexEntries,
-  rebuildIndex,
-  updateLogIndexEntryMetadata,
-  type LogIndexEntry,
-  type LogIndexSummary,
-} from "./logIndex";
-import { writeChunks } from "./chunkStorage";
-import { closeSqliteLogIndex, listSqliteLogCursorEntries } from "./sqliteLogIndex";
-import type { SessionInfo, SessionLogSummary } from "../lib/sessionInfoContract";
-import { extractToolTraceEvents } from "../lib/toolTrace";
-import { extractStopReason } from "../lib/stopReason";
-import { textByteLength } from "../lib/unknown";
-import { buildSessionInfo, buildSessionLogSummary } from "./sessionInfo";
-import type { CapturedLog } from "./schemas";
-import { CapturedLogSchema } from "./schemas";
-import { apiFormatForPath } from "./formats/registry";
-import type { ImportedLogDraft } from "./logImporter";
-import {
-  archiveSessionLogs,
-  clearSessionArchives,
-  deleteArchivedLogsByIds,
-  findArchivedLogById,
-  getSessionArchiveRoot,
-  listArchivedSessionLogs,
-  listArchivedSessionIds,
-} from "./sessionArchive";
-import {
-  ensurePrivateDirectorySync,
-  PRIVATE_FILE_MODE,
-  securePrivateFileSync,
-} from "./privateDataPath";
-import { recoverCapturedLogStorage } from "./jsonlRecovery";
-import {
-  clearSessionRegistry,
-  getLogSessionId,
-  getSessionSnapshots,
-  getSessionIds,
-  markSessionFinished,
-  markSessionStarted,
-  observeSessionLog,
-  rebuildSessionRegistry,
-  resolveSessionIdentity,
-  type SessionClientInfo,
-  type SessionSnapshot,
-} from "./sessionSupervisor";
-import { installStorageLifecycleMaintenance, runStorageLifecycleGc } from "./storageLifecycle";
-
-export type { CapturedLog };
-export { getNextLogId };
-export { getLogSessionId, getSessionSnapshots } from "./sessionSupervisor";
-
-const MAX_MEMORY_CACHE = 100;
-
-export type LogStorageStats = {
-  memoryCount: number;
-  logDir: string;
-  logFileCount: number;
-  logBytes: number;
-  chunkDir: string;
-  chunkFileCount: number;
-  chunkBytes: number;
-  sessionArchiveDir: string;
-  sessionArchiveFileCount: number;
-  sessionArchiveBytes: number;
-};
-
-export type ClearPersistedLogStorageResult = {
-  cleared: number;
-  logFilesDeleted: number;
-  chunkFilesDeleted: number;
-  sessionArchiveFilesDeleted: number;
-};
-
-export type ClearPersistedLogsByIdsResult = {
-  cleared: number;
-  logFilesRewritten: number;
-  chunkFilesDeleted: number;
-  sessionArchiveLogsDeleted: number;
-};
-
-export type ListLogsPageOptions = {
-  sessionId?: string;
-  model?: string;
-  clientPid?: number;
-  offset: number;
-  limit: number;
-  includeBodies?: boolean;
-};
-
-export type ListLogsPageResult = {
-  logs: CapturedLog[];
-  total: number;
-  offset: number;
-  limit: number;
-};
-
-export type ListLogsCursorPageOptions = {
-  sessionId?: string;
-  model?: string;
-  clientPid?: number;
-  limit: number;
-  includeBodies?: boolean;
-  beforeLogId?: number;
-  afterLogId?: number;
-  anchor?: "newest" | "oldest";
-};
-
-export type ListLogsCursorPageResult = {
-  logs: CapturedLog[];
-  total: number;
-  limit: number;
-  hasOlder: boolean;
-  hasNewer: boolean;
-  oldestLogId: number | null;
-  newestLogId: number | null;
-};
-
-export type GetSessionInfoOptions = {
-  baseUrl: string;
-  includeHistory?: boolean;
-  latestLogLimit?: number;
-};
-
-// Memory cache: id -> CapturedLog (recent logs only, FIFO eviction)
-const memoryCache: Map<number, CapturedLog> = new Map();
-const MAX_CURSOR_PAGE_INDEXES = 16;
-
-type LogCursorPageIndex = {
-  key: string;
-  sessionId?: string;
-  model?: string;
-  clientPid?: number;
-  ids: number[];
-  logsById: Map<number, CapturedLog>;
-  entriesById: Map<number, LogIndexEntry>;
-};
-
-const logCursorPageIndexes: Map<string, LogCursorPageIndex> = new Map();
-let logCursorPageIndexBuildCount = 0;
-let sessionArchiveQueue: Promise<void> = Promise.resolve();
-const SESSION_ARCHIVE_BATCH_SIZE = 128;
-const SESSION_ARCHIVE_FLUSH_DELAY_MS = 10;
-let sessionArchiveBuffer: CapturedLog[] = [];
-let sessionArchiveFlushTimeout: ReturnType<typeof setTimeout> | null = null;
-
-function drainSessionArchiveBuffer(): CapturedLog[] {
-  const logs = sessionArchiveBuffer;
-  sessionArchiveBuffer = [];
-  return logs;
-}
-
-function queueSessionArchiveFlush(): void {
-  const logs = drainSessionArchiveBuffer();
-  if (logs.length === 0) return;
-  sessionArchiveQueue = sessionArchiveQueue
-    .catch(() => undefined)
-    .then(async () => {
-      await archiveSessionLogs(logs);
-    })
-    .catch((err: unknown) => {
-      logger.warn("[store] Failed to archive session logs:", String(err));
-    });
-}
-
-function cancelSessionArchiveFlushTimer(): void {
-  if (sessionArchiveFlushTimeout === null) return;
-  clearTimeout(sessionArchiveFlushTimeout);
-  sessionArchiveFlushTimeout = null;
-}
-
-function scheduleSessionArchiveFlush(): void {
-  if (sessionArchiveFlushTimeout !== null) return;
-  sessionArchiveFlushTimeout = setTimeout(() => {
-    sessionArchiveFlushTimeout = null;
-    queueSessionArchiveFlush();
-  }, SESSION_ARCHIVE_FLUSH_DELAY_MS);
-}
-
-function cursorPageIndexKey(
-  options: Pick<ListLogsCursorPageOptions, "sessionId" | "model" | "clientPid">,
-): string {
-  return JSON.stringify({
-    sessionId: options.sessionId ?? null,
-    model: options.model ?? null,
-    clientPid: options.clientPid ?? null,
-  });
-}
-
-function matchesCursorIndexFilters(log: CapturedLog, index: LogCursorPageIndex): boolean {
-  if (index.sessionId !== undefined && getLogSessionId(log) !== index.sessionId) return false;
-  if (index.model !== undefined && log.model !== index.model) return false;
-  if (index.clientPid !== undefined && log.clientPid !== index.clientPid) return false;
-  return true;
-}
-
-function insertSortedLogId(ids: number[], id: number): void {
-  if (ids.includes(id)) return;
-  const insertionIndex = ids.findIndex((candidate) => candidate > id);
-  if (insertionIndex === -1) {
-    ids.push(id);
-    return;
-  }
-  ids.splice(insertionIndex, 0, id);
-}
-
-function upsertLogCursorPageIndexes(log: CapturedLog): void {
-  for (const index of logCursorPageIndexes.values()) {
-    if (!matchesCursorIndexFilters(log, index)) {
-      if (index.logsById.delete(log.id)) {
-        index.ids = index.ids.filter((id) => id !== log.id);
-      }
-      index.entriesById.delete(log.id);
-      continue;
-    }
-    index.logsById.set(log.id, log);
-    insertSortedLogId(index.ids, log.id);
-  }
-}
-
-function removeLogsFromCursorPageIndexes(ids: ReadonlySet<number>): void {
-  if (ids.size === 0) return;
-  for (const index of logCursorPageIndexes.values()) {
-    for (const id of ids) {
-      index.logsById.delete(id);
-      index.entriesById.delete(id);
-    }
-    index.ids = index.ids.filter((id) => !ids.has(id));
-  }
-}
-
-function clearLogCursorPageIndexes(): void {
-  logCursorPageIndexes.clear();
-  logCursorPageIndexBuildCount = 0;
-}
-
-function evictOldestIfNeeded(): void {
-  while (memoryCache.size > MAX_MEMORY_CACHE) {
-    // Map preserves insertion order; first key = oldest
-    const oldestKey = memoryCache.keys().next().value;
-    if (oldestKey === undefined) break;
-    memoryCache.delete(oldestKey);
-  }
-}
-
-function normalizeLog(log: CapturedLog): CapturedLog {
-  const sessionId = getLogSessionId(log);
-  const pathFormat = apiFormatForPath(log.path);
-  const apiFormat = pathFormat === "unknown" ? log.apiFormat : pathFormat;
-  const captureIncomplete = log.captureIncomplete ?? false;
-  const droppedChunks = log.droppedChunks ?? 0;
-  const droppedBytes = log.droppedBytes ?? 0;
-  const captureIncompleteReason = log.captureIncompleteReason ?? null;
-  const stopReason = log.stopReason ?? extractStopReason(log);
-  if (
-    sessionId === log.sessionId &&
-    apiFormat === log.apiFormat &&
-    log.captureIncomplete !== undefined &&
-    log.droppedChunks !== undefined &&
-    log.droppedBytes !== undefined &&
-    log.captureIncompleteReason !== undefined &&
-    log.stopReason !== undefined
-  ) {
-    return log;
-  }
-  return {
-    ...log,
-    sessionId,
-    apiFormat,
-    captureIncomplete,
-    droppedChunks,
-    droppedBytes,
-    captureIncompleteReason,
-    stopReason,
-  };
-}
-
-function addToCache(log: CapturedLog): void {
-  const cachedLog = normalizeLog(log);
-  // If updating an existing entry, remove first to reset insertion order
-  if (memoryCache.has(cachedLog.id)) {
-    memoryCache.delete(cachedLog.id);
-  }
-  memoryCache.set(cachedLog.id, cachedLog);
-  upsertLogCursorPageIndexes(cachedLog);
-  evictOldestIfNeeded();
-}
-
-function archiveLogSnapshot(log: CapturedLog): void {
-  sessionArchiveBuffer.push(normalizeLog(log));
-  if (sessionArchiveBuffer.length >= SESSION_ARCHIVE_BATCH_SIZE) {
-    cancelSessionArchiveFlushTimer();
-    queueSessionArchiveFlush();
-  } else if (sessionArchiveBuffer.length === 1) {
-    scheduleSessionArchiveFlush();
-  }
-}
-
-export async function flushSessionArchiveWrites(): Promise<void> {
-  cancelSessionArchiveFlushTimer();
-  if (sessionArchiveBuffer.length > 0) queueSessionArchiveFlush();
-  await sessionArchiveQueue;
-  if (sessionArchiveBuffer.length > 0) await flushSessionArchiveWrites();
-}
-
-function removeFromCache(id: number): void {
-  memoryCache.delete(id);
-  removeLogsFromCursorPageIndexes(new Set([id]));
-}
-
-export function compactLogForList(log: CapturedLog): CapturedLog {
-  return {
-    ...log,
-    rawRequestBody: null,
-    responseText: null,
-    rawHeaders: undefined,
-    headers: undefined,
-    streamingChunks: undefined,
-    stopReason: log.stopReason ?? extractStopReason(log),
-    toolTraceEvents: log.toolTraceEvents ?? extractToolTraceEvents(log),
-    rawRequestBodyBytes: log.rawRequestBodyBytes ?? textByteLength(log.rawRequestBody),
-    responseTextBytes: log.responseTextBytes ?? textByteLength(log.responseText),
-    bodyContentMode: "compact",
-  };
-}
-
-function compactLogFromIndexSummary(summary: LogIndexSummary): CapturedLog {
-  return normalizeLog({
-    id: summary.id,
-    timestamp: summary.timestamp,
-    method: summary.method,
-    path: summary.path,
-    model: summary.model,
-    sessionId: summary.sessionId,
-    rawRequestBody: null,
-    responseStatus: summary.responseStatus,
-    responseText: null,
-    inputTokens: summary.inputTokens,
-    outputTokens: summary.outputTokens,
-    cacheCreationInputTokens: summary.cacheCreationInputTokens,
-    cacheReadInputTokens: summary.cacheReadInputTokens,
-    elapsedMs: summary.elapsedMs,
-    firstChunkMs: summary.firstChunkMs,
-    totalStreamMs: summary.totalStreamMs,
-    tokensPerSecond: summary.tokensPerSecond,
-    streaming: summary.streaming,
-    userAgent: summary.userAgent,
-    origin: summary.origin,
-    apiFormat: summary.apiFormat,
-    isTest: summary.isTest,
-    replayOfLogId: summary.replayOfLogId,
-    providerName: summary.providerName,
-    clientPort: summary.clientPort,
-    clientPid: summary.clientPid,
-    clientCwd: summary.clientCwd,
-    clientProjectFolder: summary.clientProjectFolder,
-    streamingChunksPath: summary.streamingChunksPath,
-    rawRequestBodyBytes: summary.rawRequestBodyBytes,
-    responseTextBytes: summary.responseTextBytes,
-    bodyContentMode: "compact",
-    captureIncomplete: summary.captureIncomplete,
-    droppedChunks: summary.droppedChunks,
-    droppedBytes: summary.droppedBytes,
-    captureIncompleteReason: summary.captureIncompleteReason,
-    warnings: summary.warnings,
-    stopReason: summary.stopReason,
-    toolTraceEvents: summary.toolTraceEvents,
-    error: summary.error,
-  });
-}
-
-function prepareLogForList(log: CapturedLog, includeBodies: boolean): CapturedLog {
-  return includeBodies ? log : compactLogForList(log);
-}
-
-/**
- * Add a test log entry to the in-memory store and persistent log file.
- * This is used by the provider test endpoint to seed provider-test sessions.
- */
-export async function addTestLogEntry(entry: Omit<CapturedLog, "id">): Promise<CapturedLog> {
-  const id = await getNextLogId();
-
-  // Persist streaming chunks to disk if present
-  let streamingChunksPath: string | null = null;
-  if (entry.streamingChunks !== undefined && entry.streamingChunks.chunks.length > 0) {
-    streamingChunksPath = writeChunks(
-      id,
-      entry.streamingChunks.chunks,
-      entry.streamingChunks.truncated,
-    );
-  }
-
-  const session = resolveSessionIdentity({
-    explicitSessionId: entry.sessionId,
-    isTest: entry.isTest,
-  });
-
-  const log: CapturedLog = normalizeLog({
-    id,
-    ...entry,
-    sessionId: session.id,
-    streamingChunksPath,
-  });
-
-  await runWithLogWriteLock(async () => {
-    const logFile = getCurrentLogFile();
-    appendLogEntry(log);
-    await addToIndex(id, logFile, -1, -1, createLogIndexEntryMetadata(log));
-  });
-
-  addToCache(log);
-  archiveLogSnapshot(log);
-  observeSessionLog(log, session.source);
-  emitLogUpdate(log);
-  return log;
-}
-
-export async function importCapturedLogs(
-  entries: readonly ImportedLogDraft[],
-  sessionId: string,
-): Promise<CapturedLog[]> {
-  const imported: CapturedLog[] = [];
-  for (const entry of entries) {
-    const log = await addTestLogEntry({
-      ...entry,
-      sessionId,
-      isTest: false,
-      replayOfLogId: null,
-    });
-    imported.push(log);
-  }
-  return imported;
-}
-
-type ClientInfo = SessionClientInfo;
-
-export async function createLog(
-  method: string,
-  path: string,
-  requestBody: string | null,
-  headers: Headers,
-  clientInfo?: ClientInfo,
-  rawHeaders?: Record<string, string>,
-  upstreamHeaders?: Record<string, string>,
-  apiFormat: "anthropic" | "openai" | "unknown" = "unknown",
-  model: string | null = null,
-  sessionId: string | null = null,
-  /** Pre-acquired log id; if omitted, `getNextLogId` is awaited internally. */
-  preAcquiredId?: number,
-): Promise<CapturedLog> {
-  const userAgent = headers.get("user-agent");
-  const origin = headers.get("origin");
-
-  const id = preAcquiredId ?? (await getNextLogId());
-  const session = resolveSessionIdentity({
-    explicitSessionId: sessionId,
-    clientInfo,
-  });
-
-  const log: CapturedLog = normalizeLog({
-    id,
-    timestamp: new Date().toISOString(),
-    method,
-    path,
-    model,
-    sessionId: session.id,
-    rawRequestBody: requestBody,
-    responseStatus: null,
-    responseText: null,
-    inputTokens: null,
-    outputTokens: null,
-    cacheCreationInputTokens: null,
-    cacheReadInputTokens: null,
-    elapsedMs: null,
-    firstChunkMs: null,
-    totalStreamMs: null,
-    tokensPerSecond: null,
-    streaming: false,
-    userAgent,
-    origin,
-    rawHeaders: rawHeaders,
-    headers: upstreamHeaders,
-    apiFormat,
-    isTest: false,
-    providerName: null,
-    clientPort: clientInfo?.port ?? null,
-    clientPid: clientInfo?.pid ?? null,
-    clientCwd: clientInfo?.cwd ?? null,
-    clientProjectFolder: clientInfo?.projectFolder ?? null,
-    streamingChunksPath: null,
-    captureIncomplete: false,
-    droppedChunks: 0,
-    droppedBytes: 0,
-    captureIncompleteReason: null,
-  });
-
-  // Write to disk and update index
-  await runWithLogWriteLock(async () => {
-    const logFile = getCurrentLogFile();
-    appendLogEntry(log);
-    await addToIndex(id, logFile, -1, -1, createLogIndexEntryMetadata(log));
-  });
-
-  // Add to memory cache
-  addToCache(log);
-  archiveLogSnapshot(log);
-  markSessionStarted(log, session.source);
-  emitLogUpdate(log);
-
-  return log;
-}
-
-export function finalizeLogUpdate(log: CapturedLog): void {
-  addToCache(log);
-  archiveLogSnapshot(log);
-  markSessionFinished(log);
-  emitLogUpdate(log);
-}
-
-/** Persist the terminal cache/session state and refresh both JSON and SQLite index summaries. */
-export async function persistFinalizedLogUpdate(log: CapturedLog): Promise<void> {
-  finalizeLogUpdate(log);
-  await updateLogIndexEntryMetadata(log);
-}
-
-async function getArchivedLogByIdForStore(id: number): Promise<CapturedLog | null> {
-  await flushSessionArchiveWrites();
-  const archivedLog = await findArchivedLogById(id);
-  if (archivedLog === null) return null;
-  const normalized = normalizeLog(archivedLog);
-  addToCache(normalized);
-  observeSessionLog(normalized);
-  return normalized;
-}
-
-/**
- * Get a log by ID, checking memory cache first then disk.
- * Uses byte-offset index for efficient single-line reads.
- */
-export async function getLogById(id: number): Promise<CapturedLog | null> {
-  // Check memory cache first
-  const cached = memoryCache.get(id);
-  if (cached !== undefined) {
-    return cached;
-  }
-
-  // Look up in index and load from disk
-  const entry = await findInIndex(id);
-  if (entry === null) {
-    return await getArchivedLogByIdForStore(id);
-  }
-
-  // Load from disk using byte-offset index
-  try {
-    const filePath = join(resolveLogDir(), entry.file);
-    if (!existsSync(filePath)) {
-      return await getArchivedLogByIdForStore(id);
-    }
-
-    // Use byte offset for direct read when available
-    if (entry.byteOffset >= 0 && entry.byteLength > 0) {
-      const fh = await open(filePath, "r");
-      try {
-        const buffer = Buffer.alloc(entry.byteLength);
-        const { bytesRead } = await fh.read(buffer, 0, entry.byteLength, entry.byteOffset);
-        if (bytesRead === 0) return null;
-        const line = buffer.toString("utf-8", 0, bytesRead).trimEnd();
-        if (line === "") return null;
-        const parsed: unknown = JSON.parse(line);
-        const result = CapturedLogSchema.safeParse(parsed);
-        if (result.success) {
-          const log = normalizeLog(result.data);
-          addToCache(log);
-          observeSessionLog(log);
-          return log;
-        }
-      } finally {
-        await fh.close();
-      }
-      return null;
-    }
-
-    const lastMatch = await scanLogFileForId(filePath, id);
-    if (lastMatch !== null) {
-      addToCache(lastMatch);
-      observeSessionLog(lastMatch);
-      return lastMatch;
-    }
-  } catch (err) {
-    logger.error("[store] Failed to read log from disk:", String(err));
-  }
-
-  return await getArchivedLogByIdForStore(id);
-}
-
-async function scanLogFileForId(filePath: string, id: number): Promise<CapturedLog | null> {
-  let lastMatch: CapturedLog | null = null;
-  const fileStream = createInterface({
-    input: createReadStream(filePath),
-    crlfDelay: Infinity,
-  });
-
-  let lineNumber = 0;
-  for await (const line of fileStream) {
-    lineNumber += 1;
-    if (line.trim() === "") continue;
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(line);
-    } catch (error) {
-      return await Promise.reject(
-        new Error(
-          `Malformed JSONL record in ${filePath} at line ${String(lineNumber)}: ${String(error)}`,
-        ),
-      );
-    }
-    const result = CapturedLogSchema.safeParse(parsed);
-    if (!result.success) {
-      return await Promise.reject(
-        new Error(`Invalid captured-log record in ${filePath} at line ${String(lineNumber)}`),
-      );
-    }
-    if (result.data.id === id) {
-      lastMatch = normalizeLog(result.data);
-      if (result.data.responseStatus !== null) {
-        return lastMatch;
-      }
-    }
-  }
-
-  return lastMatch;
-}
-
-export function getFilteredLogs(
-  sessionId?: string,
-  model?: string,
-  clientPid?: number,
-): CapturedLog[] {
-  // Cache maintains insertion order (sorted by ID since logs are added in ID order)
-  // Use spread instead of Array.from for slightly better performance
-  return [...memoryCache.values()].filter((l) => {
-    return matchesLogFilters(l, sessionId, model, clientPid);
-  });
-}
-
-function matchesLogFilters(
-  log: CapturedLog,
-  sessionId?: string,
-  model?: string,
-  clientPid?: number,
-): boolean {
-  if (sessionId !== undefined && getLogSessionId(log) !== sessionId) return false;
-  if (model !== undefined && log.model !== model) return false;
-  if (clientPid !== undefined && log.clientPid !== clientPid) return false;
-  return true;
-}
-
-type PersistedLogVisitor = (log: CapturedLog) => void;
-
-async function visitPersistedLogs(visitor: PersistedLogVisitor): Promise<void> {
-  const logDir = resolveLogDir();
-  if (!existsSync(logDir)) return;
-
-  const recovery = await recoverCapturedLogStorage(logDir);
-  if (recovery.level === "unavailable") {
-    return await Promise.reject(
-      new Error(recovery.diagnostic ?? "Captured-log recovery blocked persisted-log reads"),
-    );
-  }
-
-  try {
-    const entries = await readdirCallback(logDir);
-    const files = entries.filter((file) => file.endsWith(".jsonl")).sort();
-    for (const file of files) {
-      await visitPersistedLogFile(join(logDir, file), visitor);
-    }
-  } catch (err) {
-    logger.error("[store] Failed to list persisted logs:", String(err));
-    return await Promise.reject(
-      err instanceof Error ? err : new Error(`Failed to list persisted logs: ${String(err)}`),
-    );
-  }
-}
-
-async function visitPersistedLogFile(
-  filePath: string,
-  visitor: PersistedLogVisitor,
-): Promise<void> {
-  if (!existsSync(filePath)) return;
-
-  try {
-    const fileStream = createInterface({
-      input: createReadStream(filePath),
-      crlfDelay: Infinity,
-    });
-
-    let lineNumber = 0;
-    for await (const line of fileStream) {
-      lineNumber += 1;
-      if (line.trim() === "") continue;
-      let parsed: unknown;
-      try {
-        parsed = JSON.parse(line);
-      } catch (error) {
-        return await Promise.reject(
-          new Error(
-            `Malformed JSONL record in ${filePath} at line ${String(lineNumber)}: ${String(error)}`,
-          ),
-        );
-      }
-      const result = CapturedLogSchema.safeParse(parsed);
-      if (!result.success) {
-        return await Promise.reject(
-          new Error(`Invalid captured-log record in ${filePath} at line ${String(lineNumber)}`),
-        );
-      }
-      const log = normalizeLog(result.data);
-      visitor(log);
-    }
-  } catch (err) {
-    logger.error("[store] Failed to read persisted log file:", filePath, String(err));
-    return await Promise.reject(
-      err instanceof Error
-        ? err
-        : new Error(`Failed to read persisted log file ${filePath}: ${String(err)}`),
-    );
-  }
-}
-
-async function visitArchivedSessionLogs(
-  sessionId: string | undefined,
-  visitor: PersistedLogVisitor,
-): Promise<void> {
-  if (sessionId === undefined) return;
-  await flushSessionArchiveWrites();
-  const logs = await listArchivedSessionLogs(sessionId);
-  for (const archivedLog of logs) {
-    const log = normalizeLog(archivedLog);
-    observeSessionLog(log);
-    visitor(log);
-  }
-}
-
-function canUseIndexedListPage(options: ListLogsPageOptions): boolean {
-  return (
-    options.sessionId === undefined &&
-    options.model === undefined &&
-    options.clientPid === undefined
-  );
-}
-
-function hasUsableIndexOffset(entry: LogIndexEntry): boolean {
-  return entry.byteOffset >= 0 && entry.byteLength > 0;
-}
-
-async function listLogsPageFromIndex(
-  options: ListLogsPageOptions,
-  allowRebuild: boolean,
-): Promise<ListLogsPageResult | null> {
-  if (!canUseIndexedListPage(options)) return null;
-
-  let entries = await listIndexEntries();
-  if (entries.length === 0 && allowRebuild) {
-    await rebuildIndex();
-    entries = await listIndexEntries();
-  }
-
-  const pageStart = options.offset;
-  const pageEnd = options.offset + options.limit;
-  const pageEntries = entries.slice(pageStart, pageEnd);
-  const hasIncompleteOffset = pageEntries.some((entry) => !hasUsableIndexOffset(entry));
-
-  if (hasIncompleteOffset) {
-    if (!allowRebuild) return null;
-    await rebuildIndex();
-    return await listLogsPageFromIndex(options, false);
-  }
-
-  const logs: CapturedLog[] = [];
-  const includeBodies = options.includeBodies !== false;
-  for (const entry of pageEntries) {
-    const log = await getLogById(entry.id);
-    if (log === null) return null;
-    logs.push(prepareLogForList(log, includeBodies));
-  }
-
-  return {
-    logs,
-    total: entries.length,
-    offset: options.offset,
-    limit: options.limit,
-  };
-}
-
-export async function listLogsPage(options: ListLogsPageOptions): Promise<ListLogsPageResult> {
-  const indexedPage = await listLogsPageFromIndex(options, true);
-  if (indexedPage !== null) return indexedPage;
-
-  const seenIds = new Set<number>();
-  const pageById = new Map<number, CapturedLog>();
-  const pageStart = options.offset;
-  const pageEnd = options.offset + options.limit;
-  const includeBodies = options.includeBodies !== false;
-  let total = 0;
-
-  const visitLog = (log: CapturedLog): void => {
-    if (!matchesLogFilters(log, options.sessionId, options.model, options.clientPid)) return;
-
-    if (!seenIds.has(log.id)) {
-      seenIds.add(log.id);
-      const position = total;
-      total += 1;
-      if (position >= pageStart && position < pageEnd) {
-        pageById.set(log.id, prepareLogForList(log, includeBodies));
-      }
-      return;
-    }
-
-    if (pageById.has(log.id)) {
-      pageById.set(log.id, prepareLogForList(log, includeBodies));
-    }
-  };
-
-  await visitPersistedLogs((log) => {
-    observeSessionLog(log);
-    visitLog(log);
-  });
-
-  await visitArchivedSessionLogs(options.sessionId, visitLog);
-
-  for (const log of memoryCache.values()) {
-    visitLog(log);
-  }
-
-  const logs = [...pageById.values()].sort((left, right) => left.id - right.id);
-
-  return {
-    logs,
-    total,
-    offset: options.offset,
-    limit: options.limit,
-  };
-}
-
-function lowerBoundLogId(ids: readonly number[], target: number): number {
-  let low = 0;
-  let high = ids.length;
-  while (low < high) {
-    const middle = Math.floor((low + high) / 2);
-    const id = ids[middle];
-    if (id === undefined || id >= target) {
-      high = middle;
-      continue;
-    }
-    low = middle + 1;
-  }
-  return low;
-}
-
-function upperBoundLogId(ids: readonly number[], target: number): number {
-  let low = 0;
-  let high = ids.length;
-  while (low < high) {
-    const middle = Math.floor((low + high) / 2);
-    const id = ids[middle];
-    if (id === undefined || id > target) {
-      high = middle;
-      continue;
-    }
-    low = middle + 1;
-  }
-  return low;
-}
-
-function selectCursorPageLogs(
-  ids: readonly number[],
-  options: ListLogsCursorPageOptions,
-): number[] {
-  const windowStart =
-    options.afterLogId === undefined ? 0 : upperBoundLogId(ids, options.afterLogId);
-  const windowEnd =
-    options.beforeLogId === undefined ? ids.length : lowerBoundLogId(ids, options.beforeLogId);
-  if (windowStart >= windowEnd) return [];
-
-  if (options.afterLogId !== undefined || options.anchor === "oldest") {
-    return ids.slice(windowStart, Math.min(windowEnd, windowStart + options.limit));
-  }
-  return ids.slice(Math.max(windowStart, windowEnd - options.limit), windowEnd);
-}
-
-function rememberLogCursorPageIndex(index: LogCursorPageIndex): LogCursorPageIndex {
-  if (logCursorPageIndexes.has(index.key)) {
-    logCursorPageIndexes.delete(index.key);
-  }
-  logCursorPageIndexes.set(index.key, index);
-  while (logCursorPageIndexes.size > MAX_CURSOR_PAGE_INDEXES) {
-    const oldestKey = logCursorPageIndexes.keys().next().value;
-    if (oldestKey === undefined) break;
-    logCursorPageIndexes.delete(oldestKey);
-  }
-  return index;
-}
-
-function hasNullableStringField(entry: LogIndexEntry, field: "sessionId" | "model"): boolean {
-  const desc = Object.getOwnPropertyDescriptor(entry, field);
-  if (desc === undefined) return false;
-  return typeof desc.value === "string" || desc.value === null;
-}
-
-function hasLogIndexFilterMetadata(entry: LogIndexEntry): boolean {
-  return hasNullableStringField(entry, "sessionId") && hasNullableStringField(entry, "model");
-}
-
-function hasLogIndexSummary(entry: LogIndexEntry): boolean {
-  return entry.summary !== undefined;
-}
-
-function matchesLogIndexEntryFilters(
-  entry: LogIndexEntry,
-  sessionId: string | undefined,
-  model: string | undefined,
-  clientPid: number | undefined,
-): boolean {
-  if (sessionId !== undefined && entry.sessionId !== sessionId) return false;
-  if (model !== undefined && entry.model !== model) return false;
-  if (clientPid !== undefined && entry.summary?.clientPid !== clientPid) return false;
-  return true;
-}
-
-async function buildLogCursorPageIndexFromLogIndex(
-  options: Pick<ListLogsCursorPageOptions, "sessionId" | "model" | "clientPid">,
-  allowRebuild: boolean,
-): Promise<LogCursorPageIndex | null> {
-  let entries = await listSqliteLogCursorEntries(options);
-  if (entries === null) {
-    if (options.clientPid !== undefined) return null;
-    entries = await listFilteredIndexEntries(options);
-  }
-  if (entries.length === 0 && allowRebuild) {
-    await rebuildIndex();
-    entries = await listSqliteLogCursorEntries(options);
-    if (entries === null) {
-      if (options.clientPid !== undefined) return null;
-      entries = await listFilteredIndexEntries(options);
-    }
-  }
-
-  if (entries.some((entry) => !hasLogIndexFilterMetadata(entry))) {
-    if (!allowRebuild) return null;
-    await rebuildIndex();
-    return await buildLogCursorPageIndexFromLogIndex(options, false);
-  }
-
-  const matchingEntries = entries.filter((entry) =>
-    matchesLogIndexEntryFilters(entry, options.sessionId, options.model, options.clientPid),
-  );
-
-  if (matchingEntries.some((entry) => !hasLogIndexSummary(entry))) {
-    if (!allowRebuild) return null;
-    await rebuildIndex();
-    return await buildLogCursorPageIndexFromLogIndex(options, false);
-  }
-
-  if (matchingEntries.some((entry) => !hasUsableIndexOffset(entry) && !memoryCache.has(entry.id))) {
-    if (!allowRebuild) return null;
-    await rebuildIndex();
-    return await buildLogCursorPageIndexFromLogIndex(options, false);
-  }
-
-  const idsById = new Set<number>();
-  const entriesById = new Map<number, LogIndexEntry>();
-  for (const entry of matchingEntries) {
-    idsById.add(entry.id);
-    entriesById.set(entry.id, entry);
-  }
-
-  const logsById = new Map<number, CapturedLog>();
-  for (const log of memoryCache.values()) {
-    if (!matchesLogFilters(log, options.sessionId, options.model, options.clientPid)) continue;
-    idsById.add(log.id);
-    logsById.set(log.id, log);
-  }
-
-  if (options.sessionId !== undefined) {
-    await flushSessionArchiveWrites();
-    const archivedLogs = await listArchivedSessionLogs(options.sessionId);
-    for (const archivedLog of archivedLogs) {
-      const log = normalizeLog(archivedLog);
-      if (!matchesLogFilters(log, options.sessionId, options.model, options.clientPid)) continue;
-      observeSessionLog(log);
-      idsById.add(log.id);
-      logsById.set(log.id, log);
-    }
-  }
-
-  return {
-    key: cursorPageIndexKey(options),
-    sessionId: options.sessionId,
-    model: options.model,
-    clientPid: options.clientPid,
-    ids: [...idsById].sort((left, right) => left - right),
-    logsById,
-    entriesById,
-  };
-}
-
-async function buildLogCursorPageIndex(
-  options: Pick<ListLogsCursorPageOptions, "sessionId" | "model" | "clientPid">,
-): Promise<LogCursorPageIndex> {
-  logCursorPageIndexBuildCount += 1;
-  const indexed = await buildLogCursorPageIndexFromLogIndex(options, true);
-  if (indexed !== null) return indexed;
-
-  const key = cursorPageIndexKey(options);
-  const logsById = new Map<number, CapturedLog>();
-
-  const visitLog = (log: CapturedLog): void => {
-    if (!matchesLogFilters(log, options.sessionId, options.model, options.clientPid)) return;
-    logsById.set(log.id, log);
-  };
-
-  await visitPersistedLogs((log) => {
-    observeSessionLog(log);
-    visitLog(log);
-  });
-
-  await visitArchivedSessionLogs(options.sessionId, visitLog);
-
-  for (const log of memoryCache.values()) {
-    visitLog(log);
-  }
-
-  return {
-    key,
-    sessionId: options.sessionId,
-    model: options.model,
-    clientPid: options.clientPid,
-    ids: [...logsById.keys()].sort((left, right) => left - right),
-    logsById,
-    entriesById: new Map<number, LogIndexEntry>(),
-  };
-}
-
-async function getLogCursorPageIndex(
-  options: Pick<ListLogsCursorPageOptions, "sessionId" | "model" | "clientPid">,
-): Promise<LogCursorPageIndex> {
-  const key = cursorPageIndexKey(options);
-  const cached = logCursorPageIndexes.get(key);
-  if (cached !== undefined) {
-    logCursorPageIndexes.delete(key);
-    logCursorPageIndexes.set(key, cached);
-    return cached;
-  }
-  return rememberLogCursorPageIndex(await buildLogCursorPageIndex(options));
-}
-
-async function hydrateCursorPageLogs(
-  index: LogCursorPageIndex,
-  pageIds: readonly number[],
-): Promise<CapturedLog[]> {
-  const logs: CapturedLog[] = [];
-  for (const id of pageIds) {
-    const cached = index.logsById.get(id);
-    if (cached !== undefined) {
-      logs.push(cached);
-      continue;
-    }
-
-    const log = await getLogById(id);
-    if (log === null) continue;
-    index.logsById.set(id, log);
-    logs.push(log);
-  }
-  return logs;
-}
-
-async function hydrateCompactCursorPageLogs(
-  index: LogCursorPageIndex,
-  pageIds: readonly number[],
-): Promise<CapturedLog[]> {
-  const logs: CapturedLog[] = [];
-  for (const id of pageIds) {
-    const cached = index.logsById.get(id);
-    if (cached !== undefined) {
-      logs.push(compactLogForList(cached));
-      continue;
-    }
-
-    const entry = index.entriesById.get(id);
-    if (entry !== undefined && entry.summary !== undefined) {
-      logs.push(compactLogFromIndexSummary(entry.summary));
-      continue;
-    }
-
-    const log = await getLogById(id);
-    if (log === null) continue;
-    index.logsById.set(id, log);
-    logs.push(compactLogForList(log));
-  }
-  return logs;
-}
-
-export async function listLogsCursorPage(
-  options: ListLogsCursorPageOptions,
-): Promise<ListLogsCursorPageResult> {
-  const includeBodies = options.includeBodies !== false;
-  const index = await getLogCursorPageIndex(options);
-  const pageIds = selectCursorPageLogs(index.ids, options);
-  const pageLogs = includeBodies
-    ? await hydrateCursorPageLogs(index, pageIds)
-    : await hydrateCompactCursorPageLogs(index, pageIds);
-  const oldestLogId = pageIds[0] ?? null;
-  const newestLogId = pageIds.at(-1) ?? null;
-  const oldestIndex = oldestLogId === null ? -1 : index.ids.indexOf(oldestLogId);
-  const newestIndex = newestLogId === null ? -1 : index.ids.indexOf(newestLogId);
-
-  return {
-    logs: pageLogs.map((log) => prepareLogForList(log, includeBodies)),
-    total: index.ids.length,
-    limit: options.limit,
-    hasOlder: oldestIndex > 0,
-    hasNewer: newestIndex >= 0 && newestIndex < index.ids.length - 1,
-    oldestLogId,
-    newestLogId,
-  };
-}
-
-function findSessionSnapshot(sessionId: string): SessionSnapshot | null {
-  for (const snapshot of getSessionSnapshots()) {
-    if (snapshot.id === sessionId) return snapshot;
-  }
-  return null;
-}
-
-async function collectSessionLogSummaries(
-  sessionId: string,
-  includeHistory: boolean,
-): Promise<SessionLogSummary[]> {
-  const summariesById = new Map<number, SessionLogSummary>();
-  const observeMatchingLog = (log: CapturedLog): void => {
-    if (!matchesLogFilters(log, sessionId, undefined)) return;
-    summariesById.set(log.id, buildSessionLogSummary(log));
-  };
-
-  const indexedSummaries = await collectIndexedSessionLogSummaries(sessionId);
-  for (const summary of indexedSummaries) {
-    summariesById.set(summary.id, summary);
-  }
-
-  await flushSessionArchiveWrites();
-  const archivedLogs = await listArchivedSessionLogs(sessionId);
-  for (const archivedLog of archivedLogs) {
-    const log = normalizeLog(archivedLog);
-    observeSessionLog(log);
-    if (!summariesById.has(log.id)) {
-      summariesById.set(log.id, buildSessionLogSummary(log));
-    }
-  }
-
-  if (includeHistory && summariesById.size === 0) {
-    await visitPersistedLogs((log) => {
-      observeSessionLog(log);
-      observeMatchingLog(log);
-    });
-  }
-
-  for (const log of memoryCache.values()) {
-    observeMatchingLog(log);
-  }
-
-  return [...summariesById.values()];
-}
-
-async function collectIndexedSessionLogSummaries(sessionId: string): Promise<SessionLogSummary[]> {
-  let entries = await listFilteredIndexEntries({ sessionId });
-  if (entries.length === 0) return [];
-
-  const needsMetadataRebuild = entries.some((entry) => !hasLogIndexFilterMetadata(entry));
-  const needsSummaryRebuild = entries.some((entry) => {
-    if (!matchesLogIndexEntryFilters(entry, sessionId, undefined, undefined)) return false;
-    return !hasLogIndexSummary(entry);
-  });
-
-  if (needsMetadataRebuild || needsSummaryRebuild) {
-    await rebuildIndex();
-    entries = await listFilteredIndexEntries({ sessionId });
-  }
-
-  const summaries: SessionLogSummary[] = [];
-  for (const entry of entries) {
-    if (!matchesLogIndexEntryFilters(entry, sessionId, undefined, undefined)) continue;
-    if (entry.summary === undefined) continue;
-    summaries.push(buildSessionLogSummary(compactLogFromIndexSummary(entry.summary)));
-  }
-  return summaries;
-}
-
-async function includeSnapshotLastLogSummary(
-  sessionId: string,
-  snapshot: SessionSnapshot | null,
-  summaries: SessionLogSummary[],
-): Promise<SessionLogSummary[]> {
-  if (snapshot === null || snapshot.lastLogId === null) return summaries;
-  for (const summary of summaries) {
-    if (summary.id === snapshot.lastLogId) return summaries;
-  }
-
-  const log = await getLogById(snapshot.lastLogId);
-  if (log === null || !matchesLogFilters(log, sessionId, undefined)) return summaries;
-  return [...summaries, buildSessionLogSummary(log)];
-}
-
-export async function getSessionInfo(
-  sessionId: string,
-  options: GetSessionInfoOptions,
-): Promise<SessionInfo | null> {
-  const includeHistory = options.includeHistory === true;
-  const collectedSummaries = await collectSessionLogSummaries(sessionId, includeHistory);
-  const snapshot = findSessionSnapshot(sessionId);
-  const summaries = includeHistory
-    ? collectedSummaries
-    : await includeSnapshotLastLogSummary(sessionId, snapshot, collectedSummaries);
-  if (snapshot === null && summaries.length === 0) return null;
-  return buildSessionInfo({
-    sessionId,
-    baseUrl: options.baseUrl,
-    snapshot,
-    summaries,
-    logCoverage: includeHistory ? "history" : "recent",
-    latestLogLimit: options.latestLogLimit,
-  });
-}
-
-export function getSessions(): string[] {
-  return getSessionIds();
-}
-
-export async function listSessions(): Promise<string[]> {
-  await flushSessionArchiveWrites();
-  const sessionIds = new Set<string>(getSessionIds());
-  for (const sessionId of await listArchivedSessionIds()) {
-    sessionIds.add(sessionId);
-  }
-  return [...sessionIds].sort();
-}
-
-export function getModels(): string[] {
-  const set = new Set<string>();
-  for (const l of memoryCache.values()) {
-    if (l.model !== null && l.model !== "") set.add(l.model);
-  }
-  return [...set];
-}
-
-export function getReplayLogsForSource(sourceLogId: number): CapturedLog[] {
-  return [...memoryCache.values()].filter((log) => log.replayOfLogId === sourceLogId);
-}
-
-function collectDirectoryStats(
-  dir: string,
-  shouldCount: (fileName: string) => boolean,
-): { fileCount: number; bytes: number } {
-  if (!existsSync(dir)) return { fileCount: 0, bytes: 0 };
-  let fileCount = 0;
-  let bytes = 0;
-  const visit = (currentDir: string, depth: number): void => {
-    if (depth > 8) return;
-    let entries: string[];
-    try {
-      entries = readdirSync(currentDir);
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const path = join(currentDir, entry);
-      try {
-        const stats = statSync(path);
-        if (stats.isDirectory()) {
-          visit(path, depth + 1);
-        } else if (shouldCount(entry)) {
-          fileCount += 1;
-          bytes += stats.size;
-        }
-      } catch {
-        // Ignore files that disappear while stats are being collected.
-      }
-    }
-  };
-  visit(dir, 0);
-  return { fileCount, bytes };
-}
-
-export function getLogStorageStats(): LogStorageStats {
-  const logDir = resolveLogDir();
-  const chunkDir = getChunksDir();
-  const sessionArchiveDir = getSessionArchiveRoot();
-  const logStats = collectDirectoryStats(logDir, (fileName) => fileName.endsWith(".jsonl"));
-  const chunkStats = collectDirectoryStats(chunkDir, (fileName) => fileName.endsWith(".json"));
-  const sessionArchiveStats = collectDirectoryStats(
-    sessionArchiveDir,
-    (fileName) => fileName === "session.sqlite" || fileName.startsWith("session.sqlite-"),
-  );
-  return {
-    memoryCount: memoryCache.size,
-    logDir,
-    logFileCount: logStats.fileCount,
-    logBytes: logStats.bytes,
-    chunkDir,
-    chunkFileCount: chunkStats.fileCount,
-    chunkBytes: chunkStats.bytes,
-    sessionArchiveDir,
-    sessionArchiveFileCount: sessionArchiveStats.fileCount,
-    sessionArchiveBytes: sessionArchiveStats.bytes,
-  };
-}
-
-/**
- * Load recent completed log entries from all log files into the memory cache.
- * Called on server startup so the frontend shows existing logs.
- *
- * Strategy: stream files forward, keep the LAST completed entry per ID,
- * then only retain the newest MAX_MEMORY_CACHE entries in cache.
- */
-export async function loadLogsIntoMemory(): Promise<void> {
-  try {
-    const gcResult = runStorageLifecycleGc();
-    if (gcResult.filesDeleted > 0 || gcResult.errors.length > 0) {
-      logger.info(
-        "[store] Storage lifecycle GC completed:",
-        `${gcResult.filesDeleted} files deleted, ${gcResult.bytesDeleted} bytes reclaimed,`,
-        `${gcResult.errors.length} errors`,
-      );
-    }
-  } catch (err) {
-    logger.warn("[store] Storage lifecycle GC failed:", String(err));
-  }
-  installStorageLifecycleMaintenance();
-
-  const logDir = resolveLogDir();
-  if (!existsSync(logDir)) return;
-
-  const recentCompletedById = new Map<number, CapturedLog>();
-  await visitPersistedLogs((log) => {
-    rememberRecentCompletedLog(log, recentCompletedById);
-  });
-
-  // Sort by id descending, keep only MAX_MEMORY_CACHE newest completed entries
-  const sorted = [...recentCompletedById.values()].sort((a, b) => b.id - a.id);
-  for (const entry of sorted) {
-    addToCache(entry);
-  }
-
-  rebuildSessionRegistry(memoryCache.values());
-  clearLogCursorPageIndexes();
-}
-
-function rememberRecentCompletedLog(
-  log: CapturedLog,
-  recentCompletedById: Map<number, CapturedLog>,
-): void {
-  if (log.responseStatus === null) return;
-  recentCompletedById.set(log.id, log);
-  while (recentCompletedById.size > MAX_MEMORY_CACHE) {
-    const oldestId = findSmallestLogId(recentCompletedById);
-    if (oldestId === null) return;
-    recentCompletedById.delete(oldestId);
-  }
-}
-
-function findSmallestLogId(logsById: ReadonlyMap<number, CapturedLog>): number | null {
-  let smallestId: number | null = null;
-  for (const id of logsById.keys()) {
-    if (smallestId === null || id < smallestId) {
-      smallestId = id;
-    }
-  }
-  return smallestId;
-}
-
-export function clearAllLogs(): { cleared: number } {
-  const count = memoryCache.size;
-  memoryCache.clear();
-  clearLogCursorPageIndexes();
-  clearSessionRegistry();
-  closeSqliteLogIndex();
-  return { cleared: count };
-}
-
-async function deleteMatchingFiles(
-  dir: string,
-  shouldDelete: (fileName: string) => boolean,
-): Promise<number> {
-  if (!existsSync(dir)) return 0;
-
-  let deleted = 0;
-  let entries: string[];
-  try {
-    entries = await readdirCallback(dir);
-  } catch (err) {
-    logger.warn("[store] Failed to list log storage directory:", String(err));
-    return deleted;
-  }
-
-  for (const entry of entries) {
-    if (!shouldDelete(entry)) continue;
-    try {
-      await unlink(join(dir, entry));
-      deleted += 1;
-    } catch (err) {
-      logger.warn("[store] Failed to delete log storage file:", entry, String(err));
-    }
-  }
-  return deleted;
-}
-
-export async function clearPersistedLogStorage(): Promise<ClearPersistedLogStorageResult> {
-  return await runWithFlushedLogWriteLock(async () => {
-    await flushIndex();
-    await flushSessionArchiveWrites();
-
-    const result = clearAllLogs();
-    const [logFilesDeleted, chunkFilesDeleted, sessionArchiveFilesDeleted] = await Promise.all([
-      deleteMatchingFiles(
-        resolveLogDir(),
-        (fileName) =>
-          fileName.endsWith(".jsonl") ||
-          fileName === "logs.idx" ||
-          fileName === "inspector.sqlite" ||
-          fileName.startsWith("inspector.sqlite-"),
-      ),
-      deleteMatchingFiles(
-        getChunksDir(),
-        (fileName) =>
-          fileName.endsWith(".json") || (fileName.startsWith(".") && fileName.endsWith(".tmp")),
-      ),
-      clearSessionArchives(),
-    ]);
-
-    await rebuildIndex();
-
-    return {
-      cleared: result.cleared,
-      logFilesDeleted,
-      chunkFilesDeleted,
-      sessionArchiveFilesDeleted,
-    };
-  });
-}
-
-function readLogIdFromLine(line: string): number | null {
-  if (line.trim() === "") return null;
-  try {
-    const parsed: unknown = JSON.parse(line);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
-    const idDesc = Object.getOwnPropertyDescriptor(parsed, "id");
-    if (idDesc === undefined || typeof idDesc.value !== "number") return null;
-    return idDesc.value;
-  } catch {
-    return null;
-  }
-}
-
-type RewriteLogFileResult = {
-  rewritten: boolean;
-  removedIds: Set<number>;
-};
-
-function tempRewritePath(filePath: string): string {
-  return `${filePath}.rewrite-${String(process.pid)}-${String(Date.now())}.tmp`;
-}
-
-async function removeTempFile(filePath: string): Promise<void> {
-  try {
-    await unlink(filePath);
-  } catch {
-    // Best-effort cleanup for temp rewrite files.
-  }
-}
-
-function waitForWriterDrain(writer: WriteStream): Promise<boolean> {
-  return new Promise((resolve) => {
-    const cleanup = (): void => {
-      writer.off("drain", onDrain);
-      writer.off("error", onError);
-    };
-    const onDrain = (): void => {
-      cleanup();
-      resolve(true);
-    };
-    const onError = (): void => {
-      cleanup();
-      resolve(false);
-    };
-    writer.once("drain", onDrain);
-    writer.once("error", onError);
-  });
-}
-
-async function writeKeptLogLine(writer: WriteStream, line: string): Promise<boolean> {
-  if (writer.write(`${line}\n`, "utf-8")) return true;
-  return await waitForWriterDrain(writer);
-}
-
-function finishWriter(writer: WriteStream): Promise<boolean> {
-  return new Promise((resolve) => {
-    const cleanup = (): void => {
-      writer.off("finish", onFinish);
-      writer.off("error", onError);
-    };
-    const onFinish = (): void => {
-      cleanup();
-      resolve(true);
-    };
-    const onError = (): void => {
-      cleanup();
-      resolve(false);
-    };
-    writer.once("finish", onFinish);
-    writer.once("error", onError);
-    writer.end();
-  });
-}
-
-async function rewriteLogFileWithoutIds(
-  filePath: string,
-  ids: ReadonlySet<number>,
-): Promise<RewriteLogFileResult> {
-  const tempPath = tempRewritePath(filePath);
-  if (!ensurePrivateDirectorySync(dirname(filePath))) {
-    return { rewritten: false, removedIds: new Set() };
-  }
-  const writer = createWriteStream(tempPath, {
-    encoding: "utf-8",
-    mode: PRIVATE_FILE_MODE,
-  });
-  const removedIds = new Set<number>();
-  let keptLineCount = 0;
-  let writeOk = true;
-
-  try {
-    const fileStream = createInterface({
-      input: createReadStream(filePath),
-      crlfDelay: Infinity,
-    });
-
-    for await (const line of fileStream) {
-      if (line === "") continue;
-      const id = readLogIdFromLine(line);
-      if (id !== null && ids.has(id)) {
-        removedIds.add(id);
-      } else {
-        keptLineCount += 1;
-        writeOk = await writeKeptLogLine(writer, line);
-        if (!writeOk) break;
-      }
-    }
-  } catch (err) {
-    logger.warn("[store] Failed to stream log file for deletion:", filePath, String(err));
-    writeOk = false;
-  }
-
-  if (!(await finishWriter(writer)) || !writeOk) {
-    await removeTempFile(tempPath);
-    return { rewritten: false, removedIds: new Set() };
-  }
-
-  if (!securePrivateFileSync(tempPath)) {
-    await removeTempFile(tempPath);
-    return { rewritten: false, removedIds: new Set() };
-  }
-
-  if (removedIds.size === 0) {
-    await removeTempFile(tempPath);
-    return { rewritten: false, removedIds };
-  }
-
-  try {
-    if (keptLineCount === 0) {
-      await removeTempFile(tempPath);
-      await unlink(filePath);
-    } else {
-      await rename(tempPath, filePath);
-    }
-  } catch (err) {
-    await removeTempFile(tempPath);
-    logger.warn("[store] Failed to rewrite log file after deletion:", filePath, String(err));
-    return { rewritten: false, removedIds: new Set() };
-  }
-
-  return { rewritten: true, removedIds };
-}
-
-type RewriteLogFilesResult = {
-  logFilesRewritten: number;
-  removedIds: Set<number>;
-};
-
-async function rewriteLogFilesWithoutIds(ids: ReadonlySet<number>): Promise<RewriteLogFilesResult> {
-  const logDir = resolveLogDir();
-  if (!existsSync(logDir)) return { logFilesRewritten: 0, removedIds: new Set() };
-
-  let entries: string[];
-  try {
-    entries = await readdirCallback(logDir);
-  } catch (err) {
-    logger.warn("[store] Failed to list log directory for deletion:", String(err));
-    return { logFilesRewritten: 0, removedIds: new Set() };
-  }
-
-  let logFilesRewritten = 0;
-  const removedIds = new Set<number>();
-  for (const entry of entries) {
-    if (!entry.endsWith(".jsonl")) continue;
-    const result = await rewriteLogFileWithoutIds(join(logDir, entry), ids);
-    if (result.rewritten) logFilesRewritten += 1;
-    for (const removedId of result.removedIds) {
-      removedIds.add(removedId);
-    }
-  }
-  return { logFilesRewritten, removedIds };
-}
-
-async function deleteChunkFilesByIds(ids: ReadonlySet<number>): Promise<number> {
-  const chunkDir = getChunksDir();
-  if (!existsSync(chunkDir)) return 0;
-
-  let deleted = 0;
-  for (const id of ids) {
-    const candidates = [`${String(id)}.json`, `.${String(id)}.tmp`];
-    for (const candidate of candidates) {
-      try {
-        await unlink(join(chunkDir, candidate));
-        deleted += 1;
-      } catch {
-        // Missing chunk files are expected for non-streaming logs.
-      }
-    }
-  }
-  return deleted;
-}
-
-export async function clearPersistedLogsByIds(
-  ids: readonly number[],
-): Promise<ClearPersistedLogsByIdsResult> {
-  const uniqueIds = new Set(ids);
-  if (uniqueIds.size === 0) {
-    return {
-      cleared: 0,
-      logFilesRewritten: 0,
-      chunkFilesDeleted: 0,
-      sessionArchiveLogsDeleted: 0,
-    };
-  }
-
-  return await runWithFlushedLogWriteLock(async () => {
-    await flushIndex();
-    await flushSessionArchiveWrites();
-
-    const memoryRemovedIds = new Set<number>();
-    for (const id of uniqueIds) {
-      if (memoryCache.has(id)) memoryRemovedIds.add(id);
-    }
-    const result = clearLogsByIds([...uniqueIds]);
-    const [rewriteResult, chunkFilesDeleted, archivedRemovedIds] = await Promise.all([
-      rewriteLogFilesWithoutIds(uniqueIds),
-      deleteChunkFilesByIds(uniqueIds),
-      deleteArchivedLogsByIds(uniqueIds),
-    ]);
-
-    await rebuildIndex();
-    clearLogCursorPageIndexes();
-
-    const clearedIds = new Set<number>(rewriteResult.removedIds);
-    if (result.cleared > 0) {
-      for (const id of memoryRemovedIds) {
-        clearedIds.add(id);
-      }
-    }
-    for (const id of archivedRemovedIds) {
-      clearedIds.add(id);
-    }
-
-    return {
-      cleared: clearedIds.size,
-      logFilesRewritten: rewriteResult.logFilesRewritten,
-      chunkFilesDeleted,
-      sessionArchiveLogsDeleted: archivedRemovedIds.size,
-    };
-  });
-}
-
-/**
- * Remove a specific set of log IDs from the in-memory cache. Returns the
- * number of logs actually removed. IDs not present in the cache are ignored.
- * This is used by the per-conversation-group "Clear" button in the UI.
- */
-export function clearLogsByIds(ids: readonly number[]): { cleared: number } {
-  const unique = new Set<number>();
-  for (const id of ids) {
-    if (memoryCache.has(id)) unique.add(id);
-  }
-  for (const id of unique) {
-    removeFromCache(id);
-  }
-  removeLogsFromCursorPageIndexes(unique);
-  rebuildSessionRegistry(memoryCache.values());
-  return { cleared: unique.size };
-}
-
-export function _getLogCursorPageIndexStatsForTests(): {
-  indexCount: number;
-  buildCount: number;
-} {
-  return {
-    indexCount: logCursorPageIndexes.size,
-    buildCount: logCursorPageIndexBuildCount,
-  };
-}
-
-// SSE event system for real-time log updates
-type LogUpdateHandler = (log: CapturedLog) => void;
-const sseHandlers: Set<LogUpdateHandler> = new Set();
-
-export function onLogUpdate(handler: LogUpdateHandler): () => void {
-  sseHandlers.add(handler);
-  return () => {
-    sseHandlers.delete(handler);
-  };
-}
-
-export function emitLogUpdate(log: CapturedLog): void {
-  const failedHandlers: LogUpdateHandler[] = [];
-  for (const handler of sseHandlers) {
-    try {
-      handler(log);
-    } catch {
-      // Collect failed handlers to remove after iteration
-      failedHandlers.push(handler);
-    }
-  }
-  // Remove failed handlers after iteration to avoid Set mutation during for...of
-  for (const handler of failedHandlers) {
-    sseHandlers.delete(handler);
-  }
-}