+ );
+}
diff --git a/app/audit/components/Actions.tsx b/app/audit/components/Actions.tsx
new file mode 100644
index 000000000..d08df2f0c
--- /dev/null
+++ b/app/audit/components/Actions.tsx
@@ -0,0 +1,83 @@
+'use client';
+
+import { useContext } from 'react';
+import { ArrowRight, Plus } from 'lucide-react';
+import { OrchActionsContext } from '@/app/consciousness/components/OrchActions';
+import { cn } from '@/utils/styles';
+
+/**
+ * The page's two buttons, in its own style. The actions are the RFP landing
+ * pages' shared ones (`OrchActionsContext`): adding to the pool and starting
+ * a proposal.
+ */
+function useActions() {
+ const ctx = useContext(OrchActionsContext);
+ if (!ctx) throw new Error('The audit page buttons need an actions provider');
+ return ctx;
+}
+
+type Size = 'sm' | 'md' | 'lg';
+
+const SIZES: Record = {
+ sm: 'h-9 px-4 text-[13px]',
+ md: 'h-11 px-5 text-[14px]',
+ lg: 'h-12 px-6 text-[15px]',
+};
+
+export function AddToPoolButton({
+ size = 'md',
+ label = 'Add to the pool',
+ className,
+}: {
+ size?: Size;
+ label?: string;
+ className?: string;
+}) {
+ const { addToPool } = useActions();
+ return (
+
+ );
+}
+
+export function SubmitProposalButton({
+ size = 'md',
+ label = 'Submit a proposal',
+ className,
+}: {
+ size?: Size;
+ label?: string;
+ className?: string;
+}) {
+ const { submitProposal } = useActions();
+ return (
+
+ );
+}
+
+/** A quiet text link that starts a proposal. */
+export function ProposeLink({ label }: { label: string }) {
+ const { submitProposal } = useActions();
+ return (
+
+ );
+}
diff --git a/app/audit/components/AuditRfpActions.tsx b/app/audit/components/AuditRfpActions.tsx
new file mode 100644
index 000000000..3f8a5b315
--- /dev/null
+++ b/app/audit/components/AuditRfpActions.tsx
@@ -0,0 +1,99 @@
+'use client';
+
+import { useCallback, useEffect, useMemo, useState, type ReactNode } from 'react';
+import { useRouter } from 'next/navigation';
+import toast from 'react-hot-toast';
+import { ContributeToFundraiseModal } from '@/components/modals/ContributeToFundraiseModal';
+import { WorkCoverCard } from '@/components/work/WorkCoverCard';
+import { isAwardMechanism } from '@/components/Funding/lib/fundingMechanism';
+import { handOffRfp } from '@/components/AIMode/rfpHandoff';
+import { newDraftTarget, workspaceHref } from '@/components/AIMode/workspaceUrl';
+import { isGrantActive, type FundingPool, type Grant } from '@/types/grant';
+import { OrchActionsContext } from '@/app/consciousness/components/OrchActions';
+
+/**
+ * The page's buttons wired to the RFP, exactly as /consciousness wires its
+ * own (`app/consciousness/components/LiveRfpActions.tsx`, which this
+ * follows): Add to the pool opens the contribute panel on the grant's
+ * funding pool, and Submit a proposal hands the RFP to the AI workspace. A
+ * pending or closed RFP says so instead.
+ */
+export function AuditRfpActions({
+ grant,
+ title,
+ imageUrl,
+ children,
+}: {
+ grant: Grant;
+ title: string;
+ imageUrl: string | null;
+ children: ReactNode;
+}) {
+ const router = useRouter();
+ const [isPanelOpen, setIsPanelOpen] = useState(false);
+ const [pool, setPool] = useState(grant.fundingPool ?? null);
+ useEffect(() => setPool(grant.fundingPool ?? null), [grant.fundingPool]);
+
+ const isActive = isGrantActive(grant);
+ const notOpen =
+ grant.status === 'PENDING' ? 'This call opens once it is approved.' : 'This call is closed.';
+ const grantId = String(grant.id);
+ const organization = grant.organization?.trim() || grant.createdBy?.authorProfile?.fullName || '';
+
+ const submitProposal = useCallback(() => {
+ if (!isActive) {
+ toast(notOpen, { id: 'audit-action' });
+ return;
+ }
+ handOffRfp({
+ id: grantId,
+ shortTitle: grant.shortTitle || title,
+ imageUrl: imageUrl ?? '',
+ fundingAmount: grant.amount.usd ?? 0,
+ organization,
+ applicationVisibility: grant.applicationVisibility,
+ fundingMechanism: grant.fundingMechanism ?? 'FUNDING',
+ });
+ router.push(workspaceHref(newDraftTarget('need_funding', grantId)));
+ }, [isActive, notOpen, grant, grantId, title, imageUrl, organization, router]);
+
+ const addToPool = useCallback(() => {
+ if (!isActive || pool?.status !== 'OPEN') {
+ toast(isActive ? 'The pool is not taking contributions.' : notOpen, { id: 'audit-action' });
+ return;
+ }
+ setIsPanelOpen(true);
+ }, [isActive, pool, notOpen]);
+
+ const handleContributeSuccess = useCallback(
+ (updatedPool?: FundingPool) => {
+ if (updatedPool) setPool(updatedPool);
+ router.refresh();
+ },
+ [router]
+ );
+
+ const value = useMemo(() => ({ submitProposal, addToPool }), [submitProposal, addToPool]);
+
+ return (
+
+ {children}
+ {pool && (
+ setIsPanelOpen(false)}
+ onContributeSuccess={handleContributeSuccess}
+ fundingPool={pool}
+ proposalTitle={title}
+ variant="panel"
+ topContent={
+
+ }
+ isAward={isAwardMechanism(grant.fundingMechanism)}
+ successText="Every dollar in the pool goes to the audits funded under this call."
+ />
+ )}
+
+ );
+}
diff --git a/app/audit/components/AuditShell.tsx b/app/audit/components/AuditShell.tsx
new file mode 100644
index 000000000..e3b8515ff
--- /dev/null
+++ b/app/audit/components/AuditShell.tsx
@@ -0,0 +1,24 @@
+'use client';
+
+import type { ReactNode } from 'react';
+import { OrchActionsProvider } from '@/app/consciousness/components/OrchActions';
+
+/**
+ * A full-screen page of its own, without the app's sidebar or top bar, as
+ * /consciousness is. Until the RFP is loaded its two buttons only say that
+ * the call opens soon (`OrchActionsProvider`); `AuditRfpActions` then wires
+ * them to the live RFP.
+ */
+export function AuditShell({
+ children,
+ fontClassName,
+}: {
+ children: ReactNode;
+ fontClassName: string;
+}) {
+ return (
+
+ {children}
+
+ );
+}
diff --git a/app/audit/components/Figures.tsx b/app/audit/components/Figures.tsx
new file mode 100644
index 000000000..c81e3e54e
--- /dev/null
+++ b/app/audit/components/Figures.tsx
@@ -0,0 +1,151 @@
+import { cn } from '@/utils/styles';
+import { LEDGER, SPREAD } from '../data/content';
+import { Ref } from './Parts';
+
+/* The funnel ---------------------------------------------------------------- */
+
+/**
+ * How wide the funnel is at the top of each stage, as a share of its column;
+ * the last value is the spout. Chosen to read as a funnel, not to scale:
+ * the real figures span four orders of magnitude.
+ */
+const FUNNEL_WIDTHS = [100, 76, 36, 36, 21, 11, 7];
+
+/**
+ * The astrophysics audit as a funnel: papers go in at the top (black) and
+ * narrow to the few that were recomputed; errors come out (red) and narrow
+ * to the few anyone had challenged. Each stage's figure sits beside it.
+ */
+export function Funnel() {
+ return (
+
+
+ {LEDGER.map((row, i) => {
+ const top = FUNNEL_WIDTHS[i];
+ const bottom = FUNNEL_WIDTHS[i + 1];
+ const opensGroup = i === 0 || LEDGER[i - 1].flagged !== row.flagged;
+ return (
+
+
+
+
+
+ {opensGroup && (
+
+ {row.flagged ? 'Errors out' : 'Papers in'}
+
+ )}
+
+
+ {row.value}
+
+ {row.label}
+
+
+ {row.detail}
+
+
+
+ );
+ })}
+
+
+ The funnel is not drawn to scale. Figures from the audit’s own pages.
+
+
+
+
+ );
+}
+
+/* How an error spreads ------------------------------------------------------ */
+
+/**
+ * How the audit's errors travelled, as one ratio: the later papers that
+ * repeated an error against the later papers that objected to one. No
+ * graphic; the ratio is the figure.
+ */
+export function Spread() {
+ const { copyingPapers, objectingPapers, challenged, stillCopied, laterCopies } = SPREAD;
+ const ratio = (copyingPapers / objectingPapers).toFixed(1);
+ return (
+
+
+
+ {ratio}
+ :
+ 1
+
+
+
+
+ For every later paper that objected to an error, more than five repeated one.
+
+
+
+
+ {copyingPapers}
+
+
later papers repeated one of the audit’s errors.
+
+
+
+ {objectingPapers}
+
+
later papers objected to one.
+
+
+
+
+
+
+ An objection did not end it. Of the {challenged} errors that were challenged in print,{' '}
+ {stillCopied} went on being copied, by {laterCopies} more papers. The audit read only the
+ citing papers with open text, so these counts are floors.
+
+
+
+ );
+}
diff --git a/app/audit/components/Hero.tsx b/app/audit/components/Hero.tsx
new file mode 100644
index 000000000..45509a5aa
--- /dev/null
+++ b/app/audit/components/Hero.tsx
@@ -0,0 +1,82 @@
+import Link from 'next/link';
+import { Logo } from '@/components/ui/Logo';
+import { BackButton } from '@/app/consciousness/components/BackButton';
+import { AddToPoolButton, SubmitProposalButton } from './Actions';
+import { HeroArt } from './HeroArt';
+import { HeroCard } from './HeroCard';
+import { Ref } from './Parts';
+import type { RfpView } from '../data/rfp';
+
+/**
+ * The hero's two buttons, filling the card's width. Narrow screens drop the
+ * icons so both labels fit side by side; from tablet up the two are equal.
+ */
+const CARD_CTA =
+ 'flex-auto px-3 text-[13.5px] !gap-1.5 min-[380px]:text-[14px] [&>svg]:hidden tablet:flex-1 tablet:text-[15px] min-[900px]:[&>svg]:block';
+
+/**
+ * The same hero as /consciousness, in this page's own style: back and home
+ * at the top left, the process link at the top right, the headline, one
+ * paragraph, and the card with the pool and both buttons. The figure is 3D
+ * and sits behind: right of the text on wide screens, above it on phones.
+ */
+export function Hero({ rfp }: { rfp: RfpView }) {
+ return (
+
+
+ {/* Scrims so the type always reads over the figure: from below on
+ phones, from the left on wider screens. */}
+
+
+
+
+ Fund the audit of everything science has published.
+
+
+
+ A machine audit of one field of astrophysics reported 872 errors in 433 papers. Only 47
+ had ever been challenged in print.
+ We are raising funds to audit more fields in the open, with experts checking
+ what the machines flag.
+
+
+
+
+
+
+
+
+
+
+
+ A field as stacks of paper, one sheet per paper. Red sheets hold an error; paler ones repeat
+ it. An illustration, not data.
+
+
+ );
+}
diff --git a/app/audit/components/HeroArt.tsx b/app/audit/components/HeroArt.tsx
new file mode 100644
index 000000000..df6763732
--- /dev/null
+++ b/app/audit/components/HeroArt.tsx
@@ -0,0 +1,57 @@
+'use client';
+
+import { useEffect, useRef, useState } from 'react';
+import { cn } from '@/utils/styles';
+
+/**
+ * The hero's 3D figure (`art/stacks.ts`), behind the text. Its library loads
+ * after the page is interactive, and the canvas fades in once the first
+ * frame is drawn. With reduced motion it draws one finished frame; without
+ * WebGL (or with `?audit-gl=off`) the hero is plain paper.
+ */
+export function HeroArt() {
+ const ref = useRef(null);
+ const [ready, setReady] = useState(false);
+
+ useEffect(() => {
+ const canvas = ref.current;
+ if (!canvas) return;
+ const q = new URLSearchParams(window.location.search);
+ if (q.get('audit-gl') === 'off') return;
+ const still =
+ window.matchMedia('(prefers-reduced-motion: reduce)').matches ||
+ q.get('audit-motion') === 'reduce';
+ const css = getComputedStyle(canvas);
+ let handle: { dispose: () => void } | null = null;
+ let cancelled = false;
+ import('../art/stacks')
+ .then(({ createStacks }) => {
+ if (cancelled) return;
+ handle = createStacks(canvas, {
+ paper: css.getPropertyValue('--a-paper').trim(),
+ red: css.getPropertyValue('--a-red').trim(),
+ ink: css.getPropertyValue('--a-ink').trim(),
+ still,
+ onReady: () => setReady(true),
+ });
+ })
+ .catch((error) => {
+ console.warn('The audit hero figure failed to start; showing plain paper.', error);
+ });
+ return () => {
+ cancelled = true;
+ handle?.dispose();
+ };
+ }, []);
+
+ return (
+
+ );
+}
diff --git a/app/audit/components/HeroCard.tsx b/app/audit/components/HeroCard.tsx
new file mode 100644
index 000000000..5d6b36b86
--- /dev/null
+++ b/app/audit/components/HeroCard.tsx
@@ -0,0 +1,87 @@
+import type { ReactNode } from 'react';
+import { CircleCheck } from 'lucide-react';
+import { BackerFaces } from './Pool';
+import {
+ CAMPAIGN,
+ formatDate,
+ formatUsd,
+ formatUsdShort,
+ poolPercent,
+ type RfpView,
+} from '../data/rfp';
+
+/**
+ * Everything under the hero's paragraph, in one card, as on /consciousness:
+ * the amount raised, one track in two parts, the backers and proposals, the
+ * hero's buttons (`children`) and a footer line. Phase 1 (raising the pool)
+ * fills as money comes in; Phase 2 (the audits) waits, hatched.
+ */
+export function HeroCard({ rfp, children }: { rfp: RfpView; children: ReactNode }) {
+ const pct = poolPercent(rfp);
+ return (
+
+
+ {CAMPAIGN.taxDeductibleLine ?? 'The pool pays only for audits funded under this call'}
+
+
+ );
+}
diff --git a/app/audit/components/OutcomeIcons.tsx b/app/audit/components/OutcomeIcons.tsx
new file mode 100644
index 000000000..ffd2d48c8
--- /dev/null
+++ b/app/audit/components/OutcomeIcons.tsx
@@ -0,0 +1,247 @@
+/**
+ * Drawn icons for the four outcomes under "What science gains when its
+ * errors are found", as /consciousness has for its four tenets, in this
+ * page's own hand: black line on paper, the red pencil for an error and the
+ * blue pencil for a check. Each is complete as the server renders it; where
+ * motion is welcome each then runs one small, slow loop (audit.css).
+ */
+
+const INK = 'var(--a-ink)';
+const RED = 'var(--a-red)';
+const BLUE = 'var(--a-blue)';
+const SHEET = 'var(--a-sheet)';
+
+/** A sheet of paper with lines of text; each line is [distance from the top, length]. */
+function Sheet({
+ x,
+ y,
+ w,
+ h,
+ lines = [],
+}: {
+ x: number;
+ y: number;
+ w: number;
+ h: number;
+ lines?: [number, number][];
+}) {
+ return (
+
+
+ {lines.map(([dy, len]) => (
+
+ ))}
+
+ );
+}
+
+function Check({ d, className }: { d: string; className?: string }) {
+ return (
+
+ );
+}
+
+/** 1. Fixed before they spread: the error is corrected in the paper that
+ * made it, and the two papers that draw on it stay clean. */
+function Fixed() {
+ return (
+ <>
+
+
+
+
+
+
+
+
+
+ >
+ );
+}
+
+/** 2. Results that hold: new work, in black, set down on a stack that has
+ * been checked. */
+function Holds() {
+ return (
+ <>
+
+ {[
+ [13, 49],
+ [11, 41],
+ [14, 33],
+ [12, 25],
+ ].map(([x, y]) => (
+
+ ))}
+
+
+ >
+ );
+}
+
+/** 3. Answered sooner: an open question, and the mark that it is settled. */
+function Answered() {
+ return (
+ <>
+
+
+
+
+
+
+
+
+
+ >
+ );
+}
+
+/** 4. Checked as it appears: the red line passes over each new paper in
+ * turn, and each gets its check. */
+function Checked() {
+ const lines: [number, number][] = [
+ [6, 8],
+ [11, 6],
+ [16, 8],
+ ];
+ return (
+ <>
+
+
+
+
+
+
+
+ >
+ );
+}
+
+const ICONS = [Fixed, Holds, Answered, Checked];
+
+export function OutcomeIcon({ index }: { index: number }) {
+ const Art = ICONS[index];
+ if (!Art) return null;
+ return (
+
+ );
+}
diff --git a/app/audit/components/Parts.tsx b/app/audit/components/Parts.tsx
new file mode 100644
index 000000000..127cd16c4
--- /dev/null
+++ b/app/audit/components/Parts.tsx
@@ -0,0 +1,113 @@
+import type { ReactNode } from 'react';
+import { cn } from '@/utils/styles';
+
+/** The page's column. On wide screens its text clears the margin rule. */
+export function Wrap({ children, className }: { children: ReactNode; className?: string }) {
+ return (
+
+ {children}
+
+ );
+}
+
+/** A footnote mark linking to its entry under Sources. */
+export function Ref({ n }: { n: number }) {
+ return (
+
+ {n}
+
+ );
+}
+
+/** A section's headline. Its label is the section's own (see `Section`). */
+export function SectionHead({
+ id,
+ children,
+ className,
+}: {
+ id: string;
+ children: ReactNode;
+ className?: string;
+}) {
+ return (
+
+ {children}
+
+ );
+}
+
+/**
+ * A section between two rules. With `label`, the section opens with its
+ * number (hanging on the margin rule) and its name in the mono, and that
+ * line stays pinned to the top of the screen for as long as the section is
+ * being read.
+ */
+export function Section({
+ id,
+ labelledBy,
+ n,
+ label,
+ tone,
+ children,
+ className,
+}: {
+ id?: string;
+ labelledBy: string;
+ n?: number;
+ label?: string;
+ /** `dark` sets the section white on black. */
+ tone?: 'dark';
+ children: ReactNode;
+ className?: string;
+}) {
+ const dark = tone === 'dark';
+ return (
+
+
+ {label && (
+
+
+ {n}
+
+ {label}
+
+ )}
+ {children}
+
+
+ );
+}
diff --git a/app/audit/components/Pool.tsx b/app/audit/components/Pool.tsx
new file mode 100644
index 000000000..c6f8409f5
--- /dev/null
+++ b/app/audit/components/Pool.tsx
@@ -0,0 +1,35 @@
+import { Avatar } from '@/components/ui/Avatar';
+import { cn } from '@/utils/styles';
+import { formatUsd, poolPercent, type RfpView } from '../data/rfp';
+
+/** Progress toward the goal; a sliver always shows once anyone has given. */
+export function PoolBar({ rfp, className }: { rfp: RfpView; className?: string }) {
+ const pct = poolPercent(rfp);
+ const shown = pct > 0 ? Math.max(pct, 1.5) : 0;
+ return (
+
+
+
+ );
+}
+
+/** The top backers' faces, overlapping, up to `max`; each links to their profile. */
+export function BackerFaces({ rfp, size, max = 10 }: { rfp: RfpView; size: number; max?: number }) {
+ if (rfp.backers.length === 0) return null;
+ return (
+
+ {rfp.backers.slice(0, max).map((b) => (
+
+
+
+ ))}
+
+ );
+}
diff --git a/app/audit/components/Sections.tsx b/app/audit/components/Sections.tsx
new file mode 100644
index 000000000..c29f38383
--- /dev/null
+++ b/app/audit/components/Sections.tsx
@@ -0,0 +1,777 @@
+import { ArrowRight, ArrowUpRight, CalendarDays, Plus } from 'lucide-react';
+import Link from 'next/link';
+import { Logo } from '@/components/ui/Logo';
+import { Avatar } from '@/components/ui/Avatar';
+import { TRACK_RECORD } from '@/app/giving/lib/trackRecord';
+import { cn } from '@/utils/styles';
+import {
+ COST_FACTS,
+ FAQ,
+ LIMITS,
+ MODEL_COSTS,
+ OUTCOMES,
+ QUOTE,
+ RULES,
+ SCALE_FACTS,
+ SOURCES,
+ TRACKS,
+ US_RND_USD_BILLION,
+ type Fact as FactItem,
+} from '../data/content';
+import {
+ CAMPAIGN,
+ TALK_TO_TEAM,
+ daysLeft,
+ deadlineLabel,
+ formatDate,
+ formatUsd,
+ formatUsdShort,
+ poolPercent,
+ type RfpView,
+} from '../data/rfp';
+import { AddToPoolButton, ProposeLink, SubmitProposalButton } from './Actions';
+import { Funnel, Spread } from './Figures';
+import { OutcomeIcon } from './OutcomeIcons';
+import { BackerFaces, PoolBar } from './Pool';
+import { Ref, Section, SectionHead, Wrap } from './Parts';
+
+/* 1. Where this started ----------------------------------------------------- */
+
+/**
+ * What prompted the call: a post, quoted, then the audit it describes as a
+ * funnel (what went in, what came out, how little of it anyone had
+ * noticed).
+ */
+export function Finding() {
+ return (
+
+
+ An AI audit of astrophysics reported 872 errors.
+
+
+
+
+
+ This call was prompted by a post. On 17 November 2026 the physicist Casey Handmer
+ wrote on X that he had directed Claude Opus 5.5 to audit his old field, theoretical
+ astrophysics, and published the results.
+
+
+ The post rounds up. The audit’s published pages count 872 errors, 92 of them graded
+ major, and this page uses those figures.
+
+ Models mapped the literature around one research group, read every paper
+ they could, and re-derived the equations in the most cited ones.
+
+
+
+
+
+
+
+
+
+
+ );
+}
+
+/* 2. Why errors survive --------------------------------------------------- */
+
+/**
+ * What happened to the audit's errors after publication: how many later
+ * papers repeated one against how many objected, as one large ratio.
+ */
+export function Evidence() {
+ return (
+
+
+ Errors outlive their corrections.
+
+
+ In the audit, peer review removed about one error in five before publication. Of the errors
+ that later papers picked up, over half were still being copied seven years on.
+
+
+
+
+ );
+}
+
+/* 3. The opportunity ------------------------------------------------------ */
+
+/** Facts in a ruled list: the figure, then what it is. */
+function FactRows({ facts, className }: { facts: FactItem[]; className?: string }) {
+ return (
+
+ {facts.map((f) => (
+
+
{f.value}
+
+ {f.text}
+ {f.source != null && }
+
+
+ ))}
+
+ );
+}
+
+/** Facts side by side: a figure over its line. */
+function FactColumns({ facts }: { facts: FactItem[] }) {
+ return (
+
+ {facts.map((f) => (
+
+
+ {f.value}
+
+
+ {f.text}
+ {f.source != null && }
+
+
+ ))}
+
+ );
+}
+
+function CostChart() {
+ const max = Math.max(...MODEL_COSTS.map((m) => m.usdMillion));
+ return (
+
+ By model, US$ million
+
+ Batch pricing, November 2026. *Promotional rate. Model costs only. Redrawn from Rust’s
+ estimate.
+
+
+
+ );
+}
+
+/** A year of US research spending and the review, on one scale. */
+function ToScale() {
+ return (
+
+
+
+ US spending on research and development, 2024 (estimate)
+
+
+
+ ${US_RND_USD_BILLION} billion
+
+
+
+
+
+ $6 million
+
+
+ The upper estimate, on the same scale. The red line is drawn over a hundred times too
+ wide.
+
+
+
+ );
+}
+
+/**
+ * What finding the errors could change, then what it would cost: the
+ * outcomes first (each with the fact it rests on), then one compact block
+ * with the estimate by model and the scale it sits against.
+ */
+export function Arithmetic() {
+ return (
+
+
+ What science gains when its errors are found.
+
+
+
+ {OUTCOMES.map((o, i) => (
+
+
+
+
+
+ {String(i + 1).padStart(2, '0')}
+
+
+ {o.title}
+
+
+
+
+ {o.text}
+ {o.sources.map((n) => (
+
+ ))}
+
+
+ ))}
+
+
+
+
What it costs
+
+ And it costs a rounding error on what science already spends.
+
+
+
+
+
+ $0.6–6M
+
+
+ Estimated model cost to review 3 million open-access papers with AI. The range is
+ the choice of model.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ What tokens do not buy is the checking.
+
+
+ The Black Spatula Project ran AI checks on about 500 papers and has said its main
+ constraint is finding experts to verify what was flagged.
+ The pool pays for that: the people, the method, and getting corrections
+ into the record.
+
+ The astrophysics audit’s own rule
+ , and this call’s.
+
+
+
+
+ {RULES.map((r, i) => (
+
+
+ {String(i + 1).padStart(2, '0')}
+
+
+
{r.title}
+
+ {r.text}
+
+
+
+ ))}
+
+
+
+
+
How good are the machines, so far
+
+ {LIMITS.map((l) => (
+
+
{l.value}
+
+ {l.text}
+
+
+
+ ))}
+
+
+ These tests differ in models, fields and what counts as an error, so they do not rank one
+ another. Together they say the same thing: results vary widely, and nobody has yet
+ measured precision for a whole-field audit with human experts. Track 2 pays for that.
+
+
+
+ );
+}
+
+/* 6. How the pool works ---------------------------------------------------- */
+
+const STEPS = [
+ {
+ title: 'You add to the pool',
+ text: 'Any amount, pooled with every other backer.',
+ },
+ {
+ title: 'Researchers submit proposals',
+ text: 'Teams post their corpus, method and budget, and how they will confirm what they find.',
+ },
+ {
+ title: 'Peers review, the pool pays',
+ text: 'Open review on ResearchHub. The strongest get funded.',
+ },
+ {
+ title: 'Results are published',
+ text: 'Findings, data and code go public, including what did not hold up.',
+ },
+];
+
+export function HowItWorks() {
+ return (
+
+
+ How the pool works
+
+
+ {STEPS.map((s, i) => (
+
+ );
+}
+
+/**
+ * The programme's state: Phase 1 raises the pool (target, date, progress and
+ * what a donor checks), Phase 2 funds and runs the audits. The pool's
+ * backers and the way to the RFP's own page sit beside them.
+ */
+export function Standing({ rfp }: { rfp: RfpView }) {
+ const left = daysLeft(rfp.goalBy);
+ const more = rfp.backerCount - rfp.backers.length;
+ return (
+
+
+ Two phases
+
+
+
+
+ Phase 1
+
+ Now
+
+
+
+ Raise {formatUsd(rfp.goalUsd)} by {formatDate(rfp.goalBy)}
+
+ Only to work funded under this call.
+
+ Everything raised still funds audits under this call; we fund fewer of them.
+
+ {CAMPAIGN.taxDeductibleNote && (
+ {CAMPAIGN.taxDeductibleNote}
+ )}
+
+
+
+
+
+
+
+
+ Phase 2
+
+ Next
+
+
+
+ Pick proposals, run the audits
+
+
+ Reviewers score the proposals in the open. The pool funds the strongest, and what they
+ find is published.
+
+
+
+ {deadlineLabel(rfp)}
+ {rfp.proposalCount > 0 && ` · ${rfp.proposalCount} so far`}
+
+ In the open on ResearchHub, by peer reviewers
+ {rfp.awardRangeLabel} each
+
+
+
+ {rfp.rfpHref && (
+
+ View the RFP and its proposals
+
+
+ )}
+
+
+
+
+ {rfp.backers.length > 0 && (
+
+
Top backers
+
+ {rfp.backers.map((b) => (
+
+
+ {b.name}
+ {formatUsd(b.amountUsd)}
+
+ ))}
+
+ {more > 0 && (
+
+ and {more} more {more === 1 ? 'backer' : 'backers'}
+
+ )}
+
+ )}
+
+ );
+}
+
+/* About, talk, FAQ, sources ------------------------------------------------ */
+
+/**
+ * Who hosts the call. The description is ResearchHub's own (researchhub.com
+ * and /about); the figures are the dated track record the Giving page shows.
+ */
+export function AboutResearchHub() {
+ const stats = [
+ { value: formatUsdShort(TRACK_RECORD.contributedUsd), label: 'Contributed since 2024' },
+ {
+ value: TRACK_RECORD.proposalsFunded.toLocaleString('en-US'),
+ label: 'Proposals fully funded',
+ },
+ { value: TRACK_RECORD.peerReviews.toLocaleString('en-US'), label: 'Peer reviews' },
+ ];
+ return (
+
+
+
+
+
+ About ResearchHub
+
+
Where this call is hosted
+
+
+
+ ResearchHub is an open science platform where researchers publish, peer review, fund and
+ discuss scientific research. Its mission is to accelerate the pace of scientific
+ research.
+
+
+ It is built for work that can be checked: study designs are registered in public before
+ the work starts, review happens in the open, and results are published with no paywall.
+
+ Figures were checked against these sources on 18 November 2026. The astrophysics audit is
+ the work of its author and has not been independently verified; this page reports its claims
+ and its stated limits. If we have something wrong, tell us and we will fix it.
+
+
+ );
+}
+
+export function AuditFooter() {
+ return (
+
+ );
+}
diff --git a/app/audit/data/content.ts b/app/audit/data/content.ts
new file mode 100644
index 000000000..884720368
--- /dev/null
+++ b/app/audit/data/content.ts
@@ -0,0 +1,397 @@
+/**
+ * The page's words and figures: the audit's ledger, the evidence that errors
+ * persist, the cost estimates, what the call funds, its ground rules, the
+ * FAQ and the sources. Every figure is cited in `SOURCES` and was checked
+ * against that source on 18 November 2026. RFP facts (pool, deadline) are
+ * not here; they come from the live RFP (`rfp.ts`).
+ *
+ * The call's scope (`TRACKS`), its rules (`RULES`) and the FAQ are a DRAFT
+ * until the call's terms are set.
+ */
+
+export interface Source {
+ id: number;
+ label: string;
+ url: string;
+}
+
+export const SOURCES: Source[] = [
+ {
+ id: 1,
+ label: 'Handmer, “A field of physics, audited by machine”, 2026',
+ url: 'https://science.caseyhandmer.com/physics/',
+ },
+ {
+ id: 2,
+ label: 'Handmer, “Method and limits: how to audit a field by machine”, 2026',
+ url: 'https://science.caseyhandmer.com/physics/method.html',
+ },
+ {
+ id: 3,
+ label: 'Handmer, “872 verified errors in 433 papers”, 2026 (the audit’s full list)',
+ url: 'https://science.caseyhandmer.com/physics/errors.html',
+ },
+ {
+ id: 4,
+ label: 'Handmer, post announcing the audit, X, 17 November 2026',
+ url: 'https://x.com/CJHandmer/status/2122609626588061816',
+ },
+ {
+ id: 5,
+ label: 'Handmer, post on the cost of auditing every field, X, 17 November 2026',
+ url: 'https://x.com/CJHandmer/status/2122796358616891642',
+ },
+ {
+ id: 6,
+ label:
+ 'Rust, post estimating the cost of AI review of the open-access literature, X, 16 November 2026',
+ url: 'https://x.com/rust_ruslan/status/2122444038091718701',
+ },
+ {
+ id: 7,
+ label:
+ 'National Center for Science and Engineering Statistics, NSF 26-314, 2026 (US R&D: $993 billion estimated for 2024)',
+ url: 'https://ncses.nsf.gov/pubs/nsf26314',
+ },
+ {
+ id: 8,
+ label:
+ 'National Library of Medicine, PMC Open Access Subset (8,402,749 records on 18 November 2026)',
+ url: 'https://pmc.ncbi.nlm.nih.gov/tools/openftlist/',
+ },
+ {
+ id: 9,
+ label:
+ 'National Science Board, “The State of U.S. Science and Engineering 2026” (3.5 million articles in 2024)',
+ url: 'https://ncses.nsf.gov/pubs/nsbsep20261',
+ },
+ {
+ id: 10,
+ label:
+ 'Son et al., “When AI co-scientists fail: SPOT, a benchmark for automated verification of scientific research”, 2025',
+ url: 'https://arxiv.org/abs/2505.11855',
+ },
+ {
+ id: 11,
+ label:
+ 'Bianchi et al., “To err is human: systematic quantification of errors in published AI papers via LLM analysis”, 2025',
+ url: 'https://arxiv.org/abs/2512.05925',
+ },
+ {
+ id: 12,
+ label:
+ 'Zubeldia et al., “Auditing AI peer reviewers: a benchmark on real scientific papers”, 2026',
+ url: 'https://arxiv.org/abs/2611.17052',
+ },
+ {
+ id: 13,
+ label:
+ 'The Black Spatula Project; and coverage of its verification bottleneck, heise online, 2025',
+ url: 'https://www.heise.de/en/news/No-more-calculation-errors-AI-checks-papers-for-errors-Why-that-s-not-enough-10321469.html',
+ },
+];
+
+/**
+ * The post that prompted the call (source 4), quoted briefly. Its "nearly
+ * 1000 major" rounds up: the audit's pages count 872 upheld errors, 92 of
+ * them graded major, and the page says so beside the quote.
+ */
+export const QUOTE = {
+ text: 'We found nearly 1000 major errors that got cited many times…',
+ author: 'Casey Handmer',
+ where: 'on X, 17 November 2026',
+ url: 'https://x.com/CJHandmer/status/2122609626588061816',
+};
+
+/** The astrophysics audit, top to bottom, as a funnel. Figures from sources 1–3. */
+export interface LedgerRow {
+ value: string;
+ label: string;
+ detail: string;
+ /** An error row: drawn in the red pencil. */
+ flagged?: boolean;
+}
+
+export const LEDGER: LedgerRow[] = [
+ {
+ value: '158,059',
+ label: 'papers mapped',
+ detail:
+ 'The papers of one Caltech research group, the papers they cite and the papers that cite them.',
+ },
+ {
+ value: '50,269',
+ label: 'papers read in full',
+ detail: 'Every paper whose full text is openly available: 421 million words.',
+ },
+ {
+ value: '659',
+ label: 'papers recomputed',
+ detail:
+ 'The most cited first. A model re-derived the equations and rebuilt the numbers, without seeing errata or later papers.',
+ },
+ {
+ value: '872',
+ label: 'errors reported',
+ detail:
+ 'Spread across 433 papers. Each one was re-derived by a second, independent AI session before it counted. The audit grades 92 as major.',
+ flagged: true,
+ },
+ {
+ value: '159',
+ label: 'errors repeated by later papers',
+ detail: 'At least one later paper carried the error forward. In total, 367 later papers did.',
+ flagged: true,
+ },
+ {
+ value: '47',
+ label: 'errors criticised by a later paper',
+ detail:
+ 'Only 47 of the 872 errors were ever challenged in print. For 21 of them, the copying continued after the criticism.',
+ flagged: true,
+ },
+];
+
+/** How the audit's errors travelled into later papers (source 1). */
+export const SPREAD = {
+ copyingPapers: 367,
+ objectingPapers: 68,
+ challenged: 47,
+ stillCopied: 21,
+ laterCopies: 51,
+};
+
+/**
+ * Estimated model cost of reviewing 3 million papers, US$ million, by model.
+ * Redrawn from Rust's chart (source 6): batch pricing, November 2026.
+ */
+export const MODEL_COSTS: { model: string; usdMillion: number; note?: string }[] = [
+ { model: 'GPT-6 Astra', usdMillion: 6.0 },
+ { model: 'Claude Fable 5.2', usdMillion: 4.8 },
+ { model: 'Claude Opus 5.5', usdMillion: 2.4 },
+ { model: 'GPT-6.1 Sol', usdMillion: 1.2 },
+ { model: 'Claude Sonnet 5.5', usdMillion: 1.2 },
+ { model: 'Gemini 4 Carbon', usdMillion: 1.2, note: 'promotional rate' },
+ { model: 'GPT-6.1 Terra', usdMillion: 0.6 },
+];
+
+export const US_RND_USD_BILLION = 993;
+
+/** A stated fact: a figure and the one line that says what it is. */
+export interface Fact {
+ value: string;
+ text: string;
+ /** Omitted where the figure is this page's own arithmetic. */
+ source?: number;
+}
+
+/** What auditing costs. The headline figure is Rust's estimate (source 6). */
+export const COST_FACTS: Fact[] = [
+ {
+ value: '$0.20–$2',
+ text: 'per paper, at those rates. Our arithmetic from the estimate above.',
+ },
+ {
+ value: '$2,720',
+ text: 'Model cost of the whole astrophysics audit at list price, or about $3 for each error found.',
+ source: 1,
+ },
+ {
+ value: '$100,000',
+ text: 'Roughly what Handmer says the tokens would cost to sample every field of science.',
+ source: 5,
+ },
+];
+
+/** How large the literature is, beside the money already spent on research. */
+export const SCALE_FACTS: Fact[] = [
+ {
+ value: '8.4 million',
+ text: 'open-access papers in PubMed Central alone.',
+ source: 8,
+ },
+ {
+ value: '3.5 million',
+ text: 'new science and engineering articles published in 2024.',
+ source: 9,
+ },
+ {
+ value: '< 0.001%',
+ text: 'of one year of US research spending: what the upper estimate comes to.',
+ },
+];
+
+/**
+ * What finding the errors could change. Each is a possibility, stated with
+ * the fact it rests on.
+ */
+export const OUTCOMES: { title: string; text: string; sources: number[] }[] = [
+ {
+ title: 'Errors are fixed before they spread.',
+ text: 'Today more than five later papers repeat an error for each one that objects. An error flagged at its source can be corrected before the next paper cites it.',
+ sources: [1],
+ },
+ {
+ title: 'New work stands on results that hold.',
+ text: 'The audit estimates 34,000 errors (25,000 to 48,000) still undetected in one field’s most cited papers, and it has recomputed only 4% of them. Each one found is a result nobody builds on by mistake.',
+ sources: [1, 2],
+ },
+ {
+ title: 'Open questions are answered sooner.',
+ text: 'The audit listed 155 open questions in its field. A model judged 8 answerable now from existing data and code, and 119 that AI would speed up. Nobody has tried yet.',
+ sources: [1],
+ },
+ {
+ title: 'Every new paper is checked as it appears.',
+ text: 'About 3.5 million articles are published a year. Rust proposes running the same review on every new preprint, so that checking keeps pace with publishing.',
+ sources: [9, 6],
+ },
+];
+
+/** What the pool pays for. DRAFT scope. */
+export interface Track {
+ id: string;
+ name: string;
+ lead: string;
+ body: string;
+ asks: string[];
+}
+
+export const TRACKS: Track[] = [
+ {
+ id: 'field',
+ name: 'Audit a field',
+ lead: 'Take one field and read all of it.',
+ body: 'Map a field’s literature, screen what is open, and recompute its most relied-upon papers. Astrophysics is one field, mostly theory, around one group. Nobody knows yet what the same audit finds in cell biology, economics or clinical trials.',
+ asks: [
+ 'A defined corpus and how it is drawn',
+ 'Every error re-derived independently before it counts',
+ 'The full list published, with each derivation',
+ ],
+ },
+ {
+ id: 'verify',
+ name: 'Check the checker',
+ lead: 'Put people on the flags.',
+ body: 'No field-scale audit has had its findings adjudicated by experts. Fund the reading that turns a model’s claim into a result: specialists confirm or reject a sample of flags, and the precision is published, whatever it is.',
+ asks: [
+ 'Named domain experts and a blind protocol',
+ 'A sample large enough to give a real error bar',
+ 'The rejected flags published beside the upheld ones',
+ ],
+ },
+ {
+ id: 'correct',
+ name: 'Carry the correction',
+ lead: 'Follow each error to where it went.',
+ body: 'An error matters most in the papers that built on it. Trace confirmed errors through their citations, tell the authors first, and take corrections to journals and preprint servers so that the record changes, not only a list.',
+ asks: [
+ 'Authors contacted before anything is public',
+ 'A right of reply, published with the finding',
+ 'Corrections filed and their outcomes tracked',
+ ],
+ },
+ {
+ id: 'method',
+ name: 'Build it in the open',
+ lead: 'Make the next audit cheaper and better.',
+ body: 'Pipelines, prompts and benchmarks anyone can rerun: tests on real, author-confirmed errors; false-positive rates on clean papers; and standing audits that read new preprints as they are posted.',
+ asks: [
+ 'Open code, prompts and data under an open licence',
+ 'Measured recall and false-positive rates',
+ 'A method that works on a field its authors did not build it for',
+ ],
+ },
+];
+
+/** Conditions on funded work. DRAFT. */
+export const RULES: { title: string; text: string }[] = [
+ {
+ title: 'Two derivations, not one',
+ text: 'An error counts only when a second, independent pass reaches it without seeing the first.',
+ },
+ {
+ title: 'People before publication',
+ text: 'A named paper is called wrong only after a qualified person has checked the claim and its authors have had the chance to answer.',
+ },
+ {
+ title: 'Publish the misses',
+ text: 'Every audit reports its false positives and what it could not read, alongside what it found.',
+ },
+ {
+ title: 'Errors, not accusations',
+ text: 'The subject is mistakes in honest work. The astrophysics screen looked for paper-mill language and chatbot residue and found none.',
+ },
+ {
+ title: 'Open by default',
+ text: 'Findings, data, prompts and code are published on ResearchHub under an open licence.',
+ },
+];
+
+/** What is known about how well models find real errors. */
+export const LIMITS: { value: string; text: string; source: number }[] = [
+ {
+ value: '21%',
+ text: 'The best model’s recall on 91 real, author-confirmed errors in 2025. Its precision was 6%.',
+ source: 10,
+ },
+ {
+ value: '83%',
+ text: 'Of 316 mistakes a checker flagged in published AI papers, the share human experts confirmed.',
+ source: 11,
+ },
+ {
+ value: '12–71%',
+ text: 'Detection of errors injected into astrophysics preprints across twelve AI reviewers, with false alarms on under 9% of clean copies.',
+ source: 12,
+ },
+ {
+ value: '33 of 40',
+ text: 'Errors from the astrophysics audit upheld when a third session re-checked them blind. No person has checked any yet.',
+ source: 2,
+ },
+];
+
+export interface Faq {
+ q: string;
+ a: string;
+}
+
+export const FAQ: Faq[] = [
+ {
+ q: 'What makes a strong proposal?',
+ a: 'It names its corpus and how it is drawn, says how an error will be confirmed before it counts, and commits in advance to reporting its false-positive rate. It includes people qualified to judge the field, and it publishes everything, including the flags that did not hold up.',
+ },
+ {
+ q: 'Which fields are in scope?',
+ a: 'Any field where a claim can be checked against the paper itself: derivations, statistics, units, tables, code and data. Quantitative fields are the obvious start, but a well-argued proposal in any discipline is welcome.',
+ },
+ {
+ q: 'Does an audit need people, or only models?',
+ a: 'Both. Models make reading a whole field affordable; they also flag things that are not errors. Proposals that include expert adjudication, or that are only expert adjudication of an existing audit, are in scope.',
+ },
+ {
+ q: 'Will papers and authors be named?',
+ a: 'Only for errors a qualified person has confirmed, and after the authors have been told and given the chance to reply. The call funds work on honest mistakes, not allegations of misconduct.',
+ },
+ {
+ q: 'What about papers behind paywalls?',
+ a: 'Audits work from text they are licensed to read: open-access articles and preprints. The astrophysics audit could not read about a quarter of the papers on its map, and said so. Proposals should report their own coverage the same way.',
+ },
+ {
+ q: 'Who can apply?',
+ a: 'Anyone with a rigorous plan: university labs, institutes, independent researchers and companies, in any country and at any career stage.',
+ },
+ {
+ q: 'How are decisions made?',
+ a: 'Proposals are published on ResearchHub and peer reviewed in the open. The ResearchHub Foundation picks which to fund, guided by those reviews.',
+ },
+ {
+ q: 'Where does money added to the pool go?',
+ a: 'Only to proposals funded under this call. The pool is the call’s whole budget, built by everyone who adds to it.',
+ },
+ {
+ q: 'Is this call run with Casey Handmer or Ruslan Rust?',
+ a: 'No. Their public posts prompted it and are cited as sources. Neither is affiliated with this call or has endorsed it.',
+ },
+];
diff --git a/app/audit/data/rfp.config.json b/app/audit/data/rfp.config.json
new file mode 100644
index 000000000..5d2c7d358
--- /dev/null
+++ b/app/audit/data/rfp.config.json
@@ -0,0 +1,3 @@
+{
+ "productionPostId": null
+}
diff --git a/app/audit/data/rfp.ts b/app/audit/data/rfp.ts
new file mode 100644
index 000000000..aac74b789
--- /dev/null
+++ b/app/audit/data/rfp.ts
@@ -0,0 +1,172 @@
+import type { Work } from '@/types/work';
+import { isGrantActive, type Grant } from '@/types/grant';
+import config from './rfp.config.json';
+
+/**
+ * The literature-audit RFP: which ResearchHub post it is, and the figures the
+ * page shows, read from that post's grant. It follows /consciousness
+ * (`app/consciousness/data/rfp.ts`), with its own post and terms.
+ *
+ * Post ids differ between environments, so the id is picked per environment:
+ * - production deploys use `productionPostId` in `rfp.config.json` (null
+ * until the RFP is posted);
+ * - anywhere else, `AUDIT_RFP_POST_ID` names one, and `?rfp=`
+ * previews any.
+ * With none, the page shows an empty pool and its buttons only explain.
+ */
+export function rfpPostId(preview?: string | string[]): number | null {
+ const isProductionDeploy = process.env.VERCEL_ENV === 'production';
+ if (!isProductionDeploy && typeof preview === 'string' && /^\d+$/.test(preview)) {
+ return Number(preview);
+ }
+ const fromEnv = Number(process.env.AUDIT_RFP_POST_ID);
+ if (Number.isInteger(fromEnv) && fromEnv > 0) return fromEnv;
+ const fromConfig: number | null = config.productionPostId;
+ return isProductionDeploy ? fromConfig : null;
+}
+
+/**
+ * The campaign's own terms, which the grant does not hold.
+ *
+ * DRAFT: every value here is a placeholder until the call's terms are set.
+ * `taxDeductibleLine` stays null unless gifts to this pool are confirmed to
+ * be deductible; the page then shows no tax wording at all.
+ */
+export const CAMPAIGN: {
+ goalUsd: number;
+ goalBy: string;
+ awardRangeLabel: string;
+ taxDeductibleLine: string | null;
+ taxDeductibleNote: string | null;
+} = {
+ goalUsd: 250_000,
+ goalBy: '2027-01-31',
+ awardRangeLabel: '$5k – $100k',
+ taxDeductibleLine: null,
+ taxDeductibleNote: null,
+};
+
+export interface Backer {
+ id: number;
+ name: string;
+ amountUsd: number;
+ /** Their ResearchHub avatar; null draws the app's generated one. */
+ avatarUrl: string | null;
+ /** Their author profile, for the avatar's link. */
+ authorId?: number;
+}
+
+export type RfpStatus = 'OPEN' | 'PENDING' | 'CLOSED';
+
+/** Everything the page shows about the RFP and its pool. */
+export interface RfpView {
+ /** Null when no RFP is configured or it failed to load. */
+ grantId: number | null;
+ /** The RFP's own page: its full proposal list and details. */
+ rfpHref: string | null;
+ raisedUsd: number;
+ goalUsd: number;
+ /** Phase 1's end date, ISO. */
+ goalBy: string;
+ /** Everyone who has added to the pool. */
+ backerCount: number;
+ /** The top backers by amount, largest first (the API sends the top few). */
+ backers: Backer[];
+ /** Already paid out to funded proposals. */
+ distributedUsd: number;
+ /** Proposals submitted to the RFP (its grant's applications). */
+ proposalCount: number;
+ status: RfpStatus;
+ /** The proposal deadline as an ISO date, or null for rolling review. */
+ deadline: string | null;
+ awardRangeLabel: string;
+}
+
+/** The page's figures from the RFP post (`PostService.get`), or an empty pool. */
+export function rfpView(work: Work | null): RfpView {
+ const grant: Grant | undefined = work?.note?.post?.grant;
+ const pool = grant?.fundingPool ?? null;
+ const top = pool?.contributors.top ?? [];
+ let status: RfpStatus = 'PENDING';
+ if (grant && grant.status !== 'PENDING') status = isGrantActive(grant) ? 'OPEN' : 'CLOSED';
+ return {
+ grantId: grant?.id != null ? Number(grant.id) : null,
+ rfpHref: work && grant ? `/rfp/${work.id}/${work.slug}` : null,
+ raisedUsd: pool?.amountRaised.usd ?? 0,
+ goalUsd: CAMPAIGN.goalUsd,
+ goalBy: CAMPAIGN.goalBy,
+ backerCount: pool?.contributors.total ?? 0,
+ backers: top.map((c) => ({
+ id: c.id,
+ name: c.fullName,
+ amountUsd: c.totalContribution.usd,
+ avatarUrl: c.profileImage || null,
+ authorId: c.authorProfileId,
+ })),
+ distributedUsd: pool?.amountDistributed.usd ?? 0,
+ proposalCount: grant?.applications?.length ?? 0,
+ status,
+ deadline: grant?.endDate ? grant.endDate.slice(0, 10) : null,
+ awardRangeLabel: CAMPAIGN.awardRangeLabel,
+ };
+}
+
+/** Share of the goal raised, 0–100. */
+export function poolPercent(rfp: RfpView): number {
+ return rfp.goalUsd > 0 ? Math.min(100, (rfp.raisedUsd / rfp.goalUsd) * 100) : 0;
+}
+
+/** "$250,000" */
+export function formatUsd(amount: number): string {
+ return new Intl.NumberFormat('en-US', {
+ style: 'currency',
+ currency: 'USD',
+ maximumFractionDigits: 0,
+ }).format(amount);
+}
+
+/** "$250k", for tight spots such as the phone dock. */
+export function formatUsdShort(amount: number): string {
+ // Hand-rolled: Intl's compact notation differs between Node and browsers,
+ // which breaks hydration.
+ const short = (n: number) => String(Math.round(n * 10) / 10);
+ if (amount >= 1_000_000) return `$${short(amount / 1_000_000)}M`;
+ if (amount >= 1_000) return `$${short(amount / 1_000)}k`;
+ return `$${Math.round(amount)}`;
+}
+
+/** "31 January 2027", in UTC so server and client agree. */
+export function formatDate(iso: string): string {
+ return new Intl.DateTimeFormat('en-GB', {
+ day: 'numeric',
+ month: 'long',
+ year: 'numeric',
+ timeZone: 'UTC',
+ }).format(new Date(`${iso}T00:00:00Z`));
+}
+
+export function formatDateShort(iso: string): string {
+ return new Intl.DateTimeFormat('en-GB', {
+ day: 'numeric',
+ month: 'short',
+ timeZone: 'UTC',
+ }).format(new Date(`${iso}T00:00:00Z`));
+}
+
+/** "Open until 31 March 2027", "Open · rolling review", "Opening soon" or "Closed". */
+export function deadlineLabel(rfp: RfpView): string {
+ if (rfp.status === 'CLOSED') return 'Closed';
+ if (rfp.status === 'PENDING') return 'Opening soon';
+ return rfp.deadline ? `Open until ${formatDate(rfp.deadline)}` : 'Open · rolling review';
+}
+
+/** Whole days from now to the end of `iso` (UTC), never below zero. */
+export function daysLeft(iso: string): number {
+ const end = Date.parse(`${iso}T23:59:59Z`);
+ return Math.max(0, Math.ceil((end - Date.now()) / 86_400_000));
+}
+
+/** Where to talk to the team (Tyler's booking link, as on /give and /consciousness). */
+export const TALK_TO_TEAM = {
+ bookingUrl: 'https://cal.com/tyler-diorio/15min',
+};
diff --git a/app/audit/layout.tsx b/app/audit/layout.tsx
new file mode 100644
index 000000000..d53472ea3
--- /dev/null
+++ b/app/audit/layout.tsx
@@ -0,0 +1,41 @@
+import { Metadata } from 'next';
+import { IBM_Plex_Mono, Newsreader } from 'next/font/google';
+import { buildOpenGraphMetadata, SITE_CONFIG } from '@/lib/metadata';
+import { AuditShell } from './components/AuditShell';
+import './audit.css';
+
+// A text serif with optical sizes: headlines and reading text are set like
+// the papers the page is about. Labels and figures use a mono; controls
+// stay in Geist.
+const serif = Newsreader({
+ subsets: ['latin'],
+ style: ['normal', 'italic'],
+ axes: ['opsz'],
+ variable: '--font-audit-serif',
+ display: 'swap',
+});
+const mono = IBM_Plex_Mono({
+ subsets: ['latin'],
+ weight: ['400', '500'],
+ variable: '--font-audit-mono',
+ display: 'swap',
+});
+
+export const metadata: Metadata = {
+ ...buildOpenGraphMetadata({
+ title: 'Fund the audit of everything science has published.',
+ description:
+ 'A machine audit of one field of astrophysics reported 872 errors in 433 papers; 47 had ever been challenged in print. We are raising a pool to audit more fields in the open, with experts checking what the machines flag.',
+ url: '/audit',
+ }),
+ title: {
+ default: 'Auditing the scientific literature: request for proposals',
+ template: `%s | ${SITE_CONFIG.name}`,
+ },
+ // Not indexed until the call's terms are final (see CAMPAIGN in data/rfp.ts).
+ robots: { index: false, follow: false },
+};
+
+export default function AuditLayout({ children }: Readonly<{ children: React.ReactNode }>) {
+ return {children};
+}
diff --git a/app/audit/page.tsx b/app/audit/page.tsx
new file mode 100644
index 000000000..5880de7a6
--- /dev/null
+++ b/app/audit/page.tsx
@@ -0,0 +1,83 @@
+import { ActionDock } from './components/ActionDock';
+import { Hero } from './components/Hero';
+import {
+ AboutResearchHub,
+ Arithmetic,
+ AuditFooter,
+ Call,
+ Evidence,
+ Faq,
+ Finding,
+ HowItWorks,
+ Rules,
+ Sources,
+ Standing,
+ TalkToUs,
+} from './components/Sections';
+import { rfpPostId, rfpView } from './data/rfp';
+import { AuditRfpActions } from './components/AuditRfpActions';
+import { PostService } from '@/services/post.service';
+import type { Work } from '@/types/work';
+
+/**
+ * The RFP's post, as the RFP page's layout loads it, for the post `rfpPostId`
+ * picks in this environment. Null when there is none or the post fails to
+ * load; the page then shows an empty pool that opens soon.
+ */
+async function loadRfp(preview: string | string[] | undefined) {
+ const postId = rfpPostId(preview);
+ if (postId == null) return null;
+ try {
+ const work: Work = await PostService.get(String(postId));
+ const grant = work.note?.post?.grant;
+ if (!grant?.id) return null;
+ return { work, grant };
+ } catch {
+ return null;
+ }
+}
+
+/**
+ * The landing page for the literature-audit request for proposals: fund AI
+ * audits of the published literature, field by field, with experts checking
+ * what the machines flag. It shares its hero (pool, backers and both
+ * buttons, from the live RFP) with /consciousness and nothing else: the
+ * style is a marked-up proof, and the sections tell the audit's own story.
+ * All text is server-rendered; the hero's 3D figure starts once its script
+ * loads.
+ */
+export default async function AuditPage({
+ searchParams,
+}: {
+ searchParams: Promise>;
+}) {
+ const params = await searchParams;
+ const live = await loadRfp(params.rfp);
+ const rfp = rfpView(live?.work ?? null);
+ const page = (
+ <>
+
+