failproofai 1.0.4-beta.1 → 1.0.4-beta.4

package/.next/standalone/app/audit/_components/how-to-improve-section.tsx

@@ -12,13 +12,18 @@
  */
 import { useMemo, useState } from "react";
 import type { AuditResult } from "@/src/audit/types";
-import { type Grade, tierName } from "@/src/audit/scoring";
+// Score switched off — see `src/audit/scoring.ts`.
+// import { type Grade, tierName } from "@/src/audit/scoring";
+import type { Grade } from "@/src/audit/scoring";
 import { usePostHog } from "@/contexts/PostHogContext";
 
 interface Props {
   result: AuditResult;
-  projected: number;
-  projectedGrade: Grade;
+  /** The projection is switched off — see `src/audit/scoring.ts`. Optional
+   *  rather than removed so restoring it is un-commenting the two lines in
+   *  `audit-dashboard.tsx` and the sub-heading below. */
+  projected?: number;
+  projectedGrade?: Grade;
 }
 
 const DETECTOR_TO_PRIMARY_POLICY: Record<string, string> = {
@@ -99,7 +104,7 @@ function bulkInstall(fixes: FixRow[]): string {
   return `failproofai policies --install ${fixes.map((f) => f.name).join(" ")}`;
 }
 
-export function HowToImproveSection({ result, projected, projectedGrade }: Props) {
+export function HowToImproveSection({ result }: Props) {
   const { capture } = usePostHog();
   const fixes = useMemo(() => buildFixes(result), [result]);
   const installAllCmd = useMemo(() => bulkInstall(fixes), [fixes]);
@@ -136,9 +141,18 @@ export function HowToImproveSection({ result, projected, projectedGrade }: Props
         </button>
       </div>
       <h2 className="audit-sec-title">install or configure</h2>
-      <div className="audit-sec-sub">
+      {/* The projected-score clause is switched off. It was also the one place
+          the product promised a number it could not deliver: `deriveScore`
+          never read `enabledInConfig`, so taking this prescription and
+          re-running returned the SAME score with the projection gone. What
+          replaces it is the thing that was always true — one command, enforced
+          on every tool call. Original:
         enable all {fixes.length === 1 ? "one" : fixes.length} → projected{" "}
         <strong>{projected}</strong> · {tierName(projectedGrade).toLowerCase()}
+      */}
+      <div className="audit-sec-sub">
+        enable all {fixes.length === 1 ? "one" : fixes.length} → one command,
+        enforced on every tool call
       </div>
 
       <div className="fix-list">

package/.next/standalone/app/audit/_components/leak-section.tsx

@@ -0,0 +1,192 @@
+"use client";
+
+/**
+ * The leak report: every credential this machine found in its own transcripts.
+ *
+ * This is what replaced the persona poster and the five scored sections. The
+ * old report answered "what kind of agent user are you"; this one answers the
+ * only question a leaked key raises — what is it, where did it go, how did it
+ * get there, and what do I do now.
+ *
+ * Each row is one DISTINCT credential, not one sighting: a key pasted into
+ * forty commands is one thing to rotate, not forty. The count of exposures is a
+ * column, which is the honest way to show forty without implying forty problems.
+ */
+import { useCallback, useEffect, useState } from "react";
+import {
+  dismissLeakAction,
+  getLeaksAction,
+  setLeakNotifyAction,
+  type LeakRow,
+} from "@/app/actions/get-leaks";
+
+/** Rendered in the reader's timezone, which is why it is not done server-side. */
+function when(iso: string): string {
+  const t = Date.parse(iso);
+  if (!Number.isFinite(t)) return "unknown";
+  const days = Math.floor((Date.now() - t) / 86_400_000);
+  if (days <= 0) return "today";
+  if (days === 1) return "yesterday";
+  if (days < 30) return `${days}d ago`;
+  return new Date(t).toLocaleDateString(undefined, { month: "short", day: "numeric" });
+}
+
+/**
+ * What to actually do about this one.
+ *
+ * Two genuinely different situations, and conflating them is what makes
+ * security advice useless. A recognised prefix means a console exists and the
+ * key can be revoked there in a minute. An unattributed value — the majority,
+ * per the pattern census — has no console at all: the only move is to find
+ * where it came from, and the identifier name is usually the only clue.
+ */
+function advice(row: LeakRow): string {
+  if (row.attributed) return `rotate it in the ${row.label.replace(/ (API )?(key|token).*$/i, "")} console`;
+  if (row.name) return `find what reads ${row.name}, then rotate it there`;
+  return "trace it to its owner, then rotate it";
+}
+
+export function LeakSection() {
+  const [rows, setRows] = useState<LeakRow[] | null>(null);
+  const [notify, setNotify] = useState(true);
+  const [busy, setBusy] = useState<string | null>(null);
+
+  const load = useCallback(async () => {
+    const payload = await getLeaksAction();
+    setRows(payload.rows);
+    setNotify(payload.notify);
+  }, []);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  const dismiss = useCallback(
+    async (id: string) => {
+      setBusy(id);
+      try {
+        // Optimism would be wrong here: a dismissal that did not persist means
+        // the row comes back on the next load, and the user has to guess which
+        // of the two states is real.
+        if (await dismissLeakAction(id)) setRows((prev) => prev?.filter((r) => r.id !== id) ?? null);
+      } finally {
+        setBusy(null);
+      }
+    },
+    [],
+  );
+
+  const toggleNotify = useCallback(async () => {
+    const next = !notify;
+    setNotify(next);
+    if (!(await setLeakNotifyAction(next))) setNotify(!next);
+  }, [notify]);
+
+  if (rows === null) return null;
+
+  return (
+    <section className="audit-sec" data-screen-label="02 Leaks">
+      <div className="audit-sec-head">
+        <span className="audit-sec-eyebrow">
+          <span className="ix">02</span>{"// credentials"}
+        </span>
+        <button
+          type="button"
+          className="cbb-toggle leak-notify"
+          data-on={notify}
+          onClick={toggleNotify}
+          aria-label={notify ? "turn desktop notifications off" : "turn desktop notifications on"}
+          title="desktop notification when a new credential is found"
+        >
+          <span className="cbb-toggle-knob" />
+        </button>
+      </div>
+
+      {rows.length === 0 ? (
+        <>
+          <h2 className="audit-sec-title">no credentials found</h2>
+          <div className="audit-sec-sub">
+            {"// nothing in this machine's transcripts matched a known key format"}
+            <br />
+            {"// or a secret-named assignment."}
+          </div>
+        </>
+      ) : (
+        <>
+          <h2 className="audit-sec-title">
+            {rows.length} credential{rows.length === 1 ? "" : "s"} in your transcripts
+          </h2>
+          <div className="audit-sec-sub">
+            {"// one row per distinct key — an exposure count is not a key count."}
+          </div>
+
+          <ul className="leak-list">
+            {rows.map((row) => (
+              <li key={row.id} className="leak-row" data-attributed={row.attributed}>
+                <div className="leak-row-top">
+                  <code className="leak-key">{row.display}</code>
+                  <span className="leak-label">{row.label}</span>
+                  {row.name ? <span className="leak-name">{row.name}</span> : null}
+                  <button
+                    type="button"
+                    className="leak-dismiss"
+                    onClick={() => void dismiss(row.id)}
+                    disabled={busy === row.id}
+                  >
+                    not a secret
+                  </button>
+                </div>
+
+                {/* The 5W1H, as one sentence rather than a grid of labelled
+                    cells — a person reading a leak wants the story, and the
+                    grid version made every row look like a form to fill in. */}
+                {/* The date is FIRST seen, not last. "When did this key get
+                    into a transcript" is the question a leak raises; "when did
+                    I last run a scan that noticed" is not. They also looked
+                    identical in practice — the record keeps the 500 most
+                    recently seen findings, so everything surviving the cap
+                    reported the same recent `lastSeen` and every row read
+                    "today", which is true and useless. */}
+                <div className="leak-how">
+                  <span className="leak-verb">{row.mechanism}</span>
+                  {" in "}
+                  <span className="leak-where">{row.project}</span>
+                  {" via "}
+                  <span className="leak-who">{row.cli}</span>
+                  {" · leaked "}
+                  <span className="leak-when">{when(row.firstSeen)}</span>
+                  {when(row.firstSeen) !== when(row.lastSeen) ? (
+                    <>
+                      {" · last seen "}
+                      <span className="leak-when">{when(row.lastSeen)}</span>
+                    </>
+                  ) : null}
+                </div>
+
+                <div className="leak-foot">
+                  <span className="leak-meta">
+                    {row.occurrences} exposure{row.occurrences === 1 ? "" : "s"}
+                    {row.sessions > 1 ? ` · ${row.sessions} sessions` : ""}
+                    {" · "}
+                    {row.length} chars
+                  </span>
+                  {/* The direction is the difference between a leak a gate can
+                      stop next time and one it cannot. An input travelled OUT
+                      of the machine with the agent's request; a result came
+                      back INTO the transcript from a file or a command, where
+                      no PreToolUse hook can intercept it. */}
+                  <span className="leak-dir">
+                    {row.direction === "input"
+                      ? "sent by the agent — blockable at PreToolUse"
+                      : "returned to the agent — already in the transcript"}
+                  </span>
+                  <span className="leak-fix">{advice(row)}</span>
+                </div>
+              </li>
+            ))}
+          </ul>
+        </>
+      )}
+    </section>
+  );
+}

package/.next/standalone/app/audit/_components/share-templates.ts

@@ -7,20 +7,31 @@
  * appends a clipboard paste hint. Pure — no React, no DOM — so it's
  * unit-testable and shared by the client poster component.
  *
- * Each template references the score and/or archetype and ends on the
- * install-free CTA + handle. We intentionally never include a URL: a bare link
- * would make X/LinkedIn render a link-preview card and swallow the copied
- * image. The npx command is the call to action instead.
+ * ## The score is switched off (2026-09-07)
+ *
+ * Every template but one used to interpolate `${score}/100`. The score is
+ * commented out across the audit — see the header of `src/audit/scoring.ts` for
+ * why — so the copy is archetype-only. Eighteen templates lost a subordinate
+ * clause; two whose entire premise WAS the number ("my agent scored X/100,
+ * think yours can beat it?") are commented out in place rather than reworded,
+ * because there is nothing left of them once the number goes.
+ *
+ * `ShareCtx.score` is kept and still populated so restoring is re-adding the
+ * clause, not re-plumbing the type. The originals are preserved verbatim in the
+ * block at the bottom of this file.
  */
 import type { Grade } from "@/src/audit/scoring";
 
 export interface ShareCtx {
-  score: number;
   /** Lowercased archetype name, e.g. "the cowboy". */
   arch: string;
-  grade: Grade;
   /** Count of unenabled prescribed policies. */
   missing: number;
+  /** Optional ONLY because the score is switched off and nothing upstream
+   *  computes them any more. Restoring the score means making these required
+   *  again — which the compiler will then walk you through. */
+  score?: number;
+  grade?: Grade;
 }
 
 /** Call-to-action + handle per channel. No URL by design (see file header). */
@@ -33,52 +44,107 @@ const PASTE_LINE = "[ audit card copied to your clipboard — paste it into the
 
 /** Short, curiosity-forward — for X / Twitter. Ends on the npx CTA + @failproofai. */
 export const X_TEMPLATES: ((c: ShareCtx) => string)[] = [
-  ({ score, arch }) =>
-    `my agent has a personality and it's ${arch}. did not see that coming.\n\nran a failproof audit, scored ${score}/100, all local. find out what yours is → ${X_CTA}`,
-  ({ score, arch }) =>
-    `spent 30 seconds auditing my agent. learned more about it than i did all month.\n\nit's ${arch}. scored ${score}/100. → ${X_CTA}`,
-  ({ score }) =>
-    `my agent scored ${score}/100. think yours can beat it?\n\n30 sec audit, runs locally, gives you a personality too → ${X_CTA}`,
+  ({ arch }) =>
+    `my agent has a personality and it's ${arch}. did not see that coming.\n\nran a failproof audit, all local. find out what yours is → ${X_CTA}`,
+  ({ arch }) =>
+    `spent 30 seconds auditing my agent. learned more about it than i did all month.\n\nit's ${arch}. → ${X_CTA}`,
+  // Score-spined — nothing survives removing the number:
+  // ({ score }) =>
+  //   `my agent scored ${score}/100. think yours can beat it?\n\n30 sec audit, runs locally, gives you a personality too → ${X_CTA}`,
   ({ arch }) =>
     `turns out my agent is ${arch} and honestly it explains everything.\n\n→ ${X_CTA}`,
-  ({ score, arch }) =>
-    `ran a failproof audit on my agent. it reads how it actually behaves when things break, not just the happy path.\n\npersonality: ${arch}. score: ${score}/100. all local → ${X_CTA}`,
-  ({ score, arch }) =>
-    `got to know my agent today. it's ${arch} and scored ${score}/100. wow.\n\naudit yours in 30s, nothing leaves your machine → ${X_CTA}`,
-  ({ score, arch }) =>
-    `your agent has a personality. you just haven't met it.\n\ni met mine today: ${arch}, ${score}/100. → ${X_CTA}`,
-  ({ score, arch }) =>
-    `everyone talks about what their agent can build. nobody talks about how it acts when it breaks.\n\nmine's ${arch}, scored ${score}/100, all local → ${X_CTA}`,
-  ({ score, arch }) =>
-    `every agent builder should run this once.\n\n30 sec, local, gives your agent a personality and a quality score. mine: ${arch}, ${score}/100.\n\n${X_CTA}`,
-  ({ score, arch }) =>
-    `i'll go first: ${arch}, ${score}/100.\n\nwhat's your agent? 30 sec audit, no signup → ${X_CTA}`,
+  ({ arch }) =>
+    `ran a failproof audit on my agent. it reads how it actually behaves when things break, not just the happy path.\n\npersonality: ${arch}. all local → ${X_CTA}`,
+  ({ arch }) =>
+    `got to know my agent today. it's ${arch}. wow.\n\naudit yours in 30s, nothing leaves your machine → ${X_CTA}`,
+  ({ arch }) =>
+    `your agent has a personality. you just haven't met it.\n\ni met mine today: ${arch}. → ${X_CTA}`,
+  ({ arch }) =>
+    `everyone talks about what their agent can build. nobody talks about how it acts when it breaks.\n\nmine's ${arch}, all local → ${X_CTA}`,
+  ({ arch }) =>
+    `every agent builder should run this once.\n\n30 sec, local, gives your agent a personality. mine: ${arch}.\n\n${X_CTA}`,
+  ({ arch }) =>
+    `i'll go first: ${arch}.\n\nwhat's your agent? 30 sec audit, no signup → ${X_CTA}`,
 ];
 
 /** Longer, reflective — for LinkedIn. Ends on the npx CTA + @Failproof AI. */
 export const LI_TEMPLATES: ((c: ShareCtx) => string)[] = [
-  ({ score, arch }) =>
-    `I've spent more hours with my agent this month than with most people I know. Today I realized I couldn't tell you a single thing about how it actually behaves.\n\nSo I audited it. Turns out it's ${arch}, and it scored ${score}/100.\n\nThe audit reads its real history, including how it handles failures, not just the clean runs. 30 seconds, runs entirely locally.\n\nMeet yours: ${LI_CTA}`,
-  ({ score, arch }) =>
-    `Took a personality test today. It wasn't for me — it was for my AI agent.\n\nThe result: ${arch}, with a quality score of ${score}/100.\n\nIt works by reading the agent's actual run history, so the personality comes from how it really behaves, not a vibe. Took 30 seconds and stayed local.\n\nTry it on yours: ${LI_CTA}`,
-  ({ score, arch }) =>
-    `Everyone asks what their AI agent can build. I just found out mine has a temper.\n\nAfter watching how it reacts to a failed command, the audit called it ${arch}. It also scored its quality at ${score}/100.\n\nOddly useful to see it written down. 30 seconds, all local: ${LI_CTA}`,
-  ({ score, arch }) =>
-    `My agent does this very specific thing every time a command fails. Today I learned there's basically a name for it.\n\nRan a quick audit and it came back ${arch}, scored ${score}/100. The whole read is based on how the agent handles things going wrong, which is where its real character shows.\n\n30 seconds, nothing leaves your machine: ${LI_CTA}`,
-  ({ score, arch }) =>
-    `My AI agent scored ${score}/100 today. I didn't know you could even measure that.\n\nThe same audit also handed it a personality: ${arch}.\n\nIt reads the agent's real history and tells you where it's solid and where it slips. Took 30 seconds and ran fully locally: ${LI_CTA}`,
-  ({ score, arch }) =>
-    `I'm usually the first to scroll past "audit your X" tools. This one took 30 seconds and actually told me something.\n\nMy agent is ${arch}, and it scored ${score}/100.\n\nIt reads the agent's real run history rather than asking me anything, and none of it leaves the machine: ${LI_CTA}`,
-  ({ score, arch }) =>
-    `What is your agent's personality? I realized today that I had no answer.\n\nSo I checked. Mine is ${arch}, scored ${score}/100, with a clear read on where it shines and where it slips.\n\nIf you work with agents, run it and drop yours in the comments. 30 seconds, fully local: ${LI_CTA}`,
-  ({ score, arch }) =>
-    `I trusted my agent a little less after this morning, and quite a bit more by the afternoon.\n\nI ran an audit on it. It showed me exactly where it's reliable and where it isn't, gave it a personality (${arch}), and scored it ${score}/100.\n\nKnowing the gaps is what made me trust it more. 30 seconds, all local: ${LI_CTA}`,
-  ({ score, arch }) =>
-    `I almost skipped this because I assumed it would quietly ship my code off somewhere. It doesn't. Everything runs locally.\n\n30 seconds later I had my agent's personality (${arch}) and a quality score (${score}/100).\n\nIf privacy is usually what stops you from trying these, this one is different: ${LI_CTA}`,
-  ({ score, arch }) =>
-    `Found out my AI agent has a personality type. Found out it's ${arch}. Found out that explains a lot.\n\nIt scored ${score}/100 too. The audit reads how the agent handles failures, not just the runs where everything goes fine.\n\n30 seconds, runs locally: ${LI_CTA}`,
+  ({ arch }) =>
+    `I've spent more hours with my agent this month than with most people I know. Today I realized I couldn't tell you a single thing about how it actually behaves.\n\nSo I audited it. Turns out it's ${arch}.\n\nThe audit reads its real history, including how it handles failures, not just the clean runs. 30 seconds, runs entirely locally.\n\nMeet yours: ${LI_CTA}`,
+  ({ arch }) =>
+    `Took a personality test today. It wasn't for me — it was for my AI agent.\n\nThe result: ${arch}.\n\nIt works by reading the agent's actual run history, so the personality comes from how it really behaves, not a vibe. Took 30 seconds and stayed local.\n\nTry it on yours: ${LI_CTA}`,
+  ({ arch }) =>
+    `Everyone asks what their AI agent can build. I just found out mine has a temper.\n\nAfter watching how it reacts to a failed command, the audit called it ${arch}.\n\nOddly useful to see it written down. 30 seconds, all local: ${LI_CTA}`,
+  ({ arch }) =>
+    `My agent does this very specific thing every time a command fails. Today I learned there's basically a name for it.\n\nRan a quick audit and it came back ${arch}. The whole read is based on how the agent handles things going wrong, which is where its real character shows.\n\n30 seconds, nothing leaves your machine: ${LI_CTA}`,
+  // Score-spined — the opening line is the number:
+  // ({ score, arch }) =>
+  //   `My AI agent scored ${score}/100 today. I didn't know you could even measure that.\n\nThe same audit also handed it a personality: ${arch}.\n\nIt reads the agent's real history and tells you where it's solid and where it slips. Took 30 seconds and ran fully locally: ${LI_CTA}`,
+  ({ arch }) =>
+    `I'm usually the first to scroll past "audit your X" tools. This one took 30 seconds and actually told me something.\n\nMy agent is ${arch}.\n\nIt reads the agent's real run history rather than asking me anything, and none of it leaves the machine: ${LI_CTA}`,
+  ({ arch }) =>
+    `What is your agent's personality? I realized today that I had no answer.\n\nSo I checked. Mine is ${arch}, with a clear read on where it shines and where it slips.\n\nIf you work with agents, run it and drop yours in the comments. 30 seconds, fully local: ${LI_CTA}`,
+  ({ arch }) =>
+    `I trusted my agent a little less after this morning, and quite a bit more by the afternoon.\n\nI ran an audit on it. It showed me exactly where it's reliable and where it isn't, and gave it a personality: ${arch}.\n\nKnowing the gaps is what made me trust it more. 30 seconds, all local: ${LI_CTA}`,
+  ({ arch }) =>
+    `I almost skipped this because I assumed it would quietly ship my code off somewhere. It doesn't. Everything runs locally.\n\n30 seconds later I had my agent's personality: ${arch}.\n\nIf privacy is usually what stops you from trying these, this one is different: ${LI_CTA}`,
+  ({ arch }) =>
+    `Found out my AI agent has a personality type. Found out it's ${arch}. Found out that explains a lot.\n\nThe audit reads how the agent handles failures, not just the runs where everything goes fine.\n\n30 seconds, runs locally: ${LI_CTA}`,
 ];
 
+/* ---------------------------------------------------------------------------
+ * THE ORIGINAL SCORE-BEARING COPY, verbatim. To restore: put these two arrays
+ * back in place of the two above, and re-enable the score at its source (see
+ * `src/audit/scoring.ts`). Nothing else has to change — `ShareCtx` is unchanged
+ * and `score` is still populated by `audit-poster.tsx`.
+ *
+ * export const X_TEMPLATES: ((c: ShareCtx) => string)[] = [
+ *   ({ score, arch }) =>
+ *     `my agent has a personality and it's ${arch}. did not see that coming.\n\nran a failproof audit, scored ${score}/100, all local. find out what yours is → ${X_CTA}`,
+ *   ({ score, arch }) =>
+ *     `spent 30 seconds auditing my agent. learned more about it than i did all month.\n\nit's ${arch}. scored ${score}/100. → ${X_CTA}`,
+ *   ({ score }) =>
+ *     `my agent scored ${score}/100. think yours can beat it?\n\n30 sec audit, runs locally, gives you a personality too → ${X_CTA}`,
+ *   ({ arch }) =>
+ *     `turns out my agent is ${arch} and honestly it explains everything.\n\n→ ${X_CTA}`,
+ *   ({ score, arch }) =>
+ *     `ran a failproof audit on my agent. it reads how it actually behaves when things break, not just the happy path.\n\npersonality: ${arch}. score: ${score}/100. all local → ${X_CTA}`,
+ *   ({ score, arch }) =>
+ *     `got to know my agent today. it's ${arch} and scored ${score}/100. wow.\n\naudit yours in 30s, nothing leaves your machine → ${X_CTA}`,
+ *   ({ score, arch }) =>
+ *     `your agent has a personality. you just haven't met it.\n\ni met mine today: ${arch}, ${score}/100. → ${X_CTA}`,
+ *   ({ score, arch }) =>
+ *     `everyone talks about what their agent can build. nobody talks about how it acts when it breaks.\n\nmine's ${arch}, scored ${score}/100, all local → ${X_CTA}`,
+ *   ({ score, arch }) =>
+ *     `every agent builder should run this once.\n\n30 sec, local, gives your agent a personality and a quality score. mine: ${arch}, ${score}/100.\n\n${X_CTA}`,
+ *   ({ score, arch }) =>
+ *     `i'll go first: ${arch}, ${score}/100.\n\nwhat's your agent? 30 sec audit, no signup → ${X_CTA}`,
+ * ];
+ *
+ * export const LI_TEMPLATES: ((c: ShareCtx) => string)[] = [
+ *   ({ score, arch }) =>
+ *     `I've spent more hours with my agent this month than with most people I know. Today I realized I couldn't tell you a single thing about how it actually behaves.\n\nSo I audited it. Turns out it's ${arch}, and it scored ${score}/100.\n\nThe audit reads its real history, including how it handles failures, not just the clean runs. 30 seconds, runs entirely locally.\n\nMeet yours: ${LI_CTA}`,
+ *   ({ score, arch }) =>
+ *     `Took a personality test today. It wasn't for me — it was for my AI agent.\n\nThe result: ${arch}, with a quality score of ${score}/100.\n\nIt works by reading the agent's actual run history, so the personality comes from how it really behaves, not a vibe. Took 30 seconds and stayed local.\n\nTry it on yours: ${LI_CTA}`,
+ *   ({ score, arch }) =>
+ *     `Everyone asks what their AI agent can build. I just found out mine has a temper.\n\nAfter watching how it reacts to a failed command, the audit called it ${arch}. It also scored its quality at ${score}/100.\n\nOddly useful to see it written down. 30 seconds, all local: ${LI_CTA}`,
+ *   ({ score, arch }) =>
+ *     `My agent does this very specific thing every time a command fails. Today I learned there's basically a name for it.\n\nRan a quick audit and it came back ${arch}, scored ${score}/100. The whole read is based on how the agent handles things going wrong, which is where its real character shows.\n\n30 seconds, nothing leaves your machine: ${LI_CTA}`,
+ *   ({ score, arch }) =>
+ *     `My AI agent scored ${score}/100 today. I didn't know you could even measure that.\n\nThe same audit also handed it a personality: ${arch}.\n\nIt reads the agent's real history and tells you where it's solid and where it slips. Took 30 seconds and ran fully locally: ${LI_CTA}`,
+ *   ({ score, arch }) =>
+ *     `I'm usually the first to scroll past "audit your X" tools. This one took 30 seconds and actually told me something.\n\nMy agent is ${arch}, and it scored ${score}/100.\n\nIt reads the agent's real run history rather than asking me anything, and none of it leaves the machine: ${LI_CTA}`,
+ *   ({ score, arch }) =>
+ *     `What is your agent's personality? I realized today that I had no answer.\n\nSo I checked. Mine is ${arch}, scored ${score}/100, with a clear read on where it shines and where it slips.\n\nIf you work with agents, run it and drop yours in the comments. 30 seconds, fully local: ${LI_CTA}`,
+ *   ({ score, arch }) =>
+ *     `I trusted my agent a little less after this morning, and quite a bit more by the afternoon.\n\nI ran an audit on it. It showed me exactly where it's reliable and where it isn't, gave it a personality (${arch}), and scored it ${score}/100.\n\nKnowing the gaps is what made me trust it more. 30 seconds, all local: ${LI_CTA}`,
+ *   ({ score, arch }) =>
+ *     `I almost skipped this because I assumed it would quietly ship my code off somewhere. It doesn't. Everything runs locally.\n\n30 seconds later I had my agent's personality (${arch}) and a quality score (${score}/100).\n\nIf privacy is usually what stops you from trying these, this one is different: ${LI_CTA}`,
+ *   ({ score, arch }) =>
+ *     `Found out my AI agent has a personality type. Found out it's ${arch}. Found out that explains a lot.\n\nIt scored ${score}/100 too. The audit reads how the agent handles failures, not just the runs where everything goes fine.\n\n30 seconds, runs locally: ${LI_CTA}`,
+ * ];
+ * ------------------------------------------------------------------------- */
+
 /** djb2 hash — stable per seed so the template choice is deterministic. */
 function hashStr(s: string): number {
   let h = 5381;

package/.next/standalone/app/audit/audit-styles.css

@@ -496,7 +496,13 @@
 .poster-meta .of { color: var(--dim); }
 .poster-meta .poster-sep { color: var(--dim); }
 
-/* body — vertical centered stack: sigil → persona → score ─── */
+/* body — vertical centered stack: sigil → persona → score ───
+   The score block is switched off (see `src/audit/scoring.ts`), so this stack
+   currently renders two children, not three. It is a centered flex column with
+   a gap and no fixed track count, so it re-centers on its own. The
+   `.poster-score` rules below are kept, dormant, against the score coming
+   back — do not tidy them away, or restoring it means rewriting the styles
+   too. */
 .poster-body {
   display: flex;
   flex-direction: column;
@@ -555,6 +561,7 @@
 .poster-persona .persona-rarity .pct { color: var(--accent-pink); font-weight: 600; }
 
 /* score — score-n + /100, baseline-aligned and centered in the card. */
+/* Dormant while the score is switched off — see `src/audit/scoring.ts`. */
 .poster-score {
   display: flex;
   align-items: baseline;
@@ -1157,3 +1164,127 @@
 .share-card {
   max-width: 420px;
 }
+
+/* ── Leak report ─────────────────────────────────────────────────────────────
+   One block per distinct credential. Deliberately NOT a table: a table implies
+   columns worth scanning down, and the interesting comparison between two
+   leaked keys is never "which is longer" — it is what each one is and where it
+   went, which reads as a sentence.                                            */
+
+.leak-notify { margin-left: auto; }
+
+.leak-list {
+  list-style: none;
+  margin: 20px 0 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.leak-row {
+  border: 1px solid var(--line-2);
+  /* Hard-offset pixel shadow, never a blur — the house rule. Pink is the
+     accent that means "this one is yours to act on". */
+  box-shadow: 4px 4px 0 0 var(--line-2);
+  padding: 14px 16px;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  background: var(--bg);
+}
+/* A recognised prefix means a console exists and this is revocable in a
+   minute. That is a real difference in what the reader has to do, so it is the
+   one thing the row's own frame encodes. */
+.leak-row[data-attributed="true"] { box-shadow: 4px 4px 0 0 var(--accent-pink); }
+
+.leak-row-top {
+  display: flex;
+  align-items: baseline;
+  gap: 10px;
+  flex-wrap: wrap;
+}
+
+.leak-key {
+  font-family: var(--font-mono);
+  font-size: 14px;
+  color: var(--ink);
+  letter-spacing: 0.02em;
+  /* The masked value can be long; it must wrap rather than push the row wide. */
+  word-break: break-all;
+}
+
+.leak-label {
+  font-family: var(--font-mono);
+  font-size: 11px;
+  color: var(--accent-pink);
+  text-transform: lowercase;
+}
+
+.leak-name {
+  font-family: var(--font-mono);
+  font-size: 11px;
+  color: var(--ink-2);
+  border: 1px solid var(--line-2);
+  padding: 1px 5px;
+}
+
+.leak-dismiss {
+  margin-left: auto;
+  font-family: var(--font-mono);
+  font-size: 10px;
+  color: var(--dim);
+  background: none;
+  border: 1px solid var(--line-2);
+  padding: 3px 8px;
+  cursor: pointer;
+  text-transform: lowercase;
+}
+.leak-dismiss:hover:not(:disabled) { color: var(--ink); border-color: var(--ink-2); }
+.leak-dismiss:disabled { opacity: 0.4; cursor: not-allowed; }
+.leak-dismiss:focus-visible { outline: 2px solid var(--accent-pink); outline-offset: 2px; }
+
+.leak-how {
+  font-family: var(--font-mono);
+  font-size: 12px;
+  color: var(--ink-2);
+  line-height: 1.6;
+}
+.leak-verb { color: var(--ink); }
+.leak-where { color: var(--accent-green); }
+.leak-who { color: var(--ink); }
+.leak-when { color: var(--dim); }
+
+.leak-foot {
+  display: flex;
+  gap: 14px;
+  flex-wrap: wrap;
+  font-family: var(--font-mono);
+  font-size: 10px;
+  color: var(--dim);
+}
+.leak-fix { color: var(--accent-green); }
+.leak-dir { color: var(--ink-2); }
+
+@media (max-width: 640px) {
+  .leak-dismiss { margin-left: 0; }
+  .leak-foot { gap: 6px; flex-direction: column; }
+}
+
+/* The re-scan control in the scan header. Sits at the end of the eyebrow row so
+   it reads as an action on that section rather than a page-level nav item. */
+.scan-rerun {
+  margin-left: auto;
+  font-family: var(--font-mono);
+  font-size: 10.5px;
+  letter-spacing: 0.1em;
+  text-transform: lowercase;
+  color: var(--ink-2);
+  background: none;
+  border: 1px solid var(--line-2);
+  padding: 4px 10px;
+  cursor: pointer;
+}
+.scan-rerun:hover:not(:disabled) { color: var(--ink); border-color: var(--accent-pink); }
+.scan-rerun:disabled { opacity: 0.5; cursor: not-allowed; }
+.scan-rerun:focus-visible { outline: 2px solid var(--accent-pink); outline-offset: 2px; }