@anthusai/papyrus 5.43.0-next.5 → 5.43.0-next.50

package/amplify/data/schema.ts

@@ -4,6 +4,7 @@ import { categoryAction } from "../functions/category-action/resource";
 import { editorialChecksSchemaDefinitions } from "../functions/editorial-checks/schema";
 import { automationViewSchemaDefinitions } from "../functions/automation-view/schema";
 import { proposalActionsSchemaDefinitions } from "../functions/proposal-actions/schema";
+import { messageActionsSchemaDefinitions } from "./message-actions";
 import { monitoringViewSchemaDefinitions } from "../functions/monitoring-view/schema";
 import { contentActions } from "../functions/content-actions/resource";
 import { knowledgeQuery } from "../functions/knowledge-query/resource";
@@ -285,8 +286,6 @@ const definitions = {
     referenceId: a.id().required(),
     status: a.string().required(),
     reasonCode: a.string(),
-    messageId: a.id(),
-    relationId: a.id(),
   }),
 
   ReferenceQualityActionResult: a.customType({
@@ -582,6 +581,13 @@ const definitions = {
     .authorization((allow) => [allow.groups(contentWriteGroups)])
     .handler(functionHandler("contentActions", contentActions)),
 
+  correctReferenceCapture: a
+    .mutation()
+    .arguments({ input: a.json().required() })
+    .returns(a.json())
+    .authorization((allow) => [allow.groups(contentWriteGroups)])
+    .handler(functionHandler("contentActions", contentActions)),
+
   saveItemDraft: a
     .mutation()
     .arguments({ input: a.json().required() })
@@ -1579,8 +1585,26 @@ 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(),
+      discoveredByMonitorId: a.string(),
+      discoveryDetails: a.json(),
+      discoveryRule: a.json(),
+      // 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) => [
@@ -1593,6 +1617,9 @@ const definitions = {
       index("curationStatus").sortKeys(["curationStatusUpdatedAt"]).queryField("listReferencesByCurationStatusAndUpdatedAt"),
       index("curationStatusKey").sortKeys(["curationStatusUpdatedAt"]).queryField("listReferencesByCurationStatusKeyAndUpdatedAt"),
       index("reviewedFeedKey").sortKeys(["updatedAt"]).queryField("listReferencesByReviewedFeedAndUpdatedAt"),
+      index("discoveredByMonitorId").sortKeys(["createdAt"]).queryField("listReferencesByMonitorAndCreatedAt"),
+      index("feedStateKey").sortKeys(["predictionSortKey"]).queryField("listReferencesByFeedStateAndPrediction"),
+      index("feedStateKey").sortKeys(["feedArrivalAt"]).queryField("listReferencesByFeedStateAndArrival"),
     ])
     .authorization((allow) => [
       allow.groups(categoryWriteGroups).to(["read"]),
@@ -1680,6 +1707,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(),
@@ -1714,20 +1744,25 @@ const definitions = {
       index("searchVisibility").sortKeys(["createdAt"]).name("messagesBySearchVisibilityCreatedAt").queryField("listMessagesBySearchVisibilityAndCreatedAt"),
     ])
     .authorization((allow) => [
-      allow.groups(categoryWriteGroups).to(categoryAppendOnlyOperations),
+      // Messages belong to their author, and the backend stamps the author: people read Messages here and write them only through
+      // postMessage, editMessage, deleteOwnMessage and moderateMessage (message-actions.ts). Functions and IAM callers write directly.
+      allow.group("editor").to(["read"]),
+      allow.group(adminGroup).to(["read"]),
     ]),
 
   MessageThread: realtimeModel({
       id: a.id().required(),
       threadKind: a.string().required(),
       status: a.string().required(),
-      title: a.string().required(),
+      // The title and the creator are set when a conversation is created and read afterwards; a title changes only through
+      // renameThread (its creator or an admin), and the creator never changes.
+      title: a.string().required().authorization((allow) => [allow.group("editor").to(["read", "create"]), allow.group(adminGroup).to(["read", "create"])]),
       summary: a.string(),
       primaryAnchorKind: a.string(),
       primaryAnchorId: a.id(),
       primaryAnchorLineageId: a.id(),
       primaryAnchorKey: a.string(),
-      createdBySub: a.string(),
+      createdBySub: a.string().authorization((allow) => [allow.group("editor").to(["read", "create"]), allow.group(adminGroup).to(["read", "create"])]),
       createdByUserProfileId: a.id(),
       createdByLabel: a.string(),
       messageCount: a.integer(),
@@ -2227,6 +2262,7 @@ const definitions = {
   ...monitoringViewSchemaDefinitions,
   ...automationViewSchemaDefinitions,
   ...proposalActionsSchemaDefinitions,
+  ...messageActionsSchemaDefinitions,
 };
 if (!includeEditions) {
   const mutableDefinitions = definitions as Record<string, unknown>;

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,9 @@ 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"];
 type ReferenceCurationHandler = Schema["reviewReferenceCuration"]["functionHandler"];
@@ -213,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
@@ -224,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,
@@ -244,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",
@@ -349,8 +278,6 @@ async function reviewReferenceCuration(
     referenceId,
     status: nextStatus,
     reasonCode,
-    messageId,
-    relationId,
   };
 }
 
@@ -360,7 +287,7 @@ function requireSignedInPerson(event: { identity?: unknown }): { sub: string; la
   }
   const identity = event.identity as { sub?: unknown; claims?: Record<string, unknown> };
   const claims = identity.claims ?? {};
-  const groups = Array.isArray(claims["cognito:groups"]) ? (claims["cognito:groups"] as unknown[]) : [];
+  const groups = claimGroups(claims["cognito:groups"]);
   return {
     sub: normalizeRequiredString(claims.sub ?? identity.sub, "identity.sub"),
     label: normalizeOptionalString(claims.email) ?? normalizeOptionalString(claims.name) ?? "Newsroom editor",
@@ -632,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",
@@ -808,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",
@@ -845,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",
@@ -2094,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}.`);
   }
@@ -2161,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);
@@ -2175,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/content-actions/handler.py

@@ -365,6 +365,14 @@ def handler(event, context):
                     client, arguments, event.get("identity") or {}, receipt_store=receipt_store)
             except IntakeError as error:
                 return {"ok": False, "errors": [{"code": "intake-rejected", "message": str(error)}]}
+        if field == "correctReferenceCapture":
+            from papyrus_content.reference_curation_store import CurationError, correct_reference_capture
+
+            client, _claims = create_authoring_client()
+            try:
+                return correct_reference_capture(client, arguments, event.get("identity") or {})
+            except CurationError as error:
+                return {"ok": False, "errors": [{"code": "correction-rejected", "message": str(error)}]}
         if field == "deriveMarkus":
             return derive_markus_action(arguments)
         if field == "saveItemDraft":

package/amplify/functions/content-actions/requirements.txt

@@ -4,3 +4,5 @@ anthus-markus==0.7.0
 Pillow>=11.3,<12
 awscrt>=0.23,<1
 humanus>=0.33,<0.34
+pypdf>=6.12.1,<7
+youtube-transcript-api>=1.2.4,<2

package/amplify/functions/content-actions/resource.js

@@ -7,7 +7,7 @@ import { fileURLToPath } from "node:url";
 import { pythonLambdaCode } from "../shared/python-bundle.js";
 const dirname = path.dirname(fileURLToPath(import.meta.url));
 const projectRoot = path.resolve(dirname, "../../..");
-export const contentActionsRequirements = ["PyYAML>=6.0.2,<7", "citeproc-py>=0.8.2,<1", "anthus-markus==0.7.0", "Pillow>=11.3,<12", "awscrt>=0.23,<1", "humanus>=0.33,<0.34"];
+export const contentActionsRequirements = ["PyYAML>=6.0.2,<7", "citeproc-py>=0.8.2,<1", "anthus-markus==0.7.0", "Pillow>=11.3,<12", "awscrt>=0.23,<1", "humanus>=0.33,<0.34", "pypdf>=6.12.1,<7", "youtube-transcript-api>=1.2.4,<2"];
 function installCheckoutRequirements(outputDir) {
     const requirementsPath = path.join(projectRoot, "amplify/functions/content-actions/requirements.txt");
     execSync(`python3 -m pip install -r "${requirementsPath}" -t "${outputDir}" --no-cache-dir --platform manylinux2014_aarch64 --implementation cp --python-version 3.12 --only-binary=:all: --ignore-requires-python`, { cwd: projectRoot, stdio: "inherit" });

package/amplify/functions/content-actions/resource.ts

@@ -10,7 +10,7 @@ import { pythonLambdaCode, type SiteBundleFile } from "../shared/python-bundle";
 const dirname = path.dirname(fileURLToPath(import.meta.url));
 const projectRoot = path.resolve(dirname, "../../..");
 
-export const contentActionsRequirements = ["PyYAML>=6.0.2,<7", "citeproc-py>=0.8.2,<1", "anthus-markus==0.7.0", "Pillow>=11.3,<12", "awscrt>=0.23,<1", "humanus>=0.33,<0.34"];
+export const contentActionsRequirements = ["PyYAML>=6.0.2,<7", "citeproc-py>=0.8.2,<1", "anthus-markus==0.7.0", "Pillow>=11.3,<12", "awscrt>=0.23,<1", "humanus>=0.33,<0.34", "pypdf>=6.12.1,<7", "youtube-transcript-api>=1.2.4,<2"];
 
 function installCheckoutRequirements(outputDir: string): void {
   const requirementsPath = path.join(projectRoot, "amplify/functions/content-actions/requirements.txt");

package/amplify/functions/model-attachment-upload/handler.ts

@@ -41,6 +41,7 @@ const ALLOWED_ROLES = new Set([
   "item_excerpt",
   "message_body",
   "metadata",
+  "preview",
   "ontology_concept_profile",
   "ontology_relation_explanation",
   "published_item_body",

package/amplify/functions/monitoring-view/schema.js

@@ -14,6 +14,14 @@ export const monitoringViewSchemaDefinitions = {
         .returns(a.json())
         .authorization((allow) => [allow.groups(editors)])
         .handler(functionHandler("monitoringView", monitoringView)),
+    // One more page of one Monitoring list (runs, routerRuns, items, emailSubmissions), after a cursor from
+    // the overview or a previous page. filter "held" lists only held email submissions, restarting from the newest.
+    monitoringPage: a
+        .query()
+        .arguments({ list: a.string().required(), cursor: a.string(), filter: a.string(), scope: a.string() })
+        .returns(a.json())
+        .authorization((allow) => [allow.groups(editors)])
+        .handler(functionHandler("monitoringView", monitoringView)),
     monitoringEmailSubmission: a
         .query()
         .arguments({ receiptId: a.string().required() })
@@ -26,6 +34,14 @@ export const monitoringViewSchemaDefinitions = {
         .returns(a.json())
         .authorization((allow) => [allow.groups(editors)])
         .handler(functionHandler("monitoringView", monitoringView)),
+    // Accept ("release") or Reject ("discard") one held email submission. The function validates the
+    // signed-in editor and that the message is routed to this publication; the receiver applies it.
+    monitoringDecideEmailSubmission: a
+        .mutation()
+        .arguments({ receiptId: a.string().required(), decision: a.string().required(), reason: a.string() })
+        .returns(a.json())
+        .authorization((allow) => [allow.groups(editors)])
+        .handler(functionHandler("monitoringView", monitoringView)),
     monitoringResolveEmailArticleLink: a
         .mutation()
         .arguments({ receiptId: a.string().required(), candidateIndex: a.integer().required() })

package/amplify/functions/monitoring-view/schema.ts

@@ -16,6 +16,14 @@ export const monitoringViewSchemaDefinitions = {
     .returns(a.json())
     .authorization((allow) => [allow.groups(editors)])
     .handler(functionHandler("monitoringView", monitoringView)),
+  // One more page of one Monitoring list (runs, routerRuns, items, emailSubmissions), after a cursor from
+  // the overview or a previous page. filter "held" lists only held email submissions, restarting from the newest.
+  monitoringPage: a
+    .query()
+    .arguments({ list: a.string().required(), cursor: a.string(), filter: a.string(), scope: a.string() })
+    .returns(a.json())
+    .authorization((allow) => [allow.groups(editors)])
+    .handler(functionHandler("monitoringView", monitoringView)),
   monitoringEmailSubmission: a
     .query()
     .arguments({ receiptId: a.string().required() })
@@ -28,6 +36,14 @@ export const monitoringViewSchemaDefinitions = {
     .returns(a.json())
     .authorization((allow) => [allow.groups(editors)])
     .handler(functionHandler("monitoringView", monitoringView)),
+  // Accept ("release") or Reject ("discard") one held email submission. The function validates the
+  // signed-in editor and that the message is routed to this publication; the receiver applies it.
+  monitoringDecideEmailSubmission: a
+    .mutation()
+    .arguments({ receiptId: a.string().required(), decision: a.string().required(), reason: a.string() })
+    .returns(a.json())
+    .authorization((allow) => [allow.groups(editors)])
+    .handler(functionHandler("monitoringView", monitoringView)),
   monitoringResolveEmailArticleLink: a
     .mutation()
     .arguments({ receiptId: a.string().required(), candidateIndex: a.integer().required() })

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

@@ -3,6 +3,7 @@ import { getAmplifyDataClientConfig } from "@aws-amplify/backend/function/runtim
 import { Amplify } from "aws-amplify";
 import { generateClient } from "aws-amplify/data";
 import type { Schema } from "../../data/resource";
+import { claimGroups } from "../../../lib/staff-groups";
 
 type DataClient = ReturnType<typeof generateClient<Schema>>;
 type DataClientErrors = Array<{ message?: string | null } | string | null> | null | undefined;
@@ -474,20 +475,11 @@ function validateJsonSchemaInput(schema: Record<string, unknown>, input: Record<
 
 function requireAdmin(event: ProcedureEvent): void {
   const claims = objectValue(event.identity?.claims);
-  const groups = [
-    ...normalizeClaimGroups(claims["cognito:groups"]),
-    ...normalizeClaimGroups(claims.groups),
-  ];
+  const groups = [...claimGroups(claims["cognito:groups"]), ...claimGroups(claims.groups)];
   if (groups.includes("admin")) return;
   throw new Error("Admin role required.");
 }
 
-function normalizeClaimGroups(value: unknown): string[] {
-  if (Array.isArray(value)) return value.map((entry) => String(entry).trim()).filter(Boolean);
-  if (typeof value === "string") return value.split(",").map((entry) => entry.trim()).filter(Boolean);
-  return [];
-}
-
 async function getDataClient(): Promise<DataClient> {
   if (!clientPromise) {
     clientPromise = (async () => {

package/amplify/functions/proposal-actions/proposals.py

@@ -92,6 +92,25 @@ def is_appsync_event(event: dict[str, Any]) -> bool:
     return "arguments" in event and ("info" in event or event_field_name(event) is not None)
 PROPOSER_AI = "ai"
 STAFF_GROUPS = frozenset({"editor", "admin"})
+
+_GROUP_SEPARATORS = re.compile(r"[\s,]+")
+
+
+def claim_groups(value: Any) -> list[str]:
+    """Copy of ``papyrus_content.staff_groups.claim_groups`` (this function ships without that package; a test keeps them equal)."""
+    if isinstance(value, (list, tuple, set, frozenset)):
+        raw = [item for item in value if isinstance(item, str)]
+    elif isinstance(value, str):
+        raw = _GROUP_SEPARATORS.split(value)
+    else:
+        return []
+    cleaned = (item.strip().strip("\"'[](){}").strip() for item in raw)
+    return [item for item in cleaned if item]
+
+
+def has_editor_rights(groups: Any) -> bool:
+    """``admin`` has every editor right: an admin who is not in the ``editor`` group is staff."""
+    return any(group.lower() in STAFF_GROUPS for group in claim_groups(groups))
 #: The only moves an operator's IAM role may make, as (from, to). Everything after the draft is an editor's decision.
 OPERATOR_TRANSITIONS = frozenset({(DRAFT, IN_STEERING), (DRAFT, DECLINED)})
 BY_STAFF, BY_OPERATOR = "staff", "operator"
@@ -140,10 +159,8 @@ def staff_subject(identity: dict[str, Any]) -> str | None:
     """The Cognito subject of an editor or admin, or ``None`` for anyone else."""
     claims = identity.get("claims") or {}
     groups = claims.get("cognito:groups") or identity.get("groups") or []
-    if isinstance(groups, str):
-        groups = [group.strip() for group in groups.strip("[]").replace(",", " ").split()]
     subject = identity.get("sub")
-    if not isinstance(subject, str) or not subject or not STAFF_GROUPS.intersection(groups):
+    if not isinstance(subject, str) or not subject or not has_editor_rights(groups):
         return None
     return subject
 

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,
   }
 }