@anthusai/papyrus 5.56.1 → 5.58.0

package/components/needs-me-feed.tsx

@@ -32,7 +32,7 @@ import { NotificationSkeleton, RecentDecisions } from "./notification-cards";
 import { FEED_GRID, FEED_SURFACE_PROPS, FeedImage, PILL, REASON_LABELS, SELECTED_RING, SourceMark } from "./reference-feed";
 import { predictionFromDecision, ReviewQueueBar, useQueueGestures, type CardPrediction, type ReviewChoice } from "./reference-review-card";
 import type { CorrectCaptureAction } from "./reference-capture-client";
-import { RatingGrid } from "./review-rating-grid";
+import { DecisionControl } from "./decision-control";
 import { useMediaQuery } from "./use-media-query";
 import { useRatingStore, type RatingController } from "./use-reference-ratings";
 import { useResolvedPapyrusTheme } from "./use-resolved-papyrus-theme";
@@ -169,30 +169,24 @@ export function NeedsMeCard({ item, now, onOpen, predictionLoading, ratings, sel
         {flag ? (
           <FlagFooter busy={rating.feedback.phase === "saving"} disabledReason={disabledReason} done={item.decisionState === "acknowledged"} error={rating.feedback.phase === "error" ? rating.feedback.message ?? null : null} onAcknowledge={() => ratings.choose(item.id, "accept")} />
         ) : (
-          <RatingGrid
+          <DecisionControl
             answer={chosen}
             decided={decided}
             disabled={Boolean(disabledReason) || locked}
             disabledReason={disabledReason}
             feedback={feedback}
+            needsReason={refLike && rating.askReason}
             note={reasonLabel ? `Reason: ${reasonLabel}` : locked ? whyLine ?? "Decided here." : null}
             onChoose={(choice) => { if (!disabledReason && !locked) ratings.choose(item.id, choice); }}
+            onReasonChange={(text) => ratings.setNote(item.id, text)}
+            onReasonCommit={() => { if (!disabledReason && !locked) ratings.commitNote(item.id); }}
             prediction={cardPrediction(item, predictionLoading)}
+            reason={rating.note ?? ""}
+            reasonRequiredFor={refLike ? "reject" : null}
             showPrediction={refLike}
+            showReason={refLike}
           />
         )}
-        {refLike && rating.askReason ? (
-          // Covers the footer rather than adding to it, so asking for a reason never pushes the cards below it down.
-          <div className="absolute inset-0 z-10 flex flex-col justify-center space-y-2 bg-[var(--feed-footer)] p-3" data-review-reasons>
-            <p className="text-xs font-medium">Reason for rejecting. Choose one to save your Reject.</p>
-            <div className="flex flex-wrap gap-1.5">
-              {REFERENCE_REJECTION_REASON_CODES.map((code) => (
-                <button className={cn(PILL, "min-h-8 bg-[var(--feed-control)] px-3 text-xs")} data-review-reason={code} key={code} onClick={() => ratings.setReason(item.id, code)} type="button">{REASON_LABELS[code]}</button>
-              ))}
-              <button className={cn(PILL, "min-h-8 px-3 text-xs text-muted-foreground")} onClick={() => ratings.cancelReason(item.id)} type="button">Cancel</button>
-            </div>
-          </div>
-        ) : null}
       </div>
     </article>
   );

package/components/needs-me-reference-detail.tsx

@@ -11,6 +11,7 @@ import type { NeedsMeEntry } from "../lib/needs-me-items";
 import { DefaultOutcome, Heading, type DetailProps } from "./needs-me-bodies";
 import { decidedChoiceOf } from "./needs-me-shared";
 import { predictionFromDecision, ReviewCard, type CardPrediction } from "./reference-review-card";
+import { ReferenceConversation } from "./reference-conversation";
 import { ReferenceCapturePanel } from "./reference-capture-panel";
 import { useReferenceCapture } from "./reference-capture-client";
 import { ReferenceSourcePreview } from "./reference-source-preview";
@@ -57,6 +58,7 @@ export function ReferenceBody(props: DetailProps & { payload: Extract<NeedsMeEnt
         titleHref={url}
       >
         {payload.decision ? <div data-reference-relevance-decision={lineageId}><ReferenceSuggestionProvenance decision={payload.decision} /></div> : null}
+        <ReferenceConversation disabledReason={disabledReason ? "Editor access is required to write messages." : null} lineageId={lineageId} referenceId={reference.id} title={referenceDisplayTitle(reference)} />
       </ReviewCard>
       <DefaultOutcome item={item} />
       {incomplete ? <p className="text-sm text-muted-foreground" data-needs-me-capture-note>The captured text looks cut off or missing. Read it below. If it is incomplete, choose Paste or correct the text and say whether the capture was complete, or rate the Reference as it is.</p> : null}

package/components/news-desk-taxonomy-client.ts

@@ -10,6 +10,7 @@ import { createLocalPreviewRealPublishedVersions, createLocalPreviewAssignments,
 import { generateClient } from "aws-amplify/data";
 import { testEditorOverrideAllowed } from "../lib/test-editor-override";
 import { downloadData, getUrl } from "aws-amplify/storage";
+import { fetchAuthSession } from "aws-amplify/auth";
 import type { Schema } from "../amplify/data/resource";
 import type { NewsDeskAppendix, NewsDeskCategoryTreeNode } from "../lib/content-types";
 import { createEmptyCategorySteeringDashboard } from "../lib/category-dashboard";
@@ -45,7 +46,20 @@ import type {
   SemanticRelationRecord,
   UserDirectoryEntry,
 } from "../lib/category-repository";
-import { relationTypeKey } from "../lib/semantic-graph";
+import { relationTypeKey, semanticStateKey, semanticVersionKey } from "../lib/semantic-graph";
+import {
+  CONVERSATION_FEED_KEY,
+  GENERAL_CONVERSATION_KIND,
+  REFERENCE_CONVERSATION_KIND,
+  conversationAnchorKey,
+  conversationMessageId,
+  conversationThreadId,
+  conversationThreadKind,
+  createWithSequenceRetry,
+  findOrCreateThread,
+  type ConversationAnchor,
+  type ConversationMessage,
+} from "../lib/conversation";
 import { legacyStageKeysToLoad, type ContentItemVersionRecord } from "../lib/content-item-lifecycle";
 import { getContentItemStageDefinitions } from "../lib/site-brand";
 import { DOCTRINE_DEFINITIONS, getCategoryDoctrineDefinitions, type DoctrineCategory } from "../lib/doctrine";
@@ -103,6 +117,23 @@ const LIST_MESSAGE_THREADS_BY_KIND_AND_UPDATED_AT_QUERY = `
   }
 `;
 
+const LIST_MESSAGE_THREADS_BY_ANCHOR_AND_UPDATED_AT_QUERY = `
+  query ListMessageThreadsByAnchorAndUpdatedAt($primaryAnchorKey: String!, $sortDirection: ModelSortDirection, $limit: Int, $nextToken: String) {
+    listMessageThreadsByAnchorAndUpdatedAt(primaryAnchorKey: $primaryAnchorKey, sortDirection: $sortDirection, limit: $limit, nextToken: $nextToken) {
+      items {
+        id threadKind status title summary primaryAnchorKind primaryAnchorId primaryAnchorLineageId primaryAnchorKey createdBySub createdByUserProfileId createdByLabel messageCount lastMessageId lastMessageAt contextDigest activeResponseMessageId responseLockOwner responseLockExpiresAt metadata createdAt updatedAt newsroomFeedKey
+      }
+      nextToken
+    }
+  }
+`;
+
+const CREATE_SEMANTIC_RELATION_MUTATION = `
+  mutation CreateSemanticRelation($input: CreateSemanticRelationInput!) {
+    createSemanticRelation(input: $input) { id }
+  }
+`;
+
 const LIST_MESSAGES_BY_THREAD_AND_SEQUENCE_QUERY = `
   query ListMessagesByThreadAndSequence($threadId: ID!, $sortDirection: ModelSortDirection, $limit: Int, $nextToken: String) {
     listMessagesByThreadAndSequence(threadId: $threadId, sortDirection: $sortDirection, limit: $limit, nextToken: $nextToken) {
@@ -271,7 +302,7 @@ const NEWSROOM_ASSIGNMENT_FEED_QUERY = `
 const NEWSROOM_REFERENCE_FEED_QUERY = `
   query ListReferencesByNewsroomFeedAndCreatedAt($newsroomFeedKey: String!, $sortDirection: ModelSortDirection, $limit: Int, $nextToken: String, $filter: ModelReferenceFilterInput) {
     listReferencesByNewsroomFeedAndCreatedAt(newsroomFeedKey: $newsroomFeedKey, sortDirection: $sortDirection, limit: $limit, nextToken: $nextToken, filter: $filter) {
-      items { id lineageId versionNumber previousVersionId versionState versionCreatedAt versionCreatedBy changeReason contentHash corpusId externalItemId title authors sourceUri storagePath mediaType byteSize sha256 sourcePublishedAt sourceUpdatedAt retrievedAt inboundCitationCount outboundCitationCount importRunId importedAt createdAt curationStatus curationStatusKey curationStatusUpdatedAt curationStatusUpdatedBy curationStatusReason newsroomFeedKey reviewedFeedKey updatedAt }
+      items { id lineageId versionNumber previousVersionId versionState versionCreatedAt versionCreatedBy changeReason contentHash corpusId externalItemId title authors sourceUri storagePath mediaType byteSize sha256 sourcePublishedAt sourceUpdatedAt retrievedAt inboundCitationCount outboundCitationCount importRunId importedAt createdAt curationStatus curationStatusKey curationStatusUpdatedAt curationStatusUpdatedBy curationStatusReason curationReasonCode curationActorKind curationSectionId curationShareable curationDelegation curationDecisionRelationId newsroomFeedKey reviewedFeedKey updatedAt }
       nextToken
     }
   }
@@ -280,7 +311,7 @@ const NEWSROOM_REFERENCE_FEED_QUERY = `
 const NEWSROOM_REFERENCE_IMPORTED_FEED_QUERY = `
   query ListReferencesByNewsroomFeedAndImportedAt($newsroomFeedKey: String!, $sortDirection: ModelSortDirection, $limit: Int, $nextToken: String, $filter: ModelReferenceFilterInput) {
     listReferencesByNewsroomFeedAndImportedAt(newsroomFeedKey: $newsroomFeedKey, sortDirection: $sortDirection, limit: $limit, nextToken: $nextToken, filter: $filter) {
-      items { id lineageId versionNumber previousVersionId versionState versionCreatedAt versionCreatedBy changeReason contentHash corpusId externalItemId title authors sourceUri storagePath mediaType byteSize sha256 sourcePublishedAt sourceUpdatedAt retrievedAt inboundCitationCount outboundCitationCount importRunId importedAt createdAt curationStatus curationStatusKey curationStatusUpdatedAt curationStatusUpdatedBy curationStatusReason newsroomFeedKey reviewedFeedKey updatedAt }
+      items { id lineageId versionNumber previousVersionId versionState versionCreatedAt versionCreatedBy changeReason contentHash corpusId externalItemId title authors sourceUri storagePath mediaType byteSize sha256 sourcePublishedAt sourceUpdatedAt retrievedAt inboundCitationCount outboundCitationCount importRunId importedAt createdAt curationStatus curationStatusKey curationStatusUpdatedAt curationStatusUpdatedBy curationStatusReason curationReasonCode curationActorKind curationSectionId curationShareable curationDelegation curationDecisionRelationId newsroomFeedKey reviewedFeedKey updatedAt }
       nextToken
     }
   }
@@ -289,7 +320,7 @@ const NEWSROOM_REFERENCE_IMPORTED_FEED_QUERY = `
 const LIST_REFERENCES_BY_CURATION_STATUS_AND_UPDATED_AT_QUERY = `
   query ListReferencesByCurationStatusAndUpdatedAt($curationStatus: String!, $sortDirection: ModelSortDirection, $limit: Int, $nextToken: String, $filter: ModelReferenceFilterInput) {
     listReferencesByCurationStatusAndUpdatedAt(curationStatus: $curationStatus, sortDirection: $sortDirection, limit: $limit, nextToken: $nextToken, filter: $filter) {
-      items { id lineageId versionNumber previousVersionId versionState versionCreatedAt versionCreatedBy changeReason contentHash corpusId externalItemId title authors sourceUri storagePath mediaType byteSize sha256 sourcePublishedAt sourceUpdatedAt retrievedAt inboundCitationCount outboundCitationCount importRunId importedAt createdAt curationStatus curationStatusKey curationStatusUpdatedAt curationStatusUpdatedBy curationStatusReason newsroomFeedKey reviewedFeedKey updatedAt }
+      items { id lineageId versionNumber previousVersionId versionState versionCreatedAt versionCreatedBy changeReason contentHash corpusId externalItemId title authors sourceUri storagePath mediaType byteSize sha256 sourcePublishedAt sourceUpdatedAt retrievedAt inboundCitationCount outboundCitationCount importRunId importedAt createdAt curationStatus curationStatusKey curationStatusUpdatedAt curationStatusUpdatedBy curationStatusReason curationReasonCode curationActorKind curationSectionId curationShareable curationDelegation curationDecisionRelationId newsroomFeedKey reviewedFeedKey updatedAt }
       nextToken
     }
   }
@@ -298,7 +329,7 @@ const LIST_REFERENCES_BY_CURATION_STATUS_AND_UPDATED_AT_QUERY = `
 const LIST_REFERENCES_BY_REVIEWED_FEED_AND_UPDATED_AT_QUERY = `
   query ListReferencesByReviewedFeedAndUpdatedAt($reviewedFeedKey: String!, $sortDirection: ModelSortDirection, $limit: Int, $nextToken: String, $filter: ModelReferenceFilterInput) {
     listReferencesByReviewedFeedAndUpdatedAt(reviewedFeedKey: $reviewedFeedKey, sortDirection: $sortDirection, limit: $limit, nextToken: $nextToken, filter: $filter) {
-      items { id lineageId versionNumber previousVersionId versionState versionCreatedAt versionCreatedBy changeReason contentHash corpusId externalItemId title authors sourceUri storagePath mediaType byteSize sha256 sourcePublishedAt sourceUpdatedAt retrievedAt inboundCitationCount outboundCitationCount importRunId importedAt createdAt curationStatus curationStatusKey curationStatusUpdatedAt curationStatusUpdatedBy curationStatusReason newsroomFeedKey reviewedFeedKey updatedAt }
+      items { id lineageId versionNumber previousVersionId versionState versionCreatedAt versionCreatedBy changeReason contentHash corpusId externalItemId title authors sourceUri storagePath mediaType byteSize sha256 sourcePublishedAt sourceUpdatedAt retrievedAt inboundCitationCount outboundCitationCount importRunId importedAt createdAt curationStatus curationStatusKey curationStatusUpdatedAt curationStatusUpdatedBy curationStatusReason curationReasonCode curationActorKind curationSectionId curationShareable curationDelegation curationDecisionRelationId newsroomFeedKey reviewedFeedKey updatedAt }
       nextToken
     }
   }
@@ -307,7 +338,7 @@ const LIST_REFERENCES_BY_REVIEWED_FEED_AND_UPDATED_AT_QUERY = `
 const LIST_REFERENCES_FALLBACK_QUERY = `
   query ListReferencesFallback($limit: Int, $nextToken: String) {
     listReferences(limit: $limit, nextToken: $nextToken) {
-      items { id lineageId versionNumber previousVersionId versionState versionCreatedAt versionCreatedBy changeReason contentHash corpusId externalItemId title authors sourceUri storagePath mediaType byteSize sha256 sourcePublishedAt sourceUpdatedAt retrievedAt inboundCitationCount outboundCitationCount importRunId importedAt createdAt curationStatus curationStatusKey curationStatusUpdatedAt curationStatusUpdatedBy curationStatusReason newsroomFeedKey reviewedFeedKey updatedAt }
+      items { id lineageId versionNumber previousVersionId versionState versionCreatedAt versionCreatedBy changeReason contentHash corpusId externalItemId title authors sourceUri storagePath mediaType byteSize sha256 sourcePublishedAt sourceUpdatedAt retrievedAt inboundCitationCount outboundCitationCount importRunId importedAt createdAt curationStatus curationStatusKey curationStatusUpdatedAt curationStatusUpdatedBy curationStatusReason curationReasonCode curationActorKind curationSectionId curationShareable curationDelegation curationDecisionRelationId newsroomFeedKey reviewedFeedKey updatedAt }
       nextToken
     }
   }
@@ -440,7 +471,7 @@ const MODEL_ATTACHMENTS_BY_OWNER_QUERY = `
 
 /** Matches Reference model fields in amplify/data/resource.ts (no metadata on Reference). */
 const REFERENCE_RECORD_GRAPHQL_FIELDS =
-  "id lineageId versionNumber previousVersionId versionState versionCreatedAt versionCreatedBy changeReason contentHash corpusId externalItemId title authors sourceUri storagePath mediaType byteSize sha256 sourcePublishedAt sourceUpdatedAt retrievedAt inboundCitationCount outboundCitationCount importRunId importedAt createdAt curationStatus curationStatusKey curationStatusUpdatedAt curationStatusUpdatedBy curationStatusReason newsroomFeedKey reviewedFeedKey updatedAt";
+  "id lineageId versionNumber previousVersionId versionState versionCreatedAt versionCreatedBy changeReason contentHash corpusId externalItemId title authors sourceUri storagePath mediaType byteSize sha256 sourcePublishedAt sourceUpdatedAt retrievedAt inboundCitationCount outboundCitationCount importRunId importedAt createdAt curationStatus curationStatusKey curationStatusUpdatedAt curationStatusUpdatedBy curationStatusReason curationReasonCode curationActorKind curationSectionId curationShareable curationDelegation curationDecisionRelationId newsroomFeedKey reviewedFeedKey updatedAt";
 
 const LIST_REFERENCES_BY_LINEAGE_AND_VERSION_QUERY = `
   query ListReferencesByLineageAndVersion($lineageId: ID!, $limit: Int, $nextToken: String) {
@@ -1388,6 +1419,43 @@ export async function createSectionForumThreadRecord(input: {
   return { created: true, thread: normalizeThreadRecord(response.createMessageThread ?? thread) };
 }
 
+/**
+ * Appends one Message to a thread: the next sequence number, the Message, then the thread's count and last Message. The Message id
+ * derives from the sequence number, so a create that loses a race for the number collides and retries with the next one.
+ */
+async function appendMessageToThread(thread: MessageThreadRecord, build: (sequenceNumber: number, now: string) => MessageRecord): Promise<{ thread: MessageThreadRecord; message: MessageRecord }> {
+  const threadId = thread.id;
+  let now = new Date().toISOString();
+  let built: MessageRecord | null = null;
+  const { created } = await createWithSequenceRetry({
+    list: () => listMessagesByThreadId(threadId, 1000),
+    create: (sequenceNumber) => {
+      now = new Date().toISOString();
+      // `createdAt` is part of the composite sort key of messagesByResponseTargetStatusCreatedAt, so AppSync refuses a Message that
+      // sets it without `responseStatus`. A person's message waits on no responder: COMPLETED, as the Python message contract writes.
+      built = { responseStatus: "COMPLETED", ...build(sequenceNumber, now) };
+      return runGraphql<{ createMessage?: MessageRecord | null }>(CREATE_MESSAGE_MUTATION, { input: built });
+    },
+  });
+  const createdMessage = normalizeMessageRecord(created.createMessage ?? built!);
+  const updated = await runGraphql<{ updateMessageThread?: MessageThreadRecord | null }>(
+    UPDATE_MESSAGE_THREAD_MUTATION,
+    {
+      input: {
+        id: threadId,
+        messageCount: (thread.messageCount ?? 0) + 1,
+        lastMessageId: createdMessage.id,
+        lastMessageAt: createdMessage.createdAt,
+        updatedAt: now,
+      },
+    },
+  );
+  return {
+    thread: normalizeThreadRecord(updated.updateMessageThread ?? { ...thread, updatedAt: now }),
+    message: createdMessage,
+  };
+}
+
 export async function appendForumThreadMessageRecord(input: {
   threadId: string;
   summary: string;
@@ -1404,11 +1472,8 @@ export async function appendForumThreadMessageRecord(input: {
   if (!summary) throw new Error("summary is required");
   if (!content) throw new Error("content is required");
   const thread = await getMessageThreadRecord(threadId);
-  const existing = await listMessagesByThreadId(threadId, 1000);
-  const nextSequence = Math.max(0, ...existing.map((message) => Number(message.sequenceNumber || 0))) + 1;
-  const now = new Date().toISOString();
-  const message: MessageRecord = {
-    id: `message-forum-${safeForumId(threadId)}-${String(nextSequence).padStart(4, "0")}`,
+  return appendMessageToThread(thread, (sequenceNumber, now) => ({
+    id: `message-forum-${safeForumId(threadId)}-${String(sequenceNumber).padStart(4, "0")}`,
     messageKind: "forum_post",
     messageDomain: "edition_coordination",
     status: "active",
@@ -1417,7 +1482,7 @@ export async function appendForumThreadMessageRecord(input: {
     authorLabel: input.authorLabel?.trim() || "editor",
     threadId,
     parentMessageId: input.parentMessageId?.trim() || null,
-    sequenceNumber: nextSequence,
+    sequenceNumber,
     role: input.role || "human",
     messageType: "forum_message",
     content,
@@ -1425,28 +1490,243 @@ export async function appendForumThreadMessageRecord(input: {
     createdAt: now,
     updatedAt: now,
     newsroomFeedKey: "messages",
-  };
-  const created = await runGraphql<{ createMessage?: MessageRecord | null }>(
-    CREATE_MESSAGE_MUTATION,
-    { input: message },
-  );
-  const createdMessage = normalizeMessageRecord(created.createMessage ?? message);
-  const updated = await runGraphql<{ updateMessageThread?: MessageThreadRecord | null }>(
-    UPDATE_MESSAGE_THREAD_MUTATION,
-    {
-      input: {
-        id: threadId,
-        messageCount: (thread.messageCount ?? 0) + 1,
-        lastMessageId: createdMessage.id,
-        lastMessageAt: createdMessage.createdAt,
+  }));
+}
+
+type ConversationAuthor = { sub: string | null; label: string };
+
+async function currentConversationAuthor(): Promise<ConversationAuthor> {
+  const snapshot = await loadReaderSessionSnapshot();
+  let sub: string | null = null;
+  try {
+    const session = await fetchAuthSession();
+    const claim = session.tokens?.idToken?.payload?.sub ?? session.tokens?.accessToken?.payload?.sub;
+    sub = typeof claim === "string" && claim ? claim : null;
+  } catch {
+    sub = null;
+  }
+  return { sub, label: snapshot.auth.status === "signedIn" ? snapshot.auth.label : "editor" };
+}
+
+async function findConversationThread(anchorKey: string): Promise<MessageThreadRecord | null> {
+  type Response = { listMessageThreadsByAnchorAndUpdatedAt?: { items?: Array<MessageThreadRecord | null> | null } | null };
+  const response = await runGraphql<Response>(LIST_MESSAGE_THREADS_BY_ANCHOR_AND_UPDATED_AT_QUERY, {
+    primaryAnchorKey: anchorKey,
+    sortDirection: "DESC",
+    limit: 10,
+  });
+  const found = (response.listMessageThreadsByAnchorAndUpdatedAt?.items ?? []).filter(Boolean) as MessageThreadRecord[];
+  const thread = found.find((entry) => entry.status !== "deleted") ?? null;
+  return thread ? normalizeThreadRecord(thread) : null;
+}
+
+/** The one conversation for an anchor: found by its anchor key, created when there is none. Concurrent first posts share the thread. */
+export async function ensureConversationThread(anchor: ConversationAnchor, author?: ConversationAuthor): Promise<MessageThreadRecord> {
+  const anchorKey = conversationAnchorKey(anchor);
+  if (!anchorKey) throw new Error("An unattached conversation starts its own thread.");
+  return findOrCreateThread({
+    find: () => findConversationThread(anchorKey),
+    create: async () => {
+      const now = new Date().toISOString();
+      const lineageId = anchor.lineageId!.trim();
+      const thread: MessageThreadRecord = {
+        id: conversationThreadId(anchor),
+        threadKind: conversationThreadKind(anchor),
+        status: "active",
+        title: anchor.title?.trim() || lineageId,
+        primaryAnchorKind: anchor.kind,
+        primaryAnchorId: lineageId,
+        primaryAnchorLineageId: lineageId,
+        primaryAnchorKey: anchorKey,
+        createdBySub: author?.sub ?? null,
+        createdByLabel: author?.label ?? "editor",
+        messageCount: 0,
+        lastMessageId: null,
+        lastMessageAt: null,
+        metadata: JSON.stringify({ anchorKind: anchor.kind, anchorLineageId: lineageId }),
+        createdAt: now,
         updatedAt: now,
-      },
+        newsroomFeedKey: CONVERSATION_FEED_KEY,
+      };
+      const response = await runGraphql<{ createMessageThread?: MessageThreadRecord | null }>(CREATE_MESSAGE_THREAD_MUTATION, { input: thread });
+      return normalizeThreadRecord(response.createMessageThread ?? thread);
     },
-  );
+  });
+}
+
+function toConversationMessage(record: MessageRecord): ConversationMessage {
   return {
-    thread: normalizeThreadRecord(updated.updateMessageThread ?? { ...thread, updatedAt: now }),
-    message: createdMessage,
+    id: record.id,
+    parentMessageId: record.parentMessageId ?? null,
+    authorLabel: record.authorLabel ?? "",
+    content: record.content ?? record.body ?? "",
+    createdAt: record.createdAt,
+    sequenceNumber: Number(record.sequenceNumber ?? 0),
+  };
+}
+
+/** Every Message in the anchor's conversation, oldest first. An anchor with no conversation yet has none. */
+export async function loadConversationMessages(anchor: ConversationAnchor): Promise<ConversationMessage[]> {
+  const anchorKey = conversationAnchorKey(anchor);
+  if (!anchorKey) return [];
+  const thread = await findConversationThread(anchorKey);
+  if (!thread) return [];
+  const records = await listMessagesByThreadId(thread.id, 500);
+  return records.filter((record) => record.status !== "deleted").map(toConversationMessage);
+}
+
+/** How many Messages each Reference has, from the Reference conversation threads alone (no query per card). Keyed by lineage id. */
+export async function loadReferenceConversationCounts(): Promise<Map<string, number>> {
+  const threads = await listMessageThreadsByKind(REFERENCE_CONVERSATION_KIND, 500);
+  const counts = new Map<string, number>();
+  for (const thread of threads) {
+    const lineageId = thread.primaryAnchorLineageId;
+    if (lineageId && thread.status !== "deleted" && (thread.messageCount ?? 0) > 0) counts.set(lineageId, thread.messageCount ?? 0);
+  }
+  return counts;
+}
+
+/**
+ * Writes a Message into the anchor's conversation (finding or creating the thread), and a `comment` relation from the Message to
+ * the Reference or Item so the thing's own detail can find it. The relation is secondary: if it fails the Message is still saved.
+ */
+export async function appendConversationMessage(input: {
+  anchor: ConversationAnchor;
+  body: string;
+  parentMessageId?: string | null;
+  /** The conversation to write into, when the caller already holds it (the Messages page). Without it the anchor finds or creates it. */
+  thread?: MessageThreadRecord;
+}): Promise<{ message: ConversationMessage; thread: MessageThreadRecord; relationError: string | null }> {
+  const content = String(input.body || "").trim();
+  if (!content) throw new Error("Write something to post.");
+  const author = await currentConversationAuthor();
+  const thread = input.thread ?? await ensureConversationThread(input.anchor, author);
+  const result = await appendMessageToThread(thread, (sequenceNumber, now) => ({
+    id: conversationMessageId(thread.id, sequenceNumber),
+    messageKind: "comment",
+    messageDomain: "commentary",
+    status: "active",
+    summary: content.slice(0, 120),
+    source: "newsroom.conversation",
+    authorSub: author.sub,
+    authorLabel: author.label,
+    threadId: thread.id,
+    parentMessageId: input.parentMessageId?.trim() || null,
+    sequenceNumber,
+    role: "human",
+    messageType: "comment",
+    content,
+    metadata: JSON.stringify({ messageKind: "comment", anchorKey: conversationAnchorKey(input.anchor) }),
+    createdAt: now,
+    updatedAt: now,
+    newsroomFeedKey: CONVERSATION_FEED_KEY,
+  }));
+  let relationError: string | null = null;
+  if (input.anchor.kind !== "none") {
+    try {
+      await createCommentRelation(result.message, input.anchor);
+    } catch (error) {
+      relationError = error instanceof Error ? error.message : "The link to the Reference could not be saved.";
+    }
+  }
+  return { message: toConversationMessage(result.message), thread: result.thread, relationError };
+}
+
+/** One page of conversation threads of a kind, newest activity first. */
+export async function loadConversationThreadPage(threadKind: string, nextToken: string | null, limit = 20): Promise<{ items: MessageThreadRecord[]; nextToken: string | null }> {
+  type ThreadConnectionResponse = { listMessageThreadsByKindAndUpdatedAt?: { items?: Array<MessageThreadRecord | null> | null; nextToken?: string | null } | null };
+  const response = await runGraphql<ThreadConnectionResponse>(LIST_MESSAGE_THREADS_BY_KIND_AND_UPDATED_AT_QUERY, { threadKind, sortDirection: "DESC", limit, nextToken });
+  const connection = response.listMessageThreadsByKindAndUpdatedAt;
+  const items = ((connection?.items ?? []).filter(Boolean) as MessageThreadRecord[]).map(normalizeThreadRecord).filter((thread) => thread.status !== "deleted");
+  return { items, nextToken: connection?.nextToken ?? null };
+}
+
+/** Every Message in a conversation thread, oldest first. */
+export async function loadConversationThreadMessages(threadId: string): Promise<ConversationMessage[]> {
+  const records = await listMessagesByThreadId(threadId, 500);
+  return records.filter((record) => record.status !== "deleted").map(toConversationMessage);
+}
+
+/** Starts a conversation about nothing but itself: its own thread, and its first Message. */
+export async function startUnattachedConversation(body: string): Promise<{ message: ConversationMessage; thread: MessageThreadRecord }> {
+  const content = String(body || "").trim();
+  if (!content) throw new Error("Write something to post.");
+  const author = await currentConversationAuthor();
+  const now = new Date().toISOString();
+  const id = `message-thread-conversation-new-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  const thread: MessageThreadRecord = {
+    id,
+    threadKind: GENERAL_CONVERSATION_KIND,
+    status: "active",
+    title: content.split("\n")[0].slice(0, 80),
+    createdBySub: author.sub,
+    createdByLabel: author.label,
+    messageCount: 0,
+    lastMessageId: null,
+    lastMessageAt: null,
+    metadata: JSON.stringify({ anchorKind: "none" }),
+    createdAt: now,
+    updatedAt: now,
+    newsroomFeedKey: CONVERSATION_FEED_KEY,
   };
+  const created = await runGraphql<{ createMessageThread?: MessageThreadRecord | null }>(CREATE_MESSAGE_THREAD_MUTATION, { input: thread });
+  const saved = normalizeThreadRecord(created.createMessageThread ?? thread);
+  const result = await appendConversationMessage({ anchor: { kind: "none" }, body: content, thread: saved });
+  return { message: result.message, thread: result.thread };
+}
+
+/** The title and editorial stage of each Story, by lineage id. A Story that cannot be read has no entry. */
+export async function loadStoryHeaders(lineageIds: string[]): Promise<Map<string, { title: string; stage: string | null }>> {
+  const headers = new Map<string, { title: string; stage: string | null }>();
+  await Promise.all([...new Set(lineageIds)].map(async (lineageId) => {
+    try {
+      type Response = { listItemsByLineageAndVersion?: { items?: Array<{ versionNumber?: number | null; headline?: string | null; title?: string | null; stage?: string | null } | null> | null } | null };
+      const response = await runGraphql<Response>(`query StoryHeader($lineageId: ID!) { listItemsByLineageAndVersion(lineageId: $lineageId, limit: 50) { items { versionNumber headline title stage } } }`, { lineageId });
+      const items = (response.listItemsByLineageAndVersion?.items ?? []).filter(Boolean) as Array<{ versionNumber?: number | null; headline?: string | null; title?: string | null; stage?: string | null }>;
+      const newest = items.sort((left, right) => (right.versionNumber ?? 0) - (left.versionNumber ?? 0))[0];
+      const title = newest?.headline || newest?.title;
+      if (title) headers.set(lineageId, { title, stage: newest?.stage ?? null });
+    } catch { /* a Story that cannot be read keeps the title the thread was started with */ }
+  }));
+  return headers;
+}
+
+async function createCommentRelation(message: MessageRecord, anchor: ConversationAnchor): Promise<void> {
+  if (anchor.kind === "none") return;
+  const lineageId = anchor.lineageId.trim();
+  const objectId = anchor.id?.trim() || lineageId;
+  const now = message.createdAt;
+  await runGraphql(CREATE_SEMANTIC_RELATION_MUTATION, {
+    input: {
+      id: `semantic-relation-${message.id}-comment`,
+      relationState: "current",
+      predicate: "comment",
+      relationTypeId: "semantic-relation-type-comment",
+      relationTypeKey: "comment",
+      relationDomain: "commentary",
+      subjectKind: "message",
+      subjectId: message.id,
+      subjectLineageId: message.id,
+      subjectVersionNumber: 1,
+      objectKind: anchor.kind,
+      objectId,
+      objectLineageId: lineageId,
+      subjectStateKey: semanticStateKey("message", message.id),
+      objectStateKey: semanticStateKey(anchor.kind, lineageId),
+      objectSubjectStateKey: `${semanticStateKey(anchor.kind, lineageId)}#message`,
+      predicateObjectStateKey: `comment#${semanticStateKey(anchor.kind, lineageId)}`,
+      subjectVersionKey: semanticVersionKey("message", message.id),
+      objectVersionKey: semanticVersionKey(anchor.kind, objectId),
+      score: 1,
+      rank: 1,
+      reviewRecommended: false,
+      importedAt: now,
+      createdAt: now,
+      updatedAt: now,
+      newsroomFeedKey: "semanticRelations",
+      metadata: JSON.stringify({ kind: "conversation.comment", messageKind: "comment" }),
+    },
+  });
 }
 
 export async function deleteForumThreadMessageRecord(input: {
@@ -1627,10 +1907,17 @@ async function runGraphql<T extends Record<string, unknown>>(
   const client = generateClient<Schema>() as unknown as {
     graphql: (options: Record<string, unknown>) => Promise<{ data?: T | null; errors?: unknown[] | null }>;
   };
+  // The Amplify client rejects with the raw `{ data, errors }` response when the API returns errors; turn that into an
+  // Error carrying the API's own words, so a refusal is said in words instead of as an unknown failure.
   const response = await client.graphql({
     query,
     variables,
     authMode: USER_POOL_AUTH_MODE,
+  }).catch((failure: unknown) => {
+    if (failure && typeof failure === "object" && Array.isArray((failure as { errors?: unknown }).errors)) {
+      assertNoGraphQLErrors((failure as { errors: unknown[] }).errors);
+    }
+    throw failure;
   });
   assertNoGraphQLErrors(response.errors);
   return (response.data ?? {}) as T;
@@ -1866,17 +2153,15 @@ export async function loadEditorReferenceReviewDetails(lineageId: string) {
   configureAmplifyClient();
   const testMock = getTestEditorNewsroomMock();
   return loadReferenceReviewDetails(lineageId, {
-    relations: async (direction) => {
+    relations: async () => {
       if (testMock?.semanticRelations) return testMock.semanticRelations;
       return loadSemanticRelationsByState({
-        field: direction === "outgoing" ? "listSemanticRelationsBySubjectState" : "listSemanticRelationsByObjectState",
-        keyName: direction === "outgoing" ? "subjectStateKey" : "objectStateKey",
+        field: "listSemanticRelationsBySubjectState",
+        keyName: "subjectStateKey",
         keyValue: `reference#${lineageId}#current`,
-        query: direction === "outgoing" ? LIST_SEMANTIC_RELATIONS_BY_SUBJECT_STATE_QUERY : LIST_SEMANTIC_RELATIONS_BY_OBJECT_STATE_QUERY,
+        query: LIST_SEMANTIC_RELATIONS_BY_SUBJECT_STATE_QUERY,
       });
     },
-    message: async (id) => testMock?.messages ? testMock.messages.find((message) => message.id === id) ?? null : getMessageRecordById(id),
-    payloads: (id) => loadModelPayloadsForOwner("message", id, ["metadata"]),
   });
 }
 

package/components/newsroom-organizer.css

@@ -401,11 +401,29 @@ body:has(.newsroom-organizer)>[data-staging-banner]{flex-shrink:0}
   --feed-radius-lg: 10px;
   --feed-radius-md: 8px;
   --feed-radius-pill: 8px;
+  /* Verdict tones for the rating grid. Hue is never the only signal: the cell also carries a CircleCheck or
+     CircleX and the word Match or Miss. Named here, in the feed layer, because the component must not hold
+     literal palette values and because Tailwind's dark: variant (.dark *) never fires in this app. */
+  --feed-verdict-match-tint: #05966933;
+  --feed-verdict-match-ink: #064e3b;
+  --feed-verdict-match-fill: #059669;
+  --feed-verdict-miss-tint: #dc262633;
+  --feed-verdict-miss-ink: #7f1d1d;
+  --feed-verdict-miss-fill: #dc2626;
+  /* The quiet step for an unpredicted cell and a switched-off button. */
+  --feed-quiet: 0.6;
 }
 [data-kanbus-theme][data-color-mode="dark"] [data-feed-surface], [data-kanbus-theme][data-color-mode="dark"][data-feed-surface] {
   --feed-card: color-mix(in oklab, var(--kb-theme-paper) 94%, var(--kb-theme-ink));
   --feed-footer: color-mix(in oklab, var(--kb-theme-paper) 90%, var(--kb-theme-ink));
   --feed-control: color-mix(in oklab, var(--kb-theme-paper) 80%, var(--kb-theme-ink));
+  /* Dark verdicts lift toward the tint rather than down into it, so the ink reads on a dark card. */
+  --feed-verdict-match-tint: #34d39933;
+  --feed-verdict-match-ink: #d1fae5;
+  --feed-verdict-match-fill: #34d399;
+  --feed-verdict-miss-tint: #f8717133;
+  --feed-verdict-miss-ink: #fee2e2;
+  --feed-verdict-miss-fill: #f87171;
 }
 
 /* Borderless detail pane, Add panel and mobile sheet ([data-feed-flat]): no border, rule or box anywhere inside. Regions are told apart
@@ -426,6 +444,12 @@ body:has(.newsroom-organizer)>[data-staging-banner]{flex-shrink:0}
 }
 [data-feed-flat][data-feed-flat][data-feed-flat][data-feed-flat][data-feed-flat][data-feed-flat] [data-cyclotron-choice] { border-radius: var(--feed-radius-pill) !important; }
 [data-feed-flat][data-feed-flat][data-feed-flat][data-feed-flat][data-feed-flat][data-feed-flat] [data-review-queue-bar] { background: var(--feed-footer) !important; }
+/* The decision control keeps one corner across its segments and its reason field, and its predicted segment
+   keeps its tones apart: the flat rules above give every unpressed button the same control fill, which would
+   leave the predicted side and an untouched side looking identical. */
+[data-feed-flat][data-feed-flat][data-feed-flat][data-feed-flat][data-feed-flat][data-feed-flat][data-feed-flat][data-feed-flat] [data-decision-control] :is(button, textarea) { border-radius: var(--feed-radius-md) !important; }
+[data-feed-flat][data-feed-flat][data-feed-flat][data-feed-flat][data-feed-flat][data-feed-flat][data-feed-flat][data-feed-flat] [data-decision-control] [data-review-choice][data-state="idle"] { background: color-mix(in oklab, var(--feed-control) 45%, transparent) !important; }
+
 /* The rating grid keeps its own rounded rectangles in the borderless panes (not the pill shape the flat rules give other buttons). */
 [data-feed-flat][data-feed-flat][data-feed-flat][data-feed-flat][data-feed-flat][data-feed-flat][data-feed-flat][data-feed-flat] [data-rating-grid] :is(button, [data-cyclotron-choice]) { border-radius: var(--feed-radius-md) !important; }
 

package/components/newsroom-references-view.tsx

@@ -50,6 +50,8 @@ import { FEED_SURFACE_PROPS, FEED_SURFACE_STYLE, ReferenceFeed } from "./referen
 import { ReferenceCapturePanel } from "./reference-capture-panel";
 import { useReferenceCapture, type CorrectCaptureAction } from "./reference-capture-client";
 import { useRatingStore, type RatingController } from "./use-reference-ratings";
+import { ReferenceConversation } from "./reference-conversation";
+import { useReferenceMessageCounts } from "./use-conversation";
 import { captureStatusesByLineage } from "../lib/reference-capture";
 import { applyFeedOrderSnapshot, partitionReferenceFeed, takeFeedOrderSnapshot, type FeedOrderSnapshot, type ReferenceFeedTabKey } from "../lib/reference-feed-ranking";
 import { referenceDek, referencePreviewsByLineage, type ReferencePreview } from "../lib/reference-preview";
@@ -200,6 +202,7 @@ function ReferenceDetailPanel({
   decision,
   demo = false,
   disabled,
+  onMessageCount,
   onReview,
   predictionState = "ready",
   reviewReason,
@@ -223,6 +226,7 @@ function ReferenceDetailPanel({
   decision?: RelevanceDecisionView;
   demo?: boolean;
   disabled?: boolean;
+  onMessageCount?: (lineageId: string, count: number) => void;
   onRelevanceReview?: (curation: RelevanceCuration) => Promise<void> | void;
   onReview: (action: ReferenceCurationAction, options?: ReferenceReviewOptions) => Promise<void> | void;
   predictionState?: PredictionState;
@@ -308,6 +312,7 @@ function ReferenceDetailPanel({
             </details>
           ) : null}
           {delegated ? <DelegatedCurationNote delegated={delegated} referenceLineageId={lineageId} /> : countsAsTrainingLabel ? <CountsAsTrainingLabelNote referenceLineageId={lineageId} /> : null}
+          <ReferenceConversation disabledReason={disabled ? "Editor access is required to write messages." : null} lineageId={lineageId} onCount={onMessageCount} referenceId={reference.id} title={referenceDisplayTitle(reference)} />
         </ReviewCard>
 
         <Separator />
@@ -445,6 +450,7 @@ export function NewsroomReferencesView({
   const [view, setView] = useState<ReferenceView>("feed");
   const [addOpen, setAddOpen] = useState(false);
   const [feedTab, setFeedTab] = useState<ReferenceFeedTabKey>("feed");
+  const { counts: messageCounts, setCount: setMessageCount } = useReferenceMessageCounts(!loading);
   const [visitRated, setVisitRated] = useState<ReadonlySet<string>>(() => new Set());
   const [mountedAt] = useState(() => Date.now());
   const markVisitRated = useCallback((lineageId: string) => {
@@ -774,6 +780,7 @@ export function NewsroomReferencesView({
               <ReferenceFeed
                 disabledReason={feedDisabledReason}
                 loading={previewSkeleton || (loading && !references.length)}
+                messageCounts={messageCounts}
                 now={mountedAt}
                 onOpen={selectReference}
                 onRate={rateFromFeed}
@@ -909,6 +916,7 @@ export function NewsroomReferencesView({
               decision={decisions?.get(referenceLineageId(selectedReference))}
               demo={demo}
               disabled={disabled}
+              onMessageCount={setMessageCount}
               onRelevanceReview={onRelevanceReview ? (curation) => onRelevanceReview(selectedReference, curation) : undefined}
               onReview={runReview}
               sectionAgreement={sectionAgreement}
@@ -952,6 +960,7 @@ export function NewsroomReferencesView({
                   demo={demo}
                   disabled={disabled}
                   onClose={closeDetail}
+                  onMessageCount={setMessageCount}
                   onRelevanceReview={onRelevanceReview ? (curation) => onRelevanceReview(selectedReference, curation) : undefined}
                   onReview={runReview}
                   sectionAgreement={sectionAgreement}