failproofai 0.0.13 → 0.0.14-beta.1

package/lib/antigravity-projects.ts

@@ -0,0 +1,224 @@
+/**
+ * Antigravity (agy) project discovery + session enumeration — AUDIT-ONLY.
+ *
+ * Antigravity keeps a SQLite index of conversations at
+ * `~/.gemini/antigravity-cli/conversation_summaries.db` (table
+ * `conversation_summaries`: conversation_id, title, preview, step_count,
+ * workspace_uris, project_id, last_modified_time, agent_name, …) and one
+ * plain-JSONL transcript per conversation under `brain/<id>/…`. Verified live
+ * against agy v1.1.2.
+ *
+ * The on-disk `brain/` transcripts are the source of truth for a conversation's
+ * EXISTENCE (the summaries DB can lag / be checkpointed empty), so we enumerate
+ * from disk (lib/antigravity-sessions.ts) and ENRICH each with title + cwd from
+ * the SQLite index when a row is present. `workspace_uris` gives the project cwd
+ * → per-project grouping; when absent we recover cwd from the transcript's first
+ * `run_command` Cwd, else fall back to a synthetic "antigravity" project.
+ *
+ * DB / home override: set `ANTIGRAVITY_HOME` (used by tests).
+ */
+import { join } from "node:path";
+import { openSqliteReadonly } from "./sqlite-reader";
+import {
+  antigravityHome,
+  listAntigravityTranscripts,
+  getAntigravitySessionLog,
+} from "./antigravity-sessions";
+import { runtimeCache } from "./runtime-cache";
+import type { ProjectFolder, SessionFile } from "./projects";
+import { encodeFolderName, decodeFolderName } from "./paths";
+import { formatDate } from "./format-date";
+import { logWarn } from "./logger";
+
+/** Absolute path to the conversation-index SQLite DB. */
+export function antigravitySummariesDbPath(): string {
+  return join(antigravityHome(), "conversation_summaries.db");
+}
+
+interface SummaryRow {
+  conversation_id: string;
+  title: string | null;
+  step_count: number | null;
+  workspace_uris: string | null;
+  last_modified_time: string | number | null;
+}
+
+export interface AntigravityIndexMeta {
+  title?: string;
+  cwd?: string;
+  stepCount?: number;
+  lastMs?: number;
+}
+
+/** Parse the first workspace URI (a JSON array, or a plain string) into a cwd,
+ *  stripping any `file://` scheme. */
+function parseWorkspaceCwd(raw: string | null): string | undefined {
+  if (!raw) return undefined;
+  let first: string | undefined;
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed) && typeof parsed[0] === "string") first = parsed[0];
+    else if (typeof parsed === "string") first = parsed;
+  } catch {
+    first = raw;
+  }
+  if (!first) return undefined;
+  const stripped = first.replace(/^file:\/\//, "");
+  return stripped.length > 0 ? stripped : undefined;
+}
+
+function toMs(value: string | number | null): number | undefined {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value > 1e12 ? value : value > 1e9 ? value * 1000 : undefined;
+  }
+  if (typeof value === "string") {
+    const ms = Date.parse(value);
+    if (!Number.isNaN(ms)) return ms;
+  }
+  return undefined;
+}
+
+/** Read the conversation index → conversationId → metadata. Returns an empty
+ *  map when the DB is missing/unreadable/empty (fail-open). */
+export async function getAntigravityIndex(): Promise<Map<string, AntigravityIndexMeta>> {
+  const out = new Map<string, AntigravityIndexMeta>();
+  const db = await openSqliteReadonly(antigravitySummariesDbPath());
+  if (!db) return out;
+  try {
+    const rows = db.query<SummaryRow>(
+      "SELECT conversation_id, title, step_count, workspace_uris, last_modified_time FROM conversation_summaries",
+    );
+    for (const r of rows) {
+      if (!r.conversation_id) continue;
+      out.set(r.conversation_id, {
+        title: r.title ?? undefined,
+        cwd: parseWorkspaceCwd(r.workspace_uris),
+        stepCount: typeof r.step_count === "number" ? r.step_count : undefined,
+        lastMs: toMs(r.last_modified_time),
+      });
+    }
+  } catch {
+    // corrupt / unexpected schema — fall open with whatever we have
+  } finally {
+    db.close();
+  }
+  return out;
+}
+
+interface AntigravityConversation {
+  conversationId: string;
+  cwd: string | null;
+  title?: string;
+  mtimeMs: number;
+}
+
+/** Resolve every on-disk conversation to {cwd, title, mtime}, enriched from the
+ *  SQLite index (cwd/title/lastMs) and, when the index lacks a cwd, from the
+ *  transcript's first run_command Cwd. */
+async function resolveConversations(): Promise<AntigravityConversation[]> {
+  let transcripts;
+  try {
+    transcripts = listAntigravityTranscripts();
+  } catch (error) {
+    logWarn("Failed to scan Antigravity brain dir:", error);
+    return [];
+  }
+  const index = await getAntigravityIndex();
+
+  const out: AntigravityConversation[] = [];
+  for (const t of transcripts) {
+    const meta = index.get(t.conversationId);
+    let cwd = meta?.cwd ?? null;
+    if (!cwd) {
+      // No index cwd — recover it from the transcript itself (best-effort).
+      try {
+        const log = await getAntigravitySessionLog(t.conversationId);
+        cwd = log?.cwd ?? null;
+      } catch {
+        cwd = null;
+      }
+    }
+    out.push({
+      conversationId: t.conversationId,
+      cwd,
+      title: meta?.title,
+      mtimeMs: meta?.lastMs ?? t.mtimeMs,
+    });
+  }
+  return out;
+}
+
+/** Synthetic project name for conversations whose cwd could not be resolved. */
+const ANTIGRAVITY_UNGROUPED = "antigravity";
+
+/** Returns one ProjectFolder per resolved cwd (grouped), plus a synthetic
+ *  "antigravity" project for conversations without a cwd. */
+export async function getAntigravityProjects(): Promise<ProjectFolder[]> {
+  const conversations = await resolveConversations();
+
+  const byName = new Map<string, { latest: number; path: string }>();
+  for (const c of conversations) {
+    const name = c.cwd ? encodeFolderName(c.cwd) : ANTIGRAVITY_UNGROUPED;
+    const path = c.cwd ?? "antigravity";
+    const existing = byName.get(name);
+    if (!existing || c.mtimeMs > existing.latest) {
+      byName.set(name, { latest: c.mtimeMs, path });
+    }
+  }
+
+  const folders: ProjectFolder[] = [];
+  for (const [name, { latest, path }] of byName) {
+    const lastModified = new Date(latest);
+    folders.push({
+      name,
+      path,
+      isDirectory: true,
+      lastModified,
+      lastModifiedFormatted: formatDate(lastModified),
+      cli: ["antigravity"],
+    });
+  }
+  folders.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return folders;
+}
+
+export interface AntigravityProjectByName {
+  cwd: string | null;
+  sessions: SessionFile[];
+}
+
+/** Resolve the Antigravity conversations for a project URL slug (an encoded-cwd
+ *  folder name, or the synthetic "antigravity" bucket). */
+export async function getAntigravitySessionsByEncodedName(
+  name: string,
+): Promise<AntigravityProjectByName> {
+  const conversations = await resolveConversations();
+  const matched = conversations.filter((c) => {
+    const encoded = c.cwd ? encodeFolderName(c.cwd) : ANTIGRAVITY_UNGROUPED;
+    return encoded === name;
+  });
+  if (matched.length === 0) return { cwd: null, sessions: [] };
+
+  const sorted = [...matched].sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const cwd = sorted.find((c) => c.cwd)?.cwd ?? (name === ANTIGRAVITY_UNGROUPED ? null : decodeFolderName(name));
+
+  const sessions: SessionFile[] = sorted.map((c) => {
+    const lastModified = new Date(c.mtimeMs);
+    return {
+      name: c.title ?? c.conversationId,
+      path: `antigravity://${c.conversationId}`,
+      lastModified,
+      lastModifiedFormatted: formatDate(lastModified),
+      sessionId: c.conversationId,
+      cli: "antigravity" as const,
+    };
+  });
+  return { cwd, sessions };
+}
+
+export const getCachedAntigravityProjects = runtimeCache(getAntigravityProjects, 30);
+export const getCachedAntigravitySessionsByEncodedName = runtimeCache(
+  (name: string) => getAntigravitySessionsByEncodedName(name),
+  30,
+  { maxSize: 50 },
+);

package/lib/antigravity-sessions.ts

@@ -0,0 +1,283 @@
+/**
+ * Antigravity (agy) session transcript loader + parser.
+ *
+ * AUDIT-ONLY (Pillar 2). Antigravity writes one plain-JSONL transcript per
+ * conversation at
+ * `~/.gemini/antigravity-cli/brain/<conversationId>/.system_generated/logs/transcript_full.jsonl`
+ * (one step per line). Verified live against agy v1.1.2. Sibling
+ * `<conversationId>.trajectory.jsonl` / `.trajectory-path.json` files are
+ * IGNORED — we only read `transcript_full.jsonl`.
+ *
+ * Each transcript line is a step:
+ *   {step_index, source, type, status, created_at, content?, tool_calls?}
+ * The `type` enum (uppercase) drives parsing:
+ *   • USER_INPUT           — content = user text
+ *   • PLANNER_RESPONSE      — content = assistant text, OR tool_calls =
+ *                             [{name:"run_command", args:{CommandLine, Cwd, …}}]
+ *   • <TOOL_STEP> (e.g. RUN_COMMAND) — content = the tool result string; the
+ *                             `type` is the uppercased tool name, so we pair it
+ *                             with the preceding PLANNER_RESPONSE tool_call of
+ *                             the same name.
+ *   • CONVERSATION_HISTORY / CHECKPOINT — metadata (skipped).
+ *
+ * `antigravityLinesToLogEntries` is PURE (a function of the parsed line
+ * objects), so it is unit-testable without touching disk.
+ *
+ * Home override: set `ANTIGRAVITY_HOME` (used by tests / to point at a copied
+ * brain dir). Default: `~/.gemini/antigravity-cli`.
+ */
+import { readFile } from "node:fs/promises";
+import { readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { runtimeCache } from "./runtime-cache";
+import {
+  baseEntry,
+  formatTimestamp,
+  parseRawLines,
+  type LogEntry,
+  type UserEntry,
+  type AssistantEntry,
+  type GenericEntry,
+  type ContentBlock,
+  type ToolUseBlock,
+  type LogSource,
+} from "./log-entries";
+import { formatDuration } from "./format-duration";
+
+/** Antigravity conversations are UUID-named directories. */
+export const ANTIGRAVITY_CONVERSATION_ID_RE =
+  /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+
+/** Step `type` values that are metadata, not turns. */
+const ANTIGRAVITY_META_STEP_TYPES = new Set(["CONVERSATION_HISTORY", "CHECKPOINT"]);
+
+/** Absolute path to Antigravity's config home (override with ANTIGRAVITY_HOME). */
+export function antigravityHome(): string {
+  return process.env.ANTIGRAVITY_HOME || join(homedir(), ".gemini", "antigravity-cli");
+}
+
+/** Absolute path to the `brain/` root (one subdir per conversation). */
+export function antigravityBrainRoot(): string {
+  return join(antigravityHome(), "brain");
+}
+
+/** Relative path of a conversation's full transcript inside its brain dir. */
+export function antigravityTranscriptRelPath(): string {
+  return join(".system_generated", "logs", "transcript_full.jsonl");
+}
+
+// ── Parsing helpers ──
+
+function isPlainObject(v: unknown): v is Record<string, unknown> {
+  return !!v && typeof v === "object" && !Array.isArray(v);
+}
+
+function toDate(value: unknown, fallbackMs: number): Date {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    if (value > 1e12) return new Date(value);
+    if (value > 1e9) return new Date(value * 1000);
+  }
+  if (typeof value === "string") {
+    const ms = Date.parse(value);
+    if (!Number.isNaN(ms)) return new Date(ms);
+  }
+  return new Date(fallbackMs);
+}
+
+// ── Pure parser: transcript lines → LogEntry[] ──
+
+/**
+ * Convert Antigravity transcript JSONL lines (parsed objects, in file order)
+ * into `LogEntry[]`. USER_INPUT → user turns; PLANNER_RESPONSE → assistant
+ * turns (text and/or `tool_use` blocks); a following tool-result step
+ * (type === uppercased tool name, e.g. RUN_COMMAND) is paired back onto the
+ * matching `tool_use` block. Metadata steps (CONVERSATION_HISTORY, CHECKPOINT)
+ * are skipped. Pure — unit-testable with plain line objects.
+ */
+export function antigravityLinesToLogEntries(
+  lines: Record<string, unknown>[],
+  source: LogSource = "session",
+): LogEntry[] {
+  const entries: LogEntry[] = [];
+  // FIFO of pending tool_use blocks keyed by uppercased tool name, so a later
+  // RUN_COMMAND-type result step attaches to the right run_command call.
+  const pendingByType = new Map<string, Array<{ block: ToolUseBlock; startMs: number }>>();
+  const baseMs = Date.now();
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!isPlainObject(line)) continue;
+    const type = typeof line.type === "string" ? line.type : "";
+    if (!type || ANTIGRAVITY_META_STEP_TYPES.has(type)) continue;
+
+    const date = toDate(line.created_at, baseMs + i);
+    const timestamp = date.toISOString();
+    const stepIndex = typeof line.step_index === "number" ? line.step_index : i;
+    const raw: Record<string, unknown> = {
+      uuid: `antigravity-${stepIndex}`,
+      parentUuid: null,
+    };
+    const base = baseEntry(raw, timestamp, date, source);
+
+    if (type === "USER_INPUT") {
+      const text = typeof line.content === "string" ? line.content : "";
+      entries.push({
+        type: "user",
+        ...base,
+        message: { role: "user", content: text },
+      } satisfies UserEntry);
+      continue;
+    }
+
+    if (type === "PLANNER_RESPONSE") {
+      const blocks: ContentBlock[] = [];
+      if (typeof line.content === "string" && line.content.length > 0) {
+        blocks.push({ type: "text", text: line.content });
+      }
+      if (Array.isArray(line.tool_calls)) {
+        for (let j = 0; j < line.tool_calls.length; j++) {
+          const call = line.tool_calls[j];
+          if (!isPlainObject(call)) continue;
+          const name = typeof call.name === "string" ? call.name : "tool";
+          const input = isPlainObject(call.args) ? call.args : {};
+          const id = `${name}-${stepIndex}-${j}`;
+          const block: ToolUseBlock = { type: "tool_use", id, name, input };
+          blocks.push(block);
+          const key = name.toUpperCase();
+          const queue = pendingByType.get(key) ?? [];
+          queue.push({ block, startMs: date.getTime() });
+          pendingByType.set(key, queue);
+        }
+      }
+      if (blocks.length === 0) continue;
+      entries.push({
+        type: "assistant",
+        ...base,
+        message: { role: "assistant", content: blocks },
+      } satisfies AssistantEntry);
+      continue;
+    }
+
+    // Any other step type is a tool-result step whose `type` is the uppercased
+    // tool name (e.g. RUN_COMMAND for a run_command call). Pair it back onto the
+    // oldest matching pending tool_use block.
+    const queue = pendingByType.get(type);
+    if (queue && queue.length > 0) {
+      const { block, startMs } = queue.shift()!;
+      const durationMs = Math.max(0, date.getTime() - startMs);
+      block.result = {
+        timestamp,
+        timestampFormatted: formatTimestamp(date),
+        content: typeof line.content === "string" ? line.content : "",
+        durationMs,
+        durationFormatted: formatDuration(durationMs),
+      };
+      continue;
+    }
+    // Unpaired non-meta step — record as generic so nothing is silently lost.
+    entries.push({ type: "system", ...base, raw } satisfies GenericEntry);
+  }
+
+  entries.sort((a, b) => a.timestampMs - b.timestampMs);
+  return entries;
+}
+
+/** Best-effort cwd recovery: the first `run_command` tool_call's `Cwd` arg. */
+function recoverCwd(lines: Record<string, unknown>[]): string | undefined {
+  for (const line of lines) {
+    if (!isPlainObject(line) || !Array.isArray(line.tool_calls)) continue;
+    for (const call of line.tool_calls) {
+      if (!isPlainObject(call) || !isPlainObject(call.args)) continue;
+      const cwd = call.args.Cwd ?? call.args.cwd;
+      if (typeof cwd === "string" && cwd.length > 0) return cwd;
+    }
+  }
+  return undefined;
+}
+
+// ── Discovery + file loader ──
+
+export interface AntigravityTranscriptFile {
+  conversationId: string;
+  transcriptPath: string;
+  mtimeMs: number;
+  sizeBytes: number;
+}
+
+/** Enumerate `brain/<conversationId>/.system_generated/logs/transcript_full.jsonl`
+ *  transcripts. Skips conversation dirs without a full transcript. */
+export function listAntigravityTranscripts(): AntigravityTranscriptFile[] {
+  const root = antigravityBrainRoot();
+  const rel = antigravityTranscriptRelPath();
+  const out: AntigravityTranscriptFile[] = [];
+  let convoDirs: import("node:fs").Dirent[];
+  try {
+    convoDirs = readdirSync(root, { withFileTypes: true }).filter((d) => d.isDirectory());
+  } catch {
+    return out;
+  }
+  for (const dir of convoDirs) {
+    const conversationId = dir.name;
+    if (!ANTIGRAVITY_CONVERSATION_ID_RE.test(conversationId)) continue;
+    const transcriptPath = join(root, conversationId, rel);
+    try {
+      const st = statSync(transcriptPath);
+      if (!st.isFile()) continue;
+      out.push({ conversationId, transcriptPath, mtimeMs: st.mtimeMs, sizeBytes: st.size });
+    } catch {
+      // no full transcript for this conversation yet — skip
+    }
+  }
+  return out;
+}
+
+/** Resolve a conversation UUID to its on-disk transcript path (host-side).
+ *  Guards against traversal by requiring a UUID. Shared by the audit adapter,
+ *  the hook transcript resolver, and download-session. Synchronous. */
+export function findAntigravityTranscript(conversationId: string): string | null {
+  if (!ANTIGRAVITY_CONVERSATION_ID_RE.test(conversationId)) return null;
+  const transcriptPath = join(
+    antigravityBrainRoot(),
+    conversationId,
+    antigravityTranscriptRelPath(),
+  );
+  try {
+    if (statSync(transcriptPath).isFile()) return transcriptPath;
+  } catch {
+    // fall through
+  }
+  return null;
+}
+
+export interface AntigravitySessionLogData {
+  entries: LogEntry[];
+  rawLines: Record<string, unknown>[];
+  cwd?: string;
+  filePath: string;
+}
+
+/** Load and parse one conversation transcript by UUID. Returns `null` when the
+ *  file is missing/unreadable or the id fails validation. */
+export async function getAntigravitySessionLog(
+  conversationId: string,
+): Promise<AntigravitySessionLogData | null> {
+  const filePath = findAntigravityTranscript(conversationId);
+  if (!filePath) return null;
+  let content: string;
+  try {
+    content = await readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const rawLines = parseRawLines(content, "session");
+  const entries = antigravityLinesToLogEntries(rawLines, "session");
+  const cwd = recoverCwd(rawLines);
+  return { entries, rawLines, cwd, filePath };
+}
+
+export const getCachedAntigravitySessionLog = runtimeCache(
+  (conversationId: string) => getAntigravitySessionLog(conversationId),
+  60,
+  { maxSize: 50 },
+);

package/lib/cli-registry.ts

@@ -27,7 +27,7 @@
 import type { IntegrationType } from "@/src/hooks/types";
 
 /** Canonical CLI ids the registry knows about. Mirrors `INTEGRATION_TYPES`. */
-export const KNOWN_CLI_IDS = ["claude", "codex", "copilot", "cursor", "opencode", "pi", "gemini", "hermes"] as const satisfies readonly IntegrationType[];
+export const KNOWN_CLI_IDS = ["claude", "codex", "copilot", "cursor", "opencode", "pi", "hermes", "openclaw", "factory", "devin", "antigravity", "goose"] as const satisfies readonly IntegrationType[];
 export type CliId = (typeof KNOWN_CLI_IDS)[number];
 
 /** Per-CLI metadata consumed by the dashboard. */
@@ -69,16 +69,36 @@ const CLI_ENTRIES: Record<CliId, CliEntry> = {
     label: "Pi",
     badgeClasses: "bg-pink-500/10 text-pink-400 border-pink-500/20",
   },
-  gemini: {
-    id: "gemini",
-    label: "Gemini CLI",
-    badgeClasses: "bg-sky-500/10 text-sky-400 border-sky-500/20",
-  },
   hermes: {
     id: "hermes",
     label: "Hermes",
     badgeClasses: "bg-indigo-500/10 text-indigo-400 border-indigo-500/20",
   },
+  openclaw: {
+    id: "openclaw",
+    label: "OpenClaw",
+    badgeClasses: "bg-teal-500/10 text-teal-400 border-teal-500/20",
+  },
+  factory: {
+    id: "factory",
+    label: "Factory Droid",
+    badgeClasses: "bg-rose-500/10 text-rose-400 border-rose-500/20",
+  },
+  devin: {
+    id: "devin",
+    label: "Devin CLI",
+    badgeClasses: "bg-violet-500/10 text-violet-400 border-violet-500/20",
+  },
+  antigravity: {
+    id: "antigravity",
+    label: "Antigravity CLI",
+    badgeClasses: "bg-cyan-500/10 text-cyan-400 border-cyan-500/20",
+  },
+  goose: {
+    id: "goose",
+    label: "Goose",
+    badgeClasses: "bg-lime-500/10 text-lime-400 border-lime-500/20",
+  },
 };
 
 export function getCliEntry(id: string): CliEntry | undefined {

package/lib/devin-projects.ts

@@ -0,0 +1,141 @@
+/**
+ * Devin CLI (Cognition) session enumeration — AUDIT-ONLY.
+ *
+ * Reads the `sessions` table directly from `~/.local/share/devin/cli/sessions.db`
+ * via the bundled sql.js reader. Unlike Hermes (cwd-less, grouped by channel),
+ * each Devin session carries a real `working_directory`, so Devin sessions group
+ * by project cwd like Claude/Factory — one `ProjectFolder` per encoded cwd, and
+ * a cwd present in both Claude and Devin stores merges on the shared encoded
+ * slug (see `mergeProjectFolders` in lib/projects.ts).
+ */
+import { openSqliteReadonly } from "./sqlite-reader";
+import { devinDbPath, devinEpochToMs } from "./devin-sessions";
+import { encodeFolderName } from "./paths";
+import { runtimeCache } from "./runtime-cache";
+import type { ProjectFolder, SessionFile } from "./projects";
+import { formatDate } from "./format-date";
+
+export interface DevinSessionRef {
+  sessionId: string;
+  cwd?: string;
+  title?: string;
+  /** Encoded-cwd folder slug (matches Claude's `-home-user-project` scheme). */
+  projectName: string;
+  /** From `last_activity_at` (falls back to `created_at`) — epoch ms. */
+  mtimeMs: number;
+}
+
+interface SessionRow {
+  id: string;
+  working_directory: string | null;
+  title: string | null;
+  created_at: number | null;
+  last_activity_at: number | null;
+  hidden: number | null;
+}
+
+/**
+ * List every Devin session. Returns `[]` when the DB is missing or unreadable
+ * (fail-open — the audit just skips Devin). Hidden sessions are excluded.
+ */
+export async function getDevinSessions(): Promise<DevinSessionRef[]> {
+  const db = await openSqliteReadonly(devinDbPath());
+  if (!db) return [];
+  try {
+    const rows = db.query<SessionRow>(
+      "SELECT id, working_directory, title, created_at, last_activity_at, hidden " +
+        "FROM sessions ORDER BY last_activity_at DESC",
+    );
+    return rows
+      .filter((r) => !r.hidden)
+      .map((r) => {
+        const cwd = r.working_directory ?? undefined;
+        return {
+          sessionId: r.id,
+          cwd,
+          title: r.title ?? undefined,
+          projectName: cwd ? encodeFolderName(cwd) : "devin",
+          mtimeMs: devinEpochToMs(r.last_activity_at ?? r.created_at),
+        };
+      });
+  } catch {
+    return [];
+  } finally {
+    db.close();
+  }
+}
+
+export const getCachedDevinSessions = runtimeCache(getDevinSessions, 2);
+
+// ── Dashboard history browser (projects list + project-detail sessions) ──
+
+/** One `ProjectFolder` per encoded-cwd discovered in the Devin DB. */
+export async function getDevinProjects(): Promise<ProjectFolder[]> {
+  const sessions = await getDevinSessions();
+  const byName = new Map<string, { latest: number; cwd: string; name: string }>();
+  for (const s of sessions) {
+    if (!s.cwd) continue;
+    const existing = byName.get(s.projectName);
+    if (!existing || s.mtimeMs > existing.latest) {
+      byName.set(s.projectName, { latest: s.mtimeMs, cwd: s.cwd, name: s.projectName });
+    }
+  }
+  const folders: ProjectFolder[] = [];
+  for (const { name, cwd, latest } of byName.values()) {
+    const lastModified = new Date(latest);
+    folders.push({
+      name,
+      path: cwd,
+      isDirectory: true,
+      lastModified,
+      lastModifiedFormatted: formatDate(lastModified),
+      cli: ["devin"],
+    });
+  }
+  folders.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return folders;
+}
+
+export interface DevinProjectByName {
+  /** Canonical cwd recovered from the session's `working_directory`. */
+  cwd: string | null;
+  sessions: SessionFile[];
+}
+
+/**
+ * Resolve the Devin sessions for a project URL slug (the encoded-cwd folder
+ * name). Because Devin's `working_directory` re-encodes to the same slug Claude
+ * uses, the slug matches directly and the canonical cwd is the session's real
+ * `working_directory` (no lossy folder-decode needed).
+ */
+export async function getDevinSessionsByEncodedName(
+  name: string,
+): Promise<DevinProjectByName> {
+  const sessions = await getDevinSessions();
+  const matched = sessions.filter((s) => s.cwd && s.projectName === name);
+  if (matched.length === 0) return { cwd: null, sessions: [] };
+
+  const sorted = [...matched].sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const cwd = sorted[0].cwd ?? null;
+  return {
+    cwd,
+    sessions: sorted.map((s) => {
+      const lastModified = new Date(s.mtimeMs);
+      return {
+        name: s.title ?? s.sessionId,
+        path: `devin-db://${s.sessionId}`,
+        lastModified,
+        lastModifiedFormatted: formatDate(lastModified),
+        sessionId: s.sessionId,
+        cli: "devin" as const,
+      };
+    }),
+  };
+}
+
+export const getCachedDevinProjects = runtimeCache(getDevinProjects, 2);
+export const getCachedDevinSessionsByEncodedName = runtimeCache(
+  (name: string) => getDevinSessionsByEncodedName(name),
+  2,
+  { maxSize: 50 },
+);