failproofai 0.0.13 → 0.0.14-beta.1

package/.next/standalone/lib/devin-sessions.ts

@@ -0,0 +1,343 @@
+/**
+ * Devin CLI (Cognition) session transcript loader + parser.
+ *
+ * AUDIT-ONLY (Pillar 2). Devin stores every session in one SQLite DB at
+ * `~/.local/share/devin/cli/sessions.db`. We read it DIRECTLY via the bundled
+ * sql.js driver (lib/sqlite-reader.ts) — the same reusable path Hermes/OpenClaw
+ * use. Unlike Hermes (which is cwd-less), each Devin `sessions` row carries a
+ * real `working_directory`, so Devin sessions group by project cwd like Claude.
+ *
+ * Schema (verified live against devin v3000.1.27):
+ *   sessions(id, working_directory, backend_type, model, agent_mode,
+ *            created_at INT, last_activity_at INT, title, workspace_dirs, metadata)
+ *   message_nodes(row_id, session_id, node_id, parent_node_id,
+ *            chat_message TEXT=JSON, created_at INT, metadata)
+ *
+ * `chat_message` is OpenAI-style JSON: `{role, content, tool_calls?,
+ * tool_call_id?, thinking?, metadata?}`. Assistant tool calls are flat
+ * `tool_calls[].{id, name, arguments}` (arguments is already an object, NOT a
+ * JSON string as in the OpenAI wire format), and results are separate
+ * `role:"tool"` rows keyed by `tool_call_id`. `devinRowsToLogEntries` pairs them
+ * (mirrors lib/hermes-sessions.ts) and is a PURE function of the parsed message
+ * objects, so it is unit-testable without a DB.
+ *
+ * Home override: set `DEVIN_HOME` (used by tests / to point at a copied Devin
+ * data dir) or `DEVIN_DB_PATH` (points directly at a sessions.db).
+ */
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { openSqliteReadonly } from "./sqlite-reader";
+import { runtimeCache } from "./runtime-cache";
+import {
+  baseEntry,
+  formatTimestamp,
+  type LogEntry,
+  type UserEntry,
+  type AssistantEntry,
+  type GenericEntry,
+  type ContentBlock,
+  type ToolUseBlock,
+  type LogSource,
+} from "./log-entries";
+import { formatDuration } from "./format-duration";
+
+/** Devin session IDs are word-slug style (e.g. `estimated-seeker`). */
+export const DEVIN_SESSION_ID_RE = /^[A-Za-z0-9_-]+$/;
+
+/** Absolute path to Devin's data home (override with DEVIN_HOME). */
+export function devinHome(): string {
+  return process.env.DEVIN_HOME || join(homedir(), ".local", "share", "devin");
+}
+
+/** Absolute path to Devin's SQLite DB (override with DEVIN_DB_PATH). */
+export function devinDbPath(): string {
+  return process.env.DEVIN_DB_PATH || join(devinHome(), "cli", "sessions.db");
+}
+
+/** Coerce a Devin epoch value (seconds or ms) to epoch ms. Devin stores
+ *  `created_at`/`last_activity_at` as INTEGER epoch seconds. */
+export function devinEpochToMs(value: unknown): number {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    if (value > 1e12) return value; // already ms
+    if (value > 1e9) return value * 1000; // seconds
+  }
+  return Date.now();
+}
+
+// ── Parsing helpers ──
+
+function safeJsonParse(s: unknown): unknown {
+  if (typeof s !== "string" || s.length === 0) return undefined;
+  try {
+    return JSON.parse(s);
+  } catch {
+    return undefined;
+  }
+}
+
+function isPlainObject(v: unknown): v is Record<string, unknown> {
+  return !!v && typeof v === "object" && !Array.isArray(v);
+}
+
+/** Text from a `content` field that may be a string or an array of
+ *  `{ type:"text", text }` blocks. */
+function extractText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((c) => (isPlainObject(c) && typeof c.text === "string" ? (c.text as string) : ""))
+      .filter(Boolean)
+      .join("\n");
+  }
+  return "";
+}
+
+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);
+}
+
+interface NormalizedToolCall {
+  id: string;
+  name: string;
+  input: Record<string, unknown>;
+}
+
+/** Normalize Devin `tool_calls` into `{ id, name, input }[]`. Devin's shape is
+ *  flat: `{ id, name, arguments }` where `arguments` is already an object. Also
+ *  tolerates the OpenAI wire shape `{ id|call_id, function:{ name, arguments }}`
+ *  (arguments as a JSON string) for forward-compat. */
+function normalizeDevinToolCalls(raw: unknown): NormalizedToolCall[] {
+  const arr = Array.isArray(raw) ? raw : safeJsonParse(raw);
+  if (!Array.isArray(arr)) return [];
+  const out: NormalizedToolCall[] = [];
+  for (const tc of arr) {
+    if (!isPlainObject(tc)) continue;
+    const fn = isPlainObject(tc.function) ? tc.function : {};
+    const name =
+      typeof tc.name === "string"
+        ? tc.name
+        : typeof fn.name === "string"
+          ? (fn.name as string)
+          : "tool";
+    const id =
+      (typeof tc.id === "string" && tc.id) ||
+      (typeof tc.call_id === "string" && tc.call_id) ||
+      `${name}-${out.length}`;
+    const rawArgs = tc.arguments ?? fn.arguments;
+    const parsedArgs = isPlainObject(rawArgs) ? rawArgs : safeJsonParse(rawArgs);
+    out.push({ id, name, input: isPlainObject(parsedArgs) ? parsedArgs : {} });
+  }
+  return out;
+}
+
+/** Epoch ms for a parsed chat_message: prefer its high-precision
+ *  `metadata.created_at` ISO string, else the DB row's injected `_created_at`
+ *  (epoch seconds), else the fallback. */
+function messageDate(m: Record<string, unknown>, fallbackMs: number): Date {
+  const meta = isPlainObject(m.metadata) ? m.metadata : undefined;
+  if (meta && meta.created_at != null) return toDate(meta.created_at, fallbackMs);
+  if (m._created_at != null) return toDate(m._created_at, fallbackMs);
+  return new Date(fallbackMs);
+}
+
+// ── Pure parser: parsed chat_message objects → LogEntry[] ──
+
+/**
+ * Convert parsed `chat_message` objects (in node order) into `LogEntry[]`.
+ * Pairs each assistant `tool_calls` entry with its later `role:"tool"` result
+ * by `tool_call_id`. Roles other than user/assistant/tool (e.g. `system`)
+ * become generic system entries so nothing is dropped. Pure — unit-testable
+ * with plain message objects. Each object may carry an injected `_created_at`
+ * (the DB row's epoch-seconds timestamp) used when `metadata.created_at` is
+ * absent.
+ */
+export function devinRowsToLogEntries(
+  rows: Record<string, unknown>[],
+  source: LogSource = "session",
+): LogEntry[] {
+  const entries: LogEntry[] = [];
+  const toolUseById = new Map<string, ToolUseBlock>();
+  const toolUseStartMs = new Map<string, number>();
+  const baseMs = Date.now();
+
+  for (let i = 0; i < rows.length; i++) {
+    const m = rows[i];
+    if (!isPlainObject(m)) continue;
+
+    const role = typeof m.role === "string" ? m.role : "system";
+    const date = messageDate(m, baseMs + i);
+    const timestamp = date.toISOString();
+    const raw: Record<string, unknown> = {
+      uuid: m.message_id != null ? String(m.message_id) : `devin-${i}`,
+      parentUuid: null,
+    };
+    const base = baseEntry(raw, timestamp, date, source);
+
+    if (role === "user") {
+      entries.push({
+        type: "user",
+        ...base,
+        message: { role: "user", content: extractText(m.content) },
+      } satisfies UserEntry);
+      continue;
+    }
+
+    if (role === "assistant") {
+      const blocks: ContentBlock[] = [];
+      const text = extractText(m.content);
+      if (text) blocks.push({ type: "text", text });
+      for (const tc of normalizeDevinToolCalls(m.tool_calls)) {
+        const block: ToolUseBlock = { type: "tool_use", id: tc.id, name: tc.name, input: tc.input };
+        blocks.push(block);
+        toolUseById.set(tc.id, block);
+        toolUseStartMs.set(tc.id, date.getTime());
+      }
+      if (blocks.length === 0) continue; // empty assistant turn
+      entries.push({
+        type: "assistant",
+        ...base,
+        message: {
+          role: "assistant",
+          content: blocks,
+          model: typeof m.model === "string" ? m.model : undefined,
+        },
+      } satisfies AssistantEntry);
+      continue;
+    }
+
+    if (role === "tool") {
+      const callId = typeof m.tool_call_id === "string" ? m.tool_call_id : undefined;
+      const block = callId ? toolUseById.get(callId) : undefined;
+      if (block) {
+        const startMs = (callId && toolUseStartMs.get(callId)) || date.getTime();
+        const durationMs = Math.max(0, date.getTime() - startMs);
+        block.result = {
+          timestamp,
+          timestampFormatted: formatTimestamp(date),
+          content: extractText(m.content),
+          durationMs,
+          durationFormatted: formatDuration(durationMs),
+        };
+        continue;
+      }
+      // Orphan tool result — fall through to a system entry.
+    }
+
+    entries.push({ type: "system", ...base, raw } satisfies GenericEntry);
+  }
+
+  entries.sort((a, b) => a.timestampMs - b.timestampMs);
+  return entries;
+}
+
+// ── DB loader ──
+
+export interface DevinSessionLogData {
+  entries: LogEntry[];
+  rawLines: Record<string, unknown>[];
+  cwd?: string;
+  filePath: string; // synthetic — devin keeps sessions in a DB; we use devin-db://<id>
+}
+
+interface DevinMessageNodeRow {
+  node_id: number | null;
+  parent_node_id: number | null;
+  chat_message: string | null;
+  created_at: number | null;
+}
+
+/**
+ * Devin stores a session's messages as a FOREST, not a flat list: each turn is a
+ * node (`node_id`) linked to its `parent_node_id`, and Devin replays earlier
+ * context under fresh roots on later turns — so the table holds many branches
+ * that repeat the same messages (verified live: 29 nodes / 11 distinct messages
+ * for a 10-message conversation). Reading every node duplicates each message
+ * 2-4×. The real conversation is the single path from the NEWEST leaf back to its
+ * root. Because Devin appends nodes in order (a child's `node_id` always exceeds
+ * its parent's), the newest leaf is simply the max `node_id`; walk its
+ * `parent_node_id` chain to the root and reverse to get root→leaf order.
+ */
+export function devinActiveConversationPath(rows: DevinMessageNodeRow[]): DevinMessageNodeRow[] {
+  if (rows.length === 0) return rows;
+  const byId = new Map<number, DevinMessageNodeRow>();
+  for (const r of rows) if (typeof r.node_id === "number") byId.set(r.node_id, r);
+  // Newest leaf = highest node_id (a leaf, since children always have a higher id).
+  let cur: DevinMessageNodeRow | undefined = rows.reduce((a, b) =>
+    (a.node_id ?? -1) > (b.node_id ?? -1) ? a : b,
+  );
+  const path: DevinMessageNodeRow[] = [];
+  const seen = new Set<number>();
+  while (cur && typeof cur.node_id === "number" && !seen.has(cur.node_id)) {
+    seen.add(cur.node_id);
+    path.push(cur);
+    cur = cur.parent_node_id != null ? byId.get(cur.parent_node_id) : undefined;
+  }
+  return path.reverse(); // root → leaf = conversation order
+}
+
+/** Parse a session's `message_nodes` rows into the message objects the pure
+ *  parser consumes, injecting each row's `created_at` as `_created_at`. */
+function parseNodeRows(rows: DevinMessageNodeRow[]): Record<string, unknown>[] {
+  const out: Record<string, unknown>[] = [];
+  for (const r of rows) {
+    const parsed = safeJsonParse(r.chat_message);
+    if (!isPlainObject(parsed)) continue;
+    if (r.created_at != null && parsed._created_at == null) parsed._created_at = r.created_at;
+    out.push(parsed);
+  }
+  return out;
+}
+
+/**
+ * Load one session by ID from `sessions.db`. Returns `null` when the DB is
+ * unavailable or the session doesn't exist.
+ */
+export async function getDevinSessionLog(
+  sessionId: string,
+): Promise<DevinSessionLogData | null> {
+  if (!sessionId || !DEVIN_SESSION_ID_RE.test(sessionId)) return null;
+  const db = await openSqliteReadonly(devinDbPath());
+  if (!db) return null;
+  try {
+    const sessionRows = db.query<{ working_directory: string | null }>(
+      "SELECT working_directory FROM sessions WHERE id = ?",
+      [sessionId],
+    );
+    if (sessionRows.length === 0) return null;
+    const realCwd = sessionRows[0].working_directory;
+
+    const nodeRows = db.query<DevinMessageNodeRow>(
+      "SELECT node_id, parent_node_id, chat_message, created_at FROM message_nodes " +
+        "WHERE session_id = ? ORDER BY node_id ASC",
+      [sessionId],
+    );
+    // Reconstruct the active conversation path (drop replayed branch duplicates).
+    const rawLines = parseNodeRows(devinActiveConversationPath(nodeRows));
+    const entries = devinRowsToLogEntries(rawLines, "session");
+    const cwd = realCwd && realCwd.length > 0 ? realCwd : undefined;
+    return {
+      entries,
+      rawLines,
+      cwd,
+      filePath: `devin-db://${sessionId}`,
+    };
+  } catch {
+    return null;
+  } finally {
+    db.close();
+  }
+}
+
+export const getCachedDevinSessionLog = runtimeCache(
+  (sessionId: string) => getDevinSessionLog(sessionId),
+  2,
+  { maxSize: 50 },
+);

package/.next/standalone/lib/download-session.ts

@@ -20,6 +20,18 @@ export const OPENCODE_SESSION_RE = /^ses_[A-Za-z0-9]+$/;
  *  its download with `RangeError("Invalid session ID")`. */
 export const HERMES_SESSION_RE = /^[A-Za-z0-9_-]+$/;
 
+/** OpenClaw sessions are UUID-named files. Kept in sync with
+ *  OPENCLAW_SESSION_ID_RE in lib/openclaw-sessions.ts. */
+export const OPENCLAW_SESSION_RE = /^[0-9a-fA-F-]{36}$/;
+
+/** Devin session IDs are word-slug style (e.g. `estimated-seeker`). Kept in
+ *  sync with DEVIN_SESSION_ID_RE in lib/devin-sessions.ts. */
+export const DEVIN_SESSION_RE = /^[A-Za-z0-9_-]+$/;
+
+/** Goose session IDs are date-prefixed counters (e.g. `20260714_3`). Kept in
+ *  sync with GOOSE_SESSION_ID_RE in lib/goose-sessions.ts. */
+export const GOOSE_SESSION_RE = /^\d{8}_\d+$/;
+
 export type DownloadSource =
   | { kind: "file"; path: string }
   | { kind: "synthesized"; body: string; contentType: string; extension: string };
@@ -29,6 +41,9 @@ export type DownloadSource =
 export function isValidSessionId(cli: CliId, sessionId: string): boolean {
   if (cli === "opencode") return OPENCODE_SESSION_RE.test(sessionId);
   if (cli === "hermes") return HERMES_SESSION_RE.test(sessionId);
+  if (cli === "openclaw") return OPENCLAW_SESSION_RE.test(sessionId);
+  if (cli === "devin") return DEVIN_SESSION_RE.test(sessionId);
+  if (cli === "goose") return GOOSE_SESSION_RE.test(sessionId);
   return UUID_RE.test(sessionId);
 }
 
@@ -74,11 +89,6 @@ export async function resolveDownloadSource(
     const path = findPiTranscript(sessionId);
     return path ? { kind: "file", path } : null;
   }
-  if (cli === "gemini") {
-    const { findGeminiTranscript } = await import("./gemini-sessions");
-    const path = findGeminiTranscript(sessionId);
-    return path ? { kind: "file", path } : null;
-  }
   if (cli === "opencode") {
     // OpenCode keeps sessions in SQLite (~/.local/share/opencode/opencode.db)
     // across three tables: session / message / part. Export all three so
@@ -101,6 +111,47 @@ export async function resolveDownloadSource(
     return { kind: "synthesized", body, contentType: "application/x-ndjson", extension: "jsonl" };
   }
 
+  if (cli === "openclaw") {
+    // OpenClaw writes real JSONL transcripts on disk — stream the file verbatim.
+    const { findOpenClawTranscript } = await import("./openclaw-sessions");
+    const path = findOpenClawTranscript(sessionId);
+    return path ? { kind: "file", path } : null;
+  }
+
+  if (cli === "factory") {
+    // Factory (droid) writes real JSONL transcripts on disk — stream verbatim.
+    const { findFactoryTranscript } = await import("./factory-sessions");
+    const path = findFactoryTranscript(sessionId);
+    return path ? { kind: "file", path } : null;
+  }
+
+  if (cli === "devin") {
+    // Devin keeps sessions in SQLite (~/.local/share/devin/cli/sessions.db).
+    // Synthesize a JSONL export of the session's raw chat_message rows.
+    const { getDevinSessionLog } = await import("./devin-sessions");
+    const result = await getDevinSessionLog(sessionId);
+    if (!result) return null;
+    const body = result.rawLines.map((r) => JSON.stringify(r)).join("\n") + "\n";
+    return { kind: "synthesized", body, contentType: "application/x-ndjson", extension: "jsonl" };
+  }
+
+  if (cli === "antigravity") {
+    // Antigravity (agy) writes real JSONL transcripts on disk — stream verbatim.
+    const { findAntigravityTranscript } = await import("./antigravity-sessions");
+    const path = findAntigravityTranscript(sessionId);
+    return path ? { kind: "file", path } : null;
+  }
+
+  if (cli === "goose") {
+    // Goose keeps sessions in SQLite (~/.local/share/goose/sessions/sessions.db).
+    // Synthesize a JSONL export of the session's raw `messages` rows.
+    const { getGooseSessionLog } = await import("./goose-sessions");
+    const result = await getGooseSessionLog(sessionId);
+    if (!result) return null;
+    const body = result.rawLines.map((r) => JSON.stringify(r)).join("\n") + "\n";
+    return { kind: "synthesized", body, contentType: "application/x-ndjson", extension: "jsonl" };
+  }
+
   // Exhaustive — but TypeScript can't always see CliId is exhausted across the
   // if-chain above, so guard with a runtime fallback.
   const _exhaustive: never = cli;

package/.next/standalone/lib/error-origin.ts

@@ -0,0 +1,67 @@
+/**
+ * Works out whether a browser error actually came from the dashboard.
+ *
+ * `window`'s "error" and "unhandledrejection" events are page-global: browser
+ * extensions inject content scripts into the same page and share the same
+ * window, so their failures reach our listeners and get reported as ours. The
+ * observed case was MetaMask's "Failed to connect to MetaMask" arriving as a
+ * failproofai `unhandled_rejection`. Extensions are user-installed and
+ * open-ended, so the noise is unbounded and unrelated to our code.
+ *
+ * We therefore attribute positively — report an error only when it can be
+ * traced to our own origin — rather than maintaining a denylist of extensions
+ * we happen to know about. React render errors don't depend on this: the error
+ * boundaries (`app/global-error.tsx`, `app/components/error-fallback.tsx`)
+ * report `client_error` directly, and React only invokes those for errors thrown
+ * inside our own tree.
+ */
+
+/**
+ * Any `<vendor>-extension://` URL — `chrome-extension://`, `moz-extension://`,
+ * `safari-web-extension://`, `ms-browser-extension://`. Matching the shared
+ * suffix rather than an explicit vendor list means a new browser's scheme is
+ * filtered the day it ships.
+ */
+const EXTENSION_URL = /\b[\w-]+-extension:\/\//i;
+
+export type ErrorOrigin =
+  /** Traceable to our own origin — a real dashboard failure. */
+  | "app"
+  /** Came from a browser extension sharing the page. */
+  | "extension"
+  /** Not attributable: no stack, or a cross-origin "Script error.". */
+  | "unknown";
+
+export interface ErrorOriginInput {
+  /** `error.stack` / `reason.stack`, when the thrown value was an Error. */
+  stack?: string | null;
+  /** `ErrorEvent.filename` — the script URL. Absent on rejections. */
+  filename?: string | null;
+  /** Typically `window.location.origin`. */
+  appOrigin: string;
+}
+
+/**
+ * Classify where an error came from, using whatever location information the
+ * browser gave us.
+ *
+ * Extension frames are checked first: an error whose stack passes through an
+ * extension is that extension's problem even if one of our frames appears
+ * further down.
+ */
+export function classifyErrorOrigin({ stack, filename, appOrigin }: ErrorOriginInput): ErrorOrigin {
+  const text = [filename, stack].filter(Boolean).join("\n");
+  if (!text.trim()) return "unknown";
+  if (EXTENSION_URL.test(text)) return "extension";
+  if (appOrigin && text.includes(appOrigin)) return "app";
+  return "unknown";
+}
+
+/**
+ * Whether an error is ours to report. Only positively-attributed errors qualify:
+ * `unknown` covers cross-origin "Script error." and stack-less rejections, which
+ * are unactionable anyway — there's nothing in them to debug.
+ */
+export function isAppError(input: ErrorOriginInput): boolean {
+  return classifyErrorOrigin(input) === "app";
+}

package/.next/standalone/lib/factory-projects.ts

@@ -0,0 +1,109 @@
+/**
+ * Factory (droid) project discovery.
+ *
+ * droid stores transcripts at `~/.factory/sessions/<encoded-cwd>/<uuid>.jsonl`,
+ * using the same Claude-style encoded-cwd folder names (`-home-user-project`)
+ * as Claude Code. The encoded folder doubles as the URL slug for
+ * `/project/[name]`, so a cwd present in both stores naturally produces the same
+ * `name` and merges on the Claude side (see `mergeProjectFolders` in
+ * lib/projects.ts).
+ */
+import { decodeFolderName } from "./paths";
+import { listFactoryTranscripts, getFactorySessionLog } from "./factory-sessions";
+import type { ProjectFolder, SessionFile } from "./projects";
+import { runtimeCache } from "./runtime-cache";
+import { formatDate } from "./format-date";
+import { logWarn } from "./logger";
+
+/** Returns one ProjectFolder per encoded-cwd folder discovered under
+ *  ~/.factory/sessions/. */
+export async function getFactoryProjects(): Promise<ProjectFolder[]> {
+  let transcripts;
+  try {
+    transcripts = listFactoryTranscripts();
+  } catch (error) {
+    logWarn("Failed to scan Factory sessions:", error);
+    return [];
+  }
+
+  const byName = new Map<string, { latest: number; cwd: string; name: string }>();
+  for (const t of transcripts) {
+    const existing = byName.get(t.projectName);
+    if (!existing || t.mtimeMs > existing.latest) {
+      byName.set(t.projectName, { latest: t.mtimeMs, cwd: t.cwd, name: t.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: ["factory"],
+    });
+  }
+  folders.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return folders;
+}
+
+export interface FactoryProjectByName {
+  /** Canonical cwd recovered from a session's `session_start` line (the folder
+   *  decode is lossy). Null when no session could be read. */
+  cwd: string | null;
+  sessions: SessionFile[];
+}
+
+/**
+ * Look up Factory sessions for a project URL slug (the encoded-cwd folder name).
+ * Because droid names its folders with the same encoding Claude uses, the slug
+ * matches the folder directly. The canonical cwd is recovered from the newest
+ * session's `session_start` record (folder decode is lossy for cwds with `-`).
+ */
+export async function getFactorySessionsByEncodedName(
+  name: string,
+): Promise<FactoryProjectByName> {
+  let transcripts;
+  try {
+    transcripts = listFactoryTranscripts().filter((t) => t.projectName === name);
+  } catch (error) {
+    logWarn("Failed to scan Factory sessions:", error);
+    return { cwd: null, sessions: [] };
+  }
+  if (transcripts.length === 0) return { cwd: null, sessions: [] };
+
+  const sorted = [...transcripts].sort((a, b) => b.mtimeMs - a.mtimeMs);
+
+  // Recover the canonical cwd from the newest transcript's session_start line.
+  let cwd: string | null = null;
+  try {
+    const log = await getFactorySessionLog(sorted[0].sessionId);
+    cwd = log?.cwd ?? null;
+  } catch {
+    // best-effort — fall back to the lossy decode below
+  }
+  if (!cwd) cwd = decodeFolderName(name);
+
+  const sessions: SessionFile[] = sorted.map((t) => {
+    const lastModified = new Date(t.mtimeMs);
+    return {
+      name: t.sessionId,
+      path: t.transcriptPath,
+      lastModified,
+      lastModifiedFormatted: formatDate(lastModified),
+      sessionId: t.sessionId,
+      cli: "factory" as const,
+    };
+  });
+  return { cwd, sessions };
+}
+
+export const getCachedFactoryProjects = runtimeCache(getFactoryProjects, 30);
+export const getCachedFactorySessionsByEncodedName = runtimeCache(
+  (name: string) => getFactorySessionsByEncodedName(name),
+  30,
+  { maxSize: 50 },
+);