@anthusai/papyrus 5.57.0 → 5.59.0

package/lib/cyclotron-suggestions.ts

@@ -1,4 +1,4 @@
-import type { MessageRecord } from "./category-repository";
+import type { ReferenceRecord } from "./category-repository";
 import type { RelevanceCuration, RelevanceDecisionView } from "./relevance-decisions";
 import { safeId } from "./relevance-status";
 
@@ -149,22 +149,12 @@ function parseMetadata(value: unknown): Record<string, unknown> {
 }
 
 /**
- * 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.
+ * Reference lineage ids whose latest vote was made by a signed-in person
+ * (`curationActorKind` is `human`). Agent, Cyclotron and rule votes 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 function referencesWithHumanLatestCuration(references: readonly ReferenceRecord[]): Set<string> {
+  return new Set(references.filter((reference) => reference.curationActorKind === "human").map((reference) => reference.lineageId ?? reference.id));
 }
 
 export type SuggestionChoice = "agree" | "overrule";
@@ -233,30 +223,22 @@ export function delegationShortId(delegationId: string): string {
 }
 
 /**
- * Delegated curations by reference lineage, from each reference's latest
- * curation Message only. The person is the Message author; the agent is relayedBy.
+ * Delegated curations by reference lineage, from each Reference's latest vote only.
+ * The person is who set the status (`curationStatusUpdatedBy`); the agent is the delegation's 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);
-  }
+export function delegatedCurationsByReference(references: readonly ReferenceRecord[]): Map<string, DelegatedCuration> {
   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 : "",
+  for (const reference of references) {
+    const delegation = parseMetadata(reference.curationDelegation);
+    if (!Object.keys(delegation).length) continue;
+    const delegationId = typeof delegation.delegationId === "string" ? delegation.delegationId : "";
+    delegated.set(reference.lineageId ?? reference.id, {
+      agent: typeof delegation.relayedBy === "string" && delegation.relayedBy ? delegation.relayedBy : "an agent",
+      person: reference.curationStatusUpdatedBy?.trim() || null,
+      instruction: typeof delegation.instruction === "string" ? delegation.instruction : "",
       delegationId,
       delegationShortId: delegationShortId(delegationId),
-      countsAsTrainingLabel: metadata.actorKind === "human",
+      countsAsTrainingLabel: reference.curationActorKind === "human",
     });
   }
   return delegated;

package/lib/local-preview-seed.ts

@@ -210,15 +210,16 @@ 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.
+ * non-human votes recorded on the References, and a live-agreement payload.
  */
 export function createLocalPreviewCyclotronFixtures(references: ReferenceRecord[]): {
   relations: SemanticRelationRecord[];
-  messages: MessageRecord[];
+  /** The first few References with a latest vote recorded on them, by Reference id. */
+  votedReferences: Map<string, ReferenceRecord>;
   shadowAgreement: ShadowAgreement;
 } {
   const relations: SemanticRelationRecord[] = [];
-  const messages: MessageRecord[] = [];
+  const votedReferences = new Map<string, ReferenceRecord>();
   references.slice(0, PREVIEW_SUGGESTION_PLANS.length).forEach((reference, index) => {
     const plan = PREVIEW_SUGGESTION_PLANS[index];
     const lineageId = reference.lineageId ?? reference.id;
@@ -264,35 +265,23 @@ export function createLocalPreviewCyclotronFixtures(references: ReferenceRecord[
       }),
     } 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.",
-          } : {}),
-        }),
+      // A Reference keeps its latest vote on itself (no Message): the details sit in its curation* fields.
+      votedReferences.set(reference.id, {
+        ...reference,
+        curationStatusUpdatedAt: isoTimestampHoursBeforeBase(30 - index),
+        curationStatusUpdatedBy: plan.curation === "delegated" ? "Maya Okafor" : reference.curationStatusUpdatedBy,
+        curationActorKind: plan.curation === "service" ? "agent" : "human",
+        curationDelegation: plan.curation === "delegated" ? {
+          delegationId: "curation-delegation-9b1f6c24",
+          relayedBy: "newsroom-reporter",
+          instruction: "Reject that one, it duplicates the filing from Tuesday.",
+        } : null,
       });
     }
   });
   return {
     relations,
-    messages,
+    votedReferences,
     shadowAgreement: {
       schema: SHADOW_AGREEMENT_SCHEMA,
       comparisons: 23,

package/lib/needs-me-items.ts

@@ -127,9 +127,9 @@ export function draftItem(item: DraftItem, bySource: ReadonlyMap<string, Referen
     type: "draft",
     id: item.key,
     title: view?.headline ?? link?.label ?? "Draft",
-    dek: view ? view.dek : "Loading the draft…",
+    dek: view ? view.dek : "Loading the Proposed Story…",
     image: picture.imageUrl,
-    source: picture.siteName ?? picture.host ?? (view ? `AI ${view.kindLabel.toLowerCase()}` : "AI draft"),
+    source: picture.siteName ?? picture.host ?? (view ? `AI ${view.kindLabel.toLowerCase()}` : "Proposed Story"),
     host: picture.host,
     createdAt: timeOf(request.raisedAt),
     importance: 1,
@@ -273,10 +273,10 @@ function plural(count: number, one: string, many = `${one}s`): string {
   return `${count} ${count === 1 ? one : many}`;
 }
 
-/** "3 drafts and 12 references waiting for you"; "All caught up" when nothing waits. */
+/** "3 Proposed Stories and 12 references waiting for you"; "All caught up" when nothing waits. */
 export function waitingTextFor(counts: NeedsMeCounts): string {
   const parts = [
-    counts.drafts ? plural(counts.drafts, "draft") : null,
+    counts.drafts ? plural(counts.drafts, "Proposed Story", "Proposed Stories") : null,
     counts.references ? plural(counts.references, "reference") : null,
     counts.stories ? plural(counts.stories, "story review") : null,
     counts.email ? plural(counts.email, "held email", "held emails") : null,

package/lib/needs-me-ranking.ts

@@ -5,12 +5,10 @@
  * What they share is one question: where would a person's answer change the most? In plain words, as the page says them:
  *   1. Hard gates first. Nothing continues until a person decides one, so it leads, oldest first.
  *   2. Then the interim "value of your input" score:
- *        value = uncertainty x importance x freshness
+ *        value = uncertainty x importance
  *      - uncertainty is 1 - |2P - 1|, where P is the Cyclotron's probability that you would Accept. A coin toss (P = 0.5) is 1, a
  *        certainty is 0. An item with no prediction is 0.5: we do not know how unsure we are.
  *      - importance is the item's own priority (a relevance score, or a story or section priority). It is 1 until a source gives one.
- *      - freshness is exp(-age / tau), the weight the References feed already uses; tau is learned from how old the References you
- *        accepted were when you accepted them (reference-feed-ranking.ts). With too few examples there is no decay.
  *   3. Types are interleaved, never more than two of one type in a row while another type is waiting, so a long run of References
  *      does not bury the drafts and emails behind it.
  *   4. Confident items do not ask for you. An item whose uncertainty is below the threshold goes to "Decided automatically", where it
@@ -25,7 +23,7 @@ import type { ReferenceRecord } from "./category-repository";
 import { referenceLineageId } from "./newsroom-references";
 import { normalizeReferenceCurationStatus } from "./reference-policy";
 import type { RelevanceDecisionView } from "./relevance-decisions";
-import { acceptProbability, MINIMUM_FRESHNESS_EXAMPLES, type FeedFreshness } from "./reference-feed-ranking";
+import { acceptProbability } from "./reference-feed-ranking";
 
 export type NeedsMeType = "reference" | "draft" | "stage_review" | "held_email" | "incomplete_capture" | "concept_proposal" | "flag";
 
@@ -35,7 +33,7 @@ export const NEEDS_ME_TYPES: readonly NeedsMeType[] = ["reference", "draft", "st
 export type NeedsMeFilter = "all" | "references" | "drafts" | "stories" | "email" | "captures" | "other";
 export const NEEDS_ME_FILTERS: readonly NeedsMeFilter[] = ["all", "references", "drafts", "stories", "email", "captures", "other"];
 export const NEEDS_ME_FILTER_LABELS: Record<NeedsMeFilter, string> = {
-  all: "All", references: "References", drafts: "Drafts", stories: "Stories", email: "Email", captures: "Captures", other: "Other",
+  all: "All", references: "References", drafts: "Proposed Stories", stories: "Stories", email: "Email", captures: "Captures", other: "Other",
 };
 
 const FILTER_OF: Record<NeedsMeType, Exclude<NeedsMeFilter, "all">> = {
@@ -52,7 +50,7 @@ export function matchesFilter(item: Pick<NeedsMeItem, "type">, filter: NeedsMeFi
 
 /** The words for a type, used on the card and in the detail pane. */
 export const NEEDS_ME_TYPE_LABELS: Record<NeedsMeType, string> = {
-  reference: "Reference", draft: "AI draft", stage_review: "Story review", held_email: "Held email", incomplete_capture: "Capture check", concept_proposal: "Concept proposal", flag: "For your information",
+  reference: "Reference", draft: "Proposed Story", stage_review: "Story review", held_email: "Held email", incomplete_capture: "Capture check", concept_proposal: "Concept proposal", flag: "For your information",
 };
 
 export type NeedsMePrediction = {
@@ -109,33 +107,23 @@ export function predictionOf(decision: RelevanceDecisionView | undefined): Needs
   return { label: decision.label === (decision.positiveLabel ?? "include") ? "accept" : "reject", pAccept, confidence: decision.confidence };
 }
 
-const DAY_MILLISECONDS = 86_400_000;
-
-/** exp(-age / tau) at `now`; 1 without a learned tau or an unknown arrival. The References feed's own weight. */
-export function freshnessAt(createdAt: number | null, freshness: FeedFreshness, now: number): number {
-  if (freshness.tauDays === null || createdAt === null) return 1;
-  return Math.exp(-Math.max(now - createdAt, 0) / DAY_MILLISECONDS / freshness.tauDays);
-}
-
-export type AttentionContext = { now: number; freshness: FeedFreshness };
-
 /**
  * The value of this editor's input on one item. Higher is earlier. The interim model below is a formula; a Cyclotron "attention"
  * decision implements the same interface and is passed to `rankNeedsMe` in its place.
  */
 export interface AttentionModel {
   readonly id: string;
-  value(item: NeedsMeItem, context: AttentionContext): number;
+  value(item: NeedsMeItem): number;
 }
 
 export const interimAttention: AttentionModel = {
   id: "interim-value-of-input",
-  value: (item, { now, freshness }) => item.uncertainty * item.importance * freshnessAt(item.createdAt, freshness, now),
+  value: (item) => item.uncertainty * item.importance,
 };
 
 // --- confident items ----------------------------------------------------------------------------------------------------
 
-export const MINIMUM_CONFIRMED_EXAMPLES = MINIMUM_FRESHNESS_EXAMPLES;
+export const MINIMUM_CONFIRMED_EXAMPLES = 10;
 
 export type ConfidenceThreshold = {
   /** Null with fewer than MINIMUM_CONFIRMED_EXAMPLES confirmed predictions: nothing is guessed, nothing is skipped. */
@@ -217,11 +205,10 @@ function newestFirst(left: NeedsMeItem, right: NeedsMeItem): number {
 
 export function rankNeedsMe<P>(
   items: readonly NeedsMeItem<P>[],
-  options: { now: number; freshness: FeedFreshness; threshold: ConfidenceThreshold; attention?: AttentionModel },
+  options: { threshold: ConfidenceThreshold; attention?: AttentionModel },
 ): NeedsMeRanking<P> {
   const attention = options.attention ?? interimAttention;
-  const context: AttentionContext = { now: options.now, freshness: options.freshness };
-  const scores = new Map(items.map((item) => [item.id, attention.value(item, context)]));
+  const scores = new Map(items.map((item) => [item.id, attention.value(item)]));
   const score = (item: NeedsMeItem) => scores.get(item.id) ?? 0;
   const gates = items.filter((item) => item.hardGate).sort((left, right) => (left.createdAt ?? 0) - (right.createdAt ?? 0) || left.id.localeCompare(right.id));
   const rest = items.filter((item) => !item.hardGate);

package/lib/newsroom-board.ts

@@ -1,4 +1,4 @@
-import type { KanbanConfig, KanbanIssue } from "@kanbus/ui";
+import type { KanbanConfig, KanbanIssue, KanbanSortFieldRule } from "@kanbus/ui";
 import type { AssignmentRecord } from "./category-repository";
 import {
   ASSIGNMENT_PHASE_STAGE_KEYS,
@@ -118,11 +118,19 @@ export function assignmentColumnOrder(statusesPresentOnBoard: readonly string[])
   return [...ASSIGNMENT_STATUSES_BEFORE_OTHERS, ...otherStatuses, ...ASSIGNMENT_STATUSES_AFTER_OTHERS];
 }
 
+/**
+ * Kanbus's default column order is oldest-created first, and our content items carry no `created_at`, so without this every
+ * column listed its cards by id. Newest first by `updated_at`: it is the order the stage pages load in, and the only time a
+ * paged content item has (each save is a new version, so `createdAt` is the last edit, not the story's start).
+ */
+export const NEWEST_FIRST: KanbanSortFieldRule[] = [{ field: "updated_at", direction: "desc" }];
+
 function boardConfigForType(type: string, columns: readonly { key: string; name: string; collapsed?: boolean }[]): KanbanConfig {
   const statuses = columns.map(column => ({ ...column, category: "native" }));
   return {
     hierarchy: [], types: [type], statuses,
     categories: [{ name: "native" }], priorities: {}, type_colors: {},
+    sort_order: Object.fromEntries(statuses.map(status => [status.key, [...NEWEST_FIRST]])),
     workflows: { [type]: Object.fromEntries(statuses.map(status => [status.key, []])) },
   };
 }
@@ -165,6 +173,7 @@ export function deskBoardConfig(issues: readonly NativeBoardIssue[]): KanbanConf
     statuses: [...storiesConfig.statuses, ...assignmentsConfig.statuses],
     categories: storiesConfig.categories,
     workflows: { ...storiesConfig.workflows, ...assignmentsConfig.workflows },
+    sort_order: { ...assignmentsConfig.sort_order, ...storiesConfig.sort_order },
   };
 }
 

package/lib/newsroom-demo-dashboard.ts

@@ -161,13 +161,6 @@ export function applyPilobolusDemoDashboardContent(
   }));
 
   localized.messages = localized.messages.map((message) => {
-    if (message.messageKind === "ingestion_rationale") {
-      return {
-        ...message,
-        body: "Imported as a useful holdout against generic platform demo intake.",
-        summary: "Pilobolus intake rationale",
-      };
-    }
     if (message.messageKind === "reporting_context_packet") {
       const metadata = message.metadata && typeof message.metadata === "object" && !Array.isArray(message.metadata)
         ? message.metadata as Record<string, unknown>

package/lib/newsroom-organizer-nav.ts

@@ -8,10 +8,10 @@ export type OrganizerDestination = {
 };
 export const ORGANIZER_NAV_GROUPS: readonly { title: string; items: readonly OrganizerDestination[] }[] = [
   { title: "Editorial work", items: [
-    { key: "overview", label: "Needs me", description: "See what needs you: drafts, references and reviews.", path: "/newsroom", primary: true },
+    { key: "overview", label: "Needs me", description: "See what needs you: Proposed Stories, references and reviews.", path: "/newsroom", primary: true },
     { key: "articles", label: getContentItemName().plural, description: `Follow ${contentItemPluralLowercase} across their stages and open one to write or revise it.`, path: `/newsroom/${contentItemBoardPathSegment()}`, alsoActiveOnPaths: ["/newsroom/articles"], primary: true },
     { key: "assignments", label: "Assignments", description: "Follow research and reporting work across its statuses and claim it.", path: "/newsroom/assignments" },
-    { key: "drafts", label: "Drafts", description: "Read the story drafts that AI proposes, then accept or reject them.", path: "/newsroom/administration/proposals" },
+    { key: "drafts", label: "Proposed Stories", description: "Read the Proposed Stories that AI suggests, then accept or reject them.", path: "/newsroom/administration/proposals" },
     { key: "messages", label: "Messages", description: "Read and reply to newsroom conversations.", path: "/newsroom/messages", primary: true },
   ] },
   { title: "Research & knowledge", items: [

package/lib/post-message.ts

@@ -0,0 +1,54 @@
+/**
+ * Messages are created through the `postMessage` mutation, never through `createMessage`: the backend stamps the author from the
+ * signed-in identity, so a browser cannot name one. This is the one place that turns a Message record into that mutation and its
+ * arguments, shared by the conversation, forum and console chat writers. Authorship and timestamps are left out on purpose.
+ */
+
+const ARGUMENT_TYPES = {
+  id: "ID!",
+  threadId: "ID!",
+  content: "String",
+  messageKind: "String!",
+  messageDomain: "String!",
+  summary: "String",
+  parentMessageId: "ID",
+  sequenceNumber: "Int",
+  messageType: "String",
+  role: "String",
+  source: "String",
+  authorLabel: "String",
+  semanticLayer: "String",
+  searchVisibility: "String",
+  responseTarget: "String",
+  responseStatus: "String",
+  responseOwner: "String",
+  responseStartedAt: "AWSDateTime",
+  responseCompletedAt: "AWSDateTime",
+  metadata: "AWSJSON",
+  newsroomFeedKey: "String",
+} as const;
+
+export type PostMessageArguments = Partial<Record<keyof typeof ARGUMENT_TYPES, string | number | null>>;
+
+type MessageLike = Record<string, unknown>;
+
+/** The arguments of `postMessage` from a Message record. Anything else on the record (authorSub, authorUserProfileId, createdAt, updatedAt) is dropped. */
+export function postMessageArguments(record: MessageLike): PostMessageArguments {
+  const args: PostMessageArguments = {};
+  for (const key of Object.keys(ARGUMENT_TYPES) as Array<keyof typeof ARGUMENT_TYPES>) {
+    let value = record[key === "content" ? "content" : key];
+    if (key === "content") value = record.content ?? record.body;
+    if (value === undefined || value === null) continue;
+    if (key === "metadata") value = typeof value === "string" ? value : JSON.stringify(value);
+    args[key] = value as string | number;
+  }
+  return args;
+}
+
+/** `mutation PostMessage($id: ID!, …) { postMessage(id: $id, …) { <selection> } }` declaring exactly the arguments given. */
+export function postMessageMutation(args: PostMessageArguments, selection: string): string {
+  const keys = Object.keys(args) as Array<keyof typeof ARGUMENT_TYPES>;
+  const declared = keys.map((key) => `$${key}: ${ARGUMENT_TYPES[key]}`).join(", ");
+  const passed = keys.map((key) => `${key}: $${key}`).join(", ");
+  return `mutation PostMessage(${declared}) { postMessage(${passed}) { ${selection} } }`;
+}

package/lib/proposals-admin.ts

@@ -22,7 +22,7 @@ export type ProposalFilter = "open" | "draft" | "in_steering" | "editor_review"
 export type ProposalMove = { label: string; path?: string[]; edit?: "pin" | "unpin" | "hold" | "release"; state?: string };
 
 const STATE_LABELS: Record<string, string> = {
-  draft: "Draft",
+  draft: "Proposed",
   in_steering: "In steering",
   editor_review: "Editor review",
   approved: "Approved",
@@ -31,7 +31,7 @@ const STATE_LABELS: Record<string, string> = {
 };
 
 const KIND_LABELS: Record<string, string> = {
-  story_draft: "Story draft",
+  story_draft: "Proposed Story",
   new_concept: "New concept",
   rename: "Rename",
   merge: "Merge",

package/lib/reference-feed-keys.ts

@@ -0,0 +1,69 @@
+/**
+ * The keys the References page reads through (docs/reference-feed-indexes.md). The Python twin is
+ * src/papyrus_content/reference_feed_keys.py; scripts/fixtures/reference-feed-key-vectors.json holds the vectors both test.
+ *
+ * `feedStateKey` is "<corpusId>#unrated" (pending) or "<corpusId>#rated" (accepted or rejected); a Reference that is not the current
+ * version, or is archived, has none and is in neither feed. `predictionSortKey` is the Cyclotron's ORIGINAL P(accept), then arrival, then
+ * id; a Reference nobody predicted sorts as 0.5. A vote changes `feedStateKey` and nothing else here.
+ */
+import { normalizeReferenceCurationStatus } from "./reference-policy";
+
+export const UNDECIDED_PROBABILITY = 0.5;
+const EPOCH = "1970-01-01T00:00:00.000Z";
+const ARRIVAL_FIELDS = ["createdAt", "importedAt", "retrievedAt", "sourcePublishedAt", "versionCreatedAt"] as const;
+
+export type ReferenceFeedKeyInput = {
+  id: string;
+  corpusId?: string | null;
+  curationStatus?: string | null;
+  versionState?: string | null;
+  predictedAcceptProbability?: number | null;
+  createdAt?: string | null;
+  importedAt?: string | null;
+  retrievedAt?: string | null;
+  sourcePublishedAt?: string | null;
+  versionCreatedAt?: string | null;
+};
+
+export type ReferenceFeedKeys = {
+  feedStateKey: string | null;
+  feedArrivalAt: string;
+  predictionSortKey: string;
+};
+
+function instant(value: string | null | undefined): string | null {
+  if (!value) return null;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? new Date(parsed).toISOString() : null;
+}
+
+export function referenceFeedArrivalAt(reference: ReferenceFeedKeyInput): string {
+  for (const field of ARRIVAL_FIELDS) {
+    const found = instant(reference[field]);
+    if (found) return found;
+  }
+  return EPOCH;
+}
+
+export function referenceFeedStateKey(reference: ReferenceFeedKeyInput): string | null {
+  if (reference.versionState && reference.versionState !== "current") return null;
+  if (!reference.corpusId) return null;
+  const status = normalizeReferenceCurationStatus(reference.curationStatus);
+  if (status === "archived") return null;
+  return `${reference.corpusId}#${status === "pending" ? "unrated" : "rated"}`;
+}
+
+export function predictionSortKeyFor(probability: number | null | undefined, arrival: string, referenceId: string): string {
+  const chosen = probability === null || probability === undefined ? UNDECIDED_PROBABILITY : Math.min(1, Math.max(0, probability));
+  return `${chosen.toFixed(6)}#${arrival}#${referenceId}`;
+}
+
+/** The three feed keys for a Reference as it stands. `probability` overrides the one stored on it. */
+export function referenceFeedKeys(reference: ReferenceFeedKeyInput, probability?: number | null): ReferenceFeedKeys {
+  const arrival = referenceFeedArrivalAt(reference);
+  return {
+    feedStateKey: referenceFeedStateKey(reference),
+    feedArrivalAt: arrival,
+    predictionSortKey: predictionSortKeyFor(probability ?? reference.predictedAcceptProbability, arrival, reference.id),
+  };
+}