@vibelet/cli 0.1.38 → 1.0.1

package/src/scanner.ts

@@ -1,924 +0,0 @@
-import { readdir, stat, readFile, open } from 'fs/promises';
-import { createReadStream } from 'fs';
-import { createInterface } from 'readline';
-import { join, basename } from 'path';
-import { homedir } from 'os';
-import type {
-  AgentType,
-  ApprovalMode,
-  SessionInfo,
-  SessionSource,
-} from '@vibelet/shared';
-import { preferSessionTitle } from './session-title.js';
-import { createIdleRuntime } from './session-inventory.js';
-import { logger as rootLogger } from './logger.js';
-
-const log = rootLogger.child({ module: 'scanner' });
-
-// ---------------------------------------------------------------------------
-// TTL cache helper
-// ---------------------------------------------------------------------------
-interface CacheEntry<T> { value: T; expiresAt: number }
-
-function createTtlCache<T>(ttlMs: number) {
-  const store = new Map<string, CacheEntry<T>>();
-  return {
-    get(key: string): T | undefined {
-      const entry = store.get(key);
-      if (!entry) return undefined;
-      if (Date.now() > entry.expiresAt) { store.delete(key); return undefined; }
-      return entry.value;
-    },
-    set(key: string, value: T): void {
-      store.set(key, { value, expiresAt: Date.now() + ttlMs });
-    },
-    clear(): void { store.clear(); },
-  };
-}
-
-const SCAN_CACHE_TTL = 30_000; // 30s — explicit invalidation on mutations keeps it fresh
-const scannerCache = createTtlCache<SessionInfo[]>(SCAN_CACHE_TTL);
-const searchCache = createTtlCache<Set<string>>(SCAN_CACHE_TTL);
-const scannerInflight = new Map<string, Promise<SessionInfo[]>>();
-const searchInflight = new Map<string, Promise<Set<string>>>();
-const FILE_READ_CONCURRENCY = 24;
-
-/** Invalidate all scanner caches. Call after session creation/deletion. */
-export function invalidateScannerCache(): void {
-  scannerCache.clear();
-  searchCache.clear();
-}
-
-export interface SessionFileMeta {
-  sessionId: string;
-  agent: AgentType;
-  cwd: string;
-  title?: string;
-  approvalMode?: ApprovalMode;
-  createdAt: string;
-  lastActivityAt: string;
-  filePath: string;
-}
-
-export interface SessionRuntimeHints {
-  isResponding?: boolean;
-  partialReplyText?: string;
-}
-
-function encodeCwd(cwd: string): string {
-  return cwd.replace(/[^a-zA-Z0-9]/g, '-');
-}
-
-async function mapWithConcurrency<T, R>(
-  items: T[],
-  concurrency: number,
-  worker: (item: T, index: number) => Promise<R>,
-): Promise<R[]> {
-  if (items.length === 0) return [];
-
-  const limit = Math.max(1, Math.min(concurrency, items.length));
-  const results = new Array<R>(items.length);
-  let nextIndex = 0;
-
-  await Promise.all(Array.from({ length: limit }, async () => {
-    while (true) {
-      const index = nextIndex;
-      nextIndex += 1;
-      if (index >= items.length) return;
-      results[index] = await worker(items[index], index);
-    }
-  }));
-
-  return results;
-}
-
-/** Yield up to `maxLines` non-empty lines from text without splitting the entire string. */
-function* iterateFirstLines(text: string, maxLines: number): Generator<string> {
-  let start = 0;
-  let yielded = 0;
-  while (start < text.length && yielded < maxLines) {
-    let end = text.indexOf('\n', start);
-    if (end === -1) end = text.length;
-    const line = text.substring(start, end);
-    start = end + 1;
-    if (line.length === 0 || line.trim().length === 0) continue;
-    yield line;
-    yielded += 1;
-  }
-}
-
-/**
- * Read the head of a file (up to `maxBytes`) instead of the entire file.
- * For files smaller than `maxBytes`, this is equivalent to readFile.
- * For large files (100MB+), this avoids loading the entire content into memory.
- */
-const HEAD_READ_MAX_BYTES = 512 * 1024; // 512 KB — enough for 64-96 JSONL lines
-const TAIL_READ_MAX_BYTES = 256 * 1024; // 256 KB — enough to capture recent mode changes
-
-async function readFileHead(filePath: string, fileSize: number): Promise<string> {
-  if (fileSize <= HEAD_READ_MAX_BYTES) {
-    return readFile(filePath, 'utf-8');
-  }
-  const fd = await open(filePath, 'r');
-  try {
-    const buf = Buffer.alloc(HEAD_READ_MAX_BYTES);
-    const { bytesRead } = await fd.read(buf, 0, HEAD_READ_MAX_BYTES, 0);
-    return buf.toString('utf-8', 0, bytesRead);
-  } finally {
-    await fd.close();
-  }
-}
-
-async function readFileTail(filePath: string, fileSize: number): Promise<string> {
-  if (fileSize <= TAIL_READ_MAX_BYTES) {
-    return readFile(filePath, 'utf-8');
-  }
-  const fd = await open(filePath, 'r');
-  try {
-    const start = Math.max(0, fileSize - TAIL_READ_MAX_BYTES);
-    const buf = Buffer.alloc(fileSize - start);
-    const { bytesRead } = await fd.read(buf, 0, buf.length, start);
-    return buf.toString('utf-8', 0, bytesRead);
-  } finally {
-    await fd.close();
-  }
-}
-
-function mapClaudePermissionMode(permissionMode: unknown): ApprovalMode | undefined {
-  switch (permissionMode) {
-    case 'plan':
-      return 'plan';
-    case 'acceptEdits':
-      return 'acceptEdits';
-    case 'bypassPermissions':
-      return 'autoApprove';
-    case 'default':
-      return 'normal';
-    default:
-      return undefined;
-  }
-}
-
-function mapCodexApprovalModeFromTurnContext(payload: any): ApprovalMode | undefined {
-  const approvalPolicy = typeof payload?.approval_policy === 'string' ? payload.approval_policy : '';
-  const sandboxPolicy = payload?.sandbox_policy;
-  const sandboxType = typeof sandboxPolicy?.type === 'string' ? sandboxPolicy.type : '';
-  const writableRoots = Array.isArray(sandboxPolicy?.writable_roots) ? sandboxPolicy.writable_roots : null;
-
-  if (approvalPolicy === 'never' && sandboxType === 'danger-full-access') {
-    return 'autoApprove';
-  }
-  if (approvalPolicy === 'on-request' && sandboxType === 'workspace-write') {
-    return writableRoots?.length ? 'normal' : 'plan';
-  }
-  return undefined;
-}
-
-function readClaudeApprovalModeFromEntry(entry: any): ApprovalMode | undefined {
-  if (entry?.type === 'permission-mode') {
-    return mapClaudePermissionMode(entry.permissionMode);
-  }
-  return mapClaudePermissionMode(entry?.permissionMode);
-}
-
-function readCodexApprovalModeFromEntry(entry: any): ApprovalMode | undefined {
-  if (entry?.type !== 'turn_context') {
-    return undefined;
-  }
-  return mapCodexApprovalModeFromTurnContext(entry.payload);
-}
-
-async function readSessionApprovalModeFromFile(
-  filePath: string,
-  agent: AgentType,
-  fileSize: number,
-): Promise<ApprovalMode | undefined> {
-  let latestApprovalMode: ApprovalMode | undefined;
-  const content = await readFileTail(filePath, fileSize);
-  for (const line of content.split('\n')) {
-    if (!line.trim()) continue;
-    let entry: any;
-    try {
-      entry = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    const approvalMode = agent === 'claude'
-      ? readClaudeApprovalModeFromEntry(entry)
-      : readCodexApprovalModeFromEntry(entry);
-    if (approvalMode) {
-      latestApprovalMode = approvalMode;
-    }
-  }
-  return latestApprovalMode;
-}
-
-function extractCodexText(content: unknown): string {
-  if (typeof content === 'string') return content;
-  if (!Array.isArray(content)) return '';
-  return content
-    .map((item) => {
-      if (!item || typeof item !== 'object') return '';
-      if (typeof (item as any).text === 'string') return (item as any).text;
-      if (typeof (item as any).content === 'string') return (item as any).content;
-      return '';
-    })
-    .join('');
-}
-
-function extractCodexUserMessageText(entry: any): string {
-  if (entry?.type === 'response_item' && entry.payload?.type === 'message' && entry.payload.role === 'user') {
-    return extractCodexText(entry.payload.content);
-  }
-  if (entry?.type === 'event_msg' && entry.payload?.type === 'user_message' && typeof entry.payload.message === 'string') {
-    return entry.payload.message;
-  }
-  return '';
-}
-
-function extractClaudeText(content: unknown): string {
-  if (typeof content === 'string') return content;
-  if (!Array.isArray(content)) return '';
-  return content
-    .map((item) => {
-      if (!item || typeof item !== 'object') return '';
-      if ((item as any).type !== 'text') return '';
-      return typeof (item as any).text === 'string' ? (item as any).text : '';
-    })
-    .join('');
-}
-
-const CLAUDE_INTERNAL_USER_MESSAGE_PREFIXES = [
-  '<task-notification>',
-  '<local-command-caveat>',
-  '<local-command-stdout>',
-  '<local-command-stderr>',
-  '<command-name>',
-  '<command-message>',
-  '<command-args>',
-  '<system-reminder>',
-  '<environment_context>',
-  '# AGENTS.md instructions for ',
-];
-
-function isClaudeInternalUserMessage(entry: any, text: string): boolean {
-  if (entry?.isMeta === true) return true;
-  const trimmed = text.trim();
-  if (!trimmed) return false;
-  return CLAUDE_INTERNAL_USER_MESSAGE_PREFIXES.some(prefix => trimmed.startsWith(prefix));
-}
-
-function extractClaudeUserMessageText(entry: any): string {
-  if (entry?.type !== 'user' || entry.message?.role !== 'user') return '';
-  const text = extractClaudeText(entry.message.content);
-  return isClaudeInternalUserMessage(entry, text) ? '' : text;
-}
-
-function hasClaudeToolResult(content: unknown): boolean {
-  return Array.isArray(content) && content.some((item) => item && typeof item === 'object' && (item as any).type === 'tool_result');
-}
-
-function isCodexSetupMessage(text: string): boolean {
-  const trimmed = text.trim();
-  return trimmed.startsWith('# AGENTS.md instructions for ') || trimmed.startsWith('<environment_context>');
-}
-
-function toIdleSessionInfo(meta: SessionFileMeta, source: SessionSource = 'scanner'): SessionInfo {
-  return {
-    sessionId: meta.sessionId,
-    agent: meta.agent,
-    cwd: meta.cwd,
-    title: meta.title,
-    observedApprovalMode: meta.approvalMode,
-    createdAt: meta.createdAt,
-    lastActivityAt: meta.lastActivityAt,
-    sources: [source],
-    runtime: createIdleRuntime(),
-  };
-}
-
-export function extractSessionIdFromSessionFile(agent: AgentType, filePath: string): string | null {
-  const name = basename(filePath, '.jsonl');
-  if (agent === 'claude') return name || null;
-  const match = name.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i);
-  return match?.[1] ?? null;
-}
-
-async function readClaudeSessionFileMeta(filePath: string, fileSize: number): Promise<Pick<SessionFileMeta, 'sessionId' | 'cwd' | 'title' | 'approvalMode'> | null> {
-  const content = await readFileHead(filePath, fileSize);
-  const lines = iterateFirstLines(content, 64);
-
-  let cwd = '';
-  let sessionId = '';
-  let title: string | undefined;
-  let firstUserText: string | undefined;
-  let derivedTitle: string | undefined;
-
-  for (const line of lines) {
-    let entry: any;
-    try {
-      entry = JSON.parse(line);
-    } catch {
-      continue;
-    }
-
-    if (!cwd && typeof entry.cwd === 'string') cwd = entry.cwd;
-    if (!sessionId && typeof entry.sessionId === 'string') sessionId = entry.sessionId;
-    if (!title) {
-      title = preferSessionTitle([entry.customTitle, entry.summary]);
-    }
-    if (!derivedTitle) {
-      const userText = extractClaudeUserMessageText(entry);
-      const nextDerivedTitle = preferSessionTitle([], userText);
-      if (nextDerivedTitle) {
-        firstUserText = userText;
-        derivedTitle = nextDerivedTitle;
-      }
-    }
-
-    if (cwd && (title || derivedTitle)) break;
-  }
-
-  if (!cwd) return null;
-
-  return {
-    sessionId: sessionId || extractSessionIdFromSessionFile('claude', filePath) || basename(filePath, '.jsonl'),
-    cwd,
-    title: title ?? derivedTitle ?? preferSessionTitle([], firstUserText),
-    approvalMode: await readSessionApprovalModeFromFile(filePath, 'claude', fileSize),
-  };
-}
-
-async function readCodexSessionFileMeta(filePath: string, fileSize: number): Promise<Pick<SessionFileMeta, 'sessionId' | 'cwd' | 'title' | 'approvalMode'> | null> {
-  const content = await readFileHead(filePath, fileSize);
-  const lines = iterateFirstLines(content, 96);
-
-  let cwd = '';
-  let sessionId = '';
-  let title: string | undefined;
-  let firstUserText: string | undefined;
-  let derivedTitle: string | undefined;
-
-  for (const line of lines) {
-    let entry: any;
-    try {
-      entry = JSON.parse(line);
-    } catch {
-      continue;
-    }
-
-    if (!cwd) {
-      cwd = entry.payload?.cwd ?? entry.cwd ?? '';
-    }
-    if (!sessionId) {
-      sessionId = entry.payload?.id ?? entry.id ?? '';
-    }
-    if (!title) {
-      title = preferSessionTitle([entry.payload?.title, entry.title]);
-    }
-    if (!derivedTitle) {
-      const userText = extractCodexUserMessageText(entry);
-      const nextDerivedTitle = userText && !isCodexSetupMessage(userText)
-        ? preferSessionTitle([], userText)
-        : undefined;
-      if (nextDerivedTitle) {
-        firstUserText = userText;
-        derivedTitle = nextDerivedTitle;
-      }
-    }
-
-    if (cwd && (title || derivedTitle)) break;
-  }
-
-  if (!cwd) return null;
-
-  return {
-    sessionId: sessionId || extractSessionIdFromSessionFile('codex', filePath) || basename(filePath, '.jsonl'),
-    cwd,
-    title: title ?? derivedTitle ?? preferSessionTitle([], firstUserText),
-    approvalMode: await readSessionApprovalModeFromFile(filePath, 'codex', fileSize),
-  };
-}
-
-export async function readSessionFileMeta(filePath: string, agent: AgentType): Promise<SessionFileMeta | null> {
-  const fileStat = await stat(filePath).catch(() => null);
-  if (!fileStat) return null;
-
-  try {
-    const fileSize = fileStat.size;
-    if (agent === 'claude') {
-      const meta = await readClaudeSessionFileMeta(filePath, fileSize);
-      if (!meta) return null;
-      return {
-        sessionId: meta.sessionId,
-        agent,
-        cwd: meta.cwd,
-        title: meta.title,
-        approvalMode: meta.approvalMode,
-        createdAt: new Date(fileStat.birthtimeMs).toISOString(),
-        lastActivityAt: new Date(fileStat.mtimeMs).toISOString(),
-        filePath,
-      };
-    }
-
-    const meta = await readCodexSessionFileMeta(filePath, fileSize);
-    if (!meta) return null;
-
-    return {
-      sessionId: meta.sessionId,
-      agent,
-      cwd: meta.cwd,
-      title: meta.title,
-      approvalMode: meta.approvalMode,
-      createdAt: new Date(fileStat.birthtimeMs).toISOString(),
-      lastActivityAt: new Date(fileStat.mtimeMs).toISOString(),
-      filePath,
-    };
-  } catch {
-    return null;
-  }
-}
-
-export async function listClaudeSessions(cwd?: string, partial?: SessionInfo[]): Promise<SessionInfo[]> {
-  const projectsDir = join(homedir(), '.claude', 'projects');
-
-  try {
-    let dirNames: string[];
-    if (cwd) {
-      dirNames = [encodeCwd(cwd)];
-    } else {
-      const entries = await readdir(projectsDir, { withFileTypes: true });
-      dirNames = entries.filter(e => e.isDirectory()).map(e => e.name);
-    }
-
-    // Collect all file paths, then read in parallel
-    const filePaths: string[] = [];
-    for (const dir of dirNames) {
-      const dirPath = join(projectsDir, dir);
-      const files = await readdir(dirPath).catch(() => [] as string[]);
-      for (const file of files) {
-        if (file.endsWith('.jsonl')) filePaths.push(join(dirPath, file));
-      }
-    }
-
-    // Stat files to get mtime, then sort by recency so active sessions are scanned first.
-    // Even if the inventory timeout fires mid-scan, recently active sessions are already in `partial`.
-    const fileStats = await mapWithConcurrency(filePaths, FILE_READ_CONCURRENCY, async (fp) => {
-      const s = await stat(fp).catch(() => null);
-      return { path: fp, mtimeMs: s?.mtimeMs ?? 0 };
-    });
-    fileStats.sort((a, b) => b.mtimeMs - a.mtimeMs);
-
-    const metas = await mapWithConcurrency(fileStats, FILE_READ_CONCURRENCY, async (entry) => {
-      const meta = await readSessionFileMeta(entry.path, 'claude');
-      if (meta && partial) partial.push(toIdleSessionInfo(meta));
-      return meta;
-    });
-    const sessions = metas
-      .filter((meta): meta is SessionFileMeta => meta !== null)
-      .map(meta => toIdleSessionInfo(meta));
-
-    return sessions.sort((a, b) => b.lastActivityAt.localeCompare(a.lastActivityAt));
-  } catch (e) {
-    // .claude/projects might not exist
-    log.warn({ error: String(e) }, 'failed to list claude sessions');
-    return [];
-  }
-}
-
-export async function listCodexSessions(cwd?: string, partial?: SessionInfo[]): Promise<SessionInfo[]> {
-  const sessionsDir = join(homedir(), '.codex', 'sessions');
-
-  try {
-    const years = await readdir(sessionsDir).catch(() => []);
-
-    // Collect all file paths first via directory traversal
-    const filePaths: string[] = [];
-    for (const year of years) {
-      const yearPath = join(sessionsDir, year);
-      const months = await readdir(yearPath).catch(() => []);
-
-      for (const month of months) {
-        const monthPath = join(yearPath, month);
-        const days = await readdir(monthPath).catch(() => []);
-
-        for (const day of days) {
-          const dayPath = join(monthPath, day);
-          const files = await readdir(dayPath).catch(() => []);
-
-          for (const file of files) {
-            if (file.endsWith('.jsonl')) filePaths.push(join(dayPath, file));
-          }
-        }
-      }
-    }
-
-    // Stat files to get mtime, then sort by recency so active sessions are scanned first
-    const fileStats = await mapWithConcurrency(filePaths, FILE_READ_CONCURRENCY, async (fp) => {
-      const s = await stat(fp).catch(() => null);
-      return { path: fp, mtimeMs: s?.mtimeMs ?? 0 };
-    });
-    fileStats.sort((a, b) => b.mtimeMs - a.mtimeMs);
-
-    const metas = await mapWithConcurrency(fileStats, FILE_READ_CONCURRENCY, async (entry) => {
-      const meta = await readSessionFileMeta(entry.path, 'codex');
-      if (meta && partial && (!cwd || meta.cwd === cwd)) partial.push(toIdleSessionInfo(meta));
-      return meta;
-    });
-    const sessions = metas
-      .filter((meta): meta is SessionFileMeta => meta !== null)
-      .filter(meta => !cwd || meta.cwd === cwd)
-      .map(meta => toIdleSessionInfo(meta));
-
-    return sessions.sort((a, b) => b.lastActivityAt.localeCompare(a.lastActivityAt));
-  } catch (e) {
-    // .codex/sessions might not exist
-    log.warn({ error: String(e) }, 'failed to list codex sessions');
-    return [];
-  }
-}
-
-export async function listSessions(agent?: AgentType, cwd?: string, partial?: SessionInfo[]): Promise<SessionInfo[]> {
-  const home = homedir();
-  const cacheKey = `list:${home}:${agent ?? 'all'}:${cwd ?? ''}`;
-  const cached = scannerCache.get(cacheKey);
-  if (cached) return cached;
-
-  // Coalesce concurrent callers into a single in-flight scan
-  const inflight = scannerInflight.get(cacheKey);
-  if (inflight) return inflight;
-
-  const promise = (async () => {
-    let result: SessionInfo[];
-    if (agent === 'claude') {
-      result = await listClaudeSessions(cwd, partial);
-    } else if (agent === 'codex') {
-      result = await listCodexSessions(cwd, partial);
-    } else {
-      const [claude, codex] = await Promise.all([
-        listClaudeSessions(cwd, partial),
-        listCodexSessions(cwd, partial),
-      ]);
-      result = [...claude, ...codex].sort((a, b) => b.lastActivityAt.localeCompare(a.lastActivityAt));
-    }
-
-    scannerCache.set(cacheKey, result);
-    return result;
-  })();
-
-  scannerInflight.set(cacheKey, promise);
-  promise.finally(() => scannerInflight.delete(cacheKey));
-  return promise;
-}
-
-export async function searchSessionContent(query: string, agent?: AgentType): Promise<Set<string>> {
-  const home = homedir();
-  const cacheKey = `search:${home}:${query}:${agent ?? 'all'}`;
-  const cached = searchCache.get(cacheKey);
-  if (cached) return cached;
-
-  // Coalesce concurrent callers into a single in-flight search
-  const inflight = searchInflight.get(cacheKey);
-  if (inflight) return inflight;
-
-  const promise = (async () => {
-    const matched = new Set<string>();
-    const q = query.toLowerCase();
-
-    async function searchClaudeFiles(): Promise<void> {
-      const projectsDir = join(homedir(), '.claude', 'projects');
-      try {
-        const entries = await readdir(projectsDir, { withFileTypes: true });
-        const filePaths: string[] = [];
-        for (const entry of entries) {
-          if (!entry.isDirectory()) continue;
-          const dirPath = join(projectsDir, entry.name);
-          const files = await readdir(dirPath).catch(() => [] as string[]);
-          for (const file of files) {
-            if (file.endsWith('.jsonl')) filePaths.push(join(dirPath, file));
-          }
-        }
-        const results = await mapWithConcurrency(filePaths, FILE_READ_CONCURRENCY, (filePath) => searchFileContent(filePath, q, 'claude'));
-        for (const result of results) {
-          if (result) matched.add(result);
-        }
-      } catch (e) {
-        log.warn({ error: String(e) }, 'failed to search claude files');
-      }
-    }
-
-    async function searchCodexFiles(): Promise<void> {
-      const sessionsDir = join(homedir(), '.codex', 'sessions');
-      try {
-        const filePaths: string[] = [];
-        async function collectFiles(dir: string): Promise<void> {
-          const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
-          for (const entry of entries) {
-            const fullPath = join(dir, entry.name);
-            if (entry.isDirectory()) {
-              await collectFiles(fullPath);
-            } else if (entry.name.endsWith('.jsonl')) {
-              filePaths.push(fullPath);
-            }
-          }
-        }
-        await collectFiles(sessionsDir);
-        const results = await mapWithConcurrency(filePaths, FILE_READ_CONCURRENCY, (filePath) => searchFileContent(filePath, q, 'codex'));
-        for (const result of results) {
-          if (result) matched.add(result);
-        }
-      } catch (e) {
-        log.warn({ error: String(e) }, 'failed to search codex files');
-      }
-    }
-
-    if (agent === 'claude') {
-      await searchClaudeFiles();
-    } else if (agent === 'codex') {
-      await searchCodexFiles();
-    } else {
-      await Promise.all([searchClaudeFiles(), searchCodexFiles()]);
-    }
-
-    searchCache.set(cacheKey, matched);
-    return matched;
-  })();
-
-  searchInflight.set(cacheKey, promise);
-  promise.finally(() => searchInflight.delete(cacheKey));
-  return promise;
-}
-
-/** Returns the sessionId if the file contains matching text, null otherwise. */
-async function searchFileContent(filePath: string, query: string, agent: AgentType): Promise<string | null> {
-  const input = createReadStream(filePath, { encoding: 'utf-8' });
-  const reader = createInterface({ input, crlfDelay: Infinity });
-  const extractText = agent === 'claude' ? extractClaudeMessageText : extractCodexMessageText;
-  let sessionId = '';
-  let found = false;
-
-  try {
-    for await (const line of reader) {
-      if (!line.trim()) continue;
-      let entry: any;
-      try {
-        entry = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      if (!sessionId) {
-        if (agent === 'claude') {
-          if (typeof entry.sessionId === 'string') sessionId = entry.sessionId;
-        } else {
-          sessionId = entry.payload?.id ?? entry.id ?? '';
-        }
-      }
-      if (!found) {
-        const text = extractText(entry);
-        if (text && text.toLowerCase().includes(query)) {
-          found = true;
-        }
-      }
-      if (sessionId && found) break;
-    }
-  } finally {
-    reader.close();
-    input.destroy();
-  }
-
-  if (!found) return null;
-  return sessionId || extractSessionIdFromSessionFile(agent, filePath);
-}
-
-function extractClaudeMessageText(entry: any): string {
-  if (entry?.type === 'user' && entry.message?.role === 'user') {
-    return extractClaudeUserMessageText(entry);
-  }
-  if (entry?.type === 'assistant' && entry.message?.role === 'assistant') {
-    return extractClaudeText(entry.message.content);
-  }
-  return '';
-}
-
-function extractCodexMessageText(entry: any): string {
-  if (entry?.type === 'response_item' && entry.payload?.type === 'message') {
-    const role = entry.payload.role;
-    if (role === 'user' || role === 'assistant') {
-      return extractCodexText(entry.payload.content);
-    }
-  }
-  const userText = extractCodexUserMessageText(entry);
-  if (userText) return userText;
-  return '';
-}
-
-async function readJsonlFile(filePath: string, onEntry: (entry: any) => boolean | void): Promise<void> {
-  const input = createReadStream(filePath, { encoding: 'utf-8' });
-  const reader = createInterface({ input, crlfDelay: Infinity });
-
-  try {
-    for await (const line of reader) {
-      if (!line.trim()) continue;
-      let entry: any;
-      try {
-        entry = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      if (onEntry(entry)) break;
-    }
-  } finally {
-    reader.close();
-    input.destroy();
-  }
-}
-
-async function resolveClaudeSessionFilePath(sessionId: string, cwd?: string): Promise<string | null> {
-  const projectsDir = join(homedir(), '.claude', 'projects');
-  const primaryDir = cwd ? encodeCwd(cwd) : null;
-  const allDirs = await readdir(projectsDir).catch(() => [] as string[]);
-  const dirs = primaryDir
-    ? [primaryDir, ...allDirs.filter((dir) => dir !== primaryDir)]
-    : allDirs;
-
-  for (const dir of dirs) {
-    const filePath = join(projectsDir, dir, `${sessionId}.jsonl`);
-    const fileStat = await stat(filePath).catch(() => null);
-    if (fileStat?.isFile()) {
-      return filePath;
-    }
-  }
-
-  return null;
-}
-
-async function resolveSessionFilePath(sessionId: string, agent: AgentType, cwd?: string): Promise<string | null> {
-  if (agent === 'claude') {
-    return resolveClaudeSessionFilePath(sessionId, cwd);
-  }
-
-  const sessionsDir = join(homedir(), '.codex', 'sessions');
-  return findCodexSessionFile(sessionsDir, sessionId);
-}
-
-type ClaudeRuntimeRelevantEntry =
-  | { kind: 'userPrompt' }
-  | { kind: 'toolResult' }
-  | { kind: 'assistant'; stopReason?: string | null; text?: string }
-  | { kind: 'stopHook' };
-
-function classifyClaudeRuntimeEntry(entry: any): ClaudeRuntimeRelevantEntry | null {
-  if (entry?.type === 'user' && entry.message?.role === 'user') {
-    if (hasClaudeToolResult(entry.message.content)) {
-      return { kind: 'toolResult' };
-    }
-
-    const text = extractClaudeUserMessageText(entry);
-    if (text) {
-      return { kind: 'userPrompt' };
-    }
-    return null;
-  }
-
-  if (entry?.type === 'assistant' && entry.message?.role === 'assistant') {
-    const text = extractClaudeText(entry.message.content);
-    const stopReason = entry.message?.stop_reason;
-    return {
-      kind: 'assistant',
-      stopReason: typeof stopReason === 'string' ? stopReason : stopReason ?? null,
-      ...(text ? { text } : {}),
-    };
-  }
-
-  if (entry?.type === 'system' && entry.subtype === 'stop_hook_summary') {
-    return { kind: 'stopHook' };
-  }
-
-  return null;
-}
-
-function runtimeHintsFromClaudeEntry(entry: ClaudeRuntimeRelevantEntry | null): SessionRuntimeHints {
-  if (!entry) return {};
-
-  if (entry.kind === 'stopHook') {
-    return {};
-  }
-
-  if (entry.kind === 'assistant') {
-    const isResponding = entry.stopReason == null || entry.stopReason === 'tool_use';
-    return {
-      ...(isResponding ? { isResponding: true } : {}),
-      ...(isResponding && entry.text ? { partialReplyText: entry.text } : {}),
-    };
-  }
-
-  return { isResponding: true };
-}
-
-export async function readSessionRuntimeHintsFromFile(filePath: string, agent: AgentType): Promise<SessionRuntimeHints> {
-  if (agent !== 'claude') {
-    return {};
-  }
-
-  let lastRelevant: ClaudeRuntimeRelevantEntry | null = null;
-  try {
-    await readJsonlFile(filePath, (entry) => {
-      const relevant = classifyClaudeRuntimeEntry(entry);
-      if (relevant) {
-        lastRelevant = relevant;
-      }
-    });
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
-      log.warn({ filePath, error: String(error) }, 'failed to read session runtime hints');
-    }
-    return {};
-  }
-
-  return runtimeHintsFromClaudeEntry(lastRelevant);
-}
-
-export async function readSessionRuntimeHints(sessionId: string, agent: AgentType, cwd?: string): Promise<SessionRuntimeHints> {
-  const filePath = await resolveSessionFilePath(sessionId, agent, cwd);
-  if (!filePath) {
-    return {};
-  }
-
-  return readSessionRuntimeHintsFromFile(filePath, agent);
-}
-
-export async function readSessionHistory(sessionId: string, agent: AgentType, cwd?: string): Promise<Array<{ role: 'user' | 'assistant'; content: string }>> {
-  const messages: Array<{ role: 'user' | 'assistant'; content: string }> = [];
-  const appendHistoryMessage = (
-    message: { role: 'user' | 'assistant'; content: string },
-    options?: { coalesceConsecutiveAssistant?: boolean },
-  ) => {
-    if (options?.coalesceConsecutiveAssistant && message.role === 'assistant') {
-      const lastMessage = messages[messages.length - 1];
-      if (lastMessage?.role === 'assistant') {
-        messages[messages.length - 1] = message;
-        return;
-      }
-    }
-    messages.push(message);
-  };
-
-  if (agent === 'claude') {
-    try {
-      const filePath = await resolveClaudeSessionFilePath(sessionId, cwd);
-      if (filePath) {
-        await readJsonlFile(filePath, (msg) => {
-          if (msg.type === 'user' && msg.message?.role === 'user') {
-            const text = extractClaudeUserMessageText(msg);
-            if (text) appendHistoryMessage({ role: 'user', content: text });
-          } else if (msg.type === 'assistant' && msg.message?.role === 'assistant') {
-            const text = extractClaudeText(msg.message.content);
-            if (text) appendHistoryMessage({ role: 'assistant', content: text });
-          }
-        });
-      }
-    } catch (e) {
-      log.warn({ error: String(e) }, 'failed to read claude session history');
-    }
-  } else if (agent === 'codex') {
-    try {
-      const filePath = await resolveSessionFilePath(sessionId, agent, cwd);
-      if (filePath) {
-        await readJsonlFile(filePath, (msg) => {
-          if (msg.type !== 'response_item' || msg.payload?.type !== 'message') return;
-          const role = msg.payload.role;
-          if (role !== 'user' && role !== 'assistant') return;
-          const text = extractCodexText(msg.payload.content);
-          if (!text) return;
-          if (role === 'user' && isCodexSetupMessage(text)) return;
-          appendHistoryMessage(
-            { role, content: text },
-            { coalesceConsecutiveAssistant: true },
-          );
-        });
-      }
-    } catch (e) {
-      log.warn({ error: String(e) }, 'failed to read codex session history');
-    }
-  }
-
-  return messages;
-}
-
-async function findCodexSessionFile(dir: string, sessionId: string): Promise<string | null> {
-  try {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = join(dir, entry.name);
-      if (entry.isDirectory()) {
-        const found = await findCodexSessionFile(fullPath, sessionId);
-        if (found) return found;
-      } else if (entry.name.includes(sessionId) && entry.name.endsWith('.jsonl')) {
-        return fullPath;
-      }
-    }
-  } catch (e) {
-    log.warn({ error: String(e) }, 'failed to walk codex sessions dir');
-  }
-  return null;
-}