@anthusai/papyrus 5.45.0 → 5.47.0

package/lib/notification-feed.ts

@@ -0,0 +1,250 @@
+/**
+ * The Notification Center as a feed of cards ("What needs me?"): which cards there are, how they are counted, filtered and
+ * worded. Pure functions, so the page and its tests share them. A review request that covers several AI drafts is not shown as a
+ * batch: each draft is its own card, with a small caption saying which run it came from. The request still closes itself when
+ * its last draft is decided (components/notification-center.tsx).
+ */
+import type { ReferenceRecord } from "./category-repository";
+import { referenceDisplayTitle, referenceLineageId } from "./newsroom-references";
+import { normalizeReferenceCurationStatus } from "./reference-policy";
+import type { ReferencePreview } from "./reference-preview";
+import { draftDecisionOf, type DraftView } from "./review-drafts";
+import { draftIdsOf, isDraftReview, proposalHref, sectionReviews, type DraftDecision, type ReviewRequest } from "./review-requests";
+import { getNewsroomNavHref } from "./newsroom-nav";
+
+export type NotificationFilter = "all" | "drafts" | "references" | "other";
+export const NOTIFICATION_FILTERS: readonly NotificationFilter[] = ["all", "drafts", "references", "other"];
+export const FILTER_LABELS: Record<NotificationFilter, string> = { all: "All", drafts: "Drafts", references: "References", other: "Other" };
+
+export type DraftItem = {
+  kind: "draft";
+  /** `<request id>#<draft id>`. */
+  key: string;
+  request: ReviewRequest;
+  draftId: string;
+  /** Undefined while the Proposal is still loading. */
+  view: DraftView | undefined;
+  decision: DraftDecision | null;
+};
+
+/** A request that is decided as a whole: a hard gate, a soft review of something that is not a draft, or a flag. */
+export type RequestItem = { kind: "request"; key: string; request: ReviewRequest };
+
+export type NotificationItems = {
+  drafts: DraftItem[];
+  /** Hard gates first, then the other soft reviews, soonest deadline first. */
+  reviews: RequestItem[];
+  /** For your information: flags. */
+  flags: RequestItem[];
+  counts: NotificationCounts;
+};
+
+export type NotificationCounts = { drafts: number; references: number; other: number };
+
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] as const;
+
+/** "Oct 27", in UTC so the words do not change with the reader's time zone. */
+export function shortDate(iso: string | null | undefined): string {
+  if (!iso) return "";
+  const date = new Date(iso);
+  if (Number.isNaN(date.getTime())) return "";
+  return `${MONTHS[date.getUTCMonth()]} ${date.getUTCDate()}`;
+}
+
+function sentenceCase(slug: string): string {
+  const spaced = slug.replace(/[-_.]+/g, " ").trim();
+  return spaced ? spaced[0].toUpperCase() + spaced.slice(1) : "";
+}
+
+/** Where a request came from, in words: the run its batch names ("Monitor stories run"), else the step that raised it. */
+export function requestSource(request: Pick<ReviewRequest, "subject" | "raisedBy">): string {
+  if (request.subject.type === "batch") {
+    const named = request.subject.id.replace(/-\d{8}t\d{6}z.*$/i, "").replace(/-[0-9a-f]{6,}$/i, "");
+    if (/[a-z]{3,}/i.test(named)) return sentenceCase(named);
+  }
+  return sentenceCase(request.raisedBy) || "An automated step";
+}
+
+/** The small caption on a card that came out of a request: "from Monitor stories run · Oct 27". */
+export function requestCaption(request: Pick<ReviewRequest, "subject" | "raisedBy" | "raisedAt">): string {
+  const when = shortDate(request.raisedAt);
+  return `from ${requestSource(request)}${when ? ` · ${when}` : ""}`;
+}
+
+const NO_FALLBACK = { by: "", at: "" } as const;
+
+/**
+ * The cards for review requests. A draft review becomes one card per draft: undecided drafts of open requests, plus drafts decided in
+ * this visit (`stay`, keyed `<request id>#<draft id>`) so a card does not vanish under the editor's thumb. Drafts that are not Proposals
+ * on this site cannot be opened here; when none can, the request itself is one card that takes Accept or Reject.
+ */
+export function buildNotificationItems(input: {
+  requests: ReviewRequest[];
+  drafts: Readonly<Record<string, DraftView | undefined>>;
+  missingDrafts: ReadonlySet<string>;
+  draftsState: "loading" | "ready" | "failed";
+  /** Draft keys and request ids decided in this visit. */
+  stay: ReadonlySet<string>;
+  referenceCount: number;
+}): NotificationItems {
+  const sections = sectionReviews(input.requests);
+  const closedHere = input.requests.filter((request) => request.state !== "open" && input.stay.has(request.id));
+  const draftItems: DraftItem[] = [];
+  const requestLevel: ReviewRequest[] = [];
+  const draftRequests = [...sections.draftBatches, ...input.requests.filter((request) => request.state !== "open" && isDraftReview(request) && draftIdsOf(request).some((id) => input.stay.has(`${request.id}#${id}`)))];
+  for (const request of draftRequests) {
+    const available = draftIdsOf(request).filter((id) => !input.missingDrafts.has(id));
+    if (request.state === "open" && input.draftsState === "ready" && available.length === 0) {
+      requestLevel.push(request);
+      continue;
+    }
+    for (const draftId of available) {
+      const key = `${request.id}#${draftId}`;
+      const view = input.drafts[draftId];
+      const decision = draftDecisionOf(request.links.find((link) => link.id === draftId), view, NO_FALLBACK);
+      const waiting = request.state === "open" && !decision;
+      if (waiting || input.stay.has(key)) draftItems.push({ kind: "draft", key, request, draftId, view, decision });
+    }
+  }
+  const asItem = (request: ReviewRequest): RequestItem => ({ kind: "request", key: request.id, request });
+  const standing = (request: ReviewRequest) => request.state === "open" || input.stay.has(request.id);
+  const reviews = [
+    ...sections.hardGates,
+    ...sections.softReviews,
+    ...requestLevel,
+    ...closedHere.filter((request) => request.mode !== "flag" && !isDraftReview(request)),
+  ].filter(standing).map(asItem);
+  const flags = [...sections.flags, ...closedHere.filter((request) => request.mode === "flag")].filter(standing).map(asItem);
+  return {
+    drafts: draftItems,
+    reviews: [...new Map(reviews.map((item) => [item.key, item])).values()],
+    flags: [...new Map(flags.map((item) => [item.key, item])).values()],
+    counts: {
+      drafts: draftItems.filter((item) => !item.decision).length,
+      references: input.referenceCount,
+      other: [...reviews, ...flags].filter((item) => item.request.state === "open").length,
+    },
+  };
+}
+
+function plural(count: number, one: string, many = `${one}s`): string {
+  return `${count} ${count === 1 ? one : many}`;
+}
+
+/** "3 drafts and 12 references waiting for you"; "All caught up" when nothing waits. */
+export function waitingText(counts: NotificationCounts): string {
+  const parts = [
+    counts.drafts ? plural(counts.drafts, "draft") : null,
+    counts.references ? plural(counts.references, "reference") : null,
+    counts.other ? plural(counts.other, "other item") : null,
+  ].filter((part): part is string => part !== null);
+  if (!parts.length) return "All caught up";
+  const list = parts.length === 1 ? parts[0] : `${parts.slice(0, -1).join(", ")} and ${parts[parts.length - 1]}`;
+  return `${list} waiting for you`;
+}
+
+export function filterCount(filter: NotificationFilter, counts: NotificationCounts): number {
+  return filter === "all" ? counts.drafts + counts.references + counts.other : counts[filter];
+}
+
+/** Which sections a filter shows. */
+export function showsSection(filter: NotificationFilter, section: "drafts" | "references" | "other"): boolean {
+  return filter === "all" || filter === section;
+}
+
+// --- sources, pictures ----------------------------------------------------------------------------------------
+
+function normalizedAddress(address: string): string {
+  try {
+    const url = new URL(address);
+    return `${url.hostname.replace(/^www\./i, "").toLowerCase()}${url.pathname.replace(/\/+$/, "")}${url.search}`;
+  } catch {
+    return address.trim().toLowerCase();
+  }
+}
+
+/** The previews of References by the address they were saved from, so a draft's cited source finds its picture. */
+export function previewsBySourceAddress(references: ReferenceRecord[], previews: ReadonlyMap<string, ReferencePreview>): Map<string, ReferencePreview> {
+  const found = new Map<string, ReferencePreview>();
+  for (const reference of references) {
+    const preview = previews.get(referenceLineageId(reference));
+    if (preview && reference.sourceUri) found.set(normalizedAddress(reference.sourceUri), preview);
+  }
+  return found;
+}
+
+/** The first cited source that has a picture, with the site name its preview gives. */
+export function draftPicture(view: DraftView | undefined, bySource: ReadonlyMap<string, ReferencePreview>): { imageUrl: string | null; siteName: string | null; host: string | null } {
+  const sources = view?.sources ?? [];
+  const host = sources.find((source) => source.url)?.url ? sourceHost(sources.find((source) => source.url)!.url!) : null;
+  for (const source of sources) {
+    const preview = source.url ? bySource.get(normalizedAddress(source.url)) : undefined;
+    if (preview?.imageUrl) return { imageUrl: preview.imageUrl, siteName: preview.siteName, host: source.url ? sourceHost(source.url) : host };
+  }
+  return { imageUrl: null, siteName: null, host };
+}
+
+export function sourceHost(address: string): string | null {
+  try {
+    return new URL(address).hostname.replace(/^www\./i, "") || null;
+  } catch {
+    return null;
+  }
+}
+
+// --- what you decided ------------------------------------------------------------------------------------------
+
+export type RecentDecision = {
+  key: string;
+  kind: "draft" | "reference" | "request";
+  word: "Accepted" | "Rejected" | "Acknowledged" | "Answered";
+  choice: "accept" | "reject" | "acknowledge" | "answer";
+  title: string;
+  at: string;
+  href: string | null;
+  /** The editor's why, when there is one. */
+  note: string | null;
+};
+
+function requestDecision(request: ReviewRequest): Pick<RecentDecision, "word" | "choice"> | null {
+  const answer = request.answer;
+  if (request.state !== "answered" || !answer) return null;
+  if (answer.decision === "acknowledge" || (answer.decision === "approve" && request.mode === "flag")) return { word: "Acknowledged", choice: "acknowledge" };
+  if (answer.decision === "approve") return { word: "Accepted", choice: "accept" };
+  if (answer.decision === "reject") return { word: "Rejected", choice: "reject" };
+  return { word: "Answered", choice: "answer" };
+}
+
+/** What the editor decided most recently, newest first: drafts, other requests and References. "Last few", so a small default. */
+export function recentDecisions(requests: ReviewRequest[], references: ReferenceRecord[], demo = false, limit = 5): RecentDecision[] {
+  const found = new Map<string, RecentDecision>();
+  for (const request of requests) {
+    for (const link of request.links) {
+      if (!link.decision || !link.id) continue;
+      found.set(`${request.id}#${link.id}`, {
+        key: `${request.id}#${link.id}`, kind: "draft", word: link.decision.choice === "accept" ? "Accepted" : "Rejected", choice: link.decision.choice,
+        title: link.decision.title ?? link.label ?? link.id, at: link.decision.at, href: proposalHref(link.id, demo), note: link.decision.why ?? null,
+      });
+    }
+    for (const entry of request.answer?.drafts ?? []) {
+      found.set(`${request.id}#${entry.id}`, {
+        key: `${request.id}#${entry.id}`, kind: "draft", word: entry.choice === "accept" ? "Accepted" : "Rejected", choice: entry.choice,
+        title: entry.title ?? entry.id, at: entry.at, href: proposalHref(entry.id, demo), note: entry.why ?? null,
+      });
+    }
+    const whole = requestDecision(request);
+    if (whole && !request.answer?.drafts?.length) {
+      found.set(request.id, { key: request.id, kind: "request", ...whole, title: request.reason, at: request.answer!.at, href: null, note: request.answer!.feedback });
+    }
+  }
+  for (const reference of references) {
+    const status = normalizeReferenceCurationStatus(reference.curationStatus);
+    if ((status !== "accepted" && status !== "rejected") || !reference.curationStatusUpdatedAt) continue;
+    const lineageId = referenceLineageId(reference);
+    found.set(`reference#${lineageId}`, {
+      key: `reference#${lineageId}`, kind: "reference", word: status === "accepted" ? "Accepted" : "Rejected", choice: status === "accepted" ? "accept" : "reject",
+      title: referenceDisplayTitle(reference), at: reference.curationStatusUpdatedAt, href: getNewsroomNavHref(`/newsroom/references/${encodeURIComponent(lineageId)}`, demo), note: null,
+    });
+  }
+  return [...found.values()].filter((entry) => entry.at).sort((a, b) => b.at.localeCompare(a.at)).slice(0, limit);
+}

package/lib/reference-capture.ts

@@ -0,0 +1,293 @@
+/**
+ * What the newsroom actually captured of a Reference, so an editor can tell whether there is anything to rate.
+ *
+ * Curation before review (docs/reference-curation-pipeline.md) stores ONE `ReferenceAttachment` per Reference with role `curation` and sort
+ * key `003-curation`: a card with a status (`ready` / `degraded` / `capture_failed` / `running`), typed reasons, completeness signals, the
+ * summary and GROBID counts; the bodies are `ModelAttachment` rows (`curation-text`, `curation-grobid`, `curation-edit-NNNN-*`). That card is
+ * read first. Older captured text lives in `ReferenceAttachment` rows (the fallback): role `extracted_text` (the canonical text, possibly filtered to the article) and
+ * `extracted_text_raw` (what extraction returned), each with a `storagePath` to the stored text and a metadata object that carries
+ * `textLength` (characters), `title`, and any structured extraction (`grobid`, `structured`) written by `papyrus references
+ * process-fetch-url-text` / `process-attach-extracted-text`. The summary is a `metadata` payload on the Reference. A Reference that
+ * monitoring discovered has only its `source` attachment (the address): nothing captured.
+ */
+import type { ReferenceAttachmentRecord } from "./category-repository";
+
+export type CaptureState = "none" | "thin" | "full" | "running";
+
+export type CurationStatus = "ready" | "degraded" | "capture_failed" | "running";
+
+export type CurationCard = {
+  status: CurationStatus;
+  capture: { status?: string; reason?: string; transient?: boolean; sourceKind?: string; wordCount?: number; textSortKey?: string };
+  signals: Record<string, unknown>;
+  editedSignals: Record<string, unknown> | null;
+  summary: { status?: string; text?: string; stale?: boolean; reason?: string } | null;
+  grobid: { status?: string; reason?: string; title?: string; authorCount?: number; hasAbstract?: boolean; sectionCount?: number; referenceCount?: number; fieldsSortKey?: string } | null;
+  current: { textSortKey?: string; grobidSortKey?: string } | null;
+  labels: Array<{ kind?: string; assessment?: string; labeledAt?: string }>;
+};
+
+export type CaptureStatus = {
+  state: CaptureState;
+  /** Words in the stored text; an estimate (`estimated`) until the text itself is loaded. */
+  words: number | null;
+  estimated: boolean;
+  /** Where the status came from: the curation card, the older extracted-text attachment, or nothing. */
+  source?: "curation" | "extracted" | "none";
+  /** The curation card's own status, when there is a card. */
+  curation?: CurationStatus | null;
+  /** Why nothing was captured (the card's typed reason). */
+  reason?: string | null;
+  /** Plain-words signs the text may be cut off or paywalled (from the card's completeness signals). */
+  flags?: string[];
+  /** The editor's own verdict on the capture, when they gave one. */
+  assessment?: string | null;
+  summaryStale?: boolean;
+  /** Why a thin capture is thin: too few words, or signs in the text that it is cut off or paywalled. */
+  thinBy?: "length" | "signals";
+};
+
+export type CaptureAssessment = "complete" | "incomplete" | "incorrect";
+
+export const CURATION_ROLE = "curation";
+export const CURATION_SORT_KEY = "003-curation";
+
+/** Without enough captured texts to learn from, text shorter than this many words reads as a teaser. */
+export const DEFAULT_TEASER_WORDS = 250;
+/** With at least this many captured texts, the teaser line is learned: a quarter of the corpus' median length. */
+export const MINIMUM_CAPTURES_TO_LEARN = 10;
+const AVERAGE_CHARACTERS_PER_WORD = 6;
+
+export const EXTRACTED_TEXT_ROLES = ["extracted_text", "extracted_text_raw"] as const;
+
+function metadataOf(attachment: ReferenceAttachmentRecord): Record<string, unknown> {
+  const raw = attachment.metadata;
+  if (typeof raw === "string") {
+    try { const parsed = JSON.parse(raw); return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {}; } catch { return {}; }
+  }
+  return raw && typeof raw === "object" && !Array.isArray(raw) ? raw as Record<string, unknown> : {};
+}
+
+export function countWords(text: string): number {
+  const matches = text.trim().match(/\S+/g);
+  return matches ? matches.length : 0;
+}
+
+/** The characters an extracted-text attachment holds, from its own record (no download). */
+function recordedCharacters(attachment: ReferenceAttachmentRecord): number | null {
+  const length = metadataOf(attachment).textLength;
+  if (typeof length === "number" && length >= 0) return length;
+  return typeof attachment.byteSize === "number" && attachment.byteSize >= 0 ? attachment.byteSize : null;
+}
+
+function objectOf(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
+}
+
+/** The curation card of a Reference, from the attachments the newsroom already loads. Null when curation has not run. */
+export function curationCardOf(attachments: readonly ReferenceAttachmentRecord[]): CurationCard | null {
+  const row = attachments.find((attachment) => attachment.role === CURATION_ROLE && (attachment.sortKey === CURATION_SORT_KEY || !attachment.sortKey));
+  if (!row) return null;
+  const card = metadataOf(row);
+  const status = card.status;
+  if (status !== "ready" && status !== "degraded" && status !== "capture_failed" && status !== "running") return null;
+  const grobid = card.grobid ? objectOf(card.grobid) : null;
+  const summary = card.summary ? objectOf(card.summary) : null;
+  const current = card.current ? objectOf(card.current) : null;
+  return {
+    status,
+    capture: objectOf(card.capture) as CurationCard["capture"],
+    signals: objectOf(card.signals),
+    editedSignals: card.editedSignals ? objectOf(card.editedSignals) : null,
+    summary: summary as CurationCard["summary"],
+    grobid: grobid as CurationCard["grobid"],
+    current: current as CurationCard["current"],
+    labels: Array.isArray(card.labels) ? card.labels.map((label) => objectOf(label) as CurationCard["labels"][number]) : [],
+  };
+}
+
+const REASON_WORDS: Record<string, string> = {
+  blocked: "The site refused our request. It may be paywalled or protect itself from bots.",
+  http_4xx: "The page is gone or refused the request.",
+  http_5xx: "The site had an error when we asked.",
+  timeout: "The site took too long to answer.",
+  connection: "We could not connect to the site.",
+  dns: "The site's address did not resolve.",
+  tls: "The site's certificate could not be verified.",
+  too_large: "The document is larger than we read.",
+  unreadable: "The page has nothing we could read.",
+  no_text: "The page held no readable text.",
+  unsupported_media: "The address is not a page or a PDF.",
+  no_source_uri: "The record has no web address.",
+  not_public: "The address is not a public web page.",
+  invalid_url: "The address is not valid.",
+  loop: "The address redirects in a circle.",
+  unsafe_destination: "The destination did not pass our safety check.",
+};
+
+export function captureReasonWords(reason: string | null | undefined): string | null {
+  return reason ? REASON_WORDS[reason] ?? `Capture failed (${reason}).` : null;
+}
+
+/** Plain-words signs, from the card's completeness signals, that the text may be cut off or paywalled. Facts, never a verdict. */
+export function completenessFlags(signals: Record<string, unknown>): string[] {
+  const flags: string[] = [];
+  const markers = Array.isArray(signals.paywallMarkers) ? signals.paywallMarkers.map((marker) => objectOf(marker)) : [];
+  if (markers.some((marker) => marker.inTail === true)) flags.push("The text ends with a subscribe or sign-in phrase.");
+  else if (markers.length) flags.push("The text mentions subscribing or signing in.");
+  if (signals.endingPattern === "ellipsis" || signals.endingPattern === "truncation_marker") flags.push("The text stops with an ellipsis or a cut-off marker.");
+  else if (signals.endingPattern === "no_terminal_punctuation") flags.push("The text stops mid-sentence.");
+  if (signals.bodyNotLongerThanDescription === true) flags.push("The text is no longer than the page's own description.");
+  if (signals.structuredAccessibleForFree === false) flags.push("The page declares the article is not free to read.");
+  const ratio = signals.wordCountRatioToDeclared;
+  if (typeof ratio === "number" && ratio < 0.6 && typeof signals.declaredWordCount === "number") flags.push(`The page declares ${signals.declaredWordCount} words; we hold about ${Math.round(ratio * 100)}% of that.`);
+  if (signals.responseTruncated === true) flags.push("The page was larger than we read and was cut.");
+  const empty = signals.pdfEmptyPageCount;
+  if (typeof empty === "number" && empty > 0 && typeof signals.pdfPageCount === "number") flags.push(`${empty} of ${signals.pdfPageCount} PDF pages had no text (scanned).`);
+  return flags;
+}
+
+export function extractedTextAttachments(attachments: readonly ReferenceAttachmentRecord[]): ReferenceAttachmentRecord[] {
+  return attachments.filter((attachment) => (EXTRACTED_TEXT_ROLES as readonly string[]).includes(attachment.role) && Boolean(attachment.storagePath || attachment.sourceUri));
+}
+
+/** The attachment to read: the filtered canonical text first, then the raw extraction; the newest of each. */
+export function primaryTextAttachment(attachments: readonly ReferenceAttachmentRecord[]): ReferenceAttachmentRecord | null {
+  const newest = (rows: ReferenceAttachmentRecord[]) => [...rows].sort((left, right) => String(right.importedAt ?? "").localeCompare(String(left.importedAt ?? "")) || right.id.localeCompare(left.id))[0] ?? null;
+  const rows = extractedTextAttachments(attachments);
+  return newest(rows.filter((row) => row.role === "extracted_text")) ?? newest(rows.filter((row) => row.role === "extracted_text_raw"));
+}
+
+/** Words in the card's current text: the editor's corrected count when there is one, else the capture's. */
+function curationWords(card: CurationCard): number | null {
+  const edited = card.editedSignals?.wordCount;
+  if (typeof edited === "number") return edited;
+  const captured = card.capture.wordCount ?? card.signals.wordCount;
+  return typeof captured === "number" ? captured : null;
+}
+
+/** Estimated word count of one Reference's stored text, from its record alone. */
+export function estimatedWords(attachments: readonly ReferenceAttachmentRecord[]): number | null {
+  const card = curationCardOf(attachments);
+  const cardWords = card ? curationWords(card) : null;
+  if (cardWords !== null && cardWords > 0) return cardWords;
+  const primary = primaryTextAttachment(attachments);
+  const characters = primary ? recordedCharacters(primary) : null;
+  return characters === null ? null : Math.round(characters / AVERAGE_CHARACTERS_PER_WORD);
+}
+
+/** Where "thin" starts for this corpus: learned from its captured texts, else the default. */
+export function teaserWords(capturedWordCounts: readonly number[]): number {
+  if (capturedWordCounts.length < MINIMUM_CAPTURES_TO_LEARN) return DEFAULT_TEASER_WORDS;
+  const sorted = [...capturedWordCounts].sort((left, right) => left - right);
+  const middle = Math.floor(sorted.length / 2);
+  const median = sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+  return Math.max(50, Math.round(median * 0.25));
+}
+
+export function captureStatus(attachments: readonly ReferenceAttachmentRecord[], teaserLine = DEFAULT_TEASER_WORDS, loadedWords: number | null = null): CaptureStatus {
+  const card = curationCardOf(attachments);
+  const assessment = card?.labels.filter((label) => label.kind === "capture_completeness").at(-1)?.assessment ?? null;
+  const summaryStale = Boolean(card?.summary?.stale);
+  const cardWords = card ? curationWords(card) : null;
+  const cardHasText = Boolean(card && (cardWords ?? 0) > 0 && (card.capture.status === "completed" || card.current?.textSortKey));
+  if (card && cardHasText) {
+    const words = loadedWords ?? cardWords;
+    const flags = completenessFlags(card.editedSignals ?? card.signals);
+    const thin = words !== null && words < teaserLine;
+    const edited = Boolean(card.current?.textSortKey?.startsWith("curation-edit"));
+    // A complete text an editor vouched for is not second-guessed by the signals.
+    const doubtful = !edited && assessment !== "complete" && flags.length > 0 && !thin ? flags.some((flag) => /ends with|stops|no longer|not free|cut|declares/.test(flag)) : false;
+    return { state: thin || doubtful ? "thin" : "full", words, estimated: false, source: "curation", curation: card.status, reason: null, flags, assessment, summaryStale, ...(thin ? { thinBy: "length" as const } : doubtful ? { thinBy: "signals" as const } : {}) };
+  }
+  if (primaryTextAttachment(attachments)) {
+    const words = loadedWords ?? estimatedWords(attachments);
+    if (words === null) return { state: "thin", words: null, estimated: true, source: "extracted", curation: card?.status ?? null, reason: null, flags: [], assessment, summaryStale };
+    return { state: words === 0 ? "none" : words < teaserLine ? "thin" : "full", words, estimated: loadedWords === null, source: "extracted", curation: card?.status ?? null, reason: null, flags: [], assessment, summaryStale, ...(words > 0 && words < teaserLine ? { thinBy: "length" as const } : {}) };
+  }
+  if (card && card.status === "running") return { state: "running", words: null, estimated: false, source: "curation", curation: "running", reason: null, flags: [], assessment, summaryStale };
+  return { state: "none", words: null, estimated: false, source: "none", curation: card?.status ?? null, reason: card?.capture.reason ?? null, flags: [], assessment, summaryStale };
+}
+
+/** Capture status for every Reference lineage that has attachments, using one corpus-wide teaser line. */
+export function captureStatusesByLineage(attachments: readonly ReferenceAttachmentRecord[], lineageIds: Iterable<string>): { statuses: Map<string, CaptureStatus>; teaserLine: number } {
+  const byLineage = new Map<string, ReferenceAttachmentRecord[]>();
+  for (const attachment of attachments) {
+    const list = byLineage.get(attachment.referenceLineageId) ?? [];
+    list.push(attachment);
+    byLineage.set(attachment.referenceLineageId, list);
+  }
+  const counts = [...byLineage.values()].map(estimatedWords).filter((words): words is number => words !== null && words > 0);
+  const teaserLine = teaserWords(counts);
+  const statuses = new Map<string, CaptureStatus>();
+  for (const lineageId of lineageIds) statuses.set(lineageId, captureStatus(byLineage.get(lineageId) ?? [], teaserLine));
+  return { statuses, teaserLine };
+}
+
+export type CaptureLine = { state: CaptureState; label: string; detail: string };
+
+/** The plain-words status line. */
+export function captureLine(status: CaptureStatus): CaptureLine {
+  const count = status.words === null ? null : `${status.estimated ? "about " : ""}${status.words.toLocaleString("en-US")} words`;
+  if (status.state === "running") return { state: "running", label: "Being captured now", detail: "Curation is reading this item. Check back in a moment." };
+  if (status.state === "none") {
+    const why = captureReasonWords(status.reason);
+    return { state: "none", label: "No text captured", detail: why ?? (status.curation === "capture_failed" ? "Capture failed." : "Only the link is on record. There is nothing here to judge the content by.") };
+  }
+  if (status.state === "thin") {
+    const byLength = status.thinBy !== "signals";
+    return {
+      state: "thin",
+      label: status.words === null ? "Only a little text captured — may be a teaser or paywalled" : byLength ? `Only ${status.words.toLocaleString("en-US")} words — may be a teaser or paywalled` : "Captured, but it may be cut off or paywalled",
+      detail: status.flags?.length ? status.flags.join(" ") : "Check the source before you rate it.",
+    };
+  }
+  return { state: "full", label: "Full text captured", detail: count ?? "" };
+}
+
+/** Structured extraction (GROBID for papers, or the structured summary) as plain label and value rows. */
+export function structuredRows(attachments: readonly ReferenceAttachmentRecord[]): Array<{ label: string; value: string }> {
+  const rows: Array<{ label: string; value: string }> = [];
+  const raw = attachments.find((attachment) => attachment.role === "extracted_text_raw") ?? primaryTextAttachment(attachments);
+  if (!raw) return rows;
+  const metadata = metadataOf(raw);
+  const add = (label: string, value: unknown) => {
+    if (value === null || value === undefined || value === "") return;
+    const text = Array.isArray(value) ? value.map((entry) => (typeof entry === "string" ? entry : (entry as { name?: string })?.name ?? "")).filter(Boolean).join(", ")
+      : typeof value === "object" ? "" : String(value);
+    if (text.trim()) rows.push({ label, value: text.length > 400 ? `${text.slice(0, 397)}…` : text });
+  };
+  for (const source of [metadata.grobid, metadata.structured]) {
+    if (!source || typeof source !== "object" || Array.isArray(source)) continue;
+    const record = source as Record<string, unknown>;
+    add("Title", record.title);
+    add("Authors", record.authors);
+    add("Abstract", record.abstract);
+    add("DOI", record.doi);
+    add("Published", record.published ?? record.date ?? record.year);
+    add("Venue", record.venue ?? record.journal);
+    if (Array.isArray(record.citations)) add("Citations", `${record.citations.length} cited works`);
+    if (Array.isArray(record.references)) add("References", `${record.references.length} cited works`);
+    add("Keywords", record.keywords);
+  }
+  return rows;
+}
+
+/** Rows for the structured extraction from the card's GROBID fields body (`curation-grobid`), else from its counts. */
+export function grobidRows(fields: unknown, card: CurationCard | null): Array<{ label: string; value: string }> {
+  const rows: Array<{ label: string; value: string }> = [];
+  const record = objectOf(fields);
+  const add = (label: string, value: unknown) => { if (typeof value === "string" && value.trim()) rows.push({ label, value: value.length > 500 ? `${value.slice(0, 497)}…` : value }); };
+  add("Title", record.title ?? card?.grobid?.title);
+  if (Array.isArray(record.authors) && record.authors.length) {
+    add("Authors", record.authors.map((author) => (typeof author === "string" ? author : String(objectOf(author).name ?? ""))).filter(Boolean).join(", "));
+  } else if (typeof card?.grobid?.authorCount === "number") add("Authors", `${card.grobid.authorCount} authors`);
+  add("Abstract", record.abstract);
+  add("DOI", record.doi);
+  if (Array.isArray(record.keywords) && record.keywords.length) add("Keywords", record.keywords.join(", "));
+  const sections = Array.isArray(record.sections) ? record.sections.length : card?.grobid?.sectionCount;
+  if (typeof sections === "number") add("Sections", `${sections} sections`);
+  const references = Array.isArray(record.references) ? record.references.length : card?.grobid?.referenceCount;
+  if (typeof references === "number") add("References", `${references} cited works`);
+  return rows;
+}

package/lib/reference-feed-cache.ts

@@ -7,9 +7,12 @@
 import type { ReferenceRecord } from "./category-repository";
 import type { RelevanceDecisionView } from "./relevance-decisions";
 import type { ReferencePreview } from "./reference-preview";
+import type { DraftView } from "./review-drafts";
+import type { ReviewRequest } from "./review-requests";
 
 const FEED_PREFIX = "papyrus.references.feed.v1.";
 const SESSION_PREFIX = "papyrus.newsroom.session.v1.";
+const NOTIFICATION_PREFIX = "papyrus.notifications.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;
 
@@ -126,8 +129,42 @@ export function saveSessionDisplay(siteId: string, display: Omit<SessionDisplay,
   write("session", `${SESSION_PREFIX}${siteId}`, { ...display, savedAt: now });
 }
 
+/** What the Notification Center last showed: review requests (without their history) and the drafts they cover. Display only. */
+export type NotificationSnapshot = {
+  savedAt: number;
+  requests: ReviewRequest[];
+  drafts: Record<string, DraftView>;
+  missing: string[];
+};
+
+export function notificationCacheKey(siteId: string): string {
+  return `${NOTIFICATION_PREFIX}${siteId}`;
+}
+
+export function loadNotificationSnapshot(siteId: string): NotificationSnapshot | null {
+  const snapshot = read<NotificationSnapshot>("local", notificationCacheKey(siteId));
+  if (!snapshot || !Array.isArray(snapshot.requests) || typeof snapshot.drafts !== "object" || !snapshot.drafts) return null;
+  return snapshot;
+}
+
+/** Saves the newest copy; who did what stays out of storage. Quiet when storage is blocked or full. */
+export function saveNotificationSnapshot(siteId: string, parts: { requests: ReviewRequest[]; drafts: Readonly<Record<string, DraftView>>; missing: Iterable<string> }, now = Date.now()): boolean {
+  const snapshot: NotificationSnapshot = {
+    savedAt: now,
+    requests: parts.requests.map((request) => ({ ...request, history: [] })),
+    drafts: { ...parts.drafts },
+    missing: [...parts.missing],
+  };
+  return write("local", notificationCacheKey(siteId), snapshot);
+}
+
+export function clearNotificationSnapshot(siteId: string) {
+  remove("local", notificationCacheKey(siteId));
+}
+
 /** Sign-out: nothing of the signed-in view survives in this browser. */
 export function clearSavedNewsroomDisplay(siteId: string) {
   remove("session", `${SESSION_PREFIX}${siteId}`);
   clearFeedSnapshot(siteId);
+  clearNotificationSnapshot(siteId);
 }

package/lib/reference-feed-ranking.ts

@@ -189,3 +189,47 @@ export function groupFeedItems(items: FeedItem[]): Array<{ key: FeedGroupKey; it
   }
   return (["top", "more", "least"] as const).filter((key) => groups[key].length).map((key) => ({ key, items: groups[key] }));
 }
+
+/**
+ * The order of the feed, taken once per visit when it loads and then left alone: selecting, rating, a background refresh and a cache
+ * revalidation never re-rank it. Items that arrive later are counted as new and wait behind a "N new items: show" pill.
+ */
+export type FeedOrderSnapshot = {
+  /** Every Reference lineage the snapshot knew about (pending, rated and earlier): anything else is new. */
+  known: ReadonlySet<string>;
+  feed: string[];
+  earlier: string[];
+  groups: Array<{ key: FeedGroupKey; ids: string[] }>;
+  leadId: string | undefined;
+};
+
+export function takeFeedOrderSnapshot(partition: ReferenceFeedPartition): FeedOrderSnapshot {
+  const groups = groupFeedItems(partition.feed);
+  return {
+    known: new Set([...partition.feed, ...partition.earlier, ...partition.rated].map((item) => item.lineageId)),
+    feed: partition.feed.map((item) => item.lineageId),
+    earlier: partition.earlier.map((item) => item.lineageId),
+    groups: groups.map((group) => ({ key: group.key, ids: group.items.map((item) => item.lineageId) })),
+    leadId: groups[0]?.key !== "least" ? groups[0]?.items[0]?.lineageId : undefined,
+  };
+}
+
+/** The live partition with its feed order, sections and lead taken from the snapshot; records and scores stay current. */
+export function applyFeedOrderSnapshot(snapshot: FeedOrderSnapshot, live: ReferenceFeedPartition): {
+  partition: ReferenceFeedPartition;
+  groups: Array<{ key: FeedGroupKey; items: FeedItem[] }>;
+  leadId: string | undefined;
+  newCount: number;
+} {
+  const byId = new Map<string, FeedItem>();
+  for (const item of [...live.rated, ...live.earlier, ...live.feed]) byId.set(item.lineageId, item);
+  const pick = (ids: string[]) => ids.flatMap((id) => { const item = byId.get(id); return item ? [item] : []; });
+  const groups = snapshot.groups.map((group) => ({ key: group.key, items: pick(group.ids) })).filter((group) => group.items.length);
+  const newCount = [...live.feed, ...live.earlier].filter((item) => !snapshot.known.has(item.lineageId)).length;
+  return {
+    partition: { ...live, feed: pick(snapshot.feed), earlier: pick(snapshot.earlier) },
+    groups,
+    leadId: snapshot.leadId && byId.has(snapshot.leadId) ? snapshot.leadId : undefined,
+    newCount,
+  };
+}