@anthusai/papyrus 5.44.0 → 5.46.0

package/components/references-page-loading.tsx

@@ -0,0 +1,61 @@
+"use client";
+
+import { useEffect, useMemo, useState } from "react";
+import { LoaderIcon } from "lucide-react";
+import { SITE_BRAND } from "../lib/site-brand";
+import { loadFeedSnapshot, type FeedSnapshot } from "../lib/reference-feed-cache";
+import { partitionReferenceFeed, type ReferenceFeedTabKey } from "../lib/reference-feed-ranking";
+import { selectCanonicalReferenceRecords } from "../lib/newsroom-references";
+import { ReferenceFeed, ReferenceFeedSkeleton } from "./reference-feed";
+
+/**
+ * What the References page shows while the session and the first reads are still resolving: the real page header at once,
+ * then this browser's last saved view (read only, answering switches on when the session is confirmed), or card skeletons
+ * when there is none. Never a full-screen "checking" screen.
+ */
+export function ReferencesPageLoading() {
+  const [snapshot, setSnapshot] = useState<FeedSnapshot | null>(null);
+  const [checked, setChecked] = useState(false);
+  const [tab, setTab] = useState<ReferenceFeedTabKey>("feed");
+  const [note, setNote] = useState<string | null>(null);
+  const [now] = useState(() => Date.now());
+  useEffect(() => {
+    setSnapshot(loadFeedSnapshot(SITE_BRAND.id));
+    setChecked(true);
+  }, []);
+  const references = useMemo(() => selectCanonicalReferenceRecords(snapshot?.references ?? []), [snapshot]);
+  const decisions = useMemo(() => new Map(snapshot?.decisions ?? []), [snapshot]);
+  const previews = useMemo(() => new Map(snapshot?.previews ?? []), [snapshot]);
+  const partition = useMemo(() => partitionReferenceFeed(references, decisions, { now }), [references, decisions, now]);
+  const noVisitRated = useMemo(() => new Set<string>(), []);
+
+  return (
+    <div className="space-y-4" data-references-page-loading>
+      <div className="space-y-1">
+        <h2 className="text-2xl font-bold tracking-tight">References</h2>
+        <p className="text-sm text-muted-foreground">A feed ranked by what you are most likely to accept.</p>
+      </div>
+      {note ? <p className="text-sm text-muted-foreground" role="status">{note}</p> : null}
+      {checked && references.length ? (
+        <ReferenceFeed
+          disabledReason="Confirming your sign-in. You can answer in a moment."
+          now={now}
+          onOpen={() => setNote("Opening a reference is available in a moment, once your sign-in is confirmed.")}
+          onRate={() => undefined}
+          onTabChange={setTab}
+          onVisitRated={() => undefined}
+          partition={partition}
+          previews={previews}
+          stale
+          tab={tab}
+          visitRated={noVisitRated}
+        />
+      ) : (
+        <>
+          <p className="inline-flex items-center gap-1.5 text-xs text-muted-foreground" role="status"><LoaderIcon aria-hidden="true" className="size-3.5 animate-spin" />Loading your references</p>
+          <ReferenceFeedSkeleton />
+        </>
+      )}
+    </div>
+  );
+}

package/components/references-prefetch.ts

@@ -0,0 +1,52 @@
+/**
+ * Starts the References reads as soon as the editor session is confirmed, in parallel with the summary dashboard, instead of after it.
+ * The page that needs them takes the in-flight request once; anything later, or a retry, makes a fresh read. This is a head start
+ * on the same reads, not a cache: the backend authorizes each call exactly as before.
+ */
+import {
+  loadEditorMessagesData,
+  loadEditorReferencesData,
+  loadEditorSemanticRelationsData,
+} from "./news-desk-taxonomy-client";
+
+const HEAD_START_MS = 60_000;
+type Started = { startedAt: number; promise: Promise<unknown> };
+const started = new Map<string, Started>();
+
+const LOADERS = {
+  references: loadEditorReferencesData,
+  relations: loadEditorSemanticRelationsData,
+  messages: loadEditorMessagesData,
+} as const;
+type Key = keyof typeof LOADERS;
+
+/** Begin all three reads. Safe to call twice; a failure is reported to whoever takes the read, never as an unhandled rejection. */
+export function prefetchReferencesFeed(now = Date.now()) {
+  for (const key of Object.keys(LOADERS) as Key[]) {
+    if (started.has(key)) continue;
+    const promise = LOADERS[key]();
+    promise.catch(() => undefined);
+    started.set(key, { startedAt: now, promise });
+  }
+}
+
+function take<Key2 extends Key>(key: Key2, now = Date.now()): ReturnType<(typeof LOADERS)[Key2]> {
+  const head = started.get(key);
+  started.delete(key);
+  if (head && now - head.startedAt <= HEAD_START_MS) return head.promise as ReturnType<(typeof LOADERS)[Key2]>;
+  return LOADERS[key]() as ReturnType<(typeof LOADERS)[Key2]>;
+}
+
+export const loadReferencesWithHeadStart = () => take("references");
+export const loadRelationsWithHeadStart = () => take("relations");
+export const loadMessagesWithHeadStart = () => take("messages");
+
+/** Forget any unclaimed head start (sign-out). */
+export function discardReferencesHeadStart() {
+  started.clear();
+}
+
+/** The pages that need the References straight away: the feed itself and the home page, whose Notification Center shows References cards. */
+export function wantsReferencesHeadStart(pathname: string): boolean {
+  return /\/newsroom\/references(\/|$)/.test(pathname) || /\/newsroom\/?$/.test(pathname);
+}

package/components/review-rating-grid.tsx

@@ -0,0 +1,177 @@
+"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.
+ */
+
+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",
+  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";
+  /** 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(
+        "grid gap-x-2 gap-y-2.5",
+        showPrediction ? "grid-cols-[4.5rem_minmax(0,1fr)_minmax(0,1fr)]" : "grid-cols-2",
+        showPrediction && size === "large" && "grid-cols-[5rem_minmax(0,1fr)_minmax(0,1fr)]",
+      )}
+      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 flex-col items-center justify-center rounded-[16px] px-2 py-1.5 text-center",
+                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}
+            >
+              <span className="inline-flex items-center gap-1.5">
+                {Icon ? <Icon aria-hidden="true" className="size-4 shrink-0" /> : null}
+                {WORD[choice]}
+                {predicted && confidenceText ? <small className="text-xs font-normal opacity-80">{confidenceText}</small> : null}
+              </span>
+              {predicted && verdict ? <small className="text-xs font-medium" data-verdict-word>{verdict === "match" ? "Match" : "Miss"}</small> : null}
+              {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 gap-1" 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>
+          {/* The line is always there, so a prediction arriving later never changes the card's height. */}
+          <small className="min-h-4 text-center text-xs text-muted-foreground" data-cyclotron-state={prediction.state === "ready" ? undefined : prediction.state}>
+            {prediction.state === "ready" ? "\u00a0" : 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 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",
+                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 min-h-5 flex-wrap items-center gap-x-3 text-xs text-muted-foreground", 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>
+  );
+}

package/components/topic-steering-workspace.tsx

@@ -94,6 +94,10 @@ import { useOptionalNewsDeskClient } from "./news-desk-client-provider";
 import { ReferenceSourcePreview } from "./reference-source-preview";
 import type { ReaderAuthSnapshot } from "./reader-auth-state";
 import { NewsDeskAccessGate } from "./newsroom-access-gate";
+import { correctReferenceCapture } from "../lib/content-actions-client";
+import { loadMessagesWithHeadStart, loadReferencesWithHeadStart, loadRelationsWithHeadStart } from "./references-prefetch";
+import { loadFeedSnapshot, saveFeedSnapshot, type FeedSnapshot } from "../lib/reference-feed-cache";
+import { referencePreviewsByLineage } from "../lib/reference-preview";
 import { NewsroomOpsOverview } from "./newsroom-ops-overview";
 import { NewsroomCurationBootstrap } from "./newsroom-curation-bootstrap";
 import { NewsroomReferencesView } from "./newsroom-references-view";
@@ -696,7 +700,7 @@ export function NewsDeskWorkspace({
   }
 
   if (dashboard?.isPublicSkeleton && session?.shell.phase !== "ready") {
-    return <NewsDeskAccessGate shell={session?.shell ?? null} showSectionTabs={showSectionTabs} />;
+    return <NewsDeskAccessGate initialTab={initialTab} shell={session?.shell ?? null} showSectionTabs={showSectionTabs} />;
   }
 
   if (dashboard) {
@@ -716,7 +720,7 @@ export function NewsDeskWorkspace({
     );
   }
 
-  return <NewsDeskAccessGate shell={session?.shell ?? null} showSectionTabs={showSectionTabs} />;
+  return <NewsDeskAccessGate initialTab={initialTab} shell={session?.shell ?? null} showSectionTabs={showSectionTabs} />;
 }
 
 function NewsDeskDashboard({
@@ -777,9 +781,16 @@ function NewsDeskDashboard({
   const [referenceAttachments, setReferenceAttachments] = useState(dashboard.referenceAttachments);
   const [messages, setMessages] = useState(dashboard.messages);
   const [semanticRelations, setSemanticRelations] = useState(dashboard.semanticRelations);
+  const [savedFeedCopy, setSavedFeedCopy] = useState<Pick<FeedSnapshot, "references" | "previews" | "decisions"> | null>(null);
+  useEffect(() => {
+    // Display only: the last view this browser saved, shown until the live read arrives.
+    if (dashboard.isDemo) return;
+    const snapshot = loadFeedSnapshot(SITE_BRAND.id);
+    if (snapshot) setSavedFeedCopy(snapshot);
+  }, [dashboard.isDemo]);
   const cyclotronPreviewFixtures = useMemo(
-    () => (isLocalPreviewEnabled() ? createLocalPreviewCyclotronFixtures(references) : null),
-    [references],
+    () => (isLocalPreviewEnabled() && !semanticRelations.some((relation) => relation.predicate === "relevance_decision_is") ? createLocalPreviewCyclotronFixtures(references) : null),
+    [references, semanticRelations],
   );
   const relevanceDecisions = useMemo(
     () => currentRelevanceDecisions(cyclotronPreviewFixtures ? [...semanticRelations, ...cyclotronPreviewFixtures.relations] : semanticRelations),
@@ -1215,7 +1226,7 @@ function NewsDeskDashboard({
   useEffect(() => {
     if (!canLoadPrivateCorpus || hasHydratedReferences) return;
     let active = true;
-    void loadEditorReferencesData()
+    void loadReferencesWithHeadStart()
       .then(({ references: nextReferences, referenceAttachments }) => {
         if (!active) return;
         setReferences(nextReferences);
@@ -1322,12 +1333,12 @@ function NewsDeskDashboard({
     refreshNewsroomSections,
   ]);
 
-  const needsReferenceReviewData = activeTab === "references" || activeTab === "assignments" || activeTab === "messages";
+  const needsReferenceReviewData = activeTab === "overview" || activeTab === "references" || activeTab === "assignments" || activeTab === "messages";
   const selectedReviewLineageId = pathname ? pathnameReferenceLineageId ?? "" : initialSelection.reference ?? "";
   const referenceReviewData = useReferenceReviewData({
     enabled: canLoadPrivateCorpus && needsReferenceReviewData && !(activeTab === "references" && selectedReviewLineageId),
-    loadRelations: loadEditorSemanticRelationsData,
-    loadMessages: loadEditorMessagesData,
+    loadRelations: loadRelationsWithHeadStart,
+    loadMessages: loadMessagesWithHeadStart,
     onRelations: setSemanticRelations,
     onMessages: setMessages,
   });
@@ -1351,6 +1362,18 @@ function NewsDeskDashboard({
     ? selectedReviewRead.lineageId === selectedReviewLineageId ? selectedReviewRead.state : "loading"
     : referenceReviewData.state;
   const predictionError = selectedReviewIsCurrent ? selectedReviewRead.error : referenceReviewData.error;
+  useEffect(() => {
+    // Keep a display copy for the next visit once everything the feed shows has been read.
+    if (dashboard.isDemo || (activeTab !== "references" && activeTab !== "overview") || !hasHydratedReferences || predictionState !== "ready" || !references.length) return;
+    const timer = window.setTimeout(() => {
+      saveFeedSnapshot(SITE_BRAND.id, {
+        references: selectCanonicalReferenceRecords(references),
+        previews: referencePreviewsByLineage(referenceAttachments),
+        decisions: relevanceDecisions,
+      });
+    }, 800);
+    return () => window.clearTimeout(timer);
+  }, [activeTab, dashboard.isDemo, hasHydratedReferences, predictionState, referenceAttachments, references, relevanceDecisions]);
   const retryReferenceReviewData = () => { referenceReviewData.retry(); setSelectedReviewAttempt((current) => current + 1); };
 
   const applyReferenceRecord = useCallback((nextReference: ReferenceRecord) => {
@@ -3035,7 +3058,7 @@ function NewsDeskDashboard({
         headerActions={(
           <>
             {dashboard.isDemo ? (
-              <Badge variant="outline">Demo</Badge>
+              dashboard.realDataPreview ? null : <Badge variant="outline">Demo</Badge>
             ) : (
               <Link className={cn(buttonVariants({ variant: "ghost", size: "sm" }))} href="/settings">Settings</Link>
             )}
@@ -3081,9 +3104,17 @@ function NewsDeskDashboard({
             assignments={assignments}
             decisions={relevanceDecisions}
             demo={Boolean(dashboard.isDemo)}
+            disabledReason={controlsDisabled ? "Editor access is required to change this reference." : null}
             humanCuratedReferenceLineageIds={humanCuratedReferenceLineageIds}
+            loading={!dashboard.isDemo && !hasHydratedReferences}
             newsroomSections={newsroomSections}
+            notificationFixture={dashboard.notificationFixture ?? null}
+            onReview={(reference, action, options) => runReferenceCurationAction(reference, action, undefined, options?.reasonCode,
+              options?.decisionRelationId ? { decisionRelationId: options.decisionRelationId, shareable: options.shareable === true } : undefined)}
+            predictionState={referenceReviewData.state}
+            referenceAttachments={referenceAttachments}
             references={references}
+            savedCopy={savedFeedCopy}
           />
         ) : null}
         {activeTab === "search" ? (
@@ -3182,6 +3213,9 @@ function NewsDeskDashboard({
               options?.sectionId)}
             referenceAttachments={referenceAttachments}
             references={references}
+            loading={!dashboard.isDemo && !hasHydratedReferences}
+            onCorrectCapture={dashboard.isDemo ? undefined : (input) => correctReferenceCapture(input)}
+            savedCopy={savedFeedCopy}
           />
           </NewsroomCurationBootstrap>
         ) : null}

package/components/use-reference-ratings.ts

@@ -0,0 +1,132 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import type { ReferenceRejectionReasonCode } from "../lib/reference-policy";
+import type { ReviewChoice } from "./reference-review-card";
+import type { RatingFeedback } from "./review-rating-grid";
+
+/** How long after the last keystroke a typed reason is saved on its own. */
+export const NOTE_AUTOSAVE_MS = 1200;
+
+export type ItemRating = {
+  /** The reason as typed, else as saved. In the store itself it stays undefined until touched, so an untouched field follows the record. */
+  note?: string;
+  reasonCode?: ReferenceRejectionReasonCode | null;
+  /** A vote that is waiting for a reason (Reject needs one) or is still saving. */
+  pending: ReviewChoice | null;
+  /** True while a Reject is waiting for its reason. */
+  askReason: boolean;
+  feedback: RatingFeedback;
+};
+
+const EMPTY: ItemRating = { pending: null, askReason: false, feedback: { phase: "idle" } };
+
+export type RatingSave = (id: string, choice: ReviewChoice, detail: { note: string; reasonCode: ReferenceRejectionReasonCode | null }) => Promise<void> | void;
+
+export type RatingController = {
+  get: (id: string) => ItemRating;
+  choose: (id: string, choice: ReviewChoice) => void;
+  setReason: (id: string, code: ReferenceRejectionReasonCode) => void;
+  setNote: (id: string, text: string) => void;
+  /** Save a typed reason now (on blur). */
+  commitNote: (id: string) => void;
+  cancelReason: (id: string) => void;
+};
+
+/**
+ * One store for the rating state of every item, shared by the grid card and the detail pane so a vote or a reason typed in either
+ * shows in both at once. `saved(id)` is the saved human answer; `seed(id)` the saved note and reason code.
+ *   vote, then reason  -> the reason is saved onto the existing decision (on blur, or after a short pause)
+ *   reason, then vote  -> the vote carries the reason
+ * A Reject needs a reason code (the backend refuses one without), so it waits as `pending` until one is chosen; a typed reason is
+ * kept in the store until it is saved and is never dropped by a failed save.
+ */
+export function useRatingStore({ save, saved, seed }: {
+  save: RatingSave;
+  saved: (id: string) => ReviewChoice | null;
+  seed: (id: string) => { note: string; reasonCode: ReferenceRejectionReasonCode | null };
+}): RatingController {
+  const [items, setItems] = useState<Record<string, ItemRating>>({});
+  const itemsRef = useRef(items);
+  const latest = useRef({ save, saved, seed });
+  latest.current = { save, saved, seed };
+  const timers = useRef<Record<string, ReturnType<typeof setTimeout>>>({});
+  const inFlight = useRef<Set<string>>(new Set());
+  const dirty = useRef<Set<string>>(new Set());
+
+  const patch = useCallback((id: string, change: Partial<ItemRating>) => {
+    const next = { ...itemsRef.current, [id]: { ...(itemsRef.current[id] ?? EMPTY), ...change } };
+    itemsRef.current = next;
+    setItems(next);
+  }, []);
+
+  // What a reader of the store sees: the touched value, else what is saved. (A saved reason therefore shows on the card too.)
+  const get = useCallback((id: string): ItemRating => {
+    const item = items[id] ?? EMPTY;
+    const seeded = latest.current.seed(id);
+    return { ...item, note: item.note ?? seeded.note, reasonCode: item.reasonCode !== undefined ? item.reasonCode : seeded.reasonCode };
+  }, [items]);
+
+  const values = (id: string) => {
+    const item = itemsRef.current[id] ?? EMPTY;
+    const seeded = latest.current.seed(id);
+    return { note: item.note ?? seeded.note, reasonCode: item.reasonCode !== undefined ? item.reasonCode : seeded.reasonCode };
+  };
+
+  const commit = useCallback(async (id: string, choice: ReviewChoice) => {
+    const { note, reasonCode } = values(id);
+    if (choice === "reject" && !reasonCode) { patch(id, { pending: "reject", askReason: true }); return; }
+    if (inFlight.current.has(id)) { dirty.current.add(id); return; }
+    inFlight.current.add(id);
+    dirty.current.delete(id);
+    const started = itemsRef.current[id] ?? EMPTY;
+    patch(id, { pending: choice, askReason: false, feedback: { phase: "saving" } });
+    try {
+      await latest.current.save(id, choice, { note: note.trim(), reasonCode: choice === "reject" ? reasonCode : null });
+      // What was saved now follows the record again (another editor's update shows); anything typed meanwhile is kept.
+      const now = itemsRef.current[id] ?? EMPTY;
+      patch(id, { pending: null, feedback: { phase: "saved" }, ...(now.note === started.note ? { note: undefined } : {}), ...(now.reasonCode === started.reasonCode ? { reasonCode: undefined } : {}) });
+    } catch (failure) {
+      // The typed reason stays in the store; only the vote is undone.
+      patch(id, { pending: null, feedback: { phase: "error", message: failure instanceof Error ? failure.message : "Your answer could not be saved. Tap it again to retry." } });
+    } finally {
+      inFlight.current.delete(id);
+    }
+    if (dirty.current.has(id)) { dirty.current.delete(id); const again = itemsRef.current[id]?.pending ?? latest.current.saved(id); if (again) void commit(id, again); }
+  }, [patch]);
+
+  const effective = (id: string): ReviewChoice | null => itemsRef.current[id]?.pending ?? latest.current.saved(id);
+
+  const choose = useCallback((id: string, choice: ReviewChoice) => {
+    if (effective(id) === choice && !itemsRef.current[id]?.askReason) return; // the chosen answer never unselects itself
+    void commit(id, choice);
+  }, [commit]);
+
+  const setReason = useCallback((id: string, code: ReferenceRejectionReasonCode) => {
+    patch(id, { reasonCode: code });
+    // Vote then reason: onto the existing (or waiting) decision. Reason then vote: stored, and the vote carries it.
+    if (effective(id) === "reject") void commit(id, "reject");
+  }, [commit, patch]);
+
+  const setNote = useCallback((id: string, text: string) => {
+    patch(id, { note: text, feedback: { phase: "idle" } });
+    dirty.current.add(`note:${id}`);
+    clearTimeout(timers.current[id]);
+    timers.current[id] = setTimeout(() => {
+      const choice = effective(id);
+      if (choice && dirty.current.delete(`note:${id}`)) void commit(id, choice);
+    }, NOTE_AUTOSAVE_MS);
+  }, [commit, patch]);
+
+  const commitNote = useCallback((id: string) => {
+    clearTimeout(timers.current[id]);
+    const choice = effective(id);
+    if (choice && dirty.current.delete(`note:${id}`)) void commit(id, choice);
+  }, [commit]);
+
+  const cancelReason = useCallback((id: string) => patch(id, { pending: null, askReason: false }), [patch]);
+
+  useEffect(() => () => { for (const timer of Object.values(timers.current)) clearTimeout(timer); }, []);
+
+  return { get, choose, setReason, setNote, commitNote, cancelReason };
+}

package/lib/category-repository.ts

@@ -656,6 +656,10 @@ export type NewsroomSummaryFacets = {
 
 export type CategorySteeringDashboard = {
   isDemo?: boolean;
+  /** Local preview only: the demo newsroom is showing a real export (scripts/export-reference-feed-fixture.py), so it must not say "synthetic". */
+  realDataPreview?: boolean;
+  /** Local preview only: review requests and their drafts from scripts/export-notification-center-fixture.py. */
+  notificationFixture?: { requests: import("./review-requests").ReviewRequest[]; drafts: import("./review-drafts").DraftRow[] } | null;
   isPublicSkeleton?: boolean;
   summaryStatus?: "loading" | "missing" | "ready";
   summary?: NewsroomSummaryRecord | null;
@@ -820,7 +824,8 @@ function sortCategorys(categorys: CategorySteeringCategory[]): CategorySteeringC
 }
 
 function defaultNewsroomSections(importedAt: string, sectionsConfigPath?: string): NewsroomSectionRecord[] {
-  if (!sectionsConfigPath) return [];
+  // A data-driven site names a seed file it does not ship: its Sections live in the backend, so there is nothing to seed.
+  if (!sectionsConfigPath || !fs.existsSync(sectionsConfigPath)) return [];
   return loadNewsroomSectionSeedRows(sectionsConfigPath).map((row, index) => ({
     ...row,
     enabledStatus: "enabled",

package/lib/content-actions-client.ts

@@ -30,6 +30,18 @@ export type SaveItemDraftResult = { ok: true; item: SavedItemSummary };
 export type PublishItemResult = { ok: true; changed: boolean; publishedId: string; versionNumber: number | null };
 export type UnpublishItemResult = { ok: true; changed: boolean };
 
+export type CaptureAssessment = "complete" | "incomplete" | "incorrect";
+export type CorrectReferenceCaptureInput = {
+  referenceId: string;
+  /** The full corrected or pasted text. */
+  text?: string;
+  grobid?: Record<string, unknown>;
+  /** Required with text; alone it is just a label on the capture. */
+  assessment?: CaptureAssessment;
+  note?: string;
+};
+export type CorrectReferenceCaptureResult = { ok: true; referenceId: string; status: string; edits: unknown[]; label: unknown; summaryStale: boolean };
+
 export class ContentActionFailure extends Error {
   readonly errors: ContentActionError[];
 
@@ -48,6 +60,7 @@ export type ContentActionsTransport = {
     saveItemDraft: (args: { input: string }, options: { authMode: "userPool" }) => Promise<GraphqlEnvelope>;
     publishItem: (args: { input: string }, options: { authMode: "userPool" }) => Promise<GraphqlEnvelope>;
     unpublishItem: (args: { input: string }, options: { authMode: "userPool" }) => Promise<GraphqlEnvelope>;
+    correctReferenceCapture: (args: { input: string }, options: { authMode: "userPool" }) => Promise<GraphqlEnvelope>;
   };
 };
 
@@ -80,6 +93,9 @@ export function createContentActionsClient(transport: ContentActionsTransport) {
     async publishItem(id: string): Promise<PublishItemResult> {
       return parseActionResponse(await transport.mutations.publishItem({ input: JSON.stringify({ id }) }, USER_POOL));
     },
+    async correctReferenceCapture(input: CorrectReferenceCaptureInput): Promise<CorrectReferenceCaptureResult> {
+      return parseActionResponse(await transport.mutations.correctReferenceCapture({ input: JSON.stringify(input) }, USER_POOL));
+    },
     async unpublishItem(id: string): Promise<UnpublishItemResult> {
       return parseActionResponse(await transport.mutations.unpublishItem({ input: JSON.stringify({ id }) }, USER_POOL));
     },
@@ -99,3 +115,5 @@ export const deriveMarkus = (input: DeriveMarkusInput) => contentActionsClient()
 export const saveItemDraft = (input: SaveItemDraftInput) => contentActionsClient().saveItemDraft(input);
 export const publishItem = (id: string) => contentActionsClient().publishItem(id);
 export const unpublishItem = (id: string) => contentActionsClient().unpublishItem(id);
+
+export const correctReferenceCapture = (input: CorrectReferenceCaptureInput) => contentActionsClient().correctReferenceCapture(input);