@anthusai/papyrus 5.42.0 → 5.43.0-next.1

package/components/reference-review-card.tsx

@@ -0,0 +1,383 @@
+"use client";
+
+import {
+  ArchiveIcon,
+  CheckIcon,
+  ChevronLeftIcon,
+  ChevronRightIcon,
+  CircleCheckIcon,
+  CircleXIcon,
+  ExternalLinkIcon,
+} from "lucide-react";
+import { useEffect, useRef, useState, type ReactNode, type PointerEvent as ReactPointerEvent } from "react";
+import { Button } from "./ui/button";
+import { cn } from "../lib/utils";
+import { REFERENCE_REJECTION_REASON_CODES, type ReferenceRejectionReasonCode } from "../lib/reference-policy";
+
+export type ReviewChoice = "accept" | "reject";
+
+/** The Cyclotron's answer in the card's own vocabulary: Accept or Reject. */
+export type CardPrediction =
+  | { state: "ready"; choice: ReviewChoice; confidence: number | null }
+  | { state: "none" }
+  | { state: "loading" }
+  | { state: "error" };
+
+export type ReviewCardDecision = {
+  note: string;
+  reasonCode: ReferenceRejectionReasonCode | null;
+};
+
+const REASON_LABELS: Record<ReferenceRejectionReasonCode, string> = {
+  out_of_scope: "Out of scope",
+  policy_exclusion: "Policy exclusion",
+  duplicate: "Duplicate",
+  low_quality: "Low quality",
+  unavailable: "Unavailable",
+  provenance: "Provenance",
+  other: "Other",
+};
+
+const CHOICE_LABEL: Record<ReviewChoice, string> = { accept: "Accept", reject: "Reject" };
+
+function percent(confidence: number | null): string | null {
+  return confidence === null ? null : `${Math.round(confidence * 100)}%`;
+}
+
+/**
+ * One reusable card for answering a single question: Accept or Reject. The Cyclotron's row is
+ * read-only; the human row is the real control and its answer is final. Saves on tap.
+ * Written so that story review can reuse it later: it knows nothing about references.
+ */
+export function ReviewCard({
+  children,
+  decided,
+  disabledReason,
+  initialNote = "",
+  initialReason = null,
+  itemId,
+  onArchive,
+  onDecide,
+  prediction,
+  summary,
+  title,
+  titleHref,
+}: {
+  children?: ReactNode;
+  /** The saved human answer, or null while the item is undecided. */
+  decided: ReviewChoice | null;
+  /** When set, the controls explain in words why they cannot change anything. */
+  disabledReason?: string | null;
+  initialNote?: string;
+  initialReason?: ReferenceRejectionReasonCode | null;
+  itemId: string;
+  onArchive?: () => Promise<void> | void;
+  onDecide: (choice: ReviewChoice, decision: ReviewCardDecision) => Promise<void> | void;
+  prediction: CardPrediction;
+  summary?: string | null;
+  title: string;
+  titleHref?: string | null;
+}) {
+  const [draft, setDraft] = useState<ReviewChoice | null>(null);
+  const [note, setNote] = useState(initialNote);
+  const [reason, setReason] = useState<ReferenceRejectionReasonCode | null>(initialReason);
+  const [saving, setSaving] = useState(false);
+  const [saved, setSaved] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const inFlight = useRef(false);
+  const noteTouched = useRef(false);
+  const reasonTouched = useRef(false);
+  const savedNote = useRef(initialNote);
+
+  // Saved values from outside (another editor, a reload) refresh whatever the human has not touched.
+  useEffect(() => {
+    savedNote.current = initialNote;
+    if (!noteTouched.current) setNote(initialNote);
+  }, [initialNote]);
+  useEffect(() => {
+    if (!reasonTouched.current) setReason(initialReason);
+  }, [initialReason]);
+
+  const chosen = draft ?? decided;
+
+  async function save(choice: ReviewChoice, nextReason: ReferenceRejectionReasonCode | null, nextNote: string) {
+    if (disabledReason || inFlight.current) return;
+    if (choice === "reject" && !nextReason) return;
+    inFlight.current = true;
+    setSaving(true);
+    setSaved(false);
+    setError(null);
+    try {
+      await onDecide(choice, { note: nextNote.trim(), reasonCode: choice === "reject" ? nextReason : null });
+      savedNote.current = nextNote.trim();
+      noteTouched.current = false;
+      reasonTouched.current = false;
+      setDraft(null);
+      setSaved(true);
+    } catch (failure) {
+      setDraft(null);
+      setError(failure instanceof Error ? failure.message : "Your answer could not be saved. Tap it again to retry.");
+    } finally {
+      inFlight.current = false;
+      setSaving(false);
+    }
+  }
+
+  function choose(choice: ReviewChoice) {
+    if (disabledReason) return;
+    if (chosen === choice && draft === null) return; // the selected answer never unselects itself
+    setError(null);
+    setDraft(choice);
+    void save(choice, reason, note);
+  }
+
+  function chooseReason(code: ReferenceRejectionReasonCode) {
+    if (disabledReason) return;
+    setReason(code);
+    reasonTouched.current = true;
+    if (chosen === "reject") void save("reject", code, note);
+  }
+
+  function commitNote() {
+    if (!decided || disabledReason || note.trim() === savedNote.current.trim()) return;
+    void save(decided, reason, note);
+  }
+
+  // Desktop shortcuts: A accepts, R rejects. Never while typing.
+  useEffect(() => {
+    function onKey(event: KeyboardEvent) {
+      const target = event.target as HTMLElement | null;
+      if (target && (target.isContentEditable || /^(INPUT|TEXTAREA|SELECT)$/.test(target.tagName))) return;
+      if (event.metaKey || event.ctrlKey || event.altKey) return;
+      if (event.key === "a" || event.key === "A") choose("accept");
+      if (event.key === "r" || event.key === "R") choose("reject");
+    }
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  });
+
+  const predictedMarker = (choice: ReviewChoice) => {
+    if (prediction.state !== "ready" || prediction.choice !== choice) return null;
+    return prediction.choice;
+  };
+  const matched = decided && prediction.state === "ready" ? prediction.choice === decided : null;
+
+  return (
+    <section aria-label="Review" className="space-y-4" data-review-card={itemId}>
+      <header className="space-y-1">
+        <h2 className="text-lg font-semibold leading-snug text-foreground">{title}</h2>
+        {titleHref ? (
+          <a className="inline-flex max-w-full items-center gap-1 truncate text-sm text-primary underline-offset-4 hover:underline" href={titleHref} rel="noreferrer" target="_blank">
+            <span className="truncate">{titleHref}</span>
+            <ExternalLinkIcon aria-hidden="true" className="size-3.5 shrink-0" />
+          </a>
+        ) : null}
+        {summary ? <p className="text-sm text-muted-foreground">{summary}</p> : null}
+      </header>
+
+      <div className="space-y-2" data-review-row="cyclotron">
+        <div className="flex items-center gap-3">
+          <span className="w-20 shrink-0 text-sm font-semibold">Cyclotron</span>
+          {prediction.state === "ready" ? (
+            <div className="flex flex-1 gap-2">
+              {(["accept", "reject"] as const).map((choice) => {
+                const predicted = predictedMarker(choice) !== null;
+                const verdict = predicted && matched !== null ? (matched ? "match" : "miss") : null;
+                return (
+                  <span
+                    className={cn(
+                      "inline-flex min-h-10 flex-1 items-center justify-center gap-1.5 rounded-md border px-3 text-sm",
+                      predicted ? "border-foreground bg-muted font-semibold" : "border-dashed text-muted-foreground",
+                      verdict === "match" && "border-green-700 bg-green-100 text-green-950",
+                      verdict === "miss" && "border-red-700 bg-red-100 text-red-950",
+                    )}
+                    data-cyclotron-choice={choice}
+                    data-predicted={predicted || undefined}
+                    data-verdict={verdict ?? undefined}
+                    key={choice}
+                  >
+                    {verdict === "match" ? <CircleCheckIcon aria-hidden="true" className="size-4" /> : null}
+                    {verdict === "miss" ? <CircleXIcon aria-hidden="true" className="size-4" /> : null}
+                    {CHOICE_LABEL[choice]}
+                    {predicted && percent(prediction.confidence) ? <small className="text-xs font-normal">{percent(prediction.confidence)}</small> : null}
+                    {verdict ? <span className="sr-only">{verdict === "match" ? ", matches your answer" : ", differs from your answer"}</span> : null}
+                  </span>
+                );
+              })}
+            </div>
+          ) : (
+            <p className="text-sm text-muted-foreground" data-cyclotron-state={prediction.state}>
+              {prediction.state === "loading" ? "Loading…" : prediction.state === "error" ? "Prediction unavailable" : "No prediction"}
+            </p>
+          )}
+        </div>
+      </div>
+
+      <div className="space-y-2" data-review-row="you">
+        <div className="flex items-center gap-3">
+          <span className="w-20 shrink-0 text-sm font-semibold">You</span>
+          <div className="flex flex-1 gap-2">
+            {(["accept", "reject"] as const).map((choice) => {
+              const on = chosen === choice;
+              return (
+                <Button
+                  aria-disabled={disabledReason ? true : undefined}
+                  aria-pressed={on}
+                  className="min-h-14 flex-1 text-base"
+                  data-review-choice={choice}
+                  key={choice}
+                  onClick={() => choose(choice)}
+                  type="button"
+                  variant={on ? (choice === "accept" ? "default" : "destructive") : "outline"}
+                >
+                  {on ? <CheckIcon aria-hidden="true" className="size-5" /> : null}
+                  {CHOICE_LABEL[choice]}
+                </Button>
+              );
+            })}
+          </div>
+        </div>
+        <div className="min-h-5 pl-[5.75rem] text-sm" role="status">
+          {saving ? "Saving…" : saved ? (
+            <span className="inline-flex items-center gap-1" data-review-saved><CheckIcon aria-hidden="true" className="size-4" />Saved</span>
+          ) : null}
+        </div>
+        {disabledReason ? <p className="text-sm text-muted-foreground" data-review-disabled-reason>{disabledReason}</p> : null}
+        {error ? <p className="text-sm text-destructive" role="alert">{error}</p> : null}
+      </div>
+
+      <label className="block text-sm font-medium">
+        Why? (optional)
+        <textarea
+          aria-label="Why? (optional)"
+          className="mt-1 block min-h-24 w-full rounded-md border bg-background p-3 text-base font-normal"
+          onBlur={commitNote}
+          onChange={(event) => { setNote(event.target.value); noteTouched.current = true; setSaved(false); }}
+          placeholder="Say what made this an easy yes or a clear no. Your note teaches the Cyclotron."
+          value={note}
+        />
+      </label>
+
+      {chosen === "reject" ? (
+        <div className="space-y-2" data-review-reasons>
+          <p className="text-sm font-medium">Reason for rejecting</p>
+          <div className="flex flex-wrap gap-2">
+            {REFERENCE_REJECTION_REASON_CODES.map((code) => (
+              <Button
+                aria-disabled={disabledReason ? true : undefined}
+                aria-pressed={reason === code}
+                className="min-h-10"
+                data-review-reason={code}
+                key={code}
+                onClick={() => chooseReason(code)}
+                type="button"
+                variant={reason === code ? "default" : "outline"}
+              >
+                {reason === code ? <CheckIcon aria-hidden="true" className="size-4" /> : null}
+                {REASON_LABELS[code]}
+              </Button>
+            ))}
+          </div>
+          {!reason ? <p className="text-sm text-muted-foreground">Choose a reason to save your Reject.</p> : null}
+        </div>
+      ) : null}
+
+      {children}
+
+      {onArchive ? (
+        <Button aria-label="Archive reference" onClick={() => { if (!disabledReason) void onArchive(); }} size="sm" type="button" variant="ghost">
+          <ArchiveIcon aria-hidden="true" className="size-4" />
+          Archive
+        </Button>
+      ) : null}
+    </section>
+  );
+}
+
+/** Sticky Previous / position / Next bar for working through a queue. */
+export function ReviewQueueBar({
+  caughtUp = false,
+  onNext,
+  onPrevious,
+  position,
+  total,
+}: {
+  caughtUp?: boolean;
+  onNext: () => void;
+  onPrevious: () => void;
+  /** 1-based position, or null when the open item is not in the queue. */
+  position: number | null;
+  total: number;
+}) {
+  const atStart = position === 1;
+  return (
+    <nav
+      aria-label="Review queue"
+      className="sticky bottom-0 z-10 flex shrink-0 items-center gap-2 border-t border-border bg-card px-3 py-2"
+      data-review-queue-bar
+    >
+      <Button
+        aria-disabled={atStart || undefined}
+        aria-label="Previous"
+        className={cn("min-h-12 flex-1 text-base", atStart && "opacity-60")}
+        onClick={() => { if (!atStart) onPrevious(); }}
+        type="button"
+        variant="outline"
+      >
+        <ChevronLeftIcon aria-hidden="true" className="size-5" />
+        Previous
+      </Button>
+      <span className="min-w-20 text-center text-sm" data-review-queue-position>
+        {caughtUp ? "All caught up" : position ? `${position} of ${total}` : `${total} in list`}
+      </span>
+      <Button
+        aria-disabled={caughtUp || undefined}
+        aria-label="Next"
+        className={cn("min-h-12 flex-1 text-base", caughtUp && "opacity-60")}
+        onClick={() => { if (!caughtUp) onNext(); }}
+        type="button"
+        variant="outline"
+      >
+        Next
+        <ChevronRightIcon aria-hidden="true" className="size-5" />
+      </Button>
+    </nav>
+  );
+}
+
+/** Swipe left for Next, right for Previous; ← and → on a keyboard. Never required. */
+export function useQueueGestures({ onNext, onPrevious }: { onNext: () => void; onPrevious: () => void }) {
+  const start = useRef<{ x: number; y: number } | null>(null);
+  const handlers = useRef({ onNext, onPrevious });
+  handlers.current = { onNext, onPrevious };
+
+  useEffect(() => {
+    function onKey(event: KeyboardEvent) {
+      const target = event.target as HTMLElement | null;
+      if (target && (target.isContentEditable || /^(INPUT|TEXTAREA|SELECT)$/.test(target.tagName))) return;
+      if (event.metaKey || event.ctrlKey || event.altKey || event.shiftKey) return;
+      if (event.key === "ArrowRight") handlers.current.onNext();
+      if (event.key === "ArrowLeft") handlers.current.onPrevious();
+    }
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, []);
+
+  return {
+    onPointerDown(event: ReactPointerEvent) {
+      if (event.pointerType !== "touch") return;
+      start.current = { x: event.clientX, y: event.clientY };
+    },
+    onPointerUp(event: ReactPointerEvent) {
+      const origin = start.current;
+      start.current = null;
+      if (!origin || event.pointerType !== "touch") return;
+      const dx = event.clientX - origin.x;
+      const dy = event.clientY - origin.y;
+      if (Math.abs(dx) < 60 || Math.abs(dx) < Math.abs(dy) * 2) return;
+      if (dx < 0) handlers.current.onNext();
+      else handlers.current.onPrevious();
+    },
+    style: { touchAction: "pan-y" } as const,
+  };
+}

package/components/topic-steering-workspace.tsx

@@ -17,6 +17,7 @@ import { EditorialChecksAdminPanel } from "./editorial-checks-admin-panel";
 import { AutomationPanel } from "./automation-panel";
 import { MonitoringPanel } from "./monitoring-panel";
 import { ModerationPanel } from "./moderation-panel";
+import { ProposalsPanel } from "./proposals-panel";
 import { NewsletterPanel } from "./newsletter-panel";
 import { SignupEntriesPanel } from "./signup-entries-panel";
 import { pluginSettings, type PluginOutputs } from "../lib/plugin-settings";
@@ -256,7 +257,7 @@ type AssignmentAction = "claim" | "release" | "complete" | "cancel" | "reopen" |
 type ReportingPacketReviewDecision = "select" | "merge" | "brief" | "hold" | "kill";
 type AssignmentDeskViewMode = "queue" | "budget";
 type UserRoleAction = "grant" | "revoke";
-type AdministrationPanel = "users" | "policies" | "sections" | "procedures" | "automations" | "delegations" | "signups" | "newsletter" | "moderation" | "editorial-checks" | "monitoring";
+type AdministrationPanel = "users" | "policies" | "sections" | "procedures" | "automations" | "delegations" | "signups" | "newsletter" | "moderation" | "proposals" | "editorial-checks" | "monitoring";
 export type NewsDeskTab = "overview" | "desks" | "topics" | "concepts" | "references" | "messages" | "assignments" | "administration" | "search";
 type LexicalRuleScope = "publication" | "corpus" | "classifier" | "category";
 type AnalysisReindexMode = "online-update" | "classifier-retrain" | "scoped-topic-rebuild" | "entity-graph-rebuild" | "generated-analysis-rebuild";
@@ -4398,6 +4399,15 @@ function AdministrationDeskView({
                   <span>Subscribers, issues and delivery for the site&apos;s email</span>
                 </Link>
               ) : null}
+              <Link
+                href={administrationPanelHref("proposals", isDemo)}
+                data-news-desk-admin-nav="proposals"
+                data-active={administrationPanel === "proposals" || undefined}
+                onClick={() => onPanelChange("proposals")}
+              >
+                <strong>Proposals</strong>
+                <span>Story drafts and changes that AI proposes</span>
+              </Link>
               {readerPluginEnabled() ? (
                 <Link
                   href={administrationPanelHref("moderation", isDemo)}
@@ -4413,6 +4423,7 @@ function AdministrationDeskView({
             <div className="news-desk-settings-panel">
               {administrationPanel === "signups" ? <SignupEntriesPanel /> : null}
               {administrationPanel === "newsletter" ? <NewsletterPanel isAdmin={canManageUsers} isDemo={isDemo} /> : null}
+              {administrationPanel === "proposals" ? <ProposalsPanel /> : null}
               {administrationPanel === "moderation" ? <ModerationPanel /> : null}
               {administrationPanel === "editorial-checks" ? <EditorialChecksAdminPanel /> : null}
               {administrationPanel === "automations" ? <AutomationPanel isDemo={isDemo} /> : null}
@@ -12890,7 +12901,7 @@ function readerPluginEnabled(): boolean {
 }
 
 function normalizeAdministrationPanel(value: string | null | undefined, demo = false): AdministrationPanel {
-  if (value === "policies" || value === "sections" || value === "procedures" || value === "automations" || value === "delegations" || value === "editorial-checks" || value === "monitoring") return value;
+  if (value === "policies" || value === "sections" || value === "procedures" || value === "automations" || value === "delegations" || value === "editorial-checks" || value === "monitoring" || value === "proposals") return value;
   if (value === "signups" && signupPluginEnabled()) return value;
   if (value === "newsletter" && newsletterPluginEnabled(demo)) return value;
   if (value === "moderation" && readerPluginEnabled()) return value;

package/components/use-console-visibility.ts

@@ -0,0 +1,47 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+
+export function useConsoleVisibility({ available, persist = true }: { available: boolean; persist?: boolean }) {
+  const [open, setOpen] = useState(false);
+  const visible = useRef(false);
+  const entry = useRef<string | null>(null);
+  const setVisible = useCallback((next: boolean) => {
+    visible.current = next;
+    setOpen(next);
+    if (persist) try { localStorage.setItem("papyrus:console-open", String(next)); } catch { /* Optional preference. */ }
+  }, [persist]);
+  const openConsole = useCallback(() => {
+    if (!available || visible.current) return;
+    const existing = history.state?.papyrusMobileChat;
+    if (typeof existing === "string") entry.current = existing;
+    else if (matchMedia("(max-width: 900px)").matches) {
+      entry.current = crypto.randomUUID();
+      history.pushState({ ...history.state, papyrusMobileChat: entry.current }, "", location.href);
+    }
+    setVisible(true);
+  }, [available, setVisible]);
+  const closeConsole = useCallback(() => {
+    if (entry.current && history.state?.papyrusMobileChat === entry.current) history.back();
+    else setVisible(false);
+  }, [setVisible]);
+  const toggleOpen = useCallback(() => {
+    if (visible.current) closeConsole();
+    else openConsole();
+  }, [closeConsole, openConsole]);
+  useEffect(() => {
+    if (!available) {
+      visible.current = false;
+      setOpen(false);
+      return;
+    }
+    const pop = (event: PopStateEvent) => {
+      if (entry.current) setVisible(event.state?.papyrusMobileChat === entry.current);
+    };
+    window.addEventListener("popstate", pop);
+    if (typeof history.state?.papyrusMobileChat === "string") openConsole();
+    else if (persist) try { if (localStorage.getItem("papyrus:console-open") === "true") openConsole(); } catch { /* Optional preference. */ }
+    return () => window.removeEventListener("popstate", pop);
+  }, [available, openConsole, persist, setVisible]);
+  return { open, openConsole, closeConsole, toggleOpen };
+}

package/lib/cli-login-discovery.ts

@@ -0,0 +1,78 @@
+import { NextResponse, type NextRequest } from "next/server";
+import { readAmplifyOutputsFile } from "./amplify-outputs-path";
+import { SiteOriginNotConfiguredError, publicSiteOrigin, siteOriginNotConfiguredResponse } from "./site-origin";
+
+/**
+ * The public values `papyrus login <site>` needs, served at `/.well-known/papyrus-cli.json`.
+ * Every value is public (Cognito pool/client ids, hosted-UI domain, API URL). Nothing here is a
+ * secret, and the file only exists for a site whose web client registers the CLI callback.
+ */
+export const CLI_LOGIN_PATH = "/.well-known/papyrus-cli.json";
+
+export interface CliLoginDocument {
+  publication: string;
+  issuer: string;
+  client_id: string;
+  oauth_domain: string;
+  graphql_endpoint: string;
+  callback_uri: string;
+}
+
+export interface AmplifyOutputsForCliLogin {
+  auth?: {
+    user_pool_id?: string;
+    user_pool_client_id?: string;
+    aws_region?: string;
+    oauth?: { domain?: string; redirect_sign_in_uri?: string[] };
+  };
+  data?: { url?: string };
+}
+
+/**
+ * The CLI signs in through the site's existing public web app client, which every app-shell site
+ * registers with this callback (infra/amplify-app-shell/lib/site-config.ts). No separate client exists.
+ */
+export const CLI_CALLBACK_URI = "http://localhost:3001/";
+
+export function cliLoginDocumentFromOutputs(outputs: AmplifyOutputsForCliLogin | null, siteOrigin: string): CliLoginDocument | null {
+  const userPoolId = outputs?.auth?.user_pool_id;
+  const clientId = outputs?.auth?.user_pool_client_id;
+  const domain = outputs?.auth?.oauth?.domain;
+  const endpoint = outputs?.data?.url;
+  if (!userPoolId || !clientId || !domain || !endpoint || !endpoint.startsWith("https://")) return null;
+  // Only when the client really registers the callback; otherwise the sign-in could never complete.
+  if (!outputs?.auth?.oauth?.redirect_sign_in_uri?.includes(CLI_CALLBACK_URI)) return null;
+  const region = outputs?.auth?.aws_region ?? userPoolId.split("_")[0];
+  return {
+    publication: siteOrigin,
+    issuer: `https://cognito-idp.${region}.amazonaws.com/${userPoolId}`,
+    client_id: clientId,
+    oauth_domain: `https://${domain}`,
+    graphql_endpoint: endpoint,
+    callback_uri: CLI_CALLBACK_URI,
+  };
+}
+
+export interface CliLoginDiscoveryOptions {
+  readOutputs?: () => AmplifyOutputsForCliLogin | null;
+  environment?: Record<string, string | undefined>;
+}
+
+export function handleCliLoginDiscovery(request: Pick<NextRequest, "nextUrl">, options: CliLoginDiscoveryOptions = {}): NextResponse {
+  let origin: string;
+  try {
+    origin = publicSiteOrigin(request, options.environment ?? process.env);
+  } catch (error) {
+    if (error instanceof SiteOriginNotConfiguredError) return siteOriginNotConfiguredResponse(error);
+    throw error;
+  }
+  const outputs = (options.readOutputs ?? (() => readAmplifyOutputsFile() as AmplifyOutputsForCliLogin | null))();
+  const document = cliLoginDocumentFromOutputs(outputs, origin);
+  if (!document) {
+    return NextResponse.json(
+      { error: "cli_login_not_configured", message: "This site does not register the CLI sign-in callback." },
+      { status: 404, headers: { "cache-control": "public, max-age=60" } },
+    );
+  }
+  return NextResponse.json(document, { headers: { "cache-control": "public, max-age=300" } });
+}

package/lib/monitoring-client.ts

@@ -10,7 +10,7 @@ import type {
   MonitoringResult,
 } from "./monitoring-overview";
 
-type QueryField = "monitoringOverview" | "monitoringEmailSubmission" | "monitoringResolveEmailArticleLink" | "intakeEmailSubmissionReferences";
+type QueryField = "monitoringOverview" | "monitoringEmailSubmission" | "monitoringResolveEmailArticleLink" | "intakeEmailSubmissionReferences" | "monitoringQueueEmailReference";
 type GraphQLResult = { data?: Partial<Record<QueryField, unknown>>; errors?: { message?: string; errorType?: string }[] };
 
 async function query<T>(field: QueryField, queryText: string, variables: Record<string, string | number>): Promise<T | { error: "forbidden" } | { state: "unavailable" }> {
@@ -74,10 +74,19 @@ export async function importMonitoringEmailCandidates(
     } 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)) {
+    if (!response?.ok || !Array.isArray(response.references) || response.references.length !== batch.length) {
       return { imported: references.length, references, error: "The import was not accepted. Check your editor access and retry." };
     }
     references.push(...response.references);
+    for (const [index, reference] of response.references.entries()) {
+      const queued = await query<{ queued: boolean }>("monitoringQueueEmailReference",
+        `mutation MonitoringQueueEmailReference($input: AWSJSON!) { monitoringQueueEmailReference(input: $input) }`,
+        { input: JSON.stringify({ receiptId, ...batch[index], referenceId: reference.id }) });
+      if (!("queued" in queued) || !queued.queued) {
+        return { imported: references.length, references,
+          error: "References were registered, but predictions could not be queued. Retry these selected links safely." };
+      }
+    }
   }
   return { imported: references.length, references };
 }

package/lib/monitoring-overview-fixture.ts

@@ -5,7 +5,7 @@ export const FIXTURE_MONITORING_OVERVIEW: MonitoringOverview = {
   state: "ready",
   asOf: "2026-10-21T02:40:00Z",
   scope: { mode: "publication", publicationId: "desk-a", site: "a.example.test", canViewAll: true },
-  feeds: [{ id: "hn", sourceUrl: "https://news.ycombinator.com/rss", intervalSeconds: 900, limit: 30, enabled: true,
+  feeds: [{ id: "hn", sourceUrl: "https://news.ycombinator.com/rss", intervalSeconds: 900, enabled: true,
     lastStatus: "complete", lastFinishedAt: "2026-10-21T02:33:00Z", nextDueAt: "2026-10-21T02:50:00Z" }],
   runs: [
     { runId: "r3", startedAt: "2026-10-21T02:33:00.000000Z", status: "complete", new: 2, revised: 1, unchanged: 27, itemCount: 30, errorCount: 0, errors: [] },
@@ -14,7 +14,7 @@ export const FIXTURE_MONITORING_OVERVIEW: MonitoringOverview = {
   ],
   routerRuns: [{ runId: "q2", startedAt: "2026-10-21T02:37:00.000000Z", mode: "live", status: "stopped", stoppedBy: "request_ceiling_reached",
     counts: { examined: 3, decided: 1, delivered: 1, deliveryFailed: 1, routed: 1 }, errorCount: 0 }],
-  router: { mode: "live", feedback: true, enabled: true, maxItemsPerRun: 5 },
+  router: { mode: "live", feedback: true, enabled: true },
   usage: { day: "2026-10-21", decisionsToday: 2, decisionsTotal: 3, historyComplete: true },
   hiddenNotRelevant: 1,
   items: [

package/lib/monitoring-overview.ts

@@ -106,7 +106,6 @@ export type MonitoringFeed = {
   id: string;
   sourceUrl: string | null;
   intervalSeconds: number | null;
-  limit: number | null;
   enabled: boolean;
   lastStatus: string | null;
   lastFinishedAt: string | null;
@@ -121,7 +120,7 @@ export type MonitoringOverview = {
   feeds: MonitoringFeed[];
   runs: MonitoringRun[];
   routerRuns: MonitoringRouterRun[];
-  router: { mode: string; feedback: boolean; enabled: boolean; maxItemsPerRun: number | null } | null;
+  router: { mode: string; feedback: boolean; enabled: boolean } | null;
   usage: {
     day: string;
     decisionsToday: number;

package/lib/newsroom-chat-client.ts

@@ -0,0 +1,30 @@
+export type NewsroomChatFetch = typeof fetch;
+
+export function createNewsroomChatFetch(
+  accessToken: () => Promise<string | null>,
+  fetcher: NewsroomChatFetch,
+): NewsroomChatFetch {
+  return async (input, init) => {
+    if (typeof input !== "string" || (!input.startsWith("/api/newsroom/chat/") && !input.startsWith("/api/auth/prospectus/"))) {
+      throw new Error("Newsroom credentials can only be sent to this site's chat identity routes.");
+    }
+    const token = await accessToken();
+    if (!token) throw new Error("sign_in_required");
+    const headers = new Headers(init?.headers);
+    headers.set("authorization", `Bearer ${token}`);
+    return fetcher(input, { ...init, headers, credentials: "same-origin", cache: "no-store" });
+  };
+}
+
+export const newsroomChatFetch: NewsroomChatFetch = createNewsroomChatFetch(async () => {
+  const { fetchAuthSession } = await import("aws-amplify/auth");
+  const session = await fetchAuthSession();
+  return session.tokens?.accessToken?.toString() ?? null;
+}, (input, init) => globalThis.fetch(input, init));
+
+export async function connectNewsroomChat(returnPath: string, fetcher: NewsroomChatFetch = newsroomChatFetch): Promise<string> {
+  const response = await fetcher(`/api/auth/prospectus/sign-in?newsroomChat=true&returnTo=${encodeURIComponent(returnPath)}`, { method: "POST" });
+  const body = await response.json() as { authorizationUrl?: string; message?: string };
+  if (!response.ok || !body.authorizationUrl) throw new Error(body.message ?? "Private chat could not connect to your publishing account.");
+  return body.authorizationUrl;
+}