@anthusai/papyrus 2.0.0-next.1 → 2.0.0-next.10

package/amplify/plugins/editorial-checks/schema.js

@@ -0,0 +1,94 @@
+import { a } from "@aws-amplify/backend";
+import { editorialChecks } from "./function/resource.js";
+const editors = ["editor", "admin"];
+/**
+ * Policies, settings and editors' decisions live in Papyrus; Limatus checks
+ * content against them. Editors read policies and record decisions; admins
+ * manage policies and settings. Only the function (IAM) calls Limatus.
+ */
+export function editorialChecksSchemaDefinitions() {
+    return {
+        EditorialPolicy: a
+            .model({
+            id: a.id().required(),
+            policyKey: a.string().required(),
+            scope: a.string().required(),
+            version: a.integer().required(),
+            title: a.string().required(),
+            guidance: a.string().required(),
+            severity: a.string().required(),
+            enabled: a.boolean().required(),
+            detectors: a.json().required(),
+            examples: a.json(),
+            rewriteGuidance: a.string(),
+            source: a.string().required(),
+        })
+            .disableOperations(["subscriptions"])
+            .authorization((allow) => [allow.group("editor").to(["read"]), allow.group("admin")]),
+        EditorialCheckSettings: a
+            .model({
+            id: a.id().required(),
+            settings: a.json().required(),
+        })
+            .disableOperations(["subscriptions"])
+            .authorization((allow) => [allow.group("editor").to(["read"]), allow.group("admin")]),
+        EditorialFeedback: a
+            .model({
+            id: a.id().required(),
+            itemId: a.string().required(),
+            findingId: a.string().required(),
+            policyId: a.string().required(),
+            detectorId: a.string().required(),
+            lane: a.string().required(),
+            probability: a.float(),
+            decision: a.string().required(),
+            reason: a.string(),
+            text: a.string(),
+        })
+            .disableOperations(["subscriptions"])
+            .secondaryIndexes((index) => [index("itemId").queryField("listEditorialFeedbackByItem")])
+            .authorization((allow) => [allow.group("editor").to(["create", "read"]), allow.group("admin")]),
+        checkEditorial: a
+            .query()
+            .arguments({ body: a.string().required(), format: a.string(), section: a.string() })
+            .returns(a.json())
+            .authorization((allow) => [allow.groups(editors)])
+            .handler(a.handler.function(editorialChecks)),
+        suggestEditorialRewrite: a
+            .query()
+            .arguments({
+            body: a.string().required(),
+            format: a.string(),
+            section: a.string(),
+            finding: a.json(),
+            selection: a.json(),
+            note: a.string(),
+        })
+            .returns(a.json())
+            .authorization((allow) => [allow.groups(editors)])
+            .handler(a.handler.function(editorialChecks)),
+        draftEditorialQuestions: a
+            .query()
+            .arguments({ title: a.string().required(), guidance: a.string().required(), examples: a.json() })
+            .returns(a.json())
+            .authorization((allow) => [allow.group("admin")])
+            .handler(a.handler.function(editorialChecks)),
+        tryEditorialPolicy: a
+            .query()
+            .arguments({ policy: a.json().required(), text: a.string().required(), format: a.string() })
+            .returns(a.json())
+            .authorization((allow) => [allow.group("admin")])
+            .handler(a.handler.function(editorialChecks)),
+        importEditorialStarterPack: a
+            .mutation()
+            .arguments({ name: a.string().required() })
+            .returns(a.json())
+            .authorization((allow) => [allow.group("admin")])
+            .handler(a.handler.function(editorialChecks)),
+        recalibrateEditorialPolicies: a
+            .mutation()
+            .returns(a.json())
+            .authorization((allow) => [allow.group("admin")])
+            .handler(a.handler.function(editorialChecks)),
+    };
+}

package/amplify/plugins/editorial-checks/schema.ts

@@ -0,0 +1,96 @@
+import { a } from "@aws-amplify/backend";
+import { editorialChecks } from "./function/resource";
+
+const editors = ["editor", "admin"];
+
+/**
+ * Policies, settings and editors' decisions live in Papyrus; Limatus checks
+ * content against them. Editors read policies and record decisions; admins
+ * manage policies and settings. Only the function (IAM) calls Limatus.
+ */
+export function editorialChecksSchemaDefinitions() {
+  return {
+    EditorialPolicy: a
+      .model({
+        id: a.id().required(),
+        policyKey: a.string().required(),
+        scope: a.string().required(),
+        version: a.integer().required(),
+        title: a.string().required(),
+        guidance: a.string().required(),
+        severity: a.string().required(),
+        enabled: a.boolean().required(),
+        detectors: a.json().required(),
+        examples: a.json(),
+        rewriteGuidance: a.string(),
+        source: a.string().required(),
+      })
+      .disableOperations(["subscriptions"])
+      .authorization((allow) => [allow.group("editor").to(["read"]), allow.group("admin")]),
+    EditorialCheckSettings: a
+      .model({
+        id: a.id().required(),
+        settings: a.json().required(),
+      })
+      .disableOperations(["subscriptions"])
+      .authorization((allow) => [allow.group("editor").to(["read"]), allow.group("admin")]),
+    EditorialFeedback: a
+      .model({
+        id: a.id().required(),
+        itemId: a.string().required(),
+        findingId: a.string().required(),
+        policyId: a.string().required(),
+        detectorId: a.string().required(),
+        lane: a.string().required(),
+        probability: a.float(),
+        decision: a.string().required(),
+        reason: a.string(),
+        text: a.string(),
+      })
+      .disableOperations(["subscriptions"])
+      .secondaryIndexes((index) => [index("itemId").queryField("listEditorialFeedbackByItem")])
+      .authorization((allow) => [allow.group("editor").to(["create", "read"]), allow.group("admin")]),
+    checkEditorial: a
+      .query()
+      .arguments({ body: a.string().required(), format: a.string(), section: a.string() })
+      .returns(a.json())
+      .authorization((allow) => [allow.groups(editors)])
+      .handler(a.handler.function(editorialChecks)),
+    suggestEditorialRewrite: a
+      .query()
+      .arguments({
+        body: a.string().required(),
+        format: a.string(),
+        section: a.string(),
+        finding: a.json(),
+        selection: a.json(),
+        note: a.string(),
+      })
+      .returns(a.json())
+      .authorization((allow) => [allow.groups(editors)])
+      .handler(a.handler.function(editorialChecks)),
+    draftEditorialQuestions: a
+      .query()
+      .arguments({ title: a.string().required(), guidance: a.string().required(), examples: a.json() })
+      .returns(a.json())
+      .authorization((allow) => [allow.group("admin")])
+      .handler(a.handler.function(editorialChecks)),
+    tryEditorialPolicy: a
+      .query()
+      .arguments({ policy: a.json().required(), text: a.string().required(), format: a.string() })
+      .returns(a.json())
+      .authorization((allow) => [allow.group("admin")])
+      .handler(a.handler.function(editorialChecks)),
+    importEditorialStarterPack: a
+      .mutation()
+      .arguments({ name: a.string().required() })
+      .returns(a.json())
+      .authorization((allow) => [allow.group("admin")])
+      .handler(a.handler.function(editorialChecks)),
+    recalibrateEditorialPolicies: a
+      .mutation()
+      .returns(a.json())
+      .authorization((allow) => [allow.group("admin")])
+      .handler(a.handler.function(editorialChecks)),
+  };
+}

package/amplify/plugins/registry.js

@@ -1,6 +1,8 @@
+import { editorialChecksPlugin } from "./editorial-checks/papyrus.plugin.js";
 import { signupPlugin } from "./signup/papyrus.plugin.js";
 /** Plugins are packaged with Papyrus and pinned by its version: there is no registry to fetch from. */
 export const KNOWN_PLUGINS = {
+    "editorial-checks": editorialChecksPlugin,
     signup: signupPlugin,
 };
 export function resolvePlugins(requests) {

package/amplify/plugins/registry.ts

@@ -1,8 +1,10 @@
 import type { PapyrusPlugin, PluginRequest } from "./types";
+import { editorialChecksPlugin } from "./editorial-checks/papyrus.plugin";
 import { signupPlugin } from "./signup/papyrus.plugin";
 
 /** Plugins are packaged with Papyrus and pinned by its version: there is no registry to fetch from. */
 export const KNOWN_PLUGINS: Record<string, PapyrusPlugin<any, any>> = {
+  "editorial-checks": editorialChecksPlugin,
   signup: signupPlugin,
 };
 

package/amplify/site-backend.js

@@ -23,6 +23,7 @@ import { defineSiteData } from "./data/resource.js";
 import { resolvePlugins } from "./plugins/registry.js";
 import { wirePlugins } from "./plugins/wire.js";
 import { assignmentAction } from "./functions/assignment-action/resource.js";
+import { scopeAssignmentDataAccess } from "./functions/assignment-action/data-access.js";
 import { categoryAction } from "./functions/category-action/resource.js";
 import { ConsoleChatResponderStack } from "./functions/console-chat-responder/resource.js";
 import { contentActions, setSiteFilesForContentActionsBundle } from "./functions/content-actions/resource.js";
@@ -304,10 +305,14 @@ export function defineSiteBackend(papyrusSite) {
     }
     grantCorporaRead(backend.knowledgeQuery.resources.lambda);
     grantNewsroomReadWrite(backend.assignmentAction.resources.lambda);
+    scopeAssignmentDataAccess(backend.assignmentAction.resources.lambda, backend.data.resources.graphqlApi.arn);
     grantNewsroomReadWrite(backend.categoryAction.resources.lambda);
     grantNewsroomReadWrite(backend.newsroomSummary.resources.lambda);
     const contentActionsLambda = backend.contentActions.resources.lambda;
     grantNewsroomReadWriteDelete(contentActionsLambda);
+    // AppSync validates the token; pending intake additionally binds its actor
+    // and publication to this deployment's pool and existing API endpoint.
+    contentActionsLambda.addEnvironment("PAPYRUS_USER_POOL_ISSUER", `https://cognito-idp.${Stack.of(contentActionsLambda).region}.amazonaws.com/${backend.auth.resources.userPool.userPoolId}`);
     contentActionsLambda.addEnvironment("PAPYRUS_GRAPHQL_ENDPOINT", backend.data.resources.cfnResources.cfnGraphqlApi.attrGraphQlUrl);
     contentActionsLambda.addToRolePolicy(new PolicyStatement({
         actions: ["appsync:GraphQL"],

package/amplify/site-backend.ts

@@ -30,6 +30,7 @@ import { defineSiteData } from "./data/resource";
 import { resolvePlugins } from "./plugins/registry";
 import { wirePlugins } from "./plugins/wire";
 import { assignmentAction } from "./functions/assignment-action/resource";
+import { scopeAssignmentDataAccess } from "./functions/assignment-action/data-access";
 import { categoryAction } from "./functions/category-action/resource";
 import { ConsoleChatResponderStack } from "./functions/console-chat-responder/resource";
 import { contentActions, setSiteFilesForContentActionsBundle } from "./functions/content-actions/resource";
@@ -387,10 +388,20 @@ export function defineSiteBackend(papyrusSite: PapyrusSite) {
   }
   grantCorporaRead(backend.knowledgeQuery.resources.lambda as LambdaFunction);
   grantNewsroomReadWrite(backend.assignmentAction.resources.lambda as LambdaFunction);
+  scopeAssignmentDataAccess(
+    backend.assignmentAction.resources.lambda as LambdaFunction,
+    backend.data.resources.graphqlApi.arn,
+  );
   grantNewsroomReadWrite(backend.categoryAction.resources.lambda as LambdaFunction);
   grantNewsroomReadWrite(backend.newsroomSummary.resources.lambda as LambdaFunction);
   const contentActionsLambda = backend.contentActions.resources.lambda as LambdaFunction;
   grantNewsroomReadWriteDelete(contentActionsLambda);
+  // AppSync validates the token; pending intake additionally binds its actor
+  // and publication to this deployment's pool and existing API endpoint.
+  contentActionsLambda.addEnvironment(
+    "PAPYRUS_USER_POOL_ISSUER",
+    `https://cognito-idp.${Stack.of(contentActionsLambda).region}.amazonaws.com/${backend.auth.resources.userPool.userPoolId}`,
+  );
   contentActionsLambda.addEnvironment(
     "PAPYRUS_GRAPHQL_ENDPOINT",
     backend.data.resources.cfnResources.cfnGraphqlApi.attrGraphQlUrl,

package/components/editorial-checks-admin-panel.tsx

@@ -0,0 +1,337 @@
+"use client";
+
+import { useCallback, useEffect, useState } from "react";
+import { Button } from "./ui/button";
+import { Input } from "./ui/input";
+import { Spinner } from "./ui/spinner";
+import { Textarea } from "./ui/textarea";
+import { describeProbability, type EditorialCheckResult } from "../lib/editorial-checks";
+import {
+  DEFAULT_EDITORIAL_SETTINGS,
+  deletePolicy,
+  draftQuestions,
+  importStarterPack,
+  listPolicies,
+  loadSettings,
+  recalibrate,
+  savePolicy,
+  saveSettings,
+  tryPolicy,
+  type EditorialPolicyRecord,
+  type EditorialSettings,
+} from "../lib/editorial-checks-client";
+
+const STARTER_PACK = "ai-writing-tells";
+const POLICY_KEY = /^[a-z0-9][a-z0-9._-]*$/;
+
+type Draft = {
+  isNew: boolean;
+  record: EditorialPolicyRecord;
+  detectorsText: string;
+  violatesText: string;
+  compliesText: string;
+};
+
+function emptyPolicy(): EditorialPolicyRecord {
+  return {
+    id: "",
+    policyKey: "",
+    scope: "publication",
+    version: 1,
+    title: "",
+    guidance: "",
+    severity: "warn",
+    enabled: true,
+    detectors: [],
+    examples: null,
+    rewriteGuidance: null,
+    source: "custom",
+  };
+}
+
+function draftFrom(record: EditorialPolicyRecord, isNew: boolean): Draft {
+  return {
+    isNew,
+    record,
+    detectorsText: JSON.stringify(record.detectors, null, 2),
+    violatesText: (record.examples?.violates ?? []).join("\n"),
+    compliesText: (record.examples?.complies ?? []).join("\n"),
+  };
+}
+
+function lines(text: string): string[] {
+  return text.split("\n").map((line) => line.trim()).filter(Boolean);
+}
+
+/** The policy as Limatus sees it (its key is the policy id). Throws on invalid detector JSON. */
+function limatusPolicy(draft: Draft): Record<string, unknown> {
+  const detectors = JSON.parse(draft.detectorsText || "[]") as unknown;
+  if (!Array.isArray(detectors)) throw new Error("Detectors must be a JSON list.");
+  const violates = lines(draft.violatesText);
+  const complies = lines(draft.compliesText);
+  return {
+    id: draft.record.policyKey || "draft",
+    version: draft.record.version,
+    title: draft.record.title || "Draft policy",
+    guidance: draft.record.guidance || "Draft policy.",
+    severity: draft.record.severity,
+    enabled: true,
+    detectors,
+    ...(violates.length || complies.length ? { examples: { violates, complies } } : {}),
+    ...(draft.record.rewriteGuidance ? { rewriteGuidance: draft.record.rewriteGuidance } : {}),
+  };
+}
+
+export function EditorialChecksAdminPanel() {
+  const [policies, setPolicies] = useState<EditorialPolicyRecord[] | null>(null);
+  const [settings, setSettings] = useState<EditorialSettings>(DEFAULT_EDITORIAL_SETTINGS);
+  const [settingsExist, setSettingsExist] = useState(false);
+  const [draft, setDraft] = useState<Draft | null>(null);
+  const [message, setMessage] = useState<string | null>(null);
+  const [working, setWorking] = useState<string | null>(null);
+  const [tryText, setTryText] = useState("");
+  const [tryResult, setTryResult] = useState<EditorialCheckResult | null>(null);
+
+  const refresh = useCallback(async () => {
+    try {
+      const [loadedPolicies, loadedSettings] = await Promise.all([listPolicies(), loadSettings()]);
+      setPolicies(loadedPolicies);
+      setSettings(loadedSettings.settings);
+      setSettingsExist(loadedSettings.exists);
+    } catch (error) {
+      setMessage(`Error: ${error instanceof Error ? error.message : "could not load editorial checks"}`);
+    }
+  }, []);
+
+  useEffect(() => {
+    void refresh();
+  }, [refresh]);
+
+  const run = async (label: string, action: () => Promise<string | void>) => {
+    setWorking(label);
+    setMessage(null);
+    try {
+      const outcome = await action();
+      if (outcome) setMessage(outcome);
+    } catch (error) {
+      setMessage(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    } finally {
+      setWorking(null);
+    }
+  };
+
+  const patchDraft = (patch: Partial<EditorialPolicyRecord>) => setDraft((current) => (current ? { ...current, record: { ...current.record, ...patch } } : current));
+
+  const save = () =>
+    run("save", async () => {
+      if (!draft) return;
+      const key = draft.record.policyKey.trim();
+      if (!POLICY_KEY.test(key)) throw new Error("The key must be lowercase letters, digits, dots, hyphens or underscores.");
+      if (!draft.record.title.trim() || !draft.record.guidance.trim()) throw new Error("A policy needs a title and guidance.");
+      const policy = limatusPolicy(draft);
+      const record: EditorialPolicyRecord = {
+        ...draft.record,
+        id: draft.isNew ? `${draft.record.scope}#${key}` : draft.record.id,
+        policyKey: key,
+        version: draft.isNew ? 1 : draft.record.version + 1,
+        detectors: policy.detectors as unknown[],
+        examples: (policy.examples as EditorialPolicyRecord["examples"]) ?? null,
+      };
+      await savePolicy(record, draft.isNew);
+      setDraft(null);
+      await refresh();
+      return `Saved ${record.title} (version ${record.version}).`;
+    });
+
+  return (
+    <section aria-labelledby="newsroom-editorial-checks-title" data-news-desk-admin-panel="editorial-checks">
+      <h3 id="newsroom-editorial-checks-title">Editorial checks</h3>
+      <p>
+        Policies the article editor checks drafts against. Rules match words and patterns; judgment questions are answered by a decision model, sentence by sentence.
+        Findings are advice: editors can dismiss them, and publishing is never blocked.
+      </p>
+      <p aria-live="polite" role="status">
+        {working ? <><Spinner /> Working…</> : message}
+      </p>
+
+      <h4>Policies</h4>
+      <div className="flex flex-wrap gap-2">
+        <Button onClick={() => { setDraft(draftFrom(emptyPolicy(), true)); setTryResult(null); }} size="sm" type="button">New policy</Button>
+        <Button
+          disabled={working !== null}
+          onClick={() => run("import", async () => {
+            const outcome = await importStarterPack(STARTER_PACK);
+            await refresh();
+            return `Starter pack: ${outcome.created} policies added, ${outcome.skipped} already present.`;
+          })}
+          size="sm"
+          type="button"
+          variant="outline"
+        >
+          Add AI-writing tells starter pack
+        </Button>
+        <Button
+          disabled={working !== null}
+          onClick={() => run("recalibrate", async () => {
+            const outcome = await recalibrate();
+            await refresh();
+            const notes = outcome.detectors.filter((d) => d.note).map((d) => `${d.policyId}/${d.detectorId}: ${d.note}`);
+            return `Recalibrated ${outcome.updated} ${outcome.updated === 1 ? "policy" : "policies"} from editors' decisions.${notes.length ? ` ${notes.join("; ")}` : ""}`;
+          })}
+          size="sm"
+          type="button"
+          variant="outline"
+        >
+          Recalibrate from editors&apos; decisions
+        </Button>
+      </div>
+      {policies === null ? <p>Loading…</p> : policies.length === 0 ? <p>No policies yet. Add the starter pack or write one.</p> : (
+        <table data-editorial-policies>
+          <thead>
+            <tr><th scope="col">Policy</th><th scope="col">Applies to</th><th scope="col">Severity</th><th scope="col">Detectors</th><th scope="col">On</th><th scope="col"><span className="sr-only">Actions</span></th></tr>
+          </thead>
+          <tbody>
+            {policies.map((policy) => (
+              <tr data-editorial-policy-row={policy.id} key={policy.id}>
+                <td>{policy.title}<br /><small>{policy.policyKey} · v{policy.version}</small></td>
+                <td>{policy.scope === "publication" ? "Whole publication" : `Desk: ${policy.scope}`}</td>
+                <td>{policy.severity}</td>
+                <td>{policy.detectors.length === 0 ? "Guidance only" : policy.detectors.length}</td>
+                <td>
+                  <input
+                    aria-label={`${policy.title} enabled`}
+                    checked={policy.enabled}
+                    onChange={(event) => void run("toggle", async () => {
+                      await savePolicy({ ...policy, enabled: event.target.checked, version: policy.version + 1 }, false);
+                      await refresh();
+                    })}
+                    type="checkbox"
+                  />
+                </td>
+                <td>
+                  <button onClick={() => { setDraft(draftFrom(policy, false)); setTryResult(null); }} type="button">Edit</button>
+                </td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      )}
+
+      {draft ? (
+        <form
+          className="space-y-2"
+          data-editorial-policy-form
+          onSubmit={(event) => { event.preventDefault(); void save(); }}
+        >
+          <h4>{draft.isNew ? "New policy" : `Edit ${draft.record.title}`}</h4>
+          <label>Key <Input disabled={!draft.isNew} onChange={(event) => patchDraft({ policyKey: event.target.value })} value={draft.record.policyKey} /></label>
+          <label>Title <Input onChange={(event) => patchDraft({ title: event.target.value })} value={draft.record.title} /></label>
+          <label>
+            Applies to (publication, or a desk key){" "}
+            <Input disabled={!draft.isNew} onChange={(event) => patchDraft({ scope: event.target.value.trim() || "publication" })} value={draft.record.scope} />
+          </label>
+          <label>
+            Severity{" "}
+            <select onChange={(event) => patchDraft({ severity: event.target.value as EditorialPolicyRecord["severity"] })} value={draft.record.severity}>
+              <option value="error">Must fix</option>
+              <option value="warn">Should fix</option>
+              <option value="info">Consider</option>
+            </select>
+          </label>
+          <label>Guidance (what the policy asks, in plain words) <Textarea onChange={(event) => patchDraft({ guidance: event.target.value })} rows={3} value={draft.record.guidance} /></label>
+          <label>How to fix it (for rewrite suggestions) <Textarea onChange={(event) => patchDraft({ rewriteGuidance: event.target.value || null })} rows={2} value={draft.record.rewriteGuidance ?? ""} /></label>
+          <label>Examples that break it (one per line) <Textarea onChange={(event) => setDraft({ ...draft, violatesText: event.target.value })} rows={3} value={draft.violatesText} /></label>
+          <label>Examples that follow it (one per line) <Textarea onChange={(event) => setDraft({ ...draft, compliesText: event.target.value })} rows={3} value={draft.compliesText} /></label>
+          <label>
+            Detectors (JSON; see <code>limatus schema policy-pack-v1</code>)
+            <Textarea className="font-mono text-xs" onChange={(event) => setDraft({ ...draft, detectorsText: event.target.value })} rows={10} value={draft.detectorsText} />
+          </label>
+          <div className="flex flex-wrap gap-2">
+            <Button
+              disabled={working !== null || !draft.record.title.trim() || !draft.record.guidance.trim()}
+              onClick={() => run("draft", async () => {
+                const drafted = await draftQuestions(draft.record.title, draft.record.guidance);
+                const existing = JSON.parse(draft.detectorsText || "[]") as unknown[];
+                setDraft({ ...draft, detectorsText: JSON.stringify([...existing, ...drafted.detectors], null, 2) });
+                return `Added ${drafted.detectors.length} drafted judgment question(s). Review them before saving. ${drafted.notes.join(" ")}`;
+              })}
+              type="button"
+              variant="outline"
+            >
+              Draft judgment questions
+            </Button>
+            <Button disabled={working !== null} type="submit">Save</Button>
+            {!draft.isNew ? (
+              <Button
+                onClick={() => run("delete", async () => {
+                  await deletePolicy(draft.record.id);
+                  setDraft(null);
+                  await refresh();
+                  return "Policy deleted.";
+                })}
+                type="button"
+                variant="outline"
+              >
+                Delete
+              </Button>
+            ) : null}
+            <Button onClick={() => setDraft(null)} type="button" variant="ghost">Cancel</Button>
+          </div>
+
+          <fieldset className="space-y-2" data-editorial-try>
+            <legend>Try it on sample text (nothing is saved)</legend>
+            <Textarea onChange={(event) => setTryText(event.target.value)} rows={4} value={tryText} />
+            <Button
+              disabled={working !== null || !tryText.trim()}
+              onClick={() => run("try", async () => {
+                setTryResult(await tryPolicy(limatusPolicy(draft), tryText));
+              })}
+              size="sm"
+              type="button"
+              variant="outline"
+            >
+              Try policy
+            </Button>
+            {tryResult ? (
+              tryResult.findings.length === 0 ? <p>No findings.</p> : (
+                <ul data-editorial-try-findings>
+                  {tryResult.findings.map((finding) => (
+                    <li key={finding.id}>
+                      {finding.status === "review" ? "Unsure: " : ""}“{finding.excerpt || "whole text"}” {describeProbability(finding) ? `(${describeProbability(finding)})` : ""}
+                    </li>
+                  ))}
+                </ul>
+              )
+            ) : null}
+          </fieldset>
+        </form>
+      ) : null}
+
+      <h4>Settings</h4>
+      <form
+        className="space-y-2"
+        data-editorial-settings
+        onSubmit={(event) => {
+          event.preventDefault();
+          void run("settings", async () => {
+            await saveSettings(settings, settingsExist);
+            setSettingsExist(true);
+            return "Settings saved.";
+          });
+        }}
+      >
+        <label><input checked={settings.lanes.rules} onChange={(event) => setSettings({ ...settings, lanes: { ...settings.lanes, rules: event.target.checked } })} type="checkbox" /> Rule checks</label>
+        <label><input checked={settings.lanes.classifier} onChange={(event) => setSettings({ ...settings, lanes: { ...settings.lanes, classifier: event.target.checked } })} type="checkbox" /> Judgment checks (decision model)</label>
+        <label><input checked={settings.checkWhileTyping} onChange={(event) => setSettings({ ...settings, checkWhileTyping: event.target.checked })} type="checkbox" /> Check while editors type (after a short pause)</label>
+        <label><input checked={settings.publishWarning} onChange={(event) => setSettings({ ...settings, publishWarning: event.target.checked })} type="checkbox" /> Warn before publishing with open findings</label>
+        <label>Decision model <Input onChange={(event) => setSettings({ ...settings, classifierModel: event.target.value })} value={settings.classifierModel} /></label>
+        <label>Rewrite model <Input onChange={(event) => setSettings({ ...settings, rewriteModel: event.target.value })} value={settings.rewriteModel} /></label>
+        <label>Time limit for judgment checks (seconds, under 28) <Input max={26} min={1} onChange={(event) => setSettings({ ...settings, deadlineSeconds: Number(event.target.value) })} type="number" value={settings.deadlineSeconds} /></label>
+        <label>Input-token budget per check <Input min={1} onChange={(event) => setSettings({ ...settings, maxInputTokens: Number(event.target.value) })} type="number" value={settings.maxInputTokens} /></label>
+        <label>Past decisions shown to each judgment question <Input max={32} min={0} onChange={(event) => setSettings({ ...settings, maxExamplesPerQuestion: Number(event.target.value) })} type="number" value={settings.maxExamplesPerQuestion} /></label>
+        <label>House guidance for rewrites <Textarea onChange={(event) => setSettings({ ...settings, guidance: event.target.value })} rows={3} value={settings.guidance} /></label>
+        <Button disabled={working !== null} type="submit">Save settings</Button>
+      </form>
+    </section>
+  );
+}