@anthusai/papyrus 1.19.1 → 2.0.0-next.10

package/lib/editorial-checks.ts

@@ -0,0 +1,178 @@
+/**
+ * Editorial checks: the Limatus result shapes the newsroom uses, and pure helpers
+ * over them. Limatus counts offsets in UTF-16 code units, which is exactly how
+ * JavaScript indexes strings, so spans apply to the body text as they are.
+ */
+import { pluginSettings, type PluginOutputs } from "./plugin-settings";
+
+export const EDITORIAL_CHECKS_PLUGIN = "editorial-checks";
+
+export type Span = { start: number; end: number };
+export type Severity = "info" | "warn" | "error";
+
+export type EditorialFinding = {
+  id: string;
+  policyId: string;
+  policyVersion: number;
+  detectorId: string;
+  lane: "rules" | "classifier";
+  severity: Severity;
+  status: "violation" | "review";
+  segmentId: string;
+  span: Span;
+  excerpt: string;
+  /** The excerpt as a reader sees it (inline markup removed). */
+  excerptText?: string;
+  message: string;
+  probability?: number;
+  rawProbability?: number;
+  replacement?: string;
+};
+
+export type EditorialSegment = {
+  id: string;
+  kind: "document" | "paragraph" | "sentence";
+  block?: "paragraph" | "heading" | "listItem";
+  parentId?: string;
+  start: number;
+  end: number;
+  textHash: string;
+  /** Plain prose of a paragraph or sentence segment. */
+  text?: string;
+};
+
+export type LaneStatus = { status: "ran" | "disabled" | "unavailable" | "failed" | "partial"; reason?: string; detectors?: number };
+
+export type EditorialCheckResult = {
+  schemaVersion: 1;
+  offsetUnit: "utf16";
+  document: { hash: string; length: number };
+  pack: { packId: string; version: string };
+  segments: EditorialSegment[];
+  protected: { kind: string; start: number; end: number }[];
+  findings: EditorialFinding[];
+  coverage: unknown[];
+  lanes: { rules: LaneStatus; classifier: LaneStatus };
+  usage?: Record<string, number>;
+};
+
+export type RewriteOption = {
+  id: string;
+  span: Span;
+  replacement: string;
+  rationale: string;
+  factVerificationRequired: boolean;
+  unresolvedQuestions: string[];
+};
+
+export type RewriteResult = {
+  target: { findingId?: string; span: Span; excerpt: string };
+  model: string;
+  options: RewriteOption[];
+  dropped?: { replacement: string; reason: string }[];
+};
+
+export type FeedbackDecision = "accepted" | "fixed" | "dismissed";
+
+export type EditorialFeedbackInput = {
+  itemId: string;
+  findingId: string;
+  policyId: string;
+  detectorId: string;
+  lane: EditorialFinding["lane"];
+  probability: number | null;
+  decision: FeedbackDecision;
+  reason: string | null;
+  text: string | null;
+};
+
+/** Decisions on an article that has never been saved are kept under this id. */
+export const UNSAVED_ITEM_ID = "unsaved";
+
+const SEVERITY_ORDER: Record<Severity, number> = { error: 0, warn: 1, info: 2 };
+
+export function editorialChecksEnabled(outputs: PluginOutputs | null | undefined): boolean {
+  return pluginSettings(outputs, EDITORIAL_CHECKS_PLUGIN) !== null;
+}
+
+/** Findings worth showing: not dismissed, not covering the whole document, most severe first, then in reading order. */
+export function visibleFindings(findings: EditorialFinding[], dismissed: ReadonlySet<string>): EditorialFinding[] {
+  return findings
+    .filter((finding) => !dismissed.has(finding.id))
+    .sort(
+      (a, b) =>
+        SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity] ||
+        a.span.start - b.span.start ||
+        a.policyId.localeCompare(b.policyId),
+    );
+}
+
+/** Findings that can be marked in the text (document-level ones have no excerpt). */
+export function inlineFindings(findings: EditorialFinding[]): EditorialFinding[] {
+  return findings.filter((finding) => finding.excerpt.length > 0 && finding.span.end > finding.span.start);
+}
+
+export type FindingGroup = { policyId: string; severity: Severity; findings: EditorialFinding[] };
+
+export function groupByPolicy(findings: EditorialFinding[]): FindingGroup[] {
+  const groups = new Map<string, FindingGroup>();
+  for (const finding of findings) {
+    const group = groups.get(finding.policyId) ?? { policyId: finding.policyId, severity: finding.severity, findings: [] };
+    group.findings.push(finding);
+    if (SEVERITY_ORDER[finding.severity] < SEVERITY_ORDER[group.severity]) group.severity = finding.severity;
+    groups.set(finding.policyId, group);
+  }
+  return [...groups.values()].sort((a, b) => SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity] || a.policyId.localeCompare(b.policyId));
+}
+
+/** Open findings that should make an editor pause before publishing (never a block). */
+export function publishWarnings(findings: EditorialFinding[], dismissed: ReadonlySet<string>): EditorialFinding[] {
+  return visibleFindings(findings, dismissed).filter((finding) => finding.severity !== "info" && finding.status === "violation");
+}
+
+/** The text of the segment a finding sits in, which becomes a few-shot example for the classifier. */
+export function findingSegmentText(result: EditorialCheckResult, body: string, finding: EditorialFinding): string | null {
+  const segment = result.segments.find((candidate) => candidate.id === finding.segmentId);
+  if (!segment || segment.kind === "document") return null;
+  return body.slice(segment.start, segment.end);
+}
+
+export function feedbackFor(
+  result: EditorialCheckResult,
+  body: string,
+  finding: EditorialFinding,
+  decision: FeedbackDecision,
+  itemId: string | null,
+  reason: string | null = null,
+): EditorialFeedbackInput {
+  return {
+    itemId: itemId ?? UNSAVED_ITEM_ID,
+    findingId: finding.id,
+    policyId: finding.policyId,
+    detectorId: finding.detectorId,
+    lane: finding.lane,
+    probability: finding.rawProbability ?? finding.probability ?? null,
+    decision,
+    reason: reason?.trim() ? reason.trim() : null,
+    text: finding.lane === "classifier" ? findingSegmentText(result, body, finding) : null,
+  };
+}
+
+/** Replace one span of the body; the span must still hold the text it was computed for. */
+export function applyReplacement(body: string, span: Span, expected: string, replacement: string): string | null {
+  if (body.slice(span.start, span.end) !== expected) return null;
+  return body.slice(0, span.start) + replacement + body.slice(span.end);
+}
+
+export function describeProbability(finding: EditorialFinding): string | null {
+  if (finding.probability === undefined) return null;
+  return `${Math.round(finding.probability * 100)}% sure`;
+}
+
+export function laneNotice(result: EditorialCheckResult): string | null {
+  const classifier = result.lanes.classifier;
+  if (classifier.status === "partial") return `Some sentences were not judged: ${classifier.reason ?? "the check ran out of time"}.`;
+  if (classifier.status === "failed") return `The judgment checks failed: ${classifier.reason ?? "unknown error"}. Rule checks still ran.`;
+  if (classifier.status === "unavailable" && (classifier.detectors ?? 0) === 0 && classifier.reason) return `Judgment checks are not configured: ${classifier.reason}.`;
+  return null;
+}

package/lib/editorial-preview.ts

@@ -0,0 +1,228 @@
+/**
+ * Places Limatus findings on the rendered Markus preview.
+ *
+ * Limatus reports spans in the markup; the preview renders an IR tree with no
+ * character offsets. Both sides agree on the words a reader sees, so findings
+ * are placed by text: each Limatus paragraph is matched, in document order, to
+ * the rendered prose block with the same words, and each finding's plain
+ * excerpt is located inside that block. Whitespace is ignored while matching,
+ * because rendering and Limatus collapse it differently (citations, breaks).
+ *
+ * "Rendered text" is defined by `inlineLeaves`, which the preview renderer also
+ * uses, so offsets computed here are offsets the renderer can split on.
+ */
+import type { EditorialCheckResult, EditorialFinding, Severity, Span } from "./editorial-checks";
+import type { MarkusBlock, MarkusDocument, MarkusInline, MarkusNode } from "./markus-ir";
+
+export const CITATION_TOKEN = /PAPYRUSMARKUP\d{5}END/g;
+
+export type InlineLeaf =
+  | { kind: "text"; node: MarkusInline & { type: "text" }; start: number; pieces: { raw: string; start: number; isToken: boolean }[] }
+  | { kind: "code"; node: MarkusInline & { type: "code_span" }; start: number; text: string }
+  | { kind: "break"; start: number; text: string }
+  | { kind: "opaque"; start: number };
+
+/** The reader-visible text of a run of inlines; citation tokens and images take no width. */
+export function inlineLeaves(inlines: MarkusInline[], offset = 0): { leaves: InlineLeaf[]; text: string } {
+  const leaves: InlineLeaf[] = [];
+  let text = "";
+  const walk = (nodes: MarkusInline[]) => {
+    for (const node of nodes) {
+      const start = offset + text.length;
+      switch (node.type) {
+        case "text": {
+          const pieces: { raw: string; start: number; isToken: boolean }[] = [];
+          let cursor = 0;
+          let plainLength = 0;
+          for (const match of node.text.matchAll(CITATION_TOKEN)) {
+            const index = match.index ?? 0;
+            if (index > cursor) {
+              pieces.push({ raw: node.text.slice(cursor, index), start: start + plainLength, isToken: false });
+              plainLength += index - cursor;
+            }
+            pieces.push({ raw: match[0], start: start + plainLength, isToken: true });
+            cursor = index + match[0].length;
+          }
+          if (cursor < node.text.length) {
+            pieces.push({ raw: node.text.slice(cursor), start: start + plainLength, isToken: false });
+            plainLength += node.text.length - cursor;
+          }
+          leaves.push({ kind: "text", node, start, pieces });
+          text += pieces.filter((piece) => !piece.isToken).map((piece) => piece.raw).join("");
+          break;
+        }
+        case "code_span":
+          leaves.push({ kind: "code", node, start, text: node.code });
+          text += node.code;
+          break;
+        case "soft_break":
+        case "hard_break":
+          leaves.push({ kind: "break", start, text: " " });
+          text += " ";
+          break;
+        case "emphasis":
+        case "strong":
+        case "strikethrough":
+        case "link":
+          walk(node.children);
+          break;
+        default:
+          leaves.push({ kind: "opaque", start });
+      }
+    }
+  };
+  walk(inlines);
+  return { leaves, text };
+}
+
+/** Prose blocks (paragraphs and headings, including those inside lists, quotes and directives) in reading order. */
+export function proseBlocks(document: MarkusDocument): (MarkusBlock & { inline: MarkusInline[] })[] {
+  const blocks: (MarkusBlock & { inline: MarkusInline[] })[] = [];
+  const visit = (nodes: MarkusNode[]) => {
+    for (const node of nodes) {
+      if (node.type === "directive") visit(node.children);
+      else if (node.type === "paragraph" || node.type === "heading") blocks.push(node);
+      else if (node.type === "list") for (const item of node.items) visit(item.children);
+      else if (node.type === "blockquote") visit(node.children);
+    }
+  };
+  visit(document.children);
+  return blocks;
+}
+
+export type PreviewMark = Span & { findingIds: string[]; severity: Severity; status: EditorialFinding["status"] };
+export type PreviewSentence = Span & { segmentId: string; source: Span };
+
+/** What the preview needs for one rendered block, in that block's rendered-text offsets. */
+export type BlockAnnotation = { marks: PreviewMark[]; sentences: PreviewSentence[] };
+
+export type PreviewPlan = WeakMap<object, BlockAnnotation>;
+
+const SEVERITY_RANK: Record<Severity, number> = { error: 0, warn: 1, info: 2 };
+
+/** Text without whitespace, with a map from each kept character back to its index in the original. */
+function compact(text: string): { value: string; index: number[] } {
+  let value = "";
+  const index: number[] = [];
+  for (let i = 0; i < text.length; i += 1) {
+    if (!/\s/.test(text[i])) {
+      value += text[i];
+      index.push(i);
+    }
+  }
+  return { value, index };
+}
+
+/** Locate `needle` in `haystack` ignoring whitespace; the occurrence nearest `near` (a 0..1 position) wins. */
+export function locate(haystack: string, needle: string, near = 0): Span | null {
+  const hay = compact(haystack);
+  const want = compact(needle).value;
+  if (!want) return null;
+  let best: number | null = null;
+  for (let at = hay.value.indexOf(want); at !== -1; at = hay.value.indexOf(want, at + 1)) {
+    if (best === null || Math.abs(at / Math.max(hay.value.length, 1) - near) < Math.abs(best / Math.max(hay.value.length, 1) - near)) best = at;
+  }
+  if (best === null) return null;
+  return { start: hay.index[best], end: hay.index[best + want.length - 1] + 1 };
+}
+
+/** The identity of a block's words: no whitespace, no stray emphasis or code markers. */
+function blockKey(text: string): string {
+  return compact(text).value.replace(/[*_`~]/g, "");
+}
+
+/** Match every Limatus paragraph to a rendered block and place its findings and sentences there. */
+export function planPreview(
+  document: MarkusDocument,
+  result: EditorialCheckResult,
+  findings: EditorialFinding[],
+): PreviewPlan {
+  const plan: PreviewPlan = new WeakMap();
+  const blocks = proseBlocks(document).map((block) => ({ block, text: inlineLeaves(block.inline).text }));
+  const paragraphs = result.segments.filter((segment) => segment.kind === "paragraph" && segment.text);
+  let cursor = 0;
+  for (const paragraph of paragraphs) {
+    const wanted = blockKey(paragraph.text ?? "");
+    let matched = -1;
+    for (let candidate = cursor; candidate < blocks.length; candidate += 1) {
+      if (blockKey(blocks[candidate].text) === wanted) {
+        matched = candidate;
+        break;
+      }
+    }
+    if (matched === -1) continue;
+    cursor = matched + 1;
+    const { block, text } = blocks[matched];
+    const sentences: PreviewSentence[] = [];
+    for (const sentence of result.segments.filter((s) => s.kind === "sentence" && s.parentId === paragraph.id)) {
+      const near = (sentence.start - paragraph.start) / Math.max(paragraph.end - paragraph.start, 1);
+      const span = locate(text, sentence.text ?? "", near);
+      if (span) sentences.push({ ...span, segmentId: sentence.id, source: { start: sentence.start, end: sentence.end } });
+    }
+    const ranges: (Span & { finding: EditorialFinding })[] = [];
+    for (const finding of findings) {
+      const inParagraph =
+        finding.segmentId === paragraph.id ||
+        result.segments.some((s) => s.id === finding.segmentId && s.parentId === paragraph.id);
+      if (!inParagraph || !finding.excerptText) continue;
+      const near = (finding.span.start - paragraph.start) / Math.max(paragraph.end - paragraph.start, 1);
+      const span = locate(text, finding.excerptText, near);
+      if (span) ranges.push({ ...span, finding });
+    }
+    plan.set(block, { marks: flatten(ranges), sentences });
+  }
+  return plan;
+}
+
+/** Overlapping finding ranges become non-overlapping marks, each listing every finding it belongs to. */
+function flatten(ranges: (Span & { finding: EditorialFinding })[]): PreviewMark[] {
+  const cuts = [...new Set(ranges.flatMap((range) => [range.start, range.end]))].sort((a, b) => a - b);
+  const marks: PreviewMark[] = [];
+  for (let i = 0; i < cuts.length - 1; i += 1) {
+    const start = cuts[i];
+    const end = cuts[i + 1];
+    const covering = ranges.filter((range) => range.start <= start && end <= range.end).map((range) => range.finding);
+    if (covering.length === 0) continue;
+    const strongest = [...covering].sort((a, b) => SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity])[0];
+    const previous = marks[marks.length - 1];
+    const ids = covering.map((finding) => finding.id).sort();
+    if (previous && previous.end === start && previous.findingIds.join() === ids.join()) {
+      previous.end = end;
+      continue;
+    }
+    marks.push({
+      start,
+      end,
+      findingIds: ids,
+      severity: strongest.severity,
+      status: covering.every((finding) => finding.status === "review") ? "review" : "violation",
+    });
+  }
+  return marks;
+}
+
+/** A selection on the preview, as the source span of the whole sentences it touches. */
+export function selectionToSource(annotation: BlockAnnotation | undefined, selection: Span): Span | null {
+  if (!annotation) return null;
+  const touched = annotation.sentences.filter((sentence) => sentence.start < selection.end && selection.start < sentence.end);
+  if (touched.length === 0) return null;
+  return {
+    start: Math.min(...touched.map((sentence) => sentence.source.start)),
+    end: Math.max(...touched.map((sentence) => sentence.source.end)),
+  };
+}
+
+/** Split [start, end) of rendered text at mark boundaries; each piece says which mark (if any) covers it. */
+export function splitByMarks(start: number, end: number, marks: PreviewMark[]): { start: number; end: number; mark: PreviewMark | null }[] {
+  const pieces: { start: number; end: number; mark: PreviewMark | null }[] = [];
+  let cursor = start;
+  for (const mark of marks) {
+    if (mark.end <= cursor || mark.start >= end) continue;
+    if (mark.start > cursor) pieces.push({ start: cursor, end: mark.start, mark: null });
+    const pieceEnd = Math.min(mark.end, end);
+    pieces.push({ start: Math.max(mark.start, cursor), end: pieceEnd, mark });
+    cursor = pieceEnd;
+  }
+  if (cursor < end) pieces.push({ start: cursor, end, mark: null });
+  return pieces;
+}

package/lib/newsroom-board.ts

@@ -21,6 +21,31 @@ export interface NativeBoardIssue extends KanbanIssue {
   href: string;
   /** A few lines to show under the headline: the blurb, else the subtitle. */
   excerpt?: string;
+  /** The quiet path shown where a board would print the ID, e.g. `articles/my-slug` or `assignments/write-it`. */
+  displayId: string;
+}
+
+function slugify(text: string): string {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+/** Section and slug for a content item, falling back to the publication's board path segment. */
+export function contentItemDisplayId(version: { section?: string | null; slug?: string | null; lineageId: string }): string {
+  const section = slugify(version.section ?? "") || contentItemBoardPathSegment();
+  return `${section}/${slugify(version.slug ?? "") || version.lineageId.slice(0, 8)}`;
+}
+
+/** Assignments have no slug: use the title as one, else a short id. */
+export function assignmentDisplayId(assignment: { id: string; title?: string | null }): string {
+  const titleSlug = slugify(assignment.title ?? "").slice(0, 48).replace(/-+$/g, "");
+  return `assignments/${titleSlug || assignment.id.slice(0, 8)}`;
+}
+
+/** `formatIssueId` for the Kanbus UI: the host-provided path, never the raw `kind:id` prefix. */
+export function formatNativeIssueId(issue: KanbanIssue): string {
+  const displayId = (issue as Partial<NativeBoardIssue>).displayId;
+  if (displayId) return displayId;
+  return issue.id.replace(/^[A-Za-z]+:/, "").slice(0, 12);
 }
 
 export function contentItemBoardPathSegment(): string {
@@ -60,7 +85,7 @@ export function projectContentItemBoard(records: {
       title: version.headline || version.title || version.slug, nativeStatus: stage, status: `${contentItemType}/${stage}`,
       priority: 2, description: workCount ? `${workCount} assignment${workCount === 1 ? "" : "s"} on this ${contentItemType}.` : undefined,
       updated_at: version.updatedAt ?? undefined, href: `/newsroom/articles/${encodeURIComponent(version.id)}`,
-      excerpt: contentItemExcerpt(version),
+      excerpt: contentItemExcerpt(version), displayId: contentItemDisplayId(version),
     };
   });
 }
@@ -73,7 +98,7 @@ export function projectAssignmentBoard(assignments: readonly AssignmentRecord[])
     priority: row.priority ?? 2, assignee: row.assigneeId || undefined,
     description: row.summary || row.brief || undefined,
     created_at: row.createdAt, updated_at: row.updatedAt,
-    href: `/newsroom/assignments/${encodeURIComponent(row.id)}`,
+    href: `/newsroom/assignments/${encodeURIComponent(row.id)}`, displayId: assignmentDisplayId(row),
   }));
 }
 

package/lib/newsroom-list-selection.ts

@@ -22,9 +22,6 @@ export const NEWSROOM_INBOX_ROW_ACTIVE =
 export const NEWSROOM_SIDEBAR_NAV_ACTIVE =
   "bg-primary/10 text-foreground shadow-none hover:bg-primary/15";
 
-export const NEWSROOM_SIDEBAR_NAV_INACTIVE =
-  "text-muted-foreground hover:bg-muted/50 hover:text-foreground";
-
 export function newsroomListRowClassName(active: boolean, className?: string): string {
   return cn(
     NEWSROOM_LIST_ROW_BASE,

package/lib/newsroom-nav.ts

@@ -18,23 +18,20 @@ export type NewsroomNavItem = {
   label: string;
   detail: string;
   href: string;
-  mobilePrimary?: boolean;
 };
 
 export const NEWSROOM_OPS_NAV: NewsroomNavItem[] = [
-  { id: "overview", label: "Overview", detail: "Desk home", href: newsroomHref(), mobilePrimary: true },
-  { id: "articles", label: getContentItemName().plural, detail: "Drafts & published", href: newsroomHref("articles"), mobilePrimary: true },
-  { id: "assignments", label: "Assignments", detail: "Work queue", href: newsroomHref("assignments"), mobilePrimary: true },
-  { id: "references", label: "References", detail: "Knowledge base", href: newsroomHref("references"), mobilePrimary: true },
+  { id: "overview", label: "Overview", detail: "Desk home", href: newsroomHref() },
+  { id: "articles", label: getContentItemName().plural, detail: "Drafts & published", href: newsroomHref("articles") },
+  { id: "assignments", label: "Assignments", detail: "Work queue", href: newsroomHref("assignments") },
+  { id: "references", label: "References", detail: "Knowledge base", href: newsroomHref("references") },
   { id: "messages", label: "Messages", detail: "Forum", href: newsroomHref("messages") },
-  { id: "topics", label: "Topics", detail: "Taxonomy", href: newsroomHref("topics"), mobilePrimary: true },
+  { id: "topics", label: "Topics", detail: "Taxonomy", href: newsroomHref("topics") },
   { id: "concepts", label: "Concept wiki", detail: "Knowledge graph", href: newsroomHref("concepts") },
   { id: "search", label: "Search", detail: "Knowledge base", href: newsroomHref("search") },
   { id: "administration", label: "Administration", detail: "Users & policies", href: newsroomHref("administration") },
 ];
 
-export const NEWSROOM_MOBILE_PRIMARY_NAV = NEWSROOM_OPS_NAV.filter((item) => item.mobilePrimary);
-
 export function getNewsroomNavHref(href: string, demo?: boolean): string {
   const path = toPublicNewsroomPath(href);
   if (!demo) return path;

package/lib/newsroom-section-routing.ts

@@ -1,16 +1,14 @@
 import type { NewsDeskTab } from "../components/topic-steering-workspace";
 
-/** The organizer restores the existing taxonomy editor; legacy sites retain their aliases. */
+/** Resolves the requested newsroom section, mapping retired aliases onto their current destinations. */
 export function resolveNewsDeskTab(
   sectionValue: string | string[] | null | undefined,
   legacyTabValue: string | string[] | null | undefined,
-  organizer = false,
 ): NewsDeskTab {
   const section = Array.isArray(sectionValue) ? sectionValue[0] : sectionValue;
   const legacyTab = Array.isArray(legacyTabValue) ? legacyTabValue[0] : legacyTabValue;
   const raw = section ?? (legacyTab === "categories" ? "topics" : legacyTab);
-  const value = raw === "users" || raw === "doctrine" ? "administration"
-    : raw === "desks" && !organizer ? "topics" : raw;
+  const value = raw === "users" || raw === "doctrine" ? "administration" : raw;
   switch (value) {
     case "desks": case "administration": case "topics": case "concepts":
     case "references": case "messages": case "assignments": case "search":

package/lib/relevance-status.ts

@@ -127,10 +127,10 @@ export function isPrimingOutcome(value: unknown): value is PrimingOutcome {
     || (outcome.state === "failed" && typeof outcome.message === "string");
 }
 
-/** In words: waiting for the next sweep, applied as version N, or failed with the reason. */
+/** In plain words: Adding, Added, or Couldn't add with the reason. */
 export function primingStateText(view: PrimingRequestView): string {
-  if (!view.outcome) return "Waiting for the next sweep";
+  if (!view.outcome) return "Adding";
   return view.outcome.state === "applied"
-    ? `Applied as version ${view.outcome.version}`
-    : `Failed: ${view.outcome.message}`;
+    ? "Added"
+    : `Couldn't add: ${view.outcome.message}`;
 }

package/lib/site-brand.ts

@@ -1,9 +1,9 @@
-import { isLocalPreviewEnabled } from "./local-preview";
 import { areEditionsEnabled } from "./site-env";
 import type { ComponentType } from "react";
 import type { EditionPresentationFormat } from "./content-types";
 import type { Article, ArticleVideoAsset } from "./articles";
 import type { BlogPageBackgroundProps } from "../components/blog-page-background";
+import type { KanbusThemeId } from "@kanbus/ui";
 import type { SiteBrandFont } from "./brand-fonts";
 import type { PictogramFigureProps } from "../components/pictogram-figure";
 import papyrusSite from "papyrus-site";
@@ -119,6 +119,13 @@ export type SiteBrand = {
   defaultVideoCredit?: string;
   themePack: ThemePackId;
   themeTokens: ThemePackTokens;
+  /**
+   * The Kanbus editorial theme the whole newsroom (sidebar, toolbar, boards,
+   * detail panel) renders in. Hard-coded per publication: editors cannot
+   * change it. Per-publication tweaks are `--kb-theme-*` overrides in the
+   * publication's `theme.css`, scoped to `[data-kanbus-theme]`.
+   */
+  kanbusTheme: KanbusThemeId;
   renderer: RendererConfig;
   hosting: HostingConfig;
   /** Static reader app when it is not co-hosted with this Papyrus checkout. */
@@ -134,8 +141,6 @@ export type SiteBrand = {
   /** Public URL prefix for the Pretext reader (home, editions, articles, archive, settings). Default `""`; e.g. `/information`. */
   readerBasePath?: string;
   opsChrome: OpsChrome;
-  /** Opt-in CMS viewport layout; independent of the public reader renderer/theme. */
-  newsroomLayout?: "organizer";
   corpusKey: string;
   steeringConfigPath: string;
   newsroomSectionsConfigPath: string;
@@ -185,6 +190,7 @@ const REFERENCE_SITE_BRANDS: Record<SiteBrandId, SiteBrand> = {
     sectionLinkStrategy: "route",
     themePack: "papyrus",
     themeTokens: DEFAULT_THEME_PACK_TOKENS,
+    kanbusTheme: "broadsheet-green",
     renderer: { kind: "pretext" },
     hosting: { kind: "amplify-ssr" },
     opsChrome: "app",
@@ -205,11 +211,7 @@ const REGISTERED_SITE_BRANDS: Record<SiteBrandId, SiteBrand> = {
   ...Object.fromEntries((papyrusSite.brands ?? []).map((brand) => [brand.id, brand])),
 };
 
-const SITE_BRANDS: Record<SiteBrandId, SiteBrand> = isLocalPreviewEnabled()
-  ? Object.fromEntries(
-      Object.entries(REGISTERED_SITE_BRANDS).map(([id, brand]) => [id, { ...brand, newsroomLayout: "organizer" as const }]),
-    )
-  : REGISTERED_SITE_BRANDS;
+const SITE_BRANDS: Record<SiteBrandId, SiteBrand> = REGISTERED_SITE_BRANDS;
 
 export function normalizeSiteBrandId(value: string | undefined | null): SiteBrandId | null {
   if (!value) return null;
@@ -244,6 +246,14 @@ export function getSiteBrand(id: SiteBrandId = resolveSiteBrandId()): SiteBrand
 
 export const SITE_BRAND = getSiteBrand();
 
+/** Mirrors `DEFAULT_KANBUS_THEME` from `@kanbus/ui` (a test keeps the two equal) without a runtime import. */
+export const FALLBACK_KANBUS_THEME: KanbusThemeId = "newspaper-gothic";
+
+/** The newsroom theme for a brand; a brand that predates the field falls back to the default theme. */
+export function getKanbusTheme(brand: Pick<SiteBrand, "kanbusTheme"> = SITE_BRAND): KanbusThemeId {
+  return brand.kanbusTheme ?? FALLBACK_KANBUS_THEME;
+}
+
 export function getContentItemName(brand: SiteBrand = SITE_BRAND): ContentItemName {
   return brand.contentItemName ?? DEFAULT_CONTENT_ITEM_NAME;
 }