@anthusai/papyrus 2.0.0-next.9 → 2.0.0-next.90

package/lib/automation-fixture.ts

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

package/lib/automation-overview.ts

@@ -0,0 +1,252 @@
+/** Shapes and wording for the newsroom Automation page. src/papyrus_content/automations.py produces them. */
+import { formatUtc } from "./monitoring-overview";
+import { getNewsroomNavHref } from "./newsroom-nav";
+
+export { formatUtc };
+
+export type AutomationUsage = {
+  calls?: number;
+  promptTokens?: number;
+  completionTokens?: number;
+  models?: Record<string, number>;
+  complete?: boolean;
+  unpricedModels?: string[];
+};
+
+export type AutomationRun = {
+  origin: "monitor" | "manual" | "stage";
+  /** The stage a story entered to start this run (origin "stage"). */
+  stage?: string | null;
+  requestedBy: string | null;
+  reason: string | null;
+  sourceId: string | null;
+  referenceId: string | null;
+  triggerStatus: string | null;
+  runId: string | null;
+  status: string | null;
+  startedAt: string | null;
+  finishedAt: string | null;
+  durationSeconds: number | null;
+  error: string | null;
+  runRecord: "found" | "missing" | "unavailable" | "none";
+  storyId: string | null;
+  /** False when no version of the story remains (it was deleted); null when this was not looked up. */
+  storyExists?: boolean | null;
+  /** Tool name to number of calls the procedure made, when the run recorded them. */
+  toolsUsed?: Record<string, number> | null;
+  storyVersionId: string | null;
+  storyTitle: string | null;
+  costUsd: number | null;
+  costNote: string;
+  budgetUsd: number | null;
+  overBudget: boolean;
+  usage: AutomationUsage | null;
+};
+
+/** A ProcedureRun of the same procedure that this automation did not start ("Started outside this automation"). */
+export type AutomationOutsideRun = {
+  runId: string | null;
+  status: string | null;
+  startedAt: string | null;
+  finishedAt: string | null;
+  durationSeconds: number | null;
+  error: string | null;
+  requestedBy: string | null;
+  storyId: string | null;
+  storyVersionId: string | null;
+  storyTitle: string | null;
+  costUsd: number | null;
+  costNote: string;
+  overBudget: boolean;
+};
+
+export type AutomationRunNow = { available: boolean; reason: string | null; needsInput: boolean; inputNames: string[] };
+
+export type AutomationLink = {
+  state: "linked" | "input_differs" | "trigger_not_found" | "publication_not_in_router" | "router_not_found" | "not_applicable";
+  text: string;
+  routerMode?: string | null;
+  routerEnabled?: boolean;
+};
+
+export type AutomationNotice = "monitoring_not_configured" | "monitoring_unavailable" | "other_publication" | "publication_not_routed" | "not yet supported";
+
+export type AutomationRecord = {
+  id: string;
+  title: string;
+  description: string | null;
+  enabled: boolean;
+  enabledNote: string;
+  trigger: { kind: "monitor" | "schedule" | "event" | "manual"; config: Record<string, unknown> };
+  /** Story-stage automations only: the stage that fires it, where the engine moves the story after, and the bot-hop limit. */
+  onStage?: string | null;
+  nextStage?: string | null;
+  maxHops?: number | null;
+  supported: boolean;
+  supportNote: string | null;
+  procedureKey: string;
+  inputTemplate: Record<string, string>;
+  limits: { timeoutSeconds?: number; maxConcurrent?: number; budgetUsdPerRun?: number };
+  limitsNote: string;
+  runNow: AutomationRunNow;
+  createdAt: string | null;
+  updatedAt: string | null;
+  link: AutomationLink | null;
+  runs: AutomationRun[];
+  lastRun: AutomationRun | null;
+  skippedAlreadyHadReference: number;
+  notice: AutomationNotice | null;
+  outsideRuns: AutomationOutsideRun[];
+  outsideNotice: "outside_unavailable" | null;
+};
+
+export type AutomationOverview = {
+  state: "ready" | "empty";
+  asOf: string;
+  monitoring: "ready" | "not_configured";
+  automations: AutomationRecord[];
+};
+
+export type AutomationResult = AutomationOverview | { state: "unavailable" } | { error: "forbidden" | "bad_request" };
+
+const KIND_WORDS: Record<string, string> = { monitor: "Monitor", schedule: "Schedule", event: "Event", manual: "Manual" };
+
+export function triggerText(trigger: AutomationRecord["trigger"]): string {
+  const kind = KIND_WORDS[trigger.kind] ?? trigger.kind;
+  if (trigger.kind === "monitor") {
+    return `${kind} ${String(trigger.config.monitorId ?? "?")}, delivering to ${String(trigger.config.publicationId ?? "?")}`;
+  }
+  if (trigger.kind === "event" && trigger.config.event === "story.stage_entered") {
+    const next = trigger.config.nextStage ? `, then moves it to ${String(trigger.config.nextStage)}` : "";
+    return `${kind}: a story enters ${String(trigger.config.onStage ?? "?")}${next}`;
+  }
+  return kind;
+}
+
+export const ENABLED_NOTE = "the router starts nothing for a disabled automation";
+
+export function enabledText(record: Pick<AutomationRecord, "enabled">): string {
+  return record.enabled ? "Enabled" : "Disabled";
+}
+
+const STATUS_WORDS: Record<string, string> = {
+  completed: "Completed",
+  failed: "Failed",
+  running: "Running",
+  starting: "Starting",
+  started: "Started, no result recorded yet",
+  startFailed: "Could not start",
+  notRunnable: "Not runnable",
+  notTriggered: "Not started",
+  skipped: "Skipped",
+  refused: "Refused",
+  deferred: "Deferred, waiting for room",
+};
+const STATUS_MARKS: Record<string, string> = {
+  completed: "✓", failed: "✕", startFailed: "✕", notRunnable: "✕", refused: "✕", skipped: "–", deferred: "…", started: "…", starting: "…", running: "…",
+};
+
+export function statusText(status: string | null | undefined): string {
+  return status ? (STATUS_WORDS[status] ?? status) : "No runs";
+}
+
+export function statusMark(status: string | null | undefined): string {
+  return status ? (STATUS_MARKS[status] ?? "") : "";
+}
+
+export function durationText(seconds: number | null | undefined): string {
+  if (seconds === null || seconds === undefined) return "duration not recorded";
+  if (seconds < 90) return `${Math.round(seconds)} s`;
+  return `${Math.floor(seconds / 60)} min ${Math.round(seconds % 60)} s`;
+}
+
+export function dollars(value: number): string {
+  return value < 0.01 ? `$${value.toFixed(4)}` : `$${value.toFixed(2)}`;
+}
+
+/** "Cost: $0.04 (estimated ...)" or "Cost: unknown (why)", with the advisory budget flagged in words. */
+export function costText(run: Pick<AutomationRun, "costUsd" | "costNote" | "overBudget"> & { budgetUsd?: number | null }): string {
+  const base = run.costUsd === null ? `Cost: unknown (${run.costNote})` : `Cost: ${dollars(run.costUsd)} (${run.costNote})`;
+  return run.overBudget && run.budgetUsd != null ? `${base}. Over the budget of ${dollars(run.budgetUsd)} per run` : base;
+}
+
+export function toolsText(run: Pick<AutomationRun, "toolsUsed">): string {
+  const tools = Object.entries(run.toolsUsed ?? {}).sort(([a], [b]) => a.localeCompare(b));
+  return tools.length ? `Tools used: ${tools.map(([name, count]) => `${name} x${count}`).join(", ")}` : "Tools used: none recorded";
+}
+
+export function whoText(run: Pick<AutomationRun, "origin" | "requestedBy" | "sourceId"> & { stage?: string | null }): string {
+  if (run.origin === "stage") return `Story entered ${run.stage ?? "a stage"}`;
+  return run.origin === "manual" ? `Run now by ${run.requestedBy ?? "someone"}` : `Item: ${run.sourceId ?? "unknown"}`;
+}
+
+export const LIMITS_NOTE = "the timeout and the number at a time (when set) are enforced when a run starts; the budget is advisory and only flagged";
+
+export function atATimeText(limits: { maxConcurrent?: number }): string {
+  return limits.maxConcurrent === undefined ? "no limit on how many at a time" : `${limits.maxConcurrent} at a time`;
+}
+
+export type RunNowResult =
+  | { state: "started"; automationId: string; requestedBy: string }
+  | { state: "refused"; reason: string }
+  | { state: "unavailable" }
+  | { error: "forbidden" | "bad_request" };
+
+export function runNowMessage(result: RunNowResult): string {
+  if ("error" in result) return result.error === "forbidden" ? "Run now is for editors and admins." : "The request was not understood.";
+  if (result.state === "started") return "Started. The run appears in the list below within a minute; the page refreshes by itself.";
+  if (result.state === "refused") return `Not started: ${result.reason}`;
+  return "Not started: the request could not be completed right now. Nothing was started.";
+}
+
+/** The input a person typed for Run now: a JSON object, or nothing (the record's own input is used). */
+export function parseRunInput(text: string): { ok: true; value: Record<string, unknown> | null } | { ok: false; message: string } {
+  if (!text.trim()) return { ok: true, value: null };
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return { ok: false, message: "The input must be a JSON object, for example {\"name\": \"value\"}." };
+    return { ok: true, value: parsed as Record<string, unknown> };
+  } catch {
+    return { ok: false, message: "The input is not valid JSON." };
+  }
+}
+
+/** A starting point for the input box: the record's input names with empty values. */
+export function inputTemplateText(names: string[]): string {
+  return JSON.stringify(Object.fromEntries(names.map((name) => [name, ""])), null, 2);
+}
+
+const LINK_WORDS: Record<AutomationLink["state"], string> = {
+  linked: "Linked: the router's trigger matches this record.",
+  input_differs: "Differs: the router's input template is not the same as this record's.",
+  trigger_not_found: "Not linked: the router has no trigger for this procedure.",
+  publication_not_in_router: "Not linked: the router does not deliver to this publication.",
+  router_not_found: "Not linked: the monitor has no router configuration.",
+  not_applicable: "Not yet supported",
+};
+
+export function linkText(link: AutomationLink | null): string {
+  return link ? LINK_WORDS[link.state] ?? link.text : "Not checked";
+}
+
+const NOTICE_WORDS: Record<string, string> = {
+  monitoring_not_configured: "Monitoring is not connected to this site's account, so run history cannot be shown.",
+  monitoring_unavailable: "Run history could not be read right now. The record is shown without it.",
+  other_publication: "This automation belongs to another publication, so its runs are not shown here.",
+  publication_not_routed: "This publication is not one of the router's outputs, so there are no runs to show.",
+  "not yet supported": "Only monitor automations run today. This one is stored but nothing starts it.",
+};
+
+export const OUTSIDE_NOTICE = "The procedure's other runs could not be read right now.";
+
+export function noticeText(notice: AutomationNotice | null): string | null {
+  return notice ? (NOTICE_WORDS[notice] ?? notice) : null;
+}
+
+export function storyHref(storyId: string, demo?: boolean): string {
+  return getNewsroomNavHref(`/newsroom/articles/${encodeURIComponent(storyId)}`, demo);
+}
+
+export function proceduresHref(demo?: boolean): string {
+  return getNewsroomNavHref("/newsroom/administration/procedures", demo);
+}

package/lib/category-repository.ts

@@ -200,7 +200,6 @@ export type ProcedureRunRecord = {
   newsroomFeedKey?: string | null;
 };
 
-const DEFAULT_NEWSROOM_SECTIONS_CONFIG_PATH = path.join(process.cwd(), "corpora", "papyrus-newsroom-sections.yml");
 const NEWSROOM_SECTION_TYPES = new Set<NewsroomSectionType>(["canonical", "floating", "rotating"]);
 type NewsroomSectionSeedRow = Omit<NewsroomSectionRecord, "sortOrder" | "enabled" | "enabledStatus" | "createdAt" | "updatedAt"> & {
   enabled: boolean;
@@ -690,10 +689,10 @@ export type CategorySteeringDashboard = {
   loadError?: string | null;
 };
 
-const DEFAULT_ANALYSIS_PROFILES_PATH = path.join(process.cwd(), "corpora", "papyrus-analysis-profiles.yml");
-const DEFAULT_STEERING_CONFIG_PATH = path.join(process.cwd(), "corpora", "papyrus-steering.yml");
 
-export async function loadAnalysisProfileSummaries(filepath = DEFAULT_ANALYSIS_PROFILES_PATH): Promise<AnalysisProfileSummary[]> {
+/** Analysis profiles the site keeps in a file; a site that configures none (data-driven sites) has none. No default file is looked up. */
+export async function loadAnalysisProfileSummaries(filepath?: string): Promise<AnalysisProfileSummary[]> {
+  if (!filepath) return [];
   try {
     const parsed = YAML.parse(fs.readFileSync(filepath, "utf8")) as {
       schemaVersion?: number;
@@ -722,7 +721,9 @@ export async function loadAnalysisProfileSummaries(filepath = DEFAULT_ANALYSIS_P
   }
 }
 
-export async function loadConfiguredCorpusSummaries(filepath = DEFAULT_STEERING_CONFIG_PATH): Promise<CategorySteeringCorpus[]> {
+/** Corpora a site lists in a steering file; no configured file means none. No default file is looked up. */
+export async function loadConfiguredCorpusSummaries(filepath?: string): Promise<CategorySteeringCorpus[]> {
+  if (!filepath) return [];
   try {
     const parsed = YAML.parse(fs.readFileSync(filepath, "utf8")) as {
       corpora?: Array<Record<string, unknown>>;
@@ -818,7 +819,8 @@ function sortCategorys(categorys: CategorySteeringCategory[]): CategorySteeringC
   });
 }
 
-function defaultNewsroomSections(importedAt: string, sectionsConfigPath = DEFAULT_NEWSROOM_SECTIONS_CONFIG_PATH): NewsroomSectionRecord[] {
+function defaultNewsroomSections(importedAt: string, sectionsConfigPath?: string): NewsroomSectionRecord[] {
+  if (!sectionsConfigPath) return [];
   return loadNewsroomSectionSeedRows(sectionsConfigPath).map((row, index) => ({
     ...row,
     enabledStatus: "enabled",
@@ -828,7 +830,7 @@ function defaultNewsroomSections(importedAt: string, sectionsConfigPath = DEFAUL
   }));
 }
 
-function loadNewsroomSectionSeedRows(sectionsConfigPath = DEFAULT_NEWSROOM_SECTIONS_CONFIG_PATH) {
+function loadNewsroomSectionSeedRows(sectionsConfigPath: string) {
   const cached = newsroomSectionSeedRowsCache.get(sectionsConfigPath);
   if (cached) return cached;
   const parsed = YAML.parse(fs.readFileSync(sectionsConfigPath, "utf8")) as {
@@ -883,7 +885,7 @@ function normalizeNewsroomSectionSeedRow(
 
 export function createDemoCategorySteeringDashboard(
   brandId: SiteBrandId = resolveSiteBrandId(),
-  newsroomSectionsConfigPath = DEFAULT_NEWSROOM_SECTIONS_CONFIG_PATH,
+  newsroomSectionsConfigPath?: string,
 ): CategorySteeringDashboard {
   const importedAt = "2026-05-16T12:00:00.000Z";
   const profile = getNewsroomDemoProfile(brandId);
@@ -1502,7 +1504,7 @@ export function createDemoCategorySteeringDashboard(
             riskFlags: ["Avoid promotional framing."],
             coverageGaps: ["Need a second independent source."],
             openQuestions: ["Which users are affected first?"],
-            copywriterBrief: "Use accepted evidence and recent desk memory before drafting.",
+            copywriterBrief: "Use accepted evidence and recent section memory before drafting.",
           },
         },
       },
@@ -1652,8 +1654,8 @@ export function createDemoCategorySteeringDashboard(
         slug: "editorial-doctrine-policy",
         title: "Editorial Policy",
         body: [
-          "Publication doctrine is the global inclusion standard; desk doctrine sets local source priorities and framing.",
-          "News reporting should prioritize current, journalistic, and official sources; desk workflows may use academic research as background unless a desk policy explicitly makes research the primary evidence class.",
+          "Publication doctrine is the global inclusion standard; section doctrine sets local source priorities and framing.",
+          "News reporting should prioritize current, journalistic, and official sources; section workflows may use academic research as background unless a section policy explicitly makes research the primary evidence class.",
           "High-risk domains, including health-related claims, require stricter sourcing, explicit uncertainty handling, and clear separation between verified facts and interpretation.",
         ],
         editorial: { kind: "policy" },
@@ -1698,7 +1700,7 @@ export function createDemoCategorySteeringDashboard(
           question: "Should this candidate source become a reference for this publication?",
           reviewControl: "thumbs",
           reviewReason: "program",
-          reviewDetail: "Every decision is reviewed while the cyclotron is onboarding.",
+          reviewDetail: "Every suggestion is reviewed while suggestions are getting started.",
           version: 1,
         }),
       },

package/lib/console-web-context.ts

@@ -41,7 +41,7 @@ export function formatConsoleWebContextMessage(
     webPath ? `Web path: ${webPath}` : null,
     objectUri ? `Focused object: ${objectUri}` : null,
     label ? `Label: ${label}` : null,
-    tab ? `Desk: ${tab}` : null,
+    tab ? `Section: ${tab}` : null,
     viewMode ? `View: ${viewMode}` : null,
   ].filter((line): line is string => Boolean(line));