failproofai 1.0.3 → 1.0.4-beta.1

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", "hermes", "openclaw", "factory", "devin", "antigravity", "goose"] as const satisfies readonly IntegrationType[];
+export const KNOWN_CLI_IDS = ["claude", "codex", "copilot", "cursor", "opencode", "pi", "hermes", "openclaw", "factory", "devin", "antigravity", "goose", "grok", "qwen", "ori", "cline"] as const satisfies readonly IntegrationType[];
 export type CliId = (typeof KNOWN_CLI_IDS)[number];
 
 /** Per-CLI metadata consumed by the dashboard. */
@@ -99,6 +99,38 @@ const CLI_ENTRIES: Record<CliId, CliEntry> = {
     label: "Goose",
     badgeClasses: "bg-lime-500/10 text-lime-400 border-lime-500/20",
   },
+  grok: {
+    id: "grok",
+    label: "grok CLI",
+    // Neutral zinc, matching the design system's `--color-default`. Deliberately
+    // NOT a status hue: green/amber/red carry health meaning in this dashboard
+    // and must never be spent on identity. Neutral also happens to suit xAI's
+    // monochrome brand, and it is maximally far from qwen's magenta — the two
+    // were previously indistinguishable.
+    badgeClasses: "bg-zinc-500/10 text-zinc-200 border-zinc-500/20",
+  },
+  qwen: {
+    id: "qwen",
+    label: "Qwen Code",
+    // Magenta — the opposite pole from grok's neutral, and outside the
+    // status set (success/amber/orange/error) so it reads as identity.
+    badgeClasses: "bg-fuchsia-500/10 text-fuchsia-400 border-fuchsia-500/20",
+  },
+  ori: {
+    id: "ori",
+    label: "Ori",
+    // Sky — the badge set must be UNIQUE per CLI (a test asserts it), and
+    // violet/teal were already taken. Still outside the status set
+    // (success/amber/orange/error) so it reads as identity, not state.
+    badgeClasses: "bg-sky-500/10 text-sky-400 border-sky-500/20",
+  },
+  cline: {
+    id: "cline",
+    label: "Cline",
+    // Stone — the remaining neutral that is not zinc (grok's) and not a status
+    // colour.
+    badgeClasses: "bg-stone-500/10 text-stone-300 border-stone-500/20",
+  },
 };
 
 export function getCliEntry(id: string): CliEntry | undefined {

package/lib/cline-projects.ts

@@ -0,0 +1,155 @@
+/**
+ * Cline session enumeration — AUDIT-ONLY.
+ *
+ * One directory per session under `~/.cline/data/sessions/<epochMs>_<suffix>/`,
+ * each with a `<id>.json` metadata sidecar carrying a real `cwd`. So cline
+ * sessions group by project like Claude / Factory / Devin / Goose / ori rather
+ * than landing in one cwd-less bucket the way the Hermes gateway does.
+ *
+ * Enumeration reads only the small metadata sidecar, never the transcript — a
+ * project listing should not pay for parsing every message array on the box.
+ */
+import { readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+import {
+  clineSessionsDir,
+  clineTimestampToMs,
+  readClineSessionMeta,
+  CLINE_SESSION_DIR_RE,
+} from "./cline-sessions";
+import { encodeFolderName } from "./paths";
+import { runtimeCache } from "./runtime-cache";
+import type { ProjectFolder, SessionFile } from "./projects";
+import { formatDate } from "./format-date";
+
+export interface ClineSessionRef {
+  sessionId: string;
+  cwd?: string;
+  title?: string;
+  model?: string;
+  provider?: string;
+  /** Encoded-cwd folder slug (matches Claude's `-home-user-project` scheme). */
+  projectName: string;
+  mtimeMs: number;
+}
+
+/** Truncate a first prompt into a session title the way the other adapters do. */
+function titleFrom(prompt: string | undefined): string | undefined {
+  if (!prompt) return undefined;
+  // cline wraps the first turn in <user_input mode="act">…</user_input>.
+  const inner = /<user_input[^>]*>([\s\S]*?)<\/user_input>/.exec(prompt);
+  const text = (inner ? inner[1]! : prompt).trim().replace(/\s+/g, " ");
+  if (text.length === 0) return undefined;
+  return text.length > 60 ? `${text.slice(0, 59)}…` : text;
+}
+
+/**
+ * List every cline session. Returns `[]` when the directory is missing or
+ * unreadable (fail-open — the audit just skips cline).
+ */
+export async function getClineSessions(): Promise<ClineSessionRef[]> {
+  const root = clineSessionsDir();
+  let names: string[];
+  try {
+    names = await readdir(root);
+  } catch {
+    return [];
+  }
+  const out: ClineSessionRef[] = [];
+  for (const name of names) {
+    if (!CLINE_SESSION_DIR_RE.test(name)) continue;
+    const dir = join(root, name);
+    const meta = await readClineSessionMeta(dir, name);
+    let mtimeMs =
+      clineTimestampToMs(meta?.ended_at) ||
+      clineTimestampToMs(meta?.started_at) ||
+      Number(name.split("_")[0]) ||
+      0;
+    if (mtimeMs === 0) {
+      try {
+        mtimeMs = (await stat(dir)).mtimeMs;
+      } catch {
+        /* leave 0 */
+      }
+    }
+    const cwd = meta?.cwd ?? meta?.workspace_root;
+    out.push({
+      sessionId: name,
+      cwd,
+      title: titleFrom(meta?.prompt),
+      model: meta?.model,
+      provider: meta?.provider,
+      projectName: cwd ? encodeFolderName(cwd) : "cline",
+      mtimeMs,
+    });
+  }
+  out.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return out;
+}
+
+export const getCachedClineSessions = runtimeCache(getClineSessions, 2);
+
+// ── Dashboard history browser (projects list + project-detail sessions) ──
+
+/** One `ProjectFolder` per encoded-cwd discovered in cline's session store. */
+export async function getClineProjects(): Promise<ProjectFolder[]> {
+  const sessions = await getClineSessions();
+  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: ["cline"],
+    });
+  }
+  folders.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return folders;
+}
+
+export interface ClineProjectByName {
+  cwd: string | null;
+  sessions: SessionFile[];
+}
+
+/** Resolve the cline sessions for a project URL slug (the encoded-cwd folder). */
+export async function getClineSessionsByEncodedName(name: string): Promise<ClineProjectByName> {
+  const sessions = await getClineSessions();
+  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: `cline-session://${s.sessionId}`,
+        lastModified,
+        lastModifiedFormatted: formatDate(lastModified),
+        sessionId: s.sessionId,
+        cli: "cline" as const,
+      };
+    }),
+  };
+}
+
+export const getCachedClineProjects = runtimeCache(getClineProjects, 2);
+export const getCachedClineSessionsByEncodedName = runtimeCache(
+  (name: string) => getClineSessionsByEncodedName(name),
+  2,
+  { maxSize: 50 },
+);

package/lib/cline-sessions.ts

@@ -0,0 +1,268 @@
+/**
+ * Cline session transcript loader + parser.
+ *
+ * AUDIT-ONLY (Pillar 2). Cline is the easiest transcript of any integration we
+ * support, because it already speaks CLAUDE'S OWN content-block schema. Each
+ * session is a directory under `~/.cline/data/sessions/<epochMs>_<suffix>/`
+ * holding exactly two files:
+ *
+ *   <id>.json           session metadata: {session_id, source, pid, started_at,
+ *                       ended_at, exit_code, status, interactive, provider,
+ *                       model, cwd, workspace_root, prompt}
+ *   <id>.messages.json  {version, updated_at, agent, sessionId, origin,
+ *                       system_prompt, messages}
+ *
+ * and `messages[].content` is an array of the very blocks lib/log-entries.ts
+ * already models: `{type:"thinking"}`, `{type:"text"}`,
+ * `{type:"tool_use", id, name, input}`, `{type:"tool_result", tool_use_id,
+ * name, content}`. So there is no dialect to translate — only tool_result
+ * pairing, which `clineMessagesToLogEntries` does by `tool_use_id`.
+ *
+ * Two things that are NOT free, recorded so nobody assumes otherwise:
+ *   • Cline stores NO per-message timestamp. Every entry in a session therefore
+ *     carries the session's own time, so ordering within a session is array
+ *     order and per-message timing is unrecoverable. (Same limitation as ori.)
+ *   • Tool RESULTS arrive in `role:"user"` messages, Claude-style. A user
+ *     message whose content is entirely tool_result blocks is NOT user prose
+ *     and must not be emitted as one, or every tool call produces a phantom
+ *     user turn in the audit.
+ *
+ * Home override: `CLINE_HOME` (the dir containing `data/sessions`, used by
+ * tests); otherwise `$CLINE_DIR` — which cline itself honours — then `~/.cline`.
+ */
+import { readFile, readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { runtimeCache } from "./runtime-cache";
+import {
+  baseEntry,
+  formatTimestamp,
+  type LogEntry,
+  type UserEntry,
+  type AssistantEntry,
+  type ContentBlock,
+  type ToolUseBlock,
+  type LogSource,
+} from "./log-entries";
+import { formatDuration } from "./format-duration";
+
+/** Absolute path to cline's home (override with CLINE_HOME, then CLINE_DIR). */
+export function clineHome(): string {
+  return process.env.CLINE_HOME || process.env.CLINE_DIR || join(homedir(), ".cline");
+}
+
+/** Absolute path to the directory holding one folder per session. */
+export function clineSessionsDir(): string {
+  return join(clineHome(), "data", "sessions");
+}
+
+/** Session directories are `<epochMs>_<suffix>`, e.g. `1788253271772_bn188`. */
+export const CLINE_SESSION_DIR_RE = /^(\d{10,})_([A-Za-z0-9]+)$/;
+
+export function clineTimestampToMs(value: string | null | undefined): number {
+  if (!value) return 0;
+  const ms = Date.parse(value);
+  return Number.isNaN(ms) ? 0 : ms;
+}
+
+export interface ClineSessionMeta {
+  session_id?: string;
+  status?: string;
+  provider?: string;
+  model?: string;
+  cwd?: string;
+  workspace_root?: string;
+  prompt?: string;
+  started_at?: string;
+  ended_at?: string;
+  source?: string;
+  interactive?: boolean;
+  exit_code?: number;
+}
+
+interface ClineBlock {
+  type?: string;
+  text?: string;
+  thinking?: string;
+  id?: string;
+  name?: string;
+  input?: Record<string, unknown>;
+  tool_use_id?: string;
+  content?: unknown;
+}
+
+interface ClineMessage {
+  role?: string;
+  content?: string | ClineBlock[];
+}
+
+/** Flatten a tool_result's `content` into display text. Cline uses an array of
+ *  `{query, result}`-ish objects or plain text blocks depending on the tool, so
+ *  fall back to JSON rather than dropping the result entirely. */
+function toolResultText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    const parts = content.map((c) => {
+      if (typeof c === "string") return c;
+      if (c && typeof c === "object") {
+        const o = c as Record<string, unknown>;
+        if (typeof o.text === "string") return o.text;
+        if (typeof o.result === "string") return o.result;
+        return JSON.stringify(o);
+      }
+      return "";
+    });
+    return parts.filter((p) => p.length > 0).join("\n");
+  }
+  if (content && typeof content === "object") return JSON.stringify(content);
+  return "";
+}
+
+/**
+ * Parse cline's message array into the shared LogEntry[] shape.
+ *
+ * PURE — takes already-parsed JSON, so tests need no fixture directory.
+ */
+export function clineMessagesToLogEntries(
+  messages: ClineMessage[],
+  sessionId: string,
+  timestampMs: number,
+  source: LogSource = "session",
+): LogEntry[] {
+  const date = new Date(timestampMs);
+  const timestamp = date.toISOString();
+  const entries: LogEntry[] = [];
+  // tool_use id → the block awaiting its result, so a later user-role
+  // tool_result attaches onto the assistant turn that made the call.
+  const pending = new Map<string, ToolUseBlock>();
+
+  messages.forEach((msg, i) => {
+    const role = msg.role;
+    const raw = { uuid: `${sessionId}:${i}`, parentUuid: null } as Record<string, unknown>;
+    const base = baseEntry(raw, timestamp, date, source);
+    const blocks: ClineBlock[] = Array.isArray(msg.content) ? msg.content : [];
+
+    if (role === "user") {
+      // Attach any tool results this message carries…
+      let attached = 0;
+      for (const b of blocks) {
+        if (b.type !== "tool_result" || typeof b.tool_use_id !== "string") continue;
+        attached++;
+        const target = pending.get(b.tool_use_id);
+        if (!target) continue;
+        // No per-message timestamp exists, so duration is unknowable — 0 rather
+        // than a fabricated span.
+        target.result = {
+          timestamp,
+          timestampFormatted: formatTimestamp(date),
+          content: toolResultText(b.content),
+          durationMs: 0,
+          durationFormatted: formatDuration(0),
+        };
+        pending.delete(b.tool_use_id);
+      }
+      // …and only emit a user turn if there was real prose. A message that is
+      // nothing but tool results is the tool-result carrier, not a user turn.
+      const text =
+        typeof msg.content === "string"
+          ? msg.content
+          : blocks
+              .filter((b) => b.type === "text" && typeof b.text === "string")
+              .map((b) => b.text as string)
+              .join("");
+      if (text.trim().length > 0) {
+        entries.push({ ...base, type: "user", message: { role: "user", content: text } } as UserEntry);
+      } else if (attached === 0 && typeof msg.content === "string") {
+        entries.push({ ...base, type: "user", message: { role: "user", content: msg.content } } as UserEntry);
+      }
+      return;
+    }
+
+    if (role === "assistant") {
+      const out: ContentBlock[] = [];
+      for (const b of blocks) {
+        if (b.type === "thinking" && typeof b.thinking === "string") {
+          out.push({ type: "thinking", thinking: b.thinking });
+        } else if (b.type === "text" && typeof b.text === "string") {
+          out.push({ type: "text", text: b.text });
+        } else if (b.type === "tool_use" && typeof b.id === "string") {
+          const block: ToolUseBlock = {
+            type: "tool_use",
+            id: b.id,
+            name: b.name ?? "",
+            input: b.input ?? {},
+          };
+          pending.set(b.id, block);
+          out.push(block);
+        }
+      }
+      if (out.length > 0) {
+        entries.push({
+          ...base,
+          type: "assistant",
+          message: { role: "assistant", content: out },
+        } as AssistantEntry);
+      }
+    }
+  });
+
+  return entries;
+}
+
+export interface ClineSessionLog {
+  entries: LogEntry[];
+  cwd?: string;
+  meta?: ClineSessionMeta;
+}
+
+/** Read a session's metadata sidecar. Returns undefined when absent/unreadable. */
+export async function readClineSessionMeta(
+  dir: string,
+  sessionId: string,
+): Promise<ClineSessionMeta | undefined> {
+  try {
+    return JSON.parse(await readFile(join(dir, `${sessionId}.json`), "utf8")) as ClineSessionMeta;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Load and parse one cline session. Returns null when absent or unreadable. */
+export async function getClineSessionLog(sessionId: string): Promise<ClineSessionLog | null> {
+  const root = clineSessionsDir();
+  let dirs: string[];
+  try {
+    dirs = await readdir(root);
+  } catch {
+    return null;
+  }
+  // The directory is `<epochMs>_<suffix>` and the files inside are named for
+  // the FULL directory name, which is also the session id.
+  const dirName = dirs.find((d) => d === sessionId);
+  if (!dirName) return null;
+  const dir = join(root, dirName);
+
+  let parsed: { messages?: ClineMessage[]; updated_at?: string };
+  try {
+    parsed = JSON.parse(await readFile(join(dir, `${sessionId}.messages.json`), "utf8")) as {
+      messages?: ClineMessage[];
+      updated_at?: string;
+    };
+  } catch {
+    return null;
+  }
+  const meta = await readClineSessionMeta(dir, sessionId);
+  const ms =
+    clineTimestampToMs(meta?.started_at) ||
+    clineTimestampToMs(parsed.updated_at) ||
+    Number(sessionId.split("_")[0]) ||
+    0;
+
+  return {
+    entries: clineMessagesToLogEntries(parsed.messages ?? [], sessionId, ms),
+    cwd: meta?.cwd ?? meta?.workspace_root,
+    meta,
+  };
+}
+
+export const getCachedClineSessionLog = runtimeCache(getClineSessionLog, 2);

package/lib/download-session.ts

@@ -125,6 +125,21 @@ export async function resolveDownloadSource(
     return path ? { kind: "file", path } : null;
   }
 
+  if (cli === "grok") {
+    // grok writes a real chat_history.jsonl per session directory — stream it
+    // verbatim (no synthesis, like Factory).
+    const { findGrokTranscript } = await import("./grok-sessions");
+    const path = findGrokTranscript(sessionId);
+    return path ? { kind: "file", path } : null;
+  }
+
+  if (cli === "qwen") {
+    // qwen writes a real JSONL transcript per session — stream it verbatim.
+    const { findQwenTranscript } = await import("./qwen-sessions");
+    const path = findQwenTranscript(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.
@@ -152,6 +167,28 @@ export async function resolveDownloadSource(
     return { kind: "synthesized", body, contentType: "application/x-ndjson", extension: "jsonl" };
   }
 
+  if (cli === "ori") {
+    // Ori keeps the whole conversation in one SQLite column
+    // (ori_agent_loop_history.prompt). Synthesize a JSONL export from the
+    // parsed entries — there is no per-session file to stream.
+    const { getOriSessionLog } = await import("./ori-sessions");
+    const result = await getOriSessionLog(sessionId);
+    if (!result) return null;
+    const body = result.entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
+    return { kind: "synthesized", body, contentType: "application/x-ndjson", extension: "jsonl" };
+  }
+
+  if (cli === "cline") {
+    // Cline stores a real per-session messages file, but it is a single JSON
+    // document rather than JSONL, so stream the parsed entries as JSONL for
+    // consistency with every other synthesized export.
+    const { getClineSessionLog } = await import("./cline-sessions");
+    const result = await getClineSessionLog(sessionId);
+    if (!result) return null;
+    const body = result.entries.map((e) => JSON.stringify(e)).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/lib/grok-projects.ts

@@ -0,0 +1,123 @@
+/**
+ * grok CLI project discovery.
+ *
+ * grok stores transcripts at
+ * `~/.grok/sessions/<percent-encoded-cwd>/<uuid>/chat_history.jsonl`.
+ *
+ * NOTE the folder encoding differs from every other JSONL store we read: grok
+ * percent-encodes the cwd (`%2Fhome%2Fuser%2Frepo`) where Claude, Factory and
+ * Qwen dash-encode it (`-home-user-repo`).
+ *
+ * So the on-disk folder name is deliberately NOT used as the project `name`.
+ * Two reasons, and the first is a hard bug: `name` becomes the URL slug for
+ * `/project/[name]`, and a percent-encoded name re-encodes to `%252F…` in the
+ * link, which the route cannot resolve — every grok project 404'd. Second, a
+ * name no other CLI can produce merges with nothing, so a cwd driven by both
+ * grok and Claude showed up as two unrelated rows.
+ *
+ * Re-encoding the decoded cwd with `encodeFolderName` fixes both at once: the
+ * slug is URL-safe, and it is byte-identical to the one Claude/Factory/Qwen
+ * derive for the same cwd, so those rows merge as they should.
+ */
+import { encodeFolderName, decodeFolderName } from "./paths";
+import { listGrokTranscripts, getGrokSessionLog } from "./grok-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 percent-encoded cwd folder discovered under
+ *  ~/.grok/sessions/. */
+export async function getGrokProjects(): Promise<ProjectFolder[]> {
+  let transcripts;
+  try {
+    transcripts = listGrokTranscripts();
+  } catch (error) {
+    logWarn("Failed to scan grok sessions:", error);
+    return [];
+  }
+
+  const byName = new Map<string, { latest: number; cwd: string; name: string }>();
+  for (const t of transcripts) {
+    // The URL slug is derived from the real cwd, never from grok's
+    // percent-encoded folder — see the module header.
+    const name = encodeFolderName(t.cwd);
+    const existing = byName.get(name);
+    if (!existing || t.mtimeMs > existing.latest) {
+      byName.set(name, { latest: t.mtimeMs, cwd: t.cwd, name });
+    }
+  }
+
+  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: ["grok"],
+    });
+  }
+  folders.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return folders;
+}
+
+export interface GrokProjectByName {
+  /** Canonical cwd, taken from a session's summary.json `info.cwd`. Null when
+   *  no session could be read. */
+  cwd: string | null;
+  sessions: SessionFile[];
+}
+
+/**
+ * Look up grok sessions for a project URL slug (the percent-encoded cwd folder
+ * name). The canonical cwd comes from summary.json; the percent-decode is the
+ * fallback.
+ */
+export async function getGrokSessionsByEncodedName(name: string): Promise<GrokProjectByName> {
+  let transcripts;
+  try {
+    // Match on the derived slug, since that is what the link carried.
+    transcripts = listGrokTranscripts().filter((t) => encodeFolderName(t.cwd) === name);
+  } catch (error) {
+    logWarn("Failed to scan grok sessions:", error);
+    return { cwd: null, sessions: [] };
+  }
+  if (transcripts.length === 0) return { cwd: null, sessions: [] };
+
+  const sorted = [...transcripts].sort((a, b) => b.mtimeMs - a.mtimeMs);
+
+  let cwd: string | null = sorted[0].cwd || null;
+  if (!cwd) {
+    try {
+      const log = await getGrokSessionLog(sorted[0].sessionId);
+      cwd = log?.cwd ?? null;
+    } catch {
+      // best-effort — fall back to the decode below
+    }
+  }
+  // `name` is a dash-encoded cwd here, so the shared decoder is the right one.
+  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: "grok" as const,
+    };
+  });
+  return { cwd, sessions };
+}
+
+export const getCachedGrokProjects = runtimeCache(getGrokProjects, 30);
+export const getCachedGrokSessionsByEncodedName = runtimeCache(
+  (name: string) => getGrokSessionsByEncodedName(name),
+  30,
+  { maxSize: 50 },
+);