@anthusai/papyrus 5.57.0 → 5.58.0

package/amplify/data/resource.js

@@ -247,8 +247,6 @@ const schema = a.schema({
         referenceId: a.id().required(),
         status: a.string().required(),
         reasonCode: a.string(),
-        messageId: a.id(),
-        relationId: a.id(),
     }),
     ReferenceQualityActionResult: a.customType({
         ok: a.boolean().required(),
@@ -1569,8 +1567,23 @@ const schema = a.schema({
         curationStatusUpdatedAt: a.datetime(),
         curationStatusUpdatedBy: a.string(),
         curationStatusReason: a.string(),
+        curationReasonCode: a.string(),
+        curationActorKind: a.string(),
+        curationSectionId: a.string(),
+        curationShareable: a.boolean(),
+        curationDelegation: a.json(),
+        curationDecisionRelationId: a.string(),
         newsroomFeedKey: a.string(),
         reviewedFeedKey: a.string(),
+        // The References page reads the feed through two indexes (docs/reference-feed-indexes.md). `feedStateKey` is
+        // "<corpusId>#unrated" or "<corpusId>#rated" for a current, not archived Reference (null otherwise: it is in no feed).
+        // `predictionSortKey` orders Best bets, `feedArrivalAt` orders Newest. The prediction is the Cyclotron's ORIGINAL
+        // P(accept), written once, and never rewritten by a vote.
+        feedStateKey: a.string(),
+        feedArrivalAt: a.datetime(),
+        predictedAcceptProbability: a.float(),
+        predictionDecidedAt: a.datetime(),
+        predictionSortKey: a.string(),
         updatedAt: a.datetime(),
     })
         .secondaryIndexes((index) => [
@@ -1583,6 +1596,8 @@ const schema = a.schema({
         index("curationStatus").sortKeys(["curationStatusUpdatedAt"]).queryField("listReferencesByCurationStatusAndUpdatedAt"),
         index("curationStatusKey").sortKeys(["curationStatusUpdatedAt"]).queryField("listReferencesByCurationStatusKeyAndUpdatedAt"),
         index("reviewedFeedKey").sortKeys(["updatedAt"]).queryField("listReferencesByReviewedFeedAndUpdatedAt"),
+        index("feedStateKey").sortKeys(["predictionSortKey"]).queryField("listReferencesByFeedStateAndPrediction"),
+        index("feedStateKey").sortKeys(["feedArrivalAt"]).queryField("listReferencesByFeedStateAndArrival"),
     ])
         .authorization((allow) => [
         allow.groups(categoryWriteGroups).to(["read"]),
@@ -1670,6 +1685,9 @@ const schema = a.schema({
         authorSub: a.string(),
         authorUserProfileId: a.id(),
         authorLabel: a.string(),
+        editedAt: a.datetime(),
+        deletedAt: a.datetime(),
+        deletedBySub: a.string(),
         threadId: a.id(),
         parentMessageId: a.id(),
         sequenceNumber: a.integer(),
@@ -1704,8 +1722,12 @@ const schema = a.schema({
         index("searchVisibility").sortKeys(["createdAt"]).name("messagesBySearchVisibilityCreatedAt").queryField("listMessagesBySearchVisibilityAndCreatedAt"),
     ])
         .authorization((allow) => [
-        allow.groups(categoryWriteGroups).to(categoryAppendOnlyOperations),
+        // One rule per group (a group may appear once per model): editors read and add; admins also delete, for moderation.
+        allow.group("editor").to(categoryAppendOnlyOperations),
+        allow.group(adminGroup).to(["read", "create", "delete"]),
         allow.authenticated("identityPool").to(["read", "create", "update"]),
+        // Messages belong to their author: the author edits (and soft-deletes) their own, and only an admin can remove someone else's.
+        allow.ownerDefinedIn("authorSub").identityClaim("sub").to(["read", "update", "delete"]),
     ]),
     MessageThread: a
         .model({

package/amplify/data/resource.ts

@@ -267,8 +267,6 @@ const schema = a.schema({
     referenceId: a.id().required(),
     status: a.string().required(),
     reasonCode: a.string(),
-    messageId: a.id(),
-    relationId: a.id(),
   }),
 
   ReferenceQualityActionResult: a.customType({
@@ -1682,8 +1680,23 @@ const schema = a.schema({
       curationStatusUpdatedAt: a.datetime(),
       curationStatusUpdatedBy: a.string(),
       curationStatusReason: a.string(),
+      curationReasonCode: a.string(),
+      curationActorKind: a.string(),
+      curationSectionId: a.string(),
+      curationShareable: a.boolean(),
+      curationDelegation: a.json(),
+      curationDecisionRelationId: a.string(),
       newsroomFeedKey: a.string(),
       reviewedFeedKey: a.string(),
+      // The References page reads the feed through two indexes (docs/reference-feed-indexes.md). `feedStateKey` is
+      // "<corpusId>#unrated" or "<corpusId>#rated" for a current, not archived Reference (null otherwise: it is in no feed).
+      // `predictionSortKey` orders Best bets, `feedArrivalAt` orders Newest. The prediction is the Cyclotron's ORIGINAL
+      // P(accept), written once, and never rewritten by a vote.
+      feedStateKey: a.string(),
+      feedArrivalAt: a.datetime(),
+      predictedAcceptProbability: a.float(),
+      predictionDecidedAt: a.datetime(),
+      predictionSortKey: a.string(),
       updatedAt: a.datetime(),
     })
     .secondaryIndexes((index) => [
@@ -1696,6 +1709,8 @@ const schema = a.schema({
       index("curationStatus").sortKeys(["curationStatusUpdatedAt"]).queryField("listReferencesByCurationStatusAndUpdatedAt"),
       index("curationStatusKey").sortKeys(["curationStatusUpdatedAt"]).queryField("listReferencesByCurationStatusKeyAndUpdatedAt"),
       index("reviewedFeedKey").sortKeys(["updatedAt"]).queryField("listReferencesByReviewedFeedAndUpdatedAt"),
+      index("feedStateKey").sortKeys(["predictionSortKey"]).queryField("listReferencesByFeedStateAndPrediction"),
+      index("feedStateKey").sortKeys(["feedArrivalAt"]).queryField("listReferencesByFeedStateAndArrival"),
     ])
     .authorization((allow) => [
       allow.groups(categoryWriteGroups).to(["read"]),
@@ -1786,6 +1801,9 @@ const schema = a.schema({
       authorSub: a.string(),
       authorUserProfileId: a.id(),
       authorLabel: a.string(),
+      editedAt: a.datetime(),
+      deletedAt: a.datetime(),
+      deletedBySub: a.string(),
       threadId: a.id(),
       parentMessageId: a.id(),
       sequenceNumber: a.integer(),
@@ -1820,8 +1838,12 @@ const schema = a.schema({
       index("searchVisibility").sortKeys(["createdAt"]).name("messagesBySearchVisibilityCreatedAt").queryField("listMessagesBySearchVisibilityAndCreatedAt"),
     ])
     .authorization((allow) => [
-      allow.groups(categoryWriteGroups).to(categoryAppendOnlyOperations),
+      // One rule per group (a group may appear once per model): editors read and add; admins also delete, for moderation.
+      allow.group("editor").to(categoryAppendOnlyOperations),
+      allow.group(adminGroup).to(["read", "create", "delete"]),
       allow.authenticated("identityPool").to(["read", "create", "update"]),
+      // Messages belong to their author: the author edits (and soft-deletes) their own, and only an admin can remove someone else's.
+      allow.ownerDefinedIn("authorSub").identityClaim("sub").to(["read", "update", "delete"]),
     ]),
 
   MessageThread: a

package/amplify/data/schema.js

@@ -259,8 +259,6 @@ function buildBaseDefinitions(includeEditions) {
             referenceId: a.id().required(),
             status: a.string().required(),
             reasonCode: a.string(),
-            messageId: a.id(),
-            relationId: a.id(),
         }),
         ReferenceQualityActionResult: a.customType({
             ok: a.boolean().required(),
@@ -1475,8 +1473,23 @@ function buildBaseDefinitions(includeEditions) {
             curationStatusUpdatedAt: a.datetime(),
             curationStatusUpdatedBy: a.string(),
             curationStatusReason: a.string(),
+            curationReasonCode: a.string(),
+            curationActorKind: a.string(),
+            curationSectionId: a.string(),
+            curationShareable: a.boolean(),
+            curationDelegation: a.json(),
+            curationDecisionRelationId: a.string(),
             newsroomFeedKey: a.string(),
             reviewedFeedKey: a.string(),
+            // The References page reads the feed through two indexes (docs/reference-feed-indexes.md). `feedStateKey` is
+            // "<corpusId>#unrated" or "<corpusId>#rated" for a current, not archived Reference (null otherwise: it is in no feed).
+            // `predictionSortKey` orders Best bets, `feedArrivalAt` orders Newest. The prediction is the Cyclotron's ORIGINAL
+            // P(accept), written once, and never rewritten by a vote.
+            feedStateKey: a.string(),
+            feedArrivalAt: a.datetime(),
+            predictedAcceptProbability: a.float(),
+            predictionDecidedAt: a.datetime(),
+            predictionSortKey: a.string(),
             updatedAt: a.datetime(),
         })
             .secondaryIndexes((index) => [
@@ -1489,6 +1502,8 @@ function buildBaseDefinitions(includeEditions) {
             index("curationStatus").sortKeys(["curationStatusUpdatedAt"]).queryField("listReferencesByCurationStatusAndUpdatedAt"),
             index("curationStatusKey").sortKeys(["curationStatusUpdatedAt"]).queryField("listReferencesByCurationStatusKeyAndUpdatedAt"),
             index("reviewedFeedKey").sortKeys(["updatedAt"]).queryField("listReferencesByReviewedFeedAndUpdatedAt"),
+            index("feedStateKey").sortKeys(["predictionSortKey"]).queryField("listReferencesByFeedStateAndPrediction"),
+            index("feedStateKey").sortKeys(["feedArrivalAt"]).queryField("listReferencesByFeedStateAndArrival"),
         ])
             .authorization((allow) => [
             allow.groups(categoryWriteGroups).to(["read"]),
@@ -1573,6 +1588,9 @@ function buildBaseDefinitions(includeEditions) {
             authorSub: a.string(),
             authorUserProfileId: a.id(),
             authorLabel: a.string(),
+            editedAt: a.datetime(),
+            deletedAt: a.datetime(),
+            deletedBySub: a.string(),
             threadId: a.id(),
             parentMessageId: a.id(),
             sequenceNumber: a.integer(),
@@ -1607,7 +1625,11 @@ function buildBaseDefinitions(includeEditions) {
             index("searchVisibility").sortKeys(["createdAt"]).name("messagesBySearchVisibilityCreatedAt").queryField("listMessagesBySearchVisibilityAndCreatedAt"),
         ])
             .authorization((allow) => [
-            allow.groups(categoryWriteGroups).to(categoryAppendOnlyOperations),
+            // One rule per group (a group may appear once per model): editors read and add; admins also delete, for moderation.
+            allow.group("editor").to(categoryAppendOnlyOperations),
+            allow.group(adminGroup).to(["read", "create", "delete"]),
+            // Messages belong to their author: the author edits (and soft-deletes) their own, and only an admin can remove someone else's.
+            allow.ownerDefinedIn("authorSub").identityClaim("sub").to(["read", "update", "delete"]),
         ]),
         MessageThread: realtimeModel({
             id: a.id().required(),

package/amplify/data/schema.ts

@@ -285,8 +285,6 @@ const definitions = {
     referenceId: a.id().required(),
     status: a.string().required(),
     reasonCode: a.string(),
-    messageId: a.id(),
-    relationId: a.id(),
   }),
 
   ReferenceQualityActionResult: a.customType({
@@ -1586,8 +1584,23 @@ const definitions = {
       curationStatusUpdatedAt: a.datetime(),
       curationStatusUpdatedBy: a.string(),
       curationStatusReason: a.string(),
+      curationReasonCode: a.string(),
+      curationActorKind: a.string(),
+      curationSectionId: a.string(),
+      curationShareable: a.boolean(),
+      curationDelegation: a.json(),
+      curationDecisionRelationId: a.string(),
       newsroomFeedKey: a.string(),
       reviewedFeedKey: a.string(),
+      // The References page reads the feed through two indexes (docs/reference-feed-indexes.md). `feedStateKey` is
+      // "<corpusId>#unrated" or "<corpusId>#rated" for a current, not archived Reference (null otherwise: it is in no feed).
+      // `predictionSortKey` orders Best bets, `feedArrivalAt` orders Newest. The prediction is the Cyclotron's ORIGINAL
+      // P(accept), written once, and never rewritten by a vote.
+      feedStateKey: a.string(),
+      feedArrivalAt: a.datetime(),
+      predictedAcceptProbability: a.float(),
+      predictionDecidedAt: a.datetime(),
+      predictionSortKey: a.string(),
       updatedAt: a.datetime(),
     })
     .secondaryIndexes((index) => [
@@ -1600,6 +1613,8 @@ const definitions = {
       index("curationStatus").sortKeys(["curationStatusUpdatedAt"]).queryField("listReferencesByCurationStatusAndUpdatedAt"),
       index("curationStatusKey").sortKeys(["curationStatusUpdatedAt"]).queryField("listReferencesByCurationStatusKeyAndUpdatedAt"),
       index("reviewedFeedKey").sortKeys(["updatedAt"]).queryField("listReferencesByReviewedFeedAndUpdatedAt"),
+      index("feedStateKey").sortKeys(["predictionSortKey"]).queryField("listReferencesByFeedStateAndPrediction"),
+      index("feedStateKey").sortKeys(["feedArrivalAt"]).queryField("listReferencesByFeedStateAndArrival"),
     ])
     .authorization((allow) => [
       allow.groups(categoryWriteGroups).to(["read"]),
@@ -1687,6 +1702,9 @@ const definitions = {
       authorSub: a.string(),
       authorUserProfileId: a.id(),
       authorLabel: a.string(),
+      editedAt: a.datetime(),
+      deletedAt: a.datetime(),
+      deletedBySub: a.string(),
       threadId: a.id(),
       parentMessageId: a.id(),
       sequenceNumber: a.integer(),
@@ -1721,7 +1739,11 @@ const definitions = {
       index("searchVisibility").sortKeys(["createdAt"]).name("messagesBySearchVisibilityCreatedAt").queryField("listMessagesBySearchVisibilityAndCreatedAt"),
     ])
     .authorization((allow) => [
-      allow.groups(categoryWriteGroups).to(categoryAppendOnlyOperations),
+      // One rule per group (a group may appear once per model): editors read and add; admins also delete, for moderation.
+      allow.group("editor").to(categoryAppendOnlyOperations),
+      allow.group(adminGroup).to(["read", "create", "delete"]),
+      // Messages belong to their author: the author edits (and soft-deletes) their own, and only an admin can remove someone else's.
+      allow.ownerDefinedIn("authorSub").identityClaim("sub").to(["read", "update", "delete"]),
     ]),
 
   MessageThread: realtimeModel({

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

@@ -4,7 +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 { curationActorKind, referenceCurationMetadata, validatedCurationSectionId } from "../shared/reference-curation-metadata";
+import { curationActorKind, referenceVoteFields, validatedCurationSectionId } from "../shared/reference-curation-metadata";
 import {
   CURATION_DELEGATION_OWNER_TYPE,
   CURATION_DELEGATION_PAYLOAD_KIND,
@@ -24,6 +24,8 @@ import {
   requestDelegation,
   type DelegationStore,
 } from "../shared/curation-delegation-flow";
+import { rejectionReasonCodeForWrittenReason } from "../../../lib/reference-policy";
+import { referenceFeedKeys, referenceFeedStateKey } from "../../../lib/reference-feed-keys";
 import { claimGroups } from "../../../lib/staff-groups";
 
 type ReviewHandler = Schema["reviewSteeringProposal"]["functionHandler"];
@@ -214,7 +216,15 @@ async function reviewReferenceCuration(
   const referenceId = normalizeRequiredString(event.arguments.referenceId, "referenceId");
   const action = normalizeReferenceCurationAction(event.arguments.action);
   const nextStatus = referenceCurationStatusForAction(action);
-  const reasonCode = normalizeReferenceRejectionReasonCode(event.arguments.reasonCode, action === "reject");
+  const writtenReason = normalizeOptionalString(event.arguments.note);
+  // A rejection needs a reason, and the editor's own sentence is one: with no reason code sent, the
+  // words are read for the code they name, so the scope-training negatives keep arriving from the
+  // surfaces that ask for words instead of a chip. Words that name no code are filed under "other".
+  const reasonCode = normalizeReferenceRejectionReasonCode(event.arguments.reasonCode)
+    ?? (action === "reject" ? rejectionReasonCodeForWrittenReason(writtenReason) : null);
+  if (action === "reject" && !reasonCode) {
+    throw new Error("A rejection needs a reason: say why in your own words, or send a reasonCode.");
+  }
   const reference = await getRequiredRecord(client.models.Reference, referenceId, "Reference");
   const requestedSectionId = normalizeOptionalString(event.arguments.sectionId);
   const sectionRecord = requestedSectionId
@@ -225,18 +235,11 @@ async function reviewReferenceCuration(
   const actorSub = normalizeOptionalString(event.arguments.actorSub) ?? getIdentitySub(event);
   const actorLabel = normalizeOptionalString(event.arguments.actorLabel) ?? getIdentityLabel(event);
   const actor = actorLabel ?? actorSub ?? "Papyrus newsroom";
-  const note = normalizeOptionalString(event.arguments.note);
-  const referenceLineageId = normalizeOptionalString(reference.lineageId) ?? referenceId;
-  const referenceVersionNumber = typeof reference.versionNumber === "number" ? reference.versionNumber : null;
-  const referenceTitle = normalizeOptionalString(reference.title) ?? normalizeOptionalString(reference.externalItemId) ?? referenceId;
-  const messageId = `message-reference-curation-${safeId(referenceLineageId)}-${safeId(action)}-${now.replace(/[^0-9TZ]/g, "")}-${randomUUID().slice(0, 8)}`;
-  const relationId = `semantic-relation-${hashStable([
-    `message#${messageId}`,
-    "comment",
-    `reference#${referenceId}`,
-    action,
-  ]).slice(0, 16)}`;
+  const note = writtenReason;
+  const decisionRelationId = normalizeOptionalString(event.arguments.decisionRelationId);
 
+  // The vote is recorded on the Reference itself: its status, who set it and the note, plus the details of the vote.
+  // Messages come only from people, so a vote writes no Message and no comment relation.
   await requireDataResult(
     client.models.Reference.update({
       id: referenceId,
@@ -245,98 +248,23 @@ async function reviewReferenceCuration(
       curationStatusUpdatedAt: now,
       curationStatusUpdatedBy: actor,
       curationStatusReason: note,
+      ...referenceVoteFields({
+        actorKind: delegation ? "human" : curationActorKind(event.identity),
+        reasonCode,
+        sectionId,
+        shareable: event.arguments.shareable ?? null,
+        delegation,
+        decisionRelationId,
+      }),
       newsroomFeedKey: reference.newsroomFeedKey ?? "references",
       reviewedFeedKey: reviewedFeedKeyForStatus(nextStatus),
+      // A vote moves the Reference between the unrated and rated feeds; its original prediction and arrival stay as they were.
+      feedStateKey: referenceFeedStateKey({ ...reference, curationStatus: nextStatus }),
       updatedAt: now,
     }),
     "update Reference curation status",
   );
 
-  await requireDataResult(
-    client.models.Message.create(buildCanonicalMessageInput({
-      id: messageId,
-      messageKind: "reference_curation",
-      messageDomain: "commentary",
-      summary: `${referenceTitle}: ${nextStatus}`,
-      source: "newsroom",
-      authorSub: actorSub,
-      authorLabel: actor,
-      now,
-    })),
-    "create Message",
-  );
-  await putTextModelPayload(
-    client as any,
-    { ownerKind: "message", ownerId: messageId, ownerLineageId: messageId },
-    "message_body",
-    "message",
-    note ?? `${actor} marked this reference ${nextStatus}.`,
-    { filename: "message.txt", now },
-  );
-  await putJsonModelPayload(
-    client as any,
-    { ownerKind: "message", ownerId: messageId, ownerLineageId: messageId },
-    "metadata",
-    "metadata",
-    referenceCurationMetadata({
-      action,
-      curationStatus: nextStatus,
-      reasonCode,
-      referenceId,
-      referenceLineageId,
-      decisionRelationId: normalizeOptionalString(event.arguments.decisionRelationId),
-      shareable: event.arguments.shareable ?? null,
-      actorKind: delegation ? "human" : curationActorKind(event.identity),
-      sectionId,
-      delegation,
-    }),
-    { filename: "metadata.json", now },
-  );
-
-  await requireDataResult(
-    client.models.SemanticRelation.create({
-      id: relationId,
-      relationState: "current",
-      predicate: "comment",
-      relationTypeId: "semantic-relation-type-comment",
-      relationTypeKey: "comment",
-      relationDomain: "commentary",
-      subjectKind: "message",
-      subjectId: messageId,
-      subjectLineageId: messageId,
-      subjectVersionNumber: 1,
-      objectKind: "reference",
-      objectId: referenceId,
-      objectLineageId: referenceLineageId,
-      objectVersionNumber: referenceVersionNumber,
-      subjectStateKey: semanticStateKey("message", messageId),
-      objectStateKey: semanticStateKey("reference", referenceLineageId),
-      objectSubjectStateKey: `${semanticStateKey("reference", referenceLineageId)}#message`,
-      predicateObjectStateKey: `comment#${semanticStateKey("reference", referenceLineageId)}`,
-      subjectVersionKey: semanticVersionKey("message", messageId),
-      objectVersionKey: semanticVersionKey("reference", referenceId),
-      score: 1,
-      confidence: null,
-      rank: 1,
-      classifierId: null,
-      modelVersion: null,
-      reviewRecommended: false,
-      sourceSnapshotId: null,
-      importRunId: null,
-      importedAt: now,
-      createdAt: now,
-      updatedAt: now,
-      newsroomFeedKey: "semanticRelations",
-      metadata: JSON.stringify({
-        action,
-        curationStatus: nextStatus,
-        reasonCode,
-        messageKind: "reference_curation",
-      }),
-    }),
-    "create Message SemanticRelation",
-  );
-
   await updateNewsroomSummaryForReferenceCuration(client, {
     corpusId: normalizeOptionalString(reference.corpusId),
     previousStatus: normalizeOptionalString(reference.curationStatus) ?? "pending",
@@ -350,8 +278,6 @@ async function reviewReferenceCuration(
     referenceId,
     status: nextStatus,
     reasonCode,
-    messageId,
-    relationId,
   };
 }
 
@@ -633,6 +559,8 @@ async function setReferenceQualityRating(event: Parameters<ReferenceQualityHandl
       curationStatusReason: note,
       newsroomFeedKey: reference.newsroomFeedKey ?? "references",
       reviewedFeedKey: reviewedFeedKeyForStatus(nextStatus),
+      // A vote moves the Reference between the unrated and rated feeds; its original prediction and arrival stay as they were.
+      feedStateKey: referenceFeedStateKey({ ...reference, curationStatus: nextStatus }),
       updatedAt: now,
     }),
     "update Reference quality status",
@@ -809,6 +737,7 @@ async function moveReferenceCorpus(event: Parameters<MoveReferenceCorpusHandler>
       client.models.Reference.update({
         id: normalizeRequiredString(current.id, "reference.id"),
         versionState: "superseded",
+        feedStateKey: null,   // a superseded version is in no feed
         updatedAt: now,
       }),
       "supersede current Reference version",
@@ -846,8 +775,27 @@ async function moveReferenceCorpus(event: Parameters<MoveReferenceCorpusHandler>
       curationStatusUpdatedAt: normalizeOptionalString(current.curationStatusUpdatedAt) ?? now,
       curationStatusUpdatedBy: normalizeOptionalString(current.curationStatusUpdatedBy) ?? actor,
       curationStatusReason: normalizeOptionalString(current.curationStatusReason),
+      curationReasonCode: normalizeOptionalString(current.curationReasonCode),
+      curationActorKind: normalizeOptionalString(current.curationActorKind),
+      curationSectionId: normalizeOptionalString(current.curationSectionId),
+      curationShareable: typeof current.curationShareable === "boolean" ? current.curationShareable : null,
+      curationDelegation: current.curationDelegation ?? null,
+      curationDecisionRelationId: normalizeOptionalString(current.curationDecisionRelationId),
       newsroomFeedKey: normalizeOptionalString(current.newsroomFeedKey) ?? "references",
       reviewedFeedKey: normalizeOptionalString(current.reviewedFeedKey) ?? reviewedFeedKeyForStatus(curationStatus),
+      predictedAcceptProbability: typeof current.predictedAcceptProbability === "number" ? current.predictedAcceptProbability : null,
+      predictionDecidedAt: normalizeOptionalString(current.predictionDecidedAt),
+      ...referenceFeedKeys({
+        id: nextReferenceId,
+        corpusId: targetCorpusId,
+        curationStatus,
+        versionState: "current",
+        predictedAcceptProbability: typeof current.predictedAcceptProbability === "number" ? current.predictedAcceptProbability : null,
+        createdAt: normalizeOptionalString(current.createdAt) ?? now,
+        importedAt: normalizeOptionalString(current.importedAt),
+        retrievedAt: normalizeOptionalString(current.retrievedAt),
+        sourcePublishedAt: normalizeOptionalString(current.sourcePublishedAt),
+      }),
       updatedAt: now,
     }),
     "create moved Reference version",
@@ -2095,12 +2043,10 @@ const REFERENCE_REJECTION_REASON_CODES = new Set([
   "other",
 ]);
 
-function normalizeReferenceRejectionReasonCode(value: unknown, required: boolean): string | null {
+/** A supplied reason code, validated. Whether a rejection has a reason at all is the caller's rule. */
+function normalizeReferenceRejectionReasonCode(value: unknown): string | null {
   const normalized = normalizePolicyToken(value);
-  if (!normalized) {
-    if (required) throw new Error("reasonCode is required when rejecting a reference.");
-    return null;
-  }
+  if (!normalized) return null;
   if (!REFERENCE_REJECTION_REASON_CODES.has(normalized)) {
     throw new Error(`Unsupported reference rejection reason code ${normalized}.`);
   }
@@ -2162,9 +2108,6 @@ async function updateNewsroomSummaryForReferenceCuration(
   payload.generatedAt = input.now;
   payload.staleAt = new Date(Date.parse(input.now) + SUMMARY_STALE_AFTER_MS).toISOString();
   payload.source = "incremental";
-  payload.counts.messages = Math.max(0, (payload.counts.messages ?? 0) + 1);
-  payload.counts.modelAttachments = Math.max(0, (payload.counts.modelAttachments ?? 0) + 2);
-  payload.counts.semanticRelations = Math.max(0, (payload.counts.semanticRelations ?? 0) + 1);
   if (input.previousStatus !== input.nextStatus) {
     increment(payload.referenceStatusCounts, input.previousStatus, -1);
     increment(payload.referenceStatusCounts, input.nextStatus, 1);
@@ -2176,23 +2119,6 @@ async function updateNewsroomSummaryForReferenceCuration(
       increment(payload.facets.references.statusByCorpus[input.corpusId], input.nextStatus, 1);
     }
   }
-  increment(payload.messageKindCounts, "reference_curation", 1);
-  increment(payload.messageDomainCounts, "commentary", 1);
-  increment(payload.facets.messages.byKind, "reference_curation", 1);
-  increment(payload.facets.messages.byDomain, "commentary", 1);
-  increment(payload.facets.messages.byStatus, "active", 1);
-  if (!payload.facets.messages.domainByKind.reference_curation) payload.facets.messages.domainByKind.reference_curation = {};
-  increment(payload.facets.messages.domainByKind.reference_curation, "commentary", 1);
-  increment(payload.facets.modelAttachments.byOwnerKind, "message", 2);
-  increment(payload.facets.modelAttachments.byRole, "message_body", 1);
-  increment(payload.facets.modelAttachments.byRole, "metadata", 1);
-  increment(payload.facets.modelAttachments.byMediaType, "text/plain", 1);
-  increment(payload.facets.modelAttachments.byMediaType, "application/json", 1);
-  increment(payload.facets.modelAttachments.byStatus, "active", 2);
-  increment(payload.facets.semanticRelations.byRelationTypeKey, "comment", 1);
-  increment(payload.facets.semanticRelations.byRelationDomain, "workflow", 1);
-  increment(payload.facets.semanticRelations.bySubjectKind, "message", 1);
-  increment(payload.facets.semanticRelations.byObjectKind, "reference", 1);
   await upsertNewsroomSummaryPayload(client, payload, response.data, input.now);
 }
 

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

@@ -1,23 +1,19 @@
 /**
- * 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.
+ * The details of a vote, kept on the Reference itself (Messages come only from people).
+ * When the relevance cyclotron decided the reference, the vote records which decision
+ * it answered and whether its explanation may be shared (for the Cyclotron marketing
+ * recording). Both are optional. A Reference keeps only its latest vote.
  */
-export type ReferenceCurationMetadataInput = {
-  action: string
-  curationStatus: string
-  reasonCode: string | null
-  referenceId: string
-  referenceLineageId: string
+export type ReferenceVoteInput = {
+  actorKind: CurationActorKind
+  reasonCode?: string | null
+  sectionId?: string | null
   decisionRelationId?: string | null
   shareable?: boolean | null
-  actorKind?: CurationActorKind | null
-  sectionId?: string | null
   delegation?: { delegationId: string; relayedBy: string; instruction: string } | null
 }
 
-export type CurationActorKind = "human" | "service"
+export type CurationActorKind = "human" | "agent" | "cyclotron" | "rule" | "catalog"
 
 /**
  * A curation is human only when the caller signed in through the user pool, so
@@ -27,26 +23,22 @@ export type CurationActorKind = "human" | "service"
 export function curationActorKind(identity: unknown): CurationActorKind {
   const claims = (identity as {claims?: Record<string, unknown>} | null | undefined)?.claims
   const subject = claims?.sub
-  return typeof subject === "string" && subject.trim() !== "" ? "human" : "service"
+  return typeof subject === "string" && subject.trim() !== "" ? "human" : "agent"
 }
 
-export function referenceCurationMetadata(input: ReferenceCurationMetadataInput): Record<string, unknown> {
+/**
+ * The Reference fields a vote sets. Every field is always present, so a new vote clears
+ * what the last one carried. The delegation is stored as JSON.
+ */
+export function referenceVoteFields(input: ReferenceVoteInput): 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,
-    ...(input.actorKind ? {actorKind: input.actorKind} : {}),
-    ...(input.sectionId?.trim() ? {sectionId: input.sectionId.trim()} : {}),
-    ...(input.delegation
-      ? {attestation: "delegated", relayedBy: input.delegation.relayedBy, delegationId: input.delegation.delegationId,
-         instruction: input.delegation.instruction}
-      : {}),
-    ...(decisionRelationId ? {decisionRelationId} : {}),
-    ...(decisionRelationId ? {shareable: input.shareable === true} : {}),
+    curationActorKind: input.actorKind,
+    curationReasonCode: input.reasonCode?.trim() || null,
+    curationSectionId: input.sectionId?.trim() || null,
+    curationShareable: decisionRelationId ? input.shareable === true : null,
+    curationDelegation: input.delegation ? JSON.stringify(input.delegation) : null,
+    curationDecisionRelationId: decisionRelationId,
   }
 }