@anthusai/papyrus 5.31.0 → 5.32.0

package/amplify/data/resource.js

@@ -1163,6 +1163,25 @@ const schema = a.schema({
         allow.group("editor").to(["read"]),
         allow.group(adminGroup).to(authoringOperations),
     ]),
+    Automation: a
+        .model({
+        id: a.id().required(),
+        title: a.string().required(),
+        description: a.string(),
+        enabled: a.boolean().required(),
+        trigger: a.json().required(),
+        procedureKey: a.string().required(),
+        inputTemplate: a.json(),
+        limits: a.json(),
+        createdBy: a.string(),
+        createdAt: a.datetime().required(),
+        updatedBy: a.string(),
+        updatedAt: a.datetime().required(),
+    })
+        .authorization((allow) => [
+        allow.group("editor").to(["read", "create", "update"]),
+        allow.group(adminGroup).to(authoringOperations),
+    ]),
     NewsroomSection: a
         .model({
         id: a.id().required(),

package/amplify/data/resource.ts

@@ -1259,6 +1259,26 @@ const schema = a.schema({
       allow.group(adminGroup).to(authoringOperations),
     ]),
 
+  Automation: a
+    .model({
+      id: a.id().required(),
+      title: a.string().required(),
+      description: a.string(),
+      enabled: a.boolean().required(),
+      trigger: a.json().required(),
+      procedureKey: a.string().required(),
+      inputTemplate: a.json(),
+      limits: a.json(),
+      createdBy: a.string(),
+      createdAt: a.datetime().required(),
+      updatedBy: a.string(),
+      updatedAt: a.datetime().required(),
+    })
+    .authorization((allow) => [
+      allow.group("editor").to(["read", "create", "update"]),
+      allow.group(adminGroup).to(authoringOperations),
+    ]),
+
   NewsroomSection: a
     .model({
       id: a.id().required(),

package/amplify/data/schema.js

@@ -2,6 +2,7 @@ import { a } from "@aws-amplify/backend";
 import { assignmentAction } from "../functions/assignment-action/resource.js";
 import { categoryAction } from "../functions/category-action/resource.js";
 import { editorialChecksSchemaDefinitions } from "../functions/editorial-checks/schema.js";
+import { automationViewSchemaDefinitions } from "../functions/automation-view/schema.js";
 import { monitoringViewSchemaDefinitions } from "../functions/monitoring-view/schema.js";
 import { contentActions } from "../functions/content-actions/resource.js";
 import { knowledgeQuery } from "../functions/knowledge-query/resource.js";
@@ -1082,6 +1083,25 @@ function buildBaseDefinitions(includeEditions) {
             allow.group("editor").to(["read"]),
             allow.group(adminGroup).to(authoringOperations),
         ]),
+        /** A named "when X happens, run procedure Y" (PPY-9ff95b). Step 1 mirrors the monitoring router's procedureTriggers and starts nothing itself. */
+        Automation: modelWithoutSubscriptions({
+            id: a.id().required(),
+            title: a.string().required(),
+            description: a.string(),
+            enabled: a.boolean().required(),
+            trigger: a.json().required(),
+            procedureKey: a.string().required(),
+            inputTemplate: a.json(),
+            limits: a.json(),
+            createdBy: a.string(),
+            createdAt: a.datetime().required(),
+            updatedBy: a.string(),
+            updatedAt: a.datetime().required(),
+        })
+            .authorization((allow) => [
+            allow.group("editor").to(["read", "create", "update"]),
+            allow.group(adminGroup).to(authoringOperations),
+        ]),
         NewsroomSection: modelWithoutSubscriptions({
             id: a.id().required(),
             tenantId: a.string(),
@@ -2021,6 +2041,7 @@ function buildBaseDefinitions(includeEditions) {
         ]),
         ...editorialChecksSchemaDefinitions,
         ...monitoringViewSchemaDefinitions,
+        ...automationViewSchemaDefinitions,
     };
     if (!includeEditions) {
         const mutableDefinitions = definitions;

package/amplify/data/schema.ts

@@ -2,6 +2,7 @@ import { type ClientSchema, a } from "@aws-amplify/backend";
 import { assignmentAction } from "../functions/assignment-action/resource";
 import { categoryAction } from "../functions/category-action/resource";
 import { editorialChecksSchemaDefinitions } from "../functions/editorial-checks/schema";
+import { automationViewSchemaDefinitions } from "../functions/automation-view/schema";
 import { monitoringViewSchemaDefinitions } from "../functions/monitoring-view/schema";
 import { contentActions } from "../functions/content-actions/resource";
 import { knowledgeQuery } from "../functions/knowledge-query/resource";
@@ -1176,6 +1177,26 @@ const definitions = {
       allow.group(adminGroup).to(authoringOperations),
     ]),
 
+  /** A named "when X happens, run procedure Y" (PPY-9ff95b). Step 1 mirrors the monitoring router's procedureTriggers and starts nothing itself. */
+  Automation: modelWithoutSubscriptions({
+      id: a.id().required(),
+      title: a.string().required(),
+      description: a.string(),
+      enabled: a.boolean().required(),
+      trigger: a.json().required(),
+      procedureKey: a.string().required(),
+      inputTemplate: a.json(),
+      limits: a.json(),
+      createdBy: a.string(),
+      createdAt: a.datetime().required(),
+      updatedBy: a.string(),
+      updatedAt: a.datetime().required(),
+    })
+    .authorization((allow) => [
+      allow.group("editor").to(["read", "create", "update"]),
+      allow.group(adminGroup).to(authoringOperations),
+    ]),
+
   NewsroomSection: modelWithoutSubscriptions({
       id: a.id().required(),
       tenantId: a.string(),
@@ -2145,6 +2166,7 @@ const definitions = {
     ]),
   ...editorialChecksSchemaDefinitions,
   ...monitoringViewSchemaDefinitions,
+  ...automationViewSchemaDefinitions,
 };
 if (!includeEditions) {
   const mutableDefinitions = definitions as Record<string, unknown>;

package/amplify/functions/automation-view/handler.py

@@ -0,0 +1,11 @@
+"""The automation-view function: `automationOverview` for editors and admins, read-only."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from papyrus_content.automation_view import handle
+
+
+def handler(event: dict[str, Any], _context: Any = None) -> dict[str, Any]:
+    return handle(event)

package/amplify/functions/automation-view/resource.js

@@ -0,0 +1,24 @@
+import { defineFunction } from "@aws-amplify/backend";
+import { Duration } from "aws-cdk-lib";
+import { Architecture, Function, Runtime } from "aws-cdk-lib/aws-lambda";
+import { pythonLambdaCode } from "../shared/python-bundle.js";
+/** AppSync gives a resolver 30 seconds; a table read and ten run lookups need a few. */
+export const AUTOMATION_VIEW_TIMEOUT_SECONDS = 25;
+/** stdlib plus the runtime's boto3: the bundle is `papyrus_content` and nothing else. */
+export const automationView = defineFunction((scope) => new Function(scope, "papyrus-automation-view", {
+    runtime: Runtime.PYTHON_3_12,
+    architecture: Architecture.ARM_64,
+    handler: "handler.handler",
+    timeout: Duration.seconds(AUTOMATION_VIEW_TIMEOUT_SECONDS),
+    memorySize: 256,
+    code: pythonLambdaCode({ functionDir: "automation-view", modules: ["papyrus_content"], noDeps: true }, [
+        "bash",
+        "-c",
+        [
+            "set -euo pipefail",
+            "mkdir -p /asset-output/papyrus_content",
+            "cp amplify/functions/automation-view/handler.py /asset-output/handler.py",
+            "cp -R src/papyrus_content/. /asset-output/papyrus_content/",
+        ].join(" && "),
+    ]),
+}), { resourceGroupName: "data" });

package/amplify/functions/automation-view/resource.ts

@@ -0,0 +1,34 @@
+import { defineFunction } from "@aws-amplify/backend";
+import { Duration } from "aws-cdk-lib";
+import { Architecture, Function, Runtime } from "aws-cdk-lib/aws-lambda";
+import type { Construct } from "constructs";
+import { pythonLambdaCode } from "../shared/python-bundle";
+
+/** AppSync gives a resolver 30 seconds; a table read and ten run lookups need a few. */
+export const AUTOMATION_VIEW_TIMEOUT_SECONDS = 25;
+
+/** stdlib plus the runtime's boto3: the bundle is `papyrus_content` and nothing else. */
+export const automationView = defineFunction(
+  (scope: Construct) =>
+    new Function(scope, "papyrus-automation-view", {
+      runtime: Runtime.PYTHON_3_12,
+      architecture: Architecture.ARM_64,
+      handler: "handler.handler",
+      timeout: Duration.seconds(AUTOMATION_VIEW_TIMEOUT_SECONDS),
+      memorySize: 256,
+      code: pythonLambdaCode(
+        { functionDir: "automation-view", modules: ["papyrus_content"], noDeps: true },
+        [
+          "bash",
+          "-c",
+          [
+            "set -euo pipefail",
+            "mkdir -p /asset-output/papyrus_content",
+            "cp amplify/functions/automation-view/handler.py /asset-output/handler.py",
+            "cp -R src/papyrus_content/. /asset-output/papyrus_content/",
+          ].join(" && "),
+        ],
+      ),
+    }),
+  { resourceGroupName: "data" },
+);

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

@@ -0,0 +1,16 @@
+import { a } from "@aws-amplify/backend";
+import { automationView } from "./resource.js";
+const editors = ["editor", "admin"];
+/**
+ * Core to every site's data API. The Automation page reads the automation records, the monitoring
+ * trigger rows they link to, and the procedure runs through this one query. AppSync admits editors
+ * and admins only; the function checks the groups again.
+ */
+export const automationViewSchemaDefinitions = {
+    automationOverview: a
+        .query()
+        .arguments({ automationId: a.string() })
+        .returns(a.json())
+        .authorization((allow) => [allow.groups(editors)])
+        .handler(a.handler.function(automationView)),
+};

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

@@ -0,0 +1,18 @@
+import { a } from "@aws-amplify/backend";
+import { automationView } from "./resource";
+
+const editors = ["editor", "admin"];
+
+/**
+ * Core to every site's data API. The Automation page reads the automation records, the monitoring
+ * trigger rows they link to, and the procedure runs through this one query. AppSync admits editors
+ * and admins only; the function checks the groups again.
+ */
+export const automationViewSchemaDefinitions = {
+  automationOverview: a
+    .query()
+    .arguments({ automationId: a.string() })
+    .returns(a.json())
+    .authorization((allow) => [allow.groups(editors)])
+    .handler(a.handler.function(automationView)),
+};

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

@@ -0,0 +1,32 @@
+import { Stack } from "aws-cdk-lib";
+import { Effect, PolicyStatement } from "aws-cdk-lib/aws-iam";
+import { MONITORING_TABLE_PARAMETER, MONITORING_VIEW_TABLE_ACTIONS, monitoringViewParameterArn, monitoringViewTableArns, } from "../monitoring-view/wire.js";
+/** The two reads the function makes of its own site's API with its own role. It writes nothing. */
+export const AUTOMATION_VIEW_FUNCTION_FIELDS = ["Query/fields/listAutomations", "Query/fields/getProcedureRun"];
+/**
+ * Environment and least-privilege IAM for the automation-view function: two fields of the site's own API,
+ * and the same read-only grant on the monitoring table that the Monitoring page has. A site outside the
+ * monitoring account finds no parameter and the page lists its records without runs.
+ */
+export function wireAutomationView(backend) {
+    const lambda = backend.automationView.resources.lambda;
+    const stack = Stack.of(lambda);
+    lambda.addEnvironment("PAPYRUS_GRAPHQL_ENDPOINT", backend.data.resources.cfnResources.cfnGraphqlApi.attrGraphQlUrl);
+    lambda.addEnvironment("PAPYRUS_MONITORING_TABLE_PARAMETER", MONITORING_TABLE_PARAMETER);
+    const apiId = backend.data.resources.graphqlApi.apiId;
+    lambda.addToRolePolicy(new PolicyStatement({
+        effect: Effect.ALLOW,
+        actions: ["appsync:GraphQL"],
+        resources: AUTOMATION_VIEW_FUNCTION_FIELDS.map((field) => `arn:aws:appsync:${stack.region}:${stack.account}:apis/${apiId}/types/${field}`),
+    }));
+    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),
+    }));
+}

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

@@ -0,0 +1,46 @@
+import { Stack } from "aws-cdk-lib";
+import { Effect, PolicyStatement } from "aws-cdk-lib/aws-iam";
+import type { Function as LambdaFunction } from "aws-cdk-lib/aws-lambda";
+import {
+  MONITORING_TABLE_PARAMETER,
+  MONITORING_VIEW_TABLE_ACTIONS,
+  monitoringViewParameterArn,
+  monitoringViewTableArns,
+} from "../monitoring-view/wire";
+
+/** The two reads the function makes of its own site's API with its own role. It writes nothing. */
+export const AUTOMATION_VIEW_FUNCTION_FIELDS = ["Query/fields/listAutomations", "Query/fields/getProcedureRun"];
+
+/**
+ * Environment and least-privilege IAM for the automation-view function: two fields of the site's own API,
+ * and the same read-only grant on the monitoring table that the Monitoring page has. A site outside the
+ * monitoring account finds no parameter and the page lists its records without runs.
+ */
+export function wireAutomationView(backend: any): void {
+  const lambda = backend.automationView.resources.lambda as LambdaFunction;
+  const stack = Stack.of(lambda);
+  lambda.addEnvironment("PAPYRUS_GRAPHQL_ENDPOINT", backend.data.resources.cfnResources.cfnGraphqlApi.attrGraphQlUrl as string);
+  lambda.addEnvironment("PAPYRUS_MONITORING_TABLE_PARAMETER", MONITORING_TABLE_PARAMETER);
+  const apiId = backend.data.resources.graphqlApi.apiId as string;
+  lambda.addToRolePolicy(
+    new PolicyStatement({
+      effect: Effect.ALLOW,
+      actions: ["appsync:GraphQL"],
+      resources: AUTOMATION_VIEW_FUNCTION_FIELDS.map((field) => `arn:aws:appsync:${stack.region}:${stack.account}:apis/${apiId}/types/${field}`),
+    }),
+  );
+  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),
+    }),
+  );
+}

package/amplify/site-backend.js

@@ -22,6 +22,8 @@ import { applyCognitoDomainPrefix, authConfigFromEnv, defineSiteAuth, siteAuthRe
 import { PROSPECTUS_SIGN_IN_CALLBACK_PATH, addProspectusGoogleOnlyClient } from "./auth/prospectus-google-client.js";
 import { defineSiteData } from "./data/resource.js";
 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 { wireEditorialChecks } from "./functions/editorial-checks/wire.js";
@@ -94,6 +96,7 @@ export function defineSiteBackend(papyrusSite) {
     const backend = defineBackend({
         ...pluginFunctions,
         assignmentAction,
+        automationView,
         auth: defineSiteAuth(authConfig),
         categoryAction,
         contentActions,
@@ -621,6 +624,7 @@ export function defineSiteBackend(papyrusSite) {
     });
     wireEditorialChecks(backend);
     wireMonitoringView(backend);
+    wireAutomationView(backend);
     wirePlugins(backend, plugins, contentActionsLambda);
     return backend;
 }

package/amplify/site-backend.ts

@@ -29,6 +29,8 @@ import { applyCognitoDomainPrefix, authConfigFromEnv, defineSiteAuth, siteAuthRe
 import { PROSPECTUS_SIGN_IN_CALLBACK_PATH, addProspectusGoogleOnlyClient } from "./auth/prospectus-google-client";
 import { defineSiteData } from "./data/resource";
 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 { wireEditorialChecks } from "./functions/editorial-checks/wire";
@@ -115,6 +117,7 @@ export function defineSiteBackend(papyrusSite: PapyrusSite) {
   const backend = defineBackend({
     ...pluginFunctions,
     assignmentAction,
+    automationView,
     auth: defineSiteAuth(authConfig),
     categoryAction,
     contentActions,
@@ -766,6 +769,7 @@ export function defineSiteBackend(papyrusSite: PapyrusSite) {
   });
   wireEditorialChecks(backend);
   wireMonitoringView(backend);
+  wireAutomationView(backend);
   wirePlugins(backend, plugins, contentActionsLambda);
 
   return backend;

package/components/automation-panel.tsx

@@ -0,0 +1,39 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { loadAutomationOverview } from "../lib/automation-client";
+import { FIXTURE_AUTOMATION_OVERVIEW } from "../lib/automation-fixture";
+import type { AutomationResult } from "../lib/automation-overview";
+import { AutomationView } from "./automation-view";
+
+const REFRESH_MILLISECONDS = 60_000;
+
+/** Administration, Automation: loads the records and their recent runs, and refreshes each minute. */
+export function AutomationPanel({ isDemo }: { isDemo: boolean }) {
+  const [result, setResult] = useState<AutomationResult | null>(null);
+  const [selectedId, setSelectedId] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (isDemo) {
+      setResult(FIXTURE_AUTOMATION_OVERVIEW);
+      return;
+    }
+    let live = true;
+    const refresh = async () => {
+      try {
+        const next = await loadAutomationOverview();
+        if (live) setResult(next);
+      } catch {
+        if (live) setResult({ state: "unavailable" });
+      }
+    };
+    void refresh();
+    const timer = window.setInterval(() => void refresh(), REFRESH_MILLISECONDS);
+    return () => {
+      live = false;
+      window.clearInterval(timer);
+    };
+  }, [isDemo]);
+
+  return <AutomationView result={result} selectedId={selectedId} onSelect={setSelectedId} demo={isDemo} />;
+}

package/components/automation-view.tsx

@@ -0,0 +1,149 @@
+import Link from "next/link";
+import {
+  ENABLED_NOTE,
+  durationText,
+  enabledText,
+  formatUtc,
+  linkText,
+  noticeText,
+  proceduresHref,
+  statusMark,
+  statusText,
+  storyHref,
+  triggerText,
+  type AutomationRecord,
+  type AutomationResult,
+  type AutomationRun,
+} from "../lib/automation-overview";
+
+function Message({ title, children, kind }: { title: string; children?: React.ReactNode; kind: string }) {
+  return (
+    <div className="category-steering-empty" role={kind === "loading" ? "status" : "alert"} data-automation-state={kind}>
+      <strong>{title}</strong>
+      {children ? <p>{children}</p> : null}
+    </div>
+  );
+}
+
+function RunLine({ run, demo }: { run: AutomationRun; demo: boolean }) {
+  return (
+    <li data-automation-run={run.runId ?? run.sourceId ?? "unlinked"} data-run-status={run.status ?? "unknown"}>
+      <strong>{formatUtc(run.startedAt)}</strong>
+      <span><span aria-hidden="true">{statusMark(run.status)} </span>Status: {statusText(run.status)} &middot; {durationText(run.durationSeconds)}</span>
+      <span>Item: {run.sourceId ?? "unknown"}</span>
+      {run.error ? <span data-automation-run-error>Error: {run.error}</span> : null}
+      <span>
+        {run.runId ? <>Run {run.runId} (<Link href={proceduresHref(demo)}>Procedures</Link>)</> : run.triggerStatus === "started" ? "Run record not linked yet" : "No run record"}
+        {run.runRecord === "missing" ? " (the run record was not found)" : ""}
+        {run.runRecord === "unavailable" ? " (the run record could not be read)" : ""}
+      </span>
+      <span>
+        {run.storyId ? <>Story: <Link href={storyHref(run.storyId, demo)} data-automation-story-link>{run.storyTitle ?? run.storyId}</Link></> : "Story: none recorded"}
+      </span>
+      <span>Cost: unknown ({run.costNote})</span>
+    </li>
+  );
+}
+
+function Detail({ record, demo }: { record: AutomationRecord; demo: boolean }) {
+  const notice = noticeText(record.notice);
+  return (
+    <article className="news-desk-doctrine-card" data-automation-detail={record.id}>
+      <div className="news-desk-doctrine-card__header"><div><h3>{record.title}</h3><span>{record.description ?? record.id}</span></div></div>
+      <dl className="news-desk-monitoring__usage">
+        <div><dt>Trigger</dt><dd>{triggerText(record.trigger)}{record.supported ? "" : ` (${record.supportNote ?? "not yet supported"})`}</dd></div>
+        <div><dt>Procedure</dt><dd>{record.procedureKey}</dd></div>
+        <div><dt>Input</dt><dd>{Object.keys(record.inputTemplate).length ? Object.entries(record.inputTemplate).map(([name, template]) => `${name} = ${template}`).join("; ") : "none"}</dd></div>
+        <div><dt>Enabled</dt><dd>{enabledText(record)} ({ENABLED_NOTE})</dd></div>
+        <div><dt>Limits</dt><dd>timeout {record.limits.timeoutSeconds ?? "?"} s, {record.limits.maxConcurrent ?? "?"} at a time{record.limits.budgetUsdPerRun !== undefined ? `, about $${record.limits.budgetUsdPerRun} per run` : ""} ({record.limitsNote})</dd></div>
+        <div><dt>Router</dt><dd data-automation-link={record.link?.state ?? "unchecked"}>{linkText(record.link)}</dd></div>
+      </dl>
+      {notice ? <p className="news-desk-delegation-note" data-automation-notice>{notice}</p> : null}
+      <h4>Recent runs</h4>
+      {record.runs.length ? (
+        <ul className="news-desk-monitoring__list" data-automation-runs>
+          {record.runs.map((run) => <RunLine key={run.runId ?? `${run.sourceId}-${run.startedAt}`} run={run} demo={demo} />)}
+        </ul>
+      ) : <p data-automation-no-runs>No runs yet.</p>}
+      {record.skippedAlreadyHadReference > 0 ? (
+        <p className="news-desk-delegation-note" data-automation-skipped>
+          {record.skippedAlreadyHadReference} {record.skippedAlreadyHadReference === 1 ? "item was" : "items were"} not started because the Reference already existed.
+        </p>
+      ) : null}
+    </article>
+  );
+}
+
+function ListItem({ record, selected, onSelect }: { record: AutomationRecord; selected: boolean; onSelect: (id: string) => void }) {
+  const last = record.lastRun;
+  return (
+    <li data-automation={record.id}>
+      <div>
+        <strong>{record.title}</strong>
+        <span>{triggerText(record.trigger)}{record.supported ? "" : ` (${record.supportNote ?? "not yet supported"})`}</span>
+      </div>
+      <span>Procedure: {record.procedureKey}</span>
+      <span>{enabledText(record)} ({ENABLED_NOTE})</span>
+      <span data-automation-last-run>
+        Last run: <span aria-hidden="true">{statusMark(last?.status)} </span>{statusText(last?.status)}{last ? `, ${formatUtc(last.startedAt)}` : ""}
+      </span>
+      <button type="button" aria-pressed={selected} data-automation-select={record.id} onClick={() => onSelect(record.id)}>
+        {selected ? "Showing runs" : "Show runs"}
+      </button>
+    </li>
+  );
+}
+
+/** Presentation only: the panel fetches, this renders any result, so every state is testable from fixtures. */
+export function AutomationView({
+  result,
+  selectedId,
+  onSelect,
+  demo = false,
+}: {
+  result: AutomationResult | null;
+  selectedId: string | null;
+  onSelect: (id: string) => void;
+  demo?: boolean;
+}) {
+  let body: React.ReactNode;
+  if (result === null) {
+    body = <Message kind="loading" title="Loading automations" />;
+  } else if ("error" in result) {
+    body = result.error === "forbidden"
+      ? <Message kind="forbidden" title="Automations are for editors and admins">Your account does not have access to this page. Ask an admin for the editor role.</Message>
+      : <Message kind="error" title="Automations could not be read">The request was not understood. Reload the page.</Message>;
+  } else if (result.state === "unavailable") {
+    body = <Message kind="unavailable" title="Automations could not be read right now">Nothing is affected. Try again in a minute.</Message>;
+  } else if (result.state === "empty") {
+    body = <Message kind="empty" title="No automations yet">An operator creates one with <code>papyrus automations create</code>. Nothing is configured to run on its own from this page.</Message>;
+  } else {
+    const selected = result.automations.find((record) => record.id === selectedId) ?? (result.automations.length === 1 ? result.automations[0] : null);
+    body = (
+      <>
+        <article className="news-desk-doctrine-card" data-automation-section="list">
+          <div className="news-desk-doctrine-card__header"><div><h3>Automations</h3><span>What starts a procedure by itself</span></div></div>
+          <ul className="news-desk-monitoring__list">
+            {result.automations.map((record) => <ListItem key={record.id} record={record} selected={selected?.id === record.id} onSelect={onSelect} />)}
+          </ul>
+          {result.monitoring === "not_configured" ? <p className="news-desk-delegation-note" data-automation-notice>{noticeText("monitoring_not_configured")}</p> : null}
+        </article>
+        {selected ? <Detail record={selected} demo={demo} /> : <p className="news-desk-delegation-note" data-automation-pick>Choose an automation to see its recent runs.</p>}
+      </>
+    );
+  }
+  return (
+    <div data-news-desk-admin-panel="automations">
+      <article className="news-desk-doctrine-card">
+        <div className="news-desk-doctrine-card__header">
+          <div>
+            <h3>Automation</h3>
+            <span>Procedures that start on their own. Read only here; an operator changes them with the command line.</span>
+          </div>
+        </div>
+        {result && "asOf" in result ? <p className="news-desk-delegation-note" data-automation-as-of>As of {formatUtc(result.asOf)}. The enabled setting is {ENABLED_NOTE}.</p> : null}
+      </article>
+      {body}
+    </div>
+  );
+}

package/components/topic-steering-workspace.tsx

@@ -14,6 +14,7 @@ import type { ReactNode, RefObject } from "react";
 import { useCallback, useEffect, useId, useLayoutEffect, useMemo, useRef, useState, useTransition } from "react";
 import amplifyOutputs from "papyrus-amplify-outputs";
 import { EditorialChecksAdminPanel } from "./editorial-checks-admin-panel";
+import { AutomationPanel } from "./automation-panel";
 import { MonitoringPanel } from "./monitoring-panel";
 import { ModerationPanel } from "./moderation-panel";
 import { NewsletterPanel } from "./newsletter-panel";
@@ -251,7 +252,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" | "delegations" | "signups" | "newsletter" | "moderation" | "editorial-checks" | "monitoring";
+type AdministrationPanel = "users" | "policies" | "sections" | "procedures" | "automations" | "delegations" | "signups" | "newsletter" | "moderation" | "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";
@@ -4315,6 +4316,15 @@ function AdministrationDeskView({
                 <strong>Procedures</strong>
                 <span>Procedure registry and versioned Tactus code</span>
               </Link>
+              <Link
+                href={administrationPanelHref("automations", isDemo)}
+                data-news-desk-admin-nav="automations"
+                data-active={administrationPanel === "automations" || undefined}
+                onClick={() => onPanelChange("automations")}
+              >
+                <strong>Automation</strong>
+                <span>Procedures that start on their own</span>
+              </Link>
               <Link
                 href={administrationPanelHref("delegations", isDemo)}
                 data-news-desk-admin-nav="delegations"
@@ -4381,6 +4391,7 @@ function AdministrationDeskView({
               {administrationPanel === "newsletter" ? <NewsletterPanel isAdmin={canManageUsers} isDemo={isDemo} /> : null}
               {administrationPanel === "moderation" ? <ModerationPanel /> : null}
               {administrationPanel === "editorial-checks" ? <EditorialChecksAdminPanel /> : null}
+              {administrationPanel === "automations" ? <AutomationPanel isDemo={isDemo} /> : null}
               {administrationPanel === "monitoring" ? <MonitoringPanel isAdmin={canManageUsers} isDemo={isDemo} /> : null}
               {administrationPanel === "delegations" ? <AdministrationDelegationsPanel disabled={disabled} /> : null}
               {administrationPanel === "users" ? (
@@ -12855,7 +12866,7 @@ function readerPluginEnabled(): boolean {
 }
 
 function normalizeAdministrationPanel(value: string | null | undefined, demo = false): AdministrationPanel {
-  if (value === "policies" || value === "sections" || value === "procedures" || 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") return value;
   if (value === "signups" && signupPluginEnabled()) return value;
   if (value === "newsletter" && newsletterPluginEnabled(demo)) return value;
   if (value === "moderation" && readerPluginEnabled()) return value;

package/lib/automation-client.ts

@@ -0,0 +1,29 @@
+"use client";
+
+import { generateClient } from "aws-amplify/data";
+import type { AutomationResult } from "./automation-overview";
+
+type GraphQLResult = { data?: { automationOverview?: unknown }; errors?: { message?: string; errorType?: string }[] };
+
+/**
+ * Reads the automations 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 reads.
+ */
+export async function loadAutomationOverview(): Promise<AutomationResult> {
+  const client = generateClient({ authMode: "userPool" });
+  let result: GraphQLResult;
+  try {
+    result = (await client.graphql({
+      query: `query AutomationOverview($automationId: String) { automationOverview(automationId: $automationId) }`,
+      variables: {},
+    })) 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?.automationOverview === undefined || result.data.automationOverview === null) return { state: "unavailable" };
+  const raw = result.data.automationOverview;
+  return (typeof raw === "string" ? JSON.parse(raw) : raw) as AutomationResult;
+}

package/lib/automation-fixture.ts

@@ -0,0 +1,65 @@
+import type { AutomationOverview } from "./automation-overview";
+
+const COST_NOTE = "not recorded: the procedure runner does not record token use or cost on a ProcedureRun yet";
+
+/** 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: "display only until the router honours it",
+      trigger: { kind: "monitor", config: { monitorId: "ttab", publicationId: "example" } },
+      supported: true,
+      supportNote: null,
+      procedureKey: "example.ttab.ruling-analysis",
+      inputTemplate: { proceeding: "{sourceIdPrefix}", opinion_url: "{documentUrl}" },
+      limits: { timeoutSeconds: 840, maxConcurrent: 1 },
+      limitsNote: "recorded only: the runner does not enforce these yet",
+      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: [
+        { sourceId: "91000001-EXA_26", referenceId: "ref-1", triggerStatus: "completed", runId: "run-1", status: "completed",
+          startedAt: "2026-10-23T11:30:00Z", finishedAt: "2026-10-23T11:33:10Z", durationSeconds: 190, error: null, runRecord: "found",
+          storyId: "story-1", storyVersionId: "version-1", storyTitle: "Board affirms a refusal for likelihood of confusion", costUsd: null, costNote: COST_NOTE },
+        { sourceId: "91000002-EXA_26", referenceId: "ref-2", triggerStatus: "failed", runId: "run-2", status: "failed",
+          startedAt: "2026-10-23T05:30:00Z", finishedAt: "2026-10-23T05:31:00Z", durationSeconds: 60, error: "the opinion could not be downloaded", runRecord: "found",
+          storyId: null, storyVersionId: null, storyTitle: null, costUsd: null, costNote: COST_NOTE },
+        { sourceId: "91000003-EXA_26", referenceId: "ref-3", triggerStatus: "started", runId: null, status: "started",
+          startedAt: "2026-10-23T11:59:00Z", finishedAt: null, durationSeconds: null, error: null, runRecord: "none",
+          storyId: null, storyVersionId: null, storyTitle: null, costUsd: null, costNote: COST_NOTE },
+      ],
+    },
+    {
+      id: "example.weekly-digest",
+      title: "Weekly digest",
+      description: null,
+      enabled: false,
+      enabledNote: "display only until the router honours it",
+      trigger: { kind: "schedule", config: { cron: "0 9 * * 1" } },
+      supported: false,
+      supportNote: "not yet supported",
+      procedureKey: "example.weekly-digest",
+      inputTemplate: {},
+      limits: { timeoutSeconds: 840, maxConcurrent: 1 },
+      limitsNote: "recorded only: the runner does not enforce these yet",
+      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: [],
+    },
+  ],
+};
+FIXTURE_AUTOMATION_OVERVIEW.automations[0].lastRun = FIXTURE_AUTOMATION_OVERVIEW.automations[0].runs[2];

package/lib/automation-overview.ts

@@ -0,0 +1,138 @@
+/** 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 AutomationRun = {
+  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;
+  storyVersionId: string | null;
+  storyTitle: string | null;
+  costUsd: number | null;
+  costNote: 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> };
+  supported: boolean;
+  supportNote: string | null;
+  procedureKey: string;
+  inputTemplate: Record<string, string>;
+  limits: { timeoutSeconds?: number; maxConcurrent?: number; budgetUsdPerRun?: number };
+  limitsNote: string;
+  createdAt: string | null;
+  updatedAt: string | null;
+  link: AutomationLink | null;
+  runs: AutomationRun[];
+  lastRun: AutomationRun | null;
+  skippedAlreadyHadReference: number;
+  notice: AutomationNotice | 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 ?? "?")}`;
+  }
+  return kind;
+}
+
+export const ENABLED_NOTE = "display only until the router honours it";
+
+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",
+};
+const STATUS_MARKS: Record<string, string> = { completed: "✓", failed: "✕", startFailed: "✕", notRunnable: "✕", 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`;
+}
+
+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 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/package.json

@@ -75,6 +75,8 @@
     "./components/archive-grid": "./components/archive-grid.tsx",
     "./components/archive-shell": "./components/archive-shell.tsx",
     "./components/article-video": "./components/article-video.tsx",
+    "./components/automation-panel": "./components/automation-panel.tsx",
+    "./components/automation-view": "./components/automation-view.tsx",
     "./components/blog-page-background": "./components/blog-page-background.tsx",
     "./components/curation-delegation-client": "./components/curation-delegation-client.ts",
     "./components/dev-sandbox-editor-sign-in": "./components/dev-sandbox-editor-sign-in.tsx",
@@ -176,6 +178,9 @@
     "./lib/article-flow": "./lib/article-flow.ts",
     "./lib/article-frame-solver": "./lib/article-frame-solver.ts",
     "./lib/articles": "./lib/articles.ts",
+    "./lib/automation-client": "./lib/automation-client.ts",
+    "./lib/automation-fixture": "./lib/automation-fixture.ts",
+    "./lib/automation-overview": "./lib/automation-overview.ts",
     "./lib/blog-feature-solver": "./lib/blog-feature-solver.ts",
     "./lib/blog-rhythm": "./lib/blog-rhythm.ts",
     "./lib/brand-fonts-watch": "./lib/brand-fonts-watch.ts",
@@ -434,7 +439,7 @@
       "optional": true
     }
   },
-  "version": "5.31.0",
+  "version": "5.32.0",
   "dependencies": {
     "@aws-amplify/adapter-nextjs": "^1.7.3",
     "@aws-crypto/sha256-js": "5.2.0",

package/routes.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "5.31.0",
+  "version": "5.32.0",
   "routes": [
     {
       "file": "app/%5F_preview/[[...path]]/route.ts",