@anthusai/papyrus 5.43.0-next.4 → 5.43.0-next.41

package/components/papyrus-console-shell.tsx

@@ -6,6 +6,7 @@ import dynamic from "next/dynamic";
 import { usePathname, useRouter, useSearchParams } from "next/navigation";
 import { CheckIcon, UserIcon } from "lucide-react";
 import { Md5 } from "@smithy/md5-js";
+import { hasEditorRights } from "../lib/staff-groups";
 import {
   createConsoleMessage,
   createConsoleThread,
@@ -154,7 +155,7 @@ export function PapyrusConsoleShell({ children, privateChatEnabled = false }: Pa
   const [openingReferenceChat, setOpeningReferenceChat] = useState(false);
   const internalPathname = browserPathToInternalNewsroomPath(pathname);
   const isNewsroomPath = internalPathname === "/newsroom" || internalPathname.startsWith("/newsroom/");
-  const canUseConsole = Boolean(session?.hasSession && session.groups.some((group) => group === "editor" || group === "admin"));
+  const canUseConsole = Boolean(session?.hasSession && hasEditorRights(session.groups));
   const shouldOfferConsole = isNewsroomPath && canUseConsole;
   const { open, openConsole, closeConsole, toggleOpen } = useConsoleVisibility({ available: shouldOfferConsole });
 

package/components/proposals-panel.tsx

@@ -2,21 +2,20 @@
 
 import { generateClient } from "aws-amplify/data";
 import amplifyOutputs from "papyrus-amplify-outputs";
-import { useCallback, useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { ProposalsView } from "./proposals-view";
 import { pluginSettings, type PluginOutputs } from "../lib/plugin-settings";
 import {
-  EDIT_PROPOSAL,
   LIST_PROPOSALS,
-  TRANSITION_PROPOSAL,
+  filterProposals,
   proposalReceiptMessage,
   type ProposalFilter,
   type ProposalMove,
-  type ProposalReceipt,
   type ProposalRow,
 } from "../lib/proposals-admin";
+import { performProposalMove } from "../lib/proposals-client";
 
-type GraphResult = { data?: Record<string, { items?: ProposalRow[]; nextToken?: string | null } | ProposalReceipt | null>; errors?: { message?: string }[] };
+type GraphResult = { data?: Record<string, { items?: ProposalRow[]; nextToken?: string | null } | null>; errors?: { message?: string }[] };
 const MAXIMUM_PAGES = 20;
 
 async function loadProposals(): Promise<ProposalRow[]> {
@@ -34,24 +33,6 @@ async function loadProposals(): Promise<ProposalRow[]> {
   return rows;
 }
 
-async function run(query: string, field: string, variables: Record<string, string | undefined>): Promise<ProposalReceipt> {
-  const client = generateClient({ authMode: "userPool" });
-  const result = (await client.graphql({ query, variables })) as GraphResult;
-  if (result.errors?.length) return { status: "refused", message: result.errors[0]?.message ?? "The action failed." };
-  return (result.data?.[field] as ProposalReceipt | null) ?? { status: "refused", message: "The action did not answer." };
-}
-
-/** One button: a path of states is one `transitionProposal` call per state, stopping at the first refusal; pin and hold are `editProposal`. */
-async function perform(proposalId: string, move: ProposalMove, reason: string): Promise<ProposalReceipt> {
-  if (move.edit) return run(EDIT_PROPOSAL, "editProposal", { proposalId, action: move.edit });
-  let receipt: ProposalReceipt = { status: "refused", message: "Nothing to do." };
-  for (const state of move.path ?? []) {
-    receipt = await run(TRANSITION_PROPOSAL, "transitionProposal", { proposalId, state, ...(reason ? { reason } : {}) });
-    if (receipt.status !== "ok") break;
-  }
-  return receipt;
-}
-
 /** Core to every site: it does not depend on the reader-steering plugin. */
 export function ProposalsPanel() {
   const [rows, setRows] = useState<ProposalRow[]>([]);
@@ -59,6 +40,8 @@ export function ProposalsPanel() {
   const [status, setStatus] = useState("Loading...");
   const [busy, setBusy] = useState(false);
   const [reason, setReason] = useState("");
+  const [focusId, setFocusId] = useState<string | null>(null);
+  const focused = useRef(false);
   const readers = useMemo(() => pluginSettings(amplifyOutputs as PluginOutputs, "reader-steering") !== null, []);
 
   const refresh = useCallback(async (quiet = false) => {
@@ -77,12 +60,25 @@ export function ProposalsPanel() {
     void refresh();
   }, [refresh]);
 
+  // Sent here by a link such as `?proposal=<id>`: show the view that holds it and scroll to it.
+  useEffect(() => {
+    setFocusId(new URLSearchParams(window.location.search).get("proposal"));
+  }, []);
+  useEffect(() => {
+    if (!focusId || focused.current) return;
+    const row = rows.find((candidate) => candidate.id === focusId);
+    if (!row) return;
+    focused.current = true;
+    setFilter(filterProposals([row], "open").length ? "open" : "decided");
+    window.requestAnimationFrame(() => document.getElementById(`proposal-${focusId}`)?.scrollIntoView({ block: "start" }));
+  }, [focusId, rows]);
+
   const onMove = useCallback(
     async (proposalId: string, move: ProposalMove) => {
       setBusy(true);
       setStatus("Working...");
       try {
-        const receipt = await perform(proposalId, move, reason.trim());
+        const receipt = await performProposalMove(proposalId, move, reason.trim());
         setStatus(proposalReceiptMessage(receipt));
         if (receipt.status === "ok") setReason("");
       } catch (error) {
@@ -105,6 +101,7 @@ export function ProposalsPanel() {
       onReason={setReason}
       onMove={(proposalId, move) => void onMove(proposalId, move)}
       onRefresh={() => void refresh()}
+      focusId={focusId}
     />
   );
 }

package/components/proposals-view.tsx

@@ -32,6 +32,8 @@ export type ProposalsViewProps = {
   onReason: (reason: string) => void;
   onMove: (proposalId: string, move: ProposalMove) => void;
   onRefresh: () => void;
+  /** A proposal the editor was sent to (from the Notification Center): its draft opens and it is marked. */
+  focusId?: string | null;
 };
 
 export function ProposalsView(props: ProposalsViewProps) {
@@ -62,7 +64,7 @@ export function ProposalsView(props: ProposalsViewProps) {
       ) : (
         <ul>
           {shown.map((row) => (
-            <li key={row.id} data-proposal-row={row.id}>
+            <li key={row.id} id={`proposal-${row.id}`} data-proposal-row={row.id} data-proposal-focused={props.focusId === row.id || undefined}>
               <article aria-label={row.title}>
                 <p>
                   <strong>{kindLabel(row.kind)}</strong>: {row.title} ({stateLabel(row.state, props.readers)}
@@ -70,7 +72,7 @@ export function ProposalsView(props: ProposalsViewProps) {
                 </p>
                 {row.summary ? <p>{row.summary}</p> : null}
                 {row.body ? (
-                  <details>
+                  <details open={props.focusId === row.id || undefined}>
                     <summary>Read the draft</summary>
                     <pre style={{ whiteSpace: "pre-wrap", overflowWrap: "anywhere" }}>{row.body}</pre>
                   </details>

package/components/reader-auth-control.tsx

@@ -36,7 +36,9 @@ export function ReaderAuthControl({
     if (!nextPath) return;
     if (window.location.pathname !== "/" || window.location.search || window.location.hash) return;
     if (storedPath) window.sessionStorage.removeItem(POST_AUTH_PATH_KEY);
-    window.history.replaceState(window.history.state, "", nextPath);
+    if (nextPath === "/") return;
+    // Sign-in comes back to "/"; the page asked for (a deep link such as /references/<id>) may be another route, so load it.
+    window.location.replace(nextPath);
   }, [postAuthPath]);
 
   const refreshAuthState = useCallback(async () => {

package/components/reference-capture-client.ts

@@ -0,0 +1,138 @@
+"use client";
+
+import { useCallback, useEffect, useMemo, useState } from "react";
+import type { ReferenceAttachmentRecord, ReferenceRecord } from "../lib/category-repository";
+import { isLocalPreviewEnabled } from "../lib/local-preview";
+import {
+  captureStatus, countWords, curationCardOf, grobidRows, primaryTextAttachment, structuredRows,
+  type CaptureAssessment as Assessment, type CaptureStatus, type CurationCard,
+} from "../lib/reference-capture";
+import { loadModelPayloadsForOwner, loadStoragePathText, uploadModelPayloadForOwner } from "./news-desk-taxonomy-client";
+
+export type CaptureAssessment = Assessment;
+
+export type CaptureView = {
+  status: CaptureStatus;
+  /** The stored text, once read. Null while loading, or when there is none. */
+  text: string | null;
+  loading: boolean;
+  error: string | null;
+  summary: string | null;
+  /** True when an editor replaced the text and the summary awaits the next curation run. */
+  summaryStale: boolean;
+  rows: Array<{ label: string; value: string }>;
+  /** Saves an editor's pasted or corrected text and their verdict on the capture (the `correctReferenceCapture` action). */
+  correct?: (input: { text?: string; assessment: CaptureAssessment; note?: string }) => Promise<void>;
+  /** True when the current text was read from a PDF the editor uploaded. */
+  fromPdf: boolean;
+  /** Stores a PDF the editor downloaded as an attachment of the Reference, then has the server read its text (`correctReferenceCapture` with `pdfAttachmentId`). */
+  uploadPdf?: (input: { file: File; assessment: CaptureAssessment; note?: string }, onStep?: (step: "uploading" | "reading") => void) => Promise<void>;
+};
+
+/** The server reads PDFs up to this size (ideas.source_text.MAXIMUM_PDF_BYTES); say so before a slow upload that would be refused. */
+export const MAXIMUM_PDF_UPLOAD_BYTES = 8_000_000;
+export const PDF_UPLOAD_ROLE = "curation-upload-pdf";
+
+function previewText(attachment: ReferenceAttachmentRecord): string | null {
+  // Local preview only: a fixture can carry the captured text inline instead of in storage.
+  if (!isLocalPreviewEnabled()) return null;
+  const raw = attachment.metadata;
+  try {
+    const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+    const text = (parsed as { previewText?: unknown } | null)?.previewText;
+    return typeof text === "string" ? text : null;
+  } catch { return null; }
+}
+
+type Payloads = { key: string; text: string | null; grobid: unknown; summary: string | null; loaded: boolean };
+
+/**
+ * Reads what the newsroom stored for one Reference. The curation card comes first (status, word count, signals, summary, GROBID fields,
+ * and the `curation-text` body its `current` points at); the older `extracted_text` attachment is the fallback.
+ */
+export type CorrectCaptureAction = (input: { referenceId: string; text?: string; pdfAttachmentId?: string; assessment: CaptureAssessment; note?: string }) => Promise<unknown>;
+
+export function useReferenceCapture(reference: ReferenceRecord, attachments: readonly ReferenceAttachmentRecord[], teaserLine: number, correctAction?: CorrectCaptureAction): CaptureView {
+  const card: CurationCard | null = useMemo(() => curationCardOf(attachments), [attachments]);
+  const primary = useMemo(() => primaryTextAttachment(attachments), [attachments]);
+  const textSortKey = card?.current?.textSortKey ?? card?.capture.textSortKey ?? null;
+  const grobidSortKey = card?.current?.grobidSortKey ?? card?.grobid?.fieldsSortKey ?? null;
+  const [payloads, setPayloads] = useState<Payloads>({ key: "", text: null, grobid: null, summary: null, loaded: false });
+  const [fallback, setFallback] = useState<{ key: string; text: string | null; error: string | null; loading: boolean }>({ key: "", text: null, error: null, loading: false });
+  const [corrected, setCorrected] = useState<{ key: string; text: string; assessment: CaptureAssessment; fromPdf?: boolean } | null>(null);
+  const referenceKey = `${reference.id}:${textSortKey ?? ""}:${grobidSortKey ?? ""}`;
+
+  // The card's bodies and the Reference's metadata.json, in one read of the Reference's ModelAttachments.
+  useEffect(() => {
+    if (isLocalPreviewEnabled()) { setPayloads({ key: referenceKey, text: null, grobid: null, summary: null, loaded: true }); return; }
+    let active = true;
+    void loadModelPayloadsForOwner("reference", reference.id, ["metadata"])
+      .then((rows) => {
+        if (!active) return;
+        const bySortKey = (key: string | null) => (key ? rows.find((row) => row.attachment.sortKey === key) : undefined);
+        const metadata = rows.find((row) => row.attachment.sortKey === "metadata")?.json as { summary?: unknown } | null | undefined;
+        setPayloads({
+          key: referenceKey,
+          text: bySortKey(textSortKey)?.text ?? null,
+          grobid: bySortKey(grobidSortKey)?.json ?? null,
+          summary: typeof metadata?.summary === "string" && metadata.summary.trim() ? metadata.summary.trim() : null,
+          loaded: true,
+        });
+      })
+      .catch(() => { if (active) setPayloads({ key: referenceKey, text: null, grobid: null, summary: null, loaded: true }); });
+    return () => { active = false; };
+  }, [reference.id, referenceKey, textSortKey, grobidSortKey]);
+
+  // Fallback: the older extracted_text attachment, when the card has no text of its own.
+  const fallbackKey = primary ? `${primary.id}:${primary.storagePath ?? ""}` : "";
+  const useFallback = Boolean(primary) && !textSortKey;
+  useEffect(() => {
+    if (!useFallback || !primary) { setFallback({ key: "", text: null, error: null, loading: false }); return; }
+    const inline = previewText(primary);
+    if (inline !== null) { setFallback({ key: fallbackKey, text: inline, error: null, loading: false }); return; }
+    let active = true;
+    setFallback({ key: fallbackKey, text: null, error: null, loading: true });
+    void loadStoragePathText(primary.storagePath)
+      .then((result) => { if (active) setFallback({ key: fallbackKey, text: result.text, error: result.error, loading: false }); })
+      .catch((error) => { if (active) setFallback({ key: fallbackKey, text: null, error: error instanceof Error ? error.message : "Could not read the stored text.", loading: false }); });
+    return () => { active = false; };
+  }, [primary, fallbackKey, useFallback]);
+
+  const current = payloads.key === referenceKey ? payloads : null;
+  const mine = corrected && corrected.key === reference.id ? corrected : null;
+  const fromPdf = mine ? mine.fromPdf === true : card?.current?.textVia === "editor_pdf";
+  const text = mine?.text ?? (textSortKey ? current?.text ?? null : fallback.key === fallbackKey ? fallback.text : null);
+  const loading = mine ? false : textSortKey ? !(current?.loaded) : useFallback && fallback.key === fallbackKey ? fallback.loading : useFallback;
+  const error = textSortKey || mine ? null : fallback.key === fallbackKey ? fallback.error : null;
+  const loadedWords = text !== null ? countWords(text) : null;
+  const base = captureStatus(attachments, teaserLine, loadedWords);
+  const status: CaptureStatus = mine ? { ...base, state: base.state === "none" || base.state === "running" ? (loadedWords !== null && loadedWords < teaserLine ? "thin" : "full") : base.state, words: loadedWords, estimated: false, assessment: mine.assessment, summaryStale: true, ...(loadedWords !== null && loadedWords < teaserLine ? { thinBy: "length" as const } : {}) } : base;
+  const summary = card?.summary?.status === "completed" && card.summary.text ? card.summary.text : current?.summary ?? null;
+  const rows = card ? grobidRows(current?.grobid, card) : structuredRows(attachments);
+
+  const correct = useCallback(async (input: { text?: string; assessment: CaptureAssessment; note?: string }) => {
+    if (correctAction) await correctAction({ referenceId: reference.id, ...(input.text !== undefined ? { text: input.text } : {}), assessment: input.assessment, ...(input.note ? { note: input.note } : {}) });
+    setCorrected({ key: reference.id, text: input.text ?? text ?? "", assessment: input.assessment, fromPdf: input.text === undefined && fromPdf });
+  }, [reference.id, text, fromPdf, correctAction]);
+
+  const uploadPdf = useCallback(async (input: { file: File; assessment: CaptureAssessment; note?: string }, onStep?: (step: "uploading" | "reading") => void) => {
+    if (!correctAction) throw new Error("Uploading is not available here.");
+    if (input.file.size > MAXIMUM_PDF_UPLOAD_BYTES) throw new Error(`That PDF is larger than we read (${MAXIMUM_PDF_UPLOAD_BYTES / 1_000_000} MB). Paste the text instead.`);
+    onStep?.("uploading");
+    const attachment = await uploadModelPayloadForOwner({
+      ownerKind: "reference", ownerId: reference.id, ownerLineageId: reference.lineageId ?? reference.id, ownerVersionNumber: reference.versionNumber ?? null,
+      ownerVersionKey: `reference#${reference.id}`, role: PDF_UPLOAD_ROLE, sortKey: `${PDF_UPLOAD_ROLE}-${Date.now().toString(36)}`,
+      filename: input.file.name || "upload.pdf", mediaType: "application/pdf", content: input.file,
+    });
+    onStep?.("reading");
+    const result = await correctAction({ referenceId: reference.id, pdfAttachmentId: attachment.id, assessment: input.assessment, ...(input.note ? { note: input.note } : {}) });
+    // The server read the text; fetch the new body it stored so the panel shows it.
+    const sortKey = (result as { edits?: Array<{ sortKey?: string; kind?: string }> } | null | undefined)?.edits?.find((edit) => edit.kind === "text")?.sortKey;
+    const rows = sortKey ? await loadModelPayloadsForOwner("reference", reference.id, ["metadata"]) : [];
+    const stored = rows.find((row) => row.attachment.sortKey === sortKey)?.text;
+    if (typeof stored !== "string") throw new Error("The PDF was read, but its text could not be loaded. Reload to see it.");
+    setCorrected({ key: reference.id, text: stored, assessment: input.assessment, fromPdf: true });
+  }, [reference.id, reference.lineageId, reference.versionNumber, correctAction]);
+
+  return { status, text, loading, error, summary, summaryStale: Boolean(mine) || status.summaryStale === true, rows, fromPdf, correct: correctAction || isLocalPreviewEnabled() ? correct : undefined, uploadPdf: correctAction ? uploadPdf : undefined };
+}

package/components/reference-capture-panel.tsx

@@ -0,0 +1,268 @@
+"use client";
+
+import { FileCheckIcon, FileClockIcon, FileUpIcon, FileWarningIcon, FileXIcon, Loader2Icon } from "lucide-react";
+import { useEffect, useRef, useState } from "react";
+import { captureLine, type CaptureAssessment, type CaptureState, type CaptureStatus } from "../lib/reference-capture";
+import { cn } from "../lib/utils";
+import { AutoGrowTextarea } from "./ui/auto-grow-textarea";
+import type { CaptureView } from "./reference-capture-client";
+import { MarkdownContext } from "./markdown-context";
+
+const ICON = { full: FileCheckIcon, thin: FileWarningIcon, none: FileXIcon, running: FileClockIcon } as const;
+/** Colour never stands alone: each state has its own icon and words. */
+const TONE: Record<CaptureState, string> = {
+  full: "bg-emerald-600/15 text-emerald-900 dark:bg-emerald-400/15 dark:text-emerald-100",
+  thin: "bg-amber-500/20 text-amber-900 dark:bg-amber-300/15 dark:text-amber-100",
+  none: "bg-red-600/15 text-red-900 dark:bg-red-400/15 dark:text-red-100",
+  running: "bg-[var(--feed-control)] text-foreground",
+};
+
+/** A small badge for a grid card, so a thin or missing capture shows before the item is opened. It follows the curation status when there is one. */
+export function CaptureBadge({ status }: { status: CaptureStatus }) {
+  const Icon = ICON[status.state];
+  const text = status.state === "none" ? "No text" : status.state === "running" ? "Capturing" : status.state === "thin" ? (status.words === null || status.thinBy === "signals" ? "Maybe cut off" : `${status.words.toLocaleString("en-US")} words`) : "Full text";
+  return (
+    <span
+      className={cn("inline-flex items-center gap-1 rounded-full px-2 py-0.5 text-[0.7rem] font-medium", TONE[status.state])}
+      data-capture-badge={status.state}
+      data-capture-curation={status.curation ?? undefined}
+      data-capture-source={status.source}
+      title={captureLine(status).label}
+    >
+      <Icon aria-hidden="true" className="size-3.5" />
+      {text}
+    </span>
+  );
+}
+
+const PREVIEW_CHARACTERS = 1600;
+const ASSESSMENTS: Array<{ key: CaptureAssessment; label: string; hint: string }> = [
+  { key: "complete", label: "Complete", hint: "This is the whole item." },
+  { key: "incomplete", label: "Incomplete", hint: "Something is missing or cut off." },
+  { key: "incorrect", label: "Incorrect", hint: "This is not the right text." },
+];
+
+/** The editor's verdict on the machine capture; asked the same way whether they paste text or upload a PDF. */
+function AssessmentChoice({ value, onChange }: { value: CaptureAssessment | null; onChange: (value: CaptureAssessment) => void }) {
+  return (
+    <div aria-label="Was the capture complete?" className="flex flex-wrap gap-2" role="group">
+      {ASSESSMENTS.map((option) => (
+        <button
+          aria-pressed={value === option.key}
+          className={cn("inline-flex min-h-9 items-center rounded-full px-3 text-sm font-medium outline-none focus-visible:ring-2 focus-visible:ring-ring", value === option.key ? "bg-[var(--primary)] text-[var(--primary-foreground)]" : "bg-[var(--feed-card)]")}
+          data-capture-assessment={option.key}
+          key={option.key}
+          onClick={() => onChange(option.key)}
+          title={option.hint}
+          type="button"
+        >
+          {option.label}
+        </button>
+      ))}
+    </div>
+  );
+}
+
+/** "Upload a PDF": the editor's verdict, then the PDF they downloaded themselves; the server reads its text. */
+function PdfUploadForm({ capture, onDone, onCancel }: { capture: CaptureView; onDone: () => void; onCancel: () => void }) {
+  const [assessment, setAssessment] = useState<CaptureAssessment | null>(null);
+  const [note, setNote] = useState("");
+  const [phase, setPhase] = useState<"idle" | "uploading" | "reading" | "error">("idle");
+  const [message, setMessage] = useState<string | null>(null);
+  const input = useRef<HTMLInputElement>(null);
+  const reason = !assessment ? "Say whether the capture was complete, incomplete or incorrect, then choose the PDF." : null;
+  const busy = phase === "uploading" || phase === "reading";
+  async function upload(file: File) {
+    if (!assessment || !capture.uploadPdf) return;
+    setMessage(null);
+    try {
+      await capture.uploadPdf({ file, assessment, ...(note.trim() ? { note: note.trim() } : {}) }, (step) => setPhase(step));
+      onDone();
+    } catch (failure) {
+      setPhase("error");
+      setMessage(failure instanceof Error ? failure.message : "The PDF could not be uploaded.");
+    }
+  }
+  return (
+    <div className="space-y-3 rounded-2xl bg-[var(--feed-control)] p-3" data-capture-upload-form>
+      <p className="text-sm font-medium">Upload the PDF you downloaded. Its text replaces the capture, and the capture is kept.</p>
+      <AssessmentChoice onChange={setAssessment} value={assessment} />
+      <label className="block text-sm font-medium">
+        Note (optional)
+        <AutoGrowTextarea aria-label="Note about the capture (optional)" className="mt-1 block min-h-16 w-full rounded-2xl bg-[var(--feed-card)] p-3 text-sm font-normal" onChange={(event) => setNote(event.target.value)} value={note} />
+      </label>
+      <input
+        accept="application/pdf"
+        aria-label="PDF file"
+        className="hidden"
+        data-capture-upload-input
+        onChange={(event) => {
+          const file = event.target.files?.[0];
+          event.target.value = "";
+          if (file) void upload(file);
+        }}
+        ref={input}
+        type="file"
+      />
+      {reason && !busy ? <p className="text-xs text-muted-foreground" data-capture-upload-reason>{reason}</p> : null}
+      {busy ? <p className="inline-flex items-center gap-1.5 text-xs text-muted-foreground" data-capture-upload-status role="status"><Loader2Icon aria-hidden="true" className="size-3.5 animate-spin" />{phase === "uploading" ? "Uploading the PDF…" : "Reading the text from the PDF…"}</p> : null}
+      {phase === "error" ? <p className="text-xs text-destructive" data-capture-upload-error role="alert">{message}</p> : null}
+      <div className="flex gap-2">
+        <button
+          aria-disabled={reason || busy ? true : undefined}
+          className={cn("inline-flex min-h-9 items-center gap-1.5 rounded-full bg-[var(--primary)] px-4 text-sm font-semibold text-[var(--primary-foreground)] outline-none focus-visible:ring-2 focus-visible:ring-ring", (reason || busy) && "opacity-60")}
+          data-capture-upload-choose
+          onClick={() => { if (!reason && !busy) input.current?.click(); }}
+          type="button"
+        >
+          <FileUpIcon aria-hidden="true" className="size-4" />Choose the PDF
+        </button>
+        <button className="inline-flex min-h-9 items-center rounded-full bg-[var(--feed-card)] px-4 text-sm font-medium outline-none focus-visible:ring-2 focus-visible:ring-ring" disabled={busy} onClick={onCancel} type="button">Cancel</button>
+      </div>
+    </div>
+  );
+}
+
+/** "Paste or correct the text": an editor's own text and verdict on the capture, saved with `correctReferenceCapture`. */
+function CorrectionForm({ capture, onDone }: { capture: CaptureView; onDone: () => void }) {
+  const [text, setText] = useState(capture.text ?? "");
+  const [assessment, setAssessment] = useState<CaptureAssessment | null>(null);
+  const [note, setNote] = useState("");
+  const [phase, setPhase] = useState<"idle" | "saving" | "error">("idle");
+  const [message, setMessage] = useState<string | null>(null);
+  useEffect(() => { setText((current) => current || capture.text || ""); }, [capture.text]);
+  const changedText = text.trim() !== (capture.text ?? "").trim() && text.trim().length > 0;
+  const reason = !assessment ? "Say whether the capture was complete, incomplete or incorrect to save." : null;
+  async function save() {
+    if (!assessment || !capture.correct) return;
+    setPhase("saving");
+    setMessage(null);
+    try {
+      await capture.correct({ ...(changedText ? { text: text.trim() } : {}), assessment, ...(note.trim() ? { note: note.trim() } : {}) });
+      onDone();
+    } catch (failure) {
+      setPhase("error");
+      setMessage(failure instanceof Error ? failure.message : "The correction could not be saved.");
+    }
+  }
+  return (
+    <div className="space-y-3 rounded-2xl bg-[var(--feed-control)] p-3" data-capture-correction>
+      <label className="block text-sm font-medium">
+        The text
+        <AutoGrowTextarea
+          aria-label="Captured text"
+          className="mt-1 block min-h-40 w-full rounded-2xl bg-[var(--feed-card)] p-3 text-sm font-normal"
+          data-capture-correction-text
+          onChange={(event) => setText(event.target.value)}
+          placeholder="Paste the whole article here, or fix what was captured."
+          value={text}
+        />
+      </label>
+      <AssessmentChoice onChange={setAssessment} value={assessment} />
+      <label className="block text-sm font-medium">
+        Note (optional)
+        <AutoGrowTextarea aria-label="Note about the capture (optional)" className="mt-1 block min-h-16 w-full rounded-2xl bg-[var(--feed-card)] p-3 text-sm font-normal" onChange={(event) => setNote(event.target.value)} value={note} />
+      </label>
+      {reason ? <p className="text-xs text-muted-foreground" data-capture-correction-reason>{reason}</p> : null}
+      {phase === "error" ? <p className="text-xs text-destructive" role="alert">{message}</p> : null}
+      <div className="flex gap-2">
+        <button
+          aria-disabled={reason ? true : undefined}
+          className={cn("inline-flex min-h-9 items-center gap-1.5 rounded-full bg-[var(--primary)] px-4 text-sm font-semibold text-[var(--primary-foreground)] outline-none focus-visible:ring-2 focus-visible:ring-ring", reason && "opacity-60")}
+          data-capture-correction-save
+          onClick={() => { if (!reason && phase !== "saving") void save(); }}
+          type="button"
+        >
+          {phase === "saving" ? <><Loader2Icon aria-hidden="true" className="size-4 animate-spin" />Saving…</> : changedText ? "Save the text and my verdict" : "Save my verdict"}
+        </button>
+        <button className="inline-flex min-h-9 items-center rounded-full bg-[var(--feed-card)] px-4 text-sm font-medium outline-none focus-visible:ring-2 focus-visible:ring-ring" onClick={onDone} type="button">Cancel</button>
+      </div>
+    </div>
+  );
+}
+
+/** Our captured record of a Reference: what we stored of its content, said plainly, above the live source preview. */
+export function ReferenceCapturePanel({ capture, showSummary = true, startEditing = false }: {
+  capture: CaptureView;
+  /** False where the summary is already shown above the rating, with the title. */
+  showSummary?: boolean;
+  startEditing?: boolean;
+}) {
+  const [expanded, setExpanded] = useState(false);
+  const [editing, setEditing] = useState(startEditing && Boolean(capture.correct));
+  const [uploading, setUploading] = useState(false);
+  const [savedNote, setSavedNote] = useState(false);
+  const line = captureLine(capture.status);
+  const Icon = ICON[line.state];
+  const text = capture.text ?? "";
+  const long = text.length > PREVIEW_CHARACTERS;
+  return (
+    <section aria-label="Our captured record" className="space-y-3" data-capture-panel={line.state}>
+      <h3 className="text-sm font-semibold text-foreground">Our captured record</h3>
+      <div className={cn("flex items-start gap-3 rounded-2xl p-3", TONE[line.state])} data-capture-status={line.state} data-capture-source={capture.status.source}>
+        <Icon aria-hidden="true" className="mt-0.5 size-5 shrink-0" />
+        <div className="min-w-0">
+          <p className="text-sm font-semibold" data-capture-label>{line.label}</p>
+          {line.state === "full" ? null : <p className="text-xs opacity-90" data-capture-detail>{line.detail}</p>}
+          {capture.status.words !== null ? <p className="text-xs font-medium" data-capture-words>{capture.status.estimated ? "about " : ""}{capture.status.words.toLocaleString("en-US")} words</p> : null}
+          {line.state === "full" && capture.status.flags?.length ? <p className="text-xs opacity-90" data-capture-flags>{capture.status.flags.join(" ")}</p> : null}
+          {capture.status.curation === "degraded" ? <p className="text-xs opacity-90" data-capture-curation-note>Curation finished all but one stage (usually the summary).</p> : null}
+          {capture.status.assessment ? <p className="text-xs font-medium" data-capture-assessment-note>An editor marked this capture {capture.status.assessment}.</p> : null}
+        </div>
+      </div>
+      {capture.loading ? <p className="inline-flex items-center gap-1.5 text-xs text-muted-foreground" role="status"><Loader2Icon aria-hidden="true" className="size-3.5 animate-spin" />Reading the stored text…</p> : null}
+      {capture.error ? <p className="text-xs text-destructive" role="alert">The stored text could not be read. {capture.error}</p> : null}
+      {/* While the editor is open it holds the text, so the read-only copy steps aside: the text is never shown twice. */}
+      {text && capture.fromPdf ? <p className="text-xs font-medium" data-capture-from-pdf>Text from a PDF you uploaded</p> : null}
+      {text && !editing ? (
+        <div className="space-y-2">
+          {/* No scroll box of its own: on a phone a swipe here scrolls the page. "Show all" grows it in place. */}
+          {/* Captured pages are stored as Markdown: render it (as React elements, never HTML) so headings and lists read as such. */}
+          <div className="rounded-2xl bg-[var(--feed-control)] p-3 text-sm leading-relaxed" data-capture-text>
+            <MarkdownContext className="reference-capture-markdown" text={expanded || !long ? text : `${text.slice(0, PREVIEW_CHARACTERS)}…`} />
+          </div>
+          {long ? (
+            <button className="rounded-full bg-[var(--feed-control)] px-3 py-1.5 text-xs font-medium outline-none focus-visible:ring-2 focus-visible:ring-ring" data-capture-toggle onClick={() => setExpanded((value) => !value)} type="button">
+              {expanded ? "Show less" : "Show all of the captured text"}
+            </button>
+          ) : null}
+        </div>
+      ) : null}
+      {showSummary && capture.summary ? (
+        <div className="space-y-1" data-capture-summary>
+          <h4 className="text-xs font-semibold uppercase tracking-wide text-muted-foreground">Summary{capture.summaryStale ? " (out of date: the text was replaced)" : ""}</h4>
+          <p className="text-sm">{capture.summary}</p>
+        </div>
+      ) : capture.summaryStale ? <p className="text-xs text-muted-foreground" data-capture-summary-stale>The summary will be rewritten from the new text on the next curation run.</p> : null}
+      {capture.rows.length ? (
+        <dl className="grid gap-2 rounded-2xl bg-[var(--feed-control)] p-3 text-sm" data-capture-structured>
+          {capture.rows.map((row) => (
+            <div key={`${row.label}:${row.value}`}>
+              <dt className="text-xs font-semibold uppercase tracking-wide text-muted-foreground">{row.label}</dt>
+              <dd className="mt-0.5">{row.value}</dd>
+            </div>
+          ))}
+        </dl>
+      ) : null}
+      {capture.correct || capture.uploadPdf ? (
+        editing && capture.correct ? <CorrectionForm capture={capture} onDone={() => { setEditing(false); setSavedNote(true); }} />
+          : uploading && capture.uploadPdf ? <PdfUploadForm capture={capture} onCancel={() => setUploading(false)} onDone={() => { setUploading(false); setSavedNote(true); }} />
+          : (
+            <div className="flex flex-wrap items-center gap-2">
+              {capture.correct ? (
+                <button className="inline-flex min-h-9 items-center rounded-full bg-[var(--feed-control)] px-4 text-sm font-medium outline-none focus-visible:ring-2 focus-visible:ring-ring" data-capture-correct onClick={() => { setSavedNote(false); setEditing(true); }} type="button">
+                  Paste or correct the text
+                </button>
+              ) : null}
+              {capture.uploadPdf ? (
+                <button className="inline-flex min-h-9 items-center gap-1.5 rounded-full bg-[var(--feed-control)] px-4 text-sm font-medium outline-none focus-visible:ring-2 focus-visible:ring-ring" data-capture-upload onClick={() => { setSavedNote(false); setUploading(true); }} type="button">
+                  <FileUpIcon aria-hidden="true" className="size-4" />Upload a PDF
+                </button>
+              ) : null}
+              {savedNote ? <span className="text-xs text-muted-foreground" data-capture-correction-saved role="status">Saved. Your verdict trains the completeness check.</span> : null}
+            </div>
+          )
+      ) : null}
+    </section>
+  );
+}

package/components/reference-conversation.tsx

@@ -0,0 +1,43 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { ConversationThread } from "./conversation-thread";
+import { useConversation } from "./use-conversation";
+
+/**
+ * The Messages about one Reference, under its review card. Shows nothing where no conversation store is provided.
+ * `onCount` tells the feed how many Messages there are, so its card count follows what is written here.
+ */
+export function ReferenceConversation({ disabledReason = null, lineageId, onCount, referenceId, title }: {
+  disabledReason?: string | null;
+  lineageId: string;
+  onCount?: (lineageId: string, count: number) => void;
+  /** The Reference version's id, when it differs from the lineage id. */
+  referenceId?: string;
+  title?: string;
+}) {
+  const conversation = useConversation({ kind: "reference", lineageId, title, ...(referenceId ? { id: referenceId } : {}) });
+  const [now, setNow] = useState(() => Date.now());
+  useEffect(() => {
+    const timer = window.setInterval(() => setNow(Date.now()), 60000);
+    return () => window.clearInterval(timer);
+  }, []);
+  const settled = conversation.messages.filter((message) => !message.pending).length;
+  useEffect(() => {
+    if (conversation.state === "ready") onCount?.(lineageId, settled);
+  }, [conversation.state, lineageId, onCount, settled]);
+  if (!conversation.available) return null;
+  return (
+    <div data-reference-conversation={lineageId}>
+      <ConversationThread
+        disabledReason={disabledReason}
+        error={conversation.error}
+        messages={conversation.messages}
+        now={now}
+        onPost={conversation.post}
+        onRetry={conversation.retry}
+        state={conversation.state}
+      />
+    </div>
+  );
+}