failproofai 1.0.1-beta.1 → 1.0.2-beta.0

package/scripts/translate-docs/cli.ts

@@ -39,6 +39,11 @@ const { values: args } = parseArgs({
     validate: { type: "boolean", default: false },
     prune: { type: "boolean", default: false },
     "no-prune": { type: "boolean", default: false },
+    // Publish what succeeded instead of discarding it. One page failing used to
+    // exit 1, which made the box job die before its push — on 2026-08-18 that
+    // threw away 782 good translations (2.7M tokens) because ONE page overran
+    // the output limit. Opt-in, so CI and hand runs keep failing loudly.
+    "allow-partial": { type: "boolean", default: false },
     model: { type: "string", short: "m" },
     help: { type: "boolean", short: "h", default: false },
   },
@@ -56,6 +61,8 @@ Options:
       --readme-only        Only translate the README
       --docs-only          Only translate Mintlify docs
       --dry-run            Show what would be translated without calling the API
+      --allow-partial      Exit 0 when SOME pages translated, listing the failures
+                           (default: any failure exits 1 and publishes nothing)
   -f, --force              Ignore cache, re-translate everything
       --update-nav         Regenerate docs.json navigation after translation
       --validate           Check all nav references resolve to files
@@ -441,6 +448,20 @@ async function main() {
   }
 
   if (errors.length > 0) {
+    // Printed either way — a partial run must never read as a clean one.
+    console.log(`\nFAILED PAGES (${errors.length}):`);
+    for (const e of errors) {
+      console.log(`  ${e.source} [${e.lang}]: ${e.error}`);
+    }
+    if (args["allow-partial"] && translated.length > 0) {
+      // A stable marker the box job greps for, so the failure reaches Slack and
+      // the PR body instead of being buried in a 700-line log.
+      console.log(
+        `\nPARTIAL RUN — ${translated.length} page(s) translated, ${errors.length} failed. ` +
+          `Publishing what succeeded.`,
+      );
+      return;
+    }
     process.exit(1);
   }
 }

package/scripts/translate-docs/config.ts

@@ -71,8 +71,26 @@ export function getLanguageCodes(maxTier?: number): string[] {
   return langs.map((l) => l.code);
 }
 
-/** Return the default model for a given tier. Tier 1 gets Sonnet, Tier 2/3 gets Haiku. */
+/**
+ * Return the model for a given tier. Tier 1 gets Sonnet, Tier 2/3 gets Haiku.
+ *
+ * Both are overridable from the environment, PER TIER, because cost and quality
+ * do not want the same answer here. Tier 1 is Chinese, Japanese, Korean,
+ * Spanish, Portuguese, German and French — the languages most readers actually
+ * arrive in — and the tier split exists precisely so the cheap model is not
+ * asked to carry them. `--model` on the CLI flattens every tier to one model;
+ * these let the box spend differently on the two halves:
+ *
+ *   TRANSLATE_MODEL_TIER1=claude-sonnet-4-6     # quality where it is read
+ *   TRANSLATE_MODEL_TIER23=deepseek-v4-flash    # cheap for the long tail
+ *
+ * Any id the gateway serves over the Anthropic /v1/messages shape works — the
+ * translator speaks that API, not OpenAI's, so an id has to be reachable there
+ * (verified: deepseek-v4-pro and deepseek-v4-flash both are).
+ */
 export function getModelForTier(tier: number): string {
+  const override = tier <= 1 ? process.env.TRANSLATE_MODEL_TIER1 : process.env.TRANSLATE_MODEL_TIER23;
+  if (override && override.trim()) return override.trim();
   return tier <= 1 ? "claude-sonnet-4-6" : "claude-haiku-4-5";
 }
 

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

@@ -1,19 +1,29 @@
-import { readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { getLanguageByCode, NAV_TRANSLATIONS } from "./config";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const DOCS_JSON_PATH = join(__dirname, "..", "..", "docs", "docs.json");
+const DOCS_DIR = join(__dirname, "..", "..", "docs");
+const DOCS_JSON_PATH = join(DOCS_DIR, "docs.json");
 
 interface NavGroup {
   group: string;
-  pages: string[];
+  // OPTIONAL, and both of these are why: a Mintlify group may carry `pages`, or
+  // nested `groups`, or neither — the docs rebuild introduced a group whose
+  // content is an `openapi` spec and has no pages at all. `pages` entries are
+  // likewise strings OR nested groups. Typing these as required is what let
+  // `group.pages.map` crash the nightly run.
+  pages?: (string | NavGroup)[];
+  groups?: NavGroup[];
+  // Everything else (expanded, icon, openapi, …) rides along untouched.
+  [key: string]: unknown;
 }
 
 interface NavTab {
   tab: string;
   groups: NavGroup[];
+  [key: string]: unknown;
 }
 
 interface LanguageNav {
@@ -76,9 +86,33 @@ export function getNavigationPageReferences(
  * Build a navigation entry for a specific language by transforming the
  * English navigation structure.
  */
+/**
+ * Does the localized file for a nav entry exist on disk?
+ *
+ * Defaults to "yes" so the pure transform stays testable with fixtures, and the
+ * REAL check is injected by updateDocsJson / localizeProductsNavigation, which
+ * are the two paths that write docs.json.
+ */
+export type PageExists = (relativePath: string) => boolean;
+
+const fileOnDisk: PageExists = (rel) => existsSync(join(DOCS_DIR, rel));
+
+/**
+ * Keep a group only if it still carries something to render. Dropping every
+ * missing page can empty a group, and an empty group is its own validation
+ * error — but a group whose content is an `openapi` spec has no pages by
+ * design and must survive.
+ */
+function hasContent(group: NavGroup): boolean {
+  if (Array.isArray(group.pages) && group.pages.length > 0) return true;
+  if (Array.isArray(group.groups) && group.groups.length > 0) return true;
+  return !Array.isArray(group.pages) && !Array.isArray(group.groups);
+}
+
 export function buildLanguageNav(
   englishTabs: NavTab[],
   lang: string,
+  exists: PageExists = () => true,
 ): LanguageNav {
   const t = NAV_TRANSLATIONS[lang];
   if (!t) throw new Error(`No nav translations for language: ${lang}`);
@@ -97,13 +131,47 @@ export function buildLanguageNav(
     Examples: t.examples,
   };
 
-  const tabs: NavTab[] = englishTabs.map((tab) => ({
-    tab: tabNameMap[tab.tab] || tab.tab,
-    groups: tab.groups.map((group) => ({
-      group: groupNameMap[group.group] || group.group,
-      pages: group.pages.map((page) => `${lang}/${page}`),
-    })),
-  }));
+  // Rebuilt by SPREADING the English group, not by picking two fields off it.
+  // The old form silently dropped every other key — `expanded`, `icon`,
+  // `openapi` — so a localized nav quietly lost them, and it crashed outright
+  // on the first group that had no `pages` at all.
+  const localizeGroup = (group: NavGroup): NavGroup => {
+    const out: NavGroup = { ...group, group: groupNameMap[group.group] || group.group };
+    if (Array.isArray(group.pages)) {
+      // A page entry is a path to prefix, or a nested group to recurse into.
+      //
+      // A path is DROPPED when its localized file is not on disk. The English
+      // tree is the source of the nav, so without this every English page gets
+      // an entry in all fourteen languages whether or not it was translated —
+      // and `mintlify validate` rejects the run. That took down a nightly job
+      // that had already translated 784 pages: one page failed, the nav still
+      // referenced it in that language, and every successful page was discarded
+      // with it. Omitting the entry is the honest state: the page does not
+      // exist in that language yet.
+      out.pages = group.pages
+        .map((page) =>
+          typeof page === "string" ? `${lang}/${page}` : localizeGroup(page),
+        )
+        .filter((page) =>
+          typeof page === "string" ? exists(`${page}.mdx`) : hasContent(page),
+        );
+    }
+    if (Array.isArray(group.groups)) {
+      out.groups = group.groups.map(localizeGroup).filter(hasContent);
+    }
+    // No pages and no groups (an `openapi` group): carried through as-is. The
+    // spec is not translated, and dropping the group would remove the API
+    // reference from every non-English nav.
+    return out;
+  };
+
+  const tabs: NavTab[] = englishTabs
+    .map((tab) => ({
+      ...tab,
+      tab: tabNameMap[tab.tab] || tab.tab,
+      groups: (tab.groups ?? []).map(localizeGroup).filter(hasContent),
+    }))
+    .filter((tab) => tab.groups.length > 0);
 
   return {
     language: getLanguageByCode(lang)?.mintlifyCode ?? lang,
@@ -125,10 +193,11 @@ export function readDocsConfig(): Record<string, unknown> {
 export function generateLanguagesArray(
   englishTabs: NavTab[],
   langCodes: string[],
+  exists: PageExists = () => true,
 ): LanguageNav[] {
   // English first (default)
   const english: LanguageNav = { language: "en", tabs: englishTabs };
-  const others = langCodes.map((code) => buildLanguageNav(englishTabs, code));
+  const others = langCodes.map((code) => buildLanguageNav(englishTabs, code, exists));
   return [english, ...others];
 }
 
@@ -136,6 +205,9 @@ export function generateLanguagesArray(
 export function localizeProductsNavigation(
   products: unknown[],
   langCodes: string[],
+  // Defaults to the real disk check, like updateDocsJson — injectable so the
+  // pure transform can be exercised against fixtures that are not on disk.
+  exists: PageExists = fileOnDisk,
 ): Record<string, unknown>[] {
   return products.map((value) => {
     const product = value as Record<string, unknown>;
@@ -149,7 +221,7 @@ export function localizeProductsNavigation(
     const { tabs: _tabs, ...rest } = product;
     return {
       ...rest,
-      languages: generateLanguagesArray(englishTabs, langCodes),
+      languages: generateLanguagesArray(englishTabs, langCodes, exists),
     };
   });
 }
@@ -177,7 +249,7 @@ export function updateDocsJson(langCodes: string[]): void {
   }
 
   const newNav: Record<string, unknown> = {
-    languages: generateLanguagesArray(englishTabs, langCodes),
+    languages: generateLanguagesArray(englishTabs, langCodes, fileOnDisk),
   };
   if (nav.global) {
     newNav.global = nav.global;

package/scripts/translate-docs/translator.ts

@@ -44,6 +44,24 @@ const MAX_ATTEMPTS =
     ? parsedMaxAttempts
     : 3;
 
+// How far past the source an output may run before a max_tokens stop reads as a
+// repetition loop rather than a large page. Translations of the verbose targets
+// (hi, vi, ja) sit near 2x the source's token estimate; 6x is far outside that
+// band and was ~16x in the observed failure.
+// Validated the same way MAX_TOKENS and MAX_ATTEMPTS above are, and for a
+// sharper reason: `parseInt(...) || 6` accepts a NEGATIVE, and a negative ratio
+// makes `output > source * ratio` true for every response — so a genuinely
+// oversized page would be classified as a runaway and burn all three attempts
+// to arrive exactly where it started.
+const parsedRunawayRatio = Number.parseInt(
+  process.env.TRANSLATE_RUNAWAY_RATIO ?? "",
+  10,
+);
+const RUNAWAY_RATIO =
+  Number.isInteger(parsedRunawayRatio) && parsedRunawayRatio > 0
+    ? parsedRunawayRatio
+    : 6;
+
 function getClient(): Anthropic {
   if (!client) {
     // Default 5 retries (up from SDK default of 2) so transient
@@ -151,10 +169,32 @@ export async function translateContent(
   // 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(
+    // TWO different failures wear this stop_reason, and only one of them is
+    // "the page is too big". A 16 KB source whose Vietnamese translation
+    // emitted 64 000 output tokens — observed on the box, 2026-08-18,
+    // reference/cloud-cli.mdx [vi] — is a DEGENERATE SAMPLE: the model fell
+    // into a repetition loop. Resampling fixes that; splitting the source does
+    // not, and treating it as a size problem sent one page's hiccup on to fail
+    // the whole nightly run.
+    //
+    // The tell is the ratio. Source bytes / 4 is a rough token count, and a
+    // faithful translation lands within a small multiple of it — even for the
+    // verbose target languages. Far beyond that is the model talking to
+    // itself, so the error is marked RETRYABLE and translateValidated spends
+    // an attempt on it. A source that genuinely approaches the ceiling keeps
+    // the old fail-loud behaviour, because retrying it would burn the budget
+    // three times to reach the same place.
+    const sourceTokensApprox = Math.max(1, Math.ceil(content.length / 4));
+    const runaway = response.usage.output_tokens > sourceTokensApprox * RUNAWAY_RATIO;
+    const err = new Error(
       `translation truncated at max_tokens=${MAX_TOKENS} ` +
-        `(output ${response.usage.output_tokens} tokens) — source too large to translate in one request`,
+        `(output ${response.usage.output_tokens} tokens, source ~${sourceTokensApprox}) — ` +
+        (runaway
+          ? "output dwarfs the source, which is a runaway sample rather than an oversized page"
+          : "source too large to translate in one request"),
     );
+    (err as Error & { retryable?: boolean }).retryable = runaway;
+    throw err;
   }
 
   const translated =
@@ -211,15 +251,30 @@ export async function translateValidated(opts: {
         ? { attempt, maxAttempts: MAX_ATTEMPTS, error: lastError }
         : undefined;
 
-    // No try/catch: a transport/auth/max_tokens throw is not a validity
-    // failure — let it propagate so it is never silently retried as one.
-    const result = await translateContent(
-      opts.source,
-      opts.lang,
-      opts.langName,
-      opts.model,
-      feedback,
-    );
+    // Transport/auth throws still propagate untouched — they are not validity
+    // failures and must never be silently retried as one. The ONE exception is
+    // a truncation flagged `retryable` (a runaway sample, see translateContent):
+    // that is a bad draw, and a bad draw is exactly what this loop is for.
+    let result: Awaited<ReturnType<typeof translateContent>>;
+    try {
+      result = await translateContent(
+        opts.source,
+        opts.lang,
+        opts.langName,
+        opts.model,
+        feedback,
+      );
+    } catch (e) {
+      const err = e as Error & { retryable?: boolean };
+      if (!err.retryable || attempt === MAX_ATTEMPTS) throw err;
+      lastError =
+        "The previous attempt ran past the output limit by repeating itself. " +
+        "Translate the document once, completely, and stop.";
+      console.warn(
+        `  ${opts.label} -> attempt ${attempt}/${MAX_ATTEMPTS} overran the output limit; retrying`,
+      );
+      continue;
+    }
     inputTokens += result.inputTokens;
     outputTokens += result.outputTokens;
 

package/src/audit/cache.ts

@@ -13,6 +13,7 @@ import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from "node:fs";
 import { join } from "node:path";
 import { BUILTIN_POLICIES } from "../hooks/builtin-policies";
+import { readInstalledPacks } from "../hooks/pack-manifest";
 import { AUDIT_DETECTORS } from "./detectors";
 import type { TranscriptAuditResult } from "./types";
 import { auditCacheDir } from "../hooks/fp-home";
@@ -20,14 +21,43 @@ import { auditCacheDir } from "../hooks/fp-home";
 let cachedEngineVersion: string | null = null;
 let cachedDetectorVersion: string | null = null;
 
-/** Hash of every builtin policy's name + function body. Changes when policy
- *  code changes, invalidating downstream caches. */
+/**
+ * Hash of every builtin policy's name + function body, PLUS the identity of every
+ * installed pack. Changes when policy code changes, invalidating downstream
+ * caches.
+ *
+ * Packs belong in this key because they change what a machine would have caught,
+ * which is exactly what a cached audit result claims to know. They are folded in
+ * by `id|version|sha256` rather than by source text: the pack's bytes are already
+ * digest-pinned, and hashing the loaded source instead would drag in the
+ * per-load temporary filename the loader rewrites into every import specifier —
+ * which changes on every single run and would cold-rescan the whole history each
+ * time.
+ *
+ * **A machine with no packs must hash byte-identically to a build with no pack
+ * support at all.** Otherwise merely shipping this feature invalidates every
+ * user's audit cache and forces a ~104-second cold rescan on upgrade, for a
+ * capability they are not using. Hence the empty pack set contributes nothing —
+ * not an empty line, not a separator.
+ */
 function getEngineVersion(): string {
   if (cachedEngineVersion) return cachedEngineVersion;
-  const blob = BUILTIN_POLICIES
+  const builtinBlob = BUILTIN_POLICIES
     .map((p) => `${p.name}|${p.fn.toString()}`)
     .sort()
     .join("\n");
+  // Never throws by contract, but this runs inside the audit's own try/catch-free
+  // path and a cache key is not worth taking the run down for.
+  let packBlob = "";
+  try {
+    packBlob = readInstalledPacks()
+      .packs.map((pack) => `${pack.id}|${pack.version}|${pack.sha256}`)
+      .sort()
+      .join("\n");
+  } catch {
+    packBlob = "";
+  }
+  const blob = packBlob ? `${builtinBlob}\n${packBlob}` : builtinBlob;
   cachedEngineVersion = createHash("sha1").update(blob).digest("hex").slice(0, 16);
   return cachedEngineVersion;
 }
@@ -43,6 +73,13 @@ function getDetectorVersion(): string {
   return cachedDetectorVersion;
 }
 
+/** Exposed for `engine-version-packs.test.ts`, which pins the upgrade-cost
+ *  guarantee: a machine with no packs must hash exactly as it did before packs
+ *  existed. Nothing else should call this. */
+export function getEngineVersionForTest(): string {
+  return getEngineVersion();
+}
+
 function getCachePathFor(transcriptPath: string): string {
   const root = auditCacheDir();
   const key = createHash("sha1").update(transcriptPath).digest("hex");

package/src/audit/cli.ts

@@ -58,7 +58,7 @@ export const EXIT_AUDIT_ALREADY_RUNNING = 75;
 export const AUDIT_STAGES: ReadonlyArray<{ label: string; detail: string }> = [
   { label: "discovering transcripts", detail: "walking ~/.claude, ~/.codex, ~/.cursor, …" },
   { label: "parsing session logs", detail: "reading JSONL + sqlite session stores" },
-  { label: "running policy checks", detail: "replaying through 30 builtin policies" },
+  { label: "running policy checks", detail: "replaying every policy against each tool call" },
   { label: "aggregating results", detail: "counting hits, ranking by frequency" },
 ];
 

package/src/audit/index.ts

@@ -261,7 +261,7 @@ function aggregateResults(
 
 export async function runAudit(opts: RunAuditOptions = {}): Promise<AuditResult> {
   const startedAt = Date.now();
-  initReplay();
+  await initReplay();
   try {
     return await runAuditInner(opts, startedAt);
   } finally {

package/src/audit/replay.ts

@@ -13,13 +13,19 @@
  * execSync against live git, so they never fire on PreToolUse/PostToolUse
  * replay — no explicit skip needed.
  */
+import { resolve } from "node:path";
+import { existsSync } from "node:fs";
 import type { EvaluationResult } from "../hooks/policy-evaluator";
 import { evaluatePolicies } from "../hooks/policy-evaluator";
 import { BUILTIN_POLICIES, registerBuiltinPolicies } from "../hooks/builtin-policies";
+import { PACK_ENTRY_ASSET, bundledPackDir } from "../hooks/pack-store";
+import { loadCustomHooks } from "../hooks/custom-hooks-loader";
+import { clearCustomHooks } from "../hooks/custom-hooks-registry";
 import {
   clearPolicies,
   getAllPolicies,
   normalizePolicyName,
+  registerPolicy,
   setAllPolicies,
 } from "../hooks/policy-registry";
 import type { RegisteredPolicy } from "../hooks/policy-types";
@@ -44,17 +50,97 @@ let savedSnapshot: RegisteredPolicy[] | null = null;
  *  shows what *could* be caught, not just what's currently enabled. Called
  *  once per `runAudit` invocation. Snapshots the existing registry so it can
  *  be restored by `restoreReplay()` once the audit is done. */
-export function initReplay(): void {
+export async function initReplay(): Promise<void> {
   if (initialized) return;
   savedSnapshot = getAllPolicies();
   clearPolicies();
   const enabled = BUILTIN_POLICIES
     .map((p) => p.name)
     .filter((n) => !SKIP_POLICIES.has(normalizePolicyName(n)));
-  registerBuiltinPolicies(enabled);
+  if (!(await registerFromVendoredPack(enabled))) registerBuiltinPolicies(enabled);
   initialized = true;
 }
 
+/**
+ * Register the audit's policies from the pack that ships inside the package,
+ * rather than from implementations compiled into this build.
+ *
+ * The audit scores by RUNNING the policies — three of its four penalty buckets
+ * are replay hits — so the day the builtins stop being compiled in, this is
+ * what keeps `failproofai audit` reporting the same findings and the same score
+ * for the same transcripts. The pack carries the identical functions:
+ * `builtin-pack-conformance.test.ts` replays a corpus through both and asserts
+ * the verdicts do not diverge.
+ *
+ * Two things it must get right, or the audit quietly changes:
+ *
+ * - The pack cannot carry `block-failproofai-commands`, because `alwaysOn` is
+ *   refused by the pack loader by design — a downloaded file that no local
+ *   command can switch off. It is registered from the compiled side, so the
+ *   replayed set is the same 39 either way.
+ * - The skip list still applies. `warn-repeated-tool-calls` writes a per-session
+ *   sidecar into the user's real transcript directory on every evaluation.
+ *
+ * Returns false when there is no vendored pack to read — a source checkout that
+ * has not run `build:pack`, or a tarball packed without it — and the caller
+ * falls back to the compiled implementations. An audit that silently scored on
+ * fewer policies would be worse than either.
+ */
+async function registerFromVendoredPack(enabled: string[]): Promise<boolean> {
+  const dir = bundledPackDir();
+  if (!dir) return false;
+  const entry = resolve(dir, PACK_ENTRY_ASSET);
+  if (!existsSync(entry)) return false;
+
+  const wanted = new Set(enabled);
+  let hooks;
+  try {
+    clearCustomHooks();
+    hooks = await loadCustomHooks(entry, { strict: true });
+  } catch {
+    return false;
+  } finally {
+    clearCustomHooks();
+  }
+  if (hooks.length === 0) return false;
+  const fromPack = new Map(hooks.map((hook) => [hook.name, hook]));
+
+  // Registered in CATALOG ORDER, taking the pack's function where it has one and
+  // the compiled one for the guard the pack may not carry.
+  //
+  // Order is not cosmetic here. `getPoliciesForEvent` sorts by priority only and
+  // V8's sort is stable, so registration order decides EVALUATION order, and
+  // `evaluatePolicies` stops at the first deny — which means the order decides
+  // which policy is CREDITED for a hit. Appending the always-on guard after the
+  // pack instead of at its catalog position moved it from index 11 to last, and
+  // re-attributed 3 events in a 23,477-event corpus: 456 -> 453 for the guard,
+  // with the denies it used to shadow surfacing as block-force-push and
+  // block-gh-pipeline. The audit's per-policy counts are what a user reads, so
+  // that is a changed audit, not a changed internal.
+  let registered = 0;
+  for (const policy of BUILTIN_POLICIES) {
+    if (!wanted.has(policy.name)) continue;
+    const packHook = fromPack.get(policy.name);
+    if (policy.alwaysOn || !packHook) {
+      registerPolicy(policy.name, policy.description, policy.fn, policy.match, 0, policy.params);
+      continue;
+    }
+    registerPolicy(
+      packHook.name,
+      packHook.description ?? policy.description,
+      packHook.fn,
+      packHook.match ?? policy.match,
+      0,
+      policy.params,
+    );
+    registered += 1;
+  }
+  // Nothing came from the pack: it loaded but carried none of the names the
+  // audit replays. Falling back is more honest than scoring on the compiled set
+  // while claiming the pack lane ran.
+  return registered > 0;
+}
+
 /** Restore the registry to whatever was there before `initReplay()`. Safe to
  *  call when not initialized (no-op). Always paired with `initReplay()` in a
  *  try/finally inside `runAudit()`. */
@@ -87,7 +173,7 @@ export interface ReplayHit {
  *  is reported too, so sanitize policies that emit informational notes still
  *  surface in the audit. */
 export async function replayEvent(event: NormalizedToolEvent): Promise<ReplayHit[]> {
-  if (!initialized) initReplay();
+  if (!initialized) await initReplay();
 
   const session: SessionMetadata = {
     sessionId: event.sessionId,

package/src/audit/report.ts

@@ -263,16 +263,16 @@ export function formatMarkdown(result: AuditResult): string {
   out.push("## TL;DR");
   out.push("");
   if (totalHits === 0) {
-    out.push("Clean run — the AI coding agent didn't do anything `failproofai` catches in this window.");
+    out.push("Clean run — the agent didn't do anything `failproofai` catches in this window.");
   } else {
     out.push(
-      `Over ${result.transcripts.scanned} sessions, my AI coding agent did **${totalHits} things \`failproofai\` would have stopped**: ` +
-      `${totalProtected} were already blocked in real time by my current config; ` +
-      `**${totalSlipping} slipped through** (would've been caught if more policies were on).`,
+      `Over ${result.transcripts.scanned} sessions, my agent did **${totalHits} things \`failproofai\` caught**: ` +
+      `${totalProtected} were blocked in real time by my current config; ` +
+      `**${totalSlipping} slipped through** and were only caught by the audit.`,
     );
   }
   out.push("");
-  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("> [failproofai](https://github.com/FailproofAI/failproofai) is a hook-based policy engine for 12 agent harnesses — coding CLIs, chat gateways, and self-hosted assistants. 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");