@anthusai/papyrus 1.4.0-next.1 → 1.4.0-next.3

package/amplify/functions/shared/python-bundle.js

@@ -126,9 +126,9 @@ function bundleFromPip(outputDir, options) {
 }
 export function bundleFromCheckout(outputDir, options) {
     fs.copyFileSync(path.join(packageRoot, "amplify/functions", options.functionDir, "handler.py"), path.join(outputDir, "handler.py"));
-    for (const module of options.modules) {
-        fs.mkdirSync(path.join(outputDir, module), { recursive: true });
-        fs.cpSync(path.join(packageRoot, "src", module), path.join(outputDir, module), { recursive: true });
+    for (const moduleName of options.modules) {
+        fs.mkdirSync(path.join(outputDir, moduleName), { recursive: true });
+        fs.cpSync(path.join(packageRoot, "src", moduleName), path.join(outputDir, moduleName), { recursive: true });
     }
     options.checkoutExtras?.(outputDir);
     copySiteFiles(outputDir, options.siteFiles);

package/amplify/functions/shared/python-bundle.ts

@@ -164,9 +164,9 @@ export function bundleFromCheckout(outputDir: string, options: PythonBundleOptio
     path.join(packageRoot, "amplify/functions", options.functionDir, "handler.py"),
     path.join(outputDir, "handler.py"),
   );
-  for (const module of options.modules) {
-    fs.mkdirSync(path.join(outputDir, module), { recursive: true });
-    fs.cpSync(path.join(packageRoot, "src", module), path.join(outputDir, module), { recursive: true });
+  for (const moduleName of options.modules) {
+    fs.mkdirSync(path.join(outputDir, moduleName), { recursive: true });
+    fs.cpSync(path.join(packageRoot, "src", moduleName), path.join(outputDir, moduleName), { recursive: true });
   }
   options.checkoutExtras?.(outputDir);
   copySiteFiles(outputDir, options.siteFiles);

package/app/newsroom/[section]/page.tsx

@@ -1,6 +1,7 @@
 import { resolveActiveSiteBrand } from "../../../lib/site-brand-tenant";
 import { notFound, redirect } from "next/navigation";
 import { toPublicNewsroomPath } from "../../../lib/newsroom-base-path";
+import { contentItemBoardPathSegment } from "../../../lib/newsroom-board";
 import { NewsroomBoardView } from "../../../components/newsroom-board-view";
 import { NewsDeskPage } from "../../../components/news-desk-page";
 import type { NewsDeskTab } from "../../../components/topic-steering-workspace";
@@ -43,10 +44,11 @@ const NEWS_DESK_ROUTE_SECTIONS = new Set<NewsDeskTab>([
 
 export default async function NewsDeskSectionPage({ params, searchParams }: NewsDeskSectionPageProps) {
   const { section } = await params;
-  if (section === "work") redirect(toPublicNewsroomPath("/newsroom/articles"));
+  if (section === "work") redirect(toPublicNewsroomPath(`/newsroom/${contentItemBoardPathSegment()}`));
   if (section === "users") redirect(toPublicNewsroomPath("/newsroom/administration/users"));
   if (section === "doctrine") redirect(toPublicNewsroomPath("/newsroom/administration/policies"));
   if (section === "desks" && resolveActiveSiteBrand().newsroomLayout !== "organizer") redirect(toPublicNewsroomPath("/newsroom/topics"));
+  if (section === contentItemBoardPathSegment() && resolveActiveSiteBrand().newsroomLayout === "organizer") return <NewsroomBoardView subject="contentItem" />;
   if (!NEWS_DESK_ROUTE_SECTIONS.has(section as NewsDeskTab)) notFound();
   if (section === "assignments" && resolveActiveSiteBrand().newsroomLayout === "organizer") {
     const resolved = await searchParams;

package/app/newsroom/articles/page.tsx

@@ -1,3 +1,6 @@
+import { redirect } from "next/navigation";
+import { contentItemBoardPathSegment } from "../../../lib/newsroom-board";
+import { toPublicNewsroomPath } from "../../../lib/newsroom-base-path";
 import { NewsroomBoardView } from "../../../components/newsroom-board-view";
 import { resolveActiveSiteBrand } from "../../../lib/site-brand-tenant";
 import { NewsroomArticlesView } from "../../../components/newsroom-articles-view";
@@ -11,6 +14,10 @@ type NewsroomArticlesPageProps = {
 export default async function NewsroomArticlesPage({ searchParams }: NewsroomArticlesPageProps) {
   const resolved = await searchParams;
   const demoValue = Array.isArray(resolved?.demo) ? resolved?.demo[0] : resolved?.demo;
-  if (resolveActiveSiteBrand().newsroomLayout === "organizer" && demoValue !== "1") return <NewsroomBoardView subject="contentItem" />;
+  if (resolveActiveSiteBrand().newsroomLayout === "organizer" && demoValue !== "1") {
+    const boardPathSegment = contentItemBoardPathSegment();
+    if (boardPathSegment !== "articles") redirect(toPublicNewsroomPath(`/newsroom/${boardPathSegment}`));
+    return <NewsroomBoardView subject="contentItem" />;
+  }
   return <NewsroomArticlesView demo={demoValue === "1"} />;
 }

package/app/newsroom/sections/[sectionId]/page.tsx

@@ -1,4 +1,6 @@
 import { notFound } from "next/navigation";
+import { resolveActiveSiteBrand } from "../../../../lib/site-brand-tenant";
+import { NewsroomBoardView } from "../../../../components/newsroom-board-view";
 import { NewsDeskPage } from "../../../../components/news-desk-page";
 
 export const dynamic = "force-dynamic";
@@ -13,5 +15,6 @@ export default async function NewsroomDeepSectionPage({ params, searchParams }:
   const normalizedSectionId = decodeURIComponent(sectionId ?? "").trim();
   if (!normalizedSectionId) notFound();
 
+  if (resolveActiveSiteBrand().newsroomLayout === "organizer") return <NewsroomBoardView subject="desk" deskId={normalizedSectionId} />;
   return <NewsDeskPage sectionPageId={normalizedSectionId} searchParams={searchParams} />;
 }

package/components/news-desk-taxonomy-client.ts

@@ -41,7 +41,7 @@ import type {
   UserDirectoryEntry,
 } from "../lib/category-repository";
 import { relationTypeKey } from "../lib/semantic-graph";
-import { contentItemStageKeys, type ContentItemVersionRecord } from "../lib/content-item-lifecycle";
+import { legacyStageKeysToLoad, type ContentItemVersionRecord } from "../lib/content-item-lifecycle";
 import { getContentItemStageDefinitions } from "../lib/site-brand";
 import { DOCTRINE_DEFINITIONS, getCategoryDoctrineDefinitions, type DoctrineCategory } from "../lib/doctrine";
 import { configureAmplifyClient } from "./amplify-client-provider";
@@ -2172,31 +2172,45 @@ const CONTENT_ITEMS_BY_STAGE_QUERY = `
   }
 `;
 
-export async function loadNewsroomContentItemVersions(): Promise<ContentItemVersionRecord[]> {
-  if (isLocalPreviewEnabled()) return createLocalPreviewContentItemVersions();
+export const CONTENT_ITEM_COLUMN_PAGE_LIMIT = 25;
+
+export type ContentItemStagePage = {
+  versions: ContentItemVersionRecord[];
+  nextToken: string | null;
+};
+
+/** One newest-updated-first page of the content items in one stage, so a board column can load as it is scrolled. */
+export async function loadNewsroomContentItemStagePage(
+  stage: string,
+  nextToken: string | null = null,
+  limit: number = CONTENT_ITEM_COLUMN_PAGE_LIMIT,
+): Promise<ContentItemStagePage> {
+  if (isLocalPreviewEnabled()) {
+    const versionsInStage = createLocalPreviewContentItemVersions().filter(version => version.stage === stage);
+    const offset = nextToken ? Number(nextToken) : 0;
+    const followingOffset = offset + limit;
+    return {
+      versions: versionsInStage.slice(offset, followingOffset),
+      nextToken: followingOffset < versionsInStage.length ? String(followingOffset) : null,
+    };
+  }
   configureAmplifyClient();
   const client = generateClient<Schema>() as unknown as {
     graphql: (options: Record<string, unknown>) => Promise<GraphQLConnectionResponse<ContentItemVersionRecord>>;
   };
   const field = "listItemsByStageAndUpdatedAt";
-  const versionsPerStage = await Promise.all(contentItemStageKeys(getContentItemStageDefinitions()).map(async (stage) => {
-    const versions: ContentItemVersionRecord[] = [];
-    let nextToken: string | null = null;
-    do {
-      const response: GraphQLConnectionResponse<ContentItemVersionRecord> = await client.graphql({
-        query: CONTENT_ITEMS_BY_STAGE_QUERY,
-        variables: { stage, sortDirection: "DESC", limit: NEWSROOM_PAGE_LIMIT, nextToken },
-        authMode: USER_POOL_AUTH_MODE,
-      });
-      assertNoGraphQLErrors(response.errors);
-      const connection = response.data?.[field];
-      if (!connection) throw new Error(`Missing GraphQL connection payload for ${field}.`);
-      versions.push(...((connection.items ?? []).filter(Boolean) as ContentItemVersionRecord[]));
-      nextToken = connection.nextToken ?? null;
-    } while (nextToken);
-    return versions;
-  }));
-  return versionsPerStage.flat();
+  const response: GraphQLConnectionResponse<ContentItemVersionRecord> = await client.graphql({
+    query: CONTENT_ITEMS_BY_STAGE_QUERY,
+    variables: { stage, sortDirection: "DESC", limit, nextToken },
+    authMode: USER_POOL_AUTH_MODE,
+  });
+  assertNoGraphQLErrors(response.errors);
+  const connection = response.data?.[field];
+  if (!connection) throw new Error(`Missing GraphQL connection payload for ${field}.`);
+  return {
+    versions: (connection.items ?? []).filter(Boolean) as ContentItemVersionRecord[],
+    nextToken: connection.nextToken ?? null,
+  };
 }
 
 const PUBLISHED_ITEMS_QUERY = `
@@ -2222,6 +2236,7 @@ type PublishedItemBoardRow = {
 };
 
 export async function loadNewsroomPublishedContentItemVersions(): Promise<ContentItemVersionRecord[]> {
+  if (isLocalPreviewEnabled()) return [];
   configureAmplifyClient();
   const client = generateClient<Schema>() as unknown as {
     graphql: (options: Record<string, unknown>) => Promise<GraphQLConnectionResponse<PublishedItemBoardRow>>;

package/components/newsroom-board-view.tsx

@@ -2,12 +2,10 @@
 
 import { useEffect, useMemo, useRef, useState } from "react";
 import Link from "next/link";
-import { IssueCollection, IssueDetailPanel } from "@kanbus/ui";
+import { IssueCollection, IssueDetailPanel, IssueTypeFilter, issueTypeFromFilter, useBoardColumnState } from "@kanbus/ui";
 import "@kanbus/ui/styles/kanban.css";
 import "./newsroom-newsprint-board.css";
 import { PlusIcon } from "lucide-react";
-import { buttonVariants } from "./ui/button";
-import { cn } from "../lib/utils";
 import { newsroomHref } from "../lib/newsroom-base-path";
 import {
   ASSIGNMENT_BOARD_TYPE,
@@ -15,14 +13,20 @@ import {
   canReadNewsroomBoard,
   contentItemBoardConfig,
   contentItemBoardType,
+  deskBoardConfig,
+  deskContainsAssignment,
+  deskContainsContentItem,
   projectAssignmentBoard,
   projectContentItemBoard,
   type NativeBoardIssue,
 } from "../lib/newsroom-board";
-import type { AssignmentRecord } from "../lib/category-repository";
-import { getContentItemName, SITE_BRAND } from "../lib/site-brand";
+import type { AssignmentRecord, NewsroomSectionRecord } from "../lib/category-repository";
+import { displayNewsroomSectionShortTitle } from "../lib/newsroom-sections";
+import { getContentItemName, getContentItemStageDefinitions, SITE_BRAND } from "../lib/site-brand";
 import { getNewsroomNavHref } from "../lib/newsroom-nav";
-import { loadNewsroomAssignmentPage, loadNewsroomContentItemVersions, loadNewsroomPublishedContentItemVersions } from "./news-desk-taxonomy-client";
+import { loadNewsroomAssignmentPage, loadNewsroomPublishedContentItemVersions } from "./news-desk-taxonomy-client";
+import { usePagedContentItemVersions } from "./use-paged-content-item-versions";
+import type { ContentItemVersionRecord } from "../lib/content-item-lifecycle";
 import { useOptionalNewsDeskClient } from "./news-desk-client-provider";
 import { NewsDeskAccessGate } from "./newsroom-access-gate";
 import { NewsroomOpsShell, NewsroomOpsStatusBanner } from "./newsroom-ops-shell";
@@ -31,6 +35,7 @@ import { readLocalReaderSettings, subscribeReaderSettingsChanges } from "./reade
 
 const STATIC_MOTION = { mode: "static" } as const;
 const BOARD_REFRESH_INTERVAL_MILLISECONDS = 30_000;
+const COLUMN_LOAD_MORE_DISTANCE_PIXELS = 240;
 
 async function loadEveryNewsroomAssignment() {
   const assignments: AssignmentRecord[] = [];
@@ -43,43 +48,59 @@ async function loadEveryNewsroomAssignment() {
   return assignments;
 }
 
-export type NewsroomBoardSubject = "contentItem" | "assignment";
+export type NewsroomBoardSubject = "contentItem" | "assignment" | "desk";
 
 /** Read-only board of one record kind over authenticated CMS records; existing workspaces own every mutation. */
-export function NewsroomBoardView({ subject }: { subject: NewsroomBoardSubject }) {
+export function NewsroomBoardView({ subject, deskId }: { subject: NewsroomBoardSubject; deskId?: string }) {
   const session = useOptionalNewsDeskClient();
   const allowed = canReadNewsroomBoard(session?.shell.phase);
   const theme = useResolvedPapyrusTheme();
   const [lowMotion, setLowMotion] = useState(false);
-  const [issues, setIssues] = useState<NativeBoardIssue[]>([]);
+  const [assignmentBoardIssues, setAssignmentBoardIssues] = useState<NativeBoardIssue[]>([]);
+  const [publishedVersions, setPublishedVersions] = useState<ContentItemVersionRecord[]>([]);
+  const [assignments, setAssignments] = useState<AssignmentRecord[]>([]);
   const [view, setView] = useState<"board" | "list">("board");
   const [selected, setSelected] = useState<string | null>(null);
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState<string | null>(null);
+  const [supportingRecordsLoading, setSupportingRecordsLoading] = useState(false);
+  const [supportingRecordsError, setSupportingRecordsError] = useState<string | null>(null);
   const generation = useRef(0);
+  const boardBodyRef = useRef<HTMLDivElement | null>(null);
+  const [typeFilter, setTypeFilter] = useState<string | null>("all");
+  const showsContentItems = subject !== "assignment";
+  const contentItemColumnKeyPrefix = `${contentItemBoardType()}/`;
+  const boardType = subject === "assignment" ? ASSIGNMENT_BOARD_TYPE : contentItemBoardType();
+  const deskAssignmentIssues = useMemo(() => subject === "desk" && deskId
+    ? projectAssignmentBoard(assignments.filter(assignment => deskContainsAssignment(assignment, deskId))) : [], [assignments, deskId, subject]);
+  const columnStateConfig = useMemo(() => subject === "contentItem" ? contentItemBoardConfig([])
+    : subject === "desk" ? deskBoardConfig(deskAssignmentIssues)
+    : assignmentBoardConfig(assignmentBoardIssues), [assignmentBoardIssues, deskAssignmentIssues, subject]);
+  const columnState = useBoardColumnState({ config: columnStateConfig, storageKey: `papyrus.cms.columns.v1.${SITE_BRAND.id}.${subject}` });
+  const openedCollapsedUntilOpenedStages = useMemo(() => !showsContentItems ? [] : getContentItemStageDefinitions()
+    .filter(definition => definition.collapsedUntilOpened && !columnState.collapsedColumns.has(`${contentItemColumnKeyPrefix}${definition.key}`))
+    .map(definition => definition.key), [contentItemColumnKeyPrefix, columnState.collapsedColumns, showsContentItems]);
+  const pagedContentItems = usePagedContentItemVersions({ enabled: allowed && showsContentItems, openedCollapsedUntilOpenedStages });
   useEffect(() => {
     setLowMotion(readLocalReaderSettings().motion === "low");
     return subscribeReaderSettingsChanges(settings => setLowMotion(settings.motion === "low"));
   }, []);
   useEffect(() => {
     const request = ++generation.current;
-    setIssues([]); setSelected(null); setError(null);
-    if (!allowed) { setLoading(false); return; }
-    const loadIssues = () => subject === "contentItem"
-      ? Promise.all([
-        Promise.all([loadNewsroomContentItemVersions(), loadNewsroomPublishedContentItemVersions()]).then(([workingVersions, publishedVersions]) => [...workingVersions, ...publishedVersions]),
-        loadEveryNewsroomAssignment(),
-      ]).then(([contentItemVersions, assignments]) => projectContentItemBoard({ contentItemVersions, assignments }))
-      : loadEveryNewsroomAssignment().then(projectAssignmentBoard);
+    setAssignmentBoardIssues([]); setPublishedVersions([]); setAssignments([]); setSelected(null); setSupportingRecordsError(null);
+    if (!allowed) { setSupportingRecordsLoading(false); return; }
+    const loadSupportingRecords = () => subject !== "assignment"
+      ? Promise.all([loadNewsroomPublishedContentItemVersions(), loadEveryNewsroomAssignment()]).then(([published, everyAssignment]) => {
+        if (generation.current === request) { setPublishedVersions(published); setAssignments(everyAssignment); }
+      })
+      : loadEveryNewsroomAssignment().then(everyAssignment => {
+        if (generation.current === request) setAssignmentBoardIssues(projectAssignmentBoard(everyAssignment));
+      });
     const refresh = (initial: boolean) => {
-      if (initial) setLoading(true);
-      loadIssues().then(loadedIssues => {
-        if (generation.current !== request) return;
-        setIssues(loadedIssues);
-        setError(null);
+      if (initial) setSupportingRecordsLoading(true);
+      loadSupportingRecords().then(() => {
+        if (generation.current === request) setSupportingRecordsError(null);
       }).catch((reason: unknown) => {
-        if (generation.current === request && initial) setError(reason instanceof Error ? reason.message : "Could not load newsroom records.");
-      }).finally(() => { if (generation.current === request && initial) setLoading(false); });
+        if (generation.current === request && initial) setSupportingRecordsError(reason instanceof Error ? reason.message : "Could not load newsroom records.");
+      }).finally(() => { if (generation.current === request && initial) setSupportingRecordsLoading(false); });
     };
     refresh(true);
     const refreshWhenVisible = () => { if (document.visibilityState === "visible") refresh(false); };
@@ -87,31 +108,54 @@ export function NewsroomBoardView({ subject }: { subject: NewsroomBoardSubject }
     document.addEventListener("visibilitychange", refreshWhenVisible);
     return () => { generation.current = request + 1; window.clearInterval(interval); document.removeEventListener("visibilitychange", refreshWhenVisible); };
   }, [allowed, subject]);
-  const config = useMemo(() => subject === "contentItem" ? contentItemBoardConfig(issues) : assignmentBoardConfig(issues), [issues, subject]);
-  const boardType = subject === "contentItem" ? contentItemBoardType() : ASSIGNMENT_BOARD_TYPE;
-  const pageTitle = subject === "contentItem" ? getContentItemName().plural : "Assignments";
+  const issues = useMemo(() => {
+    if (subject === "assignment") return assignmentBoardIssues;
+    if (subject === "contentItem") return projectContentItemBoard({ contentItemVersions: [...pagedContentItems.versions, ...publishedVersions], assignments });
+    const versionsOnDesk = [...pagedContentItems.versions, ...publishedVersions].filter(version => deskId && deskContainsContentItem(version, deskId));
+    return [...projectContentItemBoard({ contentItemVersions: versionsOnDesk, assignments: assignments.filter(assignment => deskId && deskContainsAssignment(assignment, deskId)) }), ...deskAssignmentIssues];
+  }, [assignmentBoardIssues, assignments, deskAssignmentIssues, deskId, pagedContentItems.versions, publishedVersions, subject]);
+  const loading = supportingRecordsLoading || (showsContentItems && pagedContentItems.loading);
+  const error = supportingRecordsError ?? (showsContentItems ? pagedContentItems.error : null);
+  const config = useMemo(() => subject === "contentItem" ? contentItemBoardConfig(issues) : subject === "desk" ? deskBoardConfig(issues) : assignmentBoardConfig(issues), [issues, subject]);
+  const columnStageFromElement = (element: Element | null) => {
+    const columnKey = element?.closest("[data-column-key]")?.getAttribute("data-column-key");
+    return columnKey?.startsWith(contentItemColumnKeyPrefix) ? columnKey.slice(contentItemColumnKeyPrefix.length) : null;
+  };
+  const loadMoreWhenColumnIsNearItsEnd = (columnScroll: HTMLElement) => {
+    const distanceToEnd = columnScroll.scrollHeight - columnScroll.scrollTop - columnScroll.clientHeight;
+    const stage = columnStageFromElement(columnScroll);
+    if (stage && distanceToEnd < COLUMN_LOAD_MORE_DISTANCE_PIXELS) pagedContentItems.loadMoreForStage(stage);
+  };
+  const handleBoardScroll = (event: React.UIEvent<HTMLDivElement>) => {
+    const target = event.target as HTMLElement;
+    if (showsContentItems && target.classList?.contains("kb-column-scroll")) loadMoreWhenColumnIsNearItsEnd(target);
+  };
+  useEffect(() => {
+    if (!showsContentItems) return;
+    boardBodyRef.current?.querySelectorAll<HTMLElement>(".kb-column-scroll").forEach(loadMoreWhenColumnIsNearItsEnd);
+  });
+  const deskTitle = session?.shell.dashboard?.newsroomSections?.find(section => section.id === deskId)?.title ?? (deskId ? displayNewsroomSectionShortTitle({ id: deskId } as NewsroomSectionRecord) : "Desk");
+  const pageTitle = subject === "contentItem" ? getContentItemName().plural : subject === "desk" ? deskTitle : "Assignments";
   const issue = issues.find(item => item.id === selected);
   if (!allowed) return <NewsDeskAccessGate shell={session?.shell ?? null} />;
-  return <NewsroomOpsShell activeTab={subject === "contentItem" ? "articles" : "assignments"} appTitle={SITE_BRAND.appTitle} backLabel={SITE_BRAND.backToHomeLabel} pageTitle={pageTitle}
-    headerActions={subject === "contentItem" ? (
-      <Link className={cn(buttonVariants({ size: "sm" }))} data-newsroom-article-new href={getNewsroomNavHref(newsroomHref("articles", "new"))}>
-        <PlusIcon aria-hidden="true" />
-        {`New ${getContentItemName().singular.toLowerCase()}`}
-      </Link>
-    ) : undefined}>
+  return <NewsroomOpsShell activeTab={subject === "contentItem" ? "articles" : subject === "desk" ? "desks" : "assignments"} appTitle={SITE_BRAND.appTitle} backLabel={SITE_BRAND.backToHomeLabel} pageTitle={pageTitle}
+    headerActions={<>
+      <span role="status" className="organizer-board-note">{loading ? "Loading records…" : `${issues.length} records loaded.`}</span>
+      <div role="group" aria-label="Record presentation" className="organizer-board-view-toggle"><button type="button" className="organizer-header-button" aria-pressed={view === "board"} onClick={() => setView("board")}>Board</button><button type="button" className="organizer-header-button" aria-pressed={view === "list"} onClick={() => setView("list")}>List</button></div>
+      {showsContentItems && (
+        <Link className="organizer-header-button" data-newsroom-article-new href={getNewsroomNavHref(newsroomHref("articles", "new"))}>
+          <PlusIcon size={14} aria-hidden="true" />
+          {`New ${getContentItemName().singular.toLowerCase()}`}
+        </Link>
+      )}
+    </>}>
     <div className="organizer-native-board papyrus-newsprint-board" data-color-mode={theme}>
-      <div className="organizer-board-toolbar">
-        <div role="group" aria-label="Record presentation"><button type="button" aria-pressed={view === "board"} onClick={() => setView("board")}>Board</button><button type="button" aria-pressed={view === "list"} onClick={() => setView("list")}>List</button></div>
-      </div>
-      <p className="organizer-board-note">{subject === "contentItem"
-        ? `Each ${getContentItemName().singular.toLowerCase()} appears once, in the column for its stage. Open one to use its existing editor.`
-        : "Each assignment appears once, in the column for its status. Open one to use its existing workflow controls."}</p>
       {error && <NewsroomOpsStatusBanner tone="error">{error}</NewsroomOpsStatusBanner>}
-      <p role="status" className="organizer-board-note">{loading ? "Loading records…" : `${issues.length} records loaded.`}</p>
-      <div className="organizer-board-body" data-detail-open={Boolean(issue)}>
-        <IssueCollection issues={issues} config={config} query={{ type: boardType }} view={view}
+      {subject === "desk" && <IssueTypeFilter config={config} value={typeFilter} onChange={setTypeFilter} name="Record type" className="organizer-board-type-filter" />}
+      <div className="organizer-board-body" data-detail-open={Boolean(issue)} ref={boardBodyRef} onScrollCapture={handleBoardScroll}>
+        <IssueCollection issues={issues} config={config} query={{ type: subject === "desk" ? issueTypeFromFilter(typeFilter) : boardType }} view={view}
           motion={lowMotion ? STATIC_MOTION : undefined}
-          columnStateKey={`papyrus.cms.columns.v1.${SITE_BRAND.id}.${subject}`} initialScroll="start"
+          collapsedColumns={columnState.collapsedColumns} onToggleCollapse={columnState.toggleColumn} initialScroll="start"
           selectedIssueId={selected} detailOpen={Boolean(issue)} onSelectIssue={item => setSelected(item.id)} ariaLabel={pageTitle}
           emptyMessage={loading ? "Loading records…" : error ? "Records could not be loaded." : "No records in this selection."} />
         {issue && <IssueDetailPanel issue={issue} onClose={() => setSelected(null)} fields={[{ label: "CMS record ID", value: issue.nativeId }, { label: "Status", value: issue.nativeStatus }]}>

package/components/newsroom-organizer-shell.tsx

@@ -21,7 +21,7 @@ const ICONS = { overview: LayoutDashboard, articles: ClipboardList, references:
 function Navigation({ activePath, demo, admin, surface, onNavigate }: { activePath: string; demo: boolean; admin: boolean; surface: string; onNavigate?: () => void }) {
   const id = useId();
   const all = ORGANIZER_NAV_GROUPS.flatMap(group => group.items);
-  const active = all.filter(item => activePath === item.path || (item.path !== "/newsroom" && activePath.startsWith(item.path + "/"))).sort((a, b) => b.path.length - a.path.length)[0]?.key;
+  const active = all.filter(item => [item.path, ...(item.alsoActiveOnPaths ?? [])].some(candidate => activePath === candidate || (candidate !== "/newsroom" && activePath.startsWith(candidate + "/")))).sort((a, b) => b.path.length - a.path.length)[0]?.key;
   return <nav className="organizer-destinations" aria-label={surface === "sidebar" ? "Newsroom" : "All workspaces"}>
     {ORGANIZER_NAV_GROUPS.map((group, index) => <section key={group.title} aria-labelledby={`${id}-${index}`}>
       <h3 id={`${id}-${index}`}>{group.title}</h3>

package/components/newsroom-organizer.css

@@ -20,7 +20,7 @@ body:has(.newsroom-organizer)>[data-staging-banner]{flex-shrink:0}
 .organizer-destinations a[aria-current=page]{border-bottom:2px solid var(--org-ink);color:var(--org-ink)}
 .newsroom-organizer :is(a,button):focus-visible,.organizer-menu :is(a,button):focus-visible{outline:2px solid currentColor;outline-offset:-3px}
 .organizer-workspace{display:flex;flex-direction:column;min-height:0;min-width:0;overflow:hidden;padding:0 16px}
-.organizer-topbar{height:57px;min-height:57px;display:flex;align-items:center;gap:16px;border-bottom:1px solid var(--org-ink)}
+.organizer-topbar{height:48px;min-height:48px;display:flex;align-items:center;gap:16px;border-bottom:1px solid var(--org-ink)}
 .organizer-masthead{font:900 28px Newsroom Display,Georgia,serif;white-space:nowrap;max-width:30vw;overflow:hidden;text-overflow:ellipsis}
 .organizer-topbar h1{font:400 12px Newsroom UI,system-ui;flex:1;min-width:0;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;margin:0}
 .organizer-toggle{display:flex;align-items:center;justify-content:center;width:36px;min-height:36px;padding:0;border:1px solid var(--org-line);flex-shrink:0}
@@ -36,12 +36,12 @@ body:has(.newsroom-organizer)>[data-staging-banner]{flex-shrink:0}
 .organizer-account-popup [role=menuitem]{min-height:40px;font-size:12px}.organizer-account-popup .reader-auth{display:contents}.organizer-account-popup .reader-auth__error{display:block;white-space:normal;font-size:11px;padding:8px}
 .organizer-bottom-nav{display:none}
 .organizer-main:has(.organizer-native-board){display:flex;overflow:hidden}
-.organizer-native-board{display:flex;flex-direction:column;flex:1;min-height:0;min-width:0;gap:12px}
-.organizer-board-toolbar{display:flex;align-items:center;justify-content:space-between;gap:12px;min-width:0;flex-wrap:wrap}
-.organizer-board-toolbar [role=group]{display:flex;gap:8px;flex-wrap:wrap}
-.organizer-board-toolbar button{min-height:44px;padding:8px 12px;border:1px solid var(--org-line)}
-.organizer-board-toolbar button[aria-pressed=true]{background:var(--org-ink);color:var(--org-paper)}
-.organizer-board-note{font-size:11px;line-height:1.5;margin:0;color:var(--org-muted)}
+.organizer-native-board{display:flex;flex-direction:column;flex:1;min-height:0;min-width:0;gap:8px}
+.organizer-board-view-toggle{display:flex;gap:4px;flex-shrink:0}
+.organizer-header-button{display:inline-flex;align-items:center;gap:6px;min-height:36px;padding:4px 12px;border:1px solid var(--org-line);font:inherit;color:inherit;background:transparent;text-decoration:none;white-space:nowrap;cursor:pointer}
+.organizer-header-button[aria-pressed=true]{background:var(--org-ink);color:var(--org-paper)}
+.organizer-board-note{font-size:11px;line-height:1.5;margin:0;color:var(--org-muted);white-space:nowrap}
+@media(min-width:901px){.newsroom-organizer[data-sidebar-collapsed=false] .organizer-masthead{display:none}}
 .organizer-board-body{position:relative;display:grid;grid-template-columns:minmax(0,1fr);flex:1;min-width:0;min-height:0;gap:16px}
 .organizer-board-body[data-detail-open=true]{grid-template-columns:minmax(0,1fr) minmax(280px,360px)}
 .organizer-board-body>.kb-issue-collection{height:100%;min-height:0;overflow:auto}
@@ -51,6 +51,7 @@ body:has(.newsroom-organizer)>[data-staging-banner]{flex-shrink:0}
 .organizer-menu .organizer-destinations{overflow-y:auto}.organizer-menu .organizer-destinations section{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:8px}.organizer-menu .organizer-destinations h3{grid-column:1/-1;font-size:12px;text-transform:none;margin:0 0 4px}
 .organizer-menu .organizer-destinations a{border:1px solid var(--org-line);padding:12px;color:var(--org-ink)}
 @media(max-width:900px){
+ .organizer-board-note{position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0 0 0 0)}
  .newsroom-organizer,.newsroom-organizer[data-sidebar-collapsed=true]{grid-template-columns:minmax(0,1fr);grid-template-rows:minmax(0,1fr) auto}
  .organizer-sidebar,.organizer-toggle{display:none}.organizer-workspace{padding:0 16px}.organizer-topbar{gap:8px;height:55px;min-height:55px}
  .organizer-masthead{font-size:24px;max-width:36vw}.organizer-topbar h1{font-size:10px}.organizer-account-header{display:flex}.organizer-header-actions{gap:4px;max-width:35%}

package/components/topic-steering-workspace.tsx

@@ -13297,7 +13297,7 @@ function buildUiAnalysisReindexAssignmentPlan({
     createdBy: actorLabel,
     createdAt: now,
     updatedAt: now,
-    newsroomFeedKey: "assignments",
+    newsroomFeedKey: "operations",
     metadata,
   };
   const event: AssignmentEventRecord = {

package/components/use-paged-content-item-versions.ts

@@ -0,0 +1,151 @@
+"use client";
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import {
+  canonicalContentItemStage,
+  legacyStageKeysToLoad,
+  type ContentItemVersionRecord,
+} from "../lib/content-item-lifecycle";
+import { getContentItemStageDefinitions } from "../lib/site-brand";
+import { loadNewsroomContentItemStagePage } from "./news-desk-taxonomy-client";
+
+const REFRESH_INTERVAL_MILLISECONDS = 30_000;
+
+type StageBucket = {
+  versions: ContentItemVersionRecord[];
+  nextToken: string | null;
+  pagesLoaded: number;
+};
+
+export type PagedContentItemVersions = {
+  versions: ContentItemVersionRecord[];
+  loading: boolean;
+  error: string | null;
+  stageHasMore: (canonicalStage: string) => boolean;
+  loadMoreForStage: (canonicalStage: string) => void;
+};
+
+function mergeFreshFirstPage(existing: StageBucket | undefined, fresh: StageBucket): StageBucket {
+  if (!existing || existing.pagesLoaded <= 1) return fresh;
+  const freshIds = new Set(fresh.versions.map(version => version.id));
+  return {
+    versions: [...fresh.versions, ...existing.versions.filter(version => !freshIds.has(version.id))],
+    nextToken: existing.nextToken,
+    pagesLoaded: existing.pagesLoaded,
+  };
+}
+
+/**
+ * Newest-updated content items per stage, one page per stage to start, more pages on demand.
+ * The periodic refresh re-fetches only first pages and keeps whatever later pages were already loaded.
+ */
+export function usePagedContentItemVersions(options: {
+  enabled: boolean;
+  openedCollapsedUntilOpenedStages: readonly string[];
+}): PagedContentItemVersions {
+  const { enabled, openedCollapsedUntilOpenedStages } = options;
+  const [buckets, setBuckets] = useState<Record<string, StageBucket>>({});
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const bucketsRef = useRef(buckets);
+  const stageKeysBeingExtendedRef = useRef(new Set<string>());
+  const generationRef = useRef(0);
+
+  const openedStagesSignature = openedCollapsedUntilOpenedStages.join(",");
+  const stageKeysToLoad = useMemo(() => {
+    const stageDefinitions = getContentItemStageDefinitions();
+    return [
+      ...stageDefinitions
+        .filter(definition => !definition.collapsedUntilOpened || openedStagesSignature.split(",").includes(definition.key))
+        .map(definition => definition.key),
+      ...legacyStageKeysToLoad(stageDefinitions),
+    ];
+  }, [openedStagesSignature]);
+  const stageKeysToLoadRef = useRef(stageKeysToLoad);
+  stageKeysToLoadRef.current = stageKeysToLoad;
+
+  const storeBuckets = useCallback((update: (previous: Record<string, StageBucket>) => Record<string, StageBucket>) => {
+    const next = update(bucketsRef.current);
+    bucketsRef.current = next;
+    setBuckets(next);
+  }, []);
+
+  const refreshFirstPages = useCallback(async (request: number, isInitial: boolean, stageKeys: readonly string[]) => {
+    if (isInitial) setLoading(true);
+    try {
+      const freshBuckets = await Promise.all(stageKeys.map(async stageKey => {
+        const page = await loadNewsroomContentItemStagePage(stageKey);
+        return [stageKey, { versions: page.versions, nextToken: page.nextToken, pagesLoaded: 1 }] as const;
+      }));
+      if (generationRef.current !== request) return;
+      storeBuckets(previous => {
+        const next = { ...previous };
+        for (const [stageKey, fresh] of freshBuckets) next[stageKey] = mergeFreshFirstPage(previous[stageKey], fresh);
+        return next;
+      });
+      setError(null);
+    } catch (reason: unknown) {
+      if (generationRef.current === request && isInitial) setError(reason instanceof Error ? reason.message : "Could not load newsroom records.");
+    } finally {
+      if (generationRef.current === request && isInitial) setLoading(false);
+    }
+  }, [storeBuckets]);
+
+  useEffect(() => {
+    const request = ++generationRef.current;
+    bucketsRef.current = {};
+    setBuckets({});
+    setError(null);
+    if (!enabled) { setLoading(false); return; }
+    void refreshFirstPages(request, true, stageKeysToLoadRef.current);
+    const refreshWhenVisible = () => {
+      if (document.visibilityState === "visible") void refreshFirstPages(request, false, stageKeysToLoadRef.current);
+    };
+    const interval = window.setInterval(refreshWhenVisible, REFRESH_INTERVAL_MILLISECONDS);
+    document.addEventListener("visibilitychange", refreshWhenVisible);
+    return () => {
+      generationRef.current = request + 1;
+      window.clearInterval(interval);
+      document.removeEventListener("visibilitychange", refreshWhenVisible);
+    };
+  }, [enabled, refreshFirstPages]);
+
+  useEffect(() => {
+    if (!enabled) return;
+    const stageKeysNotLoadedYet = stageKeysToLoad.filter(stageKey => !(stageKey in bucketsRef.current));
+    if (stageKeysNotLoadedYet.length) void refreshFirstPages(generationRef.current, false, stageKeysNotLoadedYet);
+  }, [enabled, refreshFirstPages, stageKeysToLoad]);
+
+  const stageKeysInCanonicalStage = useCallback((canonicalStage: string) => Object.keys(bucketsRef.current)
+    .filter(stageKey => canonicalContentItemStage(stageKey, getContentItemStageDefinitions()) === canonicalStage), []);
+
+  const loadMoreForStage = useCallback((canonicalStage: string) => {
+    const request = generationRef.current;
+    for (const stageKey of stageKeysInCanonicalStage(canonicalStage)) {
+      const bucket = bucketsRef.current[stageKey];
+      if (!bucket?.nextToken || stageKeysBeingExtendedRef.current.has(stageKey)) continue;
+      stageKeysBeingExtendedRef.current.add(stageKey);
+      loadNewsroomContentItemStagePage(stageKey, bucket.nextToken).then(page => {
+        if (generationRef.current !== request) return;
+        storeBuckets(previous => {
+          const current = previous[stageKey] ?? bucket;
+          const knownIds = new Set(current.versions.map(version => version.id));
+          return {
+            ...previous,
+            [stageKey]: {
+              versions: [...current.versions, ...page.versions.filter(version => !knownIds.has(version.id))],
+              nextToken: page.nextToken,
+              pagesLoaded: current.pagesLoaded + 1,
+            },
+          };
+        });
+      }).catch(() => undefined).finally(() => { stageKeysBeingExtendedRef.current.delete(stageKey); });
+    }
+  }, [stageKeysInCanonicalStage, storeBuckets]);
+
+  const stageHasMore = useCallback((canonicalStage: string) => stageKeysInCanonicalStage(canonicalStage)
+    .some(stageKey => Boolean(bucketsRef.current[stageKey]?.nextToken)), [stageKeysInCanonicalStage]);
+
+  const versions = useMemo(() => Object.values(buckets).flatMap(bucket => bucket.versions), [buckets]);
+  return { versions, loading, error, stageHasMore, loadMoreForStage };
+}

package/lib/blog-feature-solver.ts

@@ -12,7 +12,7 @@ import {
 } from "./blog-rhythm";
 import { layoutAllTextLines, layoutTextLines, prepareWithSegments, type TextLine, type TextObstacle } from "./pretext-layout";
 
-export type FeaturedLayoutMode = "obstacle" | "float" | "stacked";
+export type FeaturedLayoutMode = "float" | "stacked";
 
 export type SolvedFeaturedItem = {
   mode: FeaturedLayoutMode;
@@ -92,19 +92,6 @@ export function solveFeaturedItem(input: SolveFeaturedItemInput): SolvedFeatured
   });
   const aspectRatio = getImageAspectRatio(input.imageAsset);
 
-  if (mode === "obstacle") {
-    return solveObstacleFeaturedItem({
-      prepared,
-      containerWidth: input.containerWidth,
-      viewportWidth: input.viewportWidth,
-      rhythm,
-      textStyle: input.textStyle,
-      aspectRatio,
-      gap,
-      imageAsset: input.imageAsset,
-    });
-  }
-
   if (mode === "float") {
     return solveFloatFeaturedItem({
       prepared,
@@ -151,96 +138,6 @@ type PreparedSolveInput = {
   imageAsset: ArticleImageAsset;
 };
 
-function solveObstacleFeaturedItem(input: PreparedSolveInput): SolvedFeaturedItem {
-  const maxImageWidth = getFloatImageWidth(input);
-  let best: {
-    score: number;
-    textLines: TextLine[];
-    imageHeight: number;
-    imageWidth: number;
-    captionHeight: number;
-    mediaHeight: number;
-    copyWidth: number;
-    textFrameHeight: number;
-    hasMore: boolean;
-  } | null = null;
-
-  for (const imageWidth of getObstacleImageWidths(maxImageWidth, input.rhythm)) {
-    const copyWidth = Math.max(
-      getFloatCopyMinimum(input.viewportWidth, input.rhythm),
-      input.containerWidth - imageWidth - input.gap,
-    );
-    const imageHeight = snapImageHeight(imageWidth / input.aspectRatio, input.rhythm, input.imageAsset.layout);
-    const captionHeight = getFeatureCaptionHeight(input.imageAsset, imageWidth, input.rhythm);
-    const mediaHeight = imageHeight + captionHeight;
-    const obstacle: TextObstacle = {
-      x: Math.max(0, copyWidth - imageWidth),
-      y: 0,
-      width: imageWidth,
-      height: mediaHeight,
-    };
-
-    let candidateHeight = mediaHeight;
-    let result = layoutTextLines({
-      prepared: input.prepared,
-      cursor: { segmentIndex: 0, graphemeIndex: 0 },
-      maxHeight: candidateHeight,
-      maxWidth: copyWidth,
-      lineHeight: input.textStyle.lineHeight,
-      linePaintHeight: input.textStyle.linePaintHeight,
-      fontSize: input.textStyle.fontSize,
-      fontFamily: input.textStyle.fontFamily,
-      obstacles: [obstacle],
-    });
-
-    const textBottom = getMeasuredTextHeight(result.lines);
-    if (textBottom > 0 && textBottom < candidateHeight) {
-      candidateHeight = reserveRhythmRows(textBottom, input.rhythm);
-      obstacle.height = candidateHeight;
-      result = layoutTextLines({
-        prepared: input.prepared,
-        cursor: { segmentIndex: 0, graphemeIndex: 0 },
-        maxHeight: candidateHeight,
-        maxWidth: copyWidth,
-        lineHeight: input.textStyle.lineHeight,
-        linePaintHeight: input.textStyle.linePaintHeight,
-        fontSize: input.textStyle.fontSize,
-        fontFamily: input.textStyle.fontFamily,
-        obstacles: [obstacle],
-      });
-    }
-
-    const whitespace = Math.max(0, candidateHeight - getMeasuredTextHeight(result.lines));
-    const score = 50_000 - whitespace * 1.4 - Math.abs(candidateHeight - mediaHeight) * 0.35 - Math.abs(maxImageWidth - imageWidth) * 0.2;
-    const candidate = {
-      score,
-      textLines: result.lines,
-      imageHeight: Math.min(imageHeight, candidateHeight),
-      imageWidth,
-      captionHeight,
-      mediaHeight: candidateHeight,
-      copyWidth,
-      textFrameHeight: reserveRhythmRows(getMeasuredTextHeight(result.lines), input.rhythm),
-      hasMore: result.hasMore,
-    };
-    if (!best || candidate.score > best.score) best = candidate;
-  }
-
-  const fallbackImageHeight = input.rhythm.rowHeight * 6;
-  return {
-    mode: "obstacle",
-    textLines: best?.textLines ?? [],
-    imageHeight: best?.imageHeight ?? fallbackImageHeight,
-    imageWidth: best?.imageWidth ?? maxImageWidth,
-    captionHeight: best?.captionHeight ?? 0,
-    mediaHeight: best?.mediaHeight ?? fallbackImageHeight,
-    copyWidth: best?.copyWidth ?? input.containerWidth,
-    textFrameHeight: best?.textFrameHeight ?? 0,
-    hasMore: best?.hasMore ?? false,
-    gap: input.gap,
-  };
-}
-
 function solveFloatFeaturedItem(input: PreparedSolveInput): SolvedFeaturedItem {
   const geometry = computeFloatGeometry({
     containerWidth: input.containerWidth,
@@ -417,11 +314,6 @@ function getFloatCopyMinimum(viewportWidth: number, rhythm: VerticalRhythm): num
   return rhythmLengthRows(viewportWidth <= 600 ? FLOAT_COPY_MIN_PHONE_ROWS : FLOAT_COPY_MIN_DESKTOP_ROWS, rhythm);
 }
 
-function getObstacleImageWidths(maximum: number, rhythm: VerticalRhythm): number[] {
-  const candidateRows = [0, 1, 2].map((offset) => Math.max(rhythm.rowHeight * 5, maximum - (offset * rhythm.rowHeight)));
-  return Array.from(new Set(candidateRows));
-}
-
 function snapImageHeight(
   naturalHeight: number,
   rhythm: VerticalRhythm,

package/lib/content-item-lifecycle.ts

@@ -7,24 +7,51 @@
 export type ContentItemStageDefinition = {
   key: string;
   label: string;
+  /** Closed or rarely visited stage: its board column starts collapsed and its cards load only when it is opened. */
+  collapsedUntilOpened?: boolean;
 };
 
+export const PUBLISHED_STAGE_KEY = "published";
+
+/** Stage keys written before the story stages were simplified, read as the stage that replaced them. */
+export const LEGACY_CONTENT_ITEM_STAGE_ALIASES: Readonly<Record<string, string>> = {
+  research: "reporting",
+  report: "reporting",
+  editor_select: "reporting",
+};
+
+/** Stages for work that has not become a story yet; they appear on the assignments board only. */
+export const ASSIGNMENT_PHASE_STAGE_KEYS: readonly string[] = ["idea", "assignment"];
+
 export const DEFAULT_CONTENT_ITEM_STAGE_DEFINITIONS: readonly ContentItemStageDefinition[] = [
-  { key: "idea", label: "Idea" },
-  { key: "assignment", label: "Assignment" },
-  { key: "research", label: "Research" },
-  { key: "report", label: "Report" },
-  { key: "editor_select", label: "Editor select" },
+  { key: "reporting", label: "Reporting" },
   { key: "copywriting", label: "Copywriting" },
   { key: "illustration", label: "Illustration" },
   { key: "typesetting", label: "Typesetting" },
   { key: "published", label: "Published" },
+  { key: "held", label: "Held" },
+  { key: "spiked", label: "Spiked", collapsedUntilOpened: true },
 ];
 
 export function contentItemStageKeys(stageDefinitions: readonly ContentItemStageDefinition[]): string[] {
   return stageDefinitions.map(definition => definition.key);
 }
 
+export function canonicalContentItemStage(
+  stage: string,
+  stageDefinitions: readonly ContentItemStageDefinition[] = DEFAULT_CONTENT_ITEM_STAGE_DEFINITIONS,
+): string {
+  const isDefined = stageDefinitions.some(definition => definition.key === stage);
+  return isDefined ? stage : LEGACY_CONTENT_ITEM_STAGE_ALIASES[stage] ?? stage;
+}
+
+export function legacyStageKeysToLoad(stageDefinitions: readonly ContentItemStageDefinition[]): string[] {
+  const definedKeys = contentItemStageKeys(stageDefinitions);
+  return Object.entries(LEGACY_CONTENT_ITEM_STAGE_ALIASES)
+    .filter(([legacyKey, replacementKey]) => !definedKeys.includes(legacyKey) && definedKeys.includes(replacementKey))
+    .map(([legacyKey]) => legacyKey);
+}
+
 export function contentItemStageLabel(
   stage: string,
   stageDefinitions: readonly ContentItemStageDefinition[] = DEFAULT_CONTENT_ITEM_STAGE_DEFINITIONS,

package/lib/local-preview-seed.ts

@@ -6,15 +6,13 @@ const SEED_TIMESTAMP_BASE = Date.parse("2026-10-01T12:00:00.000Z");
 const ONE_HOUR_IN_MILLISECONDS = 60 * 60 * 1000;
 
 const SEED_CONTENT_ITEM_HEADLINES_BY_POSITION: readonly (readonly string[])[] = [
-  ["Readers ask what the newsroom should chase next", "A tip from the field: harbor dredging schedule"],
-  ["City council budget vote draws a crowd", "Interview request: regional transit director"],
-  ["Mapping every permit filed since January", "What the county audit left out"],
   ["Three sources confirm the zoning reversal", "Reporting packet: school board redistricting"],
-  ["Editor shortlist: the week's lead candidates", "Editor shortlist: the weekend long read"],
   ["Draft in progress: the last ferry crossing", "Draft in progress: neighborhood bakery profile"],
   ["Illustration brief: flooded streets, aerial view", "Illustration brief: the market at dawn"],
   ["Layout pass: front page lead and rail", "Layout pass: the Saturday supplement"],
   ["Published: harbor safety review", "Published: the lighthouse keepers' archive"],
+  ["Held for the winter issue: the lighthouse keepers' archive", "Evergreen: how the harbor dredging works"],
+  ["Spiked: the unconfirmed council rumor", "Spiked: the recycled press release"],
 ];
 
 function isoTimestampHoursBeforeBase(hours: number): string {

package/lib/newsroom-board.ts

@@ -1,6 +1,9 @@
 import type { KanbanConfig, KanbanIssue } from "@kanbus/ui";
 import type { AssignmentRecord } from "./category-repository";
 import {
+  ASSIGNMENT_PHASE_STAGE_KEYS,
+  PUBLISHED_STAGE_KEY,
+  canonicalContentItemStage,
   contentItemStageKeys,
   contentItemStageLabel,
   latestVersionPerContentItem,
@@ -17,6 +20,10 @@ export interface NativeBoardIssue extends KanbanIssue {
   href: string;
 }
 
+export function contentItemBoardPathSegment(): string {
+  return getContentItemName().plural.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "articles";
+}
+
 export function contentItemBoardType(): string {
   return getContentItemName().singular.toLowerCase();
 }
@@ -38,8 +45,12 @@ export function projectContentItemBoard(records: {
     }
   }
   const contentItemType = contentItemBoardType();
-  return latestVersionPerContentItem(records.contentItemVersions).map(version => {
-    const stage = version.stage ?? "idea";
+  const stageDefinitions = getContentItemStageDefinitions();
+  const stageKeys = contentItemStageKeys(stageDefinitions);
+  const contentItemVersionsOnBoard = latestVersionPerContentItem(records.contentItemVersions)
+    .map(version => ({ version, stage: canonicalContentItemStage(version.stage ?? "idea", stageDefinitions) }))
+    .filter(({ stage }) => stageKeys.includes(stage) || !ASSIGNMENT_PHASE_STAGE_KEYS.includes(stage));
+  return contentItemVersionsOnBoard.map(({ version, stage }) => {
     const workCount = assignmentCountByContentItem.get(version.lineageId) ?? 0;
     return {
       id: `contentItem:${version.lineageId}`, nativeId: version.lineageId, kind: "contentItem" as const, type: contentItemType,
@@ -66,9 +77,10 @@ export function contentItemColumnOrder(
   stagesPresentOnBoard: readonly string[],
   stageKeys: readonly string[] = contentItemStageKeys(getContentItemStageDefinitions()),
 ): string[] {
-  const lastStage = stageKeys[stageKeys.length - 1];
   const unrecognizedStages = [...new Set(stagesPresentOnBoard)].filter(stage => !stageKeys.includes(stage));
-  return [...stageKeys.filter(stage => stage !== lastStage), ...unrecognizedStages, lastStage];
+  const stageBeforeWhichUnrecognizedStagesSit = stageKeys.includes(PUBLISHED_STAGE_KEY) ? PUBLISHED_STAGE_KEY : stageKeys[stageKeys.length - 1];
+  const insertionIndex = stageKeys.indexOf(stageBeforeWhichUnrecognizedStagesSit);
+  return [...stageKeys.slice(0, insertionIndex), ...unrecognizedStages, ...stageKeys.slice(insertionIndex)];
 }
 
 export function assignmentColumnOrder(statusesPresentOnBoard: readonly string[]): string[] {
@@ -77,7 +89,7 @@ export function assignmentColumnOrder(statusesPresentOnBoard: readonly string[])
   return [...ASSIGNMENT_STATUSES_BEFORE_OTHERS, ...otherStatuses, ...ASSIGNMENT_STATUSES_AFTER_OTHERS];
 }
 
-function boardConfigForType(type: string, columns: readonly { key: string; name: string }[]): KanbanConfig {
+function boardConfigForType(type: string, columns: readonly { key: string; name: string; collapsed?: boolean }[]): KanbanConfig {
   const statuses = columns.map(column => ({ ...column, category: "native" }));
   return {
     hierarchy: [], types: [type], statuses,
@@ -86,11 +98,15 @@ function boardConfigForType(type: string, columns: readonly { key: string; name:
   };
 }
 
-/** Content items read left to right through the lifecycle with the final stage last. */
+/** Content items read left to right through the lifecycle; stages marked collapsed-until-opened start collapsed. */
 export function contentItemBoardConfig(issues: readonly NativeBoardIssue[]): KanbanConfig {
   const contentItemType = contentItemBoardType();
   return boardConfigForType(contentItemType, contentItemColumnOrder(issues.map(issue => issue.nativeStatus))
-    .map(stage => ({ key: `${contentItemType}/${stage}`, name: contentItemStageLabel(stage, getContentItemStageDefinitions()) })));
+    .map(stage => ({
+      key: `${contentItemType}/${stage}`,
+      name: contentItemStageLabel(stage, getContentItemStageDefinitions()),
+      collapsed: getContentItemStageDefinitions().some(definition => definition.key === stage && definition.collapsedUntilOpened),
+    })));
 }
 
 export function assignmentBoardConfig(issues: readonly NativeBoardIssue[]): KanbanConfig {
@@ -98,6 +114,31 @@ export function assignmentBoardConfig(issues: readonly NativeBoardIssue[]): Kanb
     .map(status => ({ key: `${ASSIGNMENT_BOARD_TYPE}/${status}`, name: assignmentStatusLabel(status) })));
 }
 
+function matchesDesk(candidate: string | null | undefined, deskId: string): boolean {
+  return Boolean(candidate) && candidate!.trim().toLowerCase() === deskId.trim().toLowerCase();
+}
+
+export function deskContainsContentItem(version: ContentItemVersionRecord, deskId: string): boolean {
+  return matchesDesk(version.section, deskId);
+}
+
+export function deskContainsAssignment(assignment: AssignmentRecord, deskId: string): boolean {
+  return matchesDesk(assignment.sectionId, deskId) || matchesDesk(assignment.sectionKey, deskId);
+}
+
+/** A desk board shows stories and assignments side by side; each keeps its own columns and the type filter narrows to one. */
+export function deskBoardConfig(issues: readonly NativeBoardIssue[]): KanbanConfig {
+  const storiesConfig = contentItemBoardConfig(issues.filter(issue => issue.kind === "contentItem"));
+  const assignmentsConfig = assignmentBoardConfig(issues.filter(issue => issue.kind === "assignment"));
+  return {
+    ...storiesConfig,
+    types: [...(storiesConfig.types ?? []), ...(assignmentsConfig.types ?? [])],
+    statuses: [...storiesConfig.statuses, ...assignmentsConfig.statuses],
+    categories: storiesConfig.categories,
+    workflows: { ...storiesConfig.workflows, ...assignmentsConfig.workflows },
+  };
+}
+
 export function canReadNewsroomBoard(phase: string | undefined): boolean {
   return phase === "ready";
 }

package/lib/newsroom-organizer-nav.ts

@@ -1,14 +1,15 @@
+import { contentItemBoardPathSegment } from "./newsroom-board";
 import { getContentItemName } from "./site-brand";
 
 const contentItemPluralLowercase = getContentItemName().plural.toLowerCase();
 export type OrganizerDestination = {
   key: string; label: string; description: string; path: string;
-  access?: "admin"; primary?: boolean; unavailable?: string;
+  access?: "admin"; primary?: boolean; unavailable?: string; alsoActiveOnPaths?: readonly string[];
 };
 export const ORGANIZER_NAV_GROUPS: readonly { title: string; items: readonly OrganizerDestination[] }[] = [
   { title: "Editorial work", items: [
     { key: "overview", label: "Overview", description: "See the desk and choose where to begin.", 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/articles", 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: "messages", label: "Messages", description: "Read and reply to newsroom conversations.", path: "/newsroom/messages", primary: true },
     { key: "insights", label: "Insights", description: "Discuss findings and research threads.", path: "/newsroom/insights" },

package/lib/prospectus-account-client.ts

@@ -0,0 +1,64 @@
+export interface ProspectusPublishingAccountChoice {
+  accountId: string;
+  name?: string;
+  role: string;
+}
+
+export type ProspectusAccountState =
+  | { status: "unavailable" }
+  | { status: "signedOut"; signInUrl: string }
+  | {
+      status: "signedIn";
+      publishingAccounts: ProspectusPublishingAccountChoice[];
+      selectedAccountId: string | null;
+      cyclotronLabAccess: boolean;
+    };
+
+type FetchImplementation = (input: string, init?: RequestInit) => Promise<Response>;
+
+const SESSION_PATH = "/api/auth/prospectus/session";
+const SELECTION_PATH = "/api/auth/prospectus/selection";
+const SIGN_IN_PATH = "/api/auth/prospectus/sign-in";
+
+export function prospectusSignInUrl(returnPath: string): string {
+  return `${SIGN_IN_PATH}?returnTo=${encodeURIComponent(returnPath)}`;
+}
+
+export async function loadProspectusAccountState(
+  returnPath: string,
+  fetchImplementation: FetchImplementation = fetch,
+): Promise<ProspectusAccountState> {
+  let response: Response;
+  try {
+    response = await fetchImplementation(SESSION_PATH, { credentials: "same-origin", cache: "no-store" });
+  } catch {
+    return { status: "unavailable" };
+  }
+  if (!response.ok) return { status: "unavailable" };
+  const body = await response.json().catch(() => null) as
+    | { signedIn?: boolean; publishingAccounts?: ProspectusPublishingAccountChoice[]; selectedAccountId?: string | null; cyclotronLabAccess?: boolean }
+    | null;
+  if (!body) return { status: "unavailable" };
+  if (!body.signedIn) return { status: "signedOut", signInUrl: prospectusSignInUrl(returnPath) };
+  return {
+    status: "signedIn",
+    publishingAccounts: Array.isArray(body.publishingAccounts) ? body.publishingAccounts : [],
+    selectedAccountId: body.selectedAccountId ?? null,
+    cyclotronLabAccess: body.cyclotronLabAccess === true,
+  };
+}
+
+export async function selectProspectusAccount(
+  accountId: string,
+  fetchImplementation: FetchImplementation = fetch,
+): Promise<{ selectedAccountId: string; role: string } | { error: string }> {
+  const response = await fetchImplementation(SELECTION_PATH, {
+    method: "POST",
+    credentials: "same-origin",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ accountId }),
+  });
+  const body = await response.json().catch(() => null) as { selectedAccountId?: string; role?: string; message?: string } | null;
+  if (!response.ok || !body?.selectedAccountId) return { error: body?.message ?? "That account could not be selected." };
+  return { selectedAccountId: body.selectedAccountId, role: body.role ?? "" };
+}

package/lib/site-stack.ts

@@ -149,7 +149,7 @@ export const PILOBOL_US_THEME_PACK_TOKENS: ThemePackTokens = {
 };
 
 /**
- * Anthus palette, read off the live Gatsby site at `AnthusAI/Anth.us`
+ * Anthus palette, read off the live Gatsby site at `AnthusAI/Anth.us-legacy-Gatsby`
  * (`src/styles/variables.scss` `:root`). Colors only — Shadcn owns typography.
  * Mapping from that file's names to the pack's slots:
  *

package/package.json

@@ -135,6 +135,7 @@
     "./components/use-blog-header-obstacles": "./components/use-blog-header-obstacles.ts",
     "./components/use-brand-fonts-ready": "./components/use-brand-fonts-ready.ts",
     "./components/use-near-viewport": "./components/use-near-viewport.ts",
+    "./components/use-paged-content-item-versions": "./components/use-paged-content-item-versions.ts",
     "./components/use-resolved-papyrus-theme": "./components/use-resolved-papyrus-theme.ts",
     "./components/use-rhythm-overlay": "./components/use-rhythm-overlay.ts",
     "./lib/amplify-outputs-guard": "./lib/amplify-outputs-guard.ts",
@@ -219,6 +220,7 @@
     "./lib/presentation-footer": "./lib/presentation-footer.ts",
     "./lib/pretext-layout": "./lib/pretext-layout.ts",
     "./lib/priming-proof-report": "./lib/priming-proof-report.ts",
+    "./lib/prospectus-account-client": "./lib/prospectus-account-client.ts",
     "./lib/prospectus-publication-access": "./lib/prospectus-publication-access.ts",
     "./lib/prospectus-session": "./lib/prospectus-session.ts",
     "./lib/prospectus-sign-in-routes": "./lib/prospectus-sign-in-routes.ts",
@@ -350,7 +352,7 @@
       "optional": true
     }
   },
-  "version": "1.4.0-next.1",
+  "version": "1.4.0-next.3",
   "dependencies": {
     "@aws-amplify/adapter-nextjs": "^1.7.3",
     "@aws-crypto/sha256-js": "5.2.0",
@@ -376,7 +378,9 @@
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
     "cyclotron": "https://github.com/AnthusAI/Cyclotron/releases/download/ui-v0.2.2/cyclotron-0.2.2.tgz",
+    "d3": "^7.9.0",
     "esbuild": "^0.28.2",
+    "framer-motion": "^14.3.0",
     "gray-matter": "^4.0.3",
     "gsap": "^3.15.0",
     "lucide-react": "^1.16.0",
@@ -385,6 +389,7 @@
     "shadcn": "^4.8.0",
     "tailwind-merge": "^3.6.0",
     "tailwindcss": "^4.3.0",
+    "three": "^0.186.1",
     "tsx": "^4.23.15",
     "tw-animate-css": "^1.4.0",
     "use-stick-to-bottom": "^1.1.4",

package/renderers/pretext/rhythm-article-page.tsx

@@ -13,6 +13,7 @@ import { PresentationFooter } from "../../components/presentation-footer";
 import { PresentationHeader } from "../../components/presentation-header";
 import { useBlogHeaderObstacles } from "../../components/use-blog-header-obstacles";
 import { useRhythmOverlay } from "../../components/use-rhythm-overlay";
+import { useMeasuredWidth } from "./presentation-shared";
 import { BLOG_RHYTHM, getFeaturedLayoutStyle, getRhythmShellStyle } from "./rhythm-shell-style";
 
 const BlogPageBackground = SITE_BRAND.components?.BlogPageBackground ?? GenericBlogPageBackground;
@@ -135,24 +136,6 @@ export function RhythmArticlePage({
   );
 }
 
-function useMeasuredWidth(ref: RefObject<HTMLElement | null>): number {
-  const [width, setWidth] = useState(0);
-  useEffect(() => {
-    const node = ref.current;
-    if (!node) return;
-    const update = () => setWidth(Math.max(1, Math.floor(node.getBoundingClientRect().width)));
-    update();
-    const observer = new ResizeObserver(update);
-    observer.observe(node);
-    window.addEventListener("resize", update);
-    return () => {
-      observer.disconnect();
-      window.removeEventListener("resize", update);
-    };
-  }, [ref]);
-  return width;
-}
-
 function useViewportWidth(): number {
   const [width, setWidth] = useState(0);
   useEffect(() => {

package/routes.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.4.0-next.1",
+  "version": "1.4.0-next.3",
   "routes": [
     {
       "file": "app/%5F_preview/[[...path]]/route.ts",