@anthusai/papyrus 1.11.0 → 1.12.0

package/lib/content-source-context.ts

@@ -1,10 +1,13 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { getContentSource, type ContentSource } from "./site-env";
+import { tenantIdFromEnvironment } from "./tenant-keys";
 
 export type ContentSourceContext = {
   source: ContentSource;
   /** Request-scoped data client (drafts mode: carries the visitor's session cookies). */
   client?: unknown;
+  /** Tenant of the selected Prospectus account; falls back to PAPYRUS_TENANT_ID. */
+  tenantId?: string;
 };
 
 const contentSourceStorage = new AsyncLocalStorage<ContentSourceContext>();
@@ -13,8 +16,13 @@ export function runWithContentSource<T>(
   source: ContentSource,
   operation: () => Promise<T>,
   client?: unknown,
+  tenantId?: string,
 ): Promise<T> {
-  return contentSourceStorage.run({ source, client }, operation);
+  return contentSourceStorage.run({ source, client, tenantId }, operation);
+}
+
+export function currentTenantId(): string | undefined {
+  return contentSourceStorage.getStore()?.tenantId ?? tenantIdFromEnvironment();
 }
 
 export function currentRequestClient<T>(): T | undefined {

package/lib/curation-delegation-helpers.ts

@@ -0,0 +1,59 @@
+export const DEFAULT_DELEGATION_HOURS = 8;
+export const MINIMUM_DELEGATION_HOURS = 1;
+export const MAXIMUM_DELEGATION_HOURS = 72;
+
+export type CurationDelegationRecord = {
+  delegationId: string;
+  agentLabel: string;
+  grantorLabel: string | null;
+  expiresAt: string;
+  revokedAt: string | null;
+};
+
+export type DelegationInputValidation =
+  | { ok: true; agentLabel: string; hours: number }
+  | { ok: false; message: string };
+
+export function validateDelegationInput(agentLabelText: string, hoursText: string): DelegationInputValidation {
+  const agentLabel = agentLabelText.trim();
+  if (!agentLabel) return { ok: false, message: "Enter the name of the agent you are trusting." };
+  if (/\s/.test(agentLabel)) return { ok: false, message: "The agent name cannot contain spaces. Use the name the agent passes as --agent." };
+  const trimmedHours = hoursText.trim();
+  if (!/^\d+$/.test(trimmedHours)) return { ok: false, message: `Enter a whole number of hours from ${MINIMUM_DELEGATION_HOURS} to ${MAXIMUM_DELEGATION_HOURS}.` };
+  const hours = Number(trimmedHours);
+  if (hours < MINIMUM_DELEGATION_HOURS || hours > MAXIMUM_DELEGATION_HOURS) {
+    return { ok: false, message: `A delegation lasts from ${MINIMUM_DELEGATION_HOURS} to ${MAXIMUM_DELEGATION_HOURS} hours.` };
+  }
+  return { ok: true, agentLabel, hours };
+}
+
+export function delegationExpiryText(expiresAt: string, revokedAt: string | null, nowMilliseconds: number): string {
+  if (revokedAt) return "Revoked";
+  const remaining = Date.parse(expiresAt) - nowMilliseconds;
+  if (!Number.isFinite(remaining) || remaining <= 0) return "Expired";
+  const minutes = Math.ceil(remaining / 60_000);
+  if (minutes < 60) return `Expires in ${minutes} ${minutes === 1 ? "minute" : "minutes"}`;
+  const hours = Math.round(remaining / 3_600_000);
+  return `Expires in ${hours} ${hours === 1 ? "hour" : "hours"}`;
+}
+
+export function isDelegationActive(record: CurationDelegationRecord, nowMilliseconds: number): boolean {
+  return !record.revokedAt && Date.parse(record.expiresAt) > nowMilliseconds;
+}
+
+export function buildDelegatedCommandLine(input: { email: string; agentLabel: string; token: string; action?: "approve" | "reject" }): string {
+  const email = input.email.trim() || "<your-email>";
+  return `papyrus references ${input.action ?? "approve"} <reference-id> --on-behalf-of ${email} --agent ${input.agentLabel} --instruction "<the person's own words>" --delegation-token ${input.token}`;
+}
+
+export function describeDelegationError(error: unknown): string {
+  const raw = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+  const graphql = (error as { errors?: Array<{ message?: string }> } | null)?.errors?.[0]?.message ?? "";
+  const text = `${raw} ${graphql}`.toLowerCase();
+  if (text.includes("not authorized") || text.includes("unauthorized")) return "Your account is not allowed to manage delegations. Only editors and administrators can.";
+  if (text.includes("not found")) return "That delegation no longer exists.";
+  if (text.includes("only the person who granted")) return "Only the person who granted a delegation, or an administrator, can revoke it.";
+  if (text.includes("network") || text.includes("failed to fetch")) return "Could not reach the server. Check your connection and try again.";
+  const detail = (graphql || raw).trim();
+  return detail ? `The server refused the request: ${detail}` : "Something went wrong. Nothing was changed.";
+}

package/lib/cyclotron-suggestions.ts

@@ -0,0 +1,263 @@
+import type { MessageRecord } from "./category-repository";
+import type { RelevanceCuration, RelevanceDecisionView } from "./relevance-decisions";
+import { safeId } from "./relevance-status";
+
+export const SHADOW_AGREEMENT_SCHEMA = "cyclotron-shadow-agreement/v1";
+export const MINIMUM_COMPARISONS_FOR_AGREEMENT = 10;
+
+/** What the sweep recorded about the loop itself: whether it is on, when it last ran, why it stopped. */
+export type CyclotronLoopState = {
+  enabled: boolean;
+  stoppedBecause: string | null;
+  lastSweepAt: string | null;
+  maxDecisionsPerDay: number | null;
+};
+
+/** The live-agreement payload the sweep writes: suggestions compared with later human decisions. */
+export type ShadowAgreement = {
+  schema: typeof SHADOW_AGREEMENT_SCHEMA;
+  comparisons: number;
+  agreement: number | null;
+  precision: number | null;
+  recall: number | null;
+  confusion: Record<string, unknown> | null;
+  computedAt: string | null;
+  positiveLabel: string | null;
+  loop: CyclotronLoopState | null;
+};
+
+export type AgreementStripMeasurement = {
+  comparisons: number;
+  agreement: number | null;
+  precision: number | null;
+  recall: number | null;
+  computedAt: string | null;
+};
+
+export type AgreementStripState =
+  | { kind: "hidden" }
+  | {
+    kind: "not_enough" | "measured";
+    measurement: AgreementStripMeasurement;
+    needed: number;
+    loop: CyclotronLoopState | null;
+    stopReasonSentence: string | null;
+  };
+
+export function shadowAgreementPayloadId(cyclotronId: string): string {
+  return `knowledge-raw-payload-cyclotron-shadow-agreement-${safeId(cyclotronId)}`;
+}
+
+function numberOrNull(value: unknown): number | null {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+function parseLoop(value: unknown): CyclotronLoopState | null {
+  if (!value || typeof value !== "object") return null;
+  const loop = value as Record<string, unknown>;
+  if (typeof loop.enabled !== "boolean") return null;
+  return {
+    enabled: loop.enabled,
+    stoppedBecause: typeof loop.stoppedBecause === "string" && loop.stoppedBecause ? loop.stoppedBecause : null,
+    lastSweepAt: typeof loop.lastSweepAt === "string" ? loop.lastSweepAt : null,
+    maxDecisionsPerDay: numberOrNull(loop.maxDecisionsPerDay),
+  };
+}
+
+/** A shadow-agreement payload, or null for any other JSON. */
+export function parseShadowAgreement(json: unknown): ShadowAgreement | null {
+  if (!json || typeof json !== "object") return null;
+  const record = json as Record<string, unknown>;
+  if (record.schema !== SHADOW_AGREEMENT_SCHEMA) return null;
+  return {
+    schema: SHADOW_AGREEMENT_SCHEMA,
+    comparisons: numberOrNull(record.comparisons) ?? 0,
+    agreement: numberOrNull(record.agreement),
+    precision: numberOrNull(record.precision),
+    recall: numberOrNull(record.recall),
+    confusion: record.confusion && typeof record.confusion === "object" ? (record.confusion as Record<string, unknown>) : null,
+    computedAt: typeof record.computedAt === "string" ? record.computedAt : null,
+    positiveLabel: typeof record.positiveLabel === "string" ? record.positiveLabel : null,
+    loop: parseLoop(record.loop),
+  };
+}
+
+/** The newest valid payload among a payload owner's attachments. */
+export function latestShadowAgreement(payloads: Array<{ json: unknown; updatedAt?: string | null }>): ShadowAgreement | null {
+  const valid = payloads
+    .map((payload) => ({ agreement: parseShadowAgreement(payload.json), updatedAt: payload.updatedAt }))
+    .filter((entry): entry is { agreement: ShadowAgreement; updatedAt: string | null | undefined } => entry.agreement !== null)
+    .sort((left, right) => String(right.updatedAt ?? "").localeCompare(String(left.updatedAt ?? "")));
+  return valid.length ? valid[0].agreement : null;
+}
+
+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.",
+};
+
+/** 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}.`;
+}
+
+/**
+ * What the Live agreement strip shows. No payload hides it; under ten
+ * comparisons the figures are withheld; a stop reason is always put in words.
+ */
+export function agreementStripState(agreement: ShadowAgreement | null): AgreementStripState {
+  if (!agreement) return { kind: "hidden" };
+  const loop = agreement.loop;
+  return {
+    kind: agreement.comparisons < MINIMUM_COMPARISONS_FOR_AGREEMENT ? "not_enough" : "measured",
+    measurement: {
+      comparisons: agreement.comparisons,
+      agreement: agreement.agreement,
+      precision: agreement.precision,
+      recall: agreement.recall,
+      computedAt: agreement.computedAt,
+    },
+    needed: MINIMUM_COMPARISONS_FOR_AGREEMENT,
+    loop,
+    stopReasonSentence: loop?.stoppedBecause ? stopReasonSentence(loop.stoppedBecause) : null,
+  };
+}
+
+/** "Loop on" or "Loop off", the word the strip leads with. */
+export function loopStateWords(loop: CyclotronLoopState): string {
+  return loop.enabled ? "Loop on" : "Loop 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`;
+}
+
+export function formatPercentage(fraction: number | null): string {
+  return fraction === null ? "not measured" : `${Math.round(fraction * 100)}%`;
+}
+
+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 {};
+  }
+}
+
+/**
+ * Reference lineage ids whose latest curation Message was made by a signed-in
+ * person. Agent and classifier status changes never appear here, and neither
+ * does a reference a person decided before a later non-human change.
+ */
+export function referencesWithHumanLatestCuration(messages: MessageRecord[]): Set<string> {
+  const latestByReference = new Map<string, { createdAt: string; human: boolean }>();
+  for (const message of messages) {
+    if (message.messageKind !== "reference_curation") continue;
+    const metadata = parseMetadata(message.metadata);
+    const lineageId = typeof metadata.referenceLineageId === "string" ? metadata.referenceLineageId : "";
+    if (!lineageId) continue;
+    const seen = latestByReference.get(lineageId);
+    if (seen && seen.createdAt >= message.createdAt) continue;
+    latestByReference.set(lineageId, { createdAt: message.createdAt, human: metadata.actorKind === "human" });
+  }
+  return new Set([...latestByReference].filter(([, entry]) => entry.human).map(([lineageId]) => lineageId));
+}
+
+export type SuggestionChoice = "agree" | "overrule";
+
+/**
+ * The accept or reject an editor's click becomes. Agreeing does what the
+ * suggestion implies; overruling does the opposite. Both are the ordinary
+ * curation actions, tied to the suggestion they answered.
+ */
+export function curationForSuggestionChoice(decision: RelevanceDecisionView, choice: SuggestionChoice): RelevanceCuration {
+  const suggestsAccept = decision.positiveLabel !== null && decision.label === decision.positiveLabel;
+  const accept = choice === "agree" ? suggestsAccept : !suggestsAccept;
+  return {
+    action: accept ? "accept" : "reject",
+    reasonCode: null,
+    note: null,
+    decisionRelationId: decision.decisionRelationId,
+    shareable: false,
+  };
+}
+
+export type ProvenanceSummary = {
+  teachingLabelsSentence: string;
+  primingExamplesSentence: string;
+  doctrineShortHash: string | null;
+  modelVersion: string | null;
+  decidedAt: string | null;
+};
+
+const SHORT_HASH_LENGTH = 8;
+
+/** The facts the "How this suggestion was made" block lists; null when the decision recorded no provenance. */
+export function provenanceSummary(decision: RelevanceDecisionView): ProvenanceSummary | null {
+  const provenance = decision.provenance;
+  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`,
+    doctrineShortHash: provenance.doctrineFingerprint ? provenance.doctrineFingerprint.slice(0, SHORT_HASH_LENGTH) : null,
+    modelVersion: decision.version === null ? null : `version ${decision.version}`,
+    decidedAt: decision.decidedAt,
+  };
+}
+
+export function suggestionConfidenceWords(decision: RelevanceDecisionView): string {
+  return decision.confidence === null ? "confidence unknown" : `${Math.round(decision.confidence * 100)}% sure`;
+}
+
+/** A curation recorded by an agent using a delegation a person granted. */
+export type DelegatedCuration = {
+  agent: string;
+  person: string | null;
+  instruction: string;
+  delegationId: string;
+  delegationShortId: string;
+  /** What the backend does: a delegated curation is stamped human, so the person's label trains the cyclotron. */
+  countsAsTrainingLabel: boolean;
+};
+
+const DELEGATION_ID_PREFIX = "curation-delegation-";
+const DELEGATION_SHORT_ID_LENGTH = 8;
+
+export function delegationShortId(delegationId: string): string {
+  return delegationId.replace(DELEGATION_ID_PREFIX, "").slice(0, DELEGATION_SHORT_ID_LENGTH);
+}
+
+/**
+ * Delegated curations by reference lineage, from each reference's latest
+ * curation Message only. The person is the Message author; the agent is relayedBy.
+ */
+export function delegatedCurationsByReference(messages: MessageRecord[]): Map<string, DelegatedCuration> {
+  const latest = new Map<string, MessageRecord>();
+  for (const message of messages) {
+    if (message.messageKind !== "reference_curation") continue;
+    const lineageId = parseMetadata(message.metadata).referenceLineageId;
+    if (typeof lineageId !== "string" || !lineageId) continue;
+    const seen = latest.get(lineageId);
+    if (!seen || seen.createdAt < message.createdAt) latest.set(lineageId, message);
+  }
+  const delegated = new Map<string, DelegatedCuration>();
+  for (const [lineageId, message] of latest) {
+    const metadata = parseMetadata(message.metadata);
+    if (metadata.attestation !== "delegated") continue;
+    const delegationId = typeof metadata.delegationId === "string" ? metadata.delegationId : "";
+    delegated.set(lineageId, {
+      agent: typeof metadata.relayedBy === "string" && metadata.relayedBy ? metadata.relayedBy : "an agent",
+      person: message.authorLabel?.trim() || null,
+      instruction: typeof metadata.instruction === "string" ? metadata.instruction : "",
+      delegationId,
+      delegationShortId: delegationShortId(delegationId),
+      countsAsTrainingLabel: metadata.actorKind === "human",
+    });
+  }
+  return delegated;
+}

package/lib/graphql-content-repository.ts

@@ -20,7 +20,9 @@ import { BodyIrError, matchBodyImages, projectBodyIr, type BodyProjection, type
 import { SITE_BRAND } from "./site-brand";
 import { shouldFetchVideoScripts } from "./video-mode";
 import { collectVideoScriptTargets, parseVideoScriptRef, videomlItemSlug, type VideoScriptRef } from "./video-script";
-import { currentContentSource, currentRequestClient, runWithContentSource } from "./content-source-context";
+import { selectedTenantIdFromCookies } from "./prospectus-tenant";
+import { currentContentSource, currentRequestClient, currentTenantId, runWithContentSource } from "./content-source-context";
+import { rowBelongsToTenant, tenantScopedValue } from "./tenant-keys";
 import { withRateLimitRetry } from "./rate-limit-retry";
 import { getContentSource } from "./site-env";
 
@@ -70,6 +72,7 @@ type GraphQLEditionItem = {
 
 type GraphQLItem = {
   id: string;
+  tenantId?: string | null;
   versionNumber?: number | null;
   type: string;
   status: string;
@@ -152,9 +155,10 @@ async function withReaderGraphQLContext<T>(operation: () => Promise<T>): Promise
     // Drafts are read as the signed-in visitor: the client reads the session from the request cookies, and it is
     // kept in the request's async context (never a module global) so one visitor's session cannot serve another.
     const { cookies } = await import("next/headers");
-    await cookies();
+    const cookieStore = await cookies();
     const client = generateServerClientUsingCookies<Schema>({ config, cookies, authMode: "userPool" });
-    return runWithContentSource(source, operation, client);
+    const selectedTenantId = await selectedTenantIdFromCookies(cookieStore);
+    return runWithContentSource(source, operation, client, selectedTenantId);
   }
   return withRateLimitRetry(() =>
     runWithGuestAmplifyContext(() =>
@@ -587,6 +591,10 @@ type ItemSourceModel = {
   listPublishedItemsByTypeStatusAndPublishedAt: (input: { typeStatus: string }, options: ListOptions) => ListResponse<GraphQLItem>;
 };
 
+type TenantSlugSourceModel = {
+  publishedItemByTenantSlug: (input: { tenantSlug: string }, options: ListOptions) => ListResponse<GraphQLItem>;
+};
+
 type MediaAssetSourceModel = {
   listPublishedMediaAssetsByItemAndSortKey: (
     input: { publishedItemId: string },
@@ -671,20 +679,33 @@ function getPublishedEditionItemModel(): EditionItemSourceModel {
   return model as unknown as EditionItemSourceModel;
 }
 
+async function getItemWithinTenant(
+  tenantId: string | undefined,
+  lookup: Promise<GraphQLGetResponse<GraphQLItem>>,
+): Promise<GraphQLGetResponse<GraphQLItem>> {
+  const response = await lookup;
+  return rowBelongsToTenant(tenantId, response.data) ? response : { ...response, data: null };
+}
+
 function getPublishedItemModel(): ItemSourceModel {
+  const tenantId = currentTenantId();
   if (currentContentSource() === "drafts") {
     const model = getClient().models.Item;
     if (!model) throw missingProjectionModelError("Item");
     return {
-      get: (input, options) => model.get(input, options) as Promise<GraphQLGetResponse<GraphQLItem>>,
-      publishedItemBySlug: (input, options) => model.itemBySlug(input, options) as ListResponse<GraphQLItem>,
+      get: (input, options) =>
+        getItemWithinTenant(tenantId, model.get(input, options) as Promise<GraphQLGetResponse<GraphQLItem>>),
+      publishedItemBySlug: ({ slug }, options) =>
+        (tenantId
+          ? model.itemByTenantSlug({ tenantSlug: tenantScopedValue(tenantId, slug) }, options)
+          : model.itemBySlug({ slug }, options)) as ListResponse<GraphQLItem>,
       listPublishedItemsByTypeStatusAndPublishedAt: ({ typeStatus }, options) => {
         const itemType = typeStatus.split("#")[0];
         return listMergedAcrossStatuses<GraphQLItem>(
           [DRAFT_STATUS, PUBLISHED_STATUS],
           (status, pageOptions) =>
             model.listItemsByTypeStatusAndPublishedAt(
-              { typeStatus: `${itemType}#${status}` },
+              { typeStatus: tenantScopedValue(tenantId, `${itemType}#${status}`) },
               pageOptions,
             ) as ListResponse<GraphQLItem>,
           (item) => item.publishedAt ?? "",
@@ -695,7 +716,21 @@ function getPublishedItemModel(): ItemSourceModel {
   }
   const model = getClient().models.PublishedItem;
   if (!model) throw missingProjectionModelError("PublishedItem");
-  return model as unknown as ItemSourceModel;
+  const publishedModel = model as unknown as ItemSourceModel;
+  if (!tenantId) return publishedModel;
+  return {
+    get: (input, options) => getItemWithinTenant(tenantId, publishedModel.get(input, options)),
+    publishedItemBySlug: ({ slug }, options) =>
+      (model as unknown as TenantSlugSourceModel).publishedItemByTenantSlug(
+        { tenantSlug: tenantScopedValue(tenantId, slug) },
+        options,
+      ),
+    listPublishedItemsByTypeStatusAndPublishedAt: ({ typeStatus }, options) =>
+      publishedModel.listPublishedItemsByTypeStatusAndPublishedAt(
+        { typeStatus: tenantScopedValue(tenantId, typeStatus) },
+        options,
+      ),
+  };
 }
 
 function getPublishedMediaAssetModel(): MediaAssetSourceModel {

package/lib/local-preview-seed.ts

@@ -1,14 +1,16 @@
-import type { AssignmentRecord, ReferenceRecord } from "./category-repository";
+import type { AssignmentRecord, MessageRecord, ReferenceRecord, SemanticRelationRecord } from "./category-repository";
+import { SHADOW_AGREEMENT_SCHEMA, type ShadowAgreement } from "./cyclotron-suggestions";
 import type { EditableArticle } from "./newsroom-articles";
 import type { MediaAssetRecord } from "./newsroom-media";
 import { EMPTY_STORY_REPORTING_TRAIL, type StoryReportingTrail, type TrailVersion } from "./story-reporting-trail";
 import { contentItemStageKeys, type ContentItemVersionRecord } from "./content-item-lifecycle";
 import { getContentItemStageDefinitions } from "./site-brand";
+import { LOCAL_PREVIEW_TENANTS, getLocalPreviewTenantId } from "./local-preview-tenant";
 
 const SEED_TIMESTAMP_BASE = Date.parse("2026-10-01T12:00:00.000Z");
 const ONE_HOUR_IN_MILLISECONDS = 60 * 60 * 1000;
 
-const SEED_CONTENT_ITEM_HEADLINES_BY_POSITION: readonly (readonly string[])[] = [
+const SEED_CONTENT_ITEM_HEADLINES_BY_POSITION_FOR_TENANT_ZERO: readonly (readonly string[])[] = [
   ["Three sources confirm the zoning reversal", "Reporting packet: school board redistricting"],
   ["Draft in progress: the last ferry crossing", "Draft in progress: neighborhood bakery profile"],
   ["Illustration brief: flooded streets, aerial view", "Illustration brief: the market at dawn"],
@@ -18,6 +20,24 @@ const SEED_CONTENT_ITEM_HEADLINES_BY_POSITION: readonly (readonly string[])[] =
   ["Spiked: the unconfirmed council rumor", "Spiked: the recycled press release"],
 ];
 
+const SEED_CONTENT_ITEM_HEADLINES_BY_POSITION_FOR_TENANT_ONE: readonly (readonly string[])[] = [
+  ["Field note: spore dispersal on a damp morning", "Field note: the dung beetle census"],
+  ["Draft in progress: why fungi throw their caps", "Draft in progress: the compost experiment"],
+  ["Illustration brief: a cap in flight, close up", "Illustration brief: the mycelium network"],
+  ["Layout pass: the monthly field guide", "Layout pass: the reader mailbag"],
+  ["Published: a season of mushroom sightings", "Published: how the forest floor recycles"],
+  ["Held for spring: the truffle hunt", "Evergreen: a beginner's guide to identification"],
+  ["Spiked: the unverified foraging claim", "Spiked: the duplicate field report"],
+];
+
+const SEED_CONTENT_ITEM_HEADLINES_BY_TENANT = [SEED_CONTENT_ITEM_HEADLINES_BY_POSITION_FOR_TENANT_ZERO, SEED_CONTENT_ITEM_HEADLINES_BY_POSITION_FOR_TENANT_ONE] as const;
+
+function headlinesForSelectedTenant(): readonly (readonly string[])[] {
+  const tenantId = getLocalPreviewTenantId();
+  const tenant = LOCAL_PREVIEW_TENANTS.find(candidate => candidate.accountId === tenantId) ?? LOCAL_PREVIEW_TENANTS[0];
+  return SEED_CONTENT_ITEM_HEADLINES_BY_TENANT[tenant.fixtureHeadlineSet] ?? SEED_CONTENT_ITEM_HEADLINES_BY_TENANT[0];
+}
+
 function isoTimestampHoursBeforeBase(hours: number): string {
   return new Date(SEED_TIMESTAMP_BASE - hours * ONE_HOUR_IN_MILLISECONDS).toISOString();
 }
@@ -29,7 +49,8 @@ function slugFromHeadline(headline: string): string {
 export function createLocalPreviewContentItemVersions(): ContentItemVersionRecord[] {
   const stageKeys = contentItemStageKeys(getContentItemStageDefinitions());
   return stageKeys.flatMap((stageKey, stageIndex) => {
-    const headlines = SEED_CONTENT_ITEM_HEADLINES_BY_POSITION[stageIndex % SEED_CONTENT_ITEM_HEADLINES_BY_POSITION.length];
+    const tenantHeadlines = headlinesForSelectedTenant();
+    const headlines = tenantHeadlines[stageIndex % tenantHeadlines.length];
     return headlines.map((headline, headlineIndex) => {
       const slug = slugFromHeadline(headline);
       return {
@@ -146,3 +167,120 @@ export function createLocalPreviewReportingTrail(lineageId: string): StoryReport
 export function createLocalPreviewMediaAssets(_itemId: string): MediaAssetRecord[] {
   return [];
 }
+
+type PreviewSuggestionPlan = {
+  label: "include" | "exclude";
+  confidence: number;
+  curation: "none" | "human" | "service" | "delegated";
+  provenance: boolean;
+};
+
+const PREVIEW_SUGGESTION_PLANS: readonly PreviewSuggestionPlan[] = [
+  { label: "include", confidence: 0.91, curation: "none", provenance: true },
+  { label: "include", confidence: 0.86, curation: "human", provenance: true },
+  { label: "exclude", confidence: 0.72, curation: "service", provenance: true },
+  { label: "exclude", confidence: 0.88, curation: "delegated", provenance: true },
+  { label: "exclude", confidence: 0.64, curation: "none", provenance: false },
+];
+
+const PREVIEW_CYCLOTRON_ID = "papyrus-relevance";
+
+/**
+ * Fixture data for reviewing the cyclotron suggestion UI without a backend:
+ * suggestions with provenance on the first references, a mix of human and
+ * non-human curation messages, and a live-agreement payload.
+ */
+export function createLocalPreviewCyclotronFixtures(references: ReferenceRecord[]): {
+  relations: SemanticRelationRecord[];
+  messages: MessageRecord[];
+  shadowAgreement: ShadowAgreement;
+} {
+  const relations: SemanticRelationRecord[] = [];
+  const messages: MessageRecord[] = [];
+  references.slice(0, PREVIEW_SUGGESTION_PLANS.length).forEach((reference, index) => {
+    const plan = PREVIEW_SUGGESTION_PLANS[index];
+    const lineageId = reference.lineageId ?? reference.id;
+    const decidedAt = isoTimestampHoursBeforeBase(40 - index);
+    relations.push({
+      id: `preview-relevance-relation-${index}`,
+      relationState: "current",
+      predicate: "relevance_decision_is",
+      subjectKind: "reference",
+      subjectId: reference.id,
+      subjectLineageId: lineageId,
+      objectKind: "semanticNode",
+      objectId: `semantic-node-relevance-${plan.label}-v1`,
+      objectLineageId: `semantic-node-relevance-${plan.label}`,
+      subjectStateKey: `reference#${lineageId}#current`,
+      objectStateKey: `semanticNode#semantic-node-relevance-${plan.label}#current`,
+      objectSubjectStateKey: `semanticNode#semantic-node-relevance-${plan.label}#current#reference`,
+      predicateObjectStateKey: `relevance_decision_is#semanticNode#semantic-node-relevance-${plan.label}#current`,
+      subjectVersionKey: `reference#${reference.id}`,
+      objectVersionKey: `semanticNode#semantic-node-relevance-${plan.label}-v1`,
+      confidence: plan.confidence,
+      modelVersion: "4",
+      reviewRecommended: false,
+      metadata: JSON.stringify({
+        decisionId: `preview-decision-${index}`,
+        label: plan.label,
+        probabilities: { include: plan.label === "include" ? plan.confidence : 1 - plan.confidence, exclude: plan.label === "exclude" ? plan.confidence : 1 - plan.confidence },
+        version: 4,
+        decidedAt,
+        labels: ["include", "exclude"],
+        positiveLabel: "include",
+        question: "Should this source be used as evidence for the publication?",
+        cyclotronId: PREVIEW_CYCLOTRON_ID,
+        ...(plan.provenance ? {
+          provenance: {
+            labelSet: ["include", "exclude"],
+            doctrineFingerprint: "3f9c2a71d80b46e5",
+            teachingFingerprint: "b71e04c9aa5d2f13",
+            teachingLabels: 37,
+            primingExamples: 6,
+          },
+        } : {}),
+      }),
+    } as SemanticRelationRecord);
+    if (plan.curation !== "none") {
+      const createdAt = isoTimestampHoursBeforeBase(30 - index);
+      messages.push({
+        id: `preview-curation-message-${index}`,
+        messageKind: "reference_curation",
+        messageDomain: "commentary",
+        status: "active",
+        summary: `${reference.title ?? lineageId}: curated`,
+        authorLabel: plan.curation === "delegated" ? "Maya Okafor" : null,
+        source: "newsroom",
+        createdAt,
+        updatedAt: createdAt,
+        metadata: JSON.stringify({
+          action: reference.curationStatus === "rejected" ? "reject" : "accept",
+          curationStatus: reference.curationStatus,
+          referenceLineageId: lineageId,
+          actorKind: plan.curation === "service" ? "service" : "human",
+          ...(plan.curation === "delegated" ? {
+            attestation: "delegated",
+            relayedBy: "newsroom-reporter",
+            delegationId: "curation-delegation-9b1f6c24-5d0e-4a7b-8c31-2e6f0a1d7b45",
+            instruction: "Reject that one, it duplicates the filing from Tuesday.",
+          } : {}),
+        }),
+      });
+    }
+  });
+  return {
+    relations,
+    messages,
+    shadowAgreement: {
+      schema: SHADOW_AGREEMENT_SCHEMA,
+      comparisons: 23,
+      agreement: 0.87,
+      precision: 0.9,
+      recall: 0.82,
+      confusion: { truePositive: 9, falsePositive: 1, falseNegative: 2, trueNegative: 11 },
+      computedAt: isoTimestampHoursBeforeBase(3),
+      positiveLabel: "include",
+      loop: { enabled: true, stoppedBecause: "daily decision cap", lastSweepAt: isoTimestampHoursBeforeBase(3), maxDecisionsPerDay: 50 },
+    },
+  };
+}

package/lib/local-preview-tenant.ts

@@ -0,0 +1,27 @@
+/**
+ * The local preview stands in for the multi-tenant newsroom: choosing a publishing account in the account menu
+ * switches which publication's content the preview shows. The choice is a cookie so server and browser agree.
+ */
+export const LOCAL_PREVIEW_TENANT_COOKIE = "papyrus-preview-tenant";
+export const LOCAL_PREVIEW_DEFAULT_TENANT_ID = "preview-papyrus";
+
+export type LocalPreviewTenant = { accountId: string; name: string; role: string; fixtureHeadlineSet: number };
+
+export const LOCAL_PREVIEW_TENANTS: readonly LocalPreviewTenant[] = [
+  { accountId: LOCAL_PREVIEW_DEFAULT_TENANT_ID, name: "Papyrus", role: "publisher", fixtureHeadlineSet: 0 },
+  { accountId: "preview-pilobolus", name: "Pilobolus", role: "editor", fixtureHeadlineSet: 1 },
+];
+
+export function previewTenantIdFromCookieHeader(cookieHeader: string | null | undefined): string {
+  const match = cookieHeader?.split(";").map(part => part.trim()).find(part => part.startsWith(`${LOCAL_PREVIEW_TENANT_COOKIE}=`));
+  const value = match ? decodeURIComponent(match.slice(LOCAL_PREVIEW_TENANT_COOKIE.length + 1)) : "";
+  return LOCAL_PREVIEW_TENANTS.some(tenant => tenant.accountId === value) ? value : LOCAL_PREVIEW_DEFAULT_TENANT_ID;
+}
+
+export function getLocalPreviewTenantId(): string {
+  return typeof document === "undefined" ? LOCAL_PREVIEW_DEFAULT_TENANT_ID : previewTenantIdFromCookieHeader(document.cookie);
+}
+
+export function setLocalPreviewTenantId(accountId: string): void {
+  document.cookie = `${LOCAL_PREVIEW_TENANT_COOKIE}=${encodeURIComponent(accountId)}; path=/; max-age=31536000; samesite=lax`;
+}