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

package/.next/standalone/.opencode/plugins/failproofai.mjs

@@ -18,7 +18,7 @@
 //   • src/hooks/integrations.ts (buildOpenCodePluginShim production template)
 // When #337 landed, this dev shim drifted and `block-read-outside-cwd`
 // silently no-op'd on every opencode `read` call inside this repo.
-import { spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import { resolveDevSpawn } from "../../scripts/dev-hook.mjs";
 
 const BUS_EVENT_MAP = {
@@ -70,34 +70,58 @@ function canonicalizeToolInput(canonicalToolName, args) {
   return out;
 }
 
-function runFailproofai(eventName, payload, directory) {
-  // Shared with the JSON configs' launcher: locates bun across PATH, ~/.bun/bin,
-  // $BUN_INSTALL, Homebrew and every nvm version dir. A bare spawnSync("bun")
-  // dies with ENOENT the moment bun is off the hook's PATH.
-  const spawn = resolveDevSpawn();
-  if (!spawn) {
+/**
+ * Run failproofai for one event WITHOUT blocking opencode's event loop.
+ *
+ * This was `spawnSync`, and opencode loads the plugin in-process in the TUI —
+ * so every hook froze rendering and input for the subprocess's full duration,
+ * with a 60s ceiling. The verdicts are unchanged: every caller already `await`s
+ * `applyDecision`, so the deny still lands before the tool runs. What changes
+ * is that the wait is now a promise rather than a blocked thread, and the TUI
+ * keeps painting while it happens.
+ *
+ * Fail-open on spawn error, and on the timeout — a policy that never ran must
+ * not read as a deny.
+ */
+async function runFailproofai(eventName, payload, directory) {
+  const resolved = resolveDevSpawn();
+  if (!resolved) {
     process.stderr.write(
       "[failproofai-dev] bun not found — opencode policies are NOT enforcing. " +
         "Install bun: curl -fsSL https://bun.sh/install | bash\n",
     );
     return { exitCode: 0, stdout: "", stderr: "" };
   }
-  const r = spawnSync(spawn.cmd, [...spawn.args, "--hook", eventName, "--cli", "opencode"], {
-    input: JSON.stringify(payload),
-    encoding: "utf8",
-    timeout: 60_000,
-    cwd: directory,
+  const cmd = resolved.cmd;
+  const args = [...resolved.args, "--hook", eventName, "--cli", "opencode"];
+  return await new Promise((resolveRun) => {
+    let child;
+    try {
+      child = spawn(cmd, args, { cwd: directory });
+    } catch {
+      resolveRun({ exitCode: 0, stdout: "", stderr: "" });
+      return;
+    }
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const finish = (exitCode) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolveRun({ exitCode, stdout, stderr });
+    };
+    const timer = setTimeout(() => {
+      try { child.kill("SIGKILL"); } catch { /* already gone */ }
+      finish(0);
+    }, 60_000);
+    child.stdout.on("data", (d) => { stdout += d; });
+    child.stderr.on("data", (d) => { stderr += d; });
+    child.on("error", () => finish(0));
+    child.on("close", (code) => finish(code ?? 0));
+    child.stdin.on("error", () => {});
+    child.stdin.end(JSON.stringify(payload));
   });
-  // `r.status` is null when the spawn never ran (ENOENT) or the child was
-  // killed. Coercing that to 0 reports "allowed" for a policy that never got
-  // to run, so say so on stderr rather than failing open in silence.
-  if (r.status === null) {
-    process.stderr.write(
-      `[failproofai-dev] ${eventName} hook did not run (${r.error?.code ?? r.signal ?? "unknown"}) — not enforcing\n`,
-    );
-    return { exitCode: 0, stdout: "", stderr: "" };
-  }
-  return { exitCode: r.status, stdout: r.stdout ?? "", stderr: r.stderr ?? "" };
 }
 
 async function applyDecision(result, ctx, eventName) {
@@ -150,7 +174,7 @@ export default async function failproofaiPlugin({ client, directory }) {
           }
         }
         if (!prompt) prompt = (info.text || info.content || props.text || "").toString();
-        const r = runFailproofai("UserPromptSubmit", {
+        const r = await runFailproofai("UserPromptSubmit", {
           session_id: sessionID, cwd: directory, hook_event_name: "UserPromptSubmit", prompt,
         }, directory);
         await applyDecision(r, { client, sessionID }, "UserPromptSubmit");
@@ -160,7 +184,7 @@ export default async function failproofaiPlugin({ client, directory }) {
       if (!claudeEvent) return;
       const props = event.properties || {};
       const sessionID = props.sessionID || (props.session && props.session.id) || props.id;
-      const r = runFailproofai(claudeEvent, {
+      const r = await runFailproofai(claudeEvent, {
         session_id: sessionID, cwd: directory, hook_event_name: claudeEvent,
       }, directory);
       await applyDecision(r, { client, sessionID }, claudeEvent);
@@ -168,7 +192,7 @@ export default async function failproofaiPlugin({ client, directory }) {
 
     "tool.execute.before": async (input, output) => {
       const canonicalTool = canonicalizeTool(input.tool);
-      const r = runFailproofai("PreToolUse", {
+      const r = await runFailproofai("PreToolUse", {
         session_id: input.sessionID,
         cwd: directory,
         tool_name: canonicalTool,
@@ -180,7 +204,7 @@ export default async function failproofaiPlugin({ client, directory }) {
 
     "tool.execute.after": async (input, output) => {
       const canonicalTool = canonicalizeTool(input.tool);
-      const r = runFailproofai("PostToolUse", {
+      const r = await runFailproofai("PostToolUse", {
         session_id: input.sessionID,
         cwd: directory,
         tool_name: canonicalTool,
@@ -193,7 +217,7 @@ export default async function failproofaiPlugin({ client, directory }) {
 
     "permission.ask": async (input, output) => {
       const canonicalTool = canonicalizeTool(input.tool);
-      const r = runFailproofai("PermissionRequest", {
+      const r = await runFailproofai("PermissionRequest", {
         session_id: input.sessionID,
         cwd: directory,
         tool_name: canonicalTool || input.command || "permission",

package/.next/standalone/app/actions/get-leaks.ts

@@ -0,0 +1,109 @@
+"use server";
+
+import {
+  activeFindings,
+  dismissFinding,
+  markLeakReportViewed,
+  readLeakRecord,
+} from "@/src/audit/leak-store";
+import { readConfig, updateConfig } from "@/src/hooks/fp-config";
+
+/**
+ * One credential, flattened for the report table.
+ *
+ * A separate shape from `LeakFinding` on purpose: this crosses into a client
+ * component, so it carries only what is drawn. The finding's raw sightings, its
+ * rule and its salt stay on the server side of the boundary — not because any
+ * of them is a secret (the record holds no secret by construction), but because
+ * a display type that mirrors the storage type drifts into rendering whatever
+ * gets added to storage next.
+ */
+export interface LeakRow {
+  id: string;
+  /** WHAT — `ghp_••••••••4f2a`. Never the value; there is no value to send. */
+  display: string;
+  label: string;
+  length: number;
+  /** False means no console to revoke at — the advice changes completely. */
+  attributed: boolean;
+  /** The identifier it was assigned to, when there was one. */
+  name: string | null;
+  /** WHO — the harness whose transcript carried it. */
+  cli: string;
+  /** WHERE — home-shortened project path. */
+  project: string;
+  /** WHEN — ISO, formatted client-side so it lands in the reader's timezone. */
+  lastSeen: string;
+  firstSeen: string;
+  /** HOW — "read from ~/…/.env". */
+  mechanism: string;
+  /** WHY IT MATTERS — an input the agent sent can be denied next time; a
+   *  result it received cannot be un-received. */
+  direction: "input" | "result";
+  occurrences: number;
+  sessions: number;
+}
+
+export interface LeaksPayload {
+  rows: LeakRow[];
+  /** Whether this machine may raise a desktop notification. Drawn as a toggle
+   *  beside the table, because the table is where somebody decides the banner
+   *  was worth it or not. */
+  notify: boolean;
+}
+
+export async function getLeaksAction(): Promise<LeaksPayload> {
+  const findings = activeFindings(readLeakRecord());
+  // Opening the report is the one signal worth silencing the in-CLI notice on.
+  // Recorded here rather than on a button, because reading it is the action —
+  // there is nothing further for the user to do to say "I have seen this".
+  markLeakReportViewed();
+  const rows: LeakRow[] = findings.map((f) => {
+    // The most recent sighting: where the key is now, not where it debuted.
+    const seen = f.sightings?.[f.sightings.length - 1];
+    return {
+      id: f.id,
+      display: f.fingerprint?.display ?? "[credential]",
+      label: f.fingerprint?.label ?? "secret",
+      length: f.fingerprint?.length ?? 0,
+      attributed: f.fingerprint?.attributed === true,
+      name: f.name,
+      cli: seen?.cli ?? "unknown",
+      project: seen?.cwd ?? "unknown",
+      lastSeen: f.lastSeen,
+      firstSeen: f.firstSeen,
+      mechanism: seen?.mechanism?.summary ?? "seen in a transcript",
+      direction: seen?.mechanism?.direction ?? "result",
+      occurrences: f.occurrences,
+      sessions: new Set((f.sightings ?? []).map((s) => s.sessionId)).size,
+    };
+  });
+  rows.sort((a, b) => Date.parse(b.lastSeen) - Date.parse(a.lastSeen));
+  return { rows, notify: readConfig().audit.notify };
+}
+
+/**
+ * Mark one finding as not-a-secret.
+ *
+ * The finding is RETAINED, not deleted — deleting it would let the next scan
+ * rediscover the same value and alert again, which is the one outcome that
+ * teaches a user the dismiss button does not work.
+ */
+export async function dismissLeakAction(id: string): Promise<boolean> {
+  return dismissFinding(id);
+}
+
+/**
+ * Turn the desktop banner on or off.
+ *
+ * Writes the same `audit.notify` key `failproofai config` writes and the daemon's
+ * audit child reads, so the dashboard and the CLI cannot disagree about it.
+ */
+export async function setLeakNotifyAction(notify: boolean): Promise<boolean> {
+  try {
+    updateConfig({ audit: { notify } });
+    return true;
+  } catch {
+    return false;
+  }
+}

package/.next/standalone/app/audit/_components/audit-dashboard.tsx

@@ -3,8 +3,8 @@
 /**
  * Top-level client wrapper for /audit.
  *
- * Composes the calm personality report: classify the agent into one of
- * 8 archetypes, derive a score, and render the 5-section flow:
+ * The old five-section personality report is SWITCHED OFF and being rebuilt
+ * bottom-up around leak detection. What it used to compose:
  *
  *   01 AuditPoster — single-screen shareable poster
  *   02 StrengthsSection — what it's great at
@@ -12,23 +12,36 @@
  *   04 HowToImproveSection — install / configure
  *   05 ComeBackBetterSection — spread the audit (invite)
  *
+ * Every one of those components, and the score / persona / strengths / findings
+ * modules behind them, is intact and still unit-tested — only the renders and
+ * the imports here are commented out, so restoring any of it is deleting a pair
+ * of comment markers. See the header of `src/audit/scoring.ts` for why.
+ *
+ * What this page renders now is `AuditReportPlaceholder`: the scan's own
+ * numbers. The scan, the 12-CLI transcript reader and the emailed digest all
+ * still run.
+ *
  * Empty / running states fall back to EmptyState and RunProgress.
  */
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { getAuditResultAction } from "@/app/actions/get-audit-result";
 import type { AuditResult, RunAuditOptions } from "@/src/audit/types";
-import { classifyAgent } from "@/src/audit/archetypes";
-import { deriveScore, gradeFor, projectedScore } from "@/src/audit/scoring";
-import { deriveStrengths } from "@/src/audit/strengths";
-import { deriveFindings } from "@/src/audit/findings";
+// import { classifyAgent } from "@/src/audit/archetypes";
+// Score switched off — see the header of `src/audit/scoring.ts`.
+// import { deriveScore, gradeFor, projectedScore } from "@/src/audit/scoring";
+// import { deriveStrengths } from "@/src/audit/strengths";
+// import { deriveFindings } from "@/src/audit/findings";
 import { usePostHog } from "@/contexts/PostHogContext";
 
-import { AuditPoster } from "./audit-poster";
-import { StrengthsSection } from "./strengths-section";
-import { QuirksSection } from "./quirks-section";
-import { HowToImproveSection } from "./how-to-improve-section";
-import { ComeBackBetterSection } from "./come-back-better-section";
+// The old report's five sections — switched off, not deleted. Each component
+// file and its tests are untouched; only this render is commented out.
+// import { AuditPoster } from "./audit-poster";
+// import { StrengthsSection } from "./strengths-section";
+// import { QuirksSection } from "./quirks-section";
+// import { HowToImproveSection } from "./how-to-improve-section";
+// import { ComeBackBetterSection } from "./come-back-better-section";
 import { ReportFooter } from "./report-footer";
+import { LeakSection } from "./leak-section";
 import { EmptyState } from "./empty-state";
 import { RunProgress } from "./run-progress";
 import { AuditProgressStrip, type RerunStatus } from "./audit-progress-strip";
@@ -46,7 +59,9 @@ type Initial =
 /** Tag passed to the shared `startRerun()` handler so PostHog can tell
  *  whether the click came from the bottom return-section button or the
  *  empty-state CTA. */
-export type RerunSource = "return_section" | "empty_state";
+// `scan_header` is the button in section 01 — the only re-scan control the
+// page has now that the old report's sections are switched off.
+export type RerunSource = "return_section" | "empty_state" | "scan_header";
 
 interface Props {
   initial: Initial;
@@ -59,6 +74,9 @@ interface Props {
   totalCatalogSize: number;
 }
 
+/* Switched off with the persona layer — this named the project that seeded the
+   archetype classifier and the leaderboard row. Restore alongside
+   `classifyAgent` in this file.
 function inferProjectName(result: AuditResult, override?: string): string {
   if (override && override.trim()) return override;
   // Pick the cwd that appears in the most examples — proxy for "your
@@ -81,6 +99,7 @@ function inferProjectName(result: AuditResult, override?: string): string {
   if (segs.length >= 2) return `${segs[segs.length - 2]} / ${segs[segs.length - 1]}`;
   return segs[segs.length - 1] ?? "your agent";
 }
+*/
 
 export function AuditDashboard({ initial, projectFromUrl, totalCatalogSize }: Props) {
   const [cache, setCache] = useState<Initial>(initial);
@@ -279,16 +298,22 @@ function MainReport({
   onDismissRerun,
 }: MainReportProps) {
   const { capture } = usePostHog();
-  const project = useMemo(() => inferProjectName(result, projectFromUrl), [result, projectFromUrl]);
+  // Only fed the persona classifier, which is switched off with it.
+  // const project = useMemo(() => inferProjectName(result, projectFromUrl), [result, projectFromUrl]);
   // Seed classification with the project name so the behaviour fingerprint
   // (used for tie-breaks + copy variants) is stable per project.
-  const classification = useMemo(() => classifyAgent(result, project), [result, project]);
-  const score = useMemo(() => deriveScore(result), [result]);
-  const projected = useMemo(() => projectedScore(result, score), [result, score]);
-  const grade = gradeFor(score);
-  const projectedGrade = gradeFor(projected);
-  const strengths = useMemo(() => deriveStrengths(result), [result]);
-  const findings = useMemo(() => deriveFindings(result), [result]);
+  // Persona classification is switched off with the rest of the old report. Its
+  // last live use was two telemetry properties describing a persona the product
+  // no longer shows anyone.
+  // const classification = useMemo(() => classifyAgent(result, project), [result, project]);
+  // Score switched off — see the header of `src/audit/scoring.ts`. The four
+  // functions are intact and still unit-tested; nothing calls them.
+  // const score = useMemo(() => deriveScore(result), [result]);
+  // const projected = useMemo(() => projectedScore(result, score), [result, score]);
+  // const grade = gradeFor(score);
+  // const projectedGrade = gradeFor(projected);
+  // const strengths = useMemo(() => deriveStrengths(result), [result]);
+  // const findings = useMemo(() => deriveFindings(result), [result]);
 
   // One pass over result.results: detectors triggered + missing prescribed
   // policies. Both feed PostHog instrumentation; `missing` also feeds the
@@ -310,10 +335,13 @@ function MainReport({
     if (dashboardViewedRef.current) return;
     dashboardViewedRef.current = true;
     capture("audit_dashboard_viewed", {
-      score,
-      grade,
-      archetype: classification.archetype,
-      secondary: classification.secondary ?? null,
+      // Score switched off — see `src/audit/scoring.ts`. `missing` is the
+      // prescription's denominator and is unaffected, so the copy→install
+      // funnel keeps both of its ends.
+      // score,
+      // grade,
+      // archetype: classification.archetype,
+      // secondary: classification.secondary ?? null,
       missing,
       transcripts_scanned: result.transcripts.scanned,
       results_count: result.results.length,
@@ -321,10 +349,6 @@ function MainReport({
     });
   }, [
     capture,
-    score,
-    grade,
-    classification.archetype,
-    classification.secondary,
     missing,
     result.transcripts.scanned,
     result.results.length,
@@ -332,19 +356,43 @@ function MainReport({
   ]);
 
   /** Poster ref — captured to PNG by the poster's share buttons. */
-  const posterRef = useRef<HTMLDivElement>(null);
+  // const posterRef = useRef<HTMLDivElement>(null);
 
   return (
     <div className="app">
       <AuditProgressStrip status={rerunStatus} onDismiss={onDismissRerun} />
       <div className="app-shell">
         <div className="report">
+          <AuditReportPlaceholder
+            transcripts={result.transcripts.scanned}
+            events={result.eventsScanned ?? 0}
+            projects={result.projectsScanned.length}
+            isRunning={isRunning || rerunStatus.kind === "running"}
+            onRerun={() => onRerun("scan_header")}
+          />
+          {/* The rebuilt report. It reads the leak record rather than this
+              scan's result, deliberately: a credential found last month and
+              not touched by today's transcripts is still a credential to
+              rotate, and a report that showed only the current scan's findings
+              would go quiet on exactly those. */}
+          <LeakSection />
+          {/* The whole old report is switched off — the persona poster, the
+              strengths and quirks sections, the punch-list with its install-all
+              funnel, and the invite section. It is being rebuilt bottom-up
+              around leak detection; see the header of `src/audit/scoring.ts`
+              for the reasoning and `~/Desktop/failproofai-leak-detection-
+              verdict-2026-09-07.md` for the measurements behind it.
+
+              Every component below is intact and still unit-tested — only the
+              render is commented — so restoring any one of them is deleting a
+              pair of comment markers.
+
           <AuditPoster
             ref={posterRef}
             archetypeKey={classification.archetype}
             seed={classification.variantSeed}
-            score={score}
-            grade={grade}
+            // score={score}
+            // grade={grade}
             missing={missing}
             auditedAt={cachedAt ?? new Date().toISOString()}
           />
@@ -352,10 +400,11 @@ function MainReport({
           <QuirksSection findings={findings} />
           <HowToImproveSection
             result={result}
-            projected={projected}
-            projectedGrade={projectedGrade}
+          // projected={projected}
+          // projectedGrade={projectedGrade}
           />
-          <ComeBackBetterSection score={score} />
+          <ComeBackBetterSection />
+          */}
         </div>
         <ReportFooter cachedAt={cachedAt} />
       </div>
@@ -363,6 +412,63 @@ function MainReport({
   );
 }
 
+/**
+ * What `/audit` shows while the report is being rebuilt.
+ *
+ * Deliberately states the scan's own numbers rather than nothing at all: the
+ * scan still runs, still walks every transcript across all 12 CLIs, and still
+ * feeds the emailed digest. Saying so is the difference between "this page is
+ * under construction" and "this product is broken".
+ */
+function AuditReportPlaceholder(
+  {
+    transcripts,
+    events,
+    projects,
+    isRunning,
+    onRerun,
+  }: {
+    transcripts: number;
+    events: number;
+    projects: number;
+    isRunning: boolean;
+    onRerun: () => void;
+  },
+) {
+  const n = (x: number) => x.toLocaleString();
+  return (
+    <section className="audit-sec" data-screen-label="01 Scan">
+      <div className="audit-sec-head">
+        <span className="audit-sec-eyebrow">
+          <span className="ix">01</span>{"// scan"}
+        </span>
+        {/* The re-scan control. It lived in the old report's sections and went
+            dormant when they were commented out, which left the page with no way
+            to run an audit again at all — you had to go back to the terminal. */}
+        <button
+          type="button"
+          className="scan-rerun"
+          onClick={onRerun}
+          disabled={isRunning}
+        >
+          {isRunning ? "scanning…" : "run again"}
+        </button>
+      </div>
+      <h2 className="audit-sec-title">scan complete</h2>
+      <div className="audit-sec-sub">
+        {n(events)} tool call{events === 1 ? "" : "s"} across {n(transcripts)}{" "}
+        transcript{transcripts === 1 ? "" : "s"}
+        {projects > 0 ? ` · ${n(projects)} project${projects === 1 ? "" : "s"}` : ""}
+      </div>
+      <div className="audit-sec-sub">
+        {"// the report is being rebuilt around leak detection. the scan, the"}
+        <br />
+        {"// 12-CLI transcript reader and the emailed digest are unaffected."}
+      </div>
+    </section>
+  );
+}
+
 interface ShellEmptyProps {
   running: boolean;
   mode?: "no-cache" | "zero-sessions";

package/.next/standalone/app/audit/_components/audit-poster.tsx

@@ -24,7 +24,12 @@
 import React, { forwardRef, useMemo, useState } from "react";
 import { pickArchetypeVariant, type ArchetypeKey } from "@/src/audit/archetypes";
 import { type Grade } from "@/src/audit/scoring";
-import { getArchetypeRarityPct } from "@/src/audit/social-proof";
+// Archetype rarity switched off — the percentages are eight hardcoded integers
+// ("Seeded with snapshot values; swap for live aggregates once that pipeline
+// lands"), and this is the ONLY surface that rendered them: baked by
+// html-to-image into the PNG people post publicly. A fabricated population
+// statistic on a shared card is a claim we cannot support.
+// import { getArchetypeRarityPct } from "@/src/audit/social-proof";
 import { copyOrDownloadCard, downloadCard, shareCardNative, shareCardToastMessage } from "@/lib/share-card";
 import { toast } from "@/app/components/toast";
 import { usePostHog } from "@/contexts/PostHogContext";
@@ -45,8 +50,11 @@ interface Props {
   archetypeKey: ArchetypeKey;
   /** Stable seed for variant selection (project name is the natural fit). */
   seed: string;
-  score: number;
-  grade: Grade;
+  /** The score is switched off (see `src/audit/scoring.ts`). Kept as optional
+   *  props rather than removed, so restoring is un-commenting rather than
+   *  re-threading: the dashboard simply stops passing them. */
+  score?: number;
+  grade?: Grade;
   /** Count of unenabled prescribed policies — passed to the share-text
    *  templates, not rendered on the poster itself. */
   missing: number;
@@ -63,7 +71,7 @@ export const AuditPoster = forwardRef<HTMLDivElement, Props>(function AuditPoste
     () => pickArchetypeVariant(archetypeKey, seed),
     [archetypeKey, seed],
   );
-  const rarityPct = getArchetypeRarityPct(archetypeKey);
+  // const rarityPct = getArchetypeRarityPct(archetypeKey);
   const indexLabel = String(archetype.index).padStart(2, "0");
   const auditedDate = useMemo(() => formatAuditedDate(auditedAt), [auditedAt]);
 
@@ -134,8 +142,11 @@ export const AuditPoster = forwardRef<HTMLDivElement, Props>(function AuditPoste
     }
   };
 
+  // Score switched off — the filename is keyed on the archetype instead, which
+  // is what the card now actually shows. Original:
+  //   `failproofai-${channel}-${grade.toLowerCase()}-${score}.png`
   const filenameFor = (channel: "x" | "linkedin" | "download") =>
-    `failproofai-${channel}-${grade.toLowerCase()}-${score}.png`;
+    `failproofai-${channel}-${archetypeKey}.png`;
 
   const handleShare = async (channel: "x" | "linkedin" | "download") => {
     if (busy) return;
@@ -143,8 +154,11 @@ export const AuditPoster = forwardRef<HTMLDivElement, Props>(function AuditPoste
     capture("audit_card_share_clicked", {
       channel,
       source: "poster",
-      score,
-      grade,
+      // Score switched off — see `src/audit/scoring.ts`. Note for whoever reads
+      // the funnel: these two properties stop appearing from this release, so a
+      // dashboard keyed on them breaks rather than reading zero.
+      // score,
+      // grade,
       missing_policies: missing,
     });
     try {
@@ -174,10 +188,10 @@ export const AuditPoster = forwardRef<HTMLDivElement, Props>(function AuditPoste
       }
 
       const shareCtx: ShareCtx = {
-        score,
         arch: archetype.name.toLowerCase(),
-        grade,
         missing,
+        // score,
+        // grade,
       };
       const shareText = channel === "x"
         ? pickTemplate(X_TEMPLATES, seed, shareCtx)
@@ -248,6 +262,7 @@ export const AuditPoster = forwardRef<HTMLDivElement, Props>(function AuditPoste
                 </React.Fragment>
               ))}
             </div>
+            {/* Rarity switched off — see the import above.
             {typeof rarityPct === "number" && (
               <div className="persona-rarity">
                 <span className="lbl">{"// only"}</span>{" "}
@@ -255,13 +270,17 @@ export const AuditPoster = forwardRef<HTMLDivElement, Props>(function AuditPoste
                 <span className="lbl">of agents are this archetype</span>
               </div>
             )}
+            */}
           </div>
 
-          {/* Score block — heroic number, centered in the card */}
+          {/* Score block — heroic number, centered in the card. Switched off;
+              see `src/audit/scoring.ts` for why. The archetype is the card's
+              headline now.
           <div className="poster-score">
             <span className="score-n">{score}</span>
             <span className="score-of">/100</span>
           </div>
+          */}
         </div>
 
         <footer className="poster-foot">

package/.next/standalone/app/audit/_components/come-back-better-section.tsx

@@ -21,7 +21,12 @@ import { AuthDialog, type AuthedUser } from "./auth-dialog";
 import { InviteDialog } from "./invite-dialog";
 
 interface Props {
-  /** Current audit score (0–100), forwarded into the invite email body. */
+  /** Current audit score (0–100), forwarded into the invite email body.
+   *
+   *  Always undefined while the score is switched off (see
+   *  `src/audit/scoring.ts`) — the dashboard no longer passes it. Nothing
+   *  breaks: `/api/audit/invite` already treats it as optional and simply
+   *  leaves it out of the email body when it is not a finite number. */
   score?: number;
 }
 

package/.next/standalone/app/audit/_components/empty-state.tsx

@@ -74,7 +74,10 @@ export function EmptyState({ mode, running, onStarted, onCompleted }: Props) {
           <p className="empty-sub">
             we&apos;ll walk every transcript across your installed CLIs — Claude Code,
             Codex, Copilot, Cursor, OpenCode, Pi — and count every wasteful
-            or risky action. you&apos;ll get a tier, a score, and a punch-list.
+            {/* Was "a tier, a score, and a punch-list" — the tier was never
+                rendered and the score is switched off, so this promised two
+                things the page did not show. */}
+            or risky action. you&apos;ll get your agent&apos;s archetype and a punch-list.
           </p>
 
           <div className="empty-actions">