@anthusai/papyrus 5.43.0-next.7 → 5.43.0-next.8

package/infra/site-config.js

@@ -28,6 +28,9 @@ const HOST_NAME_PATTERN = /^([a-z0-9]([a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,}$/;
 const SITE_ORIGIN_PATTERN = /^https:\/\/([a-z0-9]([a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,}(:\d{1,5})?$/;
 const DOMAIN_PREFIX_PATTERN = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
 const APP_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9 _.-]*$/;
+const CHAT_MODEL_KEY_PARAMETER_PATTERN = /^\/[A-Za-z0-9_.-]+(\/[A-Za-z0-9_.-]+)+$/;
+const CHAT_LOG_GROUP_PREFIX_PATTERN = /^\/aws\/lambda\/[A-Za-z0-9_.-]{1,100}$/;
+const CHAT_WORKER_CODE_KEY_PATTERN = /^[0-9a-f]{64}\.zip$/;
 const STACK_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9-]{0,127}$/;
 const BRANCH_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9/_.-]*$/;
 const PAPYRUS_VERSION_PATTERN = /^\d+\.\d+\.\d+(-[0-9A-Za-z-]+\.\d+)?$/;
@@ -211,6 +214,58 @@ export function resolveStagingDomainName(config) {
 export function resolveStackName(config) {
     return config.stackName ?? `amplify-app-shell-${config.siteId}`;
 }
+/** The chat data stack of a site; its construct id and CloudFormation name. Nothing when chat is not enabled. */
+export function resolveChatStackName(config) {
+    if (!config.chat?.enabled)
+        return undefined;
+    return config.chat.stackName ?? `papyrus-chat-${config.siteId}`;
+}
+export function resolveChatLogGroupPrefix(config) {
+    return config.chat?.logGroupPrefix ?? `/aws/lambda/papyrus-chat-${config.siteId}`;
+}
+/** CloudFormation export names the chat stack publishes and the app shell imports (no stack ever references the other directly). */
+export const CHAT_EXPORTED_RESOURCES = ["MessagingTableName", "ConversationIndexTableName", "SessionBucketName", "TurnRunsQueueUrl", "TurnProbesQueueUrl"];
+export const CHAT_ENVIRONMENT_NAMES = {
+    MessagingTableName: "PAPYRUS_CHAT_MESSAGING_TABLE",
+    ConversationIndexTableName: "PAPYRUS_CHAT_CONVERSATIONS_TABLE",
+    SessionBucketName: "PAPYRUS_CHAT_SESSION_BUCKET",
+    TurnRunsQueueUrl: "PAPYRUS_CHAT_TURN_RUNS_QUEUE_URL",
+    TurnProbesQueueUrl: "PAPYRUS_CHAT_TURN_PROBES_QUEUE_URL",
+};
+export const CHAT_PRIVATE_ASSISTANT_ID = "papyrus-private-assistant";
+export const CHAT_PRIVATE_ASSISTANT_NAME = "Papyrus Assistant";
+export function chatExportName(stackName, resource) {
+    return `${stackName}:${resource}`;
+}
+function parseChat(value, cms) {
+    if (value === undefined)
+        return undefined;
+    const record = requireObject(value, "chat");
+    rejectUnknownKeys(record, ["enabled", "modelKeyParameter", "stackName", "logGroupPrefix", "workerCodeS3Key"], "chat");
+    if (typeof record.enabled !== "boolean")
+        fail("chat.enabled", "must be a boolean");
+    const chat = {
+        enabled: record.enabled,
+        modelKeyParameter: requireString(record.modelKeyParameter, "chat.modelKeyParameter", CHAT_MODEL_KEY_PARAMETER_PATTERN, "SSM parameter name such as /papyrus/<site>/openai-api-key"),
+        stackName: optionalString(record.stackName, "chat.stackName", STACK_NAME_PATTERN, "CloudFormation stack name"),
+        logGroupPrefix: optionalString(record.logGroupPrefix, "chat.logGroupPrefix", CHAT_LOG_GROUP_PREFIX_PATTERN, "/aws/lambda/<name>"),
+        workerCodeS3Key: optionalString(record.workerCodeS3Key, "chat.workerCodeS3Key", CHAT_WORKER_CODE_KEY_PATTERN, "<64 hex>.zip CDK asset key"),
+    };
+    for (const key of ["stackName", "logGroupPrefix", "workerCodeS3Key"]) {
+        if (chat[key] === undefined)
+            delete chat[key];
+    }
+    if (chat.enabled && cms === undefined)
+        fail("chat.enabled", "requires cms (the chat gateway runs in the CMS compute role)");
+    if (chat.enabled && cms) {
+        for (const key of Object.keys(cms.environment)) {
+            if (key === "PAPYRUS_PRIVATE_CHAT_ENABLED" || key.startsWith("PAPYRUS_CHAT_")) {
+                fail(`cms.environment.${key}`, "is managed by the chat block when chat is enabled: remove it and use chat.enabled");
+            }
+        }
+    }
+    return chat;
+}
 export function resolveStoragePreviewPrefix(config) {
     return config.storagePreviewPrefix ?? "preview/";
 }
@@ -355,7 +410,7 @@ function parseAws(value) {
 }
 export function parseSiteConfig(raw) {
     const record = requireObject(raw, "site");
-    rejectUnknownKeys(record, ["siteId", "repository", "repositoryAccessTokenSecretArn", "brand", "frontend", "hostedZoneId", "stackName", "aws", "cms", "email", "reader", "papyrusVersion", "storagePreviewPrefix", "knowledgeRun", "autoDeploy", "github"], "site");
+    rejectUnknownKeys(record, ["siteId", "repository", "repositoryAccessTokenSecretArn", "brand", "frontend", "hostedZoneId", "stackName", "aws", "cms", "email", "reader", "papyrusVersion", "storagePreviewPrefix", "chat", "knowledgeRun", "autoDeploy", "github"], "site");
     const siteId = requireString(record.siteId, "siteId", SITE_ID_PATTERN, "kebab-case");
     const repository = requireString(record.repository, "repository", REPOSITORY_PATTERN, "https://github.com/<org>/<repo>");
     const repositoryAccessTokenSecretArn = record.repositoryAccessTokenSecretArn === undefined
@@ -448,6 +503,7 @@ export function parseSiteConfig(raw) {
             fail("github", "ownerId and repoId must be set together");
         github = { owner, repo, branches, ciCanDeployInfra: ciCanDeployInfra, ...(ownerId !== undefined ? { ownerId, repoId } : {}) };
     }
+    const chat = parseChat(record.chat, cms);
     const hasDomain = cms?.domainName !== undefined || reader?.domainName !== undefined;
     if (hasDomain && hostedZoneId === undefined) {
         fail("hostedZoneId", "is required when cms.domainName or reader.domainName is set");
@@ -469,6 +525,7 @@ export function parseSiteConfig(raw) {
         reader,
         papyrusVersion,
         storagePreviewPrefix,
+        ...(chat ? { chat } : {}),
         autoDeploy: autoDeploy,
         github,
         ...(record.knowledgeRun !== undefined ? { knowledgeRun: record.knowledgeRun } : {}),

package/infra/site-config.ts

@@ -55,6 +55,21 @@ export type CmsConfig = {
   deployStackInBuild?: boolean;
 };
 
+export type ChatConfig = {
+  enabled: boolean;
+  /** SSM SecureString parameter holding the site's OpenAI key; only the chat run worker may read it. */
+  modelKeyParameter: string;
+  /** Chat data stack name (also its CDK construct id). Default `papyrus-chat-<siteId>`. */
+  stackName?: string;
+  /** CloudWatch log group prefix of the two workers (`<prefix>-run-worker`, `<prefix>-probe-worker`). Default `/aws/lambda/papyrus-chat-<siteId>`. */
+  logGroupPrefix?: string;
+  /**
+   * Pins the worker code to an already uploaded CDK asset object (key in the CDK assets bucket) instead of
+   * bundling and uploading new bytes. Only for adopting a stack whose workers are already verified live.
+   */
+  workerCodeS3Key?: string;
+};
+
 export type AmplifyAppShellSiteConfig = {
   siteId: string;
   repository: string;
@@ -82,6 +97,11 @@ export type AmplifyAppShellSiteConfig = {
   };
   papyrusVersion: string;
   storagePreviewPrefix?: string;
+  /**
+   * Private newsroom chat for this publication (docs/private-newsroom-chat-per-site.md). Absent or
+   * `enabled: false` means the site gets neither the chat data stack nor the chat environment on its CMS.
+   */
+  chat?: ChatConfig;
   /**
    * The scheduled cloud knowledge run for this publication. The app-shell stack ignores it; it is validated by
    * infra/scheduled-jobs/lib/knowledge-run-config.ts, which owns the schema.
@@ -153,6 +173,9 @@ const HOST_NAME_PATTERN = /^([a-z0-9]([a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,}$/;
 const SITE_ORIGIN_PATTERN = /^https:\/\/([a-z0-9]([a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,}(:\d{1,5})?$/;
 const DOMAIN_PREFIX_PATTERN = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
 const APP_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9 _.-]*$/;
+const CHAT_MODEL_KEY_PARAMETER_PATTERN = /^\/[A-Za-z0-9_.-]+(\/[A-Za-z0-9_.-]+)+$/;
+const CHAT_LOG_GROUP_PREFIX_PATTERN = /^\/aws\/lambda\/[A-Za-z0-9_.-]{1,100}$/;
+const CHAT_WORKER_CODE_KEY_PATTERN = /^[0-9a-f]{64}\.zip$/;
 const STACK_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9-]{0,127}$/;
 const BRANCH_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9/_.-]*$/;
 const PAPYRUS_VERSION_PATTERN = /^\d+\.\d+\.\d+(-[0-9A-Za-z-]+\.\d+)?$/;
@@ -339,6 +362,57 @@ export function resolveStackName(config: Pick<AmplifyAppShellSiteConfig, "siteId
   return config.stackName ?? `amplify-app-shell-${config.siteId}`;
 }
 
+/** The chat data stack of a site; its construct id and CloudFormation name. Nothing when chat is not enabled. */
+export function resolveChatStackName(config: Pick<AmplifyAppShellSiteConfig, "siteId" | "chat">): string | undefined {
+  if (!config.chat?.enabled) return undefined;
+  return config.chat.stackName ?? `papyrus-chat-${config.siteId}`;
+}
+
+export function resolveChatLogGroupPrefix(config: Pick<AmplifyAppShellSiteConfig, "siteId" | "chat">): string {
+  return config.chat?.logGroupPrefix ?? `/aws/lambda/papyrus-chat-${config.siteId}`;
+}
+
+/** CloudFormation export names the chat stack publishes and the app shell imports (no stack ever references the other directly). */
+export const CHAT_EXPORTED_RESOURCES = ["MessagingTableName", "ConversationIndexTableName", "SessionBucketName", "TurnRunsQueueUrl", "TurnProbesQueueUrl"] as const;
+export const CHAT_ENVIRONMENT_NAMES: Record<(typeof CHAT_EXPORTED_RESOURCES)[number], string> = {
+  MessagingTableName: "PAPYRUS_CHAT_MESSAGING_TABLE",
+  ConversationIndexTableName: "PAPYRUS_CHAT_CONVERSATIONS_TABLE",
+  SessionBucketName: "PAPYRUS_CHAT_SESSION_BUCKET",
+  TurnRunsQueueUrl: "PAPYRUS_CHAT_TURN_RUNS_QUEUE_URL",
+  TurnProbesQueueUrl: "PAPYRUS_CHAT_TURN_PROBES_QUEUE_URL",
+};
+export const CHAT_PRIVATE_ASSISTANT_ID = "papyrus-private-assistant";
+export const CHAT_PRIVATE_ASSISTANT_NAME = "Papyrus Assistant";
+export function chatExportName(stackName: string, resource: (typeof CHAT_EXPORTED_RESOURCES)[number]): string {
+  return `${stackName}:${resource}`;
+}
+
+function parseChat(value: unknown, cms: CmsConfig | undefined): ChatConfig | undefined {
+  if (value === undefined) return undefined;
+  const record = requireObject(value, "chat");
+  rejectUnknownKeys(record, ["enabled", "modelKeyParameter", "stackName", "logGroupPrefix", "workerCodeS3Key"], "chat");
+  if (typeof record.enabled !== "boolean") fail("chat.enabled", "must be a boolean");
+  const chat: ChatConfig = {
+    enabled: record.enabled,
+    modelKeyParameter: requireString(record.modelKeyParameter, "chat.modelKeyParameter", CHAT_MODEL_KEY_PARAMETER_PATTERN, "SSM parameter name such as /papyrus/<site>/openai-api-key"),
+    stackName: optionalString(record.stackName, "chat.stackName", STACK_NAME_PATTERN, "CloudFormation stack name"),
+    logGroupPrefix: optionalString(record.logGroupPrefix, "chat.logGroupPrefix", CHAT_LOG_GROUP_PREFIX_PATTERN, "/aws/lambda/<name>"),
+    workerCodeS3Key: optionalString(record.workerCodeS3Key, "chat.workerCodeS3Key", CHAT_WORKER_CODE_KEY_PATTERN, "<64 hex>.zip CDK asset key"),
+  };
+  for (const key of ["stackName", "logGroupPrefix", "workerCodeS3Key"] as const) {
+    if (chat[key] === undefined) delete chat[key];
+  }
+  if (chat.enabled && cms === undefined) fail("chat.enabled", "requires cms (the chat gateway runs in the CMS compute role)");
+  if (chat.enabled && cms) {
+    for (const key of Object.keys(cms.environment)) {
+      if (key === "PAPYRUS_PRIVATE_CHAT_ENABLED" || key.startsWith("PAPYRUS_CHAT_")) {
+        fail(`cms.environment.${key}`, "is managed by the chat block when chat is enabled: remove it and use chat.enabled");
+      }
+    }
+  }
+  return chat;
+}
+
 export function resolveStoragePreviewPrefix(config: Pick<AmplifyAppShellSiteConfig, "storagePreviewPrefix">): string {
   return config.storagePreviewPrefix ?? "preview/";
 }
@@ -498,7 +572,7 @@ export function parseSiteConfig(raw: unknown): AmplifyAppShellSiteConfig {
   const record = requireObject(raw, "site");
   rejectUnknownKeys(
     record,
-    ["siteId", "repository", "repositoryAccessTokenSecretArn", "brand", "frontend", "hostedZoneId", "stackName", "aws", "cms", "email", "reader", "papyrusVersion", "storagePreviewPrefix", "knowledgeRun", "autoDeploy", "github"],
+    ["siteId", "repository", "repositoryAccessTokenSecretArn", "brand", "frontend", "hostedZoneId", "stackName", "aws", "cms", "email", "reader", "papyrusVersion", "storagePreviewPrefix", "chat", "knowledgeRun", "autoDeploy", "github"],
     "site",
   );
 
@@ -590,6 +664,8 @@ export function parseSiteConfig(raw: unknown): AmplifyAppShellSiteConfig {
     github = { owner, repo, branches, ciCanDeployInfra: ciCanDeployInfra as boolean, ...(ownerId !== undefined ? { ownerId, repoId } : {}) };
   }
 
+  const chat = parseChat(record.chat, cms);
+
   const hasDomain = cms?.domainName !== undefined || reader?.domainName !== undefined;
   if (hasDomain && hostedZoneId === undefined) {
     fail("hostedZoneId", "is required when cms.domainName or reader.domainName is set");
@@ -612,6 +688,7 @@ export function parseSiteConfig(raw: unknown): AmplifyAppShellSiteConfig {
     reader,
     papyrusVersion,
     storagePreviewPrefix,
+    ...(chat ? { chat } : {}),
     autoDeploy: autoDeploy as boolean,
     github,
     ...(record.knowledgeRun !== undefined ? { knowledgeRun: record.knowledgeRun } : {}),

package/lib/monitoring-overview.ts

@@ -47,6 +47,8 @@ export type MonitoringEmailDetails = {
 
 export type MonitoringEmailArticleResolution = {
   url: string; title: string; resolved: true;
+  /** Present when the original link could not be followed and the destination was found by searching the headline. */
+  foundVia?: "search"; search?: { query: string; matchScore: number; provider: string; matchedTitle?: string };
 } | { error: "forbidden" | "bad_request" | "not_resolvable" | "resolution_failed"; reason?: string } | { state: "unavailable" };
 
 export type EmailReferenceImportItem = { candidateIndex: number; source_uri: string };

package/lib/newsroom-organizer-nav.ts

@@ -11,6 +11,7 @@ export const ORGANIZER_NAV_GROUPS: readonly { title: string; items: readonly Org
     { key: "overview", label: "Overview", description: "See notifications and work needing attention.", 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: "messages", label: "Messages", description: "Read and reply to newsroom conversations.", path: "/newsroom/messages", primary: true },
   ] },
   { title: "Research & knowledge", items: [

package/lib/proposals-client.ts

@@ -0,0 +1,29 @@
+"use client";
+
+import { generateClient } from "aws-amplify/data";
+import { EDIT_PROPOSAL, TRANSITION_PROPOSAL, type ProposalMove, type ProposalReceipt } from "./proposals-admin";
+
+type GraphResult = { data?: Record<string, ProposalReceipt | null>; errors?: { message?: string }[] };
+
+async function run(query: string, field: string, variables: Record<string, string | undefined>): Promise<ProposalReceipt> {
+  const client = generateClient({ authMode: "userPool" });
+  const result = (await client.graphql({ query, variables })) as GraphResult;
+  if (result.errors?.length) return { status: "refused", message: result.errors[0]?.message ?? "The action failed." };
+  return result.data?.[field] ?? { status: "refused", message: "The action did not answer." };
+}
+
+/** Moves a proposal through `path`, one `transitionProposal` call per state, stopping at the first refusal. */
+export async function transitionProposalPath(proposalId: string, path: readonly string[], reason = ""): Promise<ProposalReceipt> {
+  let receipt: ProposalReceipt = { status: "refused", message: "Nothing to do." };
+  for (const state of path) {
+    receipt = await run(TRANSITION_PROPOSAL, "transitionProposal", { proposalId, state, ...(reason ? { reason } : {}) });
+    if (receipt.status !== "ok") break;
+  }
+  return receipt;
+}
+
+/** One button of the Proposals panel: a path of states, or `editProposal` for pin and hold. */
+export async function performProposalMove(proposalId: string, move: ProposalMove, reason: string): Promise<ProposalReceipt> {
+  if (move.edit) return run(EDIT_PROPOSAL, "editProposal", { proposalId, action: move.edit });
+  return transitionProposalPath(proposalId, move.path ?? [], reason);
+}

package/lib/review-client.ts

@@ -2,9 +2,10 @@
 
 import { generateClient } from "aws-amplify/data";
 import { getCurrentUser } from "aws-amplify/auth";
+import { draftDecisionUpdate, draftView, type DraftRow, type DraftView } from "./review-drafts";
 import {
   answerUpdate, isDue, normalizeReviewRow, timeoutUpdate,
-  type AnswerInput, type ReviewRequest,
+  type AnswerInput, type DraftDecision, type ReviewRequest,
 } from "./review-requests";
 
 /**
@@ -118,3 +119,39 @@ export async function loadStoryTitles(ids: string[]): Promise<{ titles: Record<s
   }));
   return { titles, deleted };
 }
+
+const MAX_DRAFT_LOOKUPS = 60;
+const DRAFT_FIELDS = "id kind title summary body state held evidence history override createdAt";
+
+/** Records one draft's decision on the request while it stays open. Same condition as an answer: state = open. */
+export async function saveDraftDecision(request: ReviewRequest, draftId: string, decision: DraftDecision): Promise<ReviewRequest> {
+  const result = await run(
+    `mutation Decide($input: UpdateReviewRequestInput!, $condition: ModelReviewRequestConditionInput) { updateReviewRequest(input: $input, condition: $condition) { ${FIELDS} } }`,
+    { input: draftDecisionUpdate(request, draftId, decision), condition: { state: { eq: "open" } } },
+  );
+  if (result.errors?.some((entry) => /conditional/i.test(`${entry.errorType ?? ""} ${entry.message ?? ""}`))) {
+    throw new Error("Someone else answered this, or it closed at its deadline. Refresh to see the result.");
+  }
+  if (result.errors?.length || !result.data?.updateReviewRequest) throw new Error("The draft was decided, but the request could not record it. Try again.");
+  return normalizeReviewRow(result.data.updateReviewRequest);
+}
+
+export type DraftLoad = { drafts: Record<string, DraftView>; missing: string[]; failed: string[] };
+
+/**
+ * The Proposals that review requests are about, by id (editors and admins may read them). `missing` ids have no proposal (an idea kept
+ * only as JSON has no proposal to open); `failed` ids could not be read right now, which says nothing about whether they exist.
+ */
+export async function loadDrafts(ids: string[], demo = false): Promise<DraftLoad> {
+  const drafts: Record<string, DraftView> = {};
+  const missing: string[] = [];
+  const failed: string[] = [];
+  await Promise.all([...new Set(ids)].slice(0, MAX_DRAFT_LOOKUPS).map(async (id) => {
+    const result = await run(`query Draft($id: ID!) { getProposal(id: $id) { ${DRAFT_FIELDS} } }`, { id });
+    const row = result.data?.getProposal as DraftRow | null | undefined;
+    if (row) drafts[id] = draftView(row, demo);
+    else if (result.errors?.length || !result.data) failed.push(id);
+    else missing.push(id);
+  }));
+  return { drafts, missing, failed };
+}

package/lib/review-drafts.ts

@@ -0,0 +1,231 @@
+/**
+ * The AI drafts inside a review request (a trend or monitor story batch, an idea batch): what each one says, what it rests on,
+ * and how an editor's Accept or Reject on it moves the Proposal and, once every draft is decided, closes the request.
+ * Pure functions, no network, so the card and its tests share them.
+ */
+import { proposalHref, draftIdsOf, type AnswerInput, type DraftDecision, type ReviewLink, type ReviewRequest } from "./review-requests";
+
+/** A Proposal row as the console reads it; JSON fields may arrive as strings. */
+export type DraftRow = {
+  id: string;
+  kind: string;
+  title: string;
+  summary?: string | null;
+  body?: string | null;
+  state: string;
+  held?: boolean | null;
+  evidence?: unknown;
+  history?: unknown;
+  override?: unknown;
+  createdAt?: string | null;
+};
+
+export type DraftSource = { title: string; date: string | null; url: string | null };
+export type DraftChoice = "accept" | "reject";
+
+export type DraftView = {
+  id: string;
+  kindLabel: string;
+  headline: string;
+  dek: string | null;
+  section: string | null;
+  /** The evidence in words: the signals it rests on, or the monitor that found its source. */
+  evidence: string[];
+  sources: DraftSource[];
+  moreSources: number;
+  state: string;
+  held: boolean;
+  href: string;
+  /** What the Proposal's own state says an editor already decided, or null while it is open. */
+  decided: DraftChoice | null;
+};
+
+export const MAXIMUM_SOURCES = 5;
+const MAXIMUM_EVIDENCE = 3;
+const KIND_WORDS: Record<string, string> = { story_draft: "Story draft", new_concept: "New concept", rename: "Rename", merge: "Merge", split: "Split", new_column: "New column", element_symbol: "Element symbol" };
+
+function parseJson(value: unknown): unknown {
+  if (typeof value !== "string") return value ?? null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+
+/** The lines of a "## Heading" section of the body, up to the next heading or the closing "Section:" line. */
+function bodySection(body: string, heading: RegExp): string[] {
+  const lines = body.split(/\r?\n/);
+  const start = lines.findIndex((line) => heading.test(line.trim()));
+  if (start < 0) return [];
+  const found: string[] = [];
+  for (const line of lines.slice(start + 1)) {
+    const text = line.trim();
+    if (/^#{1,6}\s/.test(text) || /^Section:/.test(text)) break;
+    if (text) found.push(text);
+  }
+  return found;
+}
+
+export function parseSource(line: string): DraftSource | null {
+  const numbered = line.match(/^\d+\.\s+(.+)$/);
+  if (!numbered) return null;
+  let rest = numbered[1].trim();
+  let url: string | null = null;
+  const link = rest.match(/^(.*?)\s*(https?:\/\/\S+)$/);
+  if (link) {
+    rest = link[1].trim();
+    url = link[2];
+  }
+  let date: string | null = null;
+  const dated = rest.match(/^(.*?)\s*\((\d{4}-\d{2}-\d{2})\)$/);
+  if (dated) {
+    rest = dated[1].trim();
+    date = dated[2];
+  }
+  return rest ? { title: rest, date, url } : null;
+}
+
+function evidenceLines(row: DraftRow): string[] {
+  const body = row.body ?? "";
+  const signals = bodySection(body, /^##\s+Signals cited\s*$/i)
+    .map((line) => line.match(/^\d+\.\s+(.+?)(?:\s+\(https?:\/\/[^)\s]*\))?\s*(?:`[^`]*`)?\s*$/)?.[1]?.trim())
+    .filter((line): line is string => Boolean(line));
+  if (signals.length) return signals.slice(0, MAXIMUM_EVIDENCE);
+  const evidence = parseJson(row.evidence);
+  const source = evidence && typeof evidence === "object" && typeof (evidence as { source?: unknown }).source === "string" ? String((evidence as { source: string }).source) : "";
+  if (!source) return [];
+  const monitor = source.match(/^(.+?) monitor:/);
+  return [monitor ? `Found by the ${monitor[1]} monitor.` : source];
+}
+
+export function draftChoiceOf(state: string): DraftChoice | null {
+  return state === "approved" ? "accept" : state === "declined" ? "reject" : null;
+}
+
+/** What an editor reads before deciding: headline, dek, section, evidence and the cited sources, from the Proposal row. */
+export function draftView(row: DraftRow, demo = false): DraftView {
+  const body = row.body ?? "";
+  const sources = [...bodySection(body, /^##\s+Sources?\s*$/i)].map(parseSource).filter((source): source is DraftSource => source !== null);
+  const section = body.match(/^Section:\s*(.+?)\.\s+Drafted by AI/m)?.[1]?.trim() ?? null;
+  const override = parseJson(row.override) as { result?: string } | null;
+  return {
+    id: row.id,
+    kindLabel: KIND_WORDS[row.kind] ?? row.kind,
+    headline: row.title,
+    dek: row.summary?.trim() || null,
+    section,
+    evidence: evidenceLines(row),
+    sources: sources.slice(0, MAXIMUM_SOURCES),
+    moreSources: Math.max(0, sources.length - MAXIMUM_SOURCES),
+    state: row.state,
+    held: Boolean(row.held),
+    href: proposalHref(row.id, demo),
+    decided: draftChoiceOf(row.state) ?? (row.state === "overridden_by_editor" ? (override?.result === "declined" ? "reject" : "accept") : null),
+  };
+}
+
+// --- moving the Proposal ----------------------------------------------------------------------------------------
+
+/**
+ * The states Accept walks through, one `transitionProposal` call each, ending at "approved" (the same state the Proposals panel's Approve reaches).
+ * A draft goes through steering and editor review on the way, as the panel's own "Move to editor review" then "Approve" do.
+ */
+export function acceptPath(state: string): string[] | null {
+  if (state === "draft") return ["in_steering", "editor_review", "approved"];
+  if (state === "in_steering") return ["editor_review", "approved"];
+  if (state === "editor_review") return ["approved"];
+  return null;
+}
+
+/** Reject ends at "declined". */
+export function rejectPath(state: string): string[] | null {
+  if (state === "draft") return ["declined"];
+  if (state === "in_steering") return ["editor_review", "declined"];
+  if (state === "editor_review") return ["declined"];
+  return null;
+}
+
+/** The sentence for a draft that cannot move, or null when it can. A hold is named, never hidden. */
+export function cannotMoveReason(view: Pick<DraftView, "state" | "held" | "decided">): string | null {
+  if (view.decided) return null;
+  if (view.held) return "This draft is on hold in Proposals. Release the hold there before you decide it.";
+  return null;
+}
+
+// --- the request's answer ---------------------------------------------------------------------------------------
+
+export type DraftLookup = Readonly<Record<string, DraftView | undefined>>;
+
+/** The decision recorded on a link, else what the Proposal's own state says (decided in Proposals), else null. */
+export function draftDecisionOf(link: ReviewLink | undefined, view: DraftView | undefined, fallback: { by: string; at: string }): DraftDecision | null {
+  if (link?.decision) return link.decision;
+  return view?.decided ? { choice: view.decided, title: view.headline, why: null, notThisKind: false, ...fallback } : null;
+}
+
+/** Ids of the request's drafts that exist and are not decided yet. */
+export function undecidedDraftIds(request: ReviewRequest, drafts: DraftLookup): string[] {
+  return draftIdsOf(request).filter((id) => {
+    const view = drafts[id];
+    if (!view) return false;
+    return draftDecisionOf(request.links.find((link) => link.id === id), view, { by: "", at: "" }) === null;
+  });
+}
+
+/** How many drafts in these requests still wait for a decision (drafts not yet loaded count as waiting). */
+export function draftsToDecide(requests: ReviewRequest[], drafts: DraftLookup, missing: ReadonlySet<string> = new Set()): number {
+  return requests.reduce((total, request) => total + draftIdsOf(request).filter((id) => !missing.has(id) && (!drafts[id] || undecidedDraftIds(request, drafts).includes(id))).length, 0);
+}
+
+/** The links with one draft's decision recorded. Links for drafts the request did not name are not invented. */
+export function withDecision(request: ReviewRequest, draftId: string, decision: DraftDecision): ReviewLink[] {
+  const named = request.links.some((link) => link.id === draftId);
+  const links = named ? request.links : [...request.links, { type: "proposal", id: draftId }];
+  return links.map((link) => (link.id === draftId ? { ...link, decision } : link));
+}
+
+/** The update that records a decision on one draft while the request stays open. Applied with the condition state = open. */
+export function draftDecisionUpdate(request: ReviewRequest, draftId: string, decision: DraftDecision): Record<string, unknown> {
+  const history = [...request.history, { at: decision.at, event: "draft_decided", by: decision.by, note: `${decision.choice} ${draftId}` }].slice(-50);
+  return { id: request.id, links: JSON.stringify(withDecision(request, draftId, decision)), updatedAt: decision.at, history: JSON.stringify(history) };
+}
+
+function quote(text: string): string {
+  return `"${text.replace(/"/g, "'")}"`;
+}
+
+/**
+ * The answer that closes a request once every draft that can be decided has been: Accept on all is an approval, Reject on all a rejection,
+ * a mix is an answer with a note naming each draft. A draft rejected as the wrong kind of story makes the answer a "not this kind" steer, which
+ * the idea pipeline reads back. Null while a draft is undecided, or when no draft of the request could be loaded.
+ */
+export function batchAnswer(request: ReviewRequest, drafts: DraftLookup, fallback: { by: string; at: string }): AnswerInput | null {
+  const ids = draftIdsOf(request).filter((id) => drafts[id]);
+  if (!ids.length) return null;
+  const decisions: (DraftDecision & { id: string })[] = [];
+  for (const id of ids) {
+    const decision = draftDecisionOf(request.links.find((link) => link.id === id), drafts[id], fallback);
+    if (!decision) return null;
+    decisions.push({ ...decision, title: decision.title ?? drafts[id]?.headline, id });
+  }
+  const rejected = decisions.filter((decision) => decision.choice === "reject");
+  const lines = decisions
+    .filter((decision) => decision.choice === "reject" || decision.why)
+    .map((decision) => `${decision.choice === "accept" ? "Accepted" : "Rejected"} ${quote(decision.title ?? decision.id)}${decision.notThisKind ? " as not this kind of story" : ""}${decision.why ? `: ${decision.why}` : ""}.`);
+  const mixed = rejected.length > 0 && rejected.length < decisions.length;
+  if (mixed) {
+    const kept = decisions.filter((decision) => decision.choice === "accept" && !decision.why).map((decision) => quote(decision.title ?? decision.id));
+    if (kept.length) lines.push(`Accepted ${kept.join(", ")}.`);
+  }
+  const links = request.links.some((link) => link.type === "proposal") ? request.links.map((link) => {
+    const decision = decisions.find((entry) => entry.id === link.id);
+    return decision ? { ...link, decision } : link;
+  }) : [...request.links, ...decisions.map((decision) => ({ type: "proposal", id: decision.id, decision }))];
+  return {
+    decision: !rejected.length ? "approve" : mixed ? "feedback" : "reject",
+    feedback: lines.join(" ") || null,
+    steer: rejected.some((decision) => decision.notThisKind) ? "not_this_kind" : null,
+    drafts: decisions,
+    links,
+  };
+}

package/lib/review-fixture.ts

@@ -1,16 +1,17 @@
+import type { DraftRow } from "./review-drafts";
 import type { ReviewRequest } from "./review-requests";
 
 /** Demo and test data: one of each mode, a timed-out soft review, and an answered one whose steering was applied. */
 export const FIXTURE_REVIEW_REQUESTS: ReviewRequest[] = [
   {
-    id: "rr-hard-1", subject: { type: "story", id: "story-ruling-1" }, mode: "hard_gate", reason: "Approve this ruling summary before it is published",
+    id: "rr-hard-1", subject: { type: "story", id: "story-ruling-1" }, mode: "hard_gate", reason: "Accept this ruling summary before it is published",
     ask: "Check the holding and the quoted passages.", raisedBy: "distinctive.ttab.ruling-analysis", raisedAt: "2026-10-23T08:00:00Z", deadline: null,
     state: "open", answer: null, links: [], history: [{ at: "2026-10-23T08:00:00Z", event: "raised", by: "distinctive.ttab.ruling-analysis", note: "hard_gate" }],
     appliedIn: null, updatedAt: "2026-10-23T08:00:00Z",
   },
   {
     id: "rr-soft-2", subject: { type: "batch", id: "2026-W43" }, mode: "soft_review", reason: "3 new story ideas to review",
-    ask: "Approve to keep them all, reject to drop the batch, or steer with a note.", raisedBy: "idea-pipeline", raisedAt: "2026-10-23T07:00:00Z",
+    ask: "Accept or reject each draft.", raisedBy: "idea-pipeline", raisedAt: "2026-10-23T07:00:00Z",
     deadline: "2026-10-30T07:00:00Z", state: "open", answer: null,
     links: [{ type: "proposal", id: "proposal-1", label: "story idea 1" }, { type: "proposal", id: "proposal-2", label: "story idea 2" }, { type: "proposal", id: "proposal-3", label: "story idea 3" }],
     history: [], appliedIn: null, updatedAt: "2026-10-23T07:00:00Z",
@@ -42,4 +43,37 @@ export const FIXTURE_REVIEW_REQUESTS: ReviewRequest[] = [
     answer: { decision: "feedback", feedback: "Keep the old name for sports", steer: "adjust", by: "Ed Itor", at: "2026-10-19T09:00:00Z" },
     links: [], history: [], appliedIn: null, updatedAt: "2026-10-19T09:00:00Z",
   },
+  {
+    id: "rr-soft-3", subject: { type: "story", id: "story-weekly" }, mode: "soft_review", reason: "Check the tone of the weekly summary", ask: "Is the tone right for readers?",
+    raisedBy: "copy-editor", raisedAt: "2026-10-23T06:00:00Z", deadline: "2026-10-31T07:00:00Z", state: "open", answer: null, links: [], history: [], appliedIn: null,
+    updatedAt: "2026-10-23T06:00:00Z",
+  },
+];
+
+const TREND_BODY = (dek: string, section: string) => [
+  `${dek} [1][3]`, "", "## Signals cited", "",
+  "1. Sparse attention: technique, 32 items in the last 2 weeks against 9 in the 6 weeks before (about 4 expected; p=0.001 after correcting for 40 windows tried) `entity:sparse-attention`",
+  "2. Open weights: cluster, steady, 58 items `cluster:open-weights`", "", "## Sources", "",
+  "3. A sparse-attention model ships open weights (2026-10-20) https://example.org/sparse-attention",
+  "4. Benchmarks for long-context models (2026-10-18) https://example.org/long-context", "", `Section: ${section}. Drafted by AI from the knowledge snapshot; an editor approves the copy and the figure before anything is published.`, "",
+].join("\n");
+
+/** Demo and test drafts for the batch fixtures: a trend story, a monitor story and a draft that already has a decision. */
+export const FIXTURE_DRAFTS: DraftRow[] = [
+  {
+    id: "proposal-1", kind: "story_draft", title: "Sparse attention goes open", summary: "Open-weight models are adopting sparse attention faster than closed labs reported.",
+    body: TREND_BODY("Open-weight models are adopting sparse attention faster than closed labs reported.", "Research"), state: "draft", held: false,
+    evidence: { signals: 2, source: "knowledge snapshot 2026-10-23 (shipped), papyrus ideas trends" }, history: [], createdAt: "2026-10-23T07:00:00Z",
+  },
+  {
+    id: "proposal-2", kind: "story_draft", title: "A new quantisation paper challenges 4-bit defaults", summary: "A preprint argues that 3-bit weights match 4-bit accuracy on long-context tasks.",
+    body: ["A preprint argues that 3-bit weights match 4-bit accuracy on long-context tasks. [1]", "", "## Source", "", "1. Rethinking 4-bit defaults (2026-10-22) https://example.org/quantisation", "",
+      "Section: Research. Drafted by AI from an item the arxiv-cs monitor found. An editor approves the copy before anything is published.", ""].join("\n"),
+    state: "draft", held: false, evidence: { signals: 1, source: "arxiv-cs monitor: https://example.org/quantisation" }, history: [], createdAt: "2026-10-23T07:00:00Z",
+  },
+  {
+    id: "proposal-3", kind: "story_draft", title: "Eight new models this week", summary: "A list of the week's releases.",
+    body: TREND_BODY("A list of the week's releases.", "News"), state: "editor_review", held: false,
+    evidence: { signals: 2, source: "knowledge snapshot 2026-10-23 (shipped), papyrus ideas trends" }, history: [], createdAt: "2026-10-23T07:00:00Z",
+  },
 ];