@anthusai/papyrus 5.32.0 → 5.33.1

package/components/automation-view.tsx

@@ -1,6 +1,10 @@
 import Link from "next/link";
+import { RunNowControl } from "./automation-run-now";
 import {
   ENABLED_NOTE,
+  OUTSIDE_NOTICE,
+  atATimeText,
+  costText,
   durationText,
   enabledText,
   formatUtc,
@@ -11,9 +15,12 @@ import {
   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 }) {
@@ -30,7 +37,8 @@ function RunLine({ run, demo }: { run: AutomationRun; demo: boolean }) {
     <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>Item: {run.sourceId ?? "unknown"}</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"}
@@ -40,12 +48,30 @@ function RunLine({ run, demo }: { run: AutomationRun; demo: boolean }) {
       <span>
         {run.storyId ? <>Story: <Link href={storyHref(run.storyId, demo)} data-automation-story-link>{run.storyTitle ?? run.storyId}</Link></> : "Story: none recorded"}
       </span>
-      <span>Cost: unknown ({run.costNote})</span>
+      <span data-automation-run-cost data-over-budget={run.overBudget || undefined}>
+        <span aria-hidden="true">{run.overBudget ? "! " : ""}</span>{costText(run)}
+      </span>
     </li>
   );
 }
 
-function Detail({ record, demo }: { record: AutomationRecord; demo: boolean }) {
+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}>
@@ -55,10 +81,11 @@ function Detail({ record, demo }: { record: AutomationRecord; demo: boolean }) {
         <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, {record.limits.maxConcurrent ?? "?"} at a time{record.limits.budgetUsdPerRun !== undefined ? `, about $${record.limits.budgetUsdPerRun} per run` : ""} ({record.limitsNote})</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>
@@ -70,6 +97,18 @@ function Detail({ record, demo }: { record: AutomationRecord; demo: boolean }) {
           {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>
   );
 }
@@ -95,16 +134,20 @@ function ListItem({ record, selected, onSelect }: { record: AutomationRecord; se
 }
 
 /** 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) {
@@ -128,7 +171,7 @@ export function AutomationView({
           </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} /> : <p className="news-desk-delegation-note" data-automation-pick>Choose an automation to see its recent runs.</p>}
+        {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>}
       </>
     );
   }
@@ -138,10 +181,10 @@ export function AutomationView({
         <div className="news-desk-doctrine-card__header">
           <div>
             <h3>Automation</h3>
-            <span>Procedures that start on their own. Read only here; an operator changes them with the command line.</span>
+            <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)}. The enabled setting is {ENABLED_NOTE}.</p> : null}
+        {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">

package/components/notification-center.tsx

@@ -0,0 +1,262 @@
+"use client";
+
+import Link from "next/link";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { Badge } from "./ui/badge";
+import { Button } from "./ui/button";
+import { getNewsroomNavHref } from "../lib/newsroom-nav";
+import {
+  cyclotronAutoDecided, cyclotronHeldForReview, formatWhen, isUnread, modeLabel, modeMark, nextText, sectionReviews,
+  steeringText, subjectHref, summarize, summaryText,
+  type AnswerInput, type CyclotronEntry, type ReviewRequest,
+} from "../lib/review-requests";
+import type { ReferenceRecord } from "../lib/category-repository";
+import type { RelevanceDecisionView } from "../lib/relevance-decisions";
+import { FIXTURE_REVIEW_REQUESTS } from "../lib/review-fixture";
+
+export type NotificationLoadState = "loading" | "ready" | "forbidden" | "unavailable";
+
+type ViewProps = {
+  loadState: NotificationLoadState;
+  requests: ReviewRequest[];
+  readIds: ReadonlySet<string>;
+  held: CyclotronEntry[];
+  autoDecided: CyclotronEntry[];
+  demo?: boolean;
+  busyId?: string | null;
+  error?: string | null;
+  onAnswer?: (request: ReviewRequest, input: AnswerInput) => void;
+  onMarkRead?: (requestId: string) => void;
+  onMarkAllRead?: () => void;
+};
+
+function Entry({ request, unread, demo, busy, onAnswer, onMarkRead }: {
+  request: ReviewRequest; unread: boolean; demo: boolean; busy: boolean;
+  onAnswer?: ViewProps["onAnswer"]; onMarkRead?: ViewProps["onMarkRead"];
+}) {
+  const [note, setNote] = useState("");
+  const href = subjectHref(request.subject, demo);
+  const open = request.state === "open";
+  const steering = steeringText(request);
+  const act = (input: AnswerInput) => onAnswer?.(request, { ...input, feedback: input.feedback ?? (note.trim() || null) });
+  return (
+    <li className="rounded-lg border p-3 space-y-2" data-review-request={request.id} data-review-mode={request.mode} data-review-state={request.state} data-review-unread={unread || undefined}>
+      <div className="flex flex-wrap items-center gap-2">
+        <Badge variant="outline"><span aria-hidden="true">{modeMark(request.mode)} </span>{modeLabel(request.mode)}</Badge>
+        {unread ? <Badge variant="default"><span aria-hidden="true">● </span>New</Badge> : <span className="text-xs text-muted-foreground">Read</span>}
+        <strong className="text-sm">{request.reason}</strong>
+      </div>
+      <p className="text-xs text-muted-foreground">
+        Raised by {request.raisedBy} on {formatWhen(request.raisedAt)}
+        {" · "}About: {href ? <Link href={href} onClick={() => onMarkRead?.(request.id)}>{request.subject.type.replace("_", " ")} {request.subject.id}</Link> : <span>{request.subject.type} {request.subject.id}</span>}
+      </p>
+      {request.ask ? <p className="text-sm">{request.ask}</p> : null}
+      {request.links.length ? (
+        <ul className="text-xs space-y-0.5" aria-label="Items in this request">
+          {request.links.slice(0, 10).map((link, index) => {
+            const target = link.url ?? (link.type ? subjectHref({ type: link.type, id: link.id ?? "" }, demo) : null);
+            return <li key={`${link.id ?? link.url}-${index}`}>{target ? <Link href={target}>{link.label ?? link.id ?? link.url}</Link> : (link.label ?? link.id)}</li>;
+          })}
+          {request.links.length > 10 ? <li>and {request.links.length - 10} more</li> : null}
+        </ul>
+      ) : null}
+      <p className="text-sm" data-review-next>{nextText(request)}</p>
+      {steering ? <p className="text-sm" data-review-steering>{steering}</p> : null}
+      {open ? (
+        <div className="space-y-2" data-review-controls>
+          <label className="block text-xs text-muted-foreground">
+            Steering note (optional)
+            <textarea
+              className="mt-1 block w-full rounded-md border bg-background p-2 text-sm"
+              disabled={busy}
+              onChange={(event) => setNote(event.target.value)}
+              placeholder={request.mode === "flag" ? "Tell the step what to do differently" : "What should change, or what did you want instead?"}
+              rows={2}
+              value={note}
+            />
+          </label>
+          <div className="flex flex-wrap gap-2">
+            {request.mode === "flag" ? (
+              <Button disabled={busy} onClick={() => act({ decision: "approve" })} size="sm" variant="outline">Acknowledge</Button>
+            ) : (
+              <>
+                <Button disabled={busy} onClick={() => act({ decision: "approve" })} size="sm" variant="outline">Approve</Button>
+                <Button disabled={busy} onClick={() => act({ decision: "reject" })} size="sm" variant="outline">Reject</Button>
+              </>
+            )}
+            <Button disabled={busy || !note.trim()} onClick={() => act({ decision: "feedback", steer: "adjust" })} size="sm" variant="outline">Steer with this note</Button>
+            <Button disabled={busy} onClick={() => act({ decision: "feedback", steer: "not_this_kind" })} size="sm" variant="outline">Not this kind of thing</Button>
+            {unread ? <Button disabled={busy} onClick={() => onMarkRead?.(request.id)} size="sm" variant="ghost">Mark read</Button> : null}
+          </div>
+        </div>
+      ) : unread ? (
+        <Button disabled={busy} onClick={() => onMarkRead?.(request.id)} size="sm" variant="ghost">Mark read</Button>
+      ) : null}
+    </li>
+  );
+}
+
+function CyclotronLine({ entry, held }: { entry: CyclotronEntry; held: boolean }) {
+  const confidence = entry.confidence === null ? "confidence not recorded" : `confidence ${Math.round(entry.confidence * 100)}%`;
+  return (
+    <li className="rounded-lg border p-3 space-y-1" data-cyclotron-entry={entry.lineageId} data-cyclotron-held={held || undefined}>
+      <div className="flex flex-wrap items-center gap-2">
+        <Badge variant="outline"><span aria-hidden="true">{held ? "◔" : "✓"} </span>{held ? "Held for review" : "Decided by the system"}</Badge>
+        <strong className="text-sm">{entry.title}</strong>
+      </div>
+      <p className="text-xs text-muted-foreground">
+        Classified as {entry.label} · {confidence}{entry.decidedAt ? ` · ${formatWhen(entry.decidedAt)}` : ""}
+        {entry.reviewedByPerson ? " · reviewed by a person" : ""}
+      </p>
+      {held ? <p className="text-sm">{entry.reviewDetail ? `${entry.reviewDetail}. ` : ""}Held for review: it stays pending until someone decides.</p> : null}
+      <Link className="text-sm" href={entry.href}>{held ? "Review it in References" : "Open it in References to correct it"}</Link>
+    </li>
+  );
+}
+
+function Section({ id, title, count, children, empty }: { id: string; title: string; count: number; children: React.ReactNode; empty: string }) {
+  return (
+    <section aria-labelledby={`notification-${id}`} className="space-y-2" data-notification-section={id}>
+      <h2 className="text-sm font-medium" id={`notification-${id}`}>{title} ({count})</h2>
+      {count ? children : <p className="text-sm text-muted-foreground">{empty}</p>}
+    </section>
+  );
+}
+
+/** The CMS console home: what needs a person, what will proceed on its own, and what the system decided. Ignore-safe by design. */
+export function NotificationCenterView({ loadState, requests, readIds, held, autoDecided, demo = false, busyId = null, error = null, onAnswer, onMarkRead, onMarkAllRead }: ViewProps) {
+  const sections = useMemo(() => sectionReviews(requests), [requests]);
+  const unreadCount = requests.filter((request) => isUnread(request, readIds)).length;
+  const summary = summarize(sections, held, autoDecided, unreadCount);
+  const entry = (request: ReviewRequest) => (
+    <Entry busy={busyId === request.id} demo={demo} key={request.id} onAnswer={onAnswer} onMarkRead={onMarkRead} request={request} unread={isUnread(request, readIds)} />
+  );
+  if (loadState === "loading") return <div role="status" data-notification-state="loading"><strong>Loading the Notification Center</strong></div>;
+  if (loadState === "forbidden") return <div role="alert" data-notification-state="forbidden"><strong>The Notification Center is for editors and admins</strong></div>;
+  if (loadState === "unavailable") return <div role="alert" data-notification-state="unavailable"><strong>Review requests could not be read right now</strong><p>Try again in a minute. Nothing waiting on a person has changed.</p></div>;
+  return (
+    <div className="space-y-6" data-notification-center>
+      <header className="space-y-1">
+        <h1 className="text-lg font-semibold">Notification Center</h1>
+        <p className="text-sm" data-notification-summary>{summaryText(summary)}</p>
+        <p className="text-xs text-muted-foreground">
+          Look, or steer. Anything you ignore keeps going: soft reviews proceed at their deadline and flags never wait. Only a hard gate waits for you.
+        </p>
+        <p className="text-xs text-muted-foreground" data-notification-unread>
+          {unreadCount ? `${unreadCount} unread` : "Nothing unread"}
+          {unreadCount ? <Button className="ml-2" onClick={onMarkAllRead} size="sm" variant="ghost">Mark all read</Button> : null}
+        </p>
+        {error ? <p role="alert" className="text-sm" data-notification-error>{error}</p> : null}
+      </header>
+
+      <Section count={sections.hardGates.length} empty="No hard gates. Nothing is blocked on you." id="hard-gates" title="Waiting for you: hard gates">
+        <ul className="space-y-2">{sections.hardGates.map(entry)}</ul>
+      </Section>
+      <Section count={sections.softReviews.length} empty="No soft reviews are running." id="soft-reviews" title="Proceeding soon: soft reviews, soonest deadline first">
+        <ul className="space-y-2">{sections.softReviews.map(entry)}</ul>
+      </Section>
+      <Section count={held.length} empty="No Cyclotron items are held for review." id="cyclotron" title="Cyclotron items routed to a person (low confidence)">
+        <ul className="space-y-2">{held.slice(0, 10).map((item) => <CyclotronLine entry={item} held key={item.lineageId} />)}</ul>
+        {held.length > 10 ? <p className="text-sm">and {held.length - 10} more. <Link href={getNewsroomNavHref("/newsroom/references", demo)}>See all in References</Link></p> : null}
+      </Section>
+      <Section count={sections.flags.length} empty="No flags." id="flags" title="Flags: for your information">
+        <ul className="space-y-2">{sections.flags.map(entry)}</ul>
+      </Section>
+      <Section count={sections.decided.length} empty="Nothing answered or proceeded yet." id="decided" title="Answered, and what became of it">
+        <ul className="space-y-2">{sections.decided.slice(0, 20).map(entry)}</ul>
+      </Section>
+      <details data-notification-section="auto-decided">
+        <summary className="cursor-pointer text-sm font-medium">Recently decided by the system ({autoDecided.length})</summary>
+        <div className="mt-2 space-y-2">
+          <p className="text-xs text-muted-foreground">Read only. The Cyclotron was confident enough to decide these without you. To correct one, open it in References.</p>
+          {autoDecided.length ? <ul className="space-y-2">{autoDecided.map((item) => <CyclotronLine entry={item} held={false} key={item.lineageId} />)}</ul> : <p className="text-sm text-muted-foreground">No automatic decisions yet.</p>}
+        </div>
+      </details>
+    </div>
+  );
+}
+
+type ContainerProps = {
+  references: ReferenceRecord[];
+  decisions: ReadonlyMap<string, RelevanceDecisionView>;
+  humanCuratedReferenceLineageIds: ReadonlySet<string>;
+  actorLabel: string;
+  demo: boolean;
+};
+
+const REFRESH_MILLISECONDS = 60_000;
+
+export function NotificationCenter({ references, decisions, humanCuratedReferenceLineageIds, actorLabel, demo }: ContainerProps) {
+  const [loadState, setLoadState] = useState<NotificationLoadState>("loading");
+  const [requests, setRequests] = useState<ReviewRequest[]>([]);
+  const [readIds, setReadIds] = useState<Set<string>>(new Set());
+  const [userKey, setUserKey] = useState<string | null>(null);
+  const [busyId, setBusyId] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  const refresh = useCallback(async () => {
+    if (demo) {
+      setRequests(FIXTURE_REVIEW_REQUESTS);
+      setReadIds(new Set(["rr-flag-1"]));
+      setLoadState("ready");
+      return;
+    }
+    try {
+      const { loadReviews } = await import("../lib/review-client");
+      const loaded = await loadReviews();
+      if (loaded.state !== "ready") {
+        setLoadState(loaded.state);
+        return;
+      }
+      setRequests(loaded.requests);
+      setReadIds(new Set(loaded.readIds));
+      setUserKey(loaded.userKey);
+      setLoadState("ready");
+    } catch {
+      setLoadState("unavailable");
+    }
+  }, [demo]);
+
+  useEffect(() => {
+    void refresh();
+    const timer = window.setInterval(() => void refresh(), REFRESH_MILLISECONDS);
+    return () => window.clearInterval(timer);
+  }, [refresh]);
+
+  const held = useMemo(() => cyclotronHeldForReview(references, decisions, demo), [references, decisions, demo]);
+  const autoDecided = useMemo(() => cyclotronAutoDecided(references, decisions, humanCuratedReferenceLineageIds, demo), [references, decisions, humanCuratedReferenceLineageIds, demo]);
+
+  const markRead = useCallback(async (requestId: string) => {
+    setReadIds((current) => new Set(current).add(requestId));
+    if (demo || !userKey) return;
+    const { markReviewRead } = await import("../lib/review-client");
+    await markReviewRead(userKey, requestId).catch(() => undefined);
+  }, [demo, userKey]);
+
+  const answer = useCallback(async (request: ReviewRequest, input: AnswerInput) => {
+    setError(null);
+    setBusyId(request.id);
+    try {
+      if (demo) throw new Error("This is a demo: answers are not saved.");
+      const { answerReviewRequest } = await import("../lib/review-client");
+      const saved = await answerReviewRequest(request, input, actorLabel);
+      setRequests((current) => current.map((entry) => (entry.id === saved.id ? saved : entry)));
+      await markRead(request.id);
+    } catch (failure) {
+      setError(failure instanceof Error ? failure.message : "Could not save the answer.");
+    } finally {
+      setBusyId(null);
+    }
+  }, [actorLabel, demo, markRead]);
+
+  const markAllRead = useCallback(() => {
+    for (const request of requests) if (isUnread(request, readIds)) void markRead(request.id);
+  }, [markRead, readIds, requests]);
+
+  return (
+    <NotificationCenterView
+      autoDecided={autoDecided} busyId={busyId} demo={demo} error={error} held={held} loadState={loadState}
+      onAnswer={answer} onMarkAllRead={markAllRead} onMarkRead={markRead} readIds={readIds} requests={requests}
+    />
+  );
+}

package/components/topic-steering-workspace.tsx

@@ -3004,7 +3004,7 @@ function NewsDeskDashboard({
     return entries;
   }, [summaryStatus, tabCounts]);
   const opsPageTitle = activeTab === "overview"
-    ? "Overview"
+    ? "Notification Center"
     : activeTab === "administration" && administrationPanel === "sections"
       ? "Sections"
       : formatDeskSectionHeadline(activeTab);
@@ -3062,8 +3062,11 @@ function NewsDeskDashboard({
 
         {activeTab === "overview" ? (
           <NewsroomOpsOverview
+            actorLabel={authState.label}
             assignments={assignments}
+            decisions={relevanceDecisions}
             demo={Boolean(dashboard.isDemo)}
+            humanCuratedReferenceLineageIds={humanCuratedReferenceLineageIds}
             messages={messages}
             newsroomSections={newsroomSections}
             references={references}

package/lib/automation-client.ts

@@ -1,7 +1,7 @@
 "use client";
 
 import { generateClient } from "aws-amplify/data";
-import type { AutomationResult } from "./automation-overview";
+import type { AutomationResult, RunNowResult } from "./automation-overview";
 
 type GraphQLResult = { data?: { automationOverview?: unknown }; errors?: { message?: string; errorType?: string }[] };
 
@@ -27,3 +27,28 @@ export async function loadAutomationOverview(): Promise<AutomationResult> {
   const raw = result.data.automationOverview;
   return (typeof raw === "string" ? JSON.parse(raw) : raw) as AutomationResult;
 }
+
+type RunGraphQLResult = { data?: { runAutomation?: unknown }; errors?: { message?: string; errorType?: string }[] };
+
+/**
+ * Starts a run of the automation's procedure now, as the signed-in editor or admin. The function behind the
+ * mutation checks the groups again, refuses a disabled automation or one at its limit, and writes the row that
+ * links the run to the automation's history. `input` is sent as JSON text; null uses the record's own input.
+ */
+export async function runAutomationNow(automationId: string, input: Record<string, unknown> | null): Promise<RunNowResult> {
+  const client = generateClient({ authMode: "userPool" });
+  let result: RunGraphQLResult;
+  try {
+    result = (await client.graphql({
+      query: `mutation RunAutomation($automationId: String!, $input: AWSJSON) { runAutomation(automationId: $automationId, input: $input) }`,
+      variables: { automationId, input: input === null ? null : JSON.stringify(input) },
+    })) as RunGraphQLResult;
+  } catch (error) {
+    result = (error && typeof error === "object" && "errors" in error ? error : { errors: [{ message: "failed" }] }) as RunGraphQLResult;
+  }
+  const refused = result.errors?.some((entry) => /unauthorized|not authorized|forbidden/i.test(`${entry.errorType ?? ""} ${entry.message ?? ""}`));
+  if (refused) return { error: "forbidden" };
+  if (result.errors?.length || result.data?.runAutomation === undefined || result.data.runAutomation === null) return { state: "unavailable" };
+  const raw = result.data.runAutomation;
+  return (typeof raw === "string" ? JSON.parse(raw) : raw) as RunNowResult;
+}

package/lib/automation-fixture.ts

@@ -1,6 +1,15 @@
-import type { AutomationOverview } from "./automation-overview";
+import type { AutomationOverview, AutomationRun } from "./automation-overview";
 
-const COST_NOTE = "not recorded: the procedure runner does not record token use or cost on a ProcedureRun yet";
+const NOT_RECORDED = "not recorded for this run";
+const ESTIMATED = "estimated from the model usage reported by the run";
+
+function run(fields: Partial<AutomationRun> & Pick<AutomationRun, "status" | "startedAt">): AutomationRun {
+  return {
+    origin: "monitor", requestedBy: null, reason: null, sourceId: null, referenceId: null, triggerStatus: fields.status, runId: null,
+    finishedAt: null, durationSeconds: null, error: null, runRecord: "none", storyId: null, storyVersionId: null, storyTitle: null,
+    costUsd: null, costNote: NOT_RECORDED, budgetUsd: null, overBudget: false, usage: null, ...fields,
+  };
+}
 
 /** A realistic overview for tests and the `?demo=1` newsroom: one live monitor automation and one stored schedule. */
 export const FIXTURE_AUTOMATION_OVERVIEW: AutomationOverview = {
@@ -13,14 +22,15 @@ export const FIXTURE_AUTOMATION_OVERVIEW: AutomationOverview = {
       title: "Analyze new TTAB rulings",
       description: "Drafts a story for each new Board decision.",
       enabled: true,
-      enabledNote: "display only until the router honours it",
+      enabledNote: "the router starts nothing for a disabled automation",
       trigger: { kind: "monitor", config: { monitorId: "ttab", publicationId: "example" } },
       supported: true,
       supportNote: null,
       procedureKey: "example.ttab.ruling-analysis",
       inputTemplate: { proceeding: "{sourceIdPrefix}", opinion_url: "{documentUrl}" },
-      limits: { timeoutSeconds: 840, maxConcurrent: 1 },
-      limitsNote: "recorded only: the runner does not enforce these yet",
+      limits: { timeoutSeconds: 840, maxConcurrent: 2, budgetUsdPerRun: 0.05 },
+      limitsNote: "the timeout and the number at a time (when set) are enforced when a run starts; the budget is advisory and only flagged",
+      runNow: { available: true, reason: null, needsInput: true, inputNames: ["opinion_url", "proceeding"] },
       createdAt: "2026-10-23T10:00:00Z",
       updatedAt: "2026-10-23T10:00:00Z",
       link: { state: "linked", text: "The router's trigger matches this record.", routerMode: "live", routerEnabled: true },
@@ -28,30 +38,44 @@ export const FIXTURE_AUTOMATION_OVERVIEW: AutomationOverview = {
       skippedAlreadyHadReference: 2,
       lastRun: null,
       runs: [
-        { sourceId: "91000001-EXA_26", referenceId: "ref-1", triggerStatus: "completed", runId: "run-1", status: "completed",
-          startedAt: "2026-10-23T11:30:00Z", finishedAt: "2026-10-23T11:33:10Z", durationSeconds: 190, error: null, runRecord: "found",
-          storyId: "story-1", storyVersionId: "version-1", storyTitle: "Board affirms a refusal for likelihood of confusion", costUsd: null, costNote: COST_NOTE },
-        { sourceId: "91000002-EXA_26", referenceId: "ref-2", triggerStatus: "failed", runId: "run-2", status: "failed",
-          startedAt: "2026-10-23T05:30:00Z", finishedAt: "2026-10-23T05:31:00Z", durationSeconds: 60, error: "the opinion could not be downloaded", runRecord: "found",
-          storyId: null, storyVersionId: null, storyTitle: null, costUsd: null, costNote: COST_NOTE },
-        { sourceId: "91000003-EXA_26", referenceId: "ref-3", triggerStatus: "started", runId: null, status: "started",
-          startedAt: "2026-10-23T11:59:00Z", finishedAt: null, durationSeconds: null, error: null, runRecord: "none",
-          storyId: null, storyVersionId: null, storyTitle: null, costUsd: null, costNote: COST_NOTE },
+        run({ sourceId: "91000001-EXA_26", referenceId: "ref-1", runId: "run-1", status: "completed", triggerStatus: "completed",
+              startedAt: "2026-10-23T11:30:00Z", finishedAt: "2026-10-23T11:33:10Z", durationSeconds: 190, runRecord: "found",
+              storyId: "story-1", storyVersionId: "version-1", storyTitle: "Board affirms a refusal for likelihood of confusion",
+              costUsd: 0.0123, costNote: ESTIMATED, budgetUsd: 0.05,
+              usage: { calls: 4, promptTokens: 61000, completionTokens: 5200, models: { "gpt-6-luna": 4 }, complete: true, unpricedModels: [] } }),
+        run({ sourceId: "91000002-EXA_26", referenceId: "ref-2", runId: "run-2", status: "failed", triggerStatus: "failed",
+              startedAt: "2026-10-23T05:30:00Z", finishedAt: "2026-10-23T05:31:00Z", durationSeconds: 60, runRecord: "found",
+              error: "the opinion could not be downloaded" }),
+        run({ sourceId: "91000003-EXA_26", referenceId: "ref-3", status: "started", startedAt: "2026-10-23T11:59:00Z" }),
+        run({ origin: "manual", requestedBy: "ryan@example.test", runId: "run-4", status: "completed", triggerStatus: "completed",
+              startedAt: "2026-10-23T09:00:00Z", finishedAt: "2026-10-23T09:05:00Z", durationSeconds: 300, runRecord: "found",
+              costUsd: 0.081, costNote: ESTIMATED, budgetUsd: 0.05, overBudget: true }),
+        run({ sourceId: "91000005-EXA_26", referenceId: "ref-5", status: "deferred", startedAt: "2026-10-23T08:00:00Z",
+              reason: "deferred: concurrency limit: 2 running, at most 2 at a time" }),
+        run({ sourceId: "91000006-EXA_26", referenceId: "ref-6", status: "skipped", startedAt: "2026-10-22T08:00:00Z",
+              reason: "automation disabled" }),
+      ],
+      outsideRuns: [
+        { runId: "run-9", status: "completed", startedAt: "2026-10-22T15:00:00Z", finishedAt: "2026-10-22T15:02:00Z", durationSeconds: 120,
+          error: null, requestedBy: "papyrus-cli", storyId: null, storyVersionId: null, storyTitle: null, costUsd: null,
+          costNote: NOT_RECORDED, overBudget: false },
       ],
+      outsideNotice: null,
     },
     {
       id: "example.weekly-digest",
       title: "Weekly digest",
       description: null,
       enabled: false,
-      enabledNote: "display only until the router honours it",
+      enabledNote: "the router starts nothing for a disabled automation",
       trigger: { kind: "schedule", config: { cron: "0 9 * * 1" } },
       supported: false,
       supportNote: "not yet supported",
       procedureKey: "example.weekly-digest",
       inputTemplate: {},
-      limits: { timeoutSeconds: 840, maxConcurrent: 1 },
-      limitsNote: "recorded only: the runner does not enforce these yet",
+      limits: { timeoutSeconds: 840 },
+      limitsNote: "the timeout and the number at a time (when set) are enforced when a run starts; the budget is advisory and only flagged",
+      runNow: { available: false, reason: "not yet supported", needsInput: false, inputNames: [] },
       createdAt: "2026-10-23T10:05:00Z",
       updatedAt: "2026-10-23T10:05:00Z",
       link: { state: "not_applicable", text: "not yet supported" },
@@ -59,7 +83,11 @@ export const FIXTURE_AUTOMATION_OVERVIEW: AutomationOverview = {
       skippedAlreadyHadReference: 0,
       lastRun: null,
       runs: [],
+      outsideRuns: [],
+      outsideNotice: null,
     },
   ],
 };
-FIXTURE_AUTOMATION_OVERVIEW.automations[0].lastRun = FIXTURE_AUTOMATION_OVERVIEW.automations[0].runs[2];
+// Newest first, as the history is served.
+FIXTURE_AUTOMATION_OVERVIEW.automations[0].runs.sort((left, right) => String(right.startedAt).localeCompare(String(left.startedAt)));
+FIXTURE_AUTOMATION_OVERVIEW.automations[0].lastRun = FIXTURE_AUTOMATION_OVERVIEW.automations[0].runs[0];