@anthusai/papyrus 5.43.0-next.37 → 5.43.0-next.39

package/components/reference-review-card.tsx

@@ -2,20 +2,16 @@
 
 import {
   ArchiveIcon,
-  CheckIcon,
   ChevronLeftIcon,
   ChevronRightIcon,
-  CircleCheckIcon,
-  CircleXIcon,
   ExternalLinkIcon,
 } from "lucide-react";
 import { useEffect, useRef, useState, type ReactNode, type PointerEvent as ReactPointerEvent } from "react";
 import { Button } from "./ui/button";
-import { AutoGrowTextarea } from "./ui/auto-grow-textarea";
 import { cn } from "../lib/utils";
-import { RatingGrid } from "./review-rating-grid";
+import { DecisionControl } from "./decision-control";
 import { useRatingStore, type RatingController } from "./use-reference-ratings";
-import { REFERENCE_REJECTION_REASON_CODES, type ReferenceRejectionReasonCode } from "../lib/reference-policy";
+import type { ReferenceRejectionReasonCode } from "../lib/reference-policy";
 
 export type ReviewChoice = "accept" | "reject";
 
@@ -31,96 +27,6 @@ export type ReviewCardDecision = {
   reasonCode: ReferenceRejectionReasonCode | null;
 };
 
-const REASON_LABELS: Record<ReferenceRejectionReasonCode, string> = {
-  out_of_scope: "Out of scope",
-  policy_exclusion: "Policy exclusion",
-  duplicate: "Duplicate",
-  low_quality: "Low quality",
-  unavailable: "Unavailable",
-  provenance: "Provenance",
-  other: "Other",
-};
-
-const CHOICE_LABEL: Record<ReviewChoice, string> = { accept: "Accept", reject: "Reject" };
-
-function percent(confidence: number | null): string | null {
-  return confidence === null ? null : `${Math.round(confidence * 100)}%`;
-}
-
-/**
- * The Cyclotron's read-only row: its Accept or Reject highlighted with its confidence, and a check or cross once a person has answered.
- * Shared by the review card and by every list that shows a suggestion before a decision.
- */
-export function CyclotronRow({ decided = null, prediction }: { decided?: ReviewChoice | null; prediction: CardPrediction }) {
-  const matched = decided && prediction.state === "ready" ? prediction.choice === decided : null;
-  return (
-    <div className="space-y-2" data-review-row="cyclotron">
-      <div className="flex items-center gap-3">
-        <span className="w-20 shrink-0 text-sm font-semibold">Cyclotron</span>
-        {prediction.state === "ready" ? (
-          <div className="flex flex-1 gap-2">
-            {(["accept", "reject"] as const).map((choice) => {
-              const predicted = prediction.state === "ready" && prediction.choice === choice;
-              const verdict = predicted && matched !== null ? (matched ? "match" : "miss") : null;
-              return (
-                <span
-                  className={cn(
-                    "inline-flex min-h-10 flex-1 items-center justify-center gap-1.5 rounded-md border px-3 text-sm",
-                    predicted ? "border-foreground bg-muted font-semibold" : "border-dashed text-muted-foreground",
-                    verdict === "match" && "border-green-700 bg-green-100 text-green-950",
-                    verdict === "miss" && "border-red-700 bg-red-100 text-red-950",
-                  )}
-                  data-cyclotron-choice={choice}
-                  data-predicted={predicted || undefined}
-                  data-verdict={verdict ?? undefined}
-                  key={choice}
-                >
-                  {verdict === "match" ? <CircleCheckIcon aria-hidden="true" className="size-4" /> : null}
-                  {verdict === "miss" ? <CircleXIcon aria-hidden="true" className="size-4" /> : null}
-                  {CHOICE_LABEL[choice]}
-                  {predicted && percent(prediction.confidence) ? <small className="text-xs font-normal">{percent(prediction.confidence)}</small> : null}
-                  {verdict ? <span className="sr-only">{verdict === "match" ? ", matches your answer" : ", differs from your answer"}</span> : null}
-                </span>
-              );
-            })}
-          </div>
-        ) : (
-          <p className="text-sm text-muted-foreground" data-cyclotron-state={prediction.state}>
-            {prediction.state === "loading" ? "Loading…" : prediction.state === "error" ? "Prediction unavailable" : "No prediction"}
-          </p>
-        )}
-      </div>
-    </div>
-  );
-}
-
-/** The two answers, large enough to tap: Accept and Reject, the chosen one filled and checked (never colour alone). */
-export function ChoiceButtons({ chosen, disabled = false, onChoose }: { chosen: ReviewChoice | null; disabled?: boolean; onChoose: (choice: ReviewChoice) => void }) {
-  return (
-    <div className="flex flex-1 gap-2">
-      {(["accept", "reject"] as const).map((choice) => {
-        const on = chosen === choice;
-        return (
-          <Button
-            aria-disabled={disabled ? true : undefined}
-            aria-pressed={on}
-            className="min-h-14 flex-1 text-base"
-            data-review-choice={choice}
-            key={choice}
-            onClick={() => onChoose(choice)}
-            type="button"
-            variant={on ? (choice === "accept" ? "default" : "destructive") : "outline"}
-          >
-            {on ? <CheckIcon aria-hidden="true" className="size-5" /> : null}
-            {CHOICE_LABEL[choice]}
-          </Button>
-        );
-      })}
-    </div>
-  );
-}
-
-/** A reference's relevance decision in the card's own vocabulary. */
 export function predictionFromDecision(decision: { label: string; positiveLabel: string | null; confidence: number | null }): CardPrediction {
   return { state: "ready", choice: decision.label === (decision.positiveLabel ?? "include") ? "accept" : "reject", confidence: decision.confidence };
 }
@@ -181,10 +87,8 @@ export function ReviewCard({
   const store = ratings ?? local;
   const item = store.get(itemId);
   const note = item.note ?? initialNote;
-  const reason = item.reasonCode !== undefined ? item.reasonCode : initialReason;
   const chosen = item.pending ?? decided;
   const choose = (choice: ReviewChoice) => { if (!disabledReason) store.choose(itemId, choice); };
-  const chooseReason = (code: ReferenceRejectionReasonCode) => { if (!disabledReason) store.setReason(itemId, code); };
   const commitNote = () => { if (!disabledReason) store.commitNote(itemId); };
 
   // Desktop shortcuts: A accepts, R rejects. Never while typing.
@@ -222,53 +126,23 @@ export function ReviewCard({
         ) : null}
       </header>
 
-      <RatingGrid
+      <DecisionControl
         answer={chosen}
         decided={decided}
         disabled={Boolean(disabledReason)}
         disabledReason={disabledReason}
         feedback={item.feedback}
+        needsReason={item.askReason}
         onChoose={choose}
+        onReasonChange={(text) => store.setNote(itemId, text)}
+        onReasonCommit={commitNote}
         prediction={prediction}
+        reason={note}
+        reasonRequiredFor="reject"
         size="large"
         surface="card"
       />
 
-      <label className="block text-sm font-medium">
-        Why? (optional)
-        <AutoGrowTextarea
-          aria-label="Why? (optional)"
-          className="mt-1 block min-h-20 w-full rounded-[var(--feed-radius-lg,10px)] bg-[var(--feed-control)] p-3 text-base font-normal outline-none placeholder:text-muted-foreground focus-visible:ring-2 focus-visible:ring-ring"
-          onBlur={commitNote}
-          onChange={(event) => store.setNote(itemId, event.target.value)}
-          placeholder="Say what made this an easy yes or a clear no. Your note teaches the Cyclotron."
-          value={note}
-        />
-      </label>
-
-      {chosen === "reject" ? (
-        <div className="space-y-2" data-review-reasons>
-          <p className="text-sm font-medium">Reason for rejecting</p>
-          <div className="flex flex-wrap gap-2">
-            {REFERENCE_REJECTION_REASON_CODES.map((code) => (
-              <button
-                aria-disabled={disabledReason ? true : undefined}
-                aria-pressed={reason === code}
-                className={cn("inline-flex min-h-10 items-center gap-1.5 rounded-[var(--feed-radius-pill,8px)] px-3 text-sm font-medium outline-none focus-visible:ring-2 focus-visible:ring-ring", reason === code ? "bg-[var(--primary)] font-semibold text-[var(--primary-foreground)]" : "bg-[var(--feed-control)]")}
-                data-review-reason={code}
-                key={code}
-                onClick={() => chooseReason(code)}
-                type="button"
-              >
-                {reason === code ? <CheckIcon aria-hidden="true" className="size-4" /> : null}
-                {REASON_LABELS[code]}
-              </button>
-            ))}
-          </div>
-          {!reason && !note.trim() ? <p className="text-sm text-muted-foreground">Choose a reason, or say why above, to save your Reject.</p> : null}
-        </div>
-      ) : null}
-
       {children}
 
       {onArchive ? (

package/components/topic-steering-workspace.tsx

@@ -101,6 +101,7 @@ import { referencePreviewsByLineage } from "../lib/reference-preview";
 import { NewsroomOpsOverview } from "./newsroom-ops-overview";
 import { NewsroomCurationBootstrap } from "./newsroom-curation-bootstrap";
 import { NewsroomReferencesView } from "./newsroom-references-view";
+import { ConversationProvider } from "./conversation-provider";
 import { NewsroomAssignmentsView } from "./newsroom-assignments-view";
 import { NewsroomTopicsView } from "./newsroom-topics-view";
 import { MarkdownContext } from "./markdown-context";
@@ -3049,7 +3050,7 @@ function NewsDeskDashboard({
       : formatDeskSectionHeadline(activeTab);
 
   return (
-    <>
+    <ConversationProvider authorLabel={authState.label} demo={Boolean(dashboard.isDemo)}>
       <NewsroomOpsShell
         activeTab={activeTab}
         appTitle={SITE_BRAND.appTitle}
@@ -3286,7 +3287,7 @@ function NewsDeskDashboard({
         </div>
       </NewsroomOpsShell>
       {topBarSearchControl.dialog}
-    </>
+    </ConversationProvider>
   );
 }
 

package/components/use-conversation.ts

@@ -0,0 +1,84 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import type { ConversationAnchor, ConversationMessage } from "../lib/conversation";
+import { useConversationStore } from "./conversation-context";
+
+export type ConversationState = "loading" | "ready" | "error";
+
+/**
+ * One conversation's Messages. Posting shows the Message at once (marked pending) and swaps in the saved one; a failed save removes
+ * it again and rejects, so the caller can give the typed text back.
+ */
+export function useConversation(anchor: ConversationAnchor) {
+  const store = useConversationStore();
+  const [messages, setMessages] = useState<ConversationMessage[]>([]);
+  const [state, setState] = useState<ConversationState>("loading");
+  const [error, setError] = useState<string | null>(null);
+  const [attempt, setAttempt] = useState(0);
+  const pendingCount = useRef(0);
+  const anchorRef = useRef(anchor);
+  anchorRef.current = anchor;
+  const anchorKey = `${anchor.kind}#${anchor.lineageId ?? ""}`;
+
+  useEffect(() => {
+    if (!store) return;
+    let active = true;
+    setState("loading");
+    setError(null);
+    setMessages([]);
+    store.load(anchorRef.current).then((loaded) => {
+      if (!active) return;
+      setMessages((current) => [...loaded, ...current.filter((message) => message.pending)]);
+      setState("ready");
+    }).catch((failure) => {
+      if (!active) return;
+      setError(failure instanceof Error ? failure.message : "The conversation could not be loaded.");
+      setState("error");
+    });
+    return () => { active = false; };
+  }, [store, anchorKey, attempt]);
+
+  const retry = useCallback(() => setAttempt((current) => current + 1), []);
+
+  const post = useCallback(async (body: string, parentMessageId: string | null) => {
+    if (!store) throw new Error("Messages are not available here.");
+    pendingCount.current += 1;
+    const pendingId = `pending-${pendingCount.current}`;
+    const pending: ConversationMessage = {
+      id: pendingId,
+      parentMessageId,
+      authorLabel: store.authorLabel,
+      content: body.trim(),
+      createdAt: new Date().toISOString(),
+      sequenceNumber: Number.MAX_SAFE_INTEGER - 1000 + pendingCount.current,
+      pending: true,
+    };
+    setMessages((current) => [...current, pending]);
+    try {
+      const saved = await store.append({ anchor: anchorRef.current, body, parentMessageId });
+      setMessages((current) => current.map((message) => (message.id === pendingId ? saved : message)));
+    } catch (failure) {
+      setMessages((current) => current.filter((message) => message.id !== pendingId));
+      throw failure instanceof Error ? failure : new Error("Your message could not be saved.");
+    }
+  }, [store]);
+
+  return { available: Boolean(store), messages, state, error, retry, post };
+}
+
+/** Message counts per Reference lineage, for the feed cards. A failed read just shows no counts. */
+export function useReferenceMessageCounts(enabled: boolean) {
+  const store = useConversationStore();
+  const [counts, setCounts] = useState<ReadonlyMap<string, number>>(() => new Map());
+  useEffect(() => {
+    if (!store || !enabled) return;
+    let active = true;
+    store.counts().then((loaded) => { if (active) setCounts((current) => new Map([...loaded, ...current])); }).catch(() => undefined);
+    return () => { active = false; };
+  }, [store, enabled]);
+  const setCount = useCallback((lineageId: string, count: number) => {
+    setCounts((current) => (current.get(lineageId) === count || (count === 0 && !current.has(lineageId)) ? current : new Map(current).set(lineageId, count)));
+  }, []);
+  return { counts, setCount };
+}

package/components/use-reference-ratings.ts

@@ -3,7 +3,7 @@
 import { useCallback, useEffect, useRef, useState } from "react";
 import type { ReferenceRejectionReasonCode } from "../lib/reference-policy";
 import type { ReviewChoice } from "./reference-review-card";
-import type { RatingFeedback } from "./review-rating-grid";
+import type { RatingFeedback } from "./decision-control";
 
 /** How long after the last keystroke a typed reason is saved on its own. */
 export const NOTE_AUTOSAVE_MS = 1200;

package/lib/conversation.ts

@@ -0,0 +1,154 @@
+/**
+ * Conversations: Messages written about a Reference (later a Story, or nothing at all). One conversation per thing, held in one
+ * MessageThread found by its anchor key. Pure helpers only, so the browser and the tests share them.
+ */
+
+export const CONVERSATION_FEED_KEY = "conversations";
+export const REFERENCE_CONVERSATION_KIND = "reference_conversation";
+export const STORY_CONVERSATION_KIND = "story_conversation";
+export const GENERAL_CONVERSATION_KIND = "conversation";
+
+/** What a conversation is about. `none` is a conversation that is about nothing but itself. */
+export type ConversationAnchor =
+  | { kind: "reference" | "item"; lineageId: string; /** The version id when it differs from the lineage id. */ id?: string; title?: string }
+  | { kind: "none"; lineageId?: undefined; title?: string };
+
+/** A Message as the conversation shows it. */
+export type ConversationMessage = {
+  id: string;
+  parentMessageId: string | null;
+  authorLabel: string;
+  content: string;
+  createdAt: string;
+  sequenceNumber: number;
+  /** True while an optimistic Message waits for the save. */
+  pending?: boolean;
+};
+
+export type ConversationReply = { message: ConversationMessage; answers: string | null };
+export type ConversationRoot = { message: ConversationMessage; replies: ConversationReply[] };
+
+function slug(value: string): string {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 120) || "thing";
+}
+
+/** `reference#<lineageId>`, `item#<lineageId>`, or null when the conversation is anchored to nothing. */
+export function conversationAnchorKey(anchor: ConversationAnchor): string | null {
+  return anchor.kind === "none" || !anchor.lineageId?.trim() ? null : `${anchor.kind}#${anchor.lineageId.trim()}`;
+}
+
+export function conversationThreadKind(anchor: ConversationAnchor): string {
+  return anchor.kind === "reference" ? REFERENCE_CONVERSATION_KIND : anchor.kind === "item" ? STORY_CONVERSATION_KIND : GENERAL_CONVERSATION_KIND;
+}
+
+/** The thread id follows the anchor, so two editors starting the same conversation at once collide on create instead of splitting it. */
+export function conversationThreadId(anchor: ConversationAnchor): string {
+  const key = conversationAnchorKey(anchor);
+  if (!key) throw new Error("A conversation without an anchor needs its own thread id.");
+  return `message-thread-conversation-${slug(key)}`;
+}
+
+export function conversationMessageId(threadId: string, sequenceNumber: number): string {
+  return `message-conversation-${slug(threadId)}-${String(sequenceNumber).padStart(4, "0")}`;
+}
+
+/** One more than the highest sequence number in use. */
+export function nextConversationSequence(existing: ReadonlyArray<{ sequenceNumber?: number | null }>): number {
+  return Math.max(0, ...existing.map((message) => Number(message.sequenceNumber || 0))) + 1;
+}
+
+/** A create that lost a race for its sequence number (the id derives from the number, so the second writer collides). */
+export function isSequenceConflict(error: unknown): boolean {
+  const text = error instanceof Error ? error.message : typeof error === "string" ? error : JSON.stringify(error ?? "");
+  return /conditional|already exists|duplicate|ConditionalCheckFailed/i.test(text);
+}
+
+/** "ryan@example.test" is shown as "ryan"; a name stays as it is. */
+export function conversationAuthorName(label: string | null | undefined): string {
+  const text = String(label ?? "").trim();
+  if (!text) return "Someone";
+  const at = text.indexOf("@");
+  return at > 0 ? text.slice(0, at) : text;
+}
+
+/**
+ * Top-level Messages in order, each with its replies. A reply to a reply stays flat under the same root and says who it answers.
+ * A reply whose parent is missing is shown as a top-level Message rather than lost.
+ */
+export function buildConversationTree(messages: ReadonlyArray<ConversationMessage>): ConversationRoot[] {
+  const sorted = [...messages].sort((a, b) => a.sequenceNumber - b.sequenceNumber || a.createdAt.localeCompare(b.createdAt));
+  const byId = new Map(sorted.map((message) => [message.id, message]));
+  const rootOf = (message: ConversationMessage): string => {
+    let current = message;
+    const seen = new Set<string>();
+    while (current.parentMessageId && byId.has(current.parentMessageId) && !seen.has(current.id)) {
+      seen.add(current.id);
+      current = byId.get(current.parentMessageId)!;
+    }
+    return current.id;
+  };
+  const roots = new Map<string, ConversationRoot>();
+  for (const message of sorted) {
+    if (rootOf(message) === message.id) roots.set(message.id, { message, replies: [] });
+  }
+  for (const message of sorted) {
+    const root = roots.get(rootOf(message));
+    if (!root || root.message.id === message.id) continue;
+    const parent = message.parentMessageId ? byId.get(message.parentMessageId) : undefined;
+    root.replies.push({ message, answers: parent && parent.id !== root.message.id ? conversationAuthorName(parent.authorLabel) : null });
+  }
+  return [...roots.values()];
+}
+
+/** Short relative time: "now", "5m", "3h", "2d". */
+export function conversationAge(createdAt: string, now: number): string {
+  const time = Date.parse(createdAt);
+  if (!Number.isFinite(time)) return "";
+  const minutes = Math.max(0, Math.round((now - time) / 60000));
+  if (minutes < 1) return "now";
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 24) return `${hours}h`;
+  return `${Math.round(hours / 24)}d`;
+}
+
+export function messageCountLabel(count: number): string {
+  return `${count} ${count === 1 ? "message" : "messages"}`;
+}
+
+/**
+ * Creates a Message with the next sequence number. The id derives from the number, so when another writer took it the create is
+ * refused and this tries the next number, up to `attempts` times. `list` returns the Messages already in the thread.
+ */
+export async function createWithSequenceRetry<Message>(input: {
+  list: () => Promise<ReadonlyArray<{ sequenceNumber?: number | null }>>;
+  create: (sequenceNumber: number) => Promise<Message>;
+  attempts?: number;
+}): Promise<{ created: Message; sequenceNumber: number }> {
+  const attempts = input.attempts ?? 5;
+  let sequenceNumber = nextConversationSequence(await input.list());
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      return { created: await input.create(sequenceNumber), sequenceNumber };
+    } catch (error) {
+      if (!isSequenceConflict(error) || attempt >= attempts) throw error;
+      sequenceNumber = nextConversationSequence(await input.list());
+    }
+  }
+}
+
+/** Finds the conversation's thread, else creates it; a create that loses a race for the (anchor-derived) id uses the winner's thread. */
+export async function findOrCreateThread<Thread>(input: {
+  find: () => Promise<Thread | null>;
+  create: () => Promise<Thread>;
+}): Promise<Thread> {
+  const existing = await input.find();
+  if (existing) return existing;
+  try {
+    return await input.create();
+  } catch (error) {
+    const raced = isSequenceConflict(error) ? await input.find() : null;
+    if (raced) return raced;
+    throw error;
+  }
+}

package/package.json

@@ -80,7 +80,11 @@
     "./components/automation-run-now": "./components/automation-run-now.tsx",
     "./components/automation-view": "./components/automation-view.tsx",
     "./components/blog-page-background": "./components/blog-page-background.tsx",
+    "./components/conversation-context": "./components/conversation-context.tsx",
+    "./components/conversation-provider": "./components/conversation-provider.tsx",
+    "./components/conversation-thread": "./components/conversation-thread.tsx",
     "./components/curation-delegation-client": "./components/curation-delegation-client.ts",
+    "./components/decision-control": "./components/decision-control.tsx",
     "./components/dev-sandbox-editor-sign-in": "./components/dev-sandbox-editor-sign-in.tsx",
     "./components/editorial-checks-admin-panel": "./components/editorial-checks-admin-panel.tsx",
     "./components/editorial-finding-card": "./components/editorial-finding-card.tsx",
@@ -146,6 +150,7 @@
     "./components/reference-add-entry": "./components/reference-add-entry.tsx",
     "./components/reference-capture-client": "./components/reference-capture-client.ts",
     "./components/reference-capture-panel": "./components/reference-capture-panel.tsx",
+    "./components/reference-conversation": "./components/reference-conversation.tsx",
     "./components/reference-curation-controls": "./components/reference-curation-controls.tsx",
     "./components/reference-cyclotron-priming": "./components/reference-cyclotron-priming.tsx",
     "./components/reference-cyclotron-status": "./components/reference-cyclotron-status.tsx",
@@ -160,7 +165,6 @@
     "./components/reference-stories": "./components/reference-stories.tsx",
     "./components/references-page-loading": "./components/references-page-loading.tsx",
     "./components/references-prefetch": "./components/references-prefetch.ts",
-    "./components/review-rating-grid": "./components/review-rating-grid.tsx",
     "./components/settings-page": "./components/settings-page.tsx",
     "./components/signup-entries-panel": "./components/signup-entries-panel.tsx",
     "./components/staging-banner": "./components/staging-banner.tsx",
@@ -189,6 +193,7 @@
     "./components/use-blog-header-obstacles": "./components/use-blog-header-obstacles.ts",
     "./components/use-brand-fonts-ready": "./components/use-brand-fonts-ready.ts",
     "./components/use-console-visibility": "./components/use-console-visibility.ts",
+    "./components/use-conversation": "./components/use-conversation.ts",
     "./components/use-editorial-checks": "./components/use-editorial-checks.ts",
     "./components/use-media-query": "./components/use-media-query.ts",
     "./components/use-near-viewport": "./components/use-near-viewport.ts",
@@ -229,6 +234,7 @@
     "./lib/content-repository": "./lib/content-repository.ts",
     "./lib/content-source-context": "./lib/content-source-context.ts",
     "./lib/content-types": "./lib/content-types.ts",
+    "./lib/conversation": "./lib/conversation.ts",
     "./lib/curation-client": "./lib/curation-client.ts",
     "./lib/curation-delegation-helpers": "./lib/curation-delegation-helpers.ts",
     "./lib/curation-routes": "./lib/curation-routes.ts",
@@ -504,7 +510,7 @@
       "optional": true
     }
   },
-  "version": "5.43.0-next.37",
+  "version": "5.43.0-next.39",
   "dependencies": {
     "@aws-amplify/adapter-nextjs": "^1.7.3",
     "@aws-crypto/sha256-js": "5.2.0",

package/routes.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "5.43.0-next.37",
+  "version": "5.43.0-next.39",
   "routes": [
     {
       "file": "app/%5F_preview/[[...path]]/route.ts",