failproofai 0.0.13 → 0.0.14-beta.1

package/scripts/translate-docs/mdx-translator.ts

@@ -1,4 +1,12 @@
-import { readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from "node:fs";
+import {
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  readdirSync,
+  statSync,
+  existsSync,
+  rmSync,
+} from "node:fs";
 import { dirname, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 import { getLanguageByCode } from "./config";
@@ -8,6 +16,7 @@ import {
   writeCache,
   isCached,
   setCacheEntry,
+  getCacheKey,
 } from "./cache";
 import type { TranslationResult, TranslationCache } from "./types";
 
@@ -93,33 +102,82 @@ export function stripStrayTrailingFence(content: string): string {
   return lines.join("\n");
 }
 
+/**
+ * Convert HTML comments (`<!-- ... -->`) into MDX brace-slash-star comments.
+ *
+ * Mintlify parses every page as MDX, where a top-level HTML comment is a hard
+ * syntax error ("Unexpected character `!` (U+0021) before name …") that fails
+ * the whole deployment — the remedy Mintlify itself suggests is switching to
+ * MDX's own comment form. The root README keeps HTML-comment syntax (GitHub
+ * renders it invisibly), so its translated copies under docs/i18n/ have to be
+ * rewritten to the MDX form or the docs deploy breaks.
+ *
+ * Comments inside fenced code blocks are left untouched — there `<!-- -->` is
+ * literal sample text (e.g. the plist snippet in the AgentEye collector docs),
+ * not a comment to convert. Any `*`+`/` sequence inside a body is broken up so
+ * the generated JS block comment can't be terminated early.
+ */
+export function convertHtmlComments(content: string): string {
+  // Map out fenced-code ranges so comments inside them stay literal. Per
+  // CommonMark, a fence opens with ≥3 backticks or tildes and closes only on a
+  // later line using the SAME character and at least the same length. A naive
+  // "any ``` toggles" counter misfires on a ```` block that embeds ``` or on
+  // mixed ```/~~~ fences — the toggle desyncs and a real top-level comment
+  // after the block would be left unconverted (breaking the deploy we fix here).
+  const fenceRanges: Array<[number, number]> = [];
+  const fenceRe = /^[ \t]*(`{3,}|~{3,})/gm;
+  let fenceMatch: RegExpExecArray | null;
+  let open: { char: string; length: number; start: number } | null = null;
+  while ((fenceMatch = fenceRe.exec(content)) !== null) {
+    const marker = fenceMatch[1];
+    if (!open) {
+      open = { char: marker[0], length: marker.length, start: fenceMatch.index };
+    } else if (marker[0] === open.char && marker.length >= open.length) {
+      const lineEnd = content.indexOf("\n", fenceRe.lastIndex);
+      fenceRanges.push([open.start, lineEnd === -1 ? content.length : lineEnd]);
+      open = null;
+    }
+    // A different char or shorter marker while a fence is open is inner content.
+  }
+  // An unterminated fence runs to the end of the document.
+  if (open) fenceRanges.push([open.start, content.length]);
+
+  const isInsideFence = (offset: number): boolean =>
+    fenceRanges.some(([start, end]) => offset >= start && offset < end);
+
+  return content.replace(
+    /<!--([\s\S]*?)-->/g,
+    (match: string, body: string, offset: number) => {
+      if (isInsideFence(offset)) return match;
+      // Neutralize any `*/` so it can't close the JS block comment early.
+      const safeBody = body.replace(/\*\//g, "* /");
+      return `{/*${safeBody}*/}`;
+    },
+  );
+}
+
 /**
  * Rewrite internal doc links to include the language prefix.
  * e.g. href="/built-in-policies" -> href="/es/built-in-policies"
  *      [Getting started](/getting-started) -> [Getting started](/es/getting-started)
  */
-export function rewriteInternalLinks(
-  content: string,
-  lang: string,
-): string {
+export function rewriteInternalLinks(content: string, lang: string): string {
+  const shouldPreservePath = (path: string): boolean =>
+    path.startsWith("/http") ||
+    path === "/" ||
+    /\.(?:png|jpe?g|gif|svg|webp|ico)(?:#.*)?$/i.test(path);
+
   // Rewrite MDX component href attributes pointing to internal paths
-  let result = content.replace(
-    /href="(\/[^"]*?)"/g,
-    (_match, path: string) => {
-      // Skip external URLs and anchors
-      if (path.startsWith("/http") || path === "/") return `href="${path}"`;
-      return `href="/${lang}${path}"`;
-    },
-  );
+  let result = content.replace(/href="(\/[^"]*?)"/g, (_match, path: string) => {
+    if (shouldPreservePath(path)) return `href="${path}"`;
+    return `href="/${lang}${path}"`;
+  });
 
   // Rewrite Markdown links with internal paths
-  result = result.replace(
-    /\]\((\/[^)]*?)\)/g,
-    (_match, path: string) => {
-      if (path.startsWith("/http") || path === "/") return `](${path})`;
-      return `](/${lang}${path})`;
-    },
-  );
+  result = result.replace(/\]\((\/[^)]*?)\)/g, (_match, path: string) => {
+    if (shouldPreservePath(path)) return `](${path})`;
+    return `](/${lang}${path})`;
+  });
 
   return result;
 }
@@ -130,7 +188,12 @@ export function rewriteInternalLinks(
 export async function translateMdxPage(
   sourcePath: string,
   lang: string,
-  options: { force?: boolean; dryRun?: boolean; model?: string; cache?: TranslationCache } = {},
+  options: {
+    force?: boolean;
+    dryRun?: boolean;
+    model?: string;
+    cache?: TranslationCache;
+  } = {},
 ): Promise<TranslationResult> {
   const relPath = relative(DOCS_DIR, sourcePath);
   const outputPath = join(DOCS_DIR, lang, relPath);
@@ -174,9 +237,11 @@ export async function translateMdxPage(
   );
 
   // Strip stray quote artifacts from JSX attribute values, drop any
-  // unmatched trailing code fence the model sometimes hallucinates, then
-  // rewrite links.
-  const sanitized = stripStrayTrailingFence(sanitizeJsxAttributes(translated));
+  // unmatched trailing code fence the model sometimes hallucinates, convert
+  // any HTML comments to MDX comments, then rewrite links.
+  const sanitized = convertHtmlComments(
+    stripStrayTrailingFence(sanitizeJsxAttributes(translated)),
+  );
   const withLinks = rewriteInternalLinks(sanitized, lang);
 
   // Write output
@@ -186,7 +251,14 @@ export async function translateMdxPage(
   // Update cache — skip if caller manages the cache (batch write)
   if (!options.cache) {
     const cache = readCache();
-    setCacheEntry(cache, relPath, lang, sourceContent, inputTokens, outputTokens);
+    setCacheEntry(
+      cache,
+      relPath,
+      lang,
+      sourceContent,
+      inputTokens,
+      outputTokens,
+    );
     writeCache(cache);
   }
 
@@ -213,7 +285,7 @@ export function getEnglishMdxPages(): string[] {
       if (statSync(full).isDirectory()) {
         // Skip language directories at the top level
         if (!prefix && isLanguageDir(entry)) continue;
-        // Skip non-doc directories like logo, i18n
+        // Skip non-page asset and localization directories.
         if (!prefix && (entry === "logo" || entry === "i18n")) continue;
         walk(full, rel);
       } else if (entry.endsWith(".mdx")) {
@@ -226,10 +298,87 @@ export function getEnglishMdxPages(): string[] {
   return results.sort();
 }
 
+/** Every `.mdx` file under `dir`, recursively. */
+function collectMdxFiles(dir: string): string[] {
+  const results: string[] = [];
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    if (statSync(full).isDirectory()) {
+      results.push(...collectMdxFiles(full));
+    } else if (entry.endsWith(".mdx")) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+
+/**
+ * Delete translated pages whose English source no longer exists, and drop
+ * their cache entries.
+ *
+ * Translation only ever moves forward: `getEnglishMdxPages()` drives what gets
+ * written, so when an English page is deleted upstream (the agenteye sync does
+ * this routinely) its 14 translations are simply never revisited. They linger
+ * on disk and `--update-nav` drops them from `docs.json`, which hides them from
+ * the sidebar but does *not* unpublish them — Mintlify still serves and indexes
+ * any `.mdx` present, so non-English readers can land on a page documenting a
+ * removed feature with no navigation out. Left unpruned these also accumulate
+ * as permanent `validate:mdx` surface area for content no English source can
+ * ever correct.
+ *
+ * Returns the docs-dir-relative paths that were (or, when `dryRun`, would be)
+ * removed.
+ */
+export function pruneOrphanedTranslations(
+  langCodes: string[],
+  options: {
+    dryRun?: boolean;
+    cache?: TranslationCache;
+    /** Override the docs root. Tests point this at a fixture tree. */
+    docsDir?: string;
+  } = {},
+): string[] {
+  const docsDir = options.docsDir ?? DOCS_DIR;
+  const removed: string[] = [];
+
+  for (const lang of langCodes) {
+    const langDir = join(docsDir, lang);
+    if (!existsSync(langDir)) continue;
+
+    for (const file of collectMdxFiles(langDir)) {
+      // docs/zh/agenteye/foo.mdx -> agenteye/foo.mdx -> docs/agenteye/foo.mdx
+      const relPath = relative(langDir, file);
+      if (existsSync(join(docsDir, relPath))) continue;
+
+      removed.push(relative(docsDir, file));
+      if (!options.dryRun) {
+        rmSync(file);
+        if (options.cache) {
+          delete options.cache.translations[getCacheKey(relPath, lang)];
+        }
+      }
+    }
+  }
+
+  return removed.sort();
+}
+
 function isLanguageDir(name: string): boolean {
   const langCodes = [
-    "zh", "ja", "ko", "es", "pt-br", "de", "fr",
-    "ru", "hi", "tr", "vi", "it", "ar", "he",
+    "zh",
+    "ja",
+    "ko",
+    "es",
+    "pt-br",
+    "de",
+    "fr",
+    "ru",
+    "hi",
+    "tr",
+    "vi",
+    "it",
+    "ar",
+    "he",
   ];
   return langCodes.includes(name);
 }

package/scripts/translate-docs/mintlify-nav.ts

@@ -1,7 +1,7 @@
 import { readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { NAV_TRANSLATIONS, LANGUAGES } from "./config";
+import { getLanguageByCode, NAV_TRANSLATIONS, LANGUAGES } from "./config";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const DOCS_JSON_PATH = join(__dirname, "..", "..", "docs", "docs.json");
@@ -21,6 +21,57 @@ interface LanguageNav {
   tabs: NavTab[];
 }
 
+export interface NavigationPageReference {
+  page: string;
+  language?: string;
+}
+
+/** Collect page references from flat, localized, or multi-product navigation. */
+export function getNavigationPageReferences(
+  navigation: unknown,
+): NavigationPageReference[] {
+  const references: NavigationPageReference[] = [];
+  const childKeys = [
+    "products",
+    "languages",
+    "tabs",
+    "groups",
+    "anchors",
+    "dropdowns",
+    "versions",
+    "menu",
+  ];
+
+  function walk(value: unknown, inheritedLanguage?: string): void {
+    if (Array.isArray(value)) {
+      for (const item of value) walk(item, inheritedLanguage);
+      return;
+    }
+    if (!value || typeof value !== "object") return;
+
+    const entry = value as Record<string, unknown>;
+    const language =
+      typeof entry.language === "string" ? entry.language : inheritedLanguage;
+
+    if (Array.isArray(entry.pages)) {
+      for (const page of entry.pages) {
+        if (typeof page === "string") {
+          references.push({ page, language });
+        } else {
+          walk(page, language);
+        }
+      }
+    }
+
+    for (const key of childKeys) {
+      if (key !== "pages" && entry[key]) walk(entry[key], language);
+    }
+  }
+
+  walk(navigation);
+  return references;
+}
+
 /**
  * Build a navigation entry for a specific language by transforming the
  * English navigation structure.
@@ -54,7 +105,10 @@ export function buildLanguageNav(
     })),
   }));
 
-  return { language: lang, tabs };
+  return {
+    language: getLanguageByCode(lang)?.mintlifyCode ?? lang,
+    tabs,
+  };
 }
 
 /**
@@ -78,6 +132,28 @@ export function generateLanguagesArray(
   return [english, ...others];
 }
 
+/** Localize every product that has English tabs or an English language entry. */
+export function localizeProductsNavigation(
+  products: unknown[],
+  langCodes: string[],
+): Record<string, unknown>[] {
+  return products.map((value) => {
+    const product = value as Record<string, unknown>;
+    const existingLanguages = product.languages as LanguageNav[] | undefined;
+    const englishTabs = existingLanguages
+      ? existingLanguages.find((entry) => entry.language === "en")?.tabs
+      : (product.tabs as NavTab[] | undefined);
+
+    if (!englishTabs) return product;
+
+    const { tabs: _tabs, ...rest } = product;
+    return {
+      ...rest,
+      languages: generateLanguagesArray(englishTabs, langCodes),
+    };
+  });
+}
+
 /**
  * Update docs.json to use the languages array structure.
  */
@@ -85,18 +161,23 @@ export function updateDocsJson(langCodes: string[]): void {
   const config = readDocsConfig();
   const nav = config.navigation as Record<string, unknown>;
 
-  // Extract existing English tabs
-  const englishTabs = nav.tabs as NavTab[];
-  if (!englishTabs) {
-    throw new Error("docs.json navigation.tabs not found — is this already using the languages format?");
+  if (Array.isArray(nav.products)) {
+    nav.products = localizeProductsNavigation(nav.products, langCodes);
+    config.navigation = nav;
+    writeFileSync(DOCS_JSON_PATH, JSON.stringify(config, null, 2) + "\n");
+    return;
   }
 
-  // Build languages array
-  const languages = generateLanguagesArray(englishTabs, langCodes);
+  const existingLanguages = nav.languages as LanguageNav[] | undefined;
+  const englishTabs = existingLanguages
+    ? existingLanguages.find((entry) => entry.language === "en")?.tabs
+    : (nav.tabs as NavTab[] | undefined);
+  if (!englishTabs) {
+    throw new Error("No English navigation tabs found in docs.json");
+  }
 
-  // Replace tabs with languages, preserve global
   const newNav: Record<string, unknown> = {
-    languages,
+    languages: generateLanguagesArray(englishTabs, langCodes),
   };
   if (nav.global) {
     newNav.global = nav.global;

package/scripts/translate-docs/readme-translator.ts

@@ -3,7 +3,11 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { LANGUAGES, getLanguageByCode } from "./config";
 import { translateContent } from "./translator";
-import { stripStrayTrailingFence } from "./mdx-translator";
+import {
+  stripStrayTrailingFence,
+  convertHtmlComments,
+  sanitizeJsxAttributes,
+} from "./mdx-translator";
 import { readCache, writeCache, isCached, setCacheEntry } from "./cache";
 import type { TranslationResult, TranslationCache } from "./types";
 
@@ -103,10 +107,14 @@ export async function translateReadme(
   const rtlOpen = langConfig.rtl ? `<div dir="rtl">\n\n` : "";
   const rtlClose = langConfig.rtl ? `\n\n</div>` : "";
 
-  // Drop any stray trailing fence the model hallucinated — would otherwise
-  // open an unclosed code block that swallows the wrapping `</div>` for RTL
-  // pages and break Mintlify's MDX parser.
-  const cleaned = stripStrayTrailingFence(translated);
+  // Run the same MDX sanitizers as translateMdxPage — the README emits JSX
+  // (the logo table), so its output has to satisfy Mintlify's MDX parser too:
+  // strip stray quote artifacts from JSX attributes, drop any unmatched
+  // trailing code fence the model hallucinates (which would swallow the RTL
+  // `</div>` wrapper), and convert HTML comments to MDX comments.
+  const cleaned = convertHtmlComments(
+    stripStrayTrailingFence(sanitizeJsxAttributes(translated)),
+  );
 
   const output = `${disclaimer}\n\n${langSelector}\n\n---\n${rtlOpen}\n${cleaned}\n${rtlClose}`;
 

package/scripts/translate-docs/translator.ts

@@ -3,6 +3,28 @@ import { DO_NOT_TRANSLATE } from "./config";
 
 let client: Anthropic | null = null;
 
+// Output-token ceiling for a single translation. The largest English docs
+// (e.g. agenteye/kubernetes-deployment.mdx at ~1400 lines) translate to well
+// beyond the old 16384 cap for verbose target languages. When a response hit
+// that cap it was silently truncated mid-MDX — leaving an unbalanced `{` or an
+// unterminated JSX expression — and the partial output was written to disk and
+// the cache, only to fail `mintlify validate` later in the consolidate job
+// (or, for the very largest pages, to trip the proxy with a "stream ended"
+// error). 64000 is Claude Haiku 4.5's max output (Tier 2/3 languages) and well
+// inside Claude Sonnet 4.6's 128000 (Tier 1), with headroom over the largest
+// observed translation; max_tokens is only a ceiling, so smaller pages still
+// stop at `end_turn` and cost the same. Streaming (below) is what keeps an
+// output this large safe from the SDK's HTTP timeout.
+// Override via TRANSLATE_MAX_TOKENS (integer >= 1; otherwise default).
+const parsedMaxTokens = Number.parseInt(
+  process.env.TRANSLATE_MAX_TOKENS ?? "",
+  10,
+);
+const MAX_TOKENS =
+  Number.isInteger(parsedMaxTokens) && parsedMaxTokens > 0
+    ? parsedMaxTokens
+    : 64000;
+
 function getClient(): Anthropic {
   if (!client) {
     // Default 5 retries (up from SDK default of 2) so transient
@@ -61,7 +83,7 @@ export async function translateContent(
   // as `messages.create(...)`, so the rest of the pipeline is unchanged.
   const response = await anthropic.messages.stream({
     model,
-    max_tokens: 16384,
+    max_tokens: MAX_TOKENS,
     system: [{ type: "text", text: SYSTEM_PROMPT, cache_control: { type: "ephemeral" } }],
     messages: [
       {
@@ -71,8 +93,22 @@ export async function translateContent(
     ],
   }).finalMessage();
 
+  // A truncated translation is worse than a failed one: the model stops
+  // mid-MDX, and that partial would otherwise be written to disk and cached as
+  // if complete, surfacing only as an unbalanced-brace parse error in
+  // `mintlify validate`. Fail loudly instead so the caller (cli.ts) records an
+  // error, never caches the partial, and excludes this language from the
+  // consolidate publish step. If a page ever legitimately needs more than
+  // MAX_TOKENS, raise TRANSLATE_MAX_TOKENS or split the source.
+  if (response.stop_reason === "max_tokens") {
+    throw new Error(
+      `translation truncated at max_tokens=${MAX_TOKENS} ` +
+        `(output ${response.usage.output_tokens} tokens) — source too large to translate in one request`,
+    );
+  }
+
   const translated =
-    response.content[0].type === "text" ? response.content[0].text : "";
+    response.content[0]?.type === "text" ? response.content[0].text : "";
 
   return {
     translated,

package/scripts/translate-docs/types.ts

@@ -1,5 +1,8 @@
 export interface LanguageConfig {
+  /** Internal code used for folders, cache keys, and translation routing. */
   code: string;
+  /** Mintlify locale when its canonical casing differs from `code`. */
+  mintlifyCode?: string;
   name: string;
   nativeName: string;
   tier: 1 | 2 | 3;

package/scripts/validate-mdx.ts

@@ -1,6 +1,6 @@
 /**
- * Validate that every docs MDX page parses with the same MDX engine Mintlify
- * runs at deploy time.
+ * Validate that every docs page (`.mdx` and `.md` — Mintlify parses both as
+ * MDX) parses with the same MDX engine Mintlify runs at deploy time.
  *
  * Why this exists: `mintlify validate` (the existing `docs` CI job) only checks
  * `docs.json` structure and nav-link resolution — it does NOT parse page
@@ -91,12 +91,20 @@ export function encodeAnnotation(value: string): string {
     .replace(/\n/g, "%0A");
 }
 
-function collectMdxFiles(dir: string): string[] {
+/**
+ * Collect every Mintlify content page under `dir`. Mintlify runs BOTH `.mdx`
+ * and `.md` files through the same MDX pipeline at deploy time, so a `.md` page
+ * with an MDX syntax error (e.g. an HTML `<!-- -->` comment, which MDX rejects)
+ * fails the deploy exactly like a broken `.mdx` would. The docs/i18n README
+ * translations are `.md`, so restricting this walk to `.mdx` let their breakage
+ * sail past this safety net and reach the post-merge deploy — collect both.
+ */
+export function collectMdxFiles(dir: string): string[] {
   const out: string[] = [];
   for (const entry of readdirSync(dir)) {
     const full = join(dir, entry);
     if (statSync(full).isDirectory()) out.push(...collectMdxFiles(full));
-    else if (entry.endsWith(".mdx")) out.push(full);
+    else if (entry.endsWith(".mdx") || entry.endsWith(".md")) out.push(full);
   }
   return out;
 }

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

@@ -0,0 +1,87 @@
+/**
+ * Antigravity (agy) transcript adapter — AUDIT (Pillar 2).
+ *
+ * Antigravity writes plain-JSONL transcripts at
+ * `~/.gemini/antigravity-cli/brain/<conversationId>/.system_generated/logs/transcript_full.jsonl`
+ * (one step per line), with a SQLite conversation index at
+ * `conversation_summaries.db`. Verified live against agy v1.1.2.
+ * lib/antigravity-sessions.ts enumerates + parses the transcripts into the
+ * shared LogEntry[] shape; lib/antigravity-projects.ts reads the SQLite index
+ * for cwd/title enrichment. `logEntriesToEvents` handles the rest (tool-name +
+ * tool-input canonicalization via the ANTIGRAVITY_* maps).
+ */
+import { readFile } from "node:fs/promises";
+import {
+  listAntigravityTranscripts,
+  antigravityLinesToLogEntries,
+} from "../../../lib/antigravity-sessions";
+import { getAntigravityIndex } from "../../../lib/antigravity-projects";
+import { parseRawLines } from "../../../lib/log-entries";
+import { encodeFolderName } from "../../../lib/paths";
+import type { NormalizedToolEvent, TranscriptMetadata } from "../types";
+import type { ListOpts } from "./claude";
+import { logEntriesToEvents } from "./shared";
+
+export async function listAntigravityTranscriptMetadata(
+  opts: ListOpts = {},
+): Promise<TranscriptMetadata[]> {
+  const projectFilter = opts.projects ? new Set(opts.projects) : null;
+  const sinceMs = opts.sinceMs ?? 0;
+  const out: TranscriptMetadata[] = [];
+
+  const index = await getAntigravityIndex();
+
+  for (const t of listAntigravityTranscripts()) {
+    if (t.mtimeMs < sinceMs) continue;
+    const cwd = index.get(t.conversationId)?.cwd;
+    // `audit --project <cwd>` filters on the conversation's workspace cwd.
+    if (projectFilter && (!cwd || !projectFilter.has(cwd))) continue;
+    out.push({
+      cli: "antigravity",
+      projectName: cwd ? encodeFolderName(cwd) : "antigravity",
+      sessionId: t.conversationId,
+      transcriptPath: t.transcriptPath,
+      mtimeMs: t.mtimeMs,
+      sizeBytes: t.sizeBytes,
+    });
+  }
+  return out;
+}
+
+export async function streamAntigravityEvents(
+  meta: TranscriptMetadata,
+): Promise<NormalizedToolEvent[]> {
+  let content: string;
+  try {
+    content = await readFile(meta.transcriptPath, "utf-8");
+  } catch {
+    return [];
+  }
+
+  const rawLines = parseRawLines(content, "session");
+  const entries = antigravityLinesToLogEntries(rawLines, "session");
+
+  // Recover cwd from the transcript's first run_command Cwd (falls back to "").
+  let cwd = "";
+  for (const line of rawLines) {
+    if (!line || typeof line !== "object") continue;
+    const calls = (line as Record<string, unknown>).tool_calls;
+    if (!Array.isArray(calls)) continue;
+    for (const call of calls) {
+      const args = call && typeof call === "object" ? (call as Record<string, unknown>).args : undefined;
+      const c = args && typeof args === "object" ? (args as Record<string, unknown>).Cwd : undefined;
+      if (typeof c === "string" && c.length > 0) {
+        cwd = c;
+        break;
+      }
+    }
+    if (cwd) break;
+  }
+
+  return logEntriesToEvents(entries, {
+    cli: "antigravity",
+    sessionId: meta.sessionId,
+    transcriptPath: meta.transcriptPath,
+    cwd,
+  });
+}

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

@@ -0,0 +1,53 @@
+/**
+ * Devin CLI (Cognition) transcript adapter — AUDIT-ONLY (Pillar 2).
+ *
+ * Devin keeps every session in one SQLite DB at
+ * `~/.local/share/devin/cli/sessions.db`. We read it directly via the bundled
+ * sql.js reader (lib/devin-projects.ts enumerates the `sessions` table;
+ * lib/devin-sessions.ts parses each session's `message_nodes`), producing the
+ * same LogEntry[] shape the other adapters do — so `logEntriesToEvents` handles
+ * the rest. Unlike Hermes, each Devin session carries a real
+ * `working_directory`, so `audit --project <cwd>` filters work.
+ */
+import { getDevinSessions } from "../../../lib/devin-projects";
+import { getDevinSessionLog } from "../../../lib/devin-sessions";
+import type { NormalizedToolEvent, TranscriptMetadata } from "../types";
+import type { ListOpts } from "./claude";
+import { logEntriesToEvents } from "./shared";
+
+export async function listDevinTranscriptMetadata(
+  opts: ListOpts = {},
+): Promise<TranscriptMetadata[]> {
+  const projectFilter = opts.projects ? new Set(opts.projects) : null;
+  const sinceMs = opts.sinceMs ?? 0;
+  const sessions = await getDevinSessions();
+  const out: TranscriptMetadata[] = [];
+  for (const s of sessions) {
+    if (s.mtimeMs < sinceMs) continue;
+    // `audit --project <cwd>` filters on the session's working directory.
+    if (projectFilter && (!s.cwd || !projectFilter.has(s.cwd))) continue;
+    out.push({
+      cli: "devin",
+      projectName: s.projectName,
+      sessionId: s.sessionId,
+      transcriptPath: `devin-db://${s.sessionId}`,
+      mtimeMs: s.mtimeMs,
+      // mtime advances on each message, so (mtime) forms a real cache key.
+      sizeBytes: 0,
+    });
+  }
+  return out;
+}
+
+export async function streamDevinEvents(
+  meta: TranscriptMetadata,
+): Promise<NormalizedToolEvent[]> {
+  const log = await getDevinSessionLog(meta.sessionId);
+  if (!log) return [];
+  return logEntriesToEvents(log.entries, {
+    cli: "devin",
+    sessionId: meta.sessionId,
+    transcriptPath: meta.transcriptPath,
+    cwd: log.cwd ?? "",
+  });
+}