@anthusai/papyrus 2.0.0-next.8 → 2.0.0-next.80

package/lib/editorial-checks-backend.ts

@@ -1,7 +1,7 @@
 import type { EditorialCheckResult, EditorialFeedbackInput, EditorialFinding, RewriteResult, Span } from "./editorial-checks";
 import type { EditorialSettings } from "./editorial-checks-settings";
 
-/** What the article editor needs from editorial checks: the plugin's GraphQL API, or the demo. */
+/** What the article editor needs from editorial checks: the site's GraphQL API, or the demo. */
 export type EditorialChecksBackend = {
   loadSettings: () => Promise<{ settings: EditorialSettings; exists: boolean }>;
   dismissedFindingIds: (itemId: string) => Promise<Set<string>>;

package/lib/editorial-checks-client.ts

@@ -161,6 +161,24 @@ export async function importStarterPack(name: string): Promise<{ created: number
   return parsed(data.importEditorialStarterPack);
 }
 
+export type StarterPackSummary = {
+  name: string;
+  title: string;
+  version?: string | null;
+  language?: string | null;
+  guidance?: string | null;
+  policyCount: number;
+  importedCount: number;
+  isDefault: boolean;
+  policies: { id: string; title?: string | null; severity?: string | null; tags: string[]; lanes: string[] }[];
+};
+
+/** The starter packs the site's Humanus ships, with how many of each pack's policies the site already has. */
+export async function listStarterPacks(): Promise<{ humanusVersion?: string | null; packs: StarterPackSummary[] }> {
+  const data = await call<{ listEditorialStarterPacks: unknown }>(`query ListStarterPacks { listEditorialStarterPacks }`);
+  return parsed(data.listEditorialStarterPacks);
+}
+
 export async function tryPolicy(policy: Record<string, unknown>, text: string): Promise<EditorialCheckResult> {
   const data = await call<{ tryEditorialPolicy: unknown }>(
     `query TryEditorialPolicy($policy: AWSJSON!, $text: String!) { tryEditorialPolicy(policy: $policy, text: $text, format: "markus") }`,
@@ -184,7 +202,7 @@ export async function recalibrate(): Promise<{ updated: number; detectors: { pol
   return parsed(data.recalibrateEditorialPolicies);
 }
 
-/** The plugin's GraphQL API, signed in as the editor. */
+/** The site's GraphQL API, signed in as the editor. */
 export const graphqlEditorialBackend: EditorialChecksBackend = {
   loadSettings,
   dismissedFindingIds,

package/lib/editorial-checks-demo.ts

@@ -1,7 +1,7 @@
 /**
  * Demo-mode editorial checks: no backend, a few stock phrases, canned rewrites.
- * The shapes match Limatus results so the editor, the preview marks and the
- * rewrite flow behave as they do against the real plugin.
+ * The shapes match Humanus results so the editor, the preview marks and the
+ * rewrite flow behave as they do against the real backend.
  */
 import type { EditorialCheckResult, EditorialFinding, EditorialSegment, RewriteResult, Span } from "./editorial-checks";
 import type { EditorialChecksBackend } from "./editorial-checks-backend";

package/lib/editorial-checks-settings.ts

@@ -1,5 +1,7 @@
 /** Runtime settings for editorial checks, stored in EditorialCheckSettings (id "settings"). */
 export type EditorialSettings = {
+  /** Core to every site and on by default; a publication turns its checks off here. */
+  enabled: boolean;
   lanes: { rules: boolean; classifier: boolean };
   classifierModel: string;
   rewriteModel: string;
@@ -12,6 +14,7 @@ export type EditorialSettings = {
 };
 
 export const DEFAULT_EDITORIAL_SETTINGS: EditorialSettings = {
+  enabled: true,
   lanes: { rules: true, classifier: true },
   classifierModel: "jev-latest",
   rewriteModel: "gpt-6-luna",

package/lib/editorial-checks.ts

@@ -1,11 +1,8 @@
 /**
- * Editorial checks: the Limatus result shapes the newsroom uses, and pure helpers
- * over them. Limatus counts offsets in UTF-16 code units, which is exactly how
+ * Editorial checks: the Humanus result shapes the newsroom uses, and pure helpers
+ * over them. Humanus counts offsets in UTF-16 code units, which is exactly how
  * JavaScript indexes strings, so spans apply to the body text as they are.
  */
-import { pluginSettings, type PluginOutputs } from "./plugin-settings";
-
-export const EDITORIAL_CHECKS_PLUGIN = "editorial-checks";
 
 export type Span = { start: number; end: number };
 export type Severity = "info" | "warn" | "error";
@@ -41,7 +38,8 @@ export type EditorialSegment = {
   text?: string;
 };
 
-export type LaneStatus = { status: "ran" | "disabled" | "unavailable" | "failed" | "partial"; reason?: string; detectors?: number };
+/** "skipped": Papyrus did not ask for judgments because the publication has no mission or policy for them to apply. */
+export type LaneStatus = { status: "ran" | "disabled" | "unavailable" | "failed" | "partial" | "skipped"; reason?: string; detectors?: number };
 
 export type EditorialCheckResult = {
   schemaVersion: 1;
@@ -52,7 +50,8 @@ export type EditorialCheckResult = {
   protected: { kind: string; start: number; end: number }[];
   findings: EditorialFinding[];
   coverage: unknown[];
-  lanes: { rules: LaneStatus; classifier: LaneStatus };
+  /** lanes.section is "skipped" when the story's section has no NewsroomSection record to take a mission and policy from. */
+  lanes: { rules: LaneStatus; classifier: LaneStatus; section?: LaneStatus };
   usage?: Record<string, number>;
 };
 
@@ -91,10 +90,6 @@ export const UNSAVED_ITEM_ID = "unsaved";
 
 const SEVERITY_ORDER: Record<Severity, number> = { error: 0, warn: 1, info: 2 };
 
-export function editorialChecksEnabled(outputs: PluginOutputs | null | undefined): boolean {
-  return pluginSettings(outputs, EDITORIAL_CHECKS_PLUGIN) !== null;
-}
-
 /** Findings worth showing: not dismissed, not covering the whole document, most severe first, then in reading order. */
 export function visibleFindings(findings: EditorialFinding[], dismissed: ReadonlySet<string>): EditorialFinding[] {
   return findings
@@ -171,8 +166,10 @@ export function describeProbability(finding: EditorialFinding): string | null {
 
 export function laneNotice(result: EditorialCheckResult): string | null {
   const classifier = result.lanes.classifier;
+  if (classifier.status === "skipped") return `Mission-based checks skipped: ${classifier.reason ?? "this publication has no mission yet"}.`;
   if (classifier.status === "partial") return `Some sentences were not judged: ${classifier.reason ?? "the check ran out of time"}.`;
   if (classifier.status === "failed") return `The judgment checks failed: ${classifier.reason ?? "unknown error"}. Rule checks still ran.`;
   if (classifier.status === "unavailable" && (classifier.detectors ?? 0) === 0 && classifier.reason) return `Judgment checks are not configured: ${classifier.reason}.`;
+  if (result.lanes.section?.status === "skipped") return `Section-based checks skipped: ${result.lanes.section.reason ?? "no section configuration"}.`;
   return null;
 }

package/lib/editorial-preview.ts

@@ -1,12 +1,12 @@
 /**
- * Places Limatus findings on the rendered Markus preview.
+ * Places Humanus findings on the rendered Markus preview.
  *
- * Limatus reports spans in the markup; the preview renders an IR tree with no
+ * Humanus reports spans in the markup; the preview renders an IR tree with no
  * character offsets. Both sides agree on the words a reader sees, so findings
- * are placed by text: each Limatus paragraph is matched, in document order, to
+ * are placed by text: each Humanus paragraph is matched, in document order, to
  * the rendered prose block with the same words, and each finding's plain
  * excerpt is located inside that block. Whitespace is ignored while matching,
- * because rendering and Limatus collapse it differently (citations, breaks).
+ * because rendering and Humanus collapse it differently (citations, breaks).
  *
  * "Rendered text" is defined by `inlineLeaves`, which the preview renderer also
  * uses, so offsets computed here are offsets the renderer can split on.
@@ -131,7 +131,7 @@ function blockKey(text: string): string {
   return compact(text).value.replace(/[*_`~]/g, "");
 }
 
-/** Match every Limatus paragraph to a rendered block and place its findings and sentences there. */
+/** Match every Humanus paragraph to a rendered block and place its findings and sentences there. */
 export function planPreview(
   document: MarkusDocument,
   result: EditorialCheckResult,

package/lib/monitoring-client.ts

@@ -0,0 +1,29 @@
+"use client";
+
+import { generateClient } from "aws-amplify/data";
+import type { MonitoringResult } from "./monitoring-overview";
+
+type GraphQLResult = { data?: { monitoringOverview?: unknown }; errors?: { message?: string; errorType?: string }[] };
+
+/**
+ * Reads the monitoring overview through the site's own authenticated API (user pool, editor or admin).
+ * The browser holds no table name, key or secret: the function behind the query does the read.
+ */
+export async function loadMonitoringOverview(scope: "publication" | "all"): Promise<MonitoringResult> {
+  const client = generateClient({ authMode: "userPool" });
+  let result: GraphQLResult;
+  try {
+    result = (await client.graphql({
+      query: `query MonitoringOverview($scope: String) { monitoringOverview(scope: $scope) }`,
+      variables: { scope },
+    })) as GraphQLResult;
+  } catch (error) {
+    // Amplify throws the response when AppSync returns errors.
+    result = (error && typeof error === "object" && "errors" in error ? error : { errors: [{ message: "failed" }] }) as GraphQLResult;
+  }
+  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?.monitoringOverview === undefined || result.data.monitoringOverview === null) return { state: "unavailable" };
+  const raw = result.data.monitoringOverview;
+  return (typeof raw === "string" ? JSON.parse(raw) : raw) as MonitoringResult;
+}

package/lib/monitoring-overview-fixture.ts

@@ -0,0 +1,51 @@
+import type { MonitoringOverview } from "./monitoring-overview";
+
+/** A realistic overview for tests and the `?demo=1` newsroom. Public Hacker News titles only. */
+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,
+    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: [] },
+    { runId: "r1", startedAt: "2026-10-21T02:18:00.000000Z", status: "complete", new: 0, revised: 0, unchanged: 30, itemCount: 30, errorCount: 0, errors: [] },
+    { runId: "r0", startedAt: "2026-10-21T02:03:00.000000Z", status: "partial", new: 1, revised: 0, unchanged: 28, itemCount: 30, errorCount: 1, errors: ["ConnectionError: timeout"] },
+  ],
+  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 },
+  usage: { day: "2026-10-21", decisionsToday: 2, decisionsTotal: 3, ceilings: { decisionsTotal: 300, decisionsPerDay: 100, items: 300 } },
+  hiddenNotRelevant: 1,
+  items: [
+    { sourceId: "104", revision: 1, title: "Fresh Show HN", url: "https://example.org/104", discussionUrl: "https://news.ycombinator.com/item?id=104",
+      observedAt: "2026-10-21T02:30:00.000000Z", routing: "collected", routingNote: null, decidedAt: null,
+      relevance: [{ publicationId: "desk-a", site: "a.example.test", relevant: null, label: null, confidence: null, delivery: { state: null } }] },
+    { sourceId: "105", revision: 1, title: "Broken request", url: "https://example.org/105", discussionUrl: "https://news.ycombinator.com/item?id=105",
+      observedAt: "2026-10-21T01:30:00.000000Z", routing: "error", routingNote: "invalid request: bad title", decidedAt: null,
+      relevance: [{ publicationId: "desk-a", site: "a.example.test", relevant: null, label: null, confidence: null, delivery: { state: null } }] },
+    { sourceId: "101", revision: 1, title: "Quantum paper on arXiv", url: "https://example.org/101", discussionUrl: "https://news.ycombinator.com/item?id=101",
+      observedAt: "2026-10-21T00:10:00.000000Z", routing: "routed", routingNote: null, decidedAt: "2026-10-21T01:00:00Z",
+      relevance: [{ publicationId: "desk-a", site: "a.example.test", relevant: true, label: "include", confidence: 0.91,
+        delivery: { state: "delivered", referenceId: "ref-1", referenceLineageId: "lin-1", deliveredAt: "2026-10-21T01:00:05Z" } }] },
+    { sourceId: "103", revision: 1, title: "Phishing kit leaks", url: "https://example.org/103", discussionUrl: "https://news.ycombinator.com/item?id=103",
+      observedAt: "2026-10-20T23:00:00.000000Z", routing: "decided", routingNote: null, decidedAt: "2026-10-20T23:10:00Z",
+      relevance: [{ publicationId: "desk-a", site: "a.example.test", relevant: true, label: "include", confidence: 0.7,
+        delivery: { state: "failed", error: "ClientError: throttled", attempts: 2 } }] },
+  ],
+};
+
+export const FIXTURE_ALL_PIPELINE_OVERVIEW: MonitoringOverview = {
+  ...FIXTURE_MONITORING_OVERVIEW,
+  scope: { mode: "all", publicationId: "desk-a", site: "a.example.test", canViewAll: true },
+  hiddenNotRelevant: 0,
+  items: FIXTURE_MONITORING_OVERVIEW.items.map((item) => item.sourceId !== "101" ? item : {
+    ...item,
+    relevance: [
+      ...item.relevance,
+      { publicationId: "desk-b", site: "b.example.test", relevant: false, label: "exclude", confidence: 0.8, delivery: { state: "not_applicable" } },
+      { publicationId: "desk-c", site: "desk-c", relevant: true, label: "include", confidence: null,
+        delivery: { state: "delivered", referenceId: "ref-2", referenceLineageId: "lin-2" } },
+    ],
+  }),
+};

package/lib/monitoring-overview.ts

@@ -0,0 +1,145 @@
+/** Shapes and wording for the newsroom Monitoring page. The function in src/papyrus_content/monitoring_view.py produces them. */
+import { getNewsroomNavHref } from "./newsroom-nav";
+
+export type MonitoringDeliveryState = "delivered" | "failed" | "pending" | "not_applicable" | null;
+
+export type MonitoringRelevance = {
+  publicationId: string;
+  site: string | null;
+  relevant: boolean | null;
+  label: string | null;
+  confidence: number | null;
+  delivery: {
+    state: MonitoringDeliveryState;
+    referenceId?: string | null;
+    referenceLineageId?: string | null;
+    deliveredAt?: string | null;
+    error?: string | null;
+    attempts?: number | null;
+  };
+};
+
+export type MonitoringItem = {
+  sourceId: string;
+  revision: number;
+  title: string;
+  url: string | null;
+  discussionUrl: string | null;
+  observedAt: string | null;
+  routing: string;
+  routingNote: string | null;
+  decidedAt: string | null;
+  relevance: MonitoringRelevance[];
+};
+
+export type MonitoringRun = {
+  runId: string;
+  startedAt: string;
+  status: string;
+  new: number;
+  revised: number;
+  unchanged: number;
+  itemCount: number | null;
+  errorCount: number;
+  errors: (string | null)[];
+};
+
+export type MonitoringRouterRun = {
+  runId: string;
+  startedAt: string;
+  mode: string;
+  status: string;
+  stoppedBy: string | null;
+  waitingForClassifier?: string[];
+  counts: Record<string, number>;
+  errorCount: number;
+};
+
+export type MonitoringFeed = {
+  id: string;
+  sourceUrl: string | null;
+  intervalSeconds: number | null;
+  limit: number | null;
+  enabled: boolean;
+  lastStatus: string | null;
+  lastFinishedAt: string | null;
+  nextDueAt: string | null;
+};
+
+export type MonitoringOverview = {
+  state: "ready" | "empty";
+  asOf: string;
+  notice?: "publication_not_routed";
+  scope: { mode: "publication" | "all"; publicationId: string | null; site: string | null; canViewAll: boolean };
+  feeds: MonitoringFeed[];
+  runs: MonitoringRun[];
+  routerRuns: MonitoringRouterRun[];
+  router: { mode: string; feedback: boolean; enabled: boolean; maxItemsPerRun: number | null } | null;
+  usage: {
+    day: string;
+    decisionsToday: number;
+    decisionsTotal: number;
+    ceilings: { decisionsTotal?: number; decisionsPerDay?: number; items?: number } | null;
+  } | null;
+  items: MonitoringItem[];
+  hiddenNotRelevant: number;
+};
+
+export type MonitoringResult =
+  | MonitoringOverview
+  | { state: "not_configured" }
+  | { state: "unavailable" }
+  | { error: "forbidden" | "bad_request" };
+
+const ROUTING_WORDS: Record<string, string> = {
+  collected: "Collected, waiting for the router",
+  "dry-run-validated": "Checked in a dry run, not sent",
+  decided: "Judged, delivery not finished",
+  routed: "Routed",
+  refused: "Refused by the shared Cyclotron",
+  uncertain: "Uncertain, needs a person",
+  error: "Error",
+};
+
+export function routingLabel(routing: string): string {
+  return ROUTING_WORDS[routing] ?? routing;
+}
+
+/** Fixed-format UTC time so the page reads the same everywhere. */
+export function formatUtc(iso: string | null | undefined): string {
+  if (!iso) return "never";
+  const match = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2})/.exec(iso);
+  return match ? `${match[1]} ${match[2]} UTC` : iso;
+}
+
+export function confidenceText(confidence: number | null): string {
+  return confidence === null ? "confidence not reported" : `${Math.round(confidence * 100)}% confidence`;
+}
+
+export function usageText(used: number, ceiling: number | undefined): string {
+  return ceiling === undefined ? `${used} used, no ceiling set` : `${used} of ${ceiling}`;
+}
+
+export function everyText(seconds: number | null): string {
+  if (!seconds) return "on a schedule";
+  return seconds % 3600 === 0 ? `every ${seconds / 3600} h` : seconds % 60 === 0 ? `every ${seconds / 60} min` : `every ${seconds} s`;
+}
+
+export function referenceHref(lineageId: string, demo?: boolean): string {
+  return getNewsroomNavHref(`/newsroom/references/${encodeURIComponent(lineageId)}`, demo);
+}
+
+export function describeRelevance(entry: MonitoringRelevance): string {
+  if (entry.relevant === null) return "Not judged yet";
+  return entry.relevant ? "Relevant" : "Not relevant";
+}
+
+export function describeDelivery(entry: MonitoringRelevance): string {
+  switch (entry.delivery.state) {
+    case "delivered": return "In the References queue";
+    case "failed": return "Not in the References queue: delivery failed";
+    case "pending": return "Not in the References queue yet";
+    case "not_applicable": return "Nothing to deliver";
+    default: return "";
+  }
+}

package/lib/news-desk-session.ts

@@ -1,5 +1,4 @@
 import type { CategorySteeringDashboard } from "./category-repository";
-import { createEmptyCategorySteeringDashboard } from "./category-dashboard";
 import type { ReaderAuthSnapshot } from "../components/reader-auth-state";
 
 export type NewsDeskShellPhase =
@@ -59,26 +58,6 @@ export function beginDeskLoad(state: NewsDeskShellState, auth: ReaderAuthSnapsho
   };
 }
 
-export function beginAuthenticatedDeskHydration(
-  state: NewsDeskShellState,
-  auth: ReaderAuthSnapshot,
-  options: { canManageUsers: boolean },
-): NewsDeskShellState {
-  const dashboard = state.dashboard ?? {
-    ...createEmptyCategorySteeringDashboard(),
-    isPublicSkeleton: false,
-    canManageUsers: options.canManageUsers,
-  };
-  return {
-    ...state,
-    phase: state.dashboard ? "refreshing" : "loadingDesk",
-    auth,
-    dashboard,
-    stale: false,
-    error: null,
-  };
-}
-
 export function resolveSignedOut(state: NewsDeskShellState, auth: ReaderAuthSnapshot): NewsDeskShellState {
   return {
     ...state,
@@ -143,6 +122,18 @@ export function resolveDashboardFailure(
   };
 }
 
+/** An unverified session must never leave private records on screen. */
+export function resolveAccessFailure(state: NewsDeskShellState, error: string): NewsDeskShellState {
+  return {
+    ...state,
+    phase: "error",
+    auth: { status: "signedOut", label: "Signed out" },
+    dashboard: null,
+    stale: false,
+    error,
+  };
+}
+
 export function patchDashboard(
   state: NewsDeskShellState,
   patch: (dashboard: CategorySteeringDashboard) => CategorySteeringDashboard,