@anthusai/papyrus 5.31.0 → 5.33.0

package/amplify/plugins/reader-steering/config.ts

@@ -98,6 +98,14 @@ export type ReaderSteeringConfig = {
     /** Most links (http, https or www) in a comment. */
     maximumLinks: number;
   };
+  proposals: {
+    /**
+     * Publish every proposal, in every state (drafts included), as public `_data/proposals/` files in each snapshot run.
+     * Off by default: proposals stay private records until a site opts in. Turning it off stops further updates; it does not
+     * delete files already published.
+     */
+    publish: boolean;
+  };
   /**
    * The hype gap is `mean(plus dimensions) - mean(minus dimensions)`, computed for reader means and for editor scores.
    * Absent means no hype gap is published. The site names the dimensions in each group.
@@ -115,7 +123,7 @@ export type ReaderSteeringConfig = {
   retirementPoll: boolean;
 };
 
-const KNOWN_KEYS = new Set(["name", "computeRoleArn", "dimensions", "limits", "reservedHandles", "karma", "ranking", "snapshot", "retirementPoll", "reservedConcurrency", "hypeGap", "submissions", "comments", "moderation", "subjects"]);
+const KNOWN_KEYS = new Set(["name", "computeRoleArn", "dimensions", "limits", "reservedHandles", "karma", "ranking", "snapshot", "retirementPoll", "reservedConcurrency", "hypeGap", "submissions", "comments", "moderation", "subjects", "proposals"]);
 
 function object(raw: unknown, label: string, known: string[]): Record<string, unknown> {
   if (raw === undefined) return {};
@@ -217,6 +225,7 @@ export function resolveReaderSteeringConfig(request: PluginRequest): ReaderSteer
   if (!Array.isArray(subjectTypes) || subjectTypes.length === 0 || !subjectTypes.every((type) => (SUBJECT_TYPES as readonly unknown[]).includes(type))) {
     throw new Error(`reader-steering plugin subjects.types must be a non-empty list of: ${SUBJECT_TYPES.join(", ")}`);
   }
+  const proposals = object(raw.proposals, "proposals", ["publish"]);
   const kinds = names(submissions.kinds, "submissions.kinds", SUBMISSION_KIND_NAME);
   const comments = object(raw.comments, "comments", ["perHour", "editWindowMinutes", "maximumLength", "maximumLinks"]);
   const hypeGap = resolveHypeGap(raw.hypeGap, dimensions);
@@ -273,6 +282,7 @@ export function resolveReaderSteeringConfig(request: PluginRequest): ReaderSteer
       maximumLength: integer(comments.maximumLength, "comments.maximumLength", 2000, 1, 10000),
       maximumLinks: integer(comments.maximumLinks, "comments.maximumLinks", 3, 0, 50),
     },
+    proposals: { publish: flag(proposals.publish, "proposals.publish") },
     retirementPoll,
     ...(hypeGap ? { hypeGap } : {}),
     ...(raw.reservedConcurrency === undefined ? {} : { reservedConcurrency: integer(raw.reservedConcurrency, "reservedConcurrency", 1, 1, 1000) }),

package/amplify/plugins/reader-steering/papyrus.plugin.js

@@ -159,6 +159,8 @@ export const readerSteeringPlugin = {
         lambda.addEnvironment("PAPYRUS_READER_SNAPSHOT_FUNCTION_ARN", contentActions.functionArn);
         lambda.addEnvironment("PAPYRUS_READER_SCHEDULER_ROLE_ARN", schedulerRole.roleArn);
         contentActions.addEnvironment("PAPYRUS_READER_SNAPSHOT_SETTINGS", JSON.stringify(readerSnapshotSettings(config)));
+        // Proposals are private unless the site opts in (docs/reader-steering.md, Proposals); the snapshot reads this flag.
+        contentActions.addEnvironment("PAPYRUS_READER_PUBLISH_PROPOSALS", config.proposals.publish ? "true" : "false");
         if (config.moderation.ai)
             wireAiModeration(lambda, contentActions, schedulerRole, config.moderation.ai.apiKeyParameter);
         lambda.addPermission("InvokeFromCmsCompute", {

package/amplify/plugins/reader-steering/papyrus.plugin.ts

@@ -182,6 +182,8 @@ export const readerSteeringPlugin: PapyrusPlugin<ReaderSteeringConfig, { readerA
     lambda.addEnvironment("PAPYRUS_READER_SNAPSHOT_FUNCTION_ARN", contentActions.functionArn);
     lambda.addEnvironment("PAPYRUS_READER_SCHEDULER_ROLE_ARN", schedulerRole.roleArn);
     contentActions.addEnvironment("PAPYRUS_READER_SNAPSHOT_SETTINGS", JSON.stringify(readerSnapshotSettings(config)));
+    // Proposals are private unless the site opts in (docs/reader-steering.md, Proposals); the snapshot reads this flag.
+    contentActions.addEnvironment("PAPYRUS_READER_PUBLISH_PROPOSALS", config.proposals.publish ? "true" : "false");
 
     if (config.moderation.ai) wireAiModeration(lambda, contentActions, schedulerRole, config.moderation.ai.apiKeyParameter);
 

package/amplify/site-backend.js

@@ -22,6 +22,8 @@ import { applyCognitoDomainPrefix, authConfigFromEnv, defineSiteAuth, siteAuthRe
 import { PROSPECTUS_SIGN_IN_CALLBACK_PATH, addProspectusGoogleOnlyClient } from "./auth/prospectus-google-client.js";
 import { defineSiteData } from "./data/resource.js";
 import { editorialChecks } from "./functions/editorial-checks/resource.js";
+import { automationView } from "./functions/automation-view/resource.js";
+import { wireAutomationView } from "./functions/automation-view/wire.js";
 import { monitoringView } from "./functions/monitoring-view/resource.js";
 import { wireMonitoringView } from "./functions/monitoring-view/wire.js";
 import { wireEditorialChecks } from "./functions/editorial-checks/wire.js";
@@ -94,6 +96,7 @@ export function defineSiteBackend(papyrusSite) {
     const backend = defineBackend({
         ...pluginFunctions,
         assignmentAction,
+        automationView,
         auth: defineSiteAuth(authConfig),
         categoryAction,
         contentActions,
@@ -621,6 +624,7 @@ export function defineSiteBackend(papyrusSite) {
     });
     wireEditorialChecks(backend);
     wireMonitoringView(backend);
+    wireAutomationView(backend);
     wirePlugins(backend, plugins, contentActionsLambda);
     return backend;
 }

package/amplify/site-backend.ts

@@ -29,6 +29,8 @@ import { applyCognitoDomainPrefix, authConfigFromEnv, defineSiteAuth, siteAuthRe
 import { PROSPECTUS_SIGN_IN_CALLBACK_PATH, addProspectusGoogleOnlyClient } from "./auth/prospectus-google-client";
 import { defineSiteData } from "./data/resource";
 import { editorialChecks } from "./functions/editorial-checks/resource";
+import { automationView } from "./functions/automation-view/resource";
+import { wireAutomationView } from "./functions/automation-view/wire";
 import { monitoringView } from "./functions/monitoring-view/resource";
 import { wireMonitoringView } from "./functions/monitoring-view/wire";
 import { wireEditorialChecks } from "./functions/editorial-checks/wire";
@@ -115,6 +117,7 @@ export function defineSiteBackend(papyrusSite: PapyrusSite) {
   const backend = defineBackend({
     ...pluginFunctions,
     assignmentAction,
+    automationView,
     auth: defineSiteAuth(authConfig),
     categoryAction,
     contentActions,
@@ -766,6 +769,7 @@ export function defineSiteBackend(papyrusSite: PapyrusSite) {
   });
   wireEditorialChecks(backend);
   wireMonitoringView(backend);
+  wireAutomationView(backend);
   wirePlugins(backend, plugins, contentActionsLambda);
 
   return backend;

package/components/automation-panel.tsx

@@ -0,0 +1,49 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { loadAutomationOverview, runAutomationNow } from "../lib/automation-client";
+import { FIXTURE_AUTOMATION_OVERVIEW } from "../lib/automation-fixture";
+import type { AutomationResult } from "../lib/automation-overview";
+import { AutomationView } from "./automation-view";
+
+const REFRESH_MILLISECONDS = 60_000;
+
+/** Administration, Automation: loads the records and their recent runs, and refreshes each minute. */
+export function AutomationPanel({ isDemo }: { isDemo: boolean }) {
+  const [result, setResult] = useState<AutomationResult | null>(null);
+  const [selectedId, setSelectedId] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (isDemo) {
+      setResult(FIXTURE_AUTOMATION_OVERVIEW);
+      return;
+    }
+    let live = true;
+    const refresh = async () => {
+      try {
+        const next = await loadAutomationOverview();
+        if (live) setResult(next);
+      } catch {
+        if (live) setResult({ state: "unavailable" });
+      }
+    };
+    void refresh();
+    const timer = window.setInterval(() => void refresh(), REFRESH_MILLISECONDS);
+    return () => {
+      live = false;
+      window.clearInterval(timer);
+    };
+  }, [isDemo]);
+
+  const runNow = isDemo ? undefined : async (automationId: string, input: Record<string, unknown> | null) => {
+    const outcome = await runAutomationNow(automationId, input);
+    try {
+      setResult(await loadAutomationOverview());   // show the new run without waiting for the minute
+    } catch {
+      /* the next refresh will */
+    }
+    return outcome;
+  };
+
+  return <AutomationView result={result} selectedId={selectedId} onSelect={setSelectedId} demo={isDemo} onRunNow={runNow} />;
+}

package/components/automation-run-now.tsx

@@ -0,0 +1,97 @@
+"use client";
+
+import { useState } from "react";
+import {
+  atATimeText,
+  inputTemplateText,
+  parseRunInput,
+  runNowMessage,
+  type AutomationRecord,
+  type RunNowResult,
+} from "../lib/automation-overview";
+
+export type RunNowPhase = "idle" | "confirming" | "running" | "done";
+
+/**
+ * "Run now": a button, then a confirm step that says what will start and, when the record's input names
+ * placeholders for an item, asks for the input of this run. Starting costs money (the procedure calls a model),
+ * so nothing starts on the first click. `initialPhase` and `initialMessage` exist so every step renders from a test.
+ */
+export function RunNowControl({
+  record,
+  demo = false,
+  onRun,
+  initialPhase = "idle",
+  initialMessage = null,
+}: {
+  record: Pick<AutomationRecord, "id" | "title" | "procedureKey" | "runNow" | "limits">;
+  demo?: boolean;
+  onRun?: (automationId: string, input: Record<string, unknown> | null) => Promise<RunNowResult>;
+  initialPhase?: RunNowPhase;
+  initialMessage?: string | null;
+}) {
+  const [phase, setPhase] = useState<RunNowPhase>(initialPhase);
+  const [message, setMessage] = useState<string | null>(initialMessage);
+  const [text, setText] = useState(record.runNow.needsInput ? inputTemplateText(record.runNow.inputNames) : "");
+  const [problem, setProblem] = useState<string | null>(null);
+
+  if (!record.runNow.available) {
+    return (
+      <p className="news-desk-delegation-note" data-automation-run-now-unavailable>
+        Run now is not available: {record.runNow.reason === "disabled" ? "the automation is disabled. Enable it first." : (record.runNow.reason ?? "not supported")}.
+      </p>
+    );
+  }
+
+  async function confirm() {
+    const parsed = parseRunInput(text);
+    if (!parsed.ok) {
+      setProblem(parsed.message);
+      return;
+    }
+    if (record.runNow.needsInput && parsed.value === null) {
+      setProblem("This automation's input names an item, so give the input for this run.");
+      return;
+    }
+    setProblem(null);
+    setPhase("running");
+    try {
+      const result = onRun ? await onRun(record.id, parsed.value) : ({ state: "unavailable" } as RunNowResult);
+      setMessage(runNowMessage(result));
+    } catch {
+      setMessage(runNowMessage({ state: "unavailable" }));
+    }
+    setPhase("done");
+  }
+
+  return (
+    <div data-automation-run-now={record.id} data-run-now-phase={phase}>
+      {phase === "idle" || phase === "done" ? (
+        <button type="button" data-automation-run-now-start onClick={() => { setMessage(null); setPhase("confirming"); }}>
+          Run now
+        </button>
+      ) : null}
+      {phase === "confirming" || phase === "running" ? (
+        <div role="group" aria-label={`Confirm Run now for ${record.title}`} data-automation-run-now-confirm>
+          <p>
+            Run <strong>{record.procedureKey}</strong> now? It calls a model, which costs money, and it counts against the
+            limit ({atATimeText(record.limits)}). The run is linked to this automation.
+          </p>
+          {demo ? <p className="news-desk-delegation-note">This is the demo, so nothing will start.</p> : null}
+          <label>
+            Input for this run{record.runNow.needsInput ? " (required)" : " (optional; blank uses the record's input)"}
+            <textarea rows={4} value={text} onChange={(event) => setText(event.target.value)} disabled={phase === "running"} data-automation-run-now-input />
+          </label>
+          {problem ? <p role="alert" data-automation-run-now-problem>{problem}</p> : null}
+          <button type="button" onClick={() => void confirm()} disabled={phase === "running" || demo} data-automation-run-now-confirm-button>
+            {phase === "running" ? "Starting…" : "Confirm: start the run"}
+          </button>{" "}
+          <button type="button" onClick={() => { setPhase("idle"); setProblem(null); }} disabled={phase === "running"} data-automation-run-now-cancel>
+            Cancel
+          </button>
+        </div>
+      ) : null}
+      {message ? <p role="status" data-automation-run-now-message>{message}</p> : null}
+    </div>
+  );
+}

package/components/automation-view.tsx

@@ -0,0 +1,192 @@
+import Link from "next/link";
+import { RunNowControl } from "./automation-run-now";
+import {
+  ENABLED_NOTE,
+  OUTSIDE_NOTICE,
+  atATimeText,
+  costText,
+  durationText,
+  enabledText,
+  formatUtc,
+  linkText,
+  noticeText,
+  proceduresHref,
+  statusMark,
+  statusText,
+  storyHref,
+  triggerText,
+  whoText,
+  type AutomationOutsideRun,
+  type AutomationRecord,
+  type AutomationResult,
+  type AutomationRun,
+  type RunNowResult,
+} from "../lib/automation-overview";
+
+function Message({ title, children, kind }: { title: string; children?: React.ReactNode; kind: string }) {
+  return (
+    <div className="category-steering-empty" role={kind === "loading" ? "status" : "alert"} data-automation-state={kind}>
+      <strong>{title}</strong>
+      {children ? <p>{children}</p> : null}
+    </div>
+  );
+}
+
+function RunLine({ run, demo }: { run: AutomationRun; demo: boolean }) {
+  return (
+    <li data-automation-run={run.runId ?? run.sourceId ?? "unlinked"} data-run-status={run.status ?? "unknown"}>
+      <strong>{formatUtc(run.startedAt)}</strong>
+      <span><span aria-hidden="true">{statusMark(run.status)} </span>Status: {statusText(run.status)} &middot; {durationText(run.durationSeconds)}</span>
+      <span>{whoText(run)}</span>
+      {run.reason ? <span data-automation-run-reason>Reason: {run.reason}</span> : null}
+      {run.error ? <span data-automation-run-error>Error: {run.error}</span> : null}
+      <span>
+        {run.runId ? <>Run {run.runId} (<Link href={proceduresHref(demo)}>Procedures</Link>)</> : run.triggerStatus === "started" ? "Run record not linked yet" : "No run record"}
+        {run.runRecord === "missing" ? " (the run record was not found)" : ""}
+        {run.runRecord === "unavailable" ? " (the run record could not be read)" : ""}
+      </span>
+      <span>
+        {run.storyId ? <>Story: <Link href={storyHref(run.storyId, demo)} data-automation-story-link>{run.storyTitle ?? run.storyId}</Link></> : "Story: none recorded"}
+      </span>
+      <span data-automation-run-cost data-over-budget={run.overBudget || undefined}>
+        <span aria-hidden="true">{run.overBudget ? "! " : ""}</span>{costText(run)}
+      </span>
+    </li>
+  );
+}
+
+function OutsideRunLine({ run, demo }: { run: AutomationOutsideRun; demo: boolean }) {
+  return (
+    <li data-automation-outside-run={run.runId ?? "unlinked"} data-run-status={run.status ?? "unknown"}>
+      <strong>{formatUtc(run.startedAt)}</strong>
+      <span><span aria-hidden="true">{statusMark(run.status)} </span>Status: {statusText(run.status)} &middot; {durationText(run.durationSeconds)}</span>
+      <span>Started by: {run.requestedBy ?? "unknown"}</span>
+      {run.error ? <span data-automation-run-error>Error: {run.error}</span> : null}
+      <span>{run.runId ? <>Run {run.runId} (<Link href={proceduresHref(demo)}>Procedures</Link>)</> : "No run id"}</span>
+      <span>
+        {run.storyId ? <>Story: <Link href={storyHref(run.storyId, demo)}>{run.storyTitle ?? run.storyId}</Link></> : "Story: none recorded"}
+      </span>
+      <span data-automation-run-cost>{costText({ ...run, budgetUsd: null })}</span>
+    </li>
+  );
+}
+
+function Detail({ record, demo, onRunNow }: { record: AutomationRecord; demo: boolean; onRunNow?: RunNowHandler }) {
+  const notice = noticeText(record.notice);
+  return (
+    <article className="news-desk-doctrine-card" data-automation-detail={record.id}>
+      <div className="news-desk-doctrine-card__header"><div><h3>{record.title}</h3><span>{record.description ?? record.id}</span></div></div>
+      <dl className="news-desk-monitoring__usage">
+        <div><dt>Trigger</dt><dd>{triggerText(record.trigger)}{record.supported ? "" : ` (${record.supportNote ?? "not yet supported"})`}</dd></div>
+        <div><dt>Procedure</dt><dd>{record.procedureKey}</dd></div>
+        <div><dt>Input</dt><dd>{Object.keys(record.inputTemplate).length ? Object.entries(record.inputTemplate).map(([name, template]) => `${name} = ${template}`).join("; ") : "none"}</dd></div>
+        <div><dt>Enabled</dt><dd>{enabledText(record)} ({ENABLED_NOTE})</dd></div>
+        <div><dt>Limits</dt><dd>timeout {record.limits.timeoutSeconds ?? "?"} s, {atATimeText(record.limits)}{record.limits.budgetUsdPerRun !== undefined ? `, about $${record.limits.budgetUsdPerRun} per run, advisory` : ""} ({record.limitsNote})</dd></div>
+        <div><dt>Router</dt><dd data-automation-link={record.link?.state ?? "unchecked"}>{linkText(record.link)}</dd></div>
+      </dl>
+      {notice ? <p className="news-desk-delegation-note" data-automation-notice>{notice}</p> : null}
+      <RunNowControl record={record} demo={demo} onRun={onRunNow} />
+      <h4>Recent runs</h4>
+      {record.runs.length ? (
+        <ul className="news-desk-monitoring__list" data-automation-runs>
+          {record.runs.map((run) => <RunLine key={run.runId ?? `${run.sourceId}-${run.startedAt}`} run={run} demo={demo} />)}
+        </ul>
+      ) : <p data-automation-no-runs>No runs yet.</p>}
+      {record.skippedAlreadyHadReference > 0 ? (
+        <p className="news-desk-delegation-note" data-automation-skipped>
+          {record.skippedAlreadyHadReference} {record.skippedAlreadyHadReference === 1 ? "item was" : "items were"} not started because the Reference already existed.
+        </p>
+      ) : null}
+      {record.outsideRuns.length || record.outsideNotice ? (
+        <>
+          <h4>Started outside this automation</h4>
+          <p className="news-desk-delegation-note">Other runs of {record.procedureKey} that this automation did not start.</p>
+          {record.outsideNotice ? <p className="news-desk-delegation-note" data-automation-notice>{OUTSIDE_NOTICE}</p> : null}
+          {record.outsideRuns.length ? (
+            <ul className="news-desk-monitoring__list" data-automation-outside-runs>
+              {record.outsideRuns.map((run) => <OutsideRunLine key={run.runId ?? run.startedAt ?? "run"} run={run} demo={demo} />)}
+            </ul>
+          ) : null}
+        </>
+      ) : null}
+    </article>
+  );
+}
+
+function ListItem({ record, selected, onSelect }: { record: AutomationRecord; selected: boolean; onSelect: (id: string) => void }) {
+  const last = record.lastRun;
+  return (
+    <li data-automation={record.id}>
+      <div>
+        <strong>{record.title}</strong>
+        <span>{triggerText(record.trigger)}{record.supported ? "" : ` (${record.supportNote ?? "not yet supported"})`}</span>
+      </div>
+      <span>Procedure: {record.procedureKey}</span>
+      <span>{enabledText(record)} ({ENABLED_NOTE})</span>
+      <span data-automation-last-run>
+        Last run: <span aria-hidden="true">{statusMark(last?.status)} </span>{statusText(last?.status)}{last ? `, ${formatUtc(last.startedAt)}` : ""}
+      </span>
+      <button type="button" aria-pressed={selected} data-automation-select={record.id} onClick={() => onSelect(record.id)}>
+        {selected ? "Showing runs" : "Show runs"}
+      </button>
+    </li>
+  );
+}
+
+/** Presentation only: the panel fetches, this renders any result, so every state is testable from fixtures. */
+export type RunNowHandler = (automationId: string, input: Record<string, unknown> | null) => Promise<RunNowResult>;
+
+export function AutomationView({
+  result,
+  selectedId,
+  onSelect,
+  demo = false,
+  onRunNow,
+}: {
+  result: AutomationResult | null;
+  selectedId: string | null;
+  onSelect: (id: string) => void;
+  demo?: boolean;
+  onRunNow?: RunNowHandler;
+}) {
+  let body: React.ReactNode;
+  if (result === null) {
+    body = <Message kind="loading" title="Loading automations" />;
+  } else if ("error" in result) {
+    body = result.error === "forbidden"
+      ? <Message kind="forbidden" title="Automations are for editors and admins">Your account does not have access to this page. Ask an admin for the editor role.</Message>
+      : <Message kind="error" title="Automations could not be read">The request was not understood. Reload the page.</Message>;
+  } else if (result.state === "unavailable") {
+    body = <Message kind="unavailable" title="Automations could not be read right now">Nothing is affected. Try again in a minute.</Message>;
+  } else if (result.state === "empty") {
+    body = <Message kind="empty" title="No automations yet">An operator creates one with <code>papyrus automations create</code>. Nothing is configured to run on its own from this page.</Message>;
+  } else {
+    const selected = result.automations.find((record) => record.id === selectedId) ?? (result.automations.length === 1 ? result.automations[0] : null);
+    body = (
+      <>
+        <article className="news-desk-doctrine-card" data-automation-section="list">
+          <div className="news-desk-doctrine-card__header"><div><h3>Automations</h3><span>What starts a procedure by itself</span></div></div>
+          <ul className="news-desk-monitoring__list">
+            {result.automations.map((record) => <ListItem key={record.id} record={record} selected={selected?.id === record.id} onSelect={onSelect} />)}
+          </ul>
+          {result.monitoring === "not_configured" ? <p className="news-desk-delegation-note" data-automation-notice>{noticeText("monitoring_not_configured")}</p> : null}
+        </article>
+        {selected ? <Detail record={selected} demo={demo} onRunNow={onRunNow} /> : <p className="news-desk-delegation-note" data-automation-pick>Choose an automation to see its recent runs.</p>}
+      </>
+    );
+  }
+  return (
+    <div data-news-desk-admin-panel="automations">
+      <article className="news-desk-doctrine-card">
+        <div className="news-desk-doctrine-card__header">
+          <div>
+            <h3>Automation</h3>
+            <span>Procedures that start on their own. Editors and admins can run one now; an operator changes the settings with the command line.</span>
+          </div>
+        </div>
+        {result && "asOf" in result ? <p className="news-desk-delegation-note" data-automation-as-of>As of {formatUtc(result.asOf)}. Enabled: {ENABLED_NOTE}.</p> : null}
+      </article>
+      {body}
+    </div>
+  );
+}

package/components/newsroom-ops-overview.tsx

@@ -33,15 +33,23 @@ import {
   sortNewsroomSections,
 } from "../lib/newsroom-sections";
 import { newsroomInboxRowClassName } from "../lib/newsroom-list-selection";
+import type { RelevanceDecisionView } from "../lib/relevance-decisions";
+import { NotificationCenter } from "./notification-center";
 
 type NewsroomOpsOverviewProps = {
   assignments: AssignmentRecord[];
+  actorLabel?: string;
+  decisions?: ReadonlyMap<string, RelevanceDecisionView>;
   demo?: boolean;
+  humanCuratedReferenceLineageIds?: ReadonlySet<string>;
   messages: MessageRecord[];
   newsroomSections: NewsroomSectionRecord[];
   references: ReferenceRecord[];
 };
 
+const NO_DECISIONS: ReadonlyMap<string, RelevanceDecisionView> = new Map();
+const NO_IDS: ReadonlySet<string> = new Set();
+
 type DestinationKey = Exclude<NewsroomNavTabId, "overview" | "desks">;
 
 const DESTINATION_ICONS: Record<DestinationKey, typeof BookOpenIcon> = {
@@ -75,8 +83,11 @@ function recentMessageCount(messages: MessageRecord[]): number {
 }
 
 export function NewsroomOpsOverview({
+  actorLabel = "",
   assignments,
+  decisions = NO_DECISIONS,
   demo = false,
+  humanCuratedReferenceLineageIds = NO_IDS,
   messages,
   newsroomSections,
   references,
@@ -117,6 +128,13 @@ export function NewsroomOpsOverview({
       data-newsroom-ops-home="true"
     >
       <div className="space-y-8" data-newsroom-overview-feeds>
+        <NotificationCenter
+          actorLabel={actorLabel}
+          decisions={decisions}
+          demo={demo}
+          humanCuratedReferenceLineageIds={humanCuratedReferenceLineageIds}
+          references={canonicalReferences}
+        />
         <section aria-label="Destinations" className="space-y-3">
           <h2 className="text-sm font-medium text-muted-foreground">Go to</h2>
           <div className="grid grid-cols-2 gap-3 sm:grid-cols-4">