@anthusai/papyrus 5.57.0 → 5.59.0

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({
@@ -1586,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) => [
@@ -1600,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"]),
@@ -1687,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(),
@@ -1721,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(),
@@ -2234,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,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,
   }
 }
 

package/components/conversation-context.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import { createContext, useContext, type ReactNode } from "react";
-import type { ConversationAnchor, ConversationMessage } from "../lib/conversation";
+import { NO_VIEWER, canDeleteMessage, canEditMessage, type ConversationAnchor, type ConversationMessage, type ConversationViewer } from "../lib/conversation";
 
 /**
  * Where conversations are read and written. The newsroom provides the network one; a demo or a test provides the in-memory one. A
@@ -14,6 +14,11 @@ export type ConversationStore = {
   append: (input: { anchor: ConversationAnchor; body: string; parentMessageId: string | null }) => Promise<ConversationMessage>;
   /** Message counts by Reference lineage, for the feed cards. */
   counts: () => Promise<Map<string, number>>;
+  /** Who is looking, and display names by profile id: what Edit, Delete and the author's name are decided from. */
+  viewer: () => Promise<ConversationViewer>;
+  authors: (profileIds: string[]) => Promise<Map<string, string>>;
+  edit: (messageId: string, body: string) => Promise<ConversationMessage>;
+  remove: (messageId: string, moderate: boolean) => Promise<ConversationMessage>;
 };
 
 const ConversationStoreContext = createContext<ConversationStore | null>(null);
@@ -27,11 +32,32 @@ export function useConversationStore(): ConversationStore | null {
 }
 
 /** A store that keeps everything in memory: the demo newsroom, and the tests. */
-export function createMemoryConversationStore(authorLabel: string, seed: Record<string, ConversationMessage[]> = {}): ConversationStore {
+export function createMemoryConversationStore(authorLabel: string, seed: Record<string, ConversationMessage[]> = {}, who: { viewer?: ConversationViewer; profiles?: Record<string, string> } = {}): ConversationStore {
+  const viewer = who.viewer ?? NO_VIEWER;
   const byAnchor = new Map<string, ConversationMessage[]>(Object.entries(seed));
   const keyOf = (anchor: ConversationAnchor) => `${anchor.kind}#${anchor.lineageId ?? ""}`;
+  const change = (messageId: string, apply: (message: ConversationMessage) => ConversationMessage) => {
+    for (const [key, list] of byAnchor) {
+      const found = list.find((message) => message.id === messageId);
+      if (!found) continue;
+      const changed = apply(found);
+      byAnchor.set(key, list.map((message) => (message.id === messageId ? changed : message)));
+      return changed;
+    }
+    throw new Error("That message is not here.");
+  };
   return {
     authorLabel,
+    viewer: async () => viewer,
+    authors: async (ids) => new Map(ids.filter((id) => who.profiles?.[id]).map((id) => [id, who.profiles![id]])),
+    edit: async (messageId, body) => change(messageId, (message) => {
+      if (!canEditMessage(viewer, message)) throw new Error("Only the author can edit a message.");
+      return { ...message, content: body.trim(), editedAt: new Date().toISOString() };
+    }),
+    remove: async (messageId) => change(messageId, (message) => {
+      if (!canDeleteMessage(viewer, message)) throw new Error("Only the author or an admin can delete a message.");
+      return { ...message, content: "", deleted: true, deletedAt: new Date().toISOString() };
+    }),
     load: async (anchor) => [...(byAnchor.get(keyOf(anchor)) ?? [])],
     append: async ({ anchor, body, parentMessageId }) => {
       const list = byAnchor.get(keyOf(anchor)) ?? [];
@@ -40,6 +66,7 @@ export function createMemoryConversationStore(authorLabel: string, seed: Record<
         id: `message-memory-${sequenceNumber}-${list.length}`,
         parentMessageId,
         authorLabel,
+        authorSub: viewer.sub,
         content: body.trim(),
         createdAt: new Date().toISOString(),
         sequenceNumber,

package/components/conversation-provider.tsx

@@ -2,7 +2,7 @@
 
 import { useMemo, type ReactNode } from "react";
 import { ConversationStoreProvider, createMemoryConversationStore, type ConversationStore } from "./conversation-context";
-import { appendConversationMessage, loadConversationMessages, loadReferenceConversationCounts } from "./news-desk-taxonomy-client";
+import { appendConversationMessage, deleteConversationMessage, editConversationMessage, loadConversationMessages, loadConversationViewer, loadReferenceConversationCounts, loadUserProfileNames } from "./news-desk-taxonomy-client";
 
 function networkConversationStore(authorLabel: string): ConversationStore {
   return {
@@ -10,6 +10,10 @@ function networkConversationStore(authorLabel: string): ConversationStore {
     load: loadConversationMessages,
     append: async ({ anchor, body, parentMessageId }) => (await appendConversationMessage({ anchor, body, parentMessageId })).message,
     counts: loadReferenceConversationCounts,
+    viewer: loadConversationViewer,
+    authors: loadUserProfileNames,
+    edit: editConversationMessage,
+    remove: (messageId, moderate) => deleteConversationMessage(messageId, moderate),
   };
 }