@anthusai/papyrus 5.32.0 → 5.33.0

package/lib/automation-overview.ts

@@ -4,7 +4,19 @@ import { getNewsroomNavHref } from "./newsroom-nav";
 
 export { formatUtc };
 
+export type AutomationUsage = {
+  calls?: number;
+  promptTokens?: number;
+  completionTokens?: number;
+  models?: Record<string, number>;
+  complete?: boolean;
+  unpricedModels?: string[];
+};
+
 export type AutomationRun = {
+  origin: "monitor" | "manual";
+  requestedBy: string | null;
+  reason: string | null;
   sourceId: string | null;
   referenceId: string | null;
   triggerStatus: string | null;
@@ -20,8 +32,30 @@ export type AutomationRun = {
   storyTitle: string | null;
   costUsd: number | null;
   costNote: string;
+  budgetUsd: number | null;
+  overBudget: boolean;
+  usage: AutomationUsage | null;
 };
 
+/** A ProcedureRun of the same procedure that this automation did not start ("Started outside this automation"). */
+export type AutomationOutsideRun = {
+  runId: string | null;
+  status: string | null;
+  startedAt: string | null;
+  finishedAt: string | null;
+  durationSeconds: number | null;
+  error: string | null;
+  requestedBy: string | null;
+  storyId: string | null;
+  storyVersionId: string | null;
+  storyTitle: string | null;
+  costUsd: number | null;
+  costNote: string;
+  overBudget: boolean;
+};
+
+export type AutomationRunNow = { available: boolean; reason: string | null; needsInput: boolean; inputNames: string[] };
+
 export type AutomationLink = {
   state: "linked" | "input_differs" | "trigger_not_found" | "publication_not_in_router" | "router_not_found" | "not_applicable";
   text: string;
@@ -44,6 +78,7 @@ export type AutomationRecord = {
   inputTemplate: Record<string, string>;
   limits: { timeoutSeconds?: number; maxConcurrent?: number; budgetUsdPerRun?: number };
   limitsNote: string;
+  runNow: AutomationRunNow;
   createdAt: string | null;
   updatedAt: string | null;
   link: AutomationLink | null;
@@ -51,6 +86,8 @@ export type AutomationRecord = {
   lastRun: AutomationRun | null;
   skippedAlreadyHadReference: number;
   notice: AutomationNotice | null;
+  outsideRuns: AutomationOutsideRun[];
+  outsideNotice: "outside_unavailable" | null;
 };
 
 export type AutomationOverview = {
@@ -72,7 +109,7 @@ export function triggerText(trigger: AutomationRecord["trigger"]): string {
   return kind;
 }
 
-export const ENABLED_NOTE = "display only until the router honours it";
+export const ENABLED_NOTE = "the router starts nothing for a disabled automation";
 
 export function enabledText(record: Pick<AutomationRecord, "enabled">): string {
   return record.enabled ? "Enabled" : "Disabled";
@@ -87,8 +124,13 @@ const STATUS_WORDS: Record<string, string> = {
   startFailed: "Could not start",
   notRunnable: "Not runnable",
   notTriggered: "Not started",
+  skipped: "Skipped",
+  refused: "Refused",
+  deferred: "Deferred, waiting for room",
+};
+const STATUS_MARKS: Record<string, string> = {
+  completed: "✓", failed: "✕", startFailed: "✕", notRunnable: "✕", refused: "✕", skipped: "–", deferred: "…", started: "…", starting: "…", running: "…",
 };
-const STATUS_MARKS: Record<string, string> = { completed: "✓", failed: "✕", startFailed: "✕", notRunnable: "✕", started: "…", starting: "…", running: "…" };
 
 export function statusText(status: string | null | undefined): string {
   return status ? (STATUS_WORDS[status] ?? status) : "No runs";
@@ -104,6 +146,56 @@ export function durationText(seconds: number | null | undefined): string {
   return `${Math.floor(seconds / 60)} min ${Math.round(seconds % 60)} s`;
 }
 
+export function dollars(value: number): string {
+  return value < 0.01 ? `$${value.toFixed(4)}` : `$${value.toFixed(2)}`;
+}
+
+/** "Cost: $0.04 (estimated ...)" or "Cost: unknown (why)", with the advisory budget flagged in words. */
+export function costText(run: Pick<AutomationRun, "costUsd" | "costNote" | "overBudget"> & { budgetUsd?: number | null }): string {
+  const base = run.costUsd === null ? `Cost: unknown (${run.costNote})` : `Cost: ${dollars(run.costUsd)} (${run.costNote})`;
+  return run.overBudget && run.budgetUsd != null ? `${base}. Over the budget of ${dollars(run.budgetUsd)} per run` : base;
+}
+
+export function whoText(run: Pick<AutomationRun, "origin" | "requestedBy" | "sourceId">): string {
+  return run.origin === "manual" ? `Run now by ${run.requestedBy ?? "someone"}` : `Item: ${run.sourceId ?? "unknown"}`;
+}
+
+export const LIMITS_NOTE = "the timeout and the number at a time (when set) are enforced when a run starts; the budget is advisory and only flagged";
+
+export function atATimeText(limits: { maxConcurrent?: number }): string {
+  return limits.maxConcurrent === undefined ? "no limit on how many at a time" : `${limits.maxConcurrent} at a time`;
+}
+
+export type RunNowResult =
+  | { state: "started"; automationId: string; requestedBy: string }
+  | { state: "refused"; reason: string }
+  | { state: "unavailable" }
+  | { error: "forbidden" | "bad_request" };
+
+export function runNowMessage(result: RunNowResult): string {
+  if ("error" in result) return result.error === "forbidden" ? "Run now is for editors and admins." : "The request was not understood.";
+  if (result.state === "started") return "Started. The run appears in the list below within a minute; the page refreshes by itself.";
+  if (result.state === "refused") return `Not started: ${result.reason}`;
+  return "Not started: the request could not be completed right now. Nothing was started.";
+}
+
+/** The input a person typed for Run now: a JSON object, or nothing (the record's own input is used). */
+export function parseRunInput(text: string): { ok: true; value: Record<string, unknown> | null } | { ok: false; message: string } {
+  if (!text.trim()) return { ok: true, value: null };
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return { ok: false, message: "The input must be a JSON object, for example {\"name\": \"value\"}." };
+    return { ok: true, value: parsed as Record<string, unknown> };
+  } catch {
+    return { ok: false, message: "The input is not valid JSON." };
+  }
+}
+
+/** A starting point for the input box: the record's input names with empty values. */
+export function inputTemplateText(names: string[]): string {
+  return JSON.stringify(Object.fromEntries(names.map((name) => [name, ""])), null, 2);
+}
+
 const LINK_WORDS: Record<AutomationLink["state"], string> = {
   linked: "Linked: the router's trigger matches this record.",
   input_differs: "Differs: the router's input template is not the same as this record's.",
@@ -125,6 +217,8 @@ const NOTICE_WORDS: Record<string, string> = {
   "not yet supported": "Only monitor automations run today. This one is stored but nothing starts it.",
 };
 
+export const OUTSIDE_NOTICE = "The procedure's other runs could not be read right now.";
+
 export function noticeText(notice: AutomationNotice | null): string | null {
   return notice ? (NOTICE_WORDS[notice] ?? notice) : null;
 }

package/lib/review-client.ts

@@ -0,0 +1,99 @@
+"use client";
+
+import { generateClient } from "aws-amplify/data";
+import { getCurrentUser } from "aws-amplify/auth";
+import {
+  answerUpdate, isDue, normalizeReviewRow, timeoutUpdate,
+  type AnswerInput, type ReviewRequest,
+} from "./review-requests";
+
+/**
+ * Review requests through the site's own authenticated API (user pool; editors and admins). The condition `state = open`
+ * on every change means two people answering at once, or an answer racing the deadline, cannot both win.
+ */
+
+const FIELDS = "id subject mode reason ask raisedBy raisedAt deadline state answer links history appliedIn updatedAt";
+const MAX_PAGES = 10;
+
+type GraphQLResult = { data?: Record<string, any>; errors?: { message?: string; errorType?: string }[] };
+
+async function run(query: string, variables: Record<string, unknown>): Promise<GraphQLResult> {
+  const client = generateClient({ authMode: "userPool" });
+  try {
+    return (await client.graphql({ query, variables })) as GraphQLResult;
+  } catch (error) {
+    // Amplify throws the response when AppSync returns errors.
+    return (error && typeof error === "object" && "errors" in error ? error : { errors: [{ message: "failed" }] }) as GraphQLResult;
+  }
+}
+
+export type ReviewLoad = { state: "ready"; requests: ReviewRequest[]; readIds: string[]; userKey: string } | { state: "forbidden" } | { state: "unavailable" };
+
+export async function currentUserKey(): Promise<string> {
+  return (await getCurrentUser()).userId;
+}
+
+/** Loads every request (newest pages first), marks due soft reviews as timed out ("proceeded without review"), and reads this user's marks. */
+export async function loadReviews(now: Date = new Date()): Promise<ReviewLoad> {
+  let userKey: string;
+  try {
+    userKey = await currentUserKey();
+  } catch {
+    return { state: "unavailable" };
+  }
+  const rows: Record<string, unknown>[] = [];
+  let nextToken: string | null = null;
+  for (let page = 0; page < MAX_PAGES; page += 1) {
+    const result = await run(
+      `query ListReviews($limit: Int, $nextToken: String) { listReviewRequests(limit: $limit, nextToken: $nextToken) { items { ${FIELDS} } nextToken } }`,
+      { limit: 500, nextToken },
+    );
+    if (result.errors?.some((entry) => /unauthorized|not authorized|forbidden/i.test(`${entry.errorType ?? ""} ${entry.message ?? ""}`))) return { state: "forbidden" };
+    const connection = result.data?.listReviewRequests;
+    if (result.errors?.length || !connection) return { state: "unavailable" };
+    rows.push(...connection.items.filter(Boolean));
+    nextToken = connection.nextToken ?? null;
+    if (!nextToken) break;
+  }
+  const requests = rows.map(normalizeReviewRow);
+  for (const [index, request] of requests.entries()) {
+    if (!isDue(request, now)) continue;
+    const update = timeoutUpdate(request, now);
+    const written = await run(
+      `mutation Expire($input: UpdateReviewRequestInput!, $condition: ModelReviewRequestConditionInput) { updateReviewRequest(input: $input, condition: $condition) { ${FIELDS} } }`,
+      { input: update, condition: { state: { eq: "open" } } },
+    );
+    const row = written.data?.updateReviewRequest;
+    requests[index] = row ? normalizeReviewRow(row) : { ...request, state: "timed_out", updatedAt: String(update.updatedAt), history: JSON.parse(String(update.history)) };
+  }
+  const marks = await run(
+    `query Marks($filter: ModelReviewReadMarkFilterInput, $limit: Int) { listReviewReadMarks(filter: $filter, limit: $limit) { items { requestId } } }`,
+    { filter: { userKey: { eq: userKey } }, limit: 5000 },
+  );
+  const readIds = (marks.data?.listReviewReadMarks?.items ?? []).filter(Boolean).map((mark: { requestId: string }) => mark.requestId);
+  return { state: "ready", requests, readIds, userKey };
+}
+
+/** Records an answer. Throws an Error with a sentence for the page when the request is closed or the write loses a race. */
+export async function answerReviewRequest(request: ReviewRequest, input: AnswerInput, by: string, now: Date = new Date()): Promise<ReviewRequest> {
+  const update = answerUpdate(request, input, by, now);
+  const result = await run(
+    `mutation Answer($input: UpdateReviewRequestInput!, $condition: ModelReviewRequestConditionInput) { updateReviewRequest(input: $input, condition: $condition) { ${FIELDS} } }`,
+    { input: update, condition: { state: { eq: "open" } } },
+  );
+  if (result.errors?.some((entry) => /conditional/i.test(`${entry.errorType ?? ""} ${entry.message ?? ""}`))) {
+    throw new Error("Someone else answered this, or it proceeded at its deadline. Refresh to see the result.");
+  }
+  if (result.errors?.length || !result.data?.updateReviewRequest) throw new Error("Could not save the answer. Nothing was changed.");
+  return normalizeReviewRow(result.data.updateReviewRequest);
+}
+
+/** This user has seen the request. Create the mark; if it exists, refresh it. */
+export async function markReviewRead(userKey: string, requestId: string, now: Date = new Date()): Promise<void> {
+  const input = { id: `${userKey}#${requestId}`, requestId, userKey, readAt: now.toISOString() };
+  const created = await run(
+    `mutation Mark($input: CreateReviewReadMarkInput!) { createReviewReadMark(input: $input) { id } }`, { input });
+  if (created.errors?.length) {
+    await run(`mutation Mark($input: UpdateReviewReadMarkInput!) { updateReviewReadMark(input: $input) { id } }`, { input });
+  }
+}

package/lib/review-fixture.ts

@@ -0,0 +1,45 @@
+import type { ReviewRequest } from "./review-requests";
+
+/** Demo and test data: one of each mode, a timed-out soft review, and an answered one whose steering was applied. */
+export const FIXTURE_REVIEW_REQUESTS: ReviewRequest[] = [
+  {
+    id: "rr-hard-1", subject: { type: "story", id: "story-ruling-1" }, mode: "hard_gate", reason: "Approve this ruling summary before it is published",
+    ask: "Check the holding and the quoted passages.", raisedBy: "distinctive.ttab.ruling-analysis", raisedAt: "2026-10-23T08:00:00Z", deadline: null,
+    state: "open", answer: null, links: [], history: [{ at: "2026-10-23T08:00:00Z", event: "raised", by: "distinctive.ttab.ruling-analysis", note: "hard_gate" }],
+    appliedIn: null, updatedAt: "2026-10-23T08:00:00Z",
+  },
+  {
+    id: "rr-soft-2", subject: { type: "batch", id: "2026-W43" }, mode: "soft_review", reason: "3 new story ideas to review",
+    ask: "Approve to keep them all, reject to drop the batch, or steer with a note.", raisedBy: "idea-pipeline", raisedAt: "2026-10-23T07:00:00Z",
+    deadline: "2026-10-30T07:00:00Z", state: "open", answer: null,
+    links: [{ type: "proposal", id: "proposal-1", label: "story idea 1" }, { type: "proposal", id: "proposal-2", label: "story idea 2" }, { type: "proposal", id: "proposal-3", label: "story idea 3" }],
+    history: [], appliedIn: null, updatedAt: "2026-10-23T07:00:00Z",
+  },
+  {
+    id: "rr-soft-1", subject: { type: "proposal", id: "proposal-9" }, mode: "soft_review", reason: "A trend story draft is ready",
+    ask: null, raisedBy: "trend-pipeline", raisedAt: "2026-10-22T07:00:00Z", deadline: "2026-10-25T07:00:00Z", state: "open", answer: null,
+    links: [], history: [], appliedIn: null, updatedAt: "2026-10-22T07:00:00Z",
+  },
+  {
+    id: "rr-flag-1", subject: { type: "reference", id: "ref-1" }, mode: "flag", reason: "Two sources disagree about the filing date",
+    ask: null, raisedBy: "reference-intake", raisedAt: "2026-10-22T10:00:00Z", deadline: null, state: "open", answer: null, links: [], history: [],
+    appliedIn: null, updatedAt: "2026-10-22T10:00:00Z",
+  },
+  {
+    id: "rr-late-1", subject: { type: "story", id: "story-old" }, mode: "soft_review", reason: "Check the headline", ask: null, raisedBy: "copy-editor",
+    raisedAt: "2026-10-10T07:00:00Z", deadline: "2026-10-17T07:00:00Z", state: "timed_out", answer: null, links: [],
+    history: [{ at: "2026-10-17T07:00:00Z", event: "timed_out", by: "system", note: "proceeded without review" }], appliedIn: null, updatedAt: "2026-10-17T07:00:00Z",
+  },
+  {
+    id: "rr-done-1", subject: { type: "batch", id: "2026-W42" }, mode: "soft_review", reason: "4 new story ideas to review", ask: null, raisedBy: "idea-pipeline",
+    raisedAt: "2026-10-16T07:00:00Z", deadline: "2026-10-23T07:00:00Z", state: "answered",
+    answer: { decision: "feedback", feedback: "Fewer listicles", steer: "not_this_kind", by: "Ed Itor", at: "2026-10-17T09:00:00Z" },
+    links: [], history: [], appliedIn: { runId: "run-w43", by: "idea-pipeline", at: "2026-10-20T07:00:00Z" }, updatedAt: "2026-10-17T09:00:00Z",
+  },
+  {
+    id: "rr-done-2", subject: { type: "proposal", id: "proposal-4" }, mode: "soft_review", reason: "A concept rename was proposed", ask: null, raisedBy: "concept-bot",
+    raisedAt: "2026-10-18T07:00:00Z", deadline: "2026-10-25T07:00:00Z", state: "answered",
+    answer: { decision: "feedback", feedback: "Keep the old name for sports", steer: "adjust", by: "Ed Itor", at: "2026-10-19T09:00:00Z" },
+    links: [], history: [], appliedIn: null, updatedAt: "2026-10-19T09:00:00Z",
+  },
+];

package/lib/review-requests.ts

@@ -0,0 +1,238 @@
+/**
+ * The Notification Center's model (PPY-1cd261, PPY-ab6a50): review requests, the Cyclotron items that wait for a person,
+ * the auto-decided stream, and the words the page says about each. Pure functions only, so the page and its tests share them.
+ *
+ * Principle (docs/notification-center.md): everything except a hard gate keeps moving if nobody acts. Each entry says in words
+ * what happens next without the reader, and only a hard gate says "Waiting for you".
+ */
+import type { ReferenceRecord } from "./category-repository";
+import { getNewsroomNavHref } from "./newsroom-nav";
+import { referenceDisplayTitle, referenceLineageId } from "./newsroom-references";
+import { normalizeReferenceCurationStatus } from "./reference-policy";
+import type { RelevanceDecisionView } from "./relevance-decisions";
+
+export type ReviewMode = "flag" | "soft_review" | "hard_gate";
+export type ReviewState = "open" | "answered" | "timed_out" | "withdrawn";
+export type ReviewDecision = "approve" | "reject" | "feedback";
+export type ReviewSteer = "adjust" | "not_this_kind";
+
+export type ReviewAnswer = { decision: ReviewDecision; feedback: string | null; steer: ReviewSteer | null; by: string; at: string };
+export type ReviewHistoryEntry = { at: string; event: string; by?: string; note?: string };
+export type ReviewLink = { label?: string; url?: string; type?: string; id?: string };
+
+export type ReviewRequest = {
+  id: string;
+  subject: { type: string; id: string };
+  mode: ReviewMode;
+  reason: string;
+  ask: string | null;
+  raisedBy: string;
+  raisedAt: string;
+  deadline: string | null;
+  state: ReviewState;
+  answer: ReviewAnswer | null;
+  links: ReviewLink[];
+  history: ReviewHistoryEntry[];
+  appliedIn: { runId: string; by: string; at: string; note?: string | null } | null;
+  updatedAt: string;
+};
+
+export const PROCEEDED_WITHOUT_REVIEW = "proceeded without review";
+const MAX_HISTORY = 50;
+
+function parseJson<T>(value: unknown, fallback: T): T {
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value) as T;
+    } catch {
+      return fallback;
+    }
+  }
+  return value === null || value === undefined ? fallback : (value as T);
+}
+
+/** A row from the API (JSON fields arrive as strings) as a request. */
+export function normalizeReviewRow(row: Record<string, unknown>): ReviewRequest {
+  return {
+    id: String(row.id),
+    subject: parseJson(row.subject, { type: "unknown", id: "" }),
+    mode: row.mode as ReviewMode,
+    reason: String(row.reason ?? ""),
+    ask: typeof row.ask === "string" ? row.ask : null,
+    raisedBy: String(row.raisedBy ?? ""),
+    raisedAt: String(row.raisedAt ?? ""),
+    deadline: typeof row.deadline === "string" ? row.deadline : null,
+    state: row.state as ReviewState,
+    answer: parseJson<ReviewAnswer | null>(row.answer, null),
+    links: parseJson<ReviewLink[]>(row.links, []),
+    history: parseJson<ReviewHistoryEntry[]>(row.history, []),
+    appliedIn: parseJson(row.appliedIn, null),
+    updatedAt: String(row.updatedAt ?? row.raisedAt ?? ""),
+  };
+}
+
+// --- the deadline (checked on read) ---------------------------------------------------------------------
+
+export function isDue(request: ReviewRequest, now: Date): boolean {
+  return request.mode === "soft_review" && request.state === "open" && request.deadline !== null && new Date(request.deadline).getTime() <= now.getTime();
+}
+
+/** The update that marks a due soft review as timed out, "proceeded without review". Applied with the condition state = open. */
+export function timeoutUpdate(request: ReviewRequest, now: Date): Record<string, unknown> {
+  const at = now.toISOString();
+  const history = [...request.history, { at, event: "timed_out", by: "system", note: PROCEEDED_WITHOUT_REVIEW }].slice(-MAX_HISTORY);
+  return { id: request.id, state: "timed_out", updatedAt: at, history: JSON.stringify(history) };
+}
+
+export type AnswerInput = { decision: ReviewDecision; feedback?: string | null; steer?: ReviewSteer | null };
+
+/** The update for an answer, or an Error saying why it is refused. Applied with the condition state = open. */
+export function answerUpdate(request: ReviewRequest, input: AnswerInput, by: string, now: Date): Record<string, unknown> {
+  if (request.state !== "open") throw new Error(`This request is ${request.state.replace("_", " ")}${request.state === "timed_out" ? ` (${PROCEEDED_WITHOUT_REVIEW})` : ""} and can no longer be answered.`);
+  const feedback = input.feedback?.trim() || null;
+  const steer = input.steer ?? null;
+  if (input.decision === "feedback" && !feedback && !steer) throw new Error("Write a note, or choose \"Not this kind of thing\".");
+  const at = now.toISOString();
+  const answer: ReviewAnswer = { decision: input.decision, feedback, steer, by, at };
+  const history = [...request.history, { at, event: "answered", by, note: input.decision }].slice(-MAX_HISTORY);
+  return { id: request.id, state: "answered", answer: JSON.stringify(answer), updatedAt: at, history: JSON.stringify(history) };
+}
+
+// --- words ------------------------------------------------------------------------------------------------
+
+export function formatWhen(iso: string | null | undefined): string {
+  if (!iso) return "";
+  const date = new Date(iso);
+  if (Number.isNaN(date.getTime())) return "";
+  return `${date.toISOString().slice(0, 10)} ${date.toISOString().slice(11, 16)} UTC`;
+}
+
+export function modeLabel(mode: ReviewMode): string {
+  return mode === "hard_gate" ? "Hard gate" : mode === "soft_review" ? "Soft review" : "Flag";
+}
+
+/** A mark and the words, never colour alone. */
+export function modeMark(mode: ReviewMode): string {
+  return mode === "hard_gate" ? "■" : mode === "soft_review" ? "◐" : "⚑";
+}
+
+/** What happens next without the reader. Only a hard gate says "Waiting for you". */
+export function nextText(request: ReviewRequest): string {
+  if (request.state === "open") {
+    if (request.mode === "hard_gate") return "Waiting for you. Nothing continues until you approve or reject.";
+    if (request.mode === "soft_review") return `Proceeds automatically on ${formatWhen(request.deadline)} unless you steer it.`;
+    return "Nothing is waiting on this. It stays here until you acknowledge it.";
+  }
+  if (request.state === "timed_out") return `Proceeded without review on ${formatWhen(request.updatedAt)}.`;
+  if (request.state === "withdrawn") return "Withdrawn by the step that raised it.";
+  const answer = request.answer;
+  return answer ? `${answerWords(answer)} by ${answer.by} on ${formatWhen(answer.at)}.` : "Answered.";
+}
+
+export function answerWords(answer: ReviewAnswer): string {
+  if (answer.steer === "not_this_kind") return "Steered: not this kind of thing";
+  if (answer.decision === "approve") return "Approved";
+  if (answer.decision === "reject") return "Rejected";
+  return "Steered with a note";
+}
+
+/** "You steered X, applied in run Y": what became of a person's input. */
+export function steeringText(request: ReviewRequest): string | null {
+  const answer = request.answer;
+  if (request.state !== "answered" || !answer || !(answer.feedback || answer.steer || answer.decision === "reject")) return null;
+  const said = answer.feedback ? `"${answer.feedback}"` : answerWords(answer).toLowerCase();
+  if (request.appliedIn) return `You steered ${said}. Applied in run ${request.appliedIn.runId} on ${formatWhen(request.appliedIn.at)}.`;
+  return `You steered ${said}. ${request.raisedBy} has not used it yet; it will on its next run.`;
+}
+
+export function subjectHref(subject: { type: string; id: string }, demo = false): string | null {
+  const id = encodeURIComponent(subject.id);
+  if (subject.type === "story") return getNewsroomNavHref(`/newsroom/articles/${id}`, demo);
+  if (subject.type === "reference" || subject.type === "cyclotron_decision") return getNewsroomNavHref(`/newsroom/references/${id}`, demo);
+  if (subject.type === "proposal") return getNewsroomNavHref(`/newsroom/topics?proposal=${id}`, demo);
+  if (subject.type === "automation_run") return getNewsroomNavHref("/newsroom/administration/automations", demo);
+  return null;
+}
+
+// --- Cyclotron items ---------------------------------------------------------------------------------------
+
+export type CyclotronEntry = {
+  lineageId: string;
+  title: string;
+  label: string;
+  confidence: number | null;
+  decidedAt: string | null;
+  reviewDetail: string | null;
+  reviewedByPerson: boolean;
+  href: string;
+};
+
+function cyclotronEntry(reference: ReferenceRecord, decision: RelevanceDecisionView, reviewed: ReadonlySet<string>, demo: boolean): CyclotronEntry {
+  const lineageId = referenceLineageId(reference);
+  return {
+    lineageId, title: referenceDisplayTitle(reference), label: decision.label, confidence: decision.confidence,
+    decidedAt: decision.decidedAt, reviewDetail: decision.reviewDetail, reviewedByPerson: reviewed.has(lineageId),
+    href: getNewsroomNavHref(`/newsroom/references/${encodeURIComponent(lineageId)}`, demo),
+  };
+}
+
+/** Items the Cyclotron routed to a person (the References tab's own rule: review recommended and still pending). Least confident first. */
+export function cyclotronHeldForReview(references: ReferenceRecord[], decisions: ReadonlyMap<string, RelevanceDecisionView>, demo = false): CyclotronEntry[] {
+  const entries: CyclotronEntry[] = [];
+  for (const reference of references) {
+    const decision = decisions.get(referenceLineageId(reference));
+    if (decision?.reviewRecommended && normalizeReferenceCurationStatus(reference.curationStatus) === "pending") {
+      entries.push(cyclotronEntry(reference, decision, new Set(), demo));
+    }
+  }
+  return entries.sort((a, b) => (a.confidence ?? 1) - (b.confidence ?? 1));
+}
+
+/** Recent classifications the Cyclotron made on its own confidence. Read only here; correcting happens on the reference. Newest first. */
+export function cyclotronAutoDecided(references: ReferenceRecord[], decisions: ReadonlyMap<string, RelevanceDecisionView>, reviewed: ReadonlySet<string>, demo = false, limit = 20): CyclotronEntry[] {
+  const entries: CyclotronEntry[] = [];
+  for (const reference of references) {
+    const decision = decisions.get(referenceLineageId(reference));
+    if (decision && !decision.reviewRecommended) entries.push(cyclotronEntry(reference, decision, reviewed, demo));
+  }
+  return entries.sort((a, b) => (b.decidedAt ?? "").localeCompare(a.decidedAt ?? "")).slice(0, limit);
+}
+
+// --- the page's shape -------------------------------------------------------------------------------------------
+
+export type NotificationSections = {
+  hardGates: ReviewRequest[];
+  softReviews: ReviewRequest[];
+  flags: ReviewRequest[];
+  /** Answered, timed out or withdrawn, newest first: what people said and what became of it. */
+  decided: ReviewRequest[];
+};
+
+export function sectionReviews(requests: ReviewRequest[]): NotificationSections {
+  const open = requests.filter((request) => request.state === "open");
+  const byRaised = (a: ReviewRequest, b: ReviewRequest) => a.raisedAt.localeCompare(b.raisedAt);
+  return {
+    hardGates: open.filter((request) => request.mode === "hard_gate").sort(byRaised),
+    softReviews: open.filter((request) => request.mode === "soft_review").sort((a, b) => (a.deadline ?? "").localeCompare(b.deadline ?? "")),
+    flags: open.filter((request) => request.mode === "flag").sort((a, b) => b.raisedAt.localeCompare(a.raisedAt)),
+    decided: requests.filter((request) => request.state !== "open").sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)),
+  };
+}
+
+export type NotificationSummary = { waiting: number; proceedingSoon: number; decidedBySystem: number; unread: number };
+
+/**
+ * "N waiting for you · N proceeding soon · N recently decided by the system".
+ * Waiting = hard gates plus Cyclotron items held for review (both stay put until a person acts). Proceeding soon = open soft reviews.
+ */
+export function summarize(sections: NotificationSections, held: CyclotronEntry[], autoDecided: CyclotronEntry[], unread: number): NotificationSummary {
+  return { waiting: sections.hardGates.length + held.length, proceedingSoon: sections.softReviews.length, decidedBySystem: autoDecided.length, unread };
+}
+
+export function summaryText(summary: NotificationSummary): string {
+  return `${summary.waiting} waiting for you · ${summary.proceedingSoon} proceeding soon · ${summary.decidedBySystem} recently decided by the system`;
+}
+
+export function isUnread(request: ReviewRequest, readIds: ReadonlySet<string>): boolean {
+  return !readIds.has(request.id);
+}

package/package.json

@@ -76,6 +76,7 @@
     "./components/archive-shell": "./components/archive-shell.tsx",
     "./components/article-video": "./components/article-video.tsx",
     "./components/automation-panel": "./components/automation-panel.tsx",
+    "./components/automation-run-now": "./components/automation-run-now.tsx",
     "./components/automation-view": "./components/automation-view.tsx",
     "./components/blog-page-background": "./components/blog-page-background.tsx",
     "./components/curation-delegation-client": "./components/curation-delegation-client.ts",
@@ -114,6 +115,7 @@
     "./components/newsroom-theme-fonts/refined-newsprint": "./components/newsroom-theme-fonts/refined-newsprint.tsx",
     "./components/newsroom-theme": "./components/newsroom-theme.tsx",
     "./components/newsroom-topics-view": "./components/newsroom-topics-view.tsx",
+    "./components/notification-center": "./components/notification-center.tsx",
     "./components/papyrus-console-shell": "./components/papyrus-console-shell.tsx",
     "./components/pictogram-figure": "./components/pictogram-figure.tsx",
     "./components/presentation-footer": "./components/presentation-footer.tsx",
@@ -304,6 +306,9 @@
     "./lib/reporting-story-budget": "./lib/reporting-story-budget.ts",
     "./lib/revalidate-prewarm": "./lib/revalidate-prewarm.ts",
     "./lib/revalidate-secret": "./lib/revalidate-secret.ts",
+    "./lib/review-client": "./lib/review-client.ts",
+    "./lib/review-fixture": "./lib/review-fixture.ts",
+    "./lib/review-requests": "./lib/review-requests.ts",
     "./lib/robots-policy": "./lib/robots-policy.ts",
     "./lib/root-route-redirect": "./lib/root-route-redirect.ts",
     "./lib/semantic-graph": "./lib/semantic-graph.ts",
@@ -439,7 +444,7 @@
       "optional": true
     }
   },
-  "version": "5.32.0",
+  "version": "5.33.0",
   "dependencies": {
     "@aws-amplify/adapter-nextjs": "^1.7.3",
     "@aws-crypto/sha256-js": "5.2.0",

package/routes.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "5.32.0",
+  "version": "5.33.0",
   "routes": [
     {
       "file": "app/%5F_preview/[[...path]]/route.ts",