@anthusai/papyrus 2.0.0-next.97 → 2.0.0-next.98

package/amplify/data/resource.js

@@ -597,6 +597,12 @@ const schema = a.schema({
         .returns(a.json())
         .authorization((allow) => [allow.groups(contentWriteGroups)])
         .handler(functionHandler("contentActions", contentActions)),
+    intakeEmailSubmissionReferences: a
+        .mutation()
+        .arguments({ input: a.json().required() })
+        .returns(a.json())
+        .authorization((allow) => [allow.groups(contentWriteGroups)])
+        .handler(functionHandler("contentActions", contentActions)),
     saveItemDraft: a
         .mutation()
         .arguments({ input: a.json().required() })

package/amplify/data/resource.ts

@@ -650,6 +650,13 @@ const schema = a.schema({
     .authorization((allow) => [allow.groups(contentWriteGroups)])
     .handler(functionHandler("contentActions", contentActions)),
 
+  intakeEmailSubmissionReferences: a
+    .mutation()
+    .arguments({ input: a.json().required() })
+    .returns(a.json())
+    .authorization((allow) => [allow.groups(contentWriteGroups)])
+    .handler(functionHandler("contentActions", contentActions)),
+
   saveItemDraft: a
     .mutation()
     .arguments({ input: a.json().required() })

package/amplify/data/schema.js

@@ -523,6 +523,12 @@ function buildBaseDefinitions(includeEditions) {
             .returns(a.json())
             .authorization((allow) => [allow.groups(contentWriteGroups)])
             .handler(functionHandler("contentActions", contentActions)),
+        intakeEmailSubmissionReferences: a
+            .mutation()
+            .arguments({ input: a.json().required() })
+            .returns(a.json())
+            .authorization((allow) => [allow.groups(contentWriteGroups)])
+            .handler(functionHandler("contentActions", contentActions)),
         saveItemDraft: a
             .mutation()
             .arguments({ input: a.json().required() })

package/amplify/data/schema.ts

@@ -574,6 +574,13 @@ const definitions = {
     .authorization((allow) => [allow.groups(contentWriteGroups)])
     .handler(functionHandler("contentActions", contentActions)),
 
+  intakeEmailSubmissionReferences: a
+    .mutation()
+    .arguments({ input: a.json().required() })
+    .returns(a.json())
+    .authorization((allow) => [allow.groups(contentWriteGroups)])
+    .handler(functionHandler("contentActions", contentActions)),
+
   saveItemDraft: a
     .mutation()
     .arguments({ input: a.json().required() })

package/amplify/functions/content-actions/handler.py

@@ -27,7 +27,7 @@ from papyrus_content.rebuild_trigger import (
 from papyrus_content.story_reporting import save_story_version
 from papyrus_content.publication import ensure_publication_from_environment
 from papyrus_content.editorial_checks import GraphQLEditorialStore, ensure_default_policies
-from papyrus_content.reference_intake import IntakeError, intake_references
+from papyrus_content.reference_intake import IntakeError, intake_email_submission_references, intake_references
 from papyrus_content.publish_alerts import PUBLISHED_TASK_KEY, announce_published
 from papyrus_content.publishing import (
     ItemFields,
@@ -356,6 +356,15 @@ def handler(event, context):
                 return intake_references(client, arguments, event.get("identity") or {})
             except IntakeError as error:
                 return {"ok": False, "errors": [{"code": "intake-rejected", "message": str(error)}]}
+        if field == "intakeEmailSubmissionReferences":
+            client, _claims = create_authoring_client()
+            try:
+                from papyrus_content.monitoring_view import default_store_factory
+                receipt_store = default_store_factory(os.environ)()
+                return intake_email_submission_references(
+                    client, arguments, event.get("identity") or {}, receipt_store=receipt_store)
+            except IntakeError as error:
+                return {"ok": False, "errors": [{"code": "intake-rejected", "message": str(error)}]}
         if field == "deriveMarkus":
             return derive_markus_action(arguments)
         if field == "saveItemDraft":

package/amplify/functions/monitoring-view/schema.js

@@ -20,4 +20,10 @@ export const monitoringViewSchemaDefinitions = {
         .returns(a.json())
         .authorization((allow) => [allow.groups(editors)])
         .handler(functionHandler("monitoringView", monitoringView)),
+    monitoringResolveEmailArticleLink: a
+        .mutation()
+        .arguments({ receiptId: a.string().required(), candidateIndex: a.integer().required() })
+        .returns(a.json())
+        .authorization((allow) => [allow.groups(editors)])
+        .handler(functionHandler("monitoringView", monitoringView)),
 };

package/amplify/functions/monitoring-view/schema.ts

@@ -22,4 +22,10 @@ export const monitoringViewSchemaDefinitions = {
     .returns(a.json())
     .authorization((allow) => [allow.groups(editors)])
     .handler(functionHandler("monitoringView", monitoringView)),
+  monitoringResolveEmailArticleLink: a
+    .mutation()
+    .arguments({ receiptId: a.string().required(), candidateIndex: a.integer().required() })
+    .returns(a.json())
+    .authorization((allow) => [allow.groups(editors)])
+    .handler(functionHandler("monitoringView", monitoringView)),
 };

package/amplify/functions/monitoring-view/wire.js

@@ -34,4 +34,29 @@ export function wireMonitoringView(backend) {
         actions: MONITORING_VIEW_TABLE_ACTIONS,
         resources: monitoringViewTableArns(stack.region, stack.account),
     }));
+    // Resolving a selected newsletter article records its destination in the
+    // same receipt partition. The editor-facing resolver validates the receipt
+    // and candidate before this single-key write.
+    lambda.addToRolePolicy(new PolicyStatement({
+        effect: Effect.ALLOW,
+        actions: ["dynamodb:PutItem"],
+        resources: monitoringViewTableArns(stack.region, stack.account).slice(0, 1),
+        conditions: { "ForAllValues:StringEquals": { "dynamodb:LeadingKeys": ["MONITOR#hn"] } },
+    }));
+}
+/** Lets the authenticated Reference-intake action verify a selected email receipt. */
+export function wireEmailReferenceIntake(lambda) {
+    const stack = Stack.of(lambda);
+    lambda.addEnvironment("PAPYRUS_MONITORING_TABLE_PARAMETER", MONITORING_TABLE_PARAMETER);
+    lambda.addToRolePolicy(new PolicyStatement({
+        effect: Effect.ALLOW,
+        actions: ["ssm:GetParameter"],
+        resources: [monitoringViewParameterArn(stack.region, stack.account)],
+    }));
+    lambda.addToRolePolicy(new PolicyStatement({
+        effect: Effect.ALLOW,
+        actions: MONITORING_VIEW_TABLE_ACTIONS,
+        resources: monitoringViewTableArns(stack.region, stack.account).slice(0, 1),
+        conditions: { "ForAllValues:StringEquals": { "dynamodb:LeadingKeys": ["MONITOR#hn"] } },
+    }));
 }

package/amplify/functions/monitoring-view/wire.ts

@@ -44,4 +44,36 @@ export function wireMonitoringView(backend: any): void {
       resources: monitoringViewTableArns(stack.region, stack.account),
     }),
   );
+  // Resolving a selected newsletter article records its destination in the
+  // same receipt partition. The editor-facing resolver validates the receipt
+  // and candidate before this single-key write.
+  lambda.addToRolePolicy(
+    new PolicyStatement({
+      effect: Effect.ALLOW,
+      actions: ["dynamodb:PutItem"],
+      resources: monitoringViewTableArns(stack.region, stack.account).slice(0, 1),
+      conditions: { "ForAllValues:StringEquals": { "dynamodb:LeadingKeys": ["MONITOR#hn"] } },
+    }),
+  );
+}
+
+/** Lets the authenticated Reference-intake action verify a selected email receipt. */
+export function wireEmailReferenceIntake(lambda: LambdaFunction): void {
+  const stack = Stack.of(lambda);
+  lambda.addEnvironment("PAPYRUS_MONITORING_TABLE_PARAMETER", MONITORING_TABLE_PARAMETER);
+  lambda.addToRolePolicy(
+    new PolicyStatement({
+      effect: Effect.ALLOW,
+      actions: ["ssm:GetParameter"],
+      resources: [monitoringViewParameterArn(stack.region, stack.account)],
+    }),
+  );
+  lambda.addToRolePolicy(
+    new PolicyStatement({
+      effect: Effect.ALLOW,
+      actions: MONITORING_VIEW_TABLE_ACTIONS,
+      resources: monitoringViewTableArns(stack.region, stack.account).slice(0, 1),
+      conditions: { "ForAllValues:StringEquals": { "dynamodb:LeadingKeys": ["MONITOR#hn"] } },
+    }),
+  );
 }

package/amplify/site-backend.js

@@ -25,7 +25,7 @@ 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 { wireEmailReferenceIntake, wireMonitoringView } from "./functions/monitoring-view/wire.js";
 import { wireEditorialChecks } from "./functions/editorial-checks/wire.js";
 import { resolvePlugins } from "./plugins/registry.js";
 import { wirePlugins } from "./plugins/wire.js";
@@ -336,6 +336,7 @@ export function defineSiteBackend(papyrusSite) {
     // and publication to this deployment's pool and existing API endpoint.
     contentActionsLambda.addEnvironment("PAPYRUS_USER_POOL_ISSUER", `https://cognito-idp.${Stack.of(contentActionsLambda).region}.amazonaws.com/${backend.auth.resources.userPool.userPoolId}`);
     contentActionsLambda.addEnvironment("PAPYRUS_GRAPHQL_ENDPOINT", backend.data.resources.cfnResources.cfnGraphqlApi.attrGraphQlUrl);
+    wireEmailReferenceIntake(contentActionsLambda);
     contentActionsLambda.addToRolePolicy(new PolicyStatement({
         actions: ["appsync:GraphQL"],
         resources: ["*"],

package/amplify/site-backend.ts

@@ -32,7 +32,7 @@ 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 { wireEmailReferenceIntake, wireMonitoringView } from "./functions/monitoring-view/wire";
 import { wireEditorialChecks } from "./functions/editorial-checks/wire";
 import { resolvePlugins } from "./plugins/registry";
 import { wirePlugins } from "./plugins/wire";
@@ -429,6 +429,7 @@ export function defineSiteBackend(papyrusSite: PapyrusSite) {
     "PAPYRUS_GRAPHQL_ENDPOINT",
     backend.data.resources.cfnResources.cfnGraphqlApi.attrGraphQlUrl,
   );
+  wireEmailReferenceIntake(contentActionsLambda);
   contentActionsLambda.addToRolePolicy(
     new PolicyStatement({
       actions: ["appsync:GraphQL"],

package/components/monitoring-overview-view.tsx

@@ -1,4 +1,6 @@
+import { useEffect, useRef, useState } from "react";
 import Link from "next/link";
+import { getNewsroomNavHref } from "../lib/newsroom-nav";
 import {
   confidenceText,
   describeDelivery,
@@ -7,8 +9,14 @@ import {
   formatUtc,
   referenceHref,
   routingLabel,
+  beginEmailSubmissionAction,
+  endEmailSubmissionAction,
+  isCurrentEmailSubmissionAction,
   type MonitoringItem,
   type MonitoringEmailDetails,
+  type MonitoringEmailArticleResolution,
+  type EmailReferenceImportItem,
+  type EmailReferenceImportOutcome,
   type MonitoringEmailSummary,
   type MonitoringOverview,
   type MonitoringRelevance,
@@ -89,16 +97,110 @@ function QueueItem({ item, ownId, demo }: { item: MonitoringItem; ownId: string
   );
 }
 
-function EmailSubmissions({ items, detail, onOpen }: {
+function EmailSubmissions({ items, detail, onOpen, onResolveArticleLink, onImportCandidates }: {
   items: MonitoringEmailSummary[]; detail: MonitoringEmailDetails | null; onOpen: (receiptId: string) => void;
+  onResolveArticleLink?: (receiptId: string, candidateIndex: number) => Promise<MonitoringEmailArticleResolution>;
+  onImportCandidates?: (receiptId: string, items: EmailReferenceImportItem[]) => Promise<EmailReferenceImportOutcome>;
 }) {
+  const [selectedByReceipt, setSelectedByReceipt] = useState<Record<string, Record<number, boolean>>>({});
+  const [resolvedByReceipt, setResolvedByReceipt] = useState<Record<string, Record<number, { url: string; title: string }>>>({});
+  const [busyIndexByReceipt, setBusyIndexByReceipt] = useState<Record<string, number | null>>({});
+  const [busyImportByReceipt, setBusyImportByReceipt] = useState<Record<string, boolean>>({});
+  const [noticeByReceipt, setNoticeByReceipt] = useState<Record<string, string>>({});
+  const [importedByReceipt, setImportedByReceipt] = useState<Record<string, EmailReferenceImportOutcome["references"]>>({});
+  const receiptId = detail && "submission" in detail ? detail.submission.receiptId : null;
+  const receiptKey = receiptId ?? "";
+  const selected = selectedByReceipt[receiptKey] ?? {};
+  const resolved = resolvedByReceipt[receiptKey] ?? {};
+  const busyIndex = busyIndexByReceipt[receiptKey] ?? null;
+  const busyImport = busyImportByReceipt[receiptKey] ?? false;
+  const notice = noticeByReceipt[receiptKey] ?? "";
+  const importedReferences = importedByReceipt[receiptKey] ?? [];
+  const activeReceiptId = useRef<string | null>(receiptId);
+  activeReceiptId.current = receiptId;
+  const inFlightActions = useRef(new Set<string>());
+  useEffect(() => {
+    if (!detail || !("submission" in detail)) return;
+    setSelectedByReceipt((current) => current[receiptKey] ? current : {
+      ...current,
+      [receiptKey]: Object.fromEntries(detail.candidateLinks.map((link, index) => [index, link.resolutionStatus !== "unresolved"])),
+    });
+  }, [receiptKey, detail]);
+
+  const resolveLink = async (index: number) => {
+    if (!receiptId || !onResolveArticleLink) return;
+    const requestReceiptId = receiptId;
+    const actionKey = `resolve:${requestReceiptId}:${index}`;
+    if (!beginEmailSubmissionAction(inFlightActions.current, actionKey)) return;
+    setBusyIndexByReceipt((current) => ({ ...current, [requestReceiptId]: index }));
+    setNoticeByReceipt((current) => ({ ...current, [requestReceiptId]: "" }));
+    try {
+      const result = await onResolveArticleLink(requestReceiptId, index);
+      if (!isCurrentEmailSubmissionAction(activeReceiptId.current, requestReceiptId)) return;
+      if (!("url" in result)) {
+        setNoticeByReceipt((current) => ({ ...current, [requestReceiptId]: "The article destination could not be resolved safely. The original link remains private and unchanged." }));
+        return;
+      }
+      const candidate = detail && "submission" in detail ? detail.candidateLinks[index] : null;
+      setResolvedByReceipt((current) => ({ ...current, [requestReceiptId]: { ...current[requestReceiptId], [index]: { url: result.url, title: result.title || candidate?.title || "Article" } } }));
+      setSelectedByReceipt((current) => ({ ...current, [requestReceiptId]: { ...current[requestReceiptId], [index]: true } }));
+      setNoticeByReceipt((current) => ({ ...current, [requestReceiptId]: "Resolved. This request may be recorded as a click by the newsletter sender." }));
+    } catch {
+      if (isCurrentEmailSubmissionAction(activeReceiptId.current, requestReceiptId)) {
+        setNoticeByReceipt((current) => ({ ...current, [requestReceiptId]: "The article destination could not be resolved. Try again later." }));
+      }
+    } finally {
+      endEmailSubmissionAction(inFlightActions.current, actionKey);
+      setBusyIndexByReceipt((current) => ({ ...current, [requestReceiptId]: null }));
+    }
+  };
+
+  const importSelected = async () => {
+    if (!receiptId || !detail || !("submission" in detail) || !onImportCandidates) return;
+    const requestReceiptId = receiptId;
+    const actionKey = `import:${requestReceiptId}`;
+    if (inFlightActions.current.has(actionKey)) return;
+    const candidates = detail.candidateLinks.flatMap((link, index) => {
+      if (!selected[index]) return [];
+      const resolvedLink = resolved[index];
+      if (!resolvedLink && link.resolutionStatus === "unresolved") return [];
+      const url = resolvedLink?.url ?? link.url;
+      return [{ candidateIndex: index, source_uri: url }];
+    });
+    if (!candidates.length) {
+      setNoticeByReceipt((current) => ({ ...current, [requestReceiptId]: "Select at least one available candidate link. Resolve tracking links before importing them." }));
+      return;
+    }
+    if (!beginEmailSubmissionAction(inFlightActions.current, actionKey)) return;
+    setBusyImportByReceipt((current) => ({ ...current, [requestReceiptId]: true }));
+    setNoticeByReceipt((current) => ({ ...current, [requestReceiptId]: "" }));
+    try {
+      const result = await onImportCandidates(requestReceiptId, candidates);
+      if (!isCurrentEmailSubmissionAction(activeReceiptId.current, requestReceiptId)) return;
+      setImportedByReceipt((current) => ({ ...current, [requestReceiptId]: result.references }));
+      if (result.error) {
+        setNoticeByReceipt((current) => ({ ...current, [requestReceiptId]: `${result.imported} of ${candidates.length} selected candidates were registered or matched. ${result.error}` }));
+      } else {
+        setNoticeByReceipt((current) => ({ ...current, [requestReceiptId]: `${result.imported} selected candidates are available as References. Import does not approve or publish them.` }));
+      }
+    } catch {
+      if (isCurrentEmailSubmissionAction(activeReceiptId.current, requestReceiptId)) {
+        setNoticeByReceipt((current) => ({ ...current, [requestReceiptId]: "The import stopped. Any completed references are safe to retry; no review decision was made." }));
+      }
+    } finally {
+      endEmailSubmissionAction(inFlightActions.current, actionKey);
+      setBusyImportByReceipt((current) => ({ ...current, [requestReceiptId]: false }));
+    }
+  };
+
   return (
     <article className="news-desk-doctrine-card" data-monitoring-section="email-submissions">
       <div className="news-desk-doctrine-card__header"><div><h3>Email submissions</h3><span>Untrusted source material held privately for editor review</span></div></div>
       {items.length ? <ul className="news-desk-monitoring__list">
         {items.map((item) => <li key={item.receiptId} data-email-submission={item.receiptId}>
           <strong>{item.subject || "(no subject)"}</strong>
-          <span>{formatUtc(item.observedAt)} · {item.linkCount} candidate links · {item.processedCount} queued</span>
+          <span>{formatUtc(item.observedAt)} · {item.linkCount} candidate links · {item.reviewRequired
+            ? `${item.linkCount} await editor import` : `${item.processedCount} queued`}</span>
           {item.reviewRequired ? <span>Authentication warnings: private review required; nothing was routed automatically.</span> : null}
           {item.unresolvedLinkCount ? <span>{item.unresolvedLinkCount} tracking links remain unresolved and were not opened.</span> : null}
           <span>Envelope sender: {item.envelopeSender || "unknown"} · MIME From (unverified): {item.headerFrom || "unknown"}</span>
@@ -115,9 +217,28 @@ function EmailSubmissions({ items, detail, onOpen }: {
           <pre style={{ whiteSpace: "pre-wrap", overflowWrap: "anywhere" }}>{detail.safeBodyText}</pre>
           <h5>Candidate references ({detail.candidateLinks.length})</h5>
           <ul>{detail.candidateLinks.map((link, index) => <li key={`${link.url}-${index}`}>
-            {link.resolutionStatus === "unresolved" ? <span>{link.title || link.url} (unresolved; not opened)</span>
-              : <a href={link.url} target="_blank" rel="noreferrer noopener">{link.title || link.url}</a>}
+            {link.resolutionStatus === "unresolved" && !resolved[index]
+              ? <span>{link.title || "Newsletter article link"} (tracking redirect not opened)</span>
+              : <a href={(resolved[index]?.url ?? link.url)} target="_blank" rel="noreferrer noopener">{resolved[index]?.title ?? (link.title || "Source link")}</a>}
+            <label>
+              <input type="checkbox" checked={selected[index] ?? false}
+                disabled={link.resolutionStatus === "unresolved" && !resolved[index]}
+                onChange={(event) => setSelectedByReceipt((current) => ({ ...current, [receiptKey]: { ...current[receiptKey], [index]: event.target.checked } }))} />
+              Add as pending Reference
+            </label>
+            {link.resolutionStatus === "unresolved" && !resolved[index] ? (
+              <button type="button" disabled={busyIndex !== null || !onResolveArticleLink} onClick={() => void resolveLink(index)}>
+                {busyIndex === index ? "Resolving…" : "Resolve article redirect (may register a click)"}
+              </button>
+            ) : null}
           </li>)}</ul>
+          <p>Adding links creates or reuses pending References. It does not approve, label, classify, or publish them.</p>
+          <button type="button" disabled={busyImport || !onImportCandidates || !detail.submission.corpusId}
+            onClick={() => void importSelected()}>
+            {busyImport ? "Adding References…" : "Add selected links to References"}
+          </button>
+          {notice ? <p role="status" data-email-import-result>{notice}</p> : null}
+          {importedReferences.length ? <p><Link href={getNewsroomNavHref("/newsroom/references", false)}>Review these References</Link></p> : null}
         </section>
       ) : detail && "error" in detail ? <p role="alert">You cannot read this submission.</p>
         : detail && "state" in detail ? <p role="alert">Submission details are unavailable.</p> : null}
@@ -125,8 +246,10 @@ function EmailSubmissions({ items, detail, onOpen }: {
   );
 }
 
-function Ready({ data, demo, emailDetail, onEmailOpen }: {
+function Ready({ data, demo, emailDetail, onEmailOpen, onResolveArticleLink, onImportCandidates }: {
   data: MonitoringOverview; demo: boolean; emailDetail: MonitoringEmailDetails | null; onEmailOpen: (id: string) => void;
+  onResolveArticleLink?: (receiptId: string, candidateIndex: number) => Promise<MonitoringEmailArticleResolution>;
+  onImportCandidates?: (receiptId: string, items: EmailReferenceImportItem[]) => Promise<EmailReferenceImportOutcome>;
 }) {
   const router = data.router;
   return (
@@ -135,7 +258,9 @@ function Ready({ data, demo, emailDetail, onEmailOpen }: {
         <p className="news-desk-delegation-note" data-monitoring-notice>This publication is not one of the router&apos;s outputs, so no relevance is shown for it here.</p>
       ) : null}
 
-      <EmailSubmissions items={data.emailSubmissions ?? []} detail={emailDetail} onOpen={onEmailOpen} />
+      <EmailSubmissions items={data.emailSubmissions ?? []} detail={emailDetail} onOpen={onEmailOpen}
+        onResolveArticleLink={demo ? undefined : onResolveArticleLink}
+        onImportCandidates={demo ? undefined : onImportCandidates} />
 
       <article className="news-desk-doctrine-card" data-monitoring-section="router">
         <div className="news-desk-doctrine-card__header"><div><h3>Router</h3><span>Sends collected items to the shared Cyclotron and delivers relevant ones to References</span></div></div>
@@ -233,6 +358,8 @@ export function MonitoringOverviewView({
   demo = false,
   emailDetail = null,
   onEmailOpen = () => {},
+  onResolveArticleLink,
+  onImportCandidates,
 }: {
   result: MonitoringResult | null;
   canViewAll: boolean;
@@ -241,6 +368,8 @@ export function MonitoringOverviewView({
   demo?: boolean;
   emailDetail?: MonitoringEmailDetails | null;
   onEmailOpen?: (receiptId: string) => void;
+  onResolveArticleLink?: (receiptId: string, candidateIndex: number) => Promise<MonitoringEmailArticleResolution>;
+  onImportCandidates?: (receiptId: string, items: EmailReferenceImportItem[]) => Promise<EmailReferenceImportOutcome>;
 }) {
   let body: React.ReactNode;
   if (result === null) {
@@ -256,7 +385,8 @@ export function MonitoringOverviewView({
   } else if (result.state === "empty") {
     body = <Message kind="empty" title="Nothing has been collected yet">No feed is configured and no run has been recorded. Items appear here after the collector&apos;s first run.</Message>;
   } else {
-    body = <Ready data={result} demo={demo} emailDetail={emailDetail} onEmailOpen={onEmailOpen} />;
+    body = <Ready data={result} demo={demo} emailDetail={emailDetail} onEmailOpen={onEmailOpen}
+      onResolveArticleLink={onResolveArticleLink} onImportCandidates={onImportCandidates} />;
   }
   const scopeLine = result && "scope" in result
     ? (result.scope.mode === "all" ? "Showing the whole shared pipeline, every publication." : `Showing what is relevant to ${result.scope.publicationId ?? "this publication"}.`)

package/components/monitoring-panel.tsx

@@ -1,9 +1,14 @@
 "use client";
 
 import { useEffect, useState } from "react";
-import { loadMonitoringEmailSubmission, loadMonitoringOverview } from "../lib/monitoring-client";
+import {
+  importMonitoringEmailCandidates,
+  loadMonitoringEmailSubmission,
+  loadMonitoringOverview,
+  resolveMonitoringEmailArticleLink,
+} from "../lib/monitoring-client";
 import { FIXTURE_ALL_PIPELINE_OVERVIEW, FIXTURE_MONITORING_OVERVIEW } from "../lib/monitoring-overview-fixture";
-import type { MonitoringEmailDetails, MonitoringResult } from "../lib/monitoring-overview";
+import type { EmailReferenceImportItem, MonitoringEmailDetails, MonitoringResult } from "../lib/monitoring-overview";
 import { MonitoringOverviewView, type MonitoringMode } from "./monitoring-overview-view";
 
 const REFRESH_MILLISECONDS = 60_000;
@@ -43,6 +48,13 @@ export function MonitoringPanel({ isAdmin, isDemo }: { isAdmin: boolean; isDemo:
     setEmailDetail(next);
   };
 
+  const resolveEmailArticleLink = (receiptId: string, candidateIndex: number) =>
+    resolveMonitoringEmailArticleLink(receiptId, candidateIndex);
+
+  const importEmailCandidates = (receiptId: string, candidates: EmailReferenceImportItem[]) =>
+    importMonitoringEmailCandidates(receiptId, candidates);
+
   return <MonitoringOverviewView result={result} canViewAll={isAdmin} mode={mode} onModeChange={setMode} demo={isDemo}
-    emailDetail={emailDetail} onEmailOpen={openEmail} />;
+    emailDetail={emailDetail} onEmailOpen={isDemo ? () => {} : openEmail} onResolveArticleLink={isDemo ? undefined : resolveEmailArticleLink}
+    onImportCandidates={importEmailCandidates} />;
 }

package/components/notification-center.tsx

@@ -23,6 +23,7 @@ type ViewProps = {
   held: CyclotronEntry[];
   autoDecided: CyclotronEntry[];
   storyTitles?: Readonly<Record<string, string>>;
+  deletedStories?: ReadonlySet<string>;
   demo?: boolean;
   busyId?: string | null;
   error?: string | null;
@@ -31,8 +32,8 @@ type ViewProps = {
   onMarkAllRead?: () => void;
 };
 
-function Entry({ request, unread, demo, busy, titles, onAnswer, onMarkRead }: {
-  request: ReviewRequest; unread: boolean; demo: boolean; busy: boolean; titles: Readonly<Record<string, string>>;
+function Entry({ request, unread, demo, busy, titles, deleted, onAnswer, onMarkRead }: {
+  request: ReviewRequest; unread: boolean; demo: boolean; busy: boolean; titles: Readonly<Record<string, string>>; deleted: ReadonlySet<string>;
   onAnswer?: ViewProps["onAnswer"]; onMarkRead?: ViewProps["onMarkRead"];
 }) {
   const [note, setNote] = useState("");
@@ -49,7 +50,7 @@ function Entry({ request, unread, demo, busy, titles, onAnswer, onMarkRead }: {
       </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)}>{subjectLabel(request.subject, titles)}</Link> : <span>{subjectLabel(request.subject, titles)}</span>}
+        {" · "}About: {href ? <Link href={href} onClick={() => onMarkRead?.(request.id)}>{subjectLabel(request.subject, titles, deleted)}</Link> : <span>{subjectLabel(request.subject, titles, deleted)}</span>}
       </p>
       {request.ask ? <p className="text-sm">{request.ask}</p> : null}
       {request.links.length ? (
@@ -78,7 +79,7 @@ function Entry({ request, unread, demo, busy, titles, onAnswer, onMarkRead }: {
           </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: "acknowledge" })} size="sm" variant="outline">Acknowledge</Button>
             ) : (
               <>
                 <Button disabled={busy} onClick={() => act({ decision: "approve" })} size="sm" variant="outline">Approve</Button>
@@ -125,12 +126,12 @@ function Section({ id, title, count, children, empty }: { id: string; title: str
 }
 
 /** 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, storyTitles = {}, busyId = null, error = null, onAnswer, onMarkRead, onMarkAllRead }: ViewProps) {
+export function NotificationCenterView({ loadState, requests, readIds, held, autoDecided, demo = false, storyTitles = {}, deletedStories = new Set<string>(), 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} titles={storyTitles} onAnswer={onAnswer} onMarkRead={onMarkRead} request={request} unread={isUnread(request, readIds)} />
+    <Entry busy={busyId === request.id} demo={demo} key={request.id} titles={storyTitles} deleted={deletedStories} onAnswer={onAnswer} onMarkRead={onMarkRead} request={request} unread={isUnread(request, readIds)} />
   );
   if (loadState === "loading") return (
     <section aria-label="Loading Notification Center" className="space-y-4" data-notification-state="loading" role="status">
@@ -206,6 +207,7 @@ export function NotificationCenter({ references, decisions, humanCuratedReferenc
   const [busyId, setBusyId] = useState<string | null>(null);
   const [error, setError] = useState<string | null>(null);
   const [storyTitles, setStoryTitles] = useState<Record<string, string>>({});
+  const [deletedStories, setDeletedStories] = useState<ReadonlySet<string>>(new Set());
 
   const refresh = useCallback(async () => {
     if (demo) {
@@ -226,7 +228,9 @@ export function NotificationCenter({ references, decisions, humanCuratedReferenc
       setUserKey(loaded.userKey);
       setLoadState("ready");
       const { loadStoryTitles } = await import("../lib/review-client");
-      setStoryTitles(await loadStoryTitles(loaded.requests.filter((request) => request.subject.type === "story").map((request) => request.subject.id)).catch(() => ({})));
+      const stories = await loadStoryTitles(loaded.requests.filter((request) => request.subject.type === "story").map((request) => request.subject.id)).catch(() => ({ titles: {}, deleted: [] as string[] }));
+      setStoryTitles(stories.titles);
+      setDeletedStories(new Set(stories.deleted));
     } catch {
       setLoadState("unavailable");
     }
@@ -270,7 +274,7 @@ export function NotificationCenter({ references, decisions, humanCuratedReferenc
 
   return (
     <NotificationCenterView
-      autoDecided={autoDecided} busyId={busyId} storyTitles={storyTitles} demo={demo} error={error} held={held} loadState={loadState}
+      autoDecided={autoDecided} busyId={busyId} storyTitles={storyTitles} deletedStories={deletedStories} demo={demo} error={error} held={held} loadState={loadState}
       onAnswer={answer} onMarkAllRead={markAllRead} onMarkRead={markRead} readIds={readIds} requests={requests}
     />
   );

package/lib/monitoring-client.ts

@@ -1,12 +1,19 @@
 "use client";
 
 import { generateClient } from "aws-amplify/data";
-import type { MonitoringEmailDetails, MonitoringResult } from "./monitoring-overview";
+import { emailReferenceBatches } from "./monitoring-overview";
+import type {
+  EmailReferenceImportItem,
+  EmailReferenceImportOutcome,
+  MonitoringEmailArticleResolution,
+  MonitoringEmailDetails,
+  MonitoringResult,
+} from "./monitoring-overview";
 
-type QueryField = "monitoringOverview" | "monitoringEmailSubmission";
+type QueryField = "monitoringOverview" | "monitoringEmailSubmission" | "monitoringResolveEmailArticleLink" | "intakeEmailSubmissionReferences";
 type GraphQLResult = { data?: Partial<Record<QueryField, unknown>>; errors?: { message?: string; errorType?: string }[] };
 
-async function query<T>(field: QueryField, queryText: string, variables: Record<string, string>): Promise<T | { error: "forbidden" } | { state: "unavailable" }> {
+async function query<T>(field: QueryField, queryText: string, variables: Record<string, string | number>): Promise<T | { error: "forbidden" } | { state: "unavailable" }> {
   const client = generateClient({ authMode: "userPool" });
   let result: GraphQLResult;
   try {
@@ -32,3 +39,45 @@ export async function loadMonitoringEmailSubmission(receiptId: string): Promise<
   return query<MonitoringEmailDetails>("monitoringEmailSubmission",
     `query MonitoringEmailSubmission($receiptId: String!) { monitoringEmailSubmission(receiptId: $receiptId) }`, { receiptId });
 }
+
+/** Resolve one explicitly selected Beehiiv article redirect; this may register a click with the sender. */
+export async function resolveMonitoringEmailArticleLink(receiptId: string, candidateIndex: number): Promise<MonitoringEmailArticleResolution> {
+  return query<MonitoringEmailArticleResolution>("monitoringResolveEmailArticleLink",
+    `mutation MonitoringResolveEmailArticleLink($receiptId: String!, $candidateIndex: Int!) { monitoringResolveEmailArticleLink(receiptId: $receiptId, candidateIndex: $candidateIndex) }`,
+    { receiptId, candidateIndex });
+}
+
+/** Use the existing editor-authorized Reference intake; 20 is its request batch size, not a total limit. */
+export async function importMonitoringEmailCandidates(
+  receiptId: string,
+  items: EmailReferenceImportItem[],
+): Promise<EmailReferenceImportOutcome> {
+  const client = generateClient({ authMode: "userPool" });
+  const references: EmailReferenceImportOutcome["references"] = [];
+  for (const batch of emailReferenceBatches(items)) {
+    let result: GraphQLResult;
+    try {
+      result = (await client.graphql({
+        query: `mutation IntakeEmailSubmissionReferences($input: AWSJSON!) { intakeEmailSubmissionReferences(input: $input) }`,
+        variables: { input: JSON.stringify({ receiptId, items: batch }) },
+      })) as GraphQLResult;
+    } catch {
+      return { imported: references.length, references, error: "The import stopped. Completed links are safe to retry." };
+    }
+    if (result.errors?.length) {
+      return { imported: references.length, references, error: "The import stopped. Completed links are safe to retry." };
+    }
+    const raw = result.data?.intakeEmailSubmissionReferences;
+    let response: { ok?: boolean; references?: EmailReferenceImportOutcome["references"] } | null | undefined;
+    try {
+      response = (typeof raw === "string" ? JSON.parse(raw) : raw) as typeof response;
+    } catch {
+      return { imported: references.length, references, error: "The import response could not be read. Completed links are safe to retry." };
+    }
+    if (!response?.ok || !Array.isArray(response.references)) {
+      return { imported: references.length, references, error: "The import was not accepted. Check your editor access and retry." };
+    }
+    references.push(...response.references);
+  }
+  return { imported: references.length, references };
+}

package/lib/monitoring-overview.ts

@@ -40,10 +40,44 @@ export type MonitoringEmailSummary = {
 };
 
 export type MonitoringEmailDetails = {
-  submission: MonitoringEmailSummary; safeBodyText: string;
+  submission: MonitoringEmailSummary & { corpusId: string | null }; safeBodyText: string;
   candidateLinks: { url: string; title: string; resolutionStatus?: "unresolved" }[]; sourceMaterialIsUntrusted: true;
 } | { error: "forbidden" | "bad_request" } | { state: "unavailable" | "not_configured" };
 
+export type MonitoringEmailArticleResolution = {
+  url: string; title: string; resolved: true;
+} | { error: "forbidden" | "bad_request" | "not_resolvable" | "resolution_failed"; reason?: string } | { state: "unavailable" };
+
+export type EmailReferenceImportItem = { candidateIndex: number; source_uri: string };
+export type EmailReferenceImportOutcome = {
+  imported: number; references: { id: string; lineageId: string; curationStatus: string }[]; error?: string;
+};
+
+/** Split a complete editor selection into API work batches; the batch size is not a total link limit. */
+export function emailReferenceBatches<T>(items: T[], batchSize = 20): T[][] {
+  if (!Number.isSafeInteger(batchSize) || batchSize < 1) throw new Error("batchSize must be a positive integer");
+  const batches: T[][] = [];
+  for (let offset = 0; offset < items.length; offset += batchSize) {
+    batches.push(items.slice(offset, offset + batchSize));
+  }
+  return batches;
+}
+
+/** Async email actions may only update the receipt that is still open. */
+export function isCurrentEmailSubmissionAction(activeReceiptId: string | null, actionReceiptId: string): boolean {
+  return activeReceiptId === actionReceiptId;
+}
+
+export function beginEmailSubmissionAction(inFlight: Set<string>, actionKey: string): boolean {
+  if (inFlight.has(actionKey)) return false;
+  inFlight.add(actionKey);
+  return true;
+}
+
+export function endEmailSubmissionAction(inFlight: Set<string>, actionKey: string): void {
+  inFlight.delete(actionKey);
+}
+
 export type MonitoringRun = {
   runId: string;
   startedAt: string;

package/lib/review-client.ts

@@ -100,18 +100,21 @@ export async function markReviewRead(userKey: string, requestId: string, now: Da
 
 const MAX_TITLE_LOOKUPS = 40;
 
-/** Titles of the stories that review requests are about, by lineage id. A story that cannot be read simply has no entry (the card falls back to the id). */
-export async function loadStoryTitles(ids: string[]): Promise<Record<string, string>> {
+/** Titles of the stories that review requests are about, by lineage id, and the ids of stories that no longer exist (no version of the lineage remains). A story that cannot be read simply has no entry (the card falls back to the id). */
+export async function loadStoryTitles(ids: string[]): Promise<{ titles: Record<string, string>; deleted: string[] }> {
   const titles: Record<string, string> = {};
+  const deleted: string[] = [];
   await Promise.all([...new Set(ids)].slice(0, MAX_TITLE_LOOKUPS).map(async (id) => {
     const result = await run(
       `query StoryTitle($lineageId: ID!) { listItemsByLineageAndVersion(lineageId: $lineageId, limit: 50) { items { versionNumber headline title } } }`,
       { lineageId: id },
     );
+    // Only a clean, empty answer means the story is gone; a failed lookup says nothing.
+    if (!result.errors?.length && result.data?.listItemsByLineageAndVersion && !(result.data.listItemsByLineageAndVersion.items ?? []).filter(Boolean).length) deleted.push(id);
     const items = (result.data?.listItemsByLineageAndVersion?.items ?? []).filter(Boolean) as { versionNumber?: number; headline?: string; title?: string }[];
     const newest = items.sort((a, b) => (b.versionNumber ?? 0) - (a.versionNumber ?? 0))[0];
     const title = newest?.headline || newest?.title;
     if (title) titles[id] = title;
   }));
-  return titles;
+  return { titles, deleted };
 }

package/lib/review-requests.ts

@@ -13,7 +13,7 @@ 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 ReviewDecision = "approve" | "acknowledge" | "reject" | "feedback";
 export type ReviewSteer = "adjust" | "not_this_kind";
 
 export type ReviewAnswer = { decision: ReviewDecision; feedback: string | null; steer: ReviewSteer | null; by: string; at: string };
@@ -89,6 +89,7 @@ export type AnswerInput = { decision: ReviewDecision; feedback?: string | 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.`);
+  if (input.decision === "acknowledge" && request.mode !== "flag") throw new Error("Only a flag is acknowledged; approve or reject this one.");
   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\".");
@@ -126,12 +127,13 @@ export function nextText(request: ReviewRequest): string {
   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.";
+  return answer ? `${answerWords(answer, request)} by ${answer.by} on ${formatWhen(answer.at)}.` : "Answered.";
 }
 
-export function answerWords(answer: ReviewAnswer): string {
+export function answerWords(answer: ReviewAnswer, request?: Pick<ReviewRequest, "mode">): string {
   if (answer.steer === "not_this_kind") return "Steered: not this kind of thing";
-  if (answer.decision === "approve") return "Approved";
+  if (answer.decision === "acknowledge") return "Acknowledged";
+  if (answer.decision === "approve") return request?.mode === "flag" ? "Acknowledged" : "Approved";
   if (answer.decision === "reject") return "Rejected";
   return "Steered with a note";
 }
@@ -146,8 +148,8 @@ export function steeringText(request: ReviewRequest): string | null {
 }
 
 /** What a request is about, in words: a story shows its title (the id when the title is not known), anything else its type and id. */
-export function subjectLabel(subject: { type: string; id: string }, titles: Readonly<Record<string, string>> = {}): string {
-  if (subject.type === "story") return titles[subject.id] ?? `story ${subject.id}`;
+export function subjectLabel(subject: { type: string; id: string }, titles: Readonly<Record<string, string>> = {}, deleted: ReadonlySet<string> = new Set()): string {
+  if (subject.type === "story") return deleted.has(subject.id) ? `story ${subject.id} (story deleted)` : titles[subject.id] ?? `story ${subject.id}`;
   return `${subject.type.replace("_", " ")} ${subject.id}`;
 }
 

package/package.json

@@ -456,7 +456,7 @@
       "optional": true
     }
   },
-  "version": "2.0.0-next.97",
+  "version": "2.0.0-next.98",
   "dependencies": {
     "@aws-amplify/adapter-nextjs": "^1.7.3",
     "@aws-crypto/sha256-js": "5.2.0",

package/routes.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.0.0-next.97",
+  "version": "2.0.0-next.98",
   "routes": [
     {
       "file": "app/%5F_preview/[[...path]]/route.ts",