@anthusai/papyrus 5.56.1 → 5.58.0

package/lib/reference-policy.ts

@@ -22,6 +22,84 @@ export function isScopeTrainingNegativeReason(code: string): boolean {
   return SCOPE_TRAINING_NEGATIVE_REASON_CODE_SET.has(code);
 }
 
+/**
+ * The phrases an editor writes when they mean one reason code and little else.
+ *
+ * The order matters, and the two scope-training codes come LAST: a sentence
+ * that also names a mechanical reason ("already have it, and off our beat") is
+ * filed under that reason instead. A false scope negative teaches the relevance
+ * classifier something wrong; a missed one only leaves it untaught.
+ *
+ * Each phrase is a whole word or wording, never a fragment, so "slopes" is not
+ * read as "slop". Words that say none of this yield no code at all rather than
+ * the nearest guess.
+ */
+const WRITTEN_REASON_PHRASES: ReadonlyArray<readonly [ReferenceRejectionReasonCode, readonly string[]]> = [
+  ["duplicate", [
+    "duplicate", "duplicates", "duplicated", "duplication", "dupe", "reprint", "reprinted",
+    "already have (it|this|that|the)", "already (got|covered|accepted|registered|ingested|indexed)",
+    "already in (our|the) (corpus|list|feed|knowledge base|library)", "same (source|piece|story) as",
+  ]],
+  ["unavailable", [
+    "paywall", "paywalled", "unavailable", "not available", "no longer (available|online|up|there|reachable)",
+    "behind a (paywall|login|subscription|sign in)", "(dead|broken|404) link", "link is (dead|broken)",
+    "(cannot|cant) (open|read|reach|access|download|retrieve)", "requires a (subscription|login|account|sign in)",
+    "taken down", "timed out", "page is gone",
+  ]],
+  ["provenance", [
+    "provenance", "unattributed", "unverified", "unverifiable", "untraceable",
+    "(cannot|cant) (verify|attribute)", "no (byline|author|citation|attribution|provenance)",
+    "(unknown|unclear|anonymous|missing) (author|source|origin|provenance)", "who wrote it",
+  ]],
+  ["low_quality", [
+    "(low|poor) quality", "poorly (written|sourced|argued|researched|edited)", "badly written", "sloppy",
+    "content farm", "clickbait", "seo (spam|bait|filler)", "slop", "junk", "spam", "no substance", "churnalism",
+  ]],
+  ["policy_exclusion", [
+    "policy exclusion", "(our|house|editorial) policy", "against (our )?policy",
+    "(policy|policies) (excludes?|forbids?|bars?|rules? out|says?)",
+    "(excluded|barred|ruled out|forbidden) by (our )?policy",
+    "we (dont|do not) (cover|run|publish|cite|take)", "not allowed", "disallowed", "prohibited",
+    "blocklist", "blocklisted", "blocked source",
+  ]],
+  ["out_of_scope", [
+    "out of scope", "outside (our|the) (scope|remit|coverage|beat|lane)", "not (in|within) (our|the) scope",
+    "off topic", "nothing to do with", "not (our|the) (beat|subject|topic|area|coverage)",
+    "not relevant", "no longer relevant", "irrelevant", "unrelated", "wrong (beat|subject|topic)",
+  ]],
+];
+
+const WRITTEN_REASON_PATTERNS: ReadonlyArray<readonly [ReferenceRejectionReasonCode, RegExp]> =
+  WRITTEN_REASON_PHRASES.map(([code, phrases]) => [code, new RegExp(`\\b(?:${phrases.join("|")})\\b`)] as const);
+
+/**
+ * The reason code a rejection is filed under when the editor gave none: what
+ * their own words plainly say, else "other".
+ *
+ * Words are a reason — a written sentence is what the editor actually gives
+ * now that there are no reason chips — but "other" is the honest answer for
+ * words that name no policy code, rather than a guess the sentence cannot
+ * support. Blank words are no reason at all, so this yields null and the
+ * caller refuses the rejection.
+ */
+export function rejectionReasonCodeForWrittenReason(writtenReason: unknown): ReferenceRejectionReasonCode | null {
+  const words = normalizeWrittenReason(writtenReason);
+  if (!words) return null;
+  for (const [code, pattern] of WRITTEN_REASON_PATTERNS) {
+    if (pattern.test(words)) return code;
+  }
+  return "other";
+}
+
+/** Lower case, apostrophes dropped ("don't" -> "dont") and every other gap a single space, so phrases match plain prose. */
+function normalizeWrittenReason(value: unknown): string {
+  return String(value ?? "")
+    .toLowerCase()
+    .replace(/['\u2018\u2019]/g, "")
+    .replace(/[^a-z0-9]+/g, " ")
+    .trim();
+}
+
 export function normalizeReferenceCurationStatus(value: unknown, defaultStatus: ReferenceCurationStatus = "pending"): ReferenceCurationStatus {
   const normalized = normalizePolicyToken(value ?? defaultStatus);
   if (normalized === "accepted" || normalized === "accept" || normalized === "ready" || normalized === "trusted") return "accepted";
@@ -61,23 +139,17 @@ export function isEvidenceEligibleReference(reference: Pick<ReferenceRecord, "ve
     && normalizeReferenceCurationStatus(reference?.curationStatus) === "accepted";
 }
 
-export function referenceReasonCode(reference: Pick<ReferenceRecord, "metadata"> | null | undefined, messages: Array<Pick<MessageRecord, "metadata" | "createdAt">> = []): ReferenceRejectionReasonCode | null {
-  const metadataReason = reasonCodeFromMetadata(reference?.metadata);
-  if (metadataReason) return metadataReason;
-  const sortedMessages = [...messages].sort((left, right) => String(right.createdAt ?? "").localeCompare(String(left.createdAt ?? "")));
-  for (const message of sortedMessages) {
-    const reason = reasonCodeFromMetadata(message.metadata);
-    if (reason) return reason;
-  }
-  return null;
+/** The reason code of the Reference's latest vote (`curationReasonCode`), else one recorded in its metadata. */
+export function referenceReasonCode(reference: Pick<ReferenceRecord, "metadata" | "curationReasonCode"> | null | undefined): ReferenceRejectionReasonCode | null {
+  return normalizeReferenceRejectionReasonCode(reference?.curationReasonCode) ?? reasonCodeFromMetadata(reference?.metadata);
 }
 
-export function scopeTrainingLabelForReference(reference: Pick<ReferenceRecord, "versionState" | "curationStatus" | "metadata"> | null | undefined, messages: Array<Pick<MessageRecord, "metadata" | "createdAt">> = []): "positive" | "negative" | null {
+export function scopeTrainingLabelForReference(reference: Pick<ReferenceRecord, "versionState" | "curationStatus" | "metadata" | "curationReasonCode"> | null | undefined): "positive" | "negative" | null {
   if (!reference || reference.versionState !== "current") return null;
   const status = normalizeReferenceCurationStatus(reference.curationStatus);
   if (status === "accepted") return "positive";
   if (status !== "rejected") return null;
-  const reasonCode = referenceReasonCode(reference, messages);
+  const reasonCode = referenceReasonCode(reference);
   return reasonCode && SCOPE_TRAINING_NEGATIVE_REASON_CODE_SET.has(reasonCode) ? "negative" : null;
 }
 

package/lib/reference-review-details.ts

@@ -1,71 +1,35 @@
-import type { HydratedModelPayload, MessageRecord, SemanticRelationRecord } from "./category-repository";
+import type { ReferenceRecord, SemanticRelationRecord } from "./category-repository";
 import { normalizeReferenceRejectionReasonCode, type ReferenceRejectionReasonCode } from "./reference-policy";
 
-function metadataRecord(value: unknown): Record<string, unknown> {
-  if (typeof value === "string") {
-    try { return metadataRecord(JSON.parse(value)); } catch { return {}; }
-  }
-  return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
-}
-
-/** The selected Reference's index is authoritative even when the global feed is truncated. */
+/**
+ * The selected Reference's indexed predictions (the Cyclotron's relevance decisions). The Reference's own latest vote
+ * (`curationActorKind`, `curationReasonCode`, ...) is already on the Reference, so no Message is read.
+ */
 export async function loadReferenceReviewDetails(lineageId: string, read: {
-  relations: (direction: "incoming" | "outgoing") => Promise<SemanticRelationRecord[]>;
-  message: (id: string) => Promise<MessageRecord | null>;
-  payloads: (id: string) => Promise<HydratedModelPayload[]>;
-}): Promise<{ relations: SemanticRelationRecord[]; messages: MessageRecord[] }> {
-  const [outgoing, incoming] = await Promise.all([read.relations("outgoing"), read.relations("incoming")]);
-  const relations = outgoing.filter((relation) => relation.subjectKind === "reference" && relation.subjectLineageId === lineageId);
-  const latest = incoming.filter((relation) => relation.predicate === "comment" && relation.relationState === "current"
-    && relation.subjectKind === "message" && relation.objectKind === "reference" && relation.objectLineageId === lineageId
-    && metadataRecord(relation.metadata).messageKind === "reference_curation")
-    .sort((a, b) => String(b.createdAt ?? b.importedAt ?? "").localeCompare(String(a.createdAt ?? a.importedAt ?? "")))[0];
-  if (!latest) return { relations, messages: [] };
-  const message = await read.message(latest.subjectId);
-  if (!message || message.messageKind !== "reference_curation") throw new Error("The latest reference review could not be loaded.");
-  const payload = (await read.payloads(message.id))
-    .filter((entry) => entry.attachment.role === "metadata" && entry.attachment.ownerKind === "message" && entry.attachment.ownerId === message.id)
-    .sort((a, b) => String(b.attachment.updatedAt ?? "").localeCompare(String(a.attachment.updatedAt ?? "")))[0];
-  if (!payload) throw new Error("The latest reference review metadata could not be loaded.");
-  if (payload.error) throw new Error(payload.error);
-  if (!payload.json || typeof payload.json !== "object" || Array.isArray(payload.json)) {
-    throw new Error("The latest reference review metadata is invalid.");
-  }
-  const hydrated = { ...message, metadata: payload.json };
-  const recordedLineage = metadataRecord(hydrated.metadata).referenceLineageId;
-  if (recordedLineage !== lineageId) throw new Error("The latest review metadata does not match this reference lineage.");
-  return { relations, messages: [hydrated] };
-}
-
-function latestReferenceReviews(messages: MessageRecord[]): Map<string, MessageRecord> {
-  const latest = new Map<string, MessageRecord>();
-  for (const message of messages) {
-    if (message.messageKind !== "reference_curation") continue;
-    const lineage = metadataRecord(message.metadata).referenceLineageId;
-    if (typeof lineage !== "string" || !lineage) continue;
-    if (!latest.has(lineage) || String(message.createdAt).localeCompare(String(latest.get(lineage)!.createdAt)) > 0) latest.set(lineage, message);
-  }
-  return latest;
+  relations: (direction: "outgoing") => Promise<SemanticRelationRecord[]>;
+}): Promise<{ relations: SemanticRelationRecord[] }> {
+  const outgoing = await read.relations("outgoing");
+  return { relations: outgoing.filter((relation) => relation.subjectKind === "reference" && relation.subjectLineageId === lineageId) };
 }
 
-/** A later acceptance or archive clears any earlier rejection reason. */
-export function latestReferenceReviewReasons(messages: MessageRecord[]): Map<string, ReferenceRejectionReasonCode> {
+/** The reason code of each rejected Reference's latest vote. A later acceptance or archive replaced the vote, so it clears the reason. */
+export function latestReferenceReviewReasons(references: readonly ReferenceRecord[]): Map<string, ReferenceRejectionReasonCode> {
   const reasons = new Map<string, ReferenceRejectionReasonCode>();
-  for (const [lineage, message] of latestReferenceReviews(messages)) {
-    const metadata = metadataRecord(message.metadata);
-    const reason = metadata.action === "reject" ? normalizeReferenceRejectionReasonCode(metadata.reasonCode) : null;
-    if (reason) reasons.set(lineage, reason);
+  for (const reference of references) {
+    if (!reference.curationActorKind || reference.curationStatus !== "rejected") continue;
+    const reason = normalizeReferenceRejectionReasonCode(reference.curationReasonCode);
+    if (reason) reasons.set(reference.lineageId ?? reference.id, reason);
   }
   return reasons;
 }
 
-/** Preserve only a Section explicitly recorded on the newest acceptance, never a prediction. */
-export function latestReferenceReviewSections(messages: MessageRecord[]): Map<string, string> {
+/** The Section a person explicitly recorded on a Reference's latest vote when accepting it, never a prediction. */
+export function latestReferenceReviewSections(references: readonly ReferenceRecord[]): Map<string, string> {
   const sections = new Map<string, string>();
-  for (const [lineage, message] of latestReferenceReviews(messages)) {
-    const metadata = metadataRecord(message.metadata);
-    const sectionId = metadata.action === "accept" && typeof metadata.sectionId === "string" ? metadata.sectionId.trim() : "";
-    if (sectionId) sections.set(lineage, sectionId);
+  for (const reference of references) {
+    if (!reference.curationActorKind || reference.curationStatus !== "accepted") continue;
+    const sectionId = reference.curationSectionId?.trim() ?? "";
+    if (sectionId) sections.set(reference.lineageId ?? reference.id, sectionId);
   }
   return sections;
 }

package/lib/relevance-decisions.ts

@@ -149,11 +149,15 @@ export function currentRelevanceDecisions(relations: SemanticRelationRecord[]):
  * any other label, or a review without a label, rejects with the reason code,
  * which the existing scope-training rule turns back into a cyclotron label
  * (out_of_scope and policy_exclusion) or none.
+ *
+ * A rejection must say why, but either way of saying it will do: a reason code,
+ * or the editor's own words, which the curation Lambda reads for the code they
+ * name. Only a rejection with neither is refused.
  */
 export function curationForRelevanceReview(decision: RelevanceDecisionView, review: RelevanceReview): RelevanceCuration {
   const accepted = review.label !== null && review.label === decision.positiveLabel;
-  if (!accepted && !review.reasonCode) {
-    throw new Error("A review that does not accept the reference needs a reason code.");
+  if (!accepted && !review.reasonCode && !review.explanation?.trim()) {
+    throw new Error("A review that does not accept the reference needs a reason code, or a written reason.");
   }
   return {
     action: accepted ? "accept" : "reject",

package/lib/story-reporting-trail.ts

@@ -17,6 +17,15 @@ export type TrailVersion = {
   updatedAt: string | null;
 };
 
+/** One stage move of the story, read from the latest Item version's `metadata.stageMoves` (not from Messages). */
+export type TrailStageMove = {
+  at: string;
+  from: string | null;
+  to: string;
+  by: string | null;
+  reason: string | null;
+};
+
 export type TrailAssignmentEvent = {
   id: string;
   eventType: string;
@@ -89,12 +98,29 @@ export type StoryReportingTrail = {
   threads: TrailThread[];
   references: TrailReference[];
   attachments: TrailAttachment[];
+  stageMoves: TrailStageMove[];
 };
 
-export const EMPTY_STORY_REPORTING_TRAIL: StoryReportingTrail = { versions: [], assignments: [], threads: [], references: [], attachments: [] };
+export const EMPTY_STORY_REPORTING_TRAIL: StoryReportingTrail = { versions: [], assignments: [], threads: [], references: [], attachments: [], stageMoves: [] };
+
+/** The stage moves recorded on an Item version's metadata, oldest first. Anything that is not a well-formed move is skipped. */
+export function stageMovesOf(metadata: unknown): TrailStageMove[] {
+  let parsed: unknown = metadata;
+  if (typeof metadata === "string") {
+    try { parsed = JSON.parse(metadata); } catch { return []; }
+  }
+  const moves = typeof parsed === "object" && parsed ? (parsed as Record<string, unknown>).stageMoves : null;
+  if (!Array.isArray(moves)) return [];
+  return moves.flatMap(entry => {
+    if (typeof entry !== "object" || !entry) return [];
+    const move = entry as Record<string, unknown>;
+    if (typeof move.at !== "string" || typeof move.to !== "string") return [];
+    return [{ at: move.at, from: typeof move.from === "string" ? move.from : null, to: move.to, by: typeof move.by === "string" ? move.by : null, reason: typeof move.reason === "string" ? move.reason : null }];
+  });
+}
 
 export function storyReportingTrailIsEmpty(trail: StoryReportingTrail): boolean {
-  return trail.assignments.length === 0 && trail.threads.length === 0 && trail.references.length === 0 && trail.attachments.length === 0 && trail.versions.length <= 1;
+  return trail.assignments.length === 0 && trail.threads.length === 0 && trail.stageMoves.length === 0 && trail.references.length === 0 && trail.attachments.length === 0 && trail.versions.length <= 1;
 }
 
 export type StoryFeedEntry =

package/package.json

@@ -80,7 +80,16 @@
     "./components/automation-run-now": "./components/automation-run-now.tsx",
     "./components/automation-view": "./components/automation-view.tsx",
     "./components/blog-page-background": "./components/blog-page-background.tsx",
+    "./components/conversation-context": "./components/conversation-context.tsx",
+    "./components/conversation-provider": "./components/conversation-provider.tsx",
+    "./components/conversation-thread": "./components/conversation-thread.tsx",
+    "./components/conversations-memory-source": "./components/conversations-memory-source.ts",
+    "./components/conversations-network-source": "./components/conversations-network-source.ts",
+    "./components/conversations-page": "./components/conversations-page.tsx",
+    "./components/conversations-source": "./components/conversations-source.ts",
+    "./components/conversations-view": "./components/conversations-view.tsx",
     "./components/curation-delegation-client": "./components/curation-delegation-client.ts",
+    "./components/decision-control": "./components/decision-control.tsx",
     "./components/dev-sandbox-editor-sign-in": "./components/dev-sandbox-editor-sign-in.tsx",
     "./components/editorial-checks-admin-panel": "./components/editorial-checks-admin-panel.tsx",
     "./components/editorial-finding-card": "./components/editorial-finding-card.tsx",
@@ -146,6 +155,7 @@
     "./components/reference-add-entry": "./components/reference-add-entry.tsx",
     "./components/reference-capture-client": "./components/reference-capture-client.ts",
     "./components/reference-capture-panel": "./components/reference-capture-panel.tsx",
+    "./components/reference-conversation": "./components/reference-conversation.tsx",
     "./components/reference-curation-controls": "./components/reference-curation-controls.tsx",
     "./components/reference-cyclotron-priming": "./components/reference-cyclotron-priming.tsx",
     "./components/reference-cyclotron-status": "./components/reference-cyclotron-status.tsx",
@@ -160,7 +170,6 @@
     "./components/reference-stories": "./components/reference-stories.tsx",
     "./components/references-page-loading": "./components/references-page-loading.tsx",
     "./components/references-prefetch": "./components/references-prefetch.ts",
-    "./components/review-rating-grid": "./components/review-rating-grid.tsx",
     "./components/settings-page": "./components/settings-page.tsx",
     "./components/signup-entries-panel": "./components/signup-entries-panel.tsx",
     "./components/staging-banner": "./components/staging-banner.tsx",
@@ -189,6 +198,7 @@
     "./components/use-blog-header-obstacles": "./components/use-blog-header-obstacles.ts",
     "./components/use-brand-fonts-ready": "./components/use-brand-fonts-ready.ts",
     "./components/use-console-visibility": "./components/use-console-visibility.ts",
+    "./components/use-conversation": "./components/use-conversation.ts",
     "./components/use-editorial-checks": "./components/use-editorial-checks.ts",
     "./components/use-media-query": "./components/use-media-query.ts",
     "./components/use-near-viewport": "./components/use-near-viewport.ts",
@@ -229,6 +239,8 @@
     "./lib/content-repository": "./lib/content-repository.ts",
     "./lib/content-source-context": "./lib/content-source-context.ts",
     "./lib/content-types": "./lib/content-types.ts",
+    "./lib/conversation-feed": "./lib/conversation-feed.ts",
+    "./lib/conversation": "./lib/conversation.ts",
     "./lib/curation-client": "./lib/curation-client.ts",
     "./lib/curation-delegation-helpers": "./lib/curation-delegation-helpers.ts",
     "./lib/curation-routes": "./lib/curation-routes.ts",
@@ -342,6 +354,7 @@
     "./lib/reference-capture": "./lib/reference-capture.ts",
     "./lib/reference-display": "./lib/reference-display.ts",
     "./lib/reference-feed-cache": "./lib/reference-feed-cache.ts",
+    "./lib/reference-feed-keys": "./lib/reference-feed-keys.ts",
     "./lib/reference-feed-ranking": "./lib/reference-feed-ranking.ts",
     "./lib/reference-policy": "./lib/reference-policy.ts",
     "./lib/reference-preview": "./lib/reference-preview.ts",
@@ -504,7 +517,7 @@
       "optional": true
     }
   },
-  "version": "5.56.1",
+  "version": "5.58.0",
   "dependencies": {
     "@aws-amplify/adapter-nextjs": "^1.7.3",
     "@aws-crypto/sha256-js": "5.2.0",

package/routes.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "5.56.1",
+  "version": "5.58.0",
   "routes": [
     {
       "file": "app/%5F_preview/[[...path]]/route.ts",

package/components/review-rating-grid.tsx

@@ -1,190 +0,0 @@
-"use client";
-
-import { CheckIcon, CircleCheckIcon, CircleXIcon, Loader2Icon, XIcon } from "lucide-react";
-import { UNRECORDED_CONFIDENCE } from "../lib/reference-feed-ranking";
-import { cn } from "../lib/utils";
-import type { CardPrediction, ReviewChoice } from "./reference-review-card";
-
-/**
- * The rating area of a card: one grid, three columns (label | Accept | Reject), and the two rows share its columns exactly.
- *   Cyclotron   [ Accept 96% ]  [ Reject ]      read only; the predicted side is highlighted with its confidence
- *               [====== confidence bar, centred at 50% ======]
- *   You         [ Accept ]      [ Reject ]      the real buttons, each directly under its matching cell
- * Feedback is never colour alone: before you answer the predicted cell is neutral-accent with a check or cross; after, it turns
- * green with a CircleCheck (Match) or red with a CircleX (Miss), and the confidence bar tints the same way. Your chosen button is
- * filled. Flat tones and rounded shapes only, no borders.
- * The grid sizes itself to its own width (a container query), not the window's: on a narrow card the label column shrinks to its
- * word, the padding tightens, and the confidence wraps under "Accept" instead of spilling out of its cell.
- */
-
-export type RatingFeedback = { phase: "idle" | "saving" | "saved" | "error"; message?: string };
-
-/** P(accept) from a prediction: its confidence is in the side it chose; an unrecorded confidence is a mild lean. */
-export function predictionAcceptProbability(prediction: Extract<CardPrediction, { state: "ready" }>): number {
-  const confidence = prediction.confidence ?? UNRECORDED_CONFIDENCE;
-  return prediction.choice === "accept" ? confidence : 1 - confidence;
-}
-
-/** How far, in percent of the whole bar, the fill reaches from the centre: |P(accept) - 0.5| * 2, over the two halves. */
-export function confidenceFillPercent(probability: number): number {
-  return Math.min(100, Math.abs(probability - 0.5) * 2 * 100);
-}
-
-const WORD: Record<ReviewChoice, string> = { accept: "Accept", reject: "Reject" };
-
-const TONE = {
-  match: "bg-emerald-600/20 text-emerald-900 dark:bg-emerald-400/20 dark:text-emerald-100",
-  miss: "bg-red-600/20 text-red-900 dark:bg-red-400/20 dark:text-red-100",
-} as const;
-const FILL = { match: "bg-emerald-600 dark:bg-emerald-400", miss: "bg-red-600 dark:bg-red-400", neutral: "bg-[var(--primary)]" } as const;
-
-export function RatingGrid({
-  answer,
-  decided = answer,
-  disabled = false,
-  disabledReason = null,
-  feedback = { phase: "idle" },
-  note = null,
-  onChoose,
-  prediction,
-  showPrediction = true,
-  size = "compact",
-  statusOverlay = false,
-  surface = "footer",
-}: {
-  /** The side the buttons show as chosen (it may be a pending choice that is still saving). */
-  answer: ReviewChoice | null;
-  /** The saved human answer, which the Match / Miss verdict compares against. */
-  decided?: ReviewChoice | null;
-  disabled?: boolean;
-  disabledReason?: string | null;
-  feedback?: RatingFeedback;
-  /** A short line shown in the status row beside the Saved tick (for example the reason). It never adds a row. */
-  note?: string | null;
-  onChoose: (choice: ReviewChoice) => void;
-  prediction: CardPrediction;
-  /** False for a card with nothing to predict (an AI draft): the Cyclotron row and the "You" label are left out and only the two buttons remain. */
-  showPrediction?: boolean;
-  size?: "compact" | "large";
-  /** Lay the Saved / note line over the bottom padding of the nearest positioned ancestor, so it adds no height under the buttons. */
-  statusOverlay?: boolean;
-  /** The tone the grid sits on, so the bar's centre notch matches it. */
-  surface?: "footer" | "card";
-}) {
-  const ready = prediction.state === "ready" ? prediction : null;
-  const verdict = ready && decided ? (ready.choice === decided ? "match" : "miss") : null;
-  const probability = ready ? predictionAcceptProbability(ready) : 0.5;
-  const half = confidenceFillPercent(probability) / 2; // percent of the full bar width, on one side of the centre
-  const leansAccept = probability >= 0.5;
-  const confidenceText = ready && ready.confidence !== null ? `${Math.round(ready.confidence * 100)}%` : null;
-  const cell = size === "large" ? "min-h-14 text-base" : "min-h-12 text-sm";
-  const label = size === "large" ? "text-sm" : "text-xs";
-
-  return (
-    <div
-      className={cn(
-        "@container/rating grid gap-x-2 gap-y-2",
-        showPrediction ? "grid-cols-[auto_minmax(0,1fr)_minmax(0,1fr)] @max-[17rem]/rating:gap-x-1.5" : "grid-cols-2",
-      )}
-      data-rating-grid
-    >
-      {showPrediction ? <div className="col-span-3 grid grid-cols-subgrid items-stretch gap-y-2" data-review-row="cyclotron">
-        <span className={cn("self-center font-semibold", label)}>Cyclotron</span>
-        {(["accept", "reject"] as const).map((choice) => {
-          const predicted = ready?.choice === choice;
-          const Icon = predicted ? (verdict === "match" ? CircleCheckIcon : verdict === "miss" ? CircleXIcon : choice === "accept" ? CheckIcon : XIcon) : null;
-          return (
-            <span
-              className={cn(
-                "flex min-w-0 flex-col items-center justify-center rounded-[16px] px-2 py-1.5 text-center @max-[17rem]/rating:px-1",
-                cell,
-                !predicted && "bg-[var(--feed-control)]/45 text-muted-foreground",
-                predicted && !verdict && "bg-[var(--feed-control)] font-semibold text-[var(--primary)]",
-                predicted && verdict && cn("font-semibold", TONE[verdict]),
-              )}
-              data-cyclotron-choice={choice}
-              data-predicted={predicted || undefined}
-              data-verdict={predicted && verdict ? verdict : undefined}
-              key={choice}
-            >
-              {/* Wraps rather than overflows: when the cell is narrow, the confidence moves onto its own line. */}
-              <span className="flex max-w-full flex-wrap items-center justify-center gap-x-1.5 leading-tight">
-                <span className="inline-flex items-center gap-1">
-                  {Icon ? <Icon aria-hidden="true" className="size-4 shrink-0" /> : null}
-                  {WORD[choice]}
-                </span>
-                {/* The confidence and the verdict share one line, so a vote never makes the cell (or the card) taller. */}
-                {predicted && (confidenceText || verdict) ? (
-                  <small className="inline-flex items-center gap-1 whitespace-nowrap text-xs">
-                    {confidenceText ? <span className="font-normal opacity-80" data-cyclotron-confidence>{confidenceText}</span> : null}
-                    {confidenceText && verdict ? <span aria-hidden="true" className="opacity-60">·</span> : null}
-                    {verdict ? <span className="font-medium" data-verdict-word>{verdict === "match" ? "Match" : "Miss"}</span> : null}
-                  </small>
-                ) : null}
-              </span>
-              {predicted && verdict ? <span className="sr-only">{verdict === "match" ? ", matches your answer" : ", differs from your answer"}</span> : null}
-            </span>
-          );
-        })}
-        <div className="col-span-2 col-start-2 flex flex-col justify-center" data-confidence>
-          <div
-            aria-label={ready ? `Cyclotron confidence: leans ${leansAccept ? "Accept" : "Reject"}, ${Math.round(confidenceFillPercent(probability))} percent of the way` : "No confidence"}
-            className="relative h-2.5 w-full overflow-hidden rounded-full bg-[var(--feed-control)]"
-            data-confidence-bar
-            data-confidence-direction={ready ? (leansAccept ? "accept" : "reject") : "none"}
-            role="img"
-          >
-            {ready ? (
-              <span
-                className={cn("absolute inset-y-0 rounded-full", FILL[verdict ?? "neutral"])}
-                data-confidence-fill
-                data-fill-percent={Math.round(half * 2)}
-                style={{ left: leansAccept ? `${50 - half}%` : "50%", width: `${half}%` }}
-              />
-            ) : null}
-            <span aria-hidden="true" className={cn("absolute inset-y-0 left-1/2 w-1 -translate-x-1/2", surface === "footer" ? "bg-[var(--feed-footer)]" : "bg-[var(--feed-card)]")} />
-          </div>
-          {/* Screen-reader status only: a visible line under the bar would push it off the middle between the Cyclotron and You rows. */}
-          <small className="sr-only" data-cyclotron-state={prediction.state === "ready" ? undefined : prediction.state}>
-            {prediction.state === "ready" ? "" : prediction.state === "loading" ? "Loading…" : prediction.state === "error" ? "Prediction unavailable" : "No prediction"}
-          </small>
-        </div>
-      </div> : null}
-
-      <div className={cn("grid grid-cols-subgrid items-stretch", showPrediction ? "col-span-3" : "col-span-2")} data-review-row="you">
-        {showPrediction ? <span className={cn("self-center font-semibold", label)}>You</span> : null}
-        {(["accept", "reject"] as const).map((choice) => {
-          const on = answer === choice;
-          const Icon = choice === "accept" ? CheckIcon : XIcon;
-          return (
-            <button
-              aria-disabled={disabled ? true : undefined}
-              aria-pressed={on}
-              className={cn(
-                "inline-flex min-w-0 items-center justify-center gap-1.5 rounded-[16px] px-2 font-medium outline-none transition-colors focus-visible:ring-2 focus-visible:ring-ring @max-[17rem]/rating:gap-1 @max-[17rem]/rating:px-1",
-                cell,
-                on ? "bg-[var(--primary)] font-semibold text-[var(--primary-foreground)]" : "bg-[var(--feed-control)] text-foreground hover:bg-[var(--feed-control)]/70",
-                disabled && !on && "opacity-60",
-              )}
-              data-review-choice={choice}
-              key={choice}
-              onClick={() => onChoose(choice)}
-              type="button"
-            >
-              <Icon aria-hidden="true" className={cn("size-4", !on && "opacity-60")} />
-              {WORD[choice]}
-            </button>
-          );
-        })}
-      </div>
-
-      <div className={cn("flex flex-wrap items-center gap-x-3 text-xs text-muted-foreground", statusOverlay ? "absolute inset-x-4 bottom-0 h-4 overflow-hidden leading-4" : cn("min-h-5", showPrediction ? "col-span-3" : "col-span-2"))} data-feed-saved role="status">
-        {note ? <span data-feed-reason>{note}</span> : null}
-        {feedback.phase === "saving" ? <span className="inline-flex items-center gap-1"><Loader2Icon aria-hidden="true" className="size-3.5 animate-spin" />Saving…</span> : null}
-        {feedback.phase === "saved" ? <span className="inline-flex items-center gap-1" data-review-saved><CheckIcon aria-hidden="true" className="size-3.5" />Saved</span> : null}
-      </div>
-      {disabledReason ? <p className={cn("text-xs text-muted-foreground", showPrediction ? "col-span-3" : "col-span-2")} data-review-disabled-reason>{disabledReason}</p> : null}
-      {feedback.phase === "error" ? <p className={cn("text-xs text-destructive", showPrediction ? "col-span-3" : "col-span-2")} role="alert">{feedback.message}</p> : null}
-    </div>
-  );
-}