@anthusai/papyrus 5.44.0 → 5.45.0

package/components/review-rating-grid.tsx

@@ -0,0 +1,164 @@
+"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" },
+  onChoose,
+  prediction,
+  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;
+  onChoose: (choice: ReviewChoice) => void;
+  prediction: CardPrediction;
+  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 grid-cols-[4.5rem_minmax(0,1fr)_minmax(0,1fr)] gap-x-2 gap-y-2.5", size === "large" && "grid-cols-[5rem_minmax(0,1fr)_minmax(0,1fr)]")} data-rating-grid>
+      <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>
+          {prediction.state === "ready" ? null : (
+            <small className="text-center text-xs text-muted-foreground" data-cyclotron-state={prediction.state}>
+              {prediction.state === "loading" ? "Loading…" : prediction.state === "error" ? "Prediction unavailable" : "No prediction"}
+            </small>
+          )}
+        </div>
+      </div>
+
+      <div className="col-span-3 grid grid-cols-subgrid items-stretch" data-review-row="you">
+        <span className={cn("self-center font-semibold", label)}>You</span>
+        {(["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 && "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="col-span-3 min-h-5 text-xs text-muted-foreground" data-feed-saved role="status">
+        {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="col-span-3 text-xs text-muted-foreground" data-review-disabled-reason>{disabledReason}</p> : null}
+      {feedback.phase === "error" ? <p className="col-span-3 text-xs text-destructive" role="alert">{feedback.message}</p> : null}
+    </div>
+  );
+}

package/components/topic-steering-workspace.tsx

@@ -94,6 +94,9 @@ 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 { 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 +699,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 +719,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 +780,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 +1225,7 @@ function NewsDeskDashboard({
   useEffect(() => {
     if (!canLoadPrivateCorpus || hasHydratedReferences) return;
     let active = true;
-    void loadEditorReferencesData()
+    void loadReferencesWithHeadStart()
       .then(({ references: nextReferences, referenceAttachments }) => {
         if (!active) return;
         setReferences(nextReferences);
@@ -1326,8 +1336,8 @@ function NewsDeskDashboard({
   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 +1361,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" || !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 +3057,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>
             )}
@@ -3182,6 +3204,8 @@ function NewsDeskDashboard({
               options?.sectionId)}
             referenceAttachments={referenceAttachments}
             references={references}
+            loading={!dashboard.isDemo && !hasHydratedReferences}
+            savedCopy={savedFeedCopy}
           />
           </NewsroomCurationBootstrap>
         ) : null}

package/lib/category-repository.ts

@@ -656,6 +656,8 @@ 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;
   isPublicSkeleton?: boolean;
   summaryStatus?: "loading" | "missing" | "ready";
   summary?: NewsroomSummaryRecord | null;
@@ -820,7 +822,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/local-preview-feed-fixture.ts

@@ -0,0 +1,43 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { CategorySteeringDashboard, ReferenceAttachmentRecord, ReferenceRecord, SemanticRelationRecord } from "./category-repository";
+
+/**
+ * Local preview only (server side): when PAPYRUS_FEED_FIXTURE names a JSON file written by
+ * scripts/export-reference-feed-fixture.py, the demo newsroom shows those References, their previews and the Cyclotron's
+ * decisions instead of the invented sample. Without the variable, or without the file, nothing changes.
+ */
+export type ReferenceFeedFixture = {
+  references: ReferenceRecord[];
+  referenceAttachments: ReferenceAttachmentRecord[];
+  semanticRelations: SemanticRelationRecord[];
+};
+
+export function loadReferenceFeedFixture(env: NodeJS.ProcessEnv = process.env): ReferenceFeedFixture | null {
+  const configured = env.PAPYRUS_FEED_FIXTURE?.trim();
+  if (!configured || env.NEXT_PUBLIC_PAPYRUS_LOCAL_PREVIEW !== "1") return null;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(path.resolve(process.cwd(), configured), "utf8"));
+    if (parsed?.schema !== "papyrus-reference-feed-fixture/1" || !Array.isArray(parsed.references)) return null;
+    return {
+      references: parsed.references,
+      referenceAttachments: Array.isArray(parsed.referenceAttachments) ? parsed.referenceAttachments : [],
+      semanticRelations: Array.isArray(parsed.semanticRelations) ? parsed.semanticRelations : [],
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function withReferenceFeedFixture(dashboard: CategorySteeringDashboard): CategorySteeringDashboard {
+  const fixture = loadReferenceFeedFixture();
+  if (!fixture) return dashboard;
+  return {
+    ...dashboard,
+    references: fixture.references,
+    referenceAttachments: fixture.referenceAttachments,
+    semanticRelations: fixture.semanticRelations,
+    messages: [],
+    realDataPreview: true,
+  };
+}

package/lib/local-preview-synthetic-rejects.ts

@@ -0,0 +1,41 @@
+import type { RelevanceDecisionView } from "./relevance-decisions";
+
+/** Strong Reject confidences, strongest first, for the preview's made-up predictions. */
+const SYNTHETIC_REJECT_CONFIDENCE = [0.95, 0.91, 0.87, 0.83, 0.79, 0.75, 0.71, 0.67];
+
+/**
+ * Local preview only. A young corpus can have no Reject predictions at all, so the Reject end of the feed cannot be reviewed on real
+ * data. `?feedSynthRejects=N` turns the N weakest Accept predictions of pending items into made-up Rejects, and the page says so
+ * in a banner. Never reachable outside local preview.
+ */
+export function chooseSyntheticRejects(
+  decisions: ReadonlyMap<string, RelevanceDecisionView> | undefined,
+  pendingLineageIds: ReadonlySet<string>,
+  count: number,
+): string[] {
+  return [...(decisions ?? new Map()).entries()]
+    .filter(([lineageId, decision]) => pendingLineageIds.has(lineageId) && decision.label === (decision.positiveLabel ?? "include"))
+    .sort((left, right) => (left[1].confidence ?? 0) - (right[1].confidence ?? 0))
+    .slice(0, Math.max(0, Math.min(count, SYNTHETIC_REJECT_CONFIDENCE.length)))
+    .map(([lineageId]) => lineageId);
+}
+
+/** Applies the chosen ids, weakest first getting the lowest of the made-up confidences. The choice is made once, so rating a card never moves it. */
+export function withSyntheticRejects(
+  decisions: ReadonlyMap<string, RelevanceDecisionView> | undefined,
+  chosen: readonly string[],
+): { decisions: Map<string, RelevanceDecisionView>; changed: number } {
+  const result = new Map(decisions ?? []);
+  let changed = 0;
+  chosen.forEach((lineageId, index) => {
+    const decision = result.get(lineageId);
+    if (!decision) return;
+    result.set(lineageId, {
+      ...decision,
+      label: decision.classes.find((label) => label !== (decision.positiveLabel ?? "include")) ?? "exclude",
+      confidence: SYNTHETIC_REJECT_CONFIDENCE[index],
+    });
+    changed += 1;
+  });
+  return { decisions: result, changed };
+}

package/lib/monitoring-client.ts

@@ -4,6 +4,8 @@ import { generateClient } from "aws-amplify/data";
 import { emailReferenceBatches } from "./monitoring-overview";
 import type {
   EmailDecisionResult,
+  MonitoringListName,
+  MonitoringPage,
   EmailReferenceImportItem,
   EmailReferenceImportOutcome,
   MonitoringEmailArticleResolution,
@@ -11,10 +13,10 @@ import type {
   MonitoringResult,
 } from "./monitoring-overview";
 
-type QueryField = "monitoringOverview" | "monitoringEmailSubmission" | "monitoringDecideEmailSubmission" | "monitoringResolveEmailArticleLink" | "intakeEmailSubmissionReferences" | "monitoringQueueEmailReference";
+type QueryField = "monitoringOverview" | "monitoringPage" | "monitoringEmailSubmission" | "monitoringDecideEmailSubmission" | "monitoringResolveEmailArticleLink" | "intakeEmailSubmissionReferences" | "monitoringQueueEmailReference";
 type GraphQLResult = { data?: Partial<Record<QueryField, unknown>>; errors?: { message?: string; errorType?: string }[] };
 
-async function query<T>(field: QueryField, queryText: string, variables: Record<string, string | number>): Promise<T | { error: "forbidden" } | { state: "unavailable" }> {
+async function query<T>(field: QueryField, queryText: string, variables: Record<string, string | number | null>): Promise<T | { error: "forbidden" } | { state: "unavailable" }> {
   const client = generateClient({ authMode: "userPool" });
   let result: GraphQLResult;
   try {
@@ -35,6 +37,18 @@ export async function loadMonitoringOverview(scope: "publication" | "all"): Prom
     `query MonitoringOverview($scope: String) { monitoringOverview(scope: $scope) }`, { scope });
 }
 
+/**
+ * One more page of one list after `cursor` (null starts the list from its newest row). `heldOnly` lists only held
+ * email submissions, so a held message is findable however old it is.
+ */
+export async function loadMonitoringPage(
+  list: MonitoringListName, cursor: string | null, scope: "publication" | "all", heldOnly = false,
+): Promise<MonitoringPage> {
+  return query<MonitoringPage>("monitoringPage",
+    `query MonitoringPage($list: String!, $cursor: String, $filter: String, $scope: String) { monitoringPage(list: $list, cursor: $cursor, filter: $filter, scope: $scope) }`,
+    { list, cursor, filter: heldOnly ? "held" : null, scope });
+}
+
 /** Loads one receipt's safe plain-text rendering and its already extracted candidate links. */
 export async function loadMonitoringEmailSubmission(receiptId: string): Promise<MonitoringEmailDetails> {
   return query<MonitoringEmailDetails>("monitoringEmailSubmission",

package/lib/monitoring-overview.ts

@@ -38,6 +38,12 @@ export type MonitoringEmailSummary = {
   envelopeSender: string | null; headerFrom: string | null; warnings: string[];
   verdicts: Record<string, string>; linkCount: number; processedCount: number; unresolvedLinkCount: number;
   reviewRequired: boolean; errorCode: string | null; quarantine: EmailQuarantine | null;
+  /** Present when the same email was received more than once: one item, every copy listed. One decision covers all copies. */
+  group?: EmailCopyGroup;
+};
+export type EmailCopyGroup = {
+  fingerprint: string; count: number;
+  copies: { receiptId: string; observedAt: string | null; status: string; linkCount: number; processedCount: number; quarantine: EmailQuarantine | null }[];
 };
 
 /** Where a held email submission stands. `null` means it never needed review. */
@@ -46,7 +52,7 @@ export type EmailQuarantineState =
   | "expired" | "decision_failed" | "release_failed";
 export type EmailQuarantine = {
   state: EmailQuarantineState;
-  decision: { action: "accept" | "reject"; by: string; at: string | null; reason: string } | null;
+  decision: { action: "accept" | "reject"; by: string; at: string | null; reason: string; viaGroup?: boolean } | null;
   failure: string | null;
 };
 export type EmailDecisionResult =
@@ -144,6 +150,17 @@ export type MonitoringFeed = {
   nextDueAt: string | null;
 };
 
+/** The lists on the page that are paged. Page sizes are the server's; there is no total. */
+export type MonitoringListName = "runs" | "routerRuns" | "items" | "emailSubmissions";
+export type MonitoringCursors = Partial<Record<MonitoringListName, string | null>>;
+export type MonitoringListRows = {
+  runs: MonitoringRun; routerRuns: MonitoringRouterRun; items: MonitoringItem; emailSubmissions: MonitoringEmailSummary;
+};
+/** One more page of one list. `cursor` is null when the list has ended. */
+export type MonitoringPage<L extends MonitoringListName = MonitoringListName> =
+  | { list: L; rows: MonitoringListRows[L][]; cursor: string | null; hiddenNotRelevant?: number }
+  | { error: "forbidden" | "bad_request" } | { state: "unavailable" | "not_configured" };
+
 export type MonitoringOverview = {
   state: "ready" | "empty";
   asOf: string;
@@ -164,6 +181,8 @@ export type MonitoringOverview = {
   otherMonitors?: string[];
   emailSubmissions?: MonitoringEmailSummary[];
   hiddenNotRelevant: number;
+  /** Where each list continues; null or missing when it has no more rows. */
+  cursors?: MonitoringCursors;
 };
 
 export type MonitoringResult =

package/lib/monitoring-paging.ts

@@ -0,0 +1,58 @@
+/** Merging loaded pages into the Monitoring lists. Kept free of other imports so the panel's tests can load it alone. */
+import type {
+  MonitoringCursors,
+  MonitoringItem,
+  MonitoringListName,
+  MonitoringListRows,
+  MonitoringOverview,
+} from "./monitoring-overview";
+
+/** Rows the editor has loaded beyond the first page of each list, and where each list continues. */
+export type MonitoringLoadedPages = Partial<{ [L in MonitoringListName]: { rows: MonitoringListRows[L][]; cursor: string | null } }>;
+
+const ROW_KEYS: { [L in MonitoringListName]: (row: MonitoringListRows[L]) => string } = {
+  runs: (row) => `${row.runId}`,
+  routerRuns: (row) => `${row.runId}`,
+  items: (row) => `${row.monitorId ?? ""}|${row.sourceId}`,
+  emailSubmissions: (row) => row.receiptId,
+};
+
+/**
+ * The first page followed by loaded pages, with a row seen twice kept once. The refresh re-reads the first page, so
+ * a row that moved onto it from a later page must not be listed again; for items the highest revision wins.
+ */
+export function mergeListPages<L extends MonitoringListName>(list: L, first: MonitoringListRows[L][], loaded: MonitoringListRows[L][]): MonitoringListRows[L][] {
+  const keyOf = ROW_KEYS[list] as (row: MonitoringListRows[L]) => string;
+  const seen = new Map<string, number>();
+  const merged: MonitoringListRows[L][] = [];
+  for (const row of [...first, ...loaded]) {
+    const key = keyOf(row);
+    const at = seen.get(key);
+    if (at === undefined) {
+      seen.set(key, merged.length);
+      merged.push(row);
+    } else if (list === "items" && (row as MonitoringItem).revision > (merged[at] as MonitoringItem).revision) {
+      merged[at] = row;
+    }
+  }
+  return merged;
+}
+
+/**
+ * What the page shows: the refreshed first page of every list plus whatever the editor loaded, with each list's
+ * cursor. With `held` the email list is replaced by the held-for-review list (its own pages).
+ */
+export function withLoadedPages(overview: MonitoringOverview, loaded: MonitoringLoadedPages, held: MonitoringLoadedPages["emailSubmissions"] | null): MonitoringOverview {
+  const cursors: MonitoringCursors = {};
+  const lists: Partial<Record<MonitoringListName, unknown[]>> = {};
+  for (const list of ["runs", "routerRuns", "items", "emailSubmissions"] as const) {
+    const extra = loaded[list];
+    lists[list] = mergeListPages(list, (overview[list] ?? []) as never[], (extra?.rows ?? []) as never[]) as unknown[];
+    cursors[list] = extra ? extra.cursor : overview.cursors?.[list] ?? null;
+  }
+  if (held) {
+    lists.emailSubmissions = held.rows;
+    cursors.emailSubmissions = held.cursor;
+  }
+  return { ...overview, ...(lists as Pick<MonitoringOverview, MonitoringListName>), cursors };
+}

package/lib/reference-feed-cache.ts

@@ -0,0 +1,133 @@
+/**
+ * Stale-while-revalidate copies of what the editor last saw, so a return visit paints cards (and the signed-in name) at once
+ * while the real reads run in the background. Display state only: the backend still authorizes every call, a cached copy never
+ * enables an action by itself, and everything here is dropped on sign-out. Every storage touch is guarded: the page renders
+ * the same, only slower, when storage is blocked or full.
+ */
+import type { ReferenceRecord } from "./category-repository";
+import type { RelevanceDecisionView } from "./relevance-decisions";
+import type { ReferencePreview } from "./reference-preview";
+
+const FEED_PREFIX = "papyrus.references.feed.v1.";
+const SESSION_PREFIX = "papyrus.newsroom.session.v1.";
+/** A saved session summary is trusted for display only this long; the live check always still runs. */
+export const SESSION_DISPLAY_TTL_MS = 15 * 60 * 1000;
+
+export type FeedSnapshot = {
+  savedAt: number;
+  references: ReferenceRecord[];
+  previews: Array<[string, ReferencePreview]>;
+  decisions: Array<[string, RelevanceDecisionView]>;
+};
+
+export type SessionDisplay = {
+  savedAt: number;
+  label: string;
+  isAdmin: boolean;
+};
+
+function storageOf(kind: "local" | "session"): Storage | null {
+  try {
+    if (typeof window === "undefined") return null;
+    return kind === "local" ? window.localStorage : window.sessionStorage;
+  } catch {
+    return null;
+  }
+}
+
+function read<T>(kind: "local" | "session", key: string): T | null {
+  try {
+    const raw = storageOf(kind)?.getItem(key);
+    return raw ? JSON.parse(raw) as T : null;
+  } catch {
+    return null;
+  }
+}
+
+function write(kind: "local" | "session", key: string, value: unknown): boolean {
+  try {
+    const storage = storageOf(kind);
+    if (!storage) return false;
+    storage.setItem(key, JSON.stringify(value));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function remove(kind: "local" | "session", key: string) {
+  try { storageOf(kind)?.removeItem(key); } catch { /* nothing to clear */ }
+}
+
+/** The fields a card needs, and nothing else: a smaller copy that fits, and less private text at rest. */
+export function slimReference(reference: ReferenceRecord): ReferenceRecord {
+  return {
+    id: reference.id,
+    lineageId: reference.lineageId,
+    versionNumber: reference.versionNumber,
+    versionState: reference.versionState,
+    corpusId: reference.corpusId,
+    externalItemId: reference.externalItemId,
+    title: reference.title,
+    sourceUri: reference.sourceUri,
+    mediaType: reference.mediaType,
+    sourcePublishedAt: reference.sourcePublishedAt,
+    retrievedAt: reference.retrievedAt,
+    importedAt: reference.importedAt,
+    createdAt: reference.createdAt,
+    curationStatus: reference.curationStatus,
+    curationStatusUpdatedAt: reference.curationStatusUpdatedAt,
+    curationStatusReason: reference.curationStatusReason,
+  };
+}
+
+export function feedCacheKey(siteId: string): string {
+  return `${FEED_PREFIX}${siteId}`;
+}
+
+export function loadFeedSnapshot(siteId: string): FeedSnapshot | null {
+  const snapshot = read<FeedSnapshot>("local", feedCacheKey(siteId));
+  if (!snapshot || !Array.isArray(snapshot.references) || !snapshot.references.length) return null;
+  return snapshot;
+}
+
+/** Saves the newest copy. On a full store it keeps the newest half, then gives up quietly. */
+export function saveFeedSnapshot(
+  siteId: string,
+  parts: { references: ReferenceRecord[]; previews: ReadonlyMap<string, ReferencePreview>; decisions: ReadonlyMap<string, RelevanceDecisionView> },
+  now = Date.now(),
+): boolean {
+  let references = parts.references.map(slimReference);
+  for (let attempt = 0; attempt < 4 && references.length; attempt += 1) {
+    const kept = new Set(references.map((reference) => reference.lineageId ?? reference.id));
+    const snapshot: FeedSnapshot = {
+      savedAt: now,
+      references,
+      previews: [...parts.previews].filter(([lineage]) => kept.has(lineage)),
+      decisions: [...parts.decisions].filter(([lineage]) => kept.has(lineage)).map(([lineage, decision]) => [lineage, { ...decision, provenance: null }]),
+    };
+    if (write("local", feedCacheKey(siteId), snapshot)) return true;
+    references = references.slice(0, Math.ceil(references.length / 2));
+  }
+  return false;
+}
+
+export function clearFeedSnapshot(siteId: string) {
+  remove("local", feedCacheKey(siteId));
+}
+
+export function loadSessionDisplay(siteId: string, now = Date.now()): SessionDisplay | null {
+  const saved = read<SessionDisplay>("session", `${SESSION_PREFIX}${siteId}`);
+  if (!saved || typeof saved.label !== "string" || typeof saved.savedAt !== "number") return null;
+  return now - saved.savedAt <= SESSION_DISPLAY_TTL_MS ? saved : null;
+}
+
+export function saveSessionDisplay(siteId: string, display: Omit<SessionDisplay, "savedAt">, now = Date.now()) {
+  write("session", `${SESSION_PREFIX}${siteId}`, { ...display, savedAt: now });
+}
+
+/** Sign-out: nothing of the signed-in view survives in this browser. */
+export function clearSavedNewsroomDisplay(siteId: string) {
+  remove("session", `${SESSION_PREFIX}${siteId}`);
+  clearFeedSnapshot(siteId);
+}