failproofai 0.0.13-beta.2 → 0.0.14-beta.0

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/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/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 ?? "",
+  });
+}

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

@@ -0,0 +1,75 @@
+/**
+ * Factory (droid) transcript adapter — AUDIT (Pillar 2).
+ *
+ * droid writes real JSONL transcripts at
+ * `~/.factory/sessions/<encoded-cwd>/<sessionId>.jsonl` (Claude-style
+ * encoded-cwd folders; verified live against droid v0.171.0).
+ * lib/factory-sessions.ts enumerates and parses them into the shared
+ * LogEntry[] shape, so `logEntriesToEvents` handles the rest.
+ */
+import { readFile } from "node:fs/promises";
+import {
+  listFactoryTranscripts,
+  factoryLinesToLogEntries,
+} from "../../../lib/factory-sessions";
+import { parseRawLines } from "../../../lib/log-entries";
+import type { NormalizedToolEvent, TranscriptMetadata } from "../types";
+import type { ListOpts } from "./claude";
+import { logEntriesToEvents } from "./shared";
+
+export async function listFactoryTranscriptMetadata(
+  opts: ListOpts = {},
+): Promise<TranscriptMetadata[]> {
+  const projectFilter = opts.projects ? new Set(opts.projects) : null;
+  const sinceMs = opts.sinceMs ?? 0;
+  const out: TranscriptMetadata[] = [];
+
+  for (const t of listFactoryTranscripts()) {
+    if (t.mtimeMs < sinceMs) continue;
+    // `audit --project <cwd>` filters on the decoded working directory.
+    if (projectFilter && !projectFilter.has(t.cwd)) continue;
+    out.push({
+      cli: "factory",
+      projectName: t.projectName,
+      sessionId: t.sessionId,
+      transcriptPath: t.transcriptPath,
+      mtimeMs: t.mtimeMs,
+      sizeBytes: t.sizeBytes,
+    });
+  }
+  return out;
+}
+
+export async function streamFactoryEvents(
+  meta: TranscriptMetadata,
+): Promise<NormalizedToolEvent[]> {
+  let content: string;
+  try {
+    content = await readFile(meta.transcriptPath, "utf-8");
+  } catch {
+    return [];
+  }
+
+  const rawLines = parseRawLines(content, "session");
+  const entries = factoryLinesToLogEntries(rawLines, "session");
+
+  // cwd lives on the `type:"session_start"` header line — recover the canonical
+  // value rather than re-decoding the (lossy) folder name.
+  let cwd = "";
+  for (const line of rawLines) {
+    if (line && typeof line === "object" && (line as Record<string, unknown>).type === "session_start") {
+      const c = (line as Record<string, unknown>).cwd;
+      if (typeof c === "string" && c.length > 0) {
+        cwd = c;
+        break;
+      }
+    }
+  }
+
+  return logEntriesToEvents(entries, {
+    cli: "factory",
+    sessionId: meta.sessionId,
+    transcriptPath: meta.transcriptPath,
+    cwd,
+  });
+}

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

@@ -0,0 +1,53 @@
+/**
+ * Goose (codename goose, Block) transcript adapter — AUDIT-ONLY (Pillar 2).
+ *
+ * Goose keeps every session in one SQLite DB at
+ * `~/.local/share/goose/sessions/sessions.db`. We read it directly via the
+ * bundled sql.js reader (lib/goose-projects.ts enumerates the `sessions` table;
+ * lib/goose-sessions.ts parses each session's `messages`), producing the same
+ * LogEntry[] shape the other adapters do — so `logEntriesToEvents` handles the
+ * rest. Like Devin, each Goose session carries a real `working_dir`, so
+ * `audit --project <cwd>` filters work (unlike the cwd-less Hermes gateway).
+ */
+import { getGooseSessions } from "../../../lib/goose-projects";
+import { getGooseSessionLog } from "../../../lib/goose-sessions";
+import type { NormalizedToolEvent, TranscriptMetadata } from "../types";
+import type { ListOpts } from "./claude";
+import { logEntriesToEvents } from "./shared";
+
+export async function listGooseTranscriptMetadata(
+  opts: ListOpts = {},
+): Promise<TranscriptMetadata[]> {
+  const projectFilter = opts.projects ? new Set(opts.projects) : null;
+  const sinceMs = opts.sinceMs ?? 0;
+  const sessions = await getGooseSessions();
+  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: "goose",
+      projectName: s.projectName,
+      sessionId: s.sessionId,
+      transcriptPath: `goose-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 streamGooseEvents(
+  meta: TranscriptMetadata,
+): Promise<NormalizedToolEvent[]> {
+  const log = await getGooseSessionLog(meta.sessionId);
+  if (!log) return [];
+  return logEntriesToEvents(log.entries, {
+    cli: "goose",
+    sessionId: meta.sessionId,
+    transcriptPath: meta.transcriptPath,
+    cwd: log.cwd ?? "",
+  });
+}

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

@@ -17,8 +17,12 @@ import { listCopilotTranscriptMetadata, streamCopilotEvents } from "./copilot";
 import { listCursorTranscriptMetadata, streamCursorEvents } from "./cursor";
 import { listOpenCodeTranscriptMetadata, streamOpenCodeEvents } from "./opencode";
 import { listPiTranscriptMetadata, streamPiEvents } from "./pi";
-import { listGeminiTranscriptMetadata, streamGeminiEvents } from "./gemini";
 import { listHermesTranscriptMetadata, streamHermesEvents } from "./hermes";
+import { listOpenClawTranscriptMetadata, streamOpenClawEvents } from "./openclaw";
+import { listFactoryTranscriptMetadata, streamFactoryEvents } from "./factory";
+import { listAntigravityTranscriptMetadata, streamAntigravityEvents } from "./antigravity";
+import { listDevinTranscriptMetadata, streamDevinEvents } from "./devin";
+import { listGooseTranscriptMetadata, streamGooseEvents } from "./goose";
 
 export type { ListOpts };
 
@@ -59,16 +63,36 @@ export const ADAPTERS: Record<IntegrationType, CliAdapter> = {
     listTranscripts: listPiTranscriptMetadata,
     streamEvents: streamPiEvents,
   },
-  gemini: {
-    cli: "gemini",
-    listTranscripts: listGeminiTranscriptMetadata,
-    streamEvents: streamGeminiEvents,
-  },
   hermes: {
     cli: "hermes",
     listTranscripts: listHermesTranscriptMetadata,
     streamEvents: streamHermesEvents,
   },
+  openclaw: {
+    cli: "openclaw",
+    listTranscripts: listOpenClawTranscriptMetadata,
+    streamEvents: streamOpenClawEvents,
+  },
+  factory: {
+    cli: "factory",
+    listTranscripts: listFactoryTranscriptMetadata,
+    streamEvents: streamFactoryEvents,
+  },
+  devin: {
+    cli: "devin",
+    listTranscripts: listDevinTranscriptMetadata,
+    streamEvents: streamDevinEvents,
+  },
+  antigravity: {
+    cli: "antigravity",
+    listTranscripts: listAntigravityTranscriptMetadata,
+    streamEvents: streamAntigravityEvents,
+  },
+  goose: {
+    cli: "goose",
+    listTranscripts: listGooseTranscriptMetadata,
+    streamEvents: streamGooseEvents,
+  },
 };
 
 export function getAdapter(cli: IntegrationType): CliAdapter {

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

@@ -0,0 +1,56 @@
+/**
+ * OpenClaw (openclaw gateway) transcript adapter — AUDIT (Pillar 2).
+ *
+ * OpenClaw writes real JSONL transcripts at
+ * `~/.openclaw/agents/<agentId>/sessions/<uuid>.jsonl` (verified live against
+ * v2026.7.1). lib/openclaw-sessions.ts enumerates and parses them into the
+ * shared LogEntry[] shape, so `logEntriesToEvents` handles the rest.
+ *
+ * Gateway sessions run in the container workspace, not a host repo, so they
+ * group by agentId (`openclaw:<agentId>`) and contribute nothing to a
+ * cwd-scoped audit.
+ */
+import {
+  listOpenClawTranscripts,
+  getOpenClawSessionLog,
+} from "../../../lib/openclaw-sessions";
+import type { NormalizedToolEvent, TranscriptMetadata } from "../types";
+import type { ListOpts } from "./claude";
+import { logEntriesToEvents } from "./shared";
+
+export async function listOpenClawTranscriptMetadata(
+  opts: ListOpts = {},
+): Promise<TranscriptMetadata[]> {
+  // `audit --project <cwd>` filters on working directory; gateway sessions run
+  // in the container workspace, not a host repo, so OpenClaw contributes
+  // nothing to a cwd-scoped audit.
+  if (opts.projects && opts.projects.length > 0) return [];
+
+  const sinceMs = opts.sinceMs ?? 0;
+  const out: TranscriptMetadata[] = [];
+  for (const t of listOpenClawTranscripts()) {
+    if (t.mtimeMs < sinceMs) continue;
+    out.push({
+      cli: "openclaw",
+      projectName: `openclaw:${t.agentId}`,
+      sessionId: t.sessionId,
+      transcriptPath: t.transcriptPath,
+      mtimeMs: t.mtimeMs,
+      sizeBytes: t.sizeBytes,
+    });
+  }
+  return out;
+}
+
+export async function streamOpenClawEvents(
+  meta: TranscriptMetadata,
+): Promise<NormalizedToolEvent[]> {
+  const log = await getOpenClawSessionLog(meta.sessionId);
+  if (!log) return [];
+  return logEntriesToEvents(log.entries, {
+    cli: "openclaw",
+    sessionId: meta.sessionId,
+    transcriptPath: meta.transcriptPath,
+    cwd: log.cwd ?? "",
+  });
+}

package/src/audit/cli.ts

@@ -20,6 +20,7 @@ import { writeDashboardCache } from "./dashboard-cache";
 import type { AuditResult, RunAuditOptions } from "./types";
 import { trackHookEvent } from "../hooks/hook-telemetry";
 import { getInstanceId } from "../../lib/telemetry-id";
+import { sanitizeErrorMessage } from "../../lib/telemetry-sanitize";
 import { openWhenReady } from "./open-browser";
 
 /** Port the bundled dashboard binds to. Matches `scripts/launch.ts`'s default
@@ -49,7 +50,7 @@ USAGE
 
 WHAT IT DOES
   1. Scans past sessions from every installed agent CLI (Claude, Codex, Cursor,
-     Copilot, OpenCode, Pi, Gemini) — entirely on your machine.
+     Copilot, OpenCode, Pi) — entirely on your machine.
   2. Starts the local dashboard and opens
      http://localhost:${DASHBOARD_PORT}/audit with your results.
 
@@ -236,6 +237,47 @@ function printSummary(result: AuditResult): void {
   for (const line of buildSummary(result)) process.stdout.write(`  ${line}\n`);
 }
 
+// ── Post-setup background audit ────────────────────────────────────────────────
+
+/**
+ * Run the audit *pipeline* (scan + cache write + summary) once the setup flow
+ * completes, right before the dashboard boots. Pre-warms
+ * `~/.failproofai/audit-dashboard.json` so the dashboard renders instantly, and
+ * immediately shows the user what's slipping through.
+ *
+ * Shows the same animated stages as `failproofai audit`. The scan runs to
+ * completion; Ctrl+C interrupts it the usual way (default SIGINT). Best-effort:
+ * never throws, never exits the process; the caller boots the dashboard
+ * afterward. Opt out with `FAILPROOFAI_NO_AUTO_AUDIT=1`.
+ */
+export async function runPostSetupAudit(): Promise<void> {
+  if (process.env.FAILPROOFAI_NO_AUTO_AUDIT === "1") return;
+  
+  process.stdout.write(
+    `\n  ${c(PINK, "✦")} ${c(BOLD, "failproofai audit now running")}  ${c(DIM, "· ctrl+c to stop")}\n\n`,
+  );
+
+  let result: AuditResult;
+  try {
+    result = await runWithProgress({});
+  } catch {
+    process.stdout.write(
+      `  ${c(PINK, "!")} ${c(DIM, "audit couldn't finish — run")} ${c(CYAN, "failproofai audit")} ${c(DIM, "later.")}\n\n`,
+    );
+    return;
+  }
+
+  if (result.eventsScanned === 0) {
+    process.stdout.write(
+      `\n  ${c(DIM, "no agent sessions to audit yet — come back after using your agent.")}\n\n`,
+    );
+    return;
+  }
+  writeDashboardCache({}, result);
+  printSummary(result);
+  process.stdout.write("\n");
+}
+
 // ── Entry point ──────────────────────────────────────────────────────────────
 
 export async function runAuditCli(args: string[]): Promise<void> {
@@ -275,6 +317,7 @@ export async function runAuditCli(args: string[]): Promise<void> {
     await trackHookEvent(instanceId, "cli_audit_failed", {
       source: "cli",
       error_type: err instanceof Error ? err.name : "unknown",
+      error_message: sanitizeErrorMessage(err),
     });
     die(`Audit failed: ${err instanceof Error ? err.message : String(err)}`);
   }

package/src/audit/report.ts

@@ -273,7 +273,7 @@ export function formatMarkdown(result: AuditResult): string {
     );
   }
   out.push("");
-  out.push("> [failproofai](https://github.com/FailproofAI/failproofai) is a hook-based policy engine for Claude Code, Codex, Copilot, Cursor, OpenCode, Pi, and Gemini CLI. The `audit` command replays past agent sessions through every builtin policy to surface patterns that were (or could've been) stopped.");
+  out.push("> [failproofai](https://github.com/FailproofAI/failproofai) is a hook-based policy engine for Claude Code, Codex, Copilot, Cursor, OpenCode, and Pi. The `audit` command replays past agent sessions through every builtin policy to surface patterns that were (or could've been) stopped.");
   out.push("");
 
   if (totalHits === 0) return out.join("\n");

package/src/audit/types.ts

@@ -24,7 +24,7 @@ export interface NormalizedToolEvent {
   toolName: string;
   /** Canonicalized tool input (snake_case keys for OpenCode/Pi). */
   toolInput: Record<string, unknown>;
-  /** Pre-canonicalization tool name (e.g. "run_shell_command" for Gemini). */
+  /** Pre-canonicalization tool name (e.g. "exec" for OpenClaw). */
   rawToolName: string;
   /**
    * Result text from the matching tool_result block, if present in the

package/src/hooks/builtin-policies.ts

@@ -53,9 +53,9 @@ function isAgentInternalPath(resolved: string): boolean {
  *   • Pi:           `.pi/settings.json` (project) and `.pi/agent/settings.json`
  *                   (user); also the Pi-managed extension dir
  *                   `.pi/extensions/` / `.pi/agent/extensions/`.
- *   • Gemini CLI:   `.gemini/settings.json` (both project and user scope —
- *                   user is `~/.gemini/settings.json`); also the Gemini-managed
- *                   hooks scripts dir `.gemini/hooks/`.
+ *   • Antigravity CLI (agy): reuses `~/.gemini/` — `~/.gemini/settings.json`
+ *                   and the customization-root hook config
+ *                   `~/.gemini/config/hooks.json`.
  * These must NEVER be edited by the agent itself — that would let it disable
  * its own protections.
  */
@@ -74,9 +74,9 @@ function isAgentSettingsFile(resolved: string): boolean {
   // Pi: settings + extensions dirs (project and user-scope variants).
   if (/[\\/]\.pi[\\/](?:agent[\\/])?settings\.json$/.test(resolved)) return true;
   if (/[\\/]\.pi[\\/](?:agent[\\/])?extensions[\\/]/.test(resolved)) return true;
-  // Gemini: settings.json + hooks dir referenced by `command: $GEMINI_PROJECT_DIR/.gemini/hooks/...`.
+  // Antigravity (agy) reuses ~/.gemini/: settings.json + the customization-root hooks.json.
   if (/[\\/]\.gemini[\\/]settings\.json$/.test(resolved)) return true;
-  if (/[\\/]\.gemini[\\/]hooks[\\/]/.test(resolved)) return true;
+  if (/[\\/]\.gemini[\\/]config[\\/]hooks\.json$/.test(resolved)) return true;
   return false;
 }