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

package/components/reference-live-agreement.tsx

@@ -12,10 +12,10 @@ import { formatSuggestionTime } from "./reference-cyclotron-suggestion";
 
 function MeasurementFigures({ measurement }: { measurement: AgreementStripMeasurement }) {
   const figures: Array<[string, string]> = [
-    ["Agreement", formatPercentage(measurement.agreement)],
-    ["Precision", formatPercentage(measurement.precision)],
-    ["Recall", formatPercentage(measurement.recall)],
-    ["Comparisons", String(measurement.comparisons)],
+    ["Matches editors", formatPercentage(measurement.agreement)],
+    ["Suggested includes editors kept", formatPercentage(measurement.precision)],
+    ["Editor includes suggested", formatPercentage(measurement.recall)],
+    ["Decisions compared", String(measurement.comparisons)],
   ];
   return (
     <dl className="flex flex-wrap gap-x-6 gap-y-1">
@@ -30,19 +30,19 @@ function MeasurementFigures({ measurement }: { measurement: AgreementStripMeasur
 }
 
 /**
- * Live agreement at the top of References: how often the cyclotron's
+ * Live agreement at the top of References: how often the
  * suggestions matched what editors then decided. Hidden without a payload.
  */
 export function ReferenceLiveAgreement({ agreement }: { agreement: ShadowAgreement | null }) {
   const state = agreementStripState(agreement);
   if (state.kind === "hidden") return null;
   return (
-    <section aria-label="Live agreement" className="shrink-0 space-y-2 border-y border-foreground py-3" data-reference-live-agreement={state.kind}>
-      <h3 className="text-xs font-semibold uppercase tracking-wide text-foreground">Live agreement</h3>
+    <section aria-label="Suggestion accuracy" className="shrink-0 space-y-2 border-y border-foreground py-3" data-reference-live-agreement={state.kind}>
+      <h3 className="text-xs font-semibold uppercase tracking-wide text-foreground">Suggestion accuracy</h3>
       {state.loop ? (
         <p className="text-sm text-foreground" data-reference-live-agreement-loop>
           <span className="font-semibold">{loopStateWords(state.loop)}</span>
-          {" · "}Last sweep {formatSuggestionTime(state.loop.lastSweepAt)}
+          {" · "}Last checked {formatSuggestionTime(state.loop.lastSweepAt)}
           {" · "}{dailyCapWords(state.loop)}
         </p>
       ) : null}
@@ -51,11 +51,11 @@ export function ReferenceLiveAgreement({ agreement }: { agreement: ShadowAgreeme
       ) : null}
       {state.kind === "not_enough" ? (
         <p className="text-sm text-foreground" data-reference-live-agreement-not-enough>
-          Not enough comparisons yet: {state.measurement.comparisons} of {state.needed} editor decisions have followed a suggestion. Figures appear at {state.needed}.
+          Not enough decisions yet: {state.measurement.comparisons} of {state.needed} editor decisions have followed a suggestion. Figures appear at {state.needed}.
         </p>
       ) : <MeasurementFigures measurement={state.measurement} />}
       <p className="text-xs text-foreground">
-        Suggestions compared with the decisions editors made afterwards. Computed {formatSuggestionTime(agreement?.computedAt ?? null)}.
+        Suggestions compared with the decisions editors made afterwards. Updated {formatSuggestionTime(agreement?.computedAt ?? null)}.
       </p>
     </section>
   );

package/components/reference-priming.tsx

@@ -10,7 +10,7 @@ export function ReferencePriming(props: PrimingPanelProps) {
   return (
     <section className="shrink-0 space-y-3" aria-label="Representative reference examples">
       <Button aria-expanded={open} onClick={() => setOpen((value) => !value)} variant="outline">
-        {open ? "Hide example priming" : "Curate reference examples (optional)"}
+        {open ? "Hide example references" : "Add example references (optional)"}
       </Button>
       {open ? <div className="max-h-[55dvh] space-y-3 overflow-y-auto pr-1"><p className="text-sm text-muted-foreground">Corrections to extracted content: describe what needs fixing, then enter the corrected title and abstract or summary. The note is saved with your correction; it does not automatically regenerate the content. Choose Publish / Not publish separately. An explanation of that judgment is optional.</p><PrimingPanel {...props} renderItem={props.renderItem ?? ((item) => <div className="space-y-2"><p className="whitespace-pre-wrap text-sm">{String(item.values.abstract ?? item.values.text ?? "")}</p><p className="break-all text-xs text-muted-foreground">{String(item.values.source_uri ?? "")}</p></div>)} /></div> : null}
     </section>

package/components/reference-relevance-review.tsx

@@ -67,7 +67,7 @@ export function ReferenceRelevanceReview({
           onChange={(event) => setShareable(event.target.checked)}
           type="checkbox"
         />
-        My explanation may be quoted publicly (for the Cyclotron example page)
+        My explanation may be quoted publicly (on a public example page)
       </label>
       {error ? <p className="text-xs text-destructive" role="alert">{error}</p> : null}
     </section>

package/components/reference-section-suggestion.tsx

@@ -98,7 +98,7 @@ export function SectionPicker({
           </label>
         );
       })}
-      <p className="text-xs text-foreground">The Section you choose is a training label for the cyclotron.</p>
+      <p className="text-xs text-foreground">The Section you choose is saved with your decision.</p>
     </fieldset>
   );
 }

package/components/topic-steering-workspace.tsx

@@ -13,6 +13,7 @@ import { usePathname, useRouter } from "next/navigation";
 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 { SignupEntriesPanel } from "./signup-entries-panel";
 import { pluginSettings, type PluginOutputs } from "../lib/plugin-settings";
 import { generateClient } from "aws-amplify/data";
@@ -246,7 +247,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";
+type AdministrationPanel = "users" | "policies" | "sections" | "procedures" | "delegations" | "signups" | "editorial-checks";
 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";
@@ -4317,6 +4318,17 @@ function AdministrationDeskView({
                 <strong>Agent delegations</strong>
                 <span>Let an agent curate References for you</span>
               </Link>
+              {editorialChecksPluginEnabled() ? (
+                <Link
+                  href={administrationPanelHref("editorial-checks", isDemo)}
+                  data-news-desk-admin-nav="editorial-checks"
+                  data-active={administrationPanel === "editorial-checks" || undefined}
+                  onClick={() => onPanelChange("editorial-checks")}
+                >
+                  <strong>Editorial checks</strong>
+                  <span>Policies the article editor checks drafts against</span>
+                </Link>
+              ) : null}
               {signupPluginEnabled() ? (
                 <Link
                   href={administrationPanelHref("signups", isDemo)}
@@ -4331,6 +4343,7 @@ function AdministrationDeskView({
             </nav>}
             <div className="news-desk-settings-panel">
               {administrationPanel === "signups" ? <SignupEntriesPanel /> : null}
+              {administrationPanel === "editorial-checks" ? <EditorialChecksAdminPanel /> : null}
               {administrationPanel === "delegations" ? <AdministrationDelegationsPanel disabled={disabled} /> : null}
               {administrationPanel === "users" ? (
                 <AdministrationUsersPanel
@@ -12794,9 +12807,14 @@ function signupPluginEnabled(): boolean {
   return pluginSettings(amplifyOutputs as PluginOutputs, "signup") !== null;
 }
 
+function editorialChecksPluginEnabled(): boolean {
+  return pluginSettings(amplifyOutputs as PluginOutputs, "editorial-checks") !== null;
+}
+
 function normalizeAdministrationPanel(value: string | null | undefined): AdministrationPanel {
   if (value === "policies" || value === "sections" || value === "procedures" || value === "delegations") return value;
   if (value === "signups" && signupPluginEnabled()) return value;
+  if (value === "editorial-checks" && editorialChecksPluginEnabled()) return value;
   return "users";
 }
 

package/components/use-editorial-checks.ts

@@ -0,0 +1,131 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import {
+  feedbackFor,
+  publishWarnings,
+  type EditorialCheckResult,
+  type EditorialFinding,
+  type FeedbackDecision,
+  type RewriteResult,
+  type Span,
+} from "../lib/editorial-checks";
+import type { EditorialChecksBackend } from "../lib/editorial-checks-backend";
+import { DEFAULT_EDITORIAL_SETTINGS, type EditorialSettings } from "../lib/editorial-checks-settings";
+import type { CheckStatus } from "./editorial-findings-panel";
+
+const CHECK_PAUSE_MS = 2000;
+
+/**
+ * Editorial checks for one article body. A result only applies to the exact body
+ * it was computed for: if the editor typed while the check ran, the result is
+ * dropped and the next pause checks again.
+ */
+export function useEditorialChecks({
+  backend,
+  body,
+  section,
+  itemId,
+}: {
+  /** null turns editorial checks off. */
+  backend: EditorialChecksBackend | null;
+  body: string | null;
+  section: string;
+  itemId: string | null;
+}) {
+  const enabled = backend !== null;
+  const [settings, setSettings] = useState<EditorialSettings>(DEFAULT_EDITORIAL_SETTINGS);
+  const [result, setResult] = useState<EditorialCheckResult | null>(null);
+  const [checkedBody, setCheckedBody] = useState<string | null>(null);
+  const [status, setStatus] = useState<CheckStatus>({ state: "idle" });
+  const [dismissed, setDismissed] = useState<Set<string>>(() => new Set());
+  const [activeFindingId, setActiveFindingId] = useState<string | null>(null);
+  const [selection, setSelection] = useState<Span>({ start: 0, end: 0 });
+  const latestBody = useRef(body);
+  latestBody.current = body;
+  const sequence = useRef(0);
+
+  useEffect(() => {
+    if (!enabled) return;
+    backend?.loadSettings().then(({ settings: loaded }) => setSettings(loaded)).catch(() => undefined);
+  }, [backend, enabled]);
+
+  useEffect(() => {
+    if (!enabled || !itemId) return;
+    backend?.dismissedFindingIds(itemId).then(setDismissed).catch(() => undefined);
+  }, [backend, enabled, itemId]);
+
+  const check = useCallback(async () => {
+    const text = latestBody.current;
+    if (!backend || text === null || !text.trim()) return;
+    const run = ++sequence.current;
+    setStatus({ state: "checking" });
+    try {
+      const checked = await backend.check(text, section.trim() || null);
+      if (run !== sequence.current) return;
+      if (latestBody.current !== text) {
+        setStatus({ state: "idle" });
+        return;
+      }
+      setResult(checked);
+      setCheckedBody(text);
+      setStatus({ state: "idle" });
+    } catch (error) {
+      if (run === sequence.current) setStatus({ state: "error", message: error instanceof Error ? error.message : "The check failed." });
+    }
+  }, [backend, section]);
+
+  useEffect(() => {
+    if (!enabled || !settings.checkWhileTyping || body === null || body === checkedBody) return;
+    const timer = window.setTimeout(() => void check(), CHECK_PAUSE_MS);
+    return () => window.clearTimeout(timer);
+  }, [body, check, checkedBody, enabled, settings.checkWhileTyping]);
+
+  const record = useCallback(
+    (finding: EditorialFinding, decision: FeedbackDecision, reason: string | null = null) => {
+      if (!result || checkedBody === null) return;
+      void backend?.recordFeedback(feedbackFor(result, checkedBody, finding, decision, itemId, reason)).catch(() => undefined);
+    },
+    [backend, checkedBody, itemId, result],
+  );
+
+  const dismiss = useCallback(
+    (finding: EditorialFinding, reason: string) => {
+      record(finding, "dismissed", reason);
+      setDismissed((current) => new Set(current).add(finding.id));
+    },
+    [record],
+  );
+
+  const suggest = useCallback(
+    (target: { finding: EditorialFinding } | { selection: Span }, note: string | null): Promise<RewriteResult> =>
+      backend
+        ? backend.suggest(latestBody.current ?? "", section.trim() || null, target, note)
+        : Promise.reject(new Error("Editorial checks are off.")),
+    [backend, section],
+  );
+
+  const current = result && checkedBody === body;
+  return {
+    enabled,
+    settings,
+    result,
+    /** Findings whose spans still match the body on screen. */
+    inlineResult: current ? result : null,
+    status,
+    dismissed,
+    activeFindingId,
+    setActiveFindingId,
+    selection,
+    setSelection,
+    check,
+    suggest,
+    dismiss,
+    accept: (finding: EditorialFinding) => record(finding, "accepted"),
+    fixed: (finding: EditorialFinding) => {
+      record(finding, "fixed");
+      setDismissed((current) => new Set(current).add(finding.id));
+    },
+    openWarnings: enabled && settings.publishWarning && result ? publishWarnings(result.findings, dismissed) : [],
+  };
+}

package/lib/cyclotron-suggestions.ts

@@ -92,13 +92,13 @@ export function latestShadowAgreement(payloads: Array<{ json: unknown; updatedAt
 }
 
 const STOP_REASON_WORDS: Record<string, string> = {
-  disabled: "The relevance cyclotron is switched off in the steering config, so it is making no suggestions.",
-  "daily decision cap": "The last sweep stopped at the daily decision cap, so some references have no suggestion yet.",
+  disabled: "Suggestions are switched off in the settings, so none are being made.",
+  "daily decision cap": "The last check reached the daily limit, so some references have no suggestion yet.",
 };
 
 /** The sentence an editor reads for a stop reason; unknown reasons are shown as given. */
 export function stopReasonSentence(reason: string): string {
-  return STOP_REASON_WORDS[reason] ?? `The last sweep stopped early: ${reason}.`;
+  return STOP_REASON_WORDS[reason] ?? `The last check stopped early: ${reason}.`;
 }
 
 /**
@@ -123,14 +123,14 @@ export function agreementStripState(agreement: ShadowAgreement | null): Agreemen
   };
 }
 
-/** "Loop on" or "Loop off", the word the strip leads with. */
+/** "Suggestions on" or "Suggestions off", the words the panel leads with. */
 export function loopStateWords(loop: CyclotronLoopState): string {
-  return loop.enabled ? "Loop on" : "Loop off";
+  return loop.enabled ? "Suggestions on" : "Suggestions off";
 }
 
 /** The daily cap in words; no cap is said plainly. */
 export function dailyCapWords(loop: CyclotronLoopState): string {
-  return loop.maxDecisionsPerDay === null ? "No daily decision cap" : `Daily cap ${loop.maxDecisionsPerDay} decisions`;
+  return loop.maxDecisionsPerDay === null ? "No daily limit" : `Daily limit ${loop.maxDecisionsPerDay} decisions`;
 }
 
 export function formatPercentage(fraction: number | null): string {
@@ -202,10 +202,10 @@ export function provenanceSummary(decision: RelevanceDecisionView): ProvenanceSu
   if (!provenance) return null;
   const plural = (count: number, singular: string) => `${count} ${singular}${count === 1 ? "" : "s"}`;
   return {
-    teachingLabelsSentence: `Taught by ${plural(provenance.teachingLabels, "label")} that editors set themselves`,
-    primingExamplesSentence: `${plural(provenance.primingExamples, "priming example")} supplied as starting examples`,
+    teachingLabelsSentence: `Based on ${plural(provenance.teachingLabels, "decision")} that editors made themselves`,
+    primingExamplesSentence: `${plural(provenance.primingExamples, "example reference")} supplied as starting examples`,
     doctrineShortHash: provenance.doctrineFingerprint ? provenance.doctrineFingerprint.slice(0, SHORT_HASH_LENGTH) : null,
-    modelVersion: decision.version === null ? null : `version ${decision.version}`,
+    modelVersion: decision.version === null ? null : `revision ${decision.version}`,
     decidedAt: decision.decidedAt,
   };
 }

package/lib/editorial-checks-backend.ts

@@ -0,0 +1,16 @@
+import type { EditorialCheckResult, EditorialFeedbackInput, EditorialFinding, RewriteResult, Span } from "./editorial-checks";
+import type { EditorialSettings } from "./editorial-checks-settings";
+
+/** What the article editor needs from editorial checks: the plugin's GraphQL API, or the demo. */
+export type EditorialChecksBackend = {
+  loadSettings: () => Promise<{ settings: EditorialSettings; exists: boolean }>;
+  dismissedFindingIds: (itemId: string) => Promise<Set<string>>;
+  check: (body: string, section: string | null) => Promise<EditorialCheckResult>;
+  suggest: (
+    body: string,
+    section: string | null,
+    target: { finding: EditorialFinding } | { selection: Span },
+    note: string | null,
+  ) => Promise<RewriteResult>;
+  recordFeedback: (input: EditorialFeedbackInput) => Promise<void>;
+};

package/lib/editorial-checks-client.ts

@@ -0,0 +1,194 @@
+"use client";
+
+import { generateClient } from "aws-amplify/data";
+import type { EditorialCheckResult, EditorialFeedbackInput, EditorialFinding, RewriteResult, Span } from "./editorial-checks";
+import type { EditorialChecksBackend } from "./editorial-checks-backend";
+import { DEFAULT_EDITORIAL_SETTINGS, type EditorialSettings } from "./editorial-checks-settings";
+
+export { DEFAULT_EDITORIAL_SETTINGS, type EditorialSettings };
+
+type GraphQLResult<T> = { data?: T; errors?: { message?: string }[] };
+
+async function call<T>(query: string, variables: Record<string, unknown> = {}): Promise<T> {
+  const client = generateClient({ authMode: "userPool" });
+  const result = (await client.graphql({ query, variables })) as GraphQLResult<T>;
+  if (result.errors?.length) throw new Error(result.errors[0]?.message ?? "Editorial checks request failed.");
+  if (!result.data) throw new Error("Editorial checks returned no data.");
+  return result.data;
+}
+
+/** AWSJSON comes back as a JSON string. */
+function parsed<T>(value: unknown): T {
+  return (typeof value === "string" ? JSON.parse(value) : value) as T;
+}
+
+export async function checkEditorial(body: string, section: string | null): Promise<EditorialCheckResult> {
+  const data = await call<{ checkEditorial: unknown }>(
+    `query CheckEditorial($body: String!, $format: String, $section: String) { checkEditorial(body: $body, format: $format, section: $section) }`,
+    { body, format: "markus", section },
+  );
+  return parsed<EditorialCheckResult>(data.checkEditorial);
+}
+
+export async function suggestRewrites(
+  body: string,
+  section: string | null,
+  target: { finding: EditorialFinding } | { selection: Span },
+  note: string | null,
+): Promise<RewriteResult> {
+  const data = await call<{ suggestEditorialRewrite: unknown }>(
+    `query SuggestEditorialRewrite($body: String!, $format: String, $section: String, $finding: AWSJSON, $selection: AWSJSON, $note: String) {
+      suggestEditorialRewrite(body: $body, format: $format, section: $section, finding: $finding, selection: $selection, note: $note)
+    }`,
+    {
+      body,
+      format: "markus",
+      section,
+      finding: "finding" in target ? JSON.stringify(target.finding) : null,
+      selection: "selection" in target ? JSON.stringify(target.selection) : null,
+      note,
+    },
+  );
+  return parsed<RewriteResult>(data.suggestEditorialRewrite);
+}
+
+export async function recordFeedback(input: EditorialFeedbackInput): Promise<void> {
+  await call(
+    `mutation CreateEditorialFeedback($input: CreateEditorialFeedbackInput!) { createEditorialFeedback(input: $input) { id } }`,
+    { input },
+  );
+}
+
+export async function dismissedFindingIds(itemId: string): Promise<Set<string>> {
+  const ids = new Set<string>();
+  let nextToken: string | null | undefined;
+  do {
+    const data = await call<{ listEditorialFeedbackByItem: { items: { findingId: string; decision: string }[]; nextToken?: string | null } }>(
+      `query ListEditorialFeedbackByItem($itemId: String!, $nextToken: String) {
+        listEditorialFeedbackByItem(itemId: $itemId, limit: 500, nextToken: $nextToken) { items { findingId decision } nextToken }
+      }`,
+      { itemId, nextToken },
+    );
+    for (const item of data.listEditorialFeedbackByItem.items) if (item.decision === "dismissed") ids.add(item.findingId);
+    nextToken = data.listEditorialFeedbackByItem.nextToken;
+  } while (nextToken);
+  return ids;
+}
+
+// --- administration ---------------------------------------------------------------
+
+export type EditorialPolicyRecord = {
+  id: string;
+  policyKey: string;
+  scope: string;
+  version: number;
+  title: string;
+  guidance: string;
+  severity: "info" | "warn" | "error";
+  enabled: boolean;
+  detectors: unknown[];
+  examples: { violates?: string[]; complies?: string[] } | null;
+  rewriteGuidance: string | null;
+  source: string;
+};
+
+const POLICY_FIELDS = "id policyKey scope version title guidance severity enabled detectors examples rewriteGuidance source";
+
+function policyFromRow(row: Record<string, unknown>): EditorialPolicyRecord {
+  return {
+    ...(row as unknown as EditorialPolicyRecord),
+    detectors: parsed<unknown[]>(row.detectors ?? "[]"),
+    examples: row.examples ? parsed<EditorialPolicyRecord["examples"]>(row.examples) : null,
+  };
+}
+
+function policyInput(policy: EditorialPolicyRecord): Record<string, unknown> {
+  return {
+    ...policy,
+    detectors: JSON.stringify(policy.detectors),
+    examples: policy.examples ? JSON.stringify(policy.examples) : null,
+  };
+}
+
+export async function listPolicies(): Promise<EditorialPolicyRecord[]> {
+  const policies: EditorialPolicyRecord[] = [];
+  let nextToken: string | null | undefined;
+  do {
+    const data = await call<{ listEditorialPolicies: { items: Record<string, unknown>[]; nextToken?: string | null } }>(
+      `query ListEditorialPolicies($nextToken: String) { listEditorialPolicies(limit: 500, nextToken: $nextToken) { items { ${POLICY_FIELDS} } nextToken } }`,
+      { nextToken },
+    );
+    policies.push(...data.listEditorialPolicies.items.map(policyFromRow));
+    nextToken = data.listEditorialPolicies.nextToken;
+  } while (nextToken);
+  return policies.sort((a, b) => a.scope.localeCompare(b.scope) || a.title.localeCompare(b.title));
+}
+
+export async function savePolicy(policy: EditorialPolicyRecord, isNew: boolean): Promise<void> {
+  const operation = isNew ? "createEditorialPolicy" : "updateEditorialPolicy";
+  const inputType = isNew ? "CreateEditorialPolicyInput" : "UpdateEditorialPolicyInput";
+  await call(`mutation SavePolicy($input: ${inputType}!) { ${operation}(input: $input) { id } }`, { input: policyInput(policy) });
+}
+
+export async function deletePolicy(id: string): Promise<void> {
+  await call(`mutation DeleteEditorialPolicy($input: DeleteEditorialPolicyInput!) { deleteEditorialPolicy(input: $input) { id } }`, { input: { id } });
+}
+
+export async function loadSettings(): Promise<{ settings: EditorialSettings; exists: boolean }> {
+  const data = await call<{ getEditorialCheckSettings: { settings: unknown } | null }>(
+    `query GetEditorialCheckSettings { getEditorialCheckSettings(id: "settings") { settings } }`,
+  );
+  const stored = data.getEditorialCheckSettings ? parsed<Partial<EditorialSettings>>(data.getEditorialCheckSettings.settings) : {};
+  return {
+    settings: { ...DEFAULT_EDITORIAL_SETTINGS, ...stored, lanes: { ...DEFAULT_EDITORIAL_SETTINGS.lanes, ...(stored.lanes ?? {}) } },
+    exists: data.getEditorialCheckSettings !== null,
+  };
+}
+
+export async function saveSettings(settings: EditorialSettings, exists: boolean): Promise<void> {
+  const operation = exists ? "updateEditorialCheckSettings" : "createEditorialCheckSettings";
+  const inputType = exists ? "UpdateEditorialCheckSettingsInput" : "CreateEditorialCheckSettingsInput";
+  await call(`mutation SaveSettings($input: ${inputType}!) { ${operation}(input: $input) { id } }`, {
+    input: { id: "settings", settings: JSON.stringify(settings) },
+  });
+}
+
+export async function importStarterPack(name: string): Promise<{ created: number; skipped: number }> {
+  const data = await call<{ importEditorialStarterPack: unknown }>(
+    `mutation ImportStarterPack($name: String!) { importEditorialStarterPack(name: $name) }`,
+    { name },
+  );
+  return parsed(data.importEditorialStarterPack);
+}
+
+export async function tryPolicy(policy: Record<string, unknown>, text: string): Promise<EditorialCheckResult> {
+  const data = await call<{ tryEditorialPolicy: unknown }>(
+    `query TryEditorialPolicy($policy: AWSJSON!, $text: String!) { tryEditorialPolicy(policy: $policy, text: $text, format: "markus") }`,
+    { policy: JSON.stringify(policy), text },
+  );
+  return parsed(data.tryEditorialPolicy);
+}
+
+export type DraftedQuestions = { detectors: Record<string, unknown>[]; notes: string[]; model: string };
+
+export async function draftQuestions(title: string, guidance: string): Promise<DraftedQuestions> {
+  const data = await call<{ draftEditorialQuestions: unknown }>(
+    `query DraftEditorialQuestions($title: String!, $guidance: String!) { draftEditorialQuestions(title: $title, guidance: $guidance) }`,
+    { title, guidance },
+  );
+  return parsed(data.draftEditorialQuestions);
+}
+
+export async function recalibrate(): Promise<{ updated: number; detectors: { policyId: string; detectorId: string; labels: number; note?: string }[] }> {
+  const data = await call<{ recalibrateEditorialPolicies: unknown }>(`mutation Recalibrate { recalibrateEditorialPolicies }`);
+  return parsed(data.recalibrateEditorialPolicies);
+}
+
+/** The plugin's GraphQL API, signed in as the editor. */
+export const graphqlEditorialBackend: EditorialChecksBackend = {
+  loadSettings,
+  dismissedFindingIds,
+  check: checkEditorial,
+  suggest: suggestRewrites,
+  recordFeedback,
+};