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

package/lib/review-drafts.ts

@@ -0,0 +1,277 @@
+/**
+ * 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;
+  /** The draft's own words: the body without its Sources and Signals lists (those are shown as chips) or its closing "Section:" line. */
+  bodyText: string;
+  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" };
+
+/** JSON fields arrive as strings, and a field written through `JSON.stringify` of a string arrives encoded twice: unwrap until it is not text. */
+function parseJson(value: unknown, depth = 0): unknown {
+  if (typeof value !== "string") return value ?? null;
+  try {
+    const parsed: unknown = JSON.parse(value);
+    return typeof parsed === "string" && depth < 2 ? parseJson(parsed, depth + 1) : parsed;
+  } 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:/);
+  const lines = [monitor ? `Found by the ${monitor[1]} monitor.` : source];
+  const check = body.match(/relevance check labelled it (\w+) with a score of (\d+(?:\.\d+)?)\./i);
+  if (check) lines.push(`Relevance check: ${check[1]}, score ${check[2]}.`);
+  return lines;
+}
+
+/** The prose of a draft: every line except the Sources and Signals cited lists and the closing "Section: ..." line. */
+export function draftBodyText(body: string): string {
+  const kept: string[] = [];
+  let skipping = false;
+  for (const line of body.split(/\r?\n/)) {
+    const text = line.trim();
+    if (/^#{1,6}\s/.test(text)) skipping = /^##\s+(Sources?|Signals cited)\s*$/i.test(text);
+    if (skipping || /^Section:\s.*Drafted by AI/i.test(text)) continue;
+    kept.push(line);
+  }
+  return kept.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+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,
+    bodyText: draftBodyText(body),
+    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 words of an answer that covers several drafts: each rejection and each Why in a sentence, the plain Accepts of a mixed batch in one more. */
+export function draftFeedback(decisions: readonly (DraftDecision & { id: string })[]): string | null {
+  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}` : ""}.`);
+  if (rejected.length > 0 && rejected.length < decisions.length) {
+    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(", ")}.`);
+  }
+  return lines.join(" ") || null;
+}
+
+/**
+ * The update that changes only the Why of a draft that is already decided. The Why is stored where the decision is: on the request's link
+ * for the draft and, once the request has closed, in its answer (`drafts` and the `feedback` sentence the idea pipeline reads back).
+ * The choice, the steering chip, who decided and when stay as they were. Applied with the condition that the state is unchanged.
+ */
+export function draftReasonUpdate(request: ReviewRequest, draftId: string, decision: DraftDecision, editor: string, now: Date): Record<string, unknown> {
+  const at = now.toISOString();
+  const why = decision.why?.trim() || null;
+  const next: DraftDecision = { ...decision, why };
+  const history = [...request.history, { at, event: "reason_edited", by: editor, note: `${decision.choice} ${draftId}` }].slice(-50);
+  const update: Record<string, unknown> = { id: request.id, links: JSON.stringify(withDecision(request, draftId, next)), updatedAt: at, history: JSON.stringify(history) };
+  if (request.answer?.drafts?.length && request.state === "answered") {
+    const known = request.answer.drafts;
+    const drafts = known.some((entry) => entry.id === draftId) ? known.map((entry) => (entry.id === draftId ? { ...entry, why } : entry)) : [...known, { ...next, id: draftId }];
+    update.answer = JSON.stringify({ ...request.answer, drafts, feedback: draftFeedback(drafts) });
+  }
+  return update;
+}
+
+/**
+ * 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 mixed = rejected.length > 0 && rejected.length < decisions.length;
+  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: draftFeedback(decisions),
+    steer: rejected.some((decision) => decision.notThisKind) ? "not_this_kind" : null,
+    drafts: decisions,
+    links,
+  };
+}

package/lib/review-fixture.ts

@@ -1,16 +1,18 @@
+import type { MonitoringEmailDetails, MonitoringEmailSummary } from "./monitoring-overview";
+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 +44,56 @@ 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",
+  },
+];
+
+/** Demo and test data: email submissions held for review (placeholders only, no real addresses). */
+export const FIXTURE_HELD_EMAILS: MonitoringEmailSummary[] = [
+  {
+    receiptId: "receipt-held-1", observedAt: "2026-10-26T15:20:00Z", status: "held", subject: "Interesting preprint on retrieval for legal research",
+    envelopeSender: "bounce@mailer.example.test", headerFrom: "A Reader <reader@example.test>", warnings: ["dkim_failed"],
+    verdicts: { spf: "PASS", dkim: "FAIL", dmarc: "FAIL", spam: "PASS", virus: "PASS" }, linkCount: 2, processedCount: 0, unresolvedLinkCount: 0,
+    reviewRequired: true, errorCode: null, quarantine: { state: "quarantined", decision: null, failure: null },
+  },
+];
+
+export const FIXTURE_EMAIL_DETAILS: Record<string, MonitoringEmailDetails> = {
+  "receipt-held-1": {
+    submission: { ...FIXTURE_HELD_EMAILS[0], corpusId: null },
+    safeBodyText: "Hi,\n\nThought you would want to see this preprint on retrieval-augmented drafting for legal research. The authors compare three retrievers on 4,000 rulings.\n\nhttps://example.org/papers/retrieval-legal\nhttps://example.org/papers/retrieval-legal/data\n\nBest,\nA Reader",
+    candidateLinks: [{ url: "https://example.org/papers/retrieval-legal", title: "Retrieval for legal research" }, { url: "https://example.org/papers/retrieval-legal/data", title: "Dataset" }],
+    sourceMaterialIsUntrusted: true,
+  },
+};

package/lib/review-requests.ts

@@ -3,7 +3,7 @@
  * the auto-decided stream, and the words the page says about each. Pure functions only, so the page and its tests share them.
  *
  * Principle (docs/notification-center.md): everything except a hard gate keeps moving if nobody acts. Each entry says in words
- * what happens next without the reader, and only a hard gate says "Waiting for you".
+ * what happens next without the reader, and only a hard gate says "Waiting for you". One decision vocabulary: Accept or Reject.
  */
 import type { ReferenceRecord } from "./category-repository";
 import { getNewsroomNavHref } from "./newsroom-nav";
@@ -16,9 +16,11 @@ export type ReviewState = "open" | "answered" | "timed_out" | "withdrawn";
 export type ReviewDecision = "approve" | "acknowledge" | "reject" | "feedback";
 export type ReviewSteer = "adjust" | "not_this_kind";
 
-export type ReviewAnswer = { decision: ReviewDecision; feedback: string | null; steer: ReviewSteer | null; by: string; at: string };
+/** One AI draft's answer inside a batch request: Accept or Reject, an optional why, and whether the editor called it the wrong kind of story. */
+export type DraftDecision = { choice: "accept" | "reject"; title?: string; why?: string | null; notThisKind?: boolean; by: string; at: string };
+export type ReviewAnswer = { decision: ReviewDecision; feedback: string | null; steer: ReviewSteer | null; by: string; at: string; drafts?: (DraftDecision & { id: string })[] };
 export type ReviewHistoryEntry = { at: string; event: string; by?: string; note?: string };
-export type ReviewLink = { label?: string; url?: string; type?: string; id?: string };
+export type ReviewLink = { label?: string; url?: string; type?: string; id?: string; decision?: DraftDecision };
 
 export type ReviewRequest = {
   id: string;
@@ -84,7 +86,11 @@ export function timeoutUpdate(request: ReviewRequest, now: Date): Record<string,
   return { id: request.id, state: "timed_out", updatedAt: at, history: JSON.stringify(history) };
 }
 
-export type AnswerInput = { decision: ReviewDecision; feedback?: string | null; steer?: ReviewSteer | null };
+export type AnswerInput = {
+  decision: ReviewDecision; feedback?: string | null; steer?: ReviewSteer | null;
+  /** A batch of AI drafts: each draft's decision, recorded on the answer and on the request's links. */
+  drafts?: (DraftDecision & { id: string })[]; links?: ReviewLink[];
+};
 
 /** The update for an answer, or an Error saying why it is refused. Applied with the condition state = open. */
 export function answerUpdate(request: ReviewRequest, input: AnswerInput, by: string, now: Date): Record<string, unknown> {
@@ -94,9 +100,37 @@ export function answerUpdate(request: ReviewRequest, input: AnswerInput, by: str
   const steer = input.steer ?? null;
   if (input.decision === "feedback" && !feedback && !steer) throw new Error("Write a note, or choose \"Not this kind of thing\".");
   const at = now.toISOString();
-  const answer: ReviewAnswer = { decision: input.decision, feedback, steer, by, at };
+  const answer: ReviewAnswer = { decision: input.decision, feedback, steer, by, at, ...(input.drafts?.length ? { drafts: input.drafts } : {}) };
   const history = [...request.history, { at, event: "answered", by, note: input.decision }].slice(-MAX_HISTORY);
-  return { id: request.id, state: "answered", answer: JSON.stringify(answer), updatedAt: at, history: JSON.stringify(history) };
+  return {
+    id: request.id, state: "answered", answer: JSON.stringify(answer), updatedAt: at, history: JSON.stringify(history),
+    ...(input.links ? { links: JSON.stringify(input.links) } : {}),
+  };
+}
+
+/**
+ * The update that changes only the note of a request that already has an answer (a hard gate, a stage review, an acknowledged flag).
+ * The decision, the steering signal, who answered and when stay as they were. Applied with the condition that the state is unchanged,
+ * so it cannot overwrite a request that timed out or was withdrawn in the meantime.
+ */
+export function answerReasonUpdate(request: ReviewRequest, why: string, editor: string, now: Date): Record<string, unknown> {
+  if (!request.answer) throw new Error("This request has no answer yet; answer it first.");
+  const at = now.toISOString();
+  const answer: ReviewAnswer = { ...request.answer, feedback: why.trim() || null };
+  const history = [...request.history, { at, event: "reason_edited", by: editor, note: request.answer.decision }].slice(-MAX_HISTORY);
+  return { id: request.id, answer: JSON.stringify(answer), updatedAt: at, history: JSON.stringify(history) };
+}
+
+/** A request with a stored update applied in memory, for the demo and the fixtures; the live data API returns the saved row instead. */
+export function applyReviewUpdate(request: ReviewRequest, update: Record<string, unknown>): ReviewRequest {
+  return {
+    ...request,
+    ...(typeof update.state === "string" ? { state: update.state as ReviewState } : {}),
+    ...(update.answer ? { answer: JSON.parse(String(update.answer)) } : {}),
+    ...(update.links ? { links: JSON.parse(String(update.links)) } : {}),
+    history: update.history ? JSON.parse(String(update.history)) : request.history,
+    updatedAt: String(update.updatedAt ?? request.updatedAt),
+  };
 }
 
 // --- words ------------------------------------------------------------------------------------------------
@@ -112,30 +146,49 @@ export function modeLabel(mode: ReviewMode): string {
   return mode === "hard_gate" ? "Hard gate" : mode === "soft_review" ? "Soft review" : "Flag";
 }
 
-/** A mark and the words, never colour alone. */
-export function modeMark(mode: ReviewMode): string {
-  return mode === "hard_gate" ? "■" : mode === "soft_review" ? "◐" : "⚑";
+/** The proposal ids a request is about: its proposal links, or its subject when that is a proposal. Empty for every other request. */
+export function draftIdsOf(request: Pick<ReviewRequest, "subject" | "links">): string[] {
+  const linked = request.links.filter((link) => link.type === "proposal" && link.id).map((link) => String(link.id));
+  const ids = linked.length ? linked : request.subject.type === "proposal" ? [request.subject.id] : [];
+  return [...new Set(ids)];
+}
+
+/** A review of AI drafts: each draft is shown and decided in the card. Flags are never drafts to decide. */
+export function isDraftReview(request: Pick<ReviewRequest, "mode" | "subject" | "links">): boolean {
+  return request.mode !== "flag" && draftIdsOf(request).length > 0;
 }
 
 /** What happens next without the reader. Only a hard gate says "Waiting for you". */
 export function nextText(request: ReviewRequest): string {
+  const drafts = isDraftReview(request);
   if (request.state === "open") {
-    if (request.mode === "hard_gate") return "Waiting for you. Nothing continues until you approve or reject.";
-    if (request.mode === "soft_review") return request.deadline ? `Proceeds automatically on ${formatWhen(request.deadline)} unless you steer it.` : "Stays open until someone handles it. It never proceeds or expires on its own.";
+    if (request.mode === "hard_gate") return "Waiting for you. Nothing continues until you accept or reject.";
+    if (request.mode === "soft_review") {
+      if (drafts) return request.deadline ? `Closes on ${formatWhen(request.deadline)} if nobody answers. The drafts stay in Proposals.` : "No deadline. The drafts stay in Proposals until an editor decides them.";
+      return request.deadline ? `If nobody answers by ${formatWhen(request.deadline)}, this closes and ${request.raisedBy} carries on without a review.` : "No deadline. Stays open until someone answers it.";
+    }
     return "Nothing is waiting on this. It stays here until you acknowledge it.";
   }
-  if (request.state === "timed_out") return `Proceeded without review on ${formatWhen(request.updatedAt)}.`;
+  if (request.state === "timed_out") return drafts ? `Closed with no answer on ${formatWhen(request.updatedAt)}. The drafts stay in Proposals.` : `Proceeded without review on ${formatWhen(request.updatedAt)}.`;
   if (request.state === "withdrawn") return "Withdrawn by the step that raised it.";
   const answer = request.answer;
   return answer ? `${answerWords(answer, request)} by ${answer.by} on ${formatWhen(answer.at)}.` : "Answered.";
 }
 
 export function answerWords(answer: ReviewAnswer, request?: Pick<ReviewRequest, "mode">): string {
-  if (answer.steer === "not_this_kind") return "Steered: not this kind of thing";
+  if (answer.drafts?.length) {
+    const accepted = answer.drafts.filter((draft) => draft.choice === "accept").length;
+    const rejected = answer.drafts.length - accepted;
+    const noun = (count: number) => `${count} ${count === 1 ? "draft" : "drafts"}`;
+    if (!rejected) return `Accepted ${noun(accepted)}`;
+    if (!accepted) return `Rejected ${noun(rejected)}`;
+    return `Accepted ${noun(accepted)} and rejected ${rejected}`;
+  }
   if (answer.decision === "acknowledge") return "Acknowledged";
-  if (answer.decision === "approve") return request?.mode === "flag" ? "Acknowledged" : "Approved";
-  if (answer.decision === "reject") return "Rejected";
-  return "Steered with a note";
+  if (answer.decision === "approve") return request?.mode === "flag" ? "Acknowledged" : "Accepted";
+  if (answer.decision === "reject") return answer.steer === "not_this_kind" ? "Rejected as not this kind of thing" : "Rejected";
+  if (answer.steer === "not_this_kind") return "Rejected as not this kind of thing";
+  return "Answered with a note";
 }
 
 /** "You steered X, applied in run Y": what became of a person's input. */
@@ -153,11 +206,16 @@ export function subjectLabel(subject: { type: string; id: string }, titles: Read
   return `${subject.type.replace("_", " ")} ${subject.id}`;
 }
 
+/** The Proposals panel, opened on one proposal. */
+export function proposalHref(proposalId: string, demo = false): string {
+  return getNewsroomNavHref(`/newsroom/administration/proposals?proposal=${encodeURIComponent(proposalId)}`, demo);
+}
+
 export function subjectHref(subject: { type: string; id: string }, demo = false): string | null {
   const id = encodeURIComponent(subject.id);
   if (subject.type === "story") return getNewsroomNavHref(`/newsroom/articles/${id}`, demo);
   if (subject.type === "reference" || subject.type === "cyclotron_decision") return getNewsroomNavHref(`/newsroom/references/${id}`, demo);
-  if (subject.type === "proposal") return getNewsroomNavHref(`/newsroom/topics?proposal=${id}`, demo);
+  if (subject.type === "proposal") return proposalHref(subject.id, demo);
   if (subject.type === "automation_run") return getNewsroomNavHref("/newsroom/administration/automations", demo);
   return null;
 }
@@ -210,6 +268,9 @@ export function cyclotronAutoDecided(references: ReferenceRecord[], decisions: R
 
 export type NotificationSections = {
   hardGates: ReviewRequest[];
+  /** Open soft reviews of AI drafts (each draft is decided in its card). */
+  draftBatches: ReviewRequest[];
+  /** Every other open soft review. */
   softReviews: ReviewRequest[];
   flags: ReviewRequest[];
   /** Answered, timed out or withdrawn, newest first: what people said and what became of it. */
@@ -221,26 +282,30 @@ export function sectionReviews(requests: ReviewRequest[]): NotificationSections
   const byRaised = (a: ReviewRequest, b: ReviewRequest) => a.raisedAt.localeCompare(b.raisedAt);
   // Requests with a deadline first, soonest first; requests with no deadline after them, oldest first.
   const bySoonestDeadline = (a: ReviewRequest, b: ReviewRequest) => (a.deadline && b.deadline ? a.deadline.localeCompare(b.deadline) : a.deadline ? -1 : b.deadline ? 1 : byRaised(a, b));
+  const soft = open.filter((request) => request.mode === "soft_review");
   return {
     hardGates: open.filter((request) => request.mode === "hard_gate").sort(byRaised),
-    softReviews: open.filter((request) => request.mode === "soft_review").sort(bySoonestDeadline),
+    draftBatches: soft.filter(isDraftReview).sort(bySoonestDeadline),
+    softReviews: soft.filter((request) => !isDraftReview(request)).sort(bySoonestDeadline),
     flags: open.filter((request) => request.mode === "flag").sort((a, b) => b.raisedAt.localeCompare(a.raisedAt)),
     decided: requests.filter((request) => request.state !== "open").sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)),
   };
 }
 
-export type NotificationSummary = { waiting: number; proceedingSoon: number; decidedBySystem: number; unread: number };
+export type NotificationSummary = { waiting: number; drafts: number; otherReviews: number; decidedBySystem: number; unread: number };
 
 /**
- * "N waiting for you · N proceeding soon · N recently decided by the system".
- * Waiting = hard gates plus Cyclotron items held for review (both stay put until a person acts). Proceeding soon = open soft reviews.
+ * "N waiting for you · N AI drafts to review · N other reviews open · N recently decided by the system".
+ * Waiting = hard gates plus Cyclotron items held for review (both stay put until a person acts). `draftsToDecide` is the number of
+ * drafts in open draft reviews that nobody has decided yet.
  */
-export function summarize(sections: NotificationSections, held: CyclotronEntry[], autoDecided: CyclotronEntry[], unread: number): NotificationSummary {
-  return { waiting: sections.hardGates.length + held.length, proceedingSoon: sections.softReviews.length, decidedBySystem: autoDecided.length, unread };
+export function summarize(sections: NotificationSections, held: CyclotronEntry[], autoDecided: CyclotronEntry[], unread: number, draftsToDecide?: number): NotificationSummary {
+  const drafts = draftsToDecide ?? sections.draftBatches.reduce((total, request) => total + draftIdsOf(request).length, 0);
+  return { waiting: sections.hardGates.length + held.length, drafts, otherReviews: sections.softReviews.length, decidedBySystem: autoDecided.length, unread };
 }
 
 export function summaryText(summary: NotificationSummary): string {
-  return `${summary.waiting} waiting for you · ${summary.proceedingSoon} proceeding soon · ${summary.decidedBySystem} recently decided by the system`;
+  return `${summary.waiting} waiting for you · ${summary.drafts} AI ${summary.drafts === 1 ? "draft" : "drafts"} to review · ${summary.otherReviews} other ${summary.otherReviews === 1 ? "review" : "reviews"} open · ${summary.decidedBySystem} recently decided by the system`;
 }
 
 export function isUnread(request: ReviewRequest, readIds: ReadonlySet<string>): boolean {

package/lib/site-brand.ts

@@ -26,6 +26,8 @@ export type SiteBrandId = string;
 export type SiteBrandComponents = {
   /** The mark shown at the top of the newsroom CMS sidebar in place of the app title. */
   NewsroomLogo?: ComponentType<{ className?: string }>;
+  /** A compact mark for the mobile newsroom top bar. Without it the bar scales down `NewsroomLogo`. */
+  NewsroomLogoCompact?: ComponentType<{ className?: string }>;
   PictogramFigure?: ComponentType<PictogramFigureProps>;
   BlogPageBackground?: ComponentType<BlogPageBackgroundProps>;
 };

package/lib/source-frameable.ts

@@ -0,0 +1,77 @@
+import { lookup } from "node:dns/promises";
+import { isIP } from "node:net";
+
+/**
+ * Whether a source page lets another site show it in a frame. Most news sites refuse (X-Frame-Options or a CSP frame-ancestors
+ * rule), and a refused frame is just an empty box, which the browser cannot detect from outside. So the newsroom asks here,
+ * on the server, before it shows a web page's live preview.
+ */
+
+/** True when the response headers allow framing by any site. A rule naming specific origins is treated as a refusal. */
+export function frameableFromHeaders(headers: Headers): boolean {
+  const xfo = headers.get("x-frame-options")?.trim().toLowerCase();
+  if (xfo && (xfo.includes("deny") || xfo.includes("sameorigin") || xfo.startsWith("allow-from"))) return false;
+  const csp = headers.get("content-security-policy");
+  if (csp) {
+    for (const directive of csp.split(";")) {
+      const [name, ...sources] = directive.trim().split(/\s+/);
+      if (name?.toLowerCase() !== "frame-ancestors") continue;
+      if (!sources.some((source) => source === "*" || source === "https:" || source === "http:")) return false;
+    }
+  }
+  return true;
+}
+
+/** Loopback, private, link-local and other non-public addresses, which the server must never be made to fetch. */
+export function isPrivateAddress(address: string): boolean {
+  const v4 = address.startsWith("::ffff:") ? address.slice(7) : address;
+  if (isIP(v4) === 4) {
+    const [a, b] = v4.split(".").map(Number);
+    return a === 0 || a === 10 || a === 127 || (a === 100 && b >= 64 && b <= 127) || (a === 169 && b === 254)
+      || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168) || a >= 224;
+  }
+  const v6 = address.toLowerCase();
+  return v6 === "::" || v6 === "::1" || v6.startsWith("fc") || v6.startsWith("fd") || v6.startsWith("fe80");
+}
+
+/** A plain public http(s) address on the default port whose host resolves only to public addresses, else null. */
+export async function publicHttpUrl(raw: string): Promise<URL | null> {
+  let url: URL;
+  try { url = new URL(raw); } catch { return null; }
+  if ((url.protocol !== "https:" && url.protocol !== "http:") || url.port || url.username || url.password) return null;
+  try {
+    const addresses = isIP(url.hostname) ? [{ address: url.hostname }] : await lookup(url.hostname, { all: true });
+    return addresses.length && addresses.every(({ address }) => !isPrivateAddress(address)) ? url : null;
+  } catch {
+    return null;
+  }
+}
+
+/** GETs a public address, following up to `maxRedirects` redirects and checking every hop with publicHttpUrl. Null on any failure. */
+export async function fetchPublic(raw: string, { accept, timeoutMs = 5000, maxRedirects = 4 }: { accept: string; timeoutMs?: number; maxRedirects?: number }): Promise<Response | null> {
+  let next = await publicHttpUrl(raw);
+  for (let hop = 0; next && hop <= maxRedirects; hop += 1) {
+    let response: Response;
+    try {
+      response = await fetch(next, { method: "GET", redirect: "manual", signal: AbortSignal.timeout(timeoutMs), headers: { accept } });
+    } catch {
+      return null;
+    }
+    const location = response.headers.get("location");
+    if (response.status >= 300 && response.status < 400 && location) {
+      void response.body?.cancel();
+      next = await publicHttpUrl(new URL(location, next).toString());
+      continue;
+    }
+    return response;
+  }
+  return null;
+}
+
+/** Asks the page itself. Anything that fails (bad address, error status, timeout, too many redirects) counts as not frameable. */
+export async function checkSourceFrameable(raw: string, options: { timeoutMs?: number; maxRedirects?: number } = {}): Promise<boolean> {
+  const response = await fetchPublic(raw, { accept: "text/html", ...options });
+  if (!response) return false;
+  void response.body?.cancel();
+  return response.ok && frameableFromHeaders(response.headers);
+}