@anthusai/papyrus 5.44.0 → 5.46.0

package/lib/local-preview-feed-fixture.ts

@@ -0,0 +1,63 @@
+import fs from "node:fs";
+import path from "node:path";
+import { normalizeReviewRow } from "./review-requests";
+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 type NotificationCenterFixture = NonNullable<CategorySteeringDashboard["notificationFixture"]>;
+
+/**
+ * Local preview only: when PAPYRUS_NOTIFICATION_FIXTURE names a JSON file written by scripts/export-notification-center-fixture.py,
+ * the demo Notification Center shows those review requests and their drafts instead of the invented sample.
+ */
+export function loadNotificationCenterFixture(env: NodeJS.ProcessEnv = process.env): NotificationCenterFixture | null {
+  const configured = env.PAPYRUS_NOTIFICATION_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-notification-center-fixture/1" || !Array.isArray(parsed.requests)) return null;
+    return { requests: parsed.requests.map(normalizeReviewRow), drafts: Array.isArray(parsed.drafts) ? parsed.drafts : [] };
+  } catch {
+    return null;
+  }
+}
+
+export function withReferenceFeedFixture(dashboard: CategorySteeringDashboard): CategorySteeringDashboard {
+  const fixture = loadReferenceFeedFixture();
+  if (!fixture) return dashboard;
+  return {
+    ...dashboard,
+    notificationFixture: loadNotificationCenterFixture(),
+    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/newsroom-nav.ts

@@ -21,7 +21,7 @@ export type NewsroomNavItem = {
 };
 
 export const NEWSROOM_OPS_NAV: NewsroomNavItem[] = [
-  { id: "overview", label: "Overview", detail: "Newsroom home", href: newsroomHref() },
+  { id: "overview", label: "Needs me", detail: "Newsroom home", href: newsroomHref() },
   { id: "articles", label: getContentItemName().plural, detail: "Drafts & published", href: newsroomHref("articles") },
   { id: "assignments", label: "Assignments", detail: "Work queue", href: newsroomHref("assignments") },
   { id: "references", label: "References", detail: "Knowledge base", href: newsroomHref("references") },

package/lib/newsroom-organizer-nav.ts

@@ -8,7 +8,7 @@ export type OrganizerDestination = {
 };
 export const ORGANIZER_NAV_GROUPS: readonly { title: string; items: readonly OrganizerDestination[] }[] = [
   { title: "Editorial work", items: [
-    { key: "overview", label: "Overview", description: "See notifications and work needing attention.", path: "/newsroom", primary: true },
+    { key: "overview", label: "Needs me", description: "See what needs you: drafts, references and reviews.", path: "/newsroom", primary: true },
     { key: "articles", label: getContentItemName().plural, description: `Follow ${contentItemPluralLowercase} across their stages and open one to write or revise it.`, path: `/newsroom/${contentItemBoardPathSegment()}`, alsoActiveOnPaths: ["/newsroom/articles"], primary: true },
     { key: "assignments", label: "Assignments", description: "Follow research and reporting work across its statuses and claim it.", path: "/newsroom/assignments" },
     { key: "drafts", label: "Drafts", description: "Read the story drafts that AI proposes, then accept or reject them.", path: "/newsroom/administration/proposals" },

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);
+}