@anthusai/papyrus 5.57.0 → 5.59.0

package/components/use-conversation.ts

@@ -1,7 +1,7 @@
 "use client";
 
 import { useCallback, useEffect, useRef, useState } from "react";
-import type { ConversationAnchor, ConversationMessage } from "../lib/conversation";
+import { NO_VIEWER, type ConversationAnchor, type ConversationMessage, type ConversationViewer } from "../lib/conversation";
 import { useConversationStore } from "./conversation-context";
 
 export type ConversationState = "loading" | "ready" | "error";
@@ -64,7 +64,41 @@ export function useConversation(anchor: ConversationAnchor) {
     }
   }, [store]);
 
-  return { available: Boolean(store), messages, state, error, retry, post };
+  const [viewer, setViewer] = useState<ConversationViewer>(NO_VIEWER);
+  useEffect(() => {
+    if (!store) return;
+    let active = true;
+    store.viewer().then((loaded) => { if (active) setViewer(loaded); }).catch(() => undefined);
+    return () => { active = false; };
+  }, [store]);
+
+  // Display names come from the authors' profiles: one request for every author not yet asked about.
+  const [names, setNames] = useState<ReadonlyMap<string, string>>(() => new Map());
+  const asked = useRef(new Set<string>());
+  useEffect(() => {
+    if (!store) return;
+    const missing = [...new Set(messages.map((message) => message.authorUserProfileId).filter((id): id is string => Boolean(id) && !asked.current.has(id as string)))];
+    if (!missing.length) return;
+    missing.forEach((id) => asked.current.add(id));
+    let active = true;
+    store.authors(missing).then((loaded) => { if (active && loaded.size) setNames((current) => new Map([...current, ...loaded])); }).catch(() => undefined);
+    return () => { active = false; };
+  }, [messages, store]);
+
+  const edit = useCallback(async (messageId: string, body: string) => {
+    if (!store) throw new Error("Messages are not available here.");
+    const saved = await store.edit(messageId, body);
+    setMessages((current) => current.map((message) => (message.id === messageId ? { ...message, ...saved } : message)));
+  }, [store]);
+  const remove = useCallback(async (messageId: string) => {
+    if (!store) throw new Error("Messages are not available here.");
+    const target = messages.find((message) => message.id === messageId);
+    const moderate = viewer.isAdmin && target?.authorSub !== viewer.sub;
+    const saved = await store.remove(messageId, moderate);
+    setMessages((current) => current.map((message) => (message.id === messageId ? { ...message, ...saved } : message)));
+  }, [store, messages, viewer]);
+
+  return { available: Boolean(store), messages, state, error, retry, post, edit, remove, viewer, names };
 }
 
 /** Message counts per Reference lineage, for the feed cards. A failed read just shows no counts. */

package/components/use-feed-preferences.ts

@@ -0,0 +1,33 @@
+"use client";
+
+import { useCallback, useEffect, useState } from "react";
+import { DEFAULT_FEED_SHOW, DEFAULT_FEED_SORT, type FeedShow, type FeedSort } from "../lib/reference-feed-ranking";
+
+const SORT_KEY = "papyrus:reference-feed:sort";
+const SHOW_KEY = "papyrus:reference-feed:show";
+
+function read<T extends string>(key: string, allowed: readonly T[], fallback: T): T {
+  try {
+    const stored = window.localStorage.getItem(key);
+    return allowed.includes(stored as T) ? (stored as T) : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+function write(key: string, value: string) {
+  try { window.localStorage.setItem(key, value); } catch { /* The choice still works for this visit without storage. */ }
+}
+
+/** The viewer's Sort and Show choices, remembered in this browser. The page renders with the defaults, then applies what was saved. */
+export function useFeedPreferences() {
+  const [sort, setSortState] = useState<FeedSort>(DEFAULT_FEED_SORT);
+  const [show, setShowState] = useState<FeedShow>(DEFAULT_FEED_SHOW);
+  useEffect(() => {
+    setSortState(read<FeedSort>(SORT_KEY, ["best", "newest"], DEFAULT_FEED_SORT));
+    setShowState(read<FeedShow>(SHOW_KEY, ["unrated", "all"], DEFAULT_FEED_SHOW));
+  }, []);
+  const setSort = useCallback((next: FeedSort) => { setSortState(next); write(SORT_KEY, next); }, []);
+  const setShow = useCallback((next: FeedShow) => { setShowState(next); write(SHOW_KEY, next); }, []);
+  return { sort, setSort, show, setShow };
+}

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;
@@ -38,8 +38,8 @@ export type RatingController = {
  * shows in both at once. `saved(id)` is the saved human answer; `seed(id)` the saved note and reason code.
  *   vote, then reason  -> the reason is saved onto the existing decision (on blur, or after a short pause)
  *   reason, then vote  -> the vote carries the reason
- * A Reject needs a reason code (the backend refuses one without), so it waits as `pending` until one is chosen; a typed reason is
- * kept in the store until it is saved and is never dropped by a failed save.
+ * A Reject needs a reason (the backend refuses one without): words or a reason code, whichever the surface asks for. With neither it
+ * waits as `pending` until one arrives; a typed reason is kept in the store until it is saved and is never dropped by a failed save.
  */
 export function useRatingStore({ save, saved, seed, needsReason, sticky, saveNote }: {
   save: RatingSave;
@@ -110,13 +110,17 @@ export function useRatingStore({ save, saved, seed, needsReason, sticky, saveNot
 
   const commit = useCallback(async (id: string, choice: ReviewChoice) => {
     if (finalDecision(id)) { void saveNoteOnly(id); return; }
-    const { note, reasonCode: chosenCode } = values(id);
-    // A typed reason is a reason: a Reject with words but no reason button is filed under "other" rather than left waiting.
-    const reasonCode = chosenCode ?? (choice === "reject" && note.trim() ? "other" : null);
-    if (choice === "reject" && !reasonCode && (latest.current.needsReason?.(id) ?? true)) { patch(id, { pending: "reject", askReason: true }); return; }
+    const { note, reasonCode } = values(id);
+    // A typed reason is a reason, so a Reject with words goes at once rather than waiting. It carries no
+    // code the editor did not pick: the backend reads the words for the code they name, and files words
+    // that name none under "other". Only a Reject with neither words nor a code waits for one.
+    if (choice === "reject" && !reasonCode && !note.trim() && (latest.current.needsReason?.(id) ?? true)) { patch(id, { pending: "reject", askReason: true }); return; }
     if (inFlight.current.has(id)) { dirty.current.add(id); return; }
     inFlight.current.add(id);
     dirty.current.delete(id);
+    // The note goes out with this save, so its own pending autosave has nothing left to send.
+    dirty.current.delete(`note:${id}`);
+    clearTimeout(timers.current[id]);
     const started = itemsRef.current[id] ?? EMPTY;
     patch(id, { pending: choice, askReason: false, feedback: { phase: "saving" } });
     try {

package/lib/category-repository.ts

@@ -280,8 +280,19 @@ export type ReferenceRecord = {
   curationStatusUpdatedAt?: string | null;
   curationStatusUpdatedBy?: string | null;
   curationStatusReason?: string | null;
+  /** The latest vote's details; a Reference keeps only its latest vote (earlier votes live in the Cyclotron's feedback). */
+  curationReasonCode?: string | null;
+  curationActorKind?: string | null;
+  curationSectionId?: string | null;
+  curationShareable?: boolean | null;
+  curationDelegation?: unknown;
+  curationDecisionRelationId?: string | null;
   newsroomFeedKey?: string | null;
   reviewedFeedKey?: string | null;
+  /** The monitor that delivered this Reference (set at intake; the Reference is the record, no Message). */
+  discoveredByMonitorId?: string | null;
+  /** What the monitor's source said about it (a Hub model's structured fields, say). */
+  discoveryDetails?: unknown;
   metadata?: unknown;
   updatedAt?: string | null;
 };
@@ -412,6 +423,9 @@ export type MessageRecord = {
   authorSub?: string | null;
   authorUserProfileId?: string | null;
   authorLabel?: string | null;
+  editedAt?: string | null;
+  deletedAt?: string | null;
+  deletedBySub?: string | null;
   threadId?: string | null;
   parentMessageId?: string | null;
   sequenceNumber?: number | null;
@@ -1471,18 +1485,6 @@ export function createDemoCategorySteeringDashboard(
       },
     ],
     messages: [
-      {
-        id: "message-demo-history-002-rationale",
-        messageKind: "ingestion_rationale",
-        messageDomain: "commentary",
-        status: "active",
-        body: "Imported as a useful holdout against modern scaling coverage.",
-        summary: "Holdout ingestion rationale",
-        source: "biblicus-import",
-        importRunId: "knowledge-import-demo-projection",
-        createdAt: importedAt,
-        updatedAt: importedAt,
-      },
       {
         id: reportingPacketMessageId,
         messageKind: "reporting_context_packet",
@@ -1826,32 +1828,6 @@ export function createDemoCategorySteeringDashboard(
         importRunId: "knowledge-import-demo-projection",
         importedAt,
       },
-      {
-        id: "semantic-relation-demo-message-history-002-rationale",
-        relationState: "current",
-        predicate: "comment",
-        relationTypeId: "semantic-relation-type-comment",
-        relationTypeKey: "comment",
-        relationDomain: "commentary",
-        subjectKind: "message",
-        subjectId: "message-demo-history-002-rationale",
-        subjectLineageId: "message-demo-history-002-rationale",
-        subjectVersionNumber: 1,
-        objectKind: "reference",
-        objectId: referenceHistoryTwoId,
-        objectLineageId: referenceHistoryTwoLineageId,
-        objectVersionNumber: 1,
-        subjectStateKey: "message#message-demo-history-002-rationale#current",
-        objectStateKey: `reference#${referenceHistoryTwoLineageId}#current`,
-        objectSubjectStateKey: `reference#${referenceHistoryTwoLineageId}#current#message`,
-        predicateObjectStateKey: `comment#reference#${referenceHistoryTwoLineageId}#current`,
-        subjectVersionKey: "message#message-demo-history-002-rationale",
-        objectVersionKey: `reference#${referenceHistoryTwoId}`,
-        rank: 1,
-        reviewRecommended: false,
-        importRunId: "knowledge-import-demo-projection",
-        importedAt,
-      },
     ],
     loadError: null,
   };

package/lib/console-chat-client.ts

@@ -3,6 +3,7 @@
 import { generateClient } from "aws-amplify/data";
 import type { Schema } from "../amplify/data/resource";
 import { configureAmplifyClient } from "../components/amplify-client-provider";
+import { postMessageArguments, postMessageMutation } from "./post-message";
 import { loadModelPayloadsForOwner, uploadModelPayloadForOwner } from "../components/news-desk-taxonomy-client";
 
 const USER_POOL_AUTH_MODE = "userPool";
@@ -190,14 +191,6 @@ const UPDATE_CONSOLE_THREAD = `
   }
 `;
 
-const CREATE_CONSOLE_MESSAGE_LEGACY = `
-  mutation CreateMessage($input: CreateMessageInput!) {
-    createMessage(input: $input) {
-      ${CONSOLE_MESSAGE_FIELDS_LEGACY}
-    }
-  }
-`;
-
 export type ConsoleChatThread = {
   id: string;
   threadKind: string;
@@ -383,79 +376,6 @@ function chooseMessageSelectionSet(schemaFields: Set<string> | null): string {
   return selected.join("\n  ");
 }
 
-function fieldValuesForCreateMessageInput(input: CreateConsoleMessageInput): Record<string, unknown> {
-  return {
-    id: input.id,
-    messageKind: input.messageKind,
-    messageDomain: input.messageDomain,
-    status: input.status,
-    summary: input.summary ?? truncateSummary(input.content ?? null),
-    source: input.source,
-    importRunId: null,
-    authorSub: null,
-    authorUserProfileId: input.authorUserProfileId ?? null,
-    authorLabel: input.authorLabel,
-    threadId: input.threadId ?? null,
-    parentMessageId: input.parentMessageId ?? null,
-    sequenceNumber: input.sequenceNumber ?? null,
-    role: input.role ?? null,
-    messageType: input.messageType ?? null,
-    semanticLayer: input.semanticLayer,
-    searchVisibility: input.searchVisibility,
-    responseTarget: input.responseTarget,
-    responseStatus: input.responseStatus ?? null,
-    responseOwner: input.responseOwner ?? null,
-    responseStartedAt: input.responseStartedAt ?? null,
-    responseCompletedAt: input.responseCompletedAt ?? null,
-    responseError: input.responseError ?? null,
-    metadata: input.metadata,
-    createdAt: input.createdAt,
-    updatedAt: input.updatedAt,
-    newsroomFeedKey: input.newsroomFeedKey,
-  };
-}
-
-function buildCreateMessageInputCandidates(
-  input: CreateConsoleMessageInput,
-  availableFields: Set<string>,
-): Record<string, unknown>[] {
-  const values = fieldValuesForCreateMessageInput(input);
-  const candidates: Record<string, unknown>[] = [];
-  const seen = new Set<string>();
-
-  const pushCandidate = (candidate: Record<string, unknown>) => {
-    const cleaned: Record<string, unknown> = {};
-    for (const [key, value] of Object.entries(candidate)) {
-      if (value !== undefined) cleaned[key] = value;
-    }
-    const signature = JSON.stringify(Object.keys(cleaned).sort().map((key) => [key, cleaned[key]]));
-    if (!seen.has(signature)) {
-      seen.add(signature);
-      candidates.push(cleaned);
-    }
-  };
-
-  if (availableFields.size) {
-    pushCandidate(sanitizeCreateMessageInput(input, availableFields));
-  } else {
-    pushCandidate(values);
-    pushCandidate({
-      id: values.id,
-      messageKind: values.messageKind,
-      messageDomain: values.messageDomain,
-      status: values.status,
-      summary: values.summary,
-      source: values.source,
-      authorLabel: values.authorLabel,
-      createdAt: values.createdAt,
-      updatedAt: values.updatedAt,
-      newsroomFeedKey: values.newsroomFeedKey,
-    });
-  }
-
-  return candidates;
-}
-
 async function loadConsoleSchemaSnapshot(): Promise<ConsoleSchemaSnapshot> {
   if (consoleSchemaSnapshot) return consoleSchemaSnapshot;
   if (consoleSchemaSnapshotPromise) return consoleSchemaSnapshotPromise;
@@ -540,70 +460,6 @@ function buildListMessagesQuery(
   `;
 }
 
-function sanitizeCreateMessageInput(
-  input: CreateConsoleMessageInput,
-  availableFields: Set<string>,
-): Record<string, unknown> {
-  const fieldValues: Record<string, unknown> = {
-    id: input.id,
-    messageKind: input.messageKind,
-    messageDomain: input.messageDomain,
-    status: input.status,
-    summary: input.summary ?? truncateSummary(input.content ?? null),
-    source: input.source,
-    importRunId: null,
-    authorSub: null,
-    authorUserProfileId: input.authorUserProfileId ?? null,
-    authorLabel: input.authorLabel,
-    threadId: input.threadId ?? null,
-    parentMessageId: input.parentMessageId ?? null,
-    sequenceNumber: input.sequenceNumber ?? null,
-    role: input.role ?? null,
-    messageType: input.messageType ?? null,
-    semanticLayer: input.semanticLayer,
-    searchVisibility: input.searchVisibility,
-    responseTarget: input.responseTarget,
-    responseStatus: input.responseStatus ?? null,
-    responseOwner: input.responseOwner ?? null,
-    responseStartedAt: input.responseStartedAt ?? null,
-    responseCompletedAt: input.responseCompletedAt ?? null,
-    responseError: input.responseError ?? null,
-    metadata: input.metadata,
-    createdAt: input.createdAt,
-    updatedAt: input.updatedAt,
-    newsroomFeedKey: input.newsroomFeedKey,
-  };
-
-  if (!availableFields.size) {
-    const conservativeFields = [
-      "id",
-      "messageKind",
-      "messageDomain",
-      "status",
-      "summary",
-      "source",
-      "authorLabel",
-      "createdAt",
-      "updatedAt",
-      "newsroomFeedKey",
-    ] as const;
-    const conservative: Record<string, unknown> = {};
-    for (const key of conservativeFields) {
-      const value = fieldValues[key];
-      if (value !== undefined) conservative[key] = value;
-    }
-    return conservative;
-  }
-
-  const sanitized: Record<string, unknown> = {};
-  for (const [key, value] of Object.entries(fieldValues)) {
-    if (!availableFields.has(key)) continue;
-    if (value === undefined) continue;
-    sanitized[key] = value;
-  }
-  return sanitized;
-}
-
 function truncateSummary(value: string | null): string | null {
   if (!value) return null;
   const normalized = value.replace(/\s+/g, " ").trim();
@@ -733,53 +589,27 @@ export async function createConsoleMessage(input: CreateConsoleMessageInput): Pr
   const selectionSets = snapshot.messageFields.size
     ? [chooseMessageSelectionSet(snapshot.messageFields)]
     : [CONSOLE_MESSAGE_FIELDS, CONSOLE_MESSAGE_FIELDS_LEGACY];
-  const inputCandidates = buildCreateMessageInputCandidates(input, snapshot.createMessageInputFields);
+  // The backend stamps the author from the signed-in identity (postMessage): the browser names none and sets no timestamps.
+  const args = postMessageArguments({ ...input, summary: input.summary ?? truncateSummary(input.content ?? null) } as unknown as Record<string, unknown>);
   let lastError: unknown = null;
 
   for (const selectionSet of selectionSets) {
-    const createMutation = `
-      mutation CreateMessage($input: CreateMessageInput!) {
-        createMessage(input: $input) {
-          ${selectionSet}
-        }
-      }
-    `;
-    for (const candidateInput of inputCandidates) {
-      try {
-        const response = await getGraphQLClient().graphql({
-          query: createMutation,
-          variables: { input: candidateInput },
-          authMode: USER_POOL_AUTH_MODE,
-        });
-        const created = normalizeConsoleMessageRecord(assertGraphQL<Record<string, unknown>>(response, "createMessage"));
-        await maybeUploadConsoleMessageBody(created.id, input.content);
-        return input.content?.trim() ? { ...created, content: input.content } : created;
-      } catch (error) {
-        if (!isUnavailableQueryError(error)) throw normalizeUnknownError(error, "createMessage");
-        lastError = error;
-      }
-    }
-  }
-
-  if (lastError) {
     try {
       const response = await getGraphQLClient().graphql({
-        query: CREATE_CONSOLE_MESSAGE_LEGACY,
-        variables: {
-          input: inputCandidates[inputCandidates.length - 1] ?? {},
-        },
+        query: postMessageMutation(args, selectionSet),
+        variables: args,
         authMode: USER_POOL_AUTH_MODE,
       });
-      const created = normalizeConsoleMessageRecord(assertGraphQL<Record<string, unknown>>(response, "createMessage"));
+      const created = normalizeConsoleMessageRecord(assertGraphQL<Record<string, unknown>>(response, "postMessage"));
       await maybeUploadConsoleMessageBody(created.id, input.content);
       return input.content?.trim() ? { ...created, content: input.content } : created;
     } catch (error) {
-      if (!isUnavailableQueryError(error)) throw normalizeUnknownError(error, "createMessage");
+      if (!isUnavailableQueryError(error)) throw normalizeUnknownError(error, "postMessage");
       lastError = error;
     }
   }
 
-  throw normalizeUnknownError(lastError, "createMessage");
+  throw normalizeUnknownError(lastError, "postMessage");
 }
 
 export async function updateConsoleMessage(

package/lib/conversation-feed.ts

@@ -0,0 +1,96 @@
+/**
+ * The Messages page: which MessageThreads are conversations, which section each belongs to, and how several newest-first streams
+ * (one per thread kind) merge into one page of conversations ordered by last activity. Pure helpers, shared by the browser and the tests.
+ */
+import { GENERAL_CONVERSATION_KIND, REFERENCE_CONVERSATION_KIND, STORY_CONVERSATION_KIND } from "./conversation";
+
+export type ConversationSection = "all" | "references" | "stories" | "chats" | "other";
+export const CONVERSATION_SECTIONS: ReadonlyArray<{ key: ConversationSection; label: string }> = [
+  { key: "all", label: "All" },
+  { key: "references", label: "References" },
+  { key: "stories", label: "Stories" },
+  { key: "chats", label: "Chats" },
+  { key: "other", label: "Other" },
+];
+
+export const CHAT_THREAD_KIND = "console";
+export const FORUM_THREAD_KINDS = ["edition_forum", "section_forum"] as const;
+
+/** The thread kinds that are conversations, by section. Machine records (provenance, curation, ingestion rationale) are in none of them. */
+const KINDS_BY_SECTION: Record<Exclude<ConversationSection, "all">, ReadonlyArray<string>> = {
+  references: [REFERENCE_CONVERSATION_KIND],
+  stories: [STORY_CONVERSATION_KIND],
+  chats: [CHAT_THREAD_KIND],
+  other: [GENERAL_CONVERSATION_KIND, ...FORUM_THREAD_KINDS],
+};
+
+export function threadKindsForSection(section: ConversationSection): string[] {
+  if (section === "all") return Object.values(KINDS_BY_SECTION).flat();
+  return [...KINDS_BY_SECTION[section]];
+}
+
+/** The section a thread kind is listed under, or null for a kind that is not a conversation. */
+export function sectionOfThreadKind(kind: string): Exclude<ConversationSection, "all"> | null {
+  for (const [section, kinds] of Object.entries(KINDS_BY_SECTION)) if (kinds.includes(kind)) return section as Exclude<ConversationSection, "all">;
+  return null;
+}
+
+export const SECTION_EMPTY_COPY: Record<ConversationSection, string> = {
+  all: "No conversations yet. Write a message above, or on a Reference, to start one.",
+  references: "No Reference has a message yet. Open a Reference and write down what it made you think.",
+  stories: "No Story has a message yet.",
+  chats: "No chats yet.",
+  other: "No other conversations yet. Write a message above to start one.",
+};
+
+export type PagedThreads<Thread> = { items: Thread[]; nextToken: string | null };
+
+type Streamable = { id: string; updatedAt: string };
+
+/**
+ * One page at a time out of several newest-first streams, merged by `updatedAt` (the order of every thread index). A stream is only
+ * asked for another page when its buffered threads have all been shown, so the order across streams is exact, never approximate.
+ */
+export function createMergedThreadStream<Thread extends Streamable>(
+  kinds: ReadonlyArray<string>,
+  loadPage: (kind: string, nextToken: string | null) => Promise<PagedThreads<Thread>>,
+) {
+  const lanes = kinds.map((kind) => ({ kind, buffer: [] as Thread[], nextToken: null as string | null, started: false, done: false }));
+  const seen = new Set<string>();
+
+  async function fill() {
+    await Promise.all(lanes.filter((lane) => !lane.done && lane.buffer.length === 0).map(async (lane) => {
+      const page = await loadPage(lane.kind, lane.started ? lane.nextToken : null);
+      lane.started = true;
+      lane.nextToken = page.nextToken;
+      lane.done = !page.nextToken;
+      lane.buffer = [...page.items].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+    }));
+  }
+
+  return {
+    /** The next `count` conversations, newest first, and whether more remain. */
+    async next(count: number): Promise<{ items: Thread[]; hasMore: boolean }> {
+      const items: Thread[] = [];
+      while (items.length < count) {
+        await fill();
+        const live = lanes.filter((lane) => lane.buffer.length > 0);
+        if (!live.length) break;
+        // A lane that is not finished and has an empty buffer after a fill returned an empty page with more behind it: ask again.
+        if (lanes.some((lane) => !lane.done && lane.buffer.length === 0)) continue;
+        const best = live.reduce((winner, lane) => (lane.buffer[0].updatedAt.localeCompare(winner.buffer[0].updatedAt) > 0 ? lane : winner));
+        const thread = best.buffer.shift()!;
+        if (seen.has(thread.id)) continue;
+        seen.add(thread.id);
+        items.push(thread);
+      }
+      return { items, hasMore: lanes.some((lane) => lane.buffer.length > 0 || !lane.done) };
+    },
+  };
+}
+
+/** The newest `limit` messages, oldest first, and how many are held back behind "Show all". */
+export function latestMessages<Message>(messages: ReadonlyArray<Message>, limit: number, showAll: boolean): { shown: Message[]; hidden: number } {
+  if (showAll || messages.length <= limit) return { shown: [...messages], hidden: 0 };
+  return { shown: messages.slice(messages.length - limit), hidden: messages.length - limit };
+}

package/lib/conversation.ts

@@ -21,10 +21,53 @@ export type ConversationMessage = {
   content: string;
   createdAt: string;
   sequenceNumber: number;
+  /** The sub of the person who wrote it: only they can edit it. */
+  authorSub?: string | null;
+  /** Their profile, where their display name lives. */
+  authorUserProfileId?: string | null;
+  /** When the author last changed the text. */
+  editedAt?: string | null;
+  /** A deleted Message keeps its place (replies stay under it) but has no text. */
+  deleted?: boolean;
+  deletedAt?: string | null;
   /** True while an optimistic Message waits for the save. */
   pending?: boolean;
 };
 
+/** Who is looking: what they may change is decided from this (an author edits their own; an admin removes anyone's). */
+export type ConversationViewer = { sub: string | null; isAdmin: boolean };
+
+export const NO_VIEWER: ConversationViewer = { sub: null, isAdmin: false };
+
+/** Only the author edits a Message, and not one that is deleted or still being saved. */
+export function canEditMessage(viewer: ConversationViewer | undefined, message: ConversationMessage): boolean {
+  return Boolean(viewer?.sub && message.authorSub && message.authorSub === viewer.sub && !message.deleted && !message.pending);
+}
+
+/** The author deletes their own; an admin deletes anyone's. */
+export function canDeleteMessage(viewer: ConversationViewer | undefined, message: ConversationMessage): boolean {
+  if (!viewer || message.deleted || message.pending) return false;
+  return viewer.isAdmin || Boolean(viewer.sub && message.authorSub && message.authorSub === viewer.sub);
+}
+
+/** Only the person who started a conversation, or an admin, renames it. */
+export function canRenameThread(viewer: ConversationViewer | undefined, thread: { createdBySub?: string | null }): boolean {
+  if (!viewer) return false;
+  return viewer.isAdmin || Boolean(viewer.sub && thread.createdBySub && thread.createdBySub === viewer.sub);
+}
+
+/**
+ * The name to show. The label saved with the Message is the author's display name (it travels with the Message, because other
+ * editors cannot read profiles); an older Message saved an email there, so a profile name, when it can be read, comes before an
+ * email's first part.
+ */
+export function messageAuthorName(message: Pick<ConversationMessage, "authorLabel" | "authorUserProfileId">, names?: ReadonlyMap<string, string>): string {
+  const label = String(message.authorLabel ?? "").trim();
+  if (label && !label.includes("@")) return label;
+  const profileName = message.authorUserProfileId ? names?.get(message.authorUserProfileId)?.trim() : "";
+  return profileName || conversationAuthorName(label);
+}
+
 export type ConversationReply = { message: ConversationMessage; answers: string | null };
 export type ConversationRoot = { message: ConversationMessage; replies: ConversationReply[] };
 
@@ -75,7 +118,7 @@ export function conversationAuthorName(label: string | null | undefined): string
  * 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[] {
+export function buildConversationTree(messages: ReadonlyArray<ConversationMessage>, nameOf: (message: ConversationMessage) => string = (message) => conversationAuthorName(message.authorLabel)): 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 => {
@@ -95,7 +138,7 @@ export function buildConversationTree(messages: ReadonlyArray<ConversationMessag
     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 });
+    root.replies.push({ message, answers: parent && parent.id !== root.message.id ? nameOf(parent) : null });
   }
   return [...roots.values()];
 }
@@ -112,6 +155,34 @@ export function conversationAge(createdAt: string, now: number): string {
   return `${Math.round(hours / 24)}d`;
 }
 
+/** The first line of a message, trimmed to fit a card: what a thread shows as its latest message. */
+export function conversationPreviewLine(content: string | null | undefined, max = 140): string {
+  const line = String(content ?? "").split("\n").map((part) => part.trim()).find(Boolean) ?? "";
+  return line.length > max ? `${line.slice(0, max - 1).trimEnd()}…` : line;
+}
+
+function threadMetadataObject(metadata: unknown): Record<string, unknown> {
+  if (metadata && typeof metadata === "object" && !Array.isArray(metadata)) return metadata as Record<string, unknown>;
+  if (typeof metadata !== "string" || !metadata.trim()) return {};
+  try {
+    const parsed = JSON.parse(metadata);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed as Record<string, unknown> : {};
+  } catch {
+    return {};
+  }
+}
+
+/** The thread's metadata (a JSON string) with the author of its latest message recorded, so a list can show who spoke last without reading messages. */
+export function threadMetadataWithLastAuthor(metadata: unknown, authorLabel: string): string {
+  return JSON.stringify({ ...threadMetadataObject(metadata), lastAuthorLabel: authorLabel });
+}
+
+/** Who wrote the latest message, as recorded on the thread; null for a thread that predates the record. */
+export function threadLastAuthorLabel(metadata: unknown): string | null {
+  const label = threadMetadataObject(metadata).lastAuthorLabel;
+  return typeof label === "string" && label.trim() ? label : null;
+}
+
 export function messageCountLabel(count: number): string {
   return `${count} ${count === 1 ? "message" : "messages"}`;
 }