@anthusai/papyrus 1.0.0-next.32 → 1.0.0-next.33

package/amplify/data/resource.js

@@ -287,6 +287,8 @@ const schema = a.schema({
         actorLabel: a.string(),
         note: a.string(),
         reasonCode: a.string(),
+        decisionRelationId: a.id(),
+        shareable: a.boolean(),
     })
         .returns(a.ref("ReferenceCurationActionResult"))
         .authorization((allow) => [

package/amplify/data/resource.ts

@@ -312,6 +312,8 @@ const schema = a.schema({
       actorLabel: a.string(),
       note: a.string(),
       reasonCode: a.string(),
+      decisionRelationId: a.id(),
+      shareable: a.boolean(),
     })
     .returns(a.ref("ReferenceCurationActionResult"))
     .authorization((allow) => [

package/amplify/data/schema.js

@@ -245,6 +245,8 @@ export const schema = a.schema({
         actorLabel: a.string(),
         note: a.string(),
         reasonCode: a.string(),
+        decisionRelationId: a.id(),
+        shareable: a.boolean(),
     })
         .returns(a.ref("ReferenceCurationActionResult"))
         .authorization((allow) => [

package/amplify/data/schema.ts

@@ -268,6 +268,8 @@ export const schema = a.schema({
       actorLabel: a.string(),
       note: a.string(),
       reasonCode: a.string(),
+      decisionRelationId: a.id(),
+      shareable: a.boolean(),
     })
     .returns(a.ref("ReferenceCurationActionResult"))
     .authorization((allow) => [

package/amplify/functions/category-action/handler.ts

@@ -4,6 +4,7 @@ import { Amplify } from "aws-amplify";
 import { generateClient } from "aws-amplify/data";
 import type { Schema } from "../../data/resource";
 import { putJsonModelPayload, putTextModelPayload, readJsonModelPayload } from "../shared/model-payloads";
+import { referenceCurationMetadata } from "../shared/reference-curation-metadata";
 
 type ReviewHandler = Schema["reviewSteeringProposal"]["functionHandler"];
 type ReferenceCurationHandler = Schema["reviewReferenceCuration"]["functionHandler"];
@@ -225,14 +226,15 @@ async function reviewReferenceCuration(event: Parameters<ReferenceCurationHandle
     { ownerKind: "message", ownerId: messageId, ownerLineageId: messageId },
     "metadata",
     "metadata",
-    {
+    referenceCurationMetadata({
       action,
       curationStatus: nextStatus,
       reasonCode,
-      curationReasonCode: reasonCode,
       referenceId,
       referenceLineageId,
-    },
+      decisionRelationId: normalizeOptionalString(event.arguments.decisionRelationId),
+      shareable: event.arguments.shareable ?? null,
+    }),
     { filename: "metadata.json", now },
   );
 

package/amplify/functions/shared/reference-curation-metadata.ts

@@ -0,0 +1,29 @@
+/**
+ * Metadata stored with an editor's reference curation Message. When the
+ * relevance cyclotron decided the reference, the review records which
+ * decision it answered and whether its explanation may be shared (for the
+ * Cyclotron marketing recording). Both are optional.
+ */
+export type ReferenceCurationMetadataInput = {
+  action: string
+  curationStatus: string
+  reasonCode: string | null
+  referenceId: string
+  referenceLineageId: string
+  decisionRelationId?: string | null
+  shareable?: boolean | null
+}
+
+export function referenceCurationMetadata(input: ReferenceCurationMetadataInput): Record<string, unknown> {
+  const decisionRelationId = input.decisionRelationId?.trim() || null
+  return {
+    action: input.action,
+    curationStatus: input.curationStatus,
+    reasonCode: input.reasonCode,
+    curationReasonCode: input.reasonCode,
+    referenceId: input.referenceId,
+    referenceLineageId: input.referenceLineageId,
+    ...(decisionRelationId ? {decisionRelationId} : {}),
+    ...(decisionRelationId ? {shareable: input.shareable === true} : {}),
+  }
+}

package/app/newsroom/layout.tsx

@@ -1,3 +1,5 @@
+// Component rules only (no reset, no theme): the Cyclotron review control and status widget.
+import "cyclotron/styles/components.css";
 import { NewsroomClientShell } from "../../components/newsroom-client-shell";
 
 export default function NewsroomLayout({ children }: Readonly<{ children: React.ReactNode }>) {

package/components/news-desk-taxonomy-client.ts

@@ -3682,3 +3682,54 @@ function normalizeUnknownErrorMessage(error: unknown, fallback: string): string
     return fallback;
   }
 }
+
+const CREATE_KNOWLEDGE_RAW_PAYLOAD_MUTATION = `
+  mutation CreateKnowledgeRawPayload($input: CreateKnowledgeRawPayloadInput!) {
+    createKnowledgeRawPayload(input: $input) { id }
+  }
+`;
+
+const GET_KNOWLEDGE_RAW_PAYLOAD_QUERY = `
+  query GetKnowledgeRawPayload($id: ID!) {
+    getKnowledgeRawPayload(id: $id) { id }
+  }
+`;
+
+/** The relevance cyclotron's latest cyclotron-status/v1 snapshot, as the sweep recorded it. */
+export async function loadCyclotronStatus(cyclotronId: string): Promise<import("cyclotron/cyclotron-status").CyclotronStatus | null> {
+  const { cyclotronStatusPayloadId, latestCyclotronStatus } = await import("../lib/relevance-status");
+  const payloads = await loadModelPayloadsForOwner("knowledgeRawPayload", cyclotronStatusPayloadId(cyclotronId), ["raw_payload"]);
+  return latestCyclotronStatus(payloads.map((payload) => ({ json: payload.json, updatedAt: payload.attachment.updatedAt })));
+}
+
+/** Ask the next decide-relevance sweep to set or clear a manual review rate. */
+export async function requestCyclotronReviewRate(
+  cyclotronId: string,
+  request: import("../lib/relevance-status").ReviewRateRequest,
+): Promise<void> {
+  const { reviewRateRequestPayloadId, safeId } = await import("../lib/relevance-status");
+  const id = reviewRateRequestPayloadId(cyclotronId);
+  const existing = await runGraphql<{ getKnowledgeRawPayload?: { id: string } | null }>(GET_KNOWLEDGE_RAW_PAYLOAD_QUERY, { id });
+  if (!existing.getKnowledgeRawPayload) {
+    await runGraphql(CREATE_KNOWLEDGE_RAW_PAYLOAD_MUTATION, {
+      input: {
+        id,
+        ownerType: "cyclotron",
+        ownerId: safeId(cyclotronId),
+        payloadKind: "cyclotron-review-rate-request",
+        createdAt: request.requestedAt,
+        updatedAt: request.requestedAt,
+      },
+    });
+  }
+  await uploadModelPayloadForOwner({
+    ownerKind: "knowledgeRawPayload",
+    ownerId: id,
+    ownerLineageId: id,
+    role: "raw_payload",
+    sortKey: `review-rate-request-${request.requestedAt}`,
+    filename: "review-rate-request.json",
+    mediaType: "application/json",
+    content: JSON.stringify(request),
+  });
+}

package/components/newsroom-references-view.tsx

@@ -44,21 +44,36 @@ import {
 import { normalizeReferenceCurationStatus } from "../lib/reference-policy";
 import { newsroomListRowClassName } from "../lib/newsroom-list-selection";
 import { ReferenceSourcePreview } from "./reference-source-preview";
+import { ReferenceRelevanceReview } from "./reference-relevance-review";
+import { ReferenceCyclotronStatus, type ReviewRateChoice } from "./reference-cyclotron-status";
+import type { CyclotronStatus } from "cyclotron/cyclotron-status";
+import type { RelevanceCuration, RelevanceDecisionView } from "../lib/relevance-decisions";
 import {
   loadReferenceAttachmentsForLineageId,
   loadStoragePathUrl,
 } from "./news-desk-taxonomy-client";
 
 type NewsroomReferencesViewProps = {
+  /** The relevance cyclotron's status snapshot, shown above the list. */
+  cyclotronStatus?: CyclotronStatus | null;
+  /** Present for editors who may ask for a manual review rate. */
+  onRequestReviewRate?: (choice: ReviewRateChoice) => Promise<void> | void;
   demo?: boolean;
+  /** The relevance cyclotron's current decisions, keyed by reference lineage. */
+  decisions?: Map<string, RelevanceDecisionView>;
   disabled?: boolean;
+  onRelevanceReview?: (reference: ReferenceRecord, curation: RelevanceCuration) => void;
   initialReferenceLineageId?: string | null;
   onReview: (reference: ReferenceRecord, action: ReferenceCurationAction) => void;
   referenceAttachments?: ReferenceAttachmentRecord[];
   references: ReferenceRecord[];
 };
 
-const STATUS_FILTERS: Array<{ key: ReferenceStatusFilter; label: string }> = [
+type ReferenceListFilter = ReferenceStatusFilter | "needs_review";
+
+const NEEDS_REVIEW_FILTER: { key: ReferenceListFilter; label: string } = { key: "needs_review", label: "Needs review" };
+
+const STATUS_FILTERS: Array<{ key: ReferenceListFilter; label: string }> = [
   { key: "all", label: "All" },
   { key: "pending", label: "Pending" },
   { key: "accepted", label: "Accepted" },
@@ -183,16 +198,30 @@ function useReferencePreviewAttachments(
   return previewAttachments;
 }
 
+function decisionSummary(decision: RelevanceDecisionView): string {
+  const sure = decision.confidence == null ? "confidence unknown" : `${Math.round(decision.confidence * 100)}% sure`;
+  return `${decision.label} · ${sure}${decision.version != null ? ` · version ${decision.version}` : ""}`;
+}
+
+function needsReview(reference: ReferenceRecord, decision: RelevanceDecisionView | undefined): boolean {
+  return Boolean(decision?.reviewRecommended)
+    && normalizeReferenceCurationStatus(reference.curationStatus) === "pending";
+}
+
 function ReferenceDetailPanel({
+  decision,
   demo,
   disabled,
+  onRelevanceReview,
   onReview,
   previewAttachments,
   reference,
   onClose,
 }: {
+  decision?: RelevanceDecisionView;
   demo?: boolean;
   disabled?: boolean;
+  onRelevanceReview?: (curation: RelevanceCuration) => void;
   onReview: (action: ReferenceCurationAction) => void;
   previewAttachments: ReferenceAttachmentRecord[];
   reference: ReferenceRecord;
@@ -224,11 +253,25 @@ function ReferenceDetailPanel({
           ) : null}
         </div>
 
+        {decision && status === "pending" && onRelevanceReview ? (
+          <ReferenceRelevanceReview
+            decision={decision}
+            disabled={disabled}
+            onCurate={onRelevanceReview}
+            referenceLineageId={lineageId}
+          />
+        ) : decision ? (
+          <p className="text-sm text-muted-foreground" data-reference-relevance-decision={lineageId}>
+            Cyclotron decision: {decisionSummary(decision)}
+          </p>
+        ) : null}
+
         <div
           className="flex flex-wrap items-center gap-2"
           data-news-desk-reference-curation-cluster
           data-reference-curation-status={status}
         >
+          {decision && status === "pending" && onRelevanceReview ? null : <>
           <Button
             aria-label="Accept reference"
             aria-pressed={status === "accepted"}
@@ -255,6 +298,7 @@ function ReferenceDetailPanel({
             <ThumbsDownIcon className="size-4" />
             Reject
           </Button>
+          </>}
           <Button
             aria-label="Archive reference"
             disabled={archiveDisabled}
@@ -347,8 +391,12 @@ function ReferenceDetailPanel({
 }
 
 export function NewsroomReferencesView({
+  cyclotronStatus,
+  decisions,
+  onRequestReviewRate,
   demo = false,
   disabled = false,
+  onRelevanceReview,
   initialReferenceLineageId = null,
   onReview,
   referenceAttachments = [],
@@ -365,13 +413,20 @@ export function NewsroomReferencesView({
   const canonicalReferences = useMemo(() => selectCanonicalReferenceRecords(references), [references]);
   const statusCounts = useMemo(() => countReferencesByStatus(canonicalReferences), [canonicalReferences]);
 
-  const [statusFilter, setStatusFilter] = useState<ReferenceStatusFilter>("all");
+  const [statusFilter, setStatusFilter] = useState<ReferenceListFilter>("all");
+  const needsReviewCount = useMemo(
+    () => canonicalReferences.filter((reference) => needsReview(reference, decisions?.get(referenceLineageId(reference)))).length,
+    [canonicalReferences, decisions],
+  );
+  const filters = decisions?.size ? [NEEDS_REVIEW_FILTER, ...STATUS_FILTERS] : STATUS_FILTERS;
   const [selectedLineageId, setSelectedLineageId] = useState(routeLineageId);
   const [mobileDetailOpen, setMobileDetailOpen] = useState(Boolean(routeLineageId) && isMobileDetail);
 
   const filteredReferences = useMemo(
-    () => filterReferencesByStatus(canonicalReferences, statusFilter),
-    [canonicalReferences, statusFilter],
+    () => statusFilter === "needs_review"
+      ? canonicalReferences.filter((reference) => needsReview(reference, decisions?.get(referenceLineageId(reference))))
+      : filterReferencesByStatus(canonicalReferences, statusFilter),
+    [canonicalReferences, decisions, statusFilter],
   );
 
   const selectedReference = useMemo(
@@ -390,7 +445,7 @@ export function NewsroomReferencesView({
     ? filteredReferences[selectedIndex + 1]
     : null;
 
-  const syncStatusUrl = useCallback((nextStatus: ReferenceStatusFilter) => {
+  const syncStatusUrl = useCallback((nextStatus: ReferenceListFilter) => {
     if (demo) return;
     syncBrowserNewsroomIndexUrl("references", {
       status: nextStatus === "all" ? "" : nextStatus,
@@ -452,22 +507,29 @@ export function NewsroomReferencesView({
             Review source intake before it becomes accepted evidence.
           </p>
         </div>
+        {cyclotronStatus ? (
+          <div className="shrink-0">
+            <ReferenceCyclotronStatus onRequestRate={disabled ? undefined : onRequestReviewRate} status={cyclotronStatus} />
+          </div>
+        ) : null}
 
         <Tabs
           className="shrink-0"
           defaultValue="all"
           onValueChange={(value) => {
-            const next = value as ReferenceStatusFilter;
+            const next = value as ReferenceListFilter;
             setStatusFilter(next);
             syncStatusUrl(next);
           }}
           value={statusFilter}
         >
           <TabsList className="h-auto w-full flex-wrap justify-start gap-1 bg-muted/40 p-1">
-            {STATUS_FILTERS.map((filter) => {
+            {filters.map((filter) => {
               const count = filter.key === "all"
                 ? canonicalReferences.length
-                : statusCounts[filter.key] ?? 0;
+                : filter.key === "needs_review"
+                  ? needsReviewCount
+                  : statusCounts[filter.key] ?? 0;
               return (
                 <TabsTrigger className="text-xs sm:text-sm" key={filter.key} value={filter.key}>
                   {filter.label}
@@ -484,6 +546,7 @@ export function NewsroomReferencesView({
               const lineageId = referenceLineageId(reference);
               const status = normalizeReferenceCurationStatus(reference.curationStatus);
               const active = selectedLineageId === lineageId;
+              const decision = decisions?.get(lineageId);
               return (
                 <button
                   aria-current={active ? "true" : undefined}
@@ -504,6 +567,14 @@ export function NewsroomReferencesView({
                     <Badge variant={referenceStatusBadgeVariant(status)}>{referenceStatusLabel(status)}</Badge>
                   </div>
                   <p className="mt-2 text-xs text-muted-foreground">{formatReferenceListDate(reference)}</p>
+                  {decision ? (
+                    <p className="mt-1 flex flex-wrap items-center gap-2 text-xs text-muted-foreground" data-reference-relevance-row={lineageId}>
+                      <span>Decision: {decisionSummary(decision)}</span>
+                      {needsReview(reference, decision) ? (
+                        <Badge variant="outline"><span aria-hidden="true">●</span> Needs review</Badge>
+                      ) : null}
+                    </p>
+                  ) : null}
                 </button>
               );
             }) : (
@@ -552,8 +623,10 @@ export function NewsroomReferencesView({
         <ScrollArea className="min-h-0 flex-1">
           {selectedReference ? (
             <ReferenceDetailPanel
+              decision={decisions?.get(referenceLineageId(selectedReference))}
               demo={demo}
               disabled={disabled}
+              onRelevanceReview={onRelevanceReview ? (curation) => onRelevanceReview(selectedReference, curation) : undefined}
               onReview={runReview}
               previewAttachments={previewAttachments}
               reference={selectedReference}
@@ -581,9 +654,11 @@ export function NewsroomReferencesView({
             {selectedReference ? (
               <ScrollArea className="max-h-[75dvh]">
                 <ReferenceDetailPanel
+                  decision={decisions?.get(referenceLineageId(selectedReference))}
                   demo={demo}
                   disabled={disabled}
                   onClose={closeDetail}
+                  onRelevanceReview={onRelevanceReview ? (curation) => onRelevanceReview(selectedReference, curation) : undefined}
                   onReview={runReview}
                   previewAttachments={previewAttachments}
                   reference={selectedReference}

package/components/reference-cyclotron-status.tsx

@@ -0,0 +1,109 @@
+"use client";
+
+import { useState } from "react";
+import { CyclotronStatusView } from "cyclotron/components/cyclotron-status";
+import type { CyclotronStatus } from "cyclotron/cyclotron-status";
+
+const RATE_CHOICES = [1, 0.5, 0.25, 0.1, 0];
+const DAY_CHOICES = [1, 7, 14, 30];
+
+export type ReviewRateChoice = { rate: number; days: number } | { clear: true };
+
+/**
+ * The relevance cyclotron's status above the References list: a strip, the
+ * detail card on demand, and, for editors who may change it, a form that asks
+ * the next sweep for a manual review rate.
+ */
+export function ReferenceCyclotronStatus({
+  onRequestRate,
+  status,
+  staleAfterHours = 24,
+  now = new Date(),
+}: {
+  onRequestRate?: (choice: ReviewRateChoice) => Promise<void> | void;
+  status: CyclotronStatus;
+  staleAfterHours?: number;
+  now?: Date;
+}) {
+  const [open, setOpen] = useState(false);
+  const [rate, setRate] = useState(0.5);
+  const [days, setDays] = useState(7);
+  const [message, setMessage] = useState<string | null>(null);
+  const ageHours = Math.max(0, (now.getTime() - Date.parse(status.asOf)) / 3_600_000);
+  const stale = Number.isFinite(ageHours) && ageHours > staleAfterHours;
+  const override = status.reviewRate.override;
+
+  async function submit(choice: ReviewRateChoice) {
+    if (!onRequestRate) return;
+    setMessage("Sending…");
+    try {
+      await onRequestRate(choice);
+      setMessage("The next sweep applies it and the status will show who set it.");
+    } catch (error) {
+      setMessage(error instanceof Error ? error.message : String(error));
+    }
+  }
+
+  return (
+    <section aria-label="Relevance cyclotron" className="space-y-2" data-reference-cyclotron-status>
+      <CyclotronStatusView status={status} />
+      {stale ? (
+        <p className="text-xs text-muted-foreground" data-reference-cyclotron-status-stale>
+          <span aria-hidden="true">⚠ </span>
+          Snapshot from {Math.round(ageHours)} hours ago; the next sweep refreshes it.
+        </p>
+      ) : null}
+      <button
+        aria-expanded={open}
+        className="text-xs text-muted-foreground underline underline-offset-4"
+        onClick={() => setOpen((value) => !value)}
+        type="button"
+      >
+        {open ? "Hide what the cyclotron is doing" : "What the cyclotron is doing"}
+      </button>
+      {open ? (
+        <div className="space-y-3">
+          <CyclotronStatusView classifierName="Relevant to this publication" status={status} variant="card" />
+          {onRequestRate ? (
+            <form
+              aria-label="Manual review rate"
+              className="flex flex-wrap items-end gap-3 text-sm"
+              data-reference-review-rate-form
+              onSubmit={(event) => {
+                event.preventDefault();
+                void submit({ rate, days });
+              }}
+            >
+              <label className="flex flex-col gap-1">
+                <span className="text-xs text-muted-foreground">Review rate for confident decisions</span>
+                <select aria-label="Manual review rate" onChange={(event) => setRate(Number(event.target.value))} value={rate}>
+                  {RATE_CHOICES.map((choice) => (
+                    <option key={choice} value={choice}>{Math.round(choice * 100)}%</option>
+                  ))}
+                </select>
+              </label>
+              <label className="flex flex-col gap-1">
+                <span className="text-xs text-muted-foreground">For</span>
+                <select aria-label="How long the manual rate lasts" onChange={(event) => setDays(Number(event.target.value))} value={days}>
+                  {DAY_CHOICES.map((choice) => (
+                    <option key={choice} value={choice}>{choice} day{choice === 1 ? "" : "s"}</option>
+                  ))}
+                </select>
+              </label>
+              <button className="cyclotron-review-secondary" type="submit">Set manual rate</button>
+              {override ? (
+                <button className="cyclotron-review-secondary" onClick={() => void submit({ clear: true })} type="button">
+                  Clear manual rate
+                </button>
+              ) : null}
+              <p className="basis-full text-xs text-muted-foreground">
+                Low-confidence decisions and the random audit share are always reviewed.
+              </p>
+              {message ? <p className="basis-full text-xs" role="status">{message}</p> : null}
+            </form>
+          ) : null}
+        </div>
+      ) : null}
+    </section>
+  );
+}

package/components/reference-relevance-review.tsx

@@ -0,0 +1,75 @@
+"use client";
+
+import { useState } from "react";
+import { ReviewControl, type ReviewReason } from "cyclotron/components/review-control";
+import { isScopeTrainingNegativeReason, REFERENCE_REJECTION_REASON_CODES } from "../lib/reference-policy";
+import {
+  curationForRelevanceReview,
+  type RelevanceCuration,
+  type RelevanceDecisionView,
+} from "../lib/relevance-decisions";
+
+/**
+ * Papyrus's existing rejection reasons, unchanged. Reasons that are not about
+ * relevance (a duplicate, an unavailable source) close the review without
+ * teaching the cyclotron.
+ */
+export const RELEVANCE_REVIEW_REASONS: ReviewReason[] = REFERENCE_REJECTION_REASON_CODES.map((code) => ({
+  code,
+  text: code.charAt(0).toUpperCase() + code.slice(1).replaceAll("_", " "),
+  ...(isScopeTrainingNegativeReason(code) ? {} : { noLabel: true }),
+}));
+
+export function ReferenceRelevanceReview({
+  disabled,
+  decision,
+  onCurate,
+  referenceLineageId,
+}: {
+  disabled?: boolean;
+  decision: RelevanceDecisionView;
+  onCurate: (curation: RelevanceCuration) => void;
+  referenceLineageId: string;
+}) {
+  const [shareable, setShareable] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const classes = decision.classes.length ? decision.classes : [decision.label];
+  return (
+    <section aria-label="Relevance review" className="space-y-2" data-reference-relevance-review={referenceLineageId}>
+      <ReviewControl
+        decision={{
+          decisionId: decision.decisionId,
+          label: decision.label,
+          confidence: decision.confidence,
+          classes,
+          version: decision.version ?? undefined,
+        }}
+        disabled={disabled}
+        itemId={referenceLineageId}
+        mode={decision.reviewControl === "thumbs" && classes.length === 2 ? "thumbs" : "labels"}
+        onReview={(review) => {
+          try {
+            setError(null);
+            onCurate(curationForRelevanceReview(decision, { ...review, shareable }));
+          } catch (failure) {
+            setError(failure instanceof Error ? failure.message : String(failure));
+          }
+        }}
+        positiveLabel={decision.positiveLabel ?? undefined}
+        question={decision.question ?? undefined}
+        reasons={RELEVANCE_REVIEW_REASONS}
+        reviewReason={decision.reviewRecommended ? decision.reviewDetail ?? undefined : undefined}
+      />
+      <label className="flex items-center gap-2 text-xs text-muted-foreground">
+        <input
+          checked={shareable}
+          disabled={disabled}
+          onChange={(event) => setShareable(event.target.checked)}
+          type="checkbox"
+        />
+        My explanation may be quoted publicly (for the Cyclotron example page)
+      </label>
+      {error ? <p className="text-xs text-destructive" role="alert">{error}</p> : null}
+    </section>
+  );
+}

package/components/topic-steering-workspace.tsx

@@ -53,6 +53,8 @@ import {
   type ForumThreadWithMessages,
   type KnowledgeQueryResponse,
   type NewsroomRecordPage,
+  loadCyclotronStatus,
+  requestCyclotronReviewRate,
 } from "./news-desk-taxonomy-client";
 import { listConsoleThreads } from "../lib/console-chat-client";
 import {
@@ -151,9 +153,13 @@ import {
   type SemanticObjectSummary,
 } from "../lib/semantic-graph";
 import {
+  normalizeReferenceRejectionReasonCode,
   REFERENCE_REJECTION_REASON_CODES,
   referenceCurationStatusForAction,
 } from "../lib/reference-policy";
+import { currentRelevanceDecisions } from "../lib/relevance-decisions";
+import { buildReviewRateRequest, DEMO_CYCLOTRON_STATUS } from "../lib/relevance-status";
+import type { CyclotronStatus } from "cyclotron/cyclotron-status";
 import {
   referenceDisplaySummary,
   referenceMetadataField,
@@ -776,6 +782,24 @@ function NewsDeskDashboard({
   const [referenceAttachments, setReferenceAttachments] = useState(dashboard.referenceAttachments);
   const [messages, setMessages] = useState(dashboard.messages);
   const [semanticRelations, setSemanticRelations] = useState(dashboard.semanticRelations);
+  const relevanceDecisions = useMemo(() => currentRelevanceDecisions(semanticRelations), [semanticRelations]);
+  const relevanceCyclotronId = useMemo(
+    () => [...relevanceDecisions.values()].find((decision) => decision.cyclotronId)?.cyclotronId ?? null,
+    [relevanceDecisions],
+  );
+  const [cyclotronStatus, setCyclotronStatus] = useState<CyclotronStatus | null>(null);
+  useEffect(() => {
+    if (!relevanceCyclotronId) return;
+    if (dashboard.isDemo) {
+      setCyclotronStatus(DEMO_CYCLOTRON_STATUS);
+      return;
+    }
+    let cancelled = false;
+    loadCyclotronStatus(relevanceCyclotronId)
+      .then((status) => { if (!cancelled) setCyclotronStatus(status); })
+      .catch(() => { if (!cancelled) setCyclotronStatus(null); });
+    return () => { cancelled = true; };
+  }, [dashboard.isDemo, relevanceCyclotronId]);
   const [semanticNodes, setSemanticNodes] = useState(dashboard.semanticNodes);
   const [assignments, setAssignments] = useState(dashboard.assignments);
   const [assignmentEvents, setAssignmentEvents] = useState(dashboard.assignmentEvents);
@@ -1507,7 +1531,13 @@ function NewsDeskDashboard({
     });
   }
 
-  function runReferenceCurationAction(reference: ReferenceRecord, action: ReferenceCurationAction, note?: string, reasonCode?: ReferenceRejectionReasonCode | null) {
+  function runReferenceCurationAction(
+    reference: ReferenceRecord,
+    action: ReferenceCurationAction,
+    note?: string,
+    reasonCode?: ReferenceRejectionReasonCode | null,
+    relevance?: { decisionRelationId: string; shareable: boolean },
+  ) {
     const nextStatus = referenceCurationStatusForAction(action);
     setActionState({ id: reference.id, message: `${action} pending`, tone: "pending" });
     if (dashboard.isDemo) {
@@ -1535,6 +1565,7 @@ function NewsDeskDashboard({
           action,
           curationStatus: nextStatus,
           reasonCode: action === "reject" ? reasonCode ?? null : null,
+          ...(relevance ? { decisionRelationId: relevance.decisionRelationId, shareable: relevance.shareable } : {}),
         },
       }, ...current]);
       setSemanticRelations((current) => [{
@@ -1575,6 +1606,8 @@ function NewsDeskDashboard({
               actorLabel: authState.label,
               note: note?.trim() || undefined,
               reasonCode: action === "reject" ? reasonCode ?? undefined : undefined,
+              decisionRelationId: relevance?.decisionRelationId,
+              shareable: relevance ? relevance.shareable : undefined,
             },
             { authMode: USER_POOL_AUTH_MODE },
           );
@@ -3153,6 +3186,20 @@ function NewsDeskDashboard({
             demo={Boolean(dashboard.isDemo)}
             disabled={controlsDisabled}
             initialReferenceLineageId={initialSelection.reference ?? pathnameReferenceLineageId}
+            cyclotronStatus={cyclotronStatus}
+            decisions={relevanceDecisions}
+            onRequestReviewRate={relevanceCyclotronId ? async (choice) => {
+              const request = buildReviewRateRequest(choice, authState.label);
+              if (dashboard.isDemo) return;
+              await requestCyclotronReviewRate(relevanceCyclotronId, request);
+            } : undefined}
+            onRelevanceReview={(reference, curation) => runReferenceCurationAction(
+              reference,
+              curation.action,
+              curation.note ?? undefined,
+              normalizeReferenceRejectionReasonCode(curation.reasonCode),
+              { decisionRelationId: curation.decisionRelationId, shareable: curation.shareable },
+            )}
             onReview={(reference, action) => runReferenceCurationAction(reference, action)}
             referenceAttachments={referenceAttachments}
             references={references}

package/lib/category-repository.ts

@@ -1660,6 +1660,47 @@ export function createDemoCategorySteeringDashboard(
       },
     ],
     semanticRelations: [
+      {
+        // The relevance cyclotron's decision about the pending demo reference.
+        id: "semantic-relation-demo-relevance-history-002",
+        relationState: "current",
+        predicate: "relevance_decision_is",
+        relationTypeKey: "relevance_decision_is",
+        relationDomain: "workflow",
+        subjectKind: "reference",
+        subjectId: referenceHistoryTwoId,
+        subjectLineageId: referenceHistoryTwoLineageId,
+        objectKind: "semanticNode",
+        objectId: "semantic-node-relevance-include-v1",
+        objectLineageId: "semantic-node-relevance-include",
+        subjectStateKey: `reference#${referenceHistoryTwoLineageId}#current`,
+        objectStateKey: "semanticNode#semantic-node-relevance-include#current",
+        objectSubjectStateKey: "semanticNode#semantic-node-relevance-include#current#reference",
+        predicateObjectStateKey: "relevance_decision_is#semanticNode#semantic-node-relevance-include#current",
+        subjectVersionKey: `reference#${referenceHistoryTwoId}`,
+        objectVersionKey: "semanticNode#semantic-node-relevance-include-v1",
+        score: 0.82,
+        confidence: 0.82,
+        rank: 1,
+        classifierId: "papyrus-relevance/relevant",
+        modelVersion: "1",
+        reviewRecommended: true,
+        importRunId: "knowledge-import-demo-projection",
+        importedAt,
+        metadata: JSON.stringify({
+          decisionId: "decision-demo-history-002",
+          cyclotronId: "papyrus-relevance",
+          label: "include",
+          probabilities: { include: 0.82, exclude: 0.18 },
+          labels: ["include", "exclude"],
+          positiveLabel: "include",
+          question: "Should this candidate source become a reference for this publication?",
+          reviewControl: "thumbs",
+          reviewReason: "program",
+          reviewDetail: "Every decision is reviewed while the cyclotron is onboarding.",
+          version: 1,
+        }),
+      },
       {
         id: "semantic-relation-demo-reporting-context-comment",
         relationState: "current",

package/lib/reference-policy.ts

@@ -17,6 +17,11 @@ export type ReferenceRejectionReasonCode = typeof REFERENCE_REJECTION_REASON_COD
 const REFERENCE_REJECTION_REASON_CODE_SET = new Set<string>(REFERENCE_REJECTION_REASON_CODES);
 const SCOPE_TRAINING_NEGATIVE_REASON_CODE_SET = new Set<string>(["out_of_scope", "policy_exclusion"]);
 
+/** Rejection reasons that say the source is not relevant (scope-training negatives). */
+export function isScopeTrainingNegativeReason(code: string): boolean {
+  return SCOPE_TRAINING_NEGATIVE_REASON_CODE_SET.has(code);
+}
+
 export function normalizeReferenceCurationStatus(value: unknown, defaultStatus: ReferenceCurationStatus = "pending"): ReferenceCurationStatus {
   const normalized = normalizePolicyToken(value ?? defaultStatus);
   if (normalized === "accepted" || normalized === "accept" || normalized === "ready" || normalized === "trusted") return "accepted";

package/lib/relevance-decisions.ts

@@ -0,0 +1,103 @@
+import type { SemanticRelationRecord } from "./category-repository";
+
+export const RELEVANCE_RELATION = "relevance_decision_is";
+
+/** The relevance cyclotron's current decision about one reference, as the References tab shows it. */
+export type RelevanceDecisionView = {
+  decisionRelationId: string;
+  decisionId: string;
+  label: string;
+  confidence: number | null;
+  version: number | null;
+  /** True when the cyclotron sent this decision to review. */
+  reviewRecommended: boolean;
+  reviewReason: "program" | "audit" | null;
+  reviewDetail: string | null;
+  classes: string[];
+  positiveLabel: string | null;
+  question: string | null;
+  /** Thumbs for a two-class decision with a positive label; per-class buttons otherwise. */
+  reviewControl: "thumbs" | "labels";
+  cyclotronId: string | null;
+};
+
+/** What an editor submits from the review control. */
+export type RelevanceReview = {
+  label: string | null;
+  reasonCode: string | null;
+  explanation: string | null;
+  shareable: boolean;
+};
+
+/** The existing curation action an editor's review becomes. */
+export type RelevanceCuration = {
+  action: "accept" | "reject";
+  reasonCode: string | null;
+  note: string | null;
+  decisionRelationId: string;
+  shareable: boolean;
+};
+
+function parseMetadata(value: unknown): Record<string, unknown> {
+  if (value && typeof value === "object" && !Array.isArray(value)) return value as Record<string, unknown>;
+  if (typeof value !== "string") return {};
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Current decisions keyed by reference lineage, from relations the Newsroom
+ * already loads: no extra request per row.
+ */
+export function currentRelevanceDecisions(relations: SemanticRelationRecord[]): Map<string, RelevanceDecisionView> {
+  const decisions = new Map<string, RelevanceDecisionView>();
+  for (const relation of relations) {
+    if (relation.predicate !== RELEVANCE_RELATION || relation.relationState !== "current") continue;
+    const metadata = parseMetadata(relation.metadata);
+    const probabilities = parseMetadata(metadata.probabilities);
+    const reason = metadata.reviewReason === "program" || metadata.reviewReason === "audit" ? metadata.reviewReason : null;
+    const version = Number(relation.modelVersion ?? metadata.version);
+    decisions.set(relation.subjectLineageId, {
+      decisionRelationId: relation.id,
+      decisionId: String(metadata.decisionId ?? ""),
+      label: String(metadata.label ?? ""),
+      confidence: typeof relation.confidence === "number" ? relation.confidence : null,
+      version: Number.isFinite(version) ? version : null,
+      reviewRecommended: Boolean(relation.reviewRecommended),
+      reviewReason: reason,
+      reviewDetail: typeof metadata.reviewDetail === "string" ? metadata.reviewDetail : null,
+      classes: Array.isArray(metadata.labels) && metadata.labels.length
+        ? metadata.labels.map(String)
+        : Object.keys(probabilities),
+      positiveLabel: typeof metadata.positiveLabel === "string" ? metadata.positiveLabel : null,
+      question: typeof metadata.question === "string" ? metadata.question : null,
+      reviewControl: metadata.reviewControl === "thumbs" ? "thumbs" : "labels",
+      cyclotronId: typeof metadata.cyclotronId === "string" ? metadata.cyclotronId : null,
+    });
+  }
+  return decisions;
+}
+
+/**
+ * Map a review to the existing curation mutation. The positive label accepts;
+ * any other label, or a review without a label, rejects with the reason code,
+ * which the existing scope-training rule turns back into a cyclotron label
+ * (out_of_scope and policy_exclusion) or none.
+ */
+export function curationForRelevanceReview(decision: RelevanceDecisionView, review: RelevanceReview): RelevanceCuration {
+  const accepted = review.label !== null && review.label === decision.positiveLabel;
+  if (!accepted && !review.reasonCode) {
+    throw new Error("A review that does not accept the reference needs a reason code.");
+  }
+  return {
+    action: accepted ? "accept" : "reject",
+    reasonCode: accepted ? null : review.reasonCode,
+    note: review.explanation?.trim() || null,
+    decisionRelationId: decision.decisionRelationId,
+    shareable: review.shareable,
+  };
+}

package/lib/relevance-status.ts

@@ -0,0 +1,63 @@
+import type { CyclotronStatus } from "cyclotron/cyclotron-status";
+import { isCyclotronStatus } from "cyclotron/cyclotron-status";
+
+/** The KnowledgeRawPayload the decide-relevance sweep writes the status snapshot to. */
+export function cyclotronStatusPayloadId(cyclotronId: string): string {
+  return `knowledge-raw-payload-cyclotron-status-${safeId(cyclotronId)}`;
+}
+
+/** The KnowledgeRawPayload an editor writes to ask for a manual review rate. */
+export function reviewRateRequestPayloadId(cyclotronId: string): string {
+  return `knowledge-raw-payload-cyclotron-review-rate-request-${safeId(cyclotronId)}`;
+}
+
+/** Mirrors Python's ids.safe_id so both sides name the same record. */
+export function safeId(value: string): string {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 140);
+}
+
+export type ReviewRateRequest =
+  | { rate: number; expiresAt: string; setBy: string; requestedAt: string }
+  | { clear: true; setBy: string; requestedAt: string };
+
+export function buildReviewRateRequest(
+  choice: { rate: number; days: number } | { clear: true },
+  setBy: string,
+  now: Date = new Date(),
+): ReviewRateRequest {
+  const requestedAt = now.toISOString();
+  if ("clear" in choice) return { clear: true, setBy, requestedAt };
+  if (!(choice.rate >= 0 && choice.rate <= 1)) throw new Error("A review rate is between 0% and 100%.");
+  if (!(choice.days >= 1)) throw new Error("A manual rate lasts at least one day.");
+  const expiresAt = new Date(now.getTime() + choice.days * 24 * 60 * 60 * 1000).toISOString();
+  return { rate: choice.rate, expiresAt, setBy, requestedAt };
+}
+
+/** The newest valid snapshot among a payload's attachments. */
+export function latestCyclotronStatus(payloads: Array<{ json: unknown; updatedAt?: string | null }>): CyclotronStatus | null {
+  const valid = payloads
+    .filter((payload) => isCyclotronStatus(payload.json))
+    .sort((left, right) => String(right.updatedAt ?? "").localeCompare(String(left.updatedAt ?? "")));
+  return valid.length ? (valid[0].json as CyclotronStatus) : null;
+}
+
+/** What demo mode shows: an onboarding cyclotron that has made one decision. */
+export const DEMO_CYCLOTRON_STATUS: CyclotronStatus = {
+  schema: "cyclotron-status/v1",
+  cyclotron: { id: "papyrus-relevance", classifier: "relevant", version: 1, refits: 0, fingerprint: "demo" },
+  asOf: "2026-05-16T12:00:00.000Z",
+  alignment: {
+    window: 200, labels: 0, accuracy: null, precision: null, recall: null,
+    positiveLabel: "include", measuredOn: "reviews selected by the cyclotron",
+  },
+  calibration: { saysSure: null, isRight: null, gapPoints: null, curve: [] },
+  reviewRate: {
+    state: "onboarding", rate: 1, reason: "Onboarding: every decision is reviewed until the cyclotron earns a lower rate.",
+    auditFloor: 0.05, confidenceThreshold: 0.7, override: null,
+    nextCheckAfterDecisions: 99,
+    nextStep: "Steps down to 50% after 2 more windows of 100 decisions with accuracy on confident decisions of at least 85% (at least 20 reviewed) and a calibration gap under 5 points. Next check in 99 decisions.",
+    expectedReviewsPerWeek: 1,
+  },
+  lastChange: null,
+  pending: { decisionsAwaitingReview: 1, staleSince: null },
+};

package/lib/semantic-graph.ts

@@ -32,6 +32,7 @@ export type SemanticObjectKind = typeof SEMANTIC_OBJECT_KINDS[number];
 export type SemanticPredicateId =
   | "classified_as"
   | "quality_rating_is"
+  | "relevance_decision_is"
   | "reference_summary_100_tokens"
   | "reference_summary_200_tokens"
   | "reference_summary_500_tokens"
@@ -80,6 +81,7 @@ export const SEMANTIC_PREDICATES: SemanticPredicateDefinition[] = [
   { id: "about", label: "about", group: "commentary", inverseLabel: "commentary" },
   { id: "comment", label: "comments on", group: "commentary", inverseLabel: "commented on by", contextPackTags: ["reference_curation", "editing", "research", "assignment_context"] },
   { id: "ingestion_rationale", label: "ingestion rationale for", group: "commentary", inverseLabel: "ingestion rationale", contextPackTags: ["reference_curation", "editing", "research", "assignment_context"] },
+  { id: "relevance_decision_is", label: "relevance decision is", group: "workflow", inverseLabel: "relevance decision for", contextPackTags: ["reference_curation"] },
   { id: "requests_work_on", label: "requests work on", group: "workflow", inverseLabel: "requested work", contextPackTags: ["assignment_context", "editing"] },
   { id: "uses_evidence", label: "uses evidence", group: "evidence", inverseLabel: "used as evidence by", contextPackTags: ["assignment_context", "research", "reference_graph"] },
   { id: "uses_signal", label: "uses signal", group: "evidence", inverseLabel: "signal for", contextPackTags: ["assignment_context", "research", "reference_graph"] },

package/package.json

@@ -100,6 +100,8 @@
     "./components/reader-auth-state": "./components/reader-auth-state.ts",
     "./components/reader-settings": "./components/reader-settings.ts",
     "./components/reader-theme-control": "./components/reader-theme-control.tsx",
+    "./components/reference-cyclotron-status": "./components/reference-cyclotron-status.tsx",
+    "./components/reference-relevance-review": "./components/reference-relevance-review.tsx",
     "./components/reference-source-preview": "./components/reference-source-preview.tsx",
     "./components/settings-page": "./components/settings-page.tsx",
     "./components/staging-banner": "./components/staging-banner.tsx",
@@ -198,6 +200,8 @@
     "./lib/reference-display": "./lib/reference-display.ts",
     "./lib/reference-policy": "./lib/reference-policy.ts",
     "./lib/reference-source-preview": "./lib/reference-source-preview.ts",
+    "./lib/relevance-decisions": "./lib/relevance-decisions.ts",
+    "./lib/relevance-status": "./lib/relevance-status.ts",
     "./lib/renderer-config": "./lib/renderer-config.ts",
     "./lib/renderer": "./lib/renderer.ts",
     "./lib/reporting-story-budget": "./lib/reporting-story-budget.ts",
@@ -295,7 +299,7 @@
       "optional": true
     }
   },
-  "version": "1.0.0-next.32",
+  "version": "1.0.0-next.33",
   "dependencies": {
     "@aws-amplify/adapter-nextjs": "^1.7.3",
     "@aws-sdk/client-cognito-identity-provider": "3.1045.0",
@@ -317,6 +321,7 @@
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
+    "cyclotron": "https://github.com/AnthusAI/Cyclotron/releases/download/ui-v0.2.1/cyclotron-0.2.1.tgz",
     "esbuild": "^0.28.2",
     "gray-matter": "^4.0.3",
     "gsap": "^3.15.0",

package/routes.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.0-next.32",
+  "version": "1.0.0-next.33",
   "routes": [
     {
       "file": "app/%5F_preview/[[...path]]/route.ts",