@vibelet/cli 0.1.35 → 0.1.37

package/src/scanner.ts

@@ -0,0 +1,924 @@
+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;
+}