failproofai 0.0.13 → 0.0.14-beta.0

package/lib/gemini-projects.ts

@@ -1,243 +0,0 @@
-/**
- * Gemini CLI project discovery.
- *
- * Empirically verified against gemini-cli v0.40.1:
- *
- *   • Session-state root: `~/.gemini/tmp/<project-basename>/`. Each subdir
- *     corresponds to one project. The basename is the cwd's last path segment
- *     (lossy when two projects share a basename — but every dir carries a
- *     `.project_root` text file with the absolute cwd to disambiguate).
- *   • Project list registry: `~/.gemini/projects.json` maps absolute cwd →
- *     basename. Authoritative when present, but we read each `.project_root`
- *     anyway so the dashboard tolerates partially-pruned registries.
- *   • Per-session file: `~/.gemini/tmp/<project>/chats/session-<ISO-timestamp>-<uuid-prefix>.jsonl`.
- *     A sidecar `<file>.jsonl.tool-calls.json` may sit alongside.
- *   • File format: JSONL. First line is metadata
- *     `{sessionId, projectHash, startTime, lastUpdated, kind}`; subsequent
- *     lines are message records `{id, timestamp, type, content: [{text}]}`
- *     and `{$set: {...}}` partial updates.
- *
- * As with Cursor / Pi / OpenCode, this module is intentionally permissive — a
- * missing `~/.gemini/` returns `[]`, malformed JSONL falls open without
- * surfacing the session.
- */
-import { open, readdir, readFile, stat } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import type { ProjectFolder, SessionFile } from "./projects";
-import { runtimeCache } from "./runtime-cache";
-import { batchAll } from "./concurrency";
-import { formatDate } from "./format-date";
-import { encodeFolderName } from "./paths";
-import { logWarn } from "./logger";
-
-/** Filename pattern for a Gemini session JSONL:
- *  `session-<ISO-timestamp-with-dashes>-<8-hex-uuid-prefix>.jsonl`. */
-const SESSION_FILE_RE = /^session-(\d{4}-\d{2}-\d{2}T\d{2}-\d{2})-([0-9a-f]{8})\.jsonl$/i;
-/** Full UUID — the filename only embeds the first 8 hex chars; the rest is on
- *  the JSONL metadata header line. The session detail route requires a full
- *  UUID, so links built from the truncated filename prefix 404. */
-const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-/** Metadata header sits on line 1 and is well under 1 KB; 4 KB covers it
- *  comfortably without slurping a multi-MB transcript. */
-const FIRST_LINE_CHUNK_BYTES = 4 * 1024;
-
-/** Override for tests. Defaults to the live Gemini session-state root. */
-function getGeminiTmpRoot(): string {
-  return process.env.GEMINI_SESSIONS_DIR
-    || join(homedir(), ".gemini", "tmp");
-}
-
-interface GeminiSessionMeta {
-  filePath: string;
-  sessionFilename: string;
-  cwd: string;
-  fileMtime: Date;
-  /** Full UUID parsed from the JSONL metadata header (line 1). Undefined when
-   *  the header is missing, malformed, or carries a non-UUID `sessionId`;
-   *  callers fall through to rendering an un-linked row. */
-  sessionId?: string;
-}
-
-async function safeReaddir(dir: string) {
-  try {
-    return await readdir(dir, { withFileTypes: true });
-  } catch {
-    return null;
-  }
-}
-
-async function statMtime(path: string): Promise<Date | null> {
-  try {
-    return (await stat(path)).mtime;
-  } catch {
-    return null;
-  }
-}
-
-/** Read the first newline-delimited line of `filePath` without slurping the
- *  rest. Mirrors `lib/codex-projects.ts`'s readFirstLine; the Gemini metadata
- *  header is always on line 1. */
-async function readFirstLine(filePath: string): Promise<string | null> {
-  let fh: Awaited<ReturnType<typeof open>> | null = null;
-  try {
-    fh = await open(filePath, "r");
-    const buf = Buffer.alloc(FIRST_LINE_CHUNK_BYTES);
-    const { bytesRead } = await fh.read(buf, 0, FIRST_LINE_CHUNK_BYTES, 0);
-    if (bytesRead === 0) return null;
-    const slice = buf.subarray(0, bytesRead);
-    const nl = slice.indexOf(0x0a); // '\n'
-    const end = nl === -1 ? bytesRead : nl;
-    return slice.subarray(0, end).toString("utf-8");
-  } catch {
-    return null;
-  } finally {
-    if (fh) await fh.close().catch(() => {});
-  }
-}
-
-/** Extract a full-UUID `sessionId` from a JSONL metadata header line. Returns
- *  undefined on parse failure, missing field, or a non-UUID value. */
-function extractFullSessionId(line: string | null): string | undefined {
-  if (!line) return undefined;
-  try {
-    const meta = JSON.parse(line) as { sessionId?: unknown };
-    if (typeof meta.sessionId !== "string") return undefined;
-    return UUID_RE.test(meta.sessionId) ? meta.sessionId : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-/** Read `.project_root` to recover the absolute cwd for a basename folder.
- *  Returns null if missing or empty (caller treats the folder as un-mappable). */
-async function readProjectRoot(projectDir: string): Promise<string | null> {
-  try {
-    const text = await readFile(join(projectDir, ".project_root"), "utf-8");
-    const trimmed = text.trim();
-    return trimmed.length > 0 ? trimmed : null;
-  } catch {
-    return null;
-  }
-}
-
-async function scanGeminiSessions(): Promise<GeminiSessionMeta[]> {
-  const root = getGeminiTmpRoot();
-  const projectDirs = await safeReaddir(root);
-  if (!projectDirs) return [];
-
-  const out: GeminiSessionMeta[] = [];
-
-  await batchAll(
-    projectDirs
-      .filter((d) => d.isDirectory())
-      .map((d) => async () => {
-        const projectDir = join(root, d.name);
-        const cwd = await readProjectRoot(projectDir);
-        if (!cwd) return;
-
-        const chatsDir = join(projectDir, "chats");
-        const files = await safeReaddir(chatsDir);
-        if (!files) return;
-
-        for (const f of files) {
-          if (!f.isFile()) continue;
-          if (!SESSION_FILE_RE.test(f.name)) continue;
-          const filePath = join(chatsDir, f.name);
-          const mtime = await statMtime(filePath);
-          if (!mtime) continue;
-          const sessionId = extractFullSessionId(await readFirstLine(filePath));
-          out.push({ filePath, sessionFilename: f.name, cwd, fileMtime: mtime, sessionId });
-        }
-      }),
-    16,
-  );
-
-  return out;
-}
-
-/** Returns one ProjectFolder per unique cwd that has at least one session file.
- *  `name` is the encoded full-cwd slug (`encodeFolderName(cwd)`), matching the
- *  routing scheme used by the dashboard's project URL — `mergeProjectFolders`
- *  unions by `name`, and `getGeminiSessionsByEncodedName` looks up by the same
- *  slug, so every cross-CLI merge and Gemini-only project link round-trips. */
-export async function getGeminiProjects(): Promise<ProjectFolder[]> {
-  const sessions = await scanGeminiSessions();
-  const byCwd = new Map<string, { mtime: Date }>();
-  for (const s of sessions) {
-    const existing = byCwd.get(s.cwd);
-    if (!existing || s.fileMtime.getTime() > existing.mtime.getTime()) {
-      byCwd.set(s.cwd, { mtime: s.fileMtime });
-    }
-  }
-  const folders: ProjectFolder[] = [...byCwd.entries()].map(([cwd, { mtime }]) => ({
-    name: encodeFolderName(cwd),
-    path: cwd,
-    isDirectory: true,
-    lastModified: mtime,
-    lastModifiedFormatted: formatDate(mtime),
-    cli: ["gemini"],
-  }));
-  folders.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
-  return folders;
-}
-
-/** Returns SessionFile entries for the given absolute cwd. Empty if none. */
-export async function getGeminiSessionsForCwd(cwd: string): Promise<SessionFile[]> {
-  const sessions = await scanGeminiSessions();
-  const matches = sessions.filter((s) => s.cwd === cwd);
-  const files: SessionFile[] = matches.map((s) => ({
-    name: s.sessionFilename,
-    path: s.filePath,
-    lastModified: s.fileMtime,
-    lastModifiedFormatted: formatDate(s.fileMtime),
-    sessionId: s.sessionId,
-    cli: "gemini",
-  }));
-  files.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
-  return files;
-}
-
-export interface GeminiProjectByName {
-  cwd: string | null;
-  sessions: SessionFile[];
-}
-
-/**
- * Looks up Gemini sessions for a project URL slug. `decodeFolderName` is lossy
- * on cwds containing `-`, so we re-encode each session's cwd via
- * `encodeFolderName` and match in that direction. Returns both the canonical
- * cwd and the matching sessions. When two distinct cwds collapse to the same
- * encoded slug we return null to avoid mis-labeling the project.
- */
-export async function getGeminiSessionsByEncodedName(name: string): Promise<GeminiProjectByName> {
-  let metas: GeminiSessionMeta[];
-  try {
-    metas = await scanGeminiSessions();
-  } catch (error) {
-    logWarn("Failed to scan Gemini sessions:", error);
-    return { cwd: null, sessions: [] };
-  }
-  const matches = metas.filter((m) => encodeFolderName(m.cwd) === name);
-  const uniqueCwds = Array.from(new Set(matches.map((m) => m.cwd)));
-  if (uniqueCwds.length !== 1) {
-    return { cwd: null, sessions: [] };
-  }
-  const sessions = matches.map((s) => ({
-    name: s.sessionFilename,
-    path: s.filePath,
-    lastModified: s.fileMtime,
-    lastModifiedFormatted: formatDate(s.fileMtime),
-    sessionId: s.sessionId,
-    cli: "gemini" as const,
-  }));
-  sessions.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
-  return { cwd: uniqueCwds[0], sessions };
-}
-
-export const getCachedGeminiProjects = runtimeCache(getGeminiProjects, 30);
-export const getCachedGeminiSessionsByEncodedName = runtimeCache(
-  (name: string) => getGeminiSessionsByEncodedName(name),
-  30,
-  { maxSize: 50 },
-);

package/lib/gemini-sessions.ts

@@ -1,365 +0,0 @@
-/**
- * Gemini CLI session transcript discovery + JSONL parser.
- *
- * Empirically verified against gemini-cli v0.40.1:
- *
- * Session files live at
- *   `~/.gemini/tmp/<project-basename>/chats/session-<ISO-timestamp-with-dashes>-<8-hex-uuid-prefix>.jsonl`
- * with a sidecar `<file>.jsonl.tool-calls.json` of tool-call records.
- * The basename component is just the cwd's last path segment; the canonical
- * cwd lives at `~/.gemini/tmp/<project-basename>/.project_root`.
- *
- * JSONL record schema (observed):
- *   • Line 1 (metadata): `{sessionId, projectHash, startTime, lastUpdated, kind}`
- *   • Subsequent lines:
- *       `{id, timestamp, type: "user" | "assistant" | ..., content: [{text}]}`  (messages)
- *       `{$set: {lastUpdated: "..."}}`                                          (partial update)
- *
- * Parser is intentionally permissive — unknown record types degrade to
- * "system" entries; malformed lines are skipped without aborting; and the
- * loader fall-opens (returns null) on any I/O or parse failure.
- */
-import { closeSync, openSync, readFileSync, readSync, readdirSync, existsSync, statSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { join, resolve, sep } from "node:path";
-import { homedir } from "node:os";
-import { runtimeCache } from "./runtime-cache";
-import {
-  baseEntry,
-  type LogEntry,
-  type UserEntry,
-  type AssistantEntry,
-  type GenericEntry,
-  type QueueOperationEntry,
-  type ContentBlock,
-  type LogSource,
-} from "./log-entries";
-
-// ── Paths ──
-
-const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-/** Matches `session-<timestamp-of-arbitrary-shape>-<8-hex-uuid-prefix>.jsonl`.
- *  Empirically gemini-cli v0.40.1 emits minute-precision (`YYYY-MM-DDTHH-mm`),
- *  but the documented format includes seconds (`YYYY-MM-DDTHH-mm:ss`) and may
- *  evolve further. The first-line `sessionId` validation in findGeminiTranscript
- *  is the load-bearing safety check, so we accept any timestamp shape. */
-const SESSION_FILE_RE = /^session-(.+)-([0-9a-f]{8})\.jsonl$/i;
-
-/** Root directory for Gemini session state, honoring GEMINI_SESSIONS_DIR. */
-export function getGeminiSessionStateRoot(): string {
-  return process.env.GEMINI_SESSIONS_DIR
-    || join(homedir(), ".gemini", "tmp");
-}
-
-/** Reject a sessionId that isn't a UUID — defends against path traversal. */
-function isSafeSessionId(sessionId: string): boolean {
-  return UUID_RE.test(sessionId);
-}
-
-/**
- * Read up to the first newline from `path` without loading the whole file.
- * Used by `findGeminiTranscript` to inspect the JSONL metadata header on
- * candidate matches; the typical header is well under 1KB and we cap at 4KB
- * for safety so a degenerate single-line file can't blow memory.
- *
- * Returns the first line as a UTF-8 string, or null on read failure / empty
- * file. If the first 4KB contain no newline, returns whatever was read so the
- * JSON.parse caller can still attempt — JSON.parse will fail for a truncated
- * object, which findGeminiTranscript treats as a malformed-header miss.
- */
-function readFirstLineSync(path: string): string | null {
-  let fd: number;
-  try {
-    fd = openSync(path, "r");
-  } catch {
-    return null;
-  }
-  try {
-    const buf = Buffer.alloc(4096);
-    const bytesRead = readSync(fd, buf, 0, buf.length, 0);
-    if (bytesRead === 0) return null;
-    const text = buf.subarray(0, bytesRead).toString("utf-8");
-    const nl = text.indexOf("\n");
-    return nl >= 0 ? text.slice(0, nl) : text;
-  } catch {
-    return null;
-  } finally {
-    try { closeSync(fd); } catch { /* best-effort */ }
-  }
-}
-
-/**
- * Find the JSONL transcript for `sessionId`. Walks every per-project subdir's
- * `chats/` directory, matches the 8-hex prefix, and verifies the first record's
- * full `sessionId` field matches. Rejects path-traversal sessionIds and
- * verifies resolved paths stay under the root. Returns null on miss.
- */
-export function findGeminiTranscript(sessionId: string): string | null {
-  if (!isSafeSessionId(sessionId)) return null;
-  const root = resolve(getGeminiSessionStateRoot());
-  const wantPrefix = sessionId.slice(0, 8).toLowerCase();
-
-  let projectDirs: string[];
-  try {
-    projectDirs = readdirSync(root);
-  } catch {
-    return null;
-  }
-
-  for (const projectDir of projectDirs) {
-    const projectPath = resolve(root, projectDir);
-    if (!projectPath.startsWith(`${root}${sep}`)) continue;
-
-    const chatsDir = resolve(projectPath, "chats");
-    let files: string[];
-    try {
-      files = readdirSync(chatsDir);
-    } catch {
-      continue;
-    }
-
-    for (const f of files) {
-      const m = SESSION_FILE_RE.exec(f);
-      if (!m || m[2].toLowerCase() !== wantPrefix) continue;
-      const candidate = resolve(chatsDir, f);
-      if (!candidate.startsWith(`${chatsDir}${sep}`)) continue;
-      if (!existsSync(candidate)) continue;
-      // Confirm the full sessionId — the 8-hex prefix isn't unique on its own.
-      // Read only the first ~4KB so large transcripts don't bloat memory; the
-      // metadata header sits on line 1 well within that bound. The full file
-      // is re-read in getGeminiSessionLog() once we've matched.
-      const firstLine = readFirstLineSync(candidate);
-      if (!firstLine) continue;
-      try {
-        const meta = JSON.parse(firstLine) as { sessionId?: unknown };
-        if (typeof meta.sessionId === "string" && meta.sessionId.toLowerCase() === sessionId.toLowerCase()) {
-          return candidate;
-        }
-      } catch {
-        // Malformed first record — try next file.
-        continue;
-      }
-    }
-  }
-  return null;
-}
-
-// ── Parser ──
-
-interface GeminiSessionRecord {
-  // Metadata-line fields (line 1)
-  sessionId?: string;
-  projectHash?: string;
-  startTime?: string;
-  lastUpdated?: string;
-  kind?: string;
-  // Message-line fields
-  id?: string;
-  timestamp?: string;
-  type?: string;
-  content?: Array<Record<string, unknown>>;
-  // Partial-update line: `{$set: {...}}`
-  $set?: Record<string, unknown>;
-}
-
-interface GeminiParseResult {
-  entries: LogEntry[];
-  rawLines: Record<string, unknown>[];
-  /** Working directory pulled from the sidecar `.project_root` if available. */
-  cwd?: string;
-}
-
-function extractMessageText(content: Array<Record<string, unknown>> | undefined): string {
-  if (!Array.isArray(content)) return "";
-  const parts: string[] = [];
-  for (const block of content) {
-    if (typeof block?.text === "string") parts.push(block.text);
-  }
-  return parts.join("\n\n");
-}
-
-function buildAssistantContent(content: Array<Record<string, unknown>> | undefined): ContentBlock[] {
-  if (!Array.isArray(content)) return [];
-  const blocks: ContentBlock[] = [];
-  for (const block of content) {
-    if (typeof block?.text === "string" && block.text.length > 0) {
-      blocks.push({ type: "text", text: block.text });
-    }
-  }
-  return blocks;
-}
-
-/**
- * Parse a Gemini JSONL transcript into `LogEntry[]` plus the raw lines.
- * Yields to the event loop every 200 lines so big transcripts don't block
- * the request.
- */
-export async function parseGeminiLog(
-  fileContent: string,
-  source: LogSource = "session",
-  cwdHint?: string,
-): Promise<GeminiParseResult> {
-  const lines = fileContent.split("\n").filter((line) => line.trim() !== "");
-  const entries: LogEntry[] = [];
-  const rawLines: Record<string, unknown>[] = [];
-  let cwd: string | undefined = cwdHint;
-  let seenStart = false;
-
-  for (let i = 0; i < lines.length; i++) {
-    if (i > 0 && i % 200 === 0) await new Promise<void>((r) => setImmediate(r));
-
-    const line = lines[i];
-    let raw: GeminiSessionRecord;
-    try {
-      raw = JSON.parse(line) as GeminiSessionRecord;
-    } catch {
-      continue;
-    }
-
-    const rawCopy = { ...(raw as Record<string, unknown>), _source: source };
-    rawLines.push(rawCopy);
-
-    // Metadata line — derive a synthetic "Session Started" entry from startTime.
-    if (typeof raw.sessionId === "string" && typeof raw.startTime === "string") {
-      const date = new Date(raw.startTime);
-      if (!Number.isNaN(date.getTime())) {
-        const label: QueueOperationEntry["label"] = seenStart ? "Session Resumed" : "Session Started";
-        seenStart = true;
-        entries.push({
-          type: "queue-operation",
-          ...baseEntry(rawCopy, date.toISOString(), date, source),
-          label,
-        } satisfies QueueOperationEntry);
-      }
-      continue;
-    }
-
-    // Partial-update line — preserve in raw but skip rendering.
-    if (raw.$set) continue;
-
-    const timestampStr = raw.timestamp;
-    if (!timestampStr) continue;
-    const date = new Date(timestampStr);
-    if (Number.isNaN(date.getTime())) continue;
-    const timestamp = date.toISOString();
-
-    const recType = raw.type;
-
-    if (recType === "user") {
-      const text = extractMessageText(raw.content);
-      if (!text) continue;
-      entries.push({
-        type: "user",
-        ...baseEntry(rawCopy, timestamp, date, source),
-        message: { role: "user", content: text },
-      } satisfies UserEntry);
-      continue;
-    }
-
-    if (recType === "assistant" || recType === "model") {
-      const blocks = buildAssistantContent(raw.content);
-      if (blocks.length === 0) {
-        entries.push({
-          type: "system",
-          ...baseEntry(rawCopy, timestamp, date, source),
-          raw: rawCopy,
-        } satisfies GenericEntry);
-        continue;
-      }
-      entries.push({
-        type: "assistant",
-        ...baseEntry(rawCopy, timestamp, date, source),
-        message: { role: "assistant", content: blocks },
-      } satisfies AssistantEntry);
-      continue;
-    }
-
-    // Unknown type — preserve raw.
-    entries.push({
-      type: "system",
-      ...baseEntry(rawCopy, timestamp, date, source),
-      raw: rawCopy,
-    } satisfies GenericEntry);
-  }
-
-  if (entries.length > 500) await new Promise<void>((r) => setImmediate(r));
-  entries.sort((a, b) => a.timestampMs - b.timestampMs);
-
-  return { entries, rawLines, cwd };
-}
-
-// ── Public loader ──
-
-export interface GeminiSessionLogData {
-  entries: LogEntry[];
-  rawLines: Record<string, unknown>[];
-  cwd?: string;
-  filePath: string;
-}
-
-/** Read `.project_root` next to the chats dir to recover the absolute cwd. */
-function readSiblingProjectRoot(transcriptPath: string): string | undefined {
-  // transcriptPath = .../<basename>/chats/<file>.jsonl
-  const chatsDir = resolve(transcriptPath, "..");
-  const projectDir = resolve(chatsDir, "..");
-  const rootFile = join(projectDir, ".project_root");
-  try {
-    const text = readFileSync(rootFile, "utf-8").trim();
-    return text.length > 0 ? text : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-export async function getGeminiSessionLog(sessionId: string): Promise<GeminiSessionLogData | null> {
-  const filePath = findGeminiTranscript(sessionId);
-  if (!filePath) return null;
-  let fileContent: string;
-  try {
-    fileContent = await readFile(filePath, "utf-8");
-  } catch {
-    return null;
-  }
-  const cwdHint = readSiblingProjectRoot(filePath);
-  let parsed: GeminiParseResult;
-  try {
-    parsed = await parseGeminiLog(fileContent, "session", cwdHint);
-  } catch {
-    return null;
-  }
-  return {
-    entries: parsed.entries,
-    rawLines: parsed.rawLines,
-    cwd: parsed.cwd,
-    filePath,
-  };
-}
-
-export const getCachedGeminiSessionLog = runtimeCache(
-  (sessionId: string) => getGeminiSessionLog(sessionId),
-  60,
-  { maxSize: 50 },
-);
-
-// ── Test helpers ──
-
-export function _statGeminiTranscript(sessionId: string): { mtimeMs: number } | null {
-  const path = findGeminiTranscript(sessionId);
-  if (!path) return null;
-  try {
-    const s = statSync(path);
-    return { mtimeMs: s.mtimeMs };
-  } catch {
-    return null;
-  }
-}
-
-export function readGeminiTranscriptSync(sessionId: string): string | null {
-  const path = findGeminiTranscript(sessionId);
-  if (!path) return null;
-  try {
-    return readFileSync(path, "utf-8");
-  } catch {
-    return null;
-  }
-}

package/src/audit/cli-adapters/gemini.ts

@@ -1,51 +0,0 @@
-/**
- * Gemini CLI transcript adapter.
- */
-import { statSync } from "node:fs";
-import { getGeminiProjects, getGeminiSessionsByEncodedName } from "../../../lib/gemini-projects";
-import { getGeminiSessionLog } from "../../../lib/gemini-sessions";
-import type { NormalizedToolEvent, TranscriptMetadata } from "../types";
-import type { ListOpts } from "./claude";
-import { logEntriesToEvents } from "./shared";
-
-export async function listGeminiTranscriptMetadata(
-  opts: ListOpts = {},
-): Promise<TranscriptMetadata[]> {
-  const projectFilter = opts.projects ? new Set(opts.projects) : null;
-  const sinceMs = opts.sinceMs ?? 0;
-  const out: TranscriptMetadata[] = [];
-
-  const projects = await getGeminiProjects();
-  for (const project of projects) {
-    const { cwd, sessions } = await getGeminiSessionsByEncodedName(project.name);
-    const effectiveCwd = cwd ?? "";
-    if (projectFilter && !projectFilter.has(effectiveCwd)) continue;
-    for (const s of sessions) {
-      const mtimeMs = s.lastModified.getTime();
-      if (mtimeMs < sinceMs) continue;
-      let sizeBytes = 0;
-      try { sizeBytes = statSync(s.path).size; } catch { /* unreadable */ }
-      if (!s.sessionId) continue;
-      out.push({
-        cli: "gemini",
-        projectName: project.name,
-        sessionId: s.sessionId,
-        transcriptPath: s.path,
-        mtimeMs,
-        sizeBytes,
-      });
-    }
-  }
-  return out;
-}
-
-export async function streamGeminiEvents(meta: TranscriptMetadata): Promise<NormalizedToolEvent[]> {
-  const log = await getGeminiSessionLog(meta.sessionId);
-  if (!log) return [];
-  return logEntriesToEvents(log.entries, {
-    cli: "gemini",
-    sessionId: meta.sessionId,
-    transcriptPath: meta.transcriptPath,
-    cwd: log.cwd ?? "",
-  });
-}