@anthusai/papyrus 5.43.0-next.4 → 5.43.0-next.41

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

@@ -0,0 +1,79 @@
+"use client";
+
+import { referenceDisplayTitle, referenceLineageId, formatReferenceListDate } from "../lib/newsroom-references";
+import { referenceMetadataField } from "../lib/reference-display";
+import { referenceDek, referencePreviewsByLineage } from "../lib/reference-preview";
+import { DEFAULT_TEASER_WORDS } from "../lib/reference-capture";
+import { isAutoAccepted, referenceReasonCode, normalizeReferenceCurationStatus } from "../lib/reference-policy";
+import { AutoAcceptedBadge } from "./auto-accepted-badge";
+import type { ReferenceRecord } from "../lib/category-repository";
+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";
+import { ReferenceSuggestionProvenance } from "./reference-cyclotron-suggestion";
+import { useReferencePreviewAttachments } from "./use-reference-preview-attachments";
+
+function cardPrediction(item: NeedsMeEntry, predictionLoading: boolean): CardPrediction {
+  if (item.payload.kind === "reference" && item.payload.decision) return predictionFromDecision(item.payload.decision);
+  return predictionLoading ? { state: "loading" } : { state: "none" };
+}
+
+/**
+ * A Reference, or a Reference whose capture may be cut off: the References detail's own pieces, in the same order. What the item is
+ * comes first (title, blurb, link, badges, summary), then the rating, then what was captured and how well.
+ */
+export function ReferenceBody(props: DetailProps & { payload: Extract<NeedsMeEntry["payload"], { kind: "reference" }> }) {
+  const { item, payload, ratings, disabledReason, attachments, captureTeaserLine = DEFAULT_TEASER_WORDS, onCorrectCapture, predictionLoading } = props;
+  const reference: ReferenceRecord = payload.reference;
+  const lineageId = referenceLineageId(reference);
+  const status = normalizeReferenceCurationStatus(reference.curationStatus);
+  const previewAttachments = useReferencePreviewAttachments(reference, attachments);
+  const capture = useReferenceCapture(reference, previewAttachments, captureTeaserLine, onCorrectCapture);
+  const url = reference.sourceUri?.trim() && /^https?:\/\//i.test(reference.sourceUri.trim()) ? reference.sourceUri.trim() : null;
+  const summary = capture.summary ?? referenceMetadataField(null, reference.metadata, "summary");
+  const dek = referenceDek(reference, referencePreviewsByLineage(previewAttachments).get(lineageId));
+  const incomplete = item.type === "incomplete_capture";
+  const auto = isAutoAccepted(reference);
+  return (
+    <div className="space-y-4" data-reference-curation-status={status} data-news-desk-reference-detail={lineageId}>
+      <ReviewCard
+        decided={decidedChoiceOf(item)}
+        disabledReason={disabledReason}
+        initialNote={status === "pending" || auto ? "" : reference.curationStatusReason ?? ""}
+        initialReason={referenceReasonCode(reference) ?? null}
+        dek={dek}
+        itemId={item.id}
+        meta={<><Heading item={item} />{auto ? <AutoAcceptedBadge actor={reference.curationStatusUpdatedBy} reason={reference.curationStatusReason} /> : null}</>}
+        onDecide={async () => undefined}
+        prediction={cardPrediction(item, predictionLoading)}
+        ratings={ratings}
+        sourcePreview={<ReferenceSourcePreview attachments={previewAttachments} sourceUri={reference.sourceUri} />}
+        summary={summary}
+        title={referenceDisplayTitle(reference)}
+        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}
+      <ReferenceCapturePanel capture={capture} showSummary={false} />
+      <dl className="grid grid-cols-2 gap-3 text-sm">
+        <div>
+          <dt className="text-xs font-medium uppercase tracking-wide text-muted-foreground">Imported</dt>
+          <dd className="mt-1 text-foreground">{formatReferenceListDate(reference)}</dd>
+        </div>
+        <div>
+          <dt className="text-xs font-medium uppercase tracking-wide text-muted-foreground">Media</dt>
+          <dd className="mt-1 text-foreground">{reference.mediaType ?? "unknown"}</dd>
+        </div>
+      </dl>
+    </div>
+  );
+}
+

package/components/needs-me-shared.tsx

@@ -0,0 +1,48 @@
+"use client";
+
+import { CheckIcon, CircleCheckIcon, Loader2Icon } from "lucide-react";
+import { cn } from "../lib/utils";
+import type { NeedsMeEntry } from "../lib/needs-me-items";
+import type { ReviewChoice } from "./reference-review-card";
+
+/** References and captures are rated like the References feed: a reason code is asked for on Reject. */
+export function isReferenceLike(item: Pick<NeedsMeEntry, "type">): boolean {
+  return item.type === "reference" || item.type === "incomplete_capture";
+}
+
+export function decidedChoiceOf(item: Pick<NeedsMeEntry, "decisionState">): ReviewChoice | null {
+  return item.decisionState === "accepted" ? "accept" : item.decisionState === "rejected" ? "reject" : null;
+}
+
+/** What was recorded when a non-Reference item was decided: its Why, and whether it was rejected as "not this kind". Shown again whenever the item is reopened. */
+export function recordedAnswer(item: NeedsMeEntry): { why: string | null; notThisKind: boolean } {
+  const { payload } = item;
+  if (payload.kind === "draft") return { why: payload.item.decision?.why ?? null, notThisKind: Boolean(payload.item.decision?.notThisKind) };
+  if (payload.kind === "request") return { why: payload.request.answer?.feedback ?? null, notThisKind: payload.request.answer?.steer === "not_this_kind" };
+  if (payload.kind === "email") return { why: payload.summary.quarantine?.decision?.reason || null, notThisKind: false };
+  return { why: null, notThisKind: false };
+}
+
+/** A flag is information, not a question: one Acknowledge button in the footer's own tone. */
+export function FlagFooter({ busy, disabledReason, done, error, onAcknowledge }: { busy: boolean; disabledReason: string | null; done: boolean; error: string | null; onAcknowledge: () => void }) {
+  return (
+    <div className="space-y-2" data-flag-footer>
+      {done ? (
+        <p className="inline-flex min-h-12 items-center gap-1.5 text-sm font-medium" data-flag-acknowledged><CircleCheckIcon aria-hidden="true" className="size-4" />Acknowledged</p>
+      ) : (
+        <button
+          aria-disabled={busy || Boolean(disabledReason) || undefined}
+          className={cn("inline-flex min-h-12 w-full items-center justify-center gap-1.5 rounded-[16px] bg-[var(--feed-control)] px-3 text-sm font-semibold text-foreground outline-none transition-colors hover:bg-[var(--feed-control)]/70 focus-visible:ring-2 focus-visible:ring-ring", (busy || disabledReason) && "opacity-60")}
+          data-flag-acknowledge
+          onClick={() => { if (!busy && !disabledReason) onAcknowledge(); }}
+          type="button"
+        >
+          {busy ? <Loader2Icon aria-hidden="true" className="size-4 animate-spin" /> : <CheckIcon aria-hidden="true" className="size-4" />}
+          {busy ? "Saving…" : "Acknowledge"}
+        </button>
+      )}
+      {disabledReason && !done ? <p className="text-xs text-muted-foreground" data-review-disabled-reason>{disabledReason}</p> : null}
+      {error ? <p className="text-xs text-destructive" role="alert">{error}</p> : null}
+    </div>
+  );
+}

package/components/news-desk-client-provider.tsx

@@ -6,6 +6,9 @@ import { createContext, useCallback, useContext, useEffect, useMemo, useRef, use
 import type { DevSandboxEditorAuth } from "../lib/dev-sandbox-editor-auth";
 import type { CategorySteeringDashboard } from "../lib/category-repository";
 import { ensureDevSandboxEditorSession } from "./dev-sandbox-editor-sign-in";
+import { discardReferencesHeadStart, prefetchReferencesFeed, wantsReferencesHeadStart } from "./references-prefetch";
+import { SITE_BRAND } from "../lib/site-brand";
+import { clearSavedNewsroomDisplay, loadSessionDisplay, saveSessionDisplay } from "../lib/reference-feed-cache";
 import {
   loadEditorAssignmentsData,
   loadEditorDoctrineRecordsData,
@@ -75,7 +78,12 @@ export function NewsDeskClientProvider({
       ));
       return;
     }
-    setShell((current) => beginAccessCheck(current));
+    // A recent confirmed session is shown (name, "loading" instead of "checking") while the real check runs again.
+    // Display only: the check below still decides access, and the backend authorizes every call.
+    const remembered = loadSessionDisplay(SITE_BRAND.id);
+    setShell((current) => (remembered && !current.dashboard
+      ? { ...beginAccessCheck(current), phase: "loadingDesk" as const, auth: { status: "signedIn" as const, label: remembered.label } }
+      : beginAccessCheck(current)));
 
     try {
       await ensureDevSandboxEditorSession(devSandboxEditorAuth);
@@ -88,6 +96,8 @@ export function NewsDeskClientProvider({
     if (bootstrapSequenceRef.current !== sequence) return;
 
     if (access.status === "signedOut") {
+      clearSavedNewsroomDisplay(SITE_BRAND.id);
+      discardReferencesHeadStart();
       setShell((current) => resolveSignedOut(current, access.auth));
       return;
     }
@@ -100,7 +110,10 @@ export function NewsDeskClientProvider({
       return;
     }
 
+    saveSessionDisplay(SITE_BRAND.id, { label: access.auth.label, isAdmin: access.isAdmin });
     setShell((current) => beginDeskLoad(current, access.auth));
+    // The References reads do not depend on the summary dashboard: start them now, side by side with it.
+    if (typeof window !== "undefined" && wantsReferencesHeadStart(window.location.pathname)) prefetchReferencesFeed();
 
     try {
       const dashboard = await loadEditorNewsDeskDashboard({ isAdmin: access.isAdmin });
@@ -113,7 +126,8 @@ export function NewsDeskClientProvider({
         return;
       }
       if (isAuthorizationError(error)) {
-        setShell((current) => resolveForbidden(current, access.auth));
+        // The session already has editor rights, so the backend refusing a read is not a missing role. Say what was refused.
+        setShell((current) => resolveDashboardFailure(current, access.auth, refusedReadMessage(error)));
         return;
       }
       setShell((current) => resolveDashboardFailure(
@@ -182,6 +196,8 @@ export function NewsDeskClientProvider({
     const unsubscribe = Hub.listen("auth", ({ payload }) => {
       if (payload.event === "signedOut") {
         bootstrapSequenceRef.current += 1;
+        clearSavedNewsroomDisplay(SITE_BRAND.id);
+        discardReferencesHeadStart();
         setShell((current) => resolveSignedOut(current, { status: "signedOut", label: "Signed out" }));
         return;
       }
@@ -215,9 +231,14 @@ function isAuthorizationError(error: unknown): boolean {
   return /not authorized|unauthorized|access denied|forbidden/i.test(message);
 }
 
+function refusedReadMessage(error: unknown): string {
+  const detail = error instanceof Error ? error.message : String(error ?? "");
+  return `The Newsroom backend refused a read for this signed-in account (${detail}). The account has editor or admin rights, so this is a backend authorization rule, not a missing role.`;
+}
+
 function resolvePrivateReadFailure(state: NewsDeskShellState, auth: NewsDeskShellState["auth"], error: unknown, fallback: string): NewsDeskShellState {
   if (isUnauthenticatedError(error)) return resolveSignedOut(state, { status: "signedOut", label: "Signed out" });
-  if (isAuthorizationError(error)) return resolveForbidden(state, auth);
+  if (isAuthorizationError(error)) return resolveDashboardFailure(state, auth, refusedReadMessage(error));
   return resolveDashboardFailure(state, auth, error instanceof Error ? error.message : fallback);
 }
 

package/components/news-desk-page.tsx

@@ -1,3 +1,4 @@
+import { withReferenceFeedFixture } from "../lib/local-preview-feed-fixture";
 import { resolveNewsDeskTab } from "../lib/newsroom-section-routing";
 import { NewsDeskWorkspace, type NewsDeskTab } from "./topic-steering-workspace";
 import {
@@ -67,7 +68,7 @@ export async function NewsDeskPage({ section: routeSection, selectionPath, searc
   const analysisProfiles = await loadAnalysisProfileSummaries(getBrandAnalysisProfilesPath(brand));
   const configuredCorpora = await loadConfiguredCorpusSummaries(getBrandSteeringConfigPath(brand));
   const dashboard = useDemoDashboard
-    ? createDemoCategorySteeringDashboard(brand.id, getBrandNewsroomSectionsConfigPath(brand))
+    ? withReferenceFeedFixture(createDemoCategorySteeringDashboard(brand.id, getBrandNewsroomSectionsConfigPath(brand)))
     : await loadCategorySteeringDashboard();
   return <NewsDeskWorkspace analysisProfiles={analysisProfiles} configuredCorpora={configuredCorpora} dashboard={dashboard} initialSelection={initialSelection} initialTab={initialTab} />;
 }

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

@@ -1,6 +1,8 @@
 "use client";
 
 import { loadReferenceReviewDetails } from "../lib/reference-review-details";
+import { loadAllPages } from "../lib/newsroom-all-pages";
+import { hasEditorRights } from "../lib/staff-groups";
 
 import { isEditorialWorkAssignment } from "../lib/newsroom-assignments";
 import { isLocalPreviewEnabled } from "../lib/local-preview";
@@ -8,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";
@@ -43,7 +46,19 @@ 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,
+  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";
@@ -101,6 +116,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) {
@@ -838,7 +870,7 @@ export async function loadEditorResolvedAccessState(): Promise<EditorAccessState
     if (!refreshed.hasSession || refreshed.auth.status === "signedOut") {
       return { status: "signedOut", isEditor: false, isAdmin: false, auth: refreshed.auth, error: null };
     }
-    const isEditor = refreshed.groups.some((group) => group === "editor" || group === "admin");
+    const isEditor = hasEditorRights(refreshed.groups);
     if (!isEditor) {
       return {
         status: "forbidden",
@@ -1386,6 +1418,41 @@ 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();
+      built = 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;
@@ -1402,11 +1469,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",
@@ -1415,7 +1479,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,
@@ -1423,30 +1487,184 @@ 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;
+}): 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 = 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 };
+}
+
+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: {
   threadId: string;
   messageId: string;
@@ -1650,22 +1868,26 @@ export async function loadEditorReferencesData(): Promise<{
         referenceAttachments,
       };
     }
-    const referencePage = await loadNewsroomReferencePage();
     return {
-      references: referencePage.items,
+      references: await loadAllNewsroomReferences(),
       referenceAttachments,
     };
   }
-  const [referencePage, referenceAttachments] = await Promise.all([
-    loadNewsroomReferencePage(),
+  const [references, referenceAttachments] = await Promise.all([
+    loadAllNewsroomReferences(),
     listUserPoolModel<ReferenceAttachmentRecord>("ReferenceAttachment"),
   ]);
   return {
-    references: referencePage.items,
+    references,
     referenceAttachments: referenceAttachments.sort((left, right) => left.sortKey.localeCompare(right.sortKey)),
   };
 }
 
+/** Every reference, page by page: the References feed ranks the whole set, so stopping at the first page hid most of it. */
+function loadAllNewsroomReferences(): Promise<ReferenceRecord[]> {
+  return loadAllPages((nextToken) => loadNewsroomReferencePage({ nextToken }));
+}
+
 export function normalizeNewsroomReferencePageOrder(value?: string | null): NewsroomReferencePageOrder {
   return value?.trim() === "imported" ? "imported" : "published";
 }

package/components/newsroom-access-gate.tsx

@@ -1,44 +1,36 @@
 "use client";
 
-import { newsroomHref } from "../lib/newsroom-base-path";
 import Link from "next/link";
 import { SITE_BRAND } from "../lib/site-brand";
 import type { NewsDeskShellState } from "../lib/news-desk-session";
 import { cn } from "../lib/utils";
 import { NewsroomOpsShell } from "./newsroom-ops-shell";
-import { NewsroomOverviewSkeleton } from "./newsroom-overview-skeleton";
+import { NotificationSkeleton } from "./notification-cards";
 import { ReaderAuthControl } from "./reader-auth-control";
 import { buttonVariants } from "./ui/button";
+import { ReferencesPageLoading } from "./references-page-loading";
 
-export function NewsDeskAccessGate({ shell, showSectionTabs = false }: { shell: NewsDeskShellState | null; showSectionTabs?: boolean }) {
+export function NewsDeskAccessGate({ initialTab, shell, showSectionTabs = false }: { initialTab?: string; shell: NewsDeskShellState | null; showSectionTabs?: boolean }) {
   const accessPhase = shell?.phase ?? "checkingAccess";
   const pending = accessPhase === "checkingAccess" || accessPhase === "loadingDesk";
+  const referencesPage = initialTab === "references";
 
   return (
     <NewsroomOpsShell
-      activeTab="overview"
+      activeTab={referencesPage ? "references" : "overview"}
       appTitle={SITE_BRAND.appTitle}
       backHref="/"
       backLabel={SITE_BRAND.backToHomeLabel}
       headerActions={(
-        <Link className={cn(buttonVariants({ variant: "ghost", size: "sm" }))} href="/settings">Settings</Link>
+        <Link className={cn(buttonVariants({ variant: "ghost", size: "sm" }), "organizer-header-settings")} href="/settings">Settings</Link>
       )}
-      pageTitle={showSectionTabs ? "Notification Center" : "Newsroom"}
-      showNavigation={showSectionTabs}
+      pageTitle={referencesPage ? "References" : showSectionTabs ? "Notification Center" : "Newsroom"}
+      showNavigation={showSectionTabs || referencesPage}
     >
-      {pending ? (showSectionTabs ? <NewsroomOverviewSkeleton /> : (
-        <div aria-label="Loading newsroom" className="space-y-4" data-newsroom-page-skeleton role="status">
-          <div className="h-6 w-48 rounded bg-muted" />
-          <div className="h-4 w-3/4 rounded bg-muted" />
-          <div className="grid gap-3 sm:grid-cols-2">
-            {Array.from({ length: 4 }, (_, index) => <div className="h-32 rounded-xl border bg-card p-4" key={index}>
-              <div className="h-4 w-2/3 rounded bg-muted" /><div className="mt-4 h-3 w-1/2 rounded bg-muted" />
-            </div>)}
-          </div>
-        </div>
-      )) : (
+      {/* The loading state is the feed's own skeleton, so what loads replaces it in place. */}
+      {pending && referencesPage ? <ReferencesPageLoading /> : pending ? <NotificationSkeleton bare={!showSectionTabs} count={4} /> : (
       <section aria-live="polite" data-news-desk-access={accessPhase} data-news-desk-access-phase={accessPhase}>
-        <div className="space-y-3 rounded-xl border border-border bg-card p-6">
+        <div className="space-y-3 rounded-xl bg-card p-6">
           <p className="m-0 text-[0.7rem] font-semibold uppercase tracking-[0.08em] text-muted-foreground">Access</p>
           <h2 className="m-0 font-sans text-xl font-semibold tracking-tight">{formatAccessTitle(shell)}</h2>
           <p className="m-0 text-sm text-muted-foreground">{formatAccessDetail(shell)}</p>
@@ -46,7 +38,8 @@ export function NewsDeskAccessGate({ shell, showSectionTabs = false }: { shell:
           <p className="m-0 text-sm text-foreground">{formatAccessActionDetail(shell)}</p>
           {shell?.phase === "signedOut" || shell?.phase === "error" ? (
             <div className="news-desk-access-panel__auth">
-              <ReaderAuthControl postAuthPath={newsroomHref()} showIdentity />
+              {/* No fixed return path: sign-in comes back to the page that asked, so a deep link survives it. */}
+              <ReaderAuthControl showIdentity />
             </div>
           ) : null}
         </div>