@anthusai/papyrus 5.58.0 → 5.60.0

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.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"}`;
 }

package/lib/needs-me-items.ts

@@ -127,9 +127,9 @@ export function draftItem(item: DraftItem, bySource: ReadonlyMap<string, Referen
     type: "draft",
     id: item.key,
     title: view?.headline ?? link?.label ?? "Draft",
-    dek: view ? view.dek : "Loading the draft…",
+    dek: view ? view.dek : "Loading the Proposed Story…",
     image: picture.imageUrl,
-    source: picture.siteName ?? picture.host ?? (view ? `AI ${view.kindLabel.toLowerCase()}` : "AI draft"),
+    source: picture.siteName ?? picture.host ?? (view ? `AI ${view.kindLabel.toLowerCase()}` : "Proposed Story"),
     host: picture.host,
     createdAt: timeOf(request.raisedAt),
     importance: 1,
@@ -273,10 +273,10 @@ function plural(count: number, one: string, many = `${one}s`): string {
   return `${count} ${count === 1 ? one : many}`;
 }
 
-/** "3 drafts and 12 references waiting for you"; "All caught up" when nothing waits. */
+/** "3 Proposed Stories and 12 references waiting for you"; "All caught up" when nothing waits. */
 export function waitingTextFor(counts: NeedsMeCounts): string {
   const parts = [
-    counts.drafts ? plural(counts.drafts, "draft") : null,
+    counts.drafts ? plural(counts.drafts, "Proposed Story", "Proposed Stories") : null,
     counts.references ? plural(counts.references, "reference") : null,
     counts.stories ? plural(counts.stories, "story review") : null,
     counts.email ? plural(counts.email, "held email", "held emails") : null,

package/lib/needs-me-ranking.ts

@@ -5,12 +5,10 @@
  * What they share is one question: where would a person's answer change the most? In plain words, as the page says them:
  *   1. Hard gates first. Nothing continues until a person decides one, so it leads, oldest first.
  *   2. Then the interim "value of your input" score:
- *        value = uncertainty x importance x freshness
+ *        value = uncertainty x importance
  *      - uncertainty is 1 - |2P - 1|, where P is the Cyclotron's probability that you would Accept. A coin toss (P = 0.5) is 1, a
  *        certainty is 0. An item with no prediction is 0.5: we do not know how unsure we are.
  *      - importance is the item's own priority (a relevance score, or a story or section priority). It is 1 until a source gives one.
- *      - freshness is exp(-age / tau), the weight the References feed already uses; tau is learned from how old the References you
- *        accepted were when you accepted them (reference-feed-ranking.ts). With too few examples there is no decay.
  *   3. Types are interleaved, never more than two of one type in a row while another type is waiting, so a long run of References
  *      does not bury the drafts and emails behind it.
  *   4. Confident items do not ask for you. An item whose uncertainty is below the threshold goes to "Decided automatically", where it
@@ -25,7 +23,7 @@ import type { ReferenceRecord } from "./category-repository";
 import { referenceLineageId } from "./newsroom-references";
 import { normalizeReferenceCurationStatus } from "./reference-policy";
 import type { RelevanceDecisionView } from "./relevance-decisions";
-import { acceptProbability, MINIMUM_FRESHNESS_EXAMPLES, type FeedFreshness } from "./reference-feed-ranking";
+import { acceptProbability } from "./reference-feed-ranking";
 
 export type NeedsMeType = "reference" | "draft" | "stage_review" | "held_email" | "incomplete_capture" | "concept_proposal" | "flag";
 
@@ -35,7 +33,7 @@ export const NEEDS_ME_TYPES: readonly NeedsMeType[] = ["reference", "draft", "st
 export type NeedsMeFilter = "all" | "references" | "drafts" | "stories" | "email" | "captures" | "other";
 export const NEEDS_ME_FILTERS: readonly NeedsMeFilter[] = ["all", "references", "drafts", "stories", "email", "captures", "other"];
 export const NEEDS_ME_FILTER_LABELS: Record<NeedsMeFilter, string> = {
-  all: "All", references: "References", drafts: "Drafts", stories: "Stories", email: "Email", captures: "Captures", other: "Other",
+  all: "All", references: "References", drafts: "Proposed Stories", stories: "Stories", email: "Email", captures: "Captures", other: "Other",
 };
 
 const FILTER_OF: Record<NeedsMeType, Exclude<NeedsMeFilter, "all">> = {
@@ -52,7 +50,7 @@ export function matchesFilter(item: Pick<NeedsMeItem, "type">, filter: NeedsMeFi
 
 /** The words for a type, used on the card and in the detail pane. */
 export const NEEDS_ME_TYPE_LABELS: Record<NeedsMeType, string> = {
-  reference: "Reference", draft: "AI draft", stage_review: "Story review", held_email: "Held email", incomplete_capture: "Capture check", concept_proposal: "Concept proposal", flag: "For your information",
+  reference: "Reference", draft: "Proposed Story", stage_review: "Story review", held_email: "Held email", incomplete_capture: "Capture check", concept_proposal: "Concept proposal", flag: "For your information",
 };
 
 export type NeedsMePrediction = {
@@ -109,33 +107,23 @@ export function predictionOf(decision: RelevanceDecisionView | undefined): Needs
   return { label: decision.label === (decision.positiveLabel ?? "include") ? "accept" : "reject", pAccept, confidence: decision.confidence };
 }
 
-const DAY_MILLISECONDS = 86_400_000;
-
-/** exp(-age / tau) at `now`; 1 without a learned tau or an unknown arrival. The References feed's own weight. */
-export function freshnessAt(createdAt: number | null, freshness: FeedFreshness, now: number): number {
-  if (freshness.tauDays === null || createdAt === null) return 1;
-  return Math.exp(-Math.max(now - createdAt, 0) / DAY_MILLISECONDS / freshness.tauDays);
-}
-
-export type AttentionContext = { now: number; freshness: FeedFreshness };
-
 /**
  * The value of this editor's input on one item. Higher is earlier. The interim model below is a formula; a Cyclotron "attention"
  * decision implements the same interface and is passed to `rankNeedsMe` in its place.
  */
 export interface AttentionModel {
   readonly id: string;
-  value(item: NeedsMeItem, context: AttentionContext): number;
+  value(item: NeedsMeItem): number;
 }
 
 export const interimAttention: AttentionModel = {
   id: "interim-value-of-input",
-  value: (item, { now, freshness }) => item.uncertainty * item.importance * freshnessAt(item.createdAt, freshness, now),
+  value: (item) => item.uncertainty * item.importance,
 };
 
 // --- confident items ----------------------------------------------------------------------------------------------------
 
-export const MINIMUM_CONFIRMED_EXAMPLES = MINIMUM_FRESHNESS_EXAMPLES;
+export const MINIMUM_CONFIRMED_EXAMPLES = 10;
 
 export type ConfidenceThreshold = {
   /** Null with fewer than MINIMUM_CONFIRMED_EXAMPLES confirmed predictions: nothing is guessed, nothing is skipped. */
@@ -217,11 +205,10 @@ function newestFirst(left: NeedsMeItem, right: NeedsMeItem): number {
 
 export function rankNeedsMe<P>(
   items: readonly NeedsMeItem<P>[],
-  options: { now: number; freshness: FeedFreshness; threshold: ConfidenceThreshold; attention?: AttentionModel },
+  options: { threshold: ConfidenceThreshold; attention?: AttentionModel },
 ): NeedsMeRanking<P> {
   const attention = options.attention ?? interimAttention;
-  const context: AttentionContext = { now: options.now, freshness: options.freshness };
-  const scores = new Map(items.map((item) => [item.id, attention.value(item, context)]));
+  const scores = new Map(items.map((item) => [item.id, attention.value(item)]));
   const score = (item: NeedsMeItem) => scores.get(item.id) ?? 0;
   const gates = items.filter((item) => item.hardGate).sort((left, right) => (left.createdAt ?? 0) - (right.createdAt ?? 0) || left.id.localeCompare(right.id));
   const rest = items.filter((item) => !item.hardGate);

package/lib/newsroom-board.ts

@@ -1,4 +1,4 @@
-import type { KanbanConfig, KanbanIssue } from "@kanbus/ui";
+import type { KanbanConfig, KanbanIssue, KanbanSortFieldRule } from "@kanbus/ui";
 import type { AssignmentRecord } from "./category-repository";
 import {
   ASSIGNMENT_PHASE_STAGE_KEYS,
@@ -118,11 +118,19 @@ export function assignmentColumnOrder(statusesPresentOnBoard: readonly string[])
   return [...ASSIGNMENT_STATUSES_BEFORE_OTHERS, ...otherStatuses, ...ASSIGNMENT_STATUSES_AFTER_OTHERS];
 }
 
+/**
+ * Kanbus's default column order is oldest-created first, and our content items carry no `created_at`, so without this every
+ * column listed its cards by id. Newest first by `updated_at`: it is the order the stage pages load in, and the only time a
+ * paged content item has (each save is a new version, so `createdAt` is the last edit, not the story's start).
+ */
+export const NEWEST_FIRST: KanbanSortFieldRule[] = [{ field: "updated_at", direction: "desc" }];
+
 function boardConfigForType(type: string, columns: readonly { key: string; name: string; collapsed?: boolean }[]): KanbanConfig {
   const statuses = columns.map(column => ({ ...column, category: "native" }));
   return {
     hierarchy: [], types: [type], statuses,
     categories: [{ name: "native" }], priorities: {}, type_colors: {},
+    sort_order: Object.fromEntries(statuses.map(status => [status.key, [...NEWEST_FIRST]])),
     workflows: { [type]: Object.fromEntries(statuses.map(status => [status.key, []])) },
   };
 }
@@ -165,6 +173,7 @@ export function deskBoardConfig(issues: readonly NativeBoardIssue[]): KanbanConf
     statuses: [...storiesConfig.statuses, ...assignmentsConfig.statuses],
     categories: storiesConfig.categories,
     workflows: { ...storiesConfig.workflows, ...assignmentsConfig.workflows },
+    sort_order: { ...assignmentsConfig.sort_order, ...storiesConfig.sort_order },
   };
 }
 

package/lib/newsroom-demo-dashboard.ts

@@ -161,13 +161,6 @@ export function applyPilobolusDemoDashboardContent(
   }));
 
   localized.messages = localized.messages.map((message) => {
-    if (message.messageKind === "ingestion_rationale") {
-      return {
-        ...message,
-        body: "Imported as a useful holdout against generic platform demo intake.",
-        summary: "Pilobolus intake rationale",
-      };
-    }
     if (message.messageKind === "reporting_context_packet") {
       const metadata = message.metadata && typeof message.metadata === "object" && !Array.isArray(message.metadata)
         ? message.metadata as Record<string, unknown>

package/lib/newsroom-organizer-nav.ts

@@ -8,10 +8,10 @@ export type OrganizerDestination = {
 };
 export const ORGANIZER_NAV_GROUPS: readonly { title: string; items: readonly OrganizerDestination[] }[] = [
   { title: "Editorial work", items: [
-    { key: "overview", label: "Needs me", description: "See what needs you: drafts, references and reviews.", path: "/newsroom", primary: true },
+    { key: "overview", label: "Needs me", description: "See what needs you: Proposed Stories, references and reviews.", path: "/newsroom", primary: true },
     { key: "articles", label: getContentItemName().plural, description: `Follow ${contentItemPluralLowercase} across their stages and open one to write or revise it.`, path: `/newsroom/${contentItemBoardPathSegment()}`, alsoActiveOnPaths: ["/newsroom/articles"], primary: true },
     { key: "assignments", label: "Assignments", description: "Follow research and reporting work across its statuses and claim it.", path: "/newsroom/assignments" },
-    { key: "drafts", label: "Drafts", description: "Read the story drafts that AI proposes, then accept or reject them.", path: "/newsroom/administration/proposals" },
+    { key: "drafts", label: "Proposed Stories", description: "Read the Proposed Stories that AI suggests, then accept or reject them.", path: "/newsroom/administration/proposals" },
     { key: "messages", label: "Messages", description: "Read and reply to newsroom conversations.", path: "/newsroom/messages", primary: true },
   ] },
   { title: "Research & knowledge", items: [

package/lib/post-message.ts

@@ -0,0 +1,54 @@
+/**
+ * Messages are created through the `postMessage` mutation, never through `createMessage`: the backend stamps the author from the
+ * signed-in identity, so a browser cannot name one. This is the one place that turns a Message record into that mutation and its
+ * arguments, shared by the conversation, forum and console chat writers. Authorship and timestamps are left out on purpose.
+ */
+
+const ARGUMENT_TYPES = {
+  id: "ID!",
+  threadId: "ID!",
+  content: "String",
+  messageKind: "String!",
+  messageDomain: "String!",
+  summary: "String",
+  parentMessageId: "ID",
+  sequenceNumber: "Int",
+  messageType: "String",
+  role: "String",
+  source: "String",
+  authorLabel: "String",
+  semanticLayer: "String",
+  searchVisibility: "String",
+  responseTarget: "String",
+  responseStatus: "String",
+  responseOwner: "String",
+  responseStartedAt: "AWSDateTime",
+  responseCompletedAt: "AWSDateTime",
+  metadata: "AWSJSON",
+  newsroomFeedKey: "String",
+} as const;
+
+export type PostMessageArguments = Partial<Record<keyof typeof ARGUMENT_TYPES, string | number | null>>;
+
+type MessageLike = Record<string, unknown>;
+
+/** The arguments of `postMessage` from a Message record. Anything else on the record (authorSub, authorUserProfileId, createdAt, updatedAt) is dropped. */
+export function postMessageArguments(record: MessageLike): PostMessageArguments {
+  const args: PostMessageArguments = {};
+  for (const key of Object.keys(ARGUMENT_TYPES) as Array<keyof typeof ARGUMENT_TYPES>) {
+    let value = record[key === "content" ? "content" : key];
+    if (key === "content") value = record.content ?? record.body;
+    if (value === undefined || value === null) continue;
+    if (key === "metadata") value = typeof value === "string" ? value : JSON.stringify(value);
+    args[key] = value as string | number;
+  }
+  return args;
+}
+
+/** `mutation PostMessage($id: ID!, …) { postMessage(id: $id, …) { <selection> } }` declaring exactly the arguments given. */
+export function postMessageMutation(args: PostMessageArguments, selection: string): string {
+  const keys = Object.keys(args) as Array<keyof typeof ARGUMENT_TYPES>;
+  const declared = keys.map((key) => `$${key}: ${ARGUMENT_TYPES[key]}`).join(", ");
+  const passed = keys.map((key) => `${key}: $${key}`).join(", ");
+  return `mutation PostMessage(${declared}) { postMessage(${passed}) { ${selection} } }`;
+}

package/lib/proposals-admin.ts

@@ -22,7 +22,7 @@ export type ProposalFilter = "open" | "draft" | "in_steering" | "editor_review"
 export type ProposalMove = { label: string; path?: string[]; edit?: "pin" | "unpin" | "hold" | "release"; state?: string };
 
 const STATE_LABELS: Record<string, string> = {
-  draft: "Draft",
+  draft: "Proposed",
   in_steering: "In steering",
   editor_review: "Editor review",
   approved: "Approved",
@@ -31,7 +31,7 @@ const STATE_LABELS: Record<string, string> = {
 };
 
 const KIND_LABELS: Record<string, string> = {
-  story_draft: "Story draft",
+  story_draft: "Proposed Story",
   new_concept: "New concept",
   rename: "Rename",
   merge: "Merge",