@anthusai/papyrus 1.3.0 → 1.4.0-next.10

package/lib/papyrus-web-locations.ts

@@ -3,12 +3,10 @@ import { PAPYRUS_OBJECT_KINDS, type PapyrusObjectKind } from "./papyrus-object-k
 import {
   buildNewsroomIndexWebPath,
   effectiveAssignmentsIndexFilters,
-  effectiveInsightsIndexFilters,
   effectiveMessagesIndexFilters,
   effectiveReferencesIndexFilters,
   normalizeReferenceIndexOrder,
   type AssignmentsIndexFilters,
-  type InsightsIndexFilters,
   type MessagesIndexFilters,
   type NewsroomIndexTab,
   type ReferencesIndexFilters,
@@ -27,7 +25,6 @@ export type PapyrusWebUiContext = {
 const NEWSROOM_TAB_IDS = new Set([
   "overview",
   "messages",
-  "insights",
   "assignments",
   "references",
   "topics",
@@ -123,21 +120,10 @@ export function webPathToPapyrusLocation(webPath: string): PapyrusWebUiContext {
     });
   }
 
-  if ((tab === "references" || tab === "messages" || tab === "assignments" || tab === "insights") && segments.length === 2) {
+  if ((tab === "references" || tab === "messages" || tab === "assignments") && segments.length === 2) {
     return newsroomIndexLocation(tab as NewsroomIndexTab, normalized, url.searchParams);
   }
 
-  if (tab === "insights" && segments[2]) {
-    const threadId = decodeURIComponent(segments[2]);
-    const objectUri = `papyrus://message/${encodeURIComponent(threadId)}`;
-    return location(objectUri, normalized, {
-      papyrusObjectUri: objectUri,
-      newsroomTab: "insights",
-      viewMode: "detail",
-      label: `Insight thread ${threadId}`,
-    });
-  }
-
   if ((tab === "references" || tab === "messages" || tab === "assignments") && segments[2]) {
     const objectId = decodeURIComponent(segments[2]);
     const kind = tab === "references" ? "reference" : tab === "messages" ? "message" : "assignment";
@@ -277,7 +263,7 @@ export function papyrusUriToWebPath(uri: string): PapyrusUriToWebPathResult {
   }
 
   if (NEWSROOM_TAB_IDS.has(id)) {
-    if (id === "references" || id === "messages" || id === "assignments" || id === "insights") {
+    if (id === "references" || id === "messages" || id === "assignments") {
       const mapped = newsroomIndexUriToWebPath(raw, `${id}/index`);
       if (mapped) return mapped;
     }
@@ -347,9 +333,6 @@ function readIndexFiltersFromSearchParams(tab: NewsroomIndexTab, searchParams: U
     kind: searchParams.get("kind")?.trim() ?? undefined,
     domain: searchParams.get("domain")?.trim() ?? undefined,
   });
-  if (tab === "insights") return effectiveInsightsIndexFilters({
-    domain: searchParams.get("domain")?.trim() ?? undefined,
-  });
   return effectiveAssignmentsIndexFilters({
     status: searchParams.get("status")?.trim() ?? undefined,
     type: searchParams.get("type")?.trim() ?? undefined,
@@ -368,9 +351,6 @@ function buildNewsroomIndexLocationUri(tab: NewsroomIndexTab, filters: Record<st
     const normalized = filters as MessagesIndexFilters;
     if (normalized.kind?.trim()) segments.push("kind", normalized.kind.trim());
     if (normalized.domain?.trim()) segments.push("domain", normalized.domain.trim());
-  } else if (tab === "insights") {
-    const normalized = filters as InsightsIndexFilters;
-    if (normalized.domain?.trim()) segments.push("domain", normalized.domain.trim());
   } else {
     const normalized = filters as AssignmentsIndexFilters;
     if (normalized.status?.trim()) segments.push("status", normalized.status.trim());
@@ -400,7 +380,7 @@ function parseIndexUriTail(objectId: string): { tab: NewsroomIndexTab; filters:
   const segments = objectId.split("/").filter(Boolean);
   if (!segments.length) return null;
   const tab = segments[0];
-  if (tab !== "references" && tab !== "messages" && tab !== "assignments" && tab !== "insights") return null;
+  if (tab !== "references" && tab !== "messages" && tab !== "assignments") return null;
   if (segments.length === 1) {
     return { tab, filters: readIndexFiltersFromSearchParams(tab, new URLSearchParams()) };
   }
@@ -414,7 +394,6 @@ function parseIndexUriTail(objectId: string): { tab: NewsroomIndexTab; filters:
   }
   if (tab === "references") return { tab, filters: effectiveReferencesIndexFilters(filters) };
   if (tab === "messages") return { tab, filters: effectiveMessagesIndexFilters(filters) };
-  if (tab === "insights") return { tab, filters: effectiveInsightsIndexFilters(filters) };
   return { tab, filters: effectiveAssignmentsIndexFilters(filters) };
 }
 

package/lib/pretext-layout.ts

@@ -9,6 +9,27 @@ import {
 
 export { layoutNextLine, prepareWithSegments, type LayoutCursor, type PreparedTextWithSegments };
 
+const preparedTextCache = new Map<string, PreparedTextWithSegments>();
+let preparedTextCacheMissCount = 0;
+
+export function getPreparedTextCacheMissCount(): number {
+  return preparedTextCacheMissCount;
+}
+
+export function prepareWithSegmentsCached(
+  text: string,
+  font: string,
+  options?: { whiteSpace?: "normal" | "pre-wrap" },
+): PreparedTextWithSegments {
+  const key = `${options?.whiteSpace ?? "normal"}\u0000${font}\u0000${text}`;
+  const cached = preparedTextCache.get(key);
+  if (cached) return cached;
+  preparedTextCacheMissCount += 1;
+  const prepared = prepareWithSegments(text, font, options);
+  preparedTextCache.set(key, prepared);
+  return prepared;
+}
+
 export type TextLine = {
   text: string;
   width: number;
@@ -184,5 +205,6 @@ function clamp(value: number, min: number, max: number): number {
 }
 
 export function clearPretextMeasurementCache(): void {
+  preparedTextCache.clear();
   clearCache();
 }

package/lib/priming-proof-report.ts

@@ -36,6 +36,7 @@ export const primingProofReportSchema = z.object({
     fingerprint: z.string().min(1),
     frozenAt: z.string().min(1),
     source: z.string().min(1),
+    design: z.string().min(1).optional(),
   }),
   priming: z.object({
     acceptedExamples: z.number().int().min(0),

package/lib/prospectus-account-client.ts

@@ -0,0 +1,90 @@
+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 ACCOUNTS_PATH = "/api/auth/prospectus/accounts";
+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 ?? "" };
+}
+
+/**
+ * Create a publishing account for the signed-in person and select it. Each call carries a fresh idempotency key,
+ * so a retried request after a dropped response cannot create a second account.
+ */
+export async function createProspectusAccount(
+  name: string,
+  fetchImplementation: FetchImplementation = fetch,
+  idempotencyKey: string = crypto.randomUUID(),
+): Promise<{ selectedAccountId: string; role: string } | { error: string }> {
+  let response: Response;
+  try {
+    response = await fetchImplementation(ACCOUNTS_PATH, {
+      method: "POST",
+      credentials: "same-origin",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ name: name.trim() || undefined, idempotencyKey }),
+    });
+  } catch {
+    return { error: "The publishing account could not be created. Check your connection and try again." };
+  }
+  const body = await response.json().catch(() => null) as { selectedAccountId?: string; role?: string; message?: string } | null;
+  if (!response.ok || !body?.selectedAccountId) return { error: body?.message ?? "The publishing account could not be created." };
+  return { selectedAccountId: body.selectedAccountId, role: body.role ?? "" };
+}

package/lib/prospectus-sign-in-routes.ts

@@ -282,3 +282,48 @@ export async function handleProspectusAccountSelection(request: NextRequest, opt
     return signInFailedResponse(503, "prospectus_unavailable", "Prospectus could not be reached.");
   }
 }
+
+const MAXIMUM_PUBLISHING_ACCOUNT_NAME_LENGTH = 150;
+const DEFAULT_PUBLISHING_ACCOUNT_NAME = "Publishing account";
+const IDEMPOTENCY_KEY_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+export async function handleProspectusPublishingAccountCreation(request: NextRequest, options: ProspectusSignInRouteOptions = {}): Promise<NextResponse> {
+  const runtime = await signInRuntimeFor(request, options);
+  if (!runtime) return signInUnavailableResponse();
+  if (request.headers.get("origin") !== request.nextUrl.origin) {
+    return signInFailedResponse(403, "cross_origin_creation", "Create an account from this site.");
+  }
+  const nowInSeconds = currentTimeInSeconds(options);
+  const session = signedInProspectusSession(request, runtime.sealingSecret, nowInSeconds);
+  if (!session) return signInFailedResponse(401, "signed_out", "Sign in first.");
+  const body = await request.json().catch(() => null) as { name?: unknown; idempotencyKey?: unknown } | null;
+  const requestedName = typeof body?.name === "string" ? body.name.trim() : "";
+  const accountName = requestedName || DEFAULT_PUBLISHING_ACCOUNT_NAME;
+  if (accountName.length > MAXIMUM_PUBLISHING_ACCOUNT_NAME_LENGTH) {
+    return signInFailedResponse(400, "account_name_too_long", "Name the account in 150 characters or fewer.");
+  }
+  const idempotencyKey = typeof body?.idempotencyKey === "string" ? body.idempotencyKey : "";
+  if (!IDEMPOTENCY_KEY_PATTERN.test(idempotencyKey)) {
+    return signInFailedResponse(400, "idempotency_key_required", "Send a UUID idempotency key.");
+  }
+  try {
+    const created = await runtime.accounts.createAccount(session.accessToken, accountName, idempotencyKey);
+    const selection = await freshlyAuthorizedPublishingSelection(runtime, session, created.account.id, siteProductFor(options));
+    if (!selection) return signInFailedResponse(403, "not_a_publishing_account", "The new account does not grant publishing access on this site.");
+    const response = NextResponse.json(
+      { selectedAccountId: selection.accountId, role: selection.role, publicationCapabilities: selection.publicationCapabilities },
+      { status: 201, headers: NO_STORE_HEADERS },
+    );
+    const selectedSession: ProspectusSignedInSession = { ...session, selectedAccountId: selection.accountId };
+    response.cookies.set(
+      PROSPECTUS_SESSION_COOKIE,
+      sealProspectusCookie(runtime.sealingSecret, PROSPECTUS_SESSION_COOKIE, selectedSession, session.accessTokenExpiresAt),
+      sealedCookieAttributes(session.accessTokenExpiresAt, nowInSeconds),
+    );
+    return response;
+  } catch (error) {
+    if (error instanceof ProspectusAccountsError) return signInFailedResponse(error.status, error.code, error.message);
+    console.error(`Prospectus account creation failed (${error instanceof Error ? error.name : "error"}).`);
+    return signInFailedResponse(503, "prospectus_unavailable", "Prospectus could not be reached.");
+  }
+}

package/lib/prospectus-site-identity.ts

@@ -49,6 +49,7 @@ export interface ProspectusRequest {
   body?: unknown;
   humanAccessToken?: string;
   identityToken?: string;
+  idempotencyKey?: string;
 }
 
 export type ProspectusTransport = (request: ProspectusRequest) => Promise<unknown>;
@@ -84,7 +85,7 @@ export function signedProspectusTransport(options: SignedProspectusTransportOpti
   }
   const runtimeCredentials = options.runtimeCredentials ?? defaultProvider();
   const fetcher = options.fetcher ?? fetch;
-  return async ({ path, method, body, humanAccessToken, identityToken }) => {
+  return async ({ path, method, body, humanAccessToken, identityToken, idempotencyKey }) => {
     const credentials = await runtimeCredentials();
     if (!credentials.sessionToken || (credentials.expiration && credentials.expiration.getTime() <= Date.now())) {
       throw new Error("Prospectus calls require the site's temporary runtime credentials; static access keys are refused.");
@@ -95,6 +96,7 @@ export function signedProspectusTransport(options: SignedProspectusTransportOpti
       host: url.host,
       ...(humanAccessToken ? { "x-prospectus-human-token": humanAccessToken } : {}),
       ...(identityToken ? { "x-prospectus-identity-token": identityToken } : {}),
+      ...(idempotencyKey ? { "idempotency-key": idempotencyKey } : {}),
       ...(payload ? { "content-type": "application/json" } : {}),
     };
     const signer = new SignatureV4({ service: "execute-api", region: options.region, credentials, sha256: Sha256 });
@@ -144,6 +146,16 @@ export class ProspectusSiteAccounts {
     }) as Promise<ProspectusAccountAuthorization>;
   }
 
+  createAccount(humanAccessToken: string, accountName: string, idempotencyKey: string): Promise<{ account: { id: string; name: string; role: ProspectusRole } }> {
+    return this.transport({
+      path: "/v1/accounts",
+      method: "POST",
+      body: { name: accountName },
+      humanAccessToken,
+      idempotencyKey,
+    }) as Promise<{ account: { id: string; name: string; role: ProspectusRole } }>;
+  }
+
   accountDirectory(humanAccessToken: string): Promise<{ person: ProspectusPerson | null; accounts: ProspectusDirectoryAccount[] }> {
     return this.transport({ path: "/v1/account-directory", method: "GET", humanAccessToken }) as Promise<{
       person: ProspectusPerson | null;

package/lib/prospectus-tenant.ts

@@ -0,0 +1,22 @@
+import {
+  PROSPECTUS_SESSION_COOKIE,
+  loadProspectusSessionSealingSecret,
+  openProspectusCookie,
+  type ProspectusSignedInSession,
+} from "./prospectus-session";
+import { tenantIdForProspectusAccount } from "./tenant-keys";
+
+type CookieReader = { get(name: string): { value: string } | undefined };
+
+/**
+ * The tenant of the publishing account the signed-in person selected, read from the sealed Prospectus session
+ * cookie. Returns undefined on a site without Prospectus, with no session, or with no account selected, so the
+ * caller falls back to the site's own tenant (PAPYRUS_TENANT_ID).
+ */
+export async function selectedTenantIdFromCookies(cookies: CookieReader, loadSecret: () => Promise<string | null> = loadProspectusSessionSealingSecret): Promise<string | undefined> {
+  const sealingSecret = await loadSecret();
+  if (!sealingSecret) return undefined;
+  const session = openProspectusCookie<ProspectusSignedInSession>(sealingSecret, PROSPECTUS_SESSION_COOKIE, cookies.get(PROSPECTUS_SESSION_COOKIE)?.value);
+  if (!session || session.accessTokenExpiresAt * 1000 <= Date.now()) return undefined;
+  return tenantIdForProspectusAccount(session.selectedAccountId);
+}

package/lib/reader-static-params.ts

@@ -1,6 +1,6 @@
 import type { ContentRepository, EditionContent } from "./content-types";
 import { graphqlContentRepository } from "./graphql-content-repository";
-import { SITE_BRAND } from "./site-brand";
+import { SITE_BRAND, editionsEnabled } from "./site-brand";
 import { getContentSource } from "./site-env";
 import type { RendererConfig } from "./renderer-config";
 
@@ -40,6 +40,7 @@ const RESERVED_DATE_CHILD_SEGMENTS = new Set(["page", "section"]);
 type EnumerationRepository = Pick<ContentRepository, "listPublishedEditions" | "loadEditionContent">;
 
 function shouldEnumerateAtBuild(): boolean {
+  if (!editionsEnabled()) return false;
   if (process.env.NODE_ENV === "development") return false;
   return siteEnumeratesReaderRoutesAtBuild();
 }

package/lib/relevance-decisions.ts

@@ -2,6 +2,15 @@ import type { SemanticRelationRecord } from "./category-repository";
 
 export const RELEVANCE_RELATION = "relevance_decision_is";
 
+/** What produced a suggestion beyond the model version, as the sweep recorded it. */
+export type RelevanceProvenance = {
+  labelSet: string[];
+  doctrineFingerprint: string | null;
+  teachingFingerprint: string | null;
+  teachingLabels: number;
+  primingExamples: number;
+};
+
 /** The relevance cyclotron's current decision about one reference, as the References tab shows it. */
 export type RelevanceDecisionView = {
   decisionRelationId: string;
@@ -19,6 +28,10 @@ export type RelevanceDecisionView = {
   /** Thumbs for a two-class decision with a positive label; per-class buttons otherwise. */
   reviewControl: "thumbs" | "labels";
   cyclotronId: string | null;
+  /** When the cyclotron made the suggestion, if the decision recorded it. */
+  decidedAt: string | null;
+  /** Null for decisions made before provenance was recorded. */
+  provenance: RelevanceProvenance | null;
 };
 
 /** What an editor submits from the review control. */
@@ -49,6 +62,20 @@ function parseMetadata(value: unknown): Record<string, unknown> {
   }
 }
 
+function parseProvenance(value: unknown): RelevanceProvenance | null {
+  const record = parseMetadata(value);
+  if (!Object.keys(record).length) return null;
+  const count = (entry: unknown) => (Number.isFinite(Number(entry)) ? Number(entry) : 0);
+  const text = (entry: unknown) => (typeof entry === "string" && entry ? entry : null);
+  return {
+    labelSet: Array.isArray(record.labelSet) ? record.labelSet.map(String) : [],
+    doctrineFingerprint: text(record.doctrineFingerprint),
+    teachingFingerprint: text(record.teachingFingerprint),
+    teachingLabels: count(record.teachingLabels),
+    primingExamples: count(record.primingExamples),
+  };
+}
+
 /**
  * Current decisions keyed by reference lineage, from relations the Newsroom
  * already loads: no extra request per row.
@@ -77,6 +104,8 @@ export function currentRelevanceDecisions(relations: SemanticRelationRecord[]):
       question: typeof metadata.question === "string" ? metadata.question : null,
       reviewControl: metadata.reviewControl === "thumbs" ? "thumbs" : "labels",
       cyclotronId: typeof metadata.cyclotronId === "string" ? metadata.cyclotronId : null,
+      decidedAt: typeof metadata.decidedAt === "string" ? metadata.decidedAt : null,
+      provenance: parseProvenance(metadata.provenance),
     });
   }
   return decisions;

package/lib/relevance-status.ts

@@ -61,3 +61,76 @@ export const DEMO_CYCLOTRON_STATUS: CyclotronStatus = {
   lastChange: null,
   pending: { decisionsAwaitingReview: 1, staleSince: null },
 };
+
+/**
+ * What the Newsroom assumes until a decision names the cyclotron: the defaults
+ * of the steering config's relevanceCyclotron block (src/papyrus_content/relevance_cyclotron.py).
+ */
+export const DEFAULT_RELEVANCE_CYCLOTRON = { id: "papyrus-relevance", labels: ["include", "exclude"] } as const;
+
+/** The payload kind of a priming request; the sweep lists the cyclotron's payloads and filters on it. */
+export const PRIMING_REQUEST_KIND = "cyclotron-priming-request";
+
+/** The attachment role the sweep writes a request's outcome under. */
+export const PRIMING_OUTCOME_ROLE = "priming_outcome";
+
+/** The KnowledgeRawPayload an editor writes to ask the next sweep to prime the cyclotron with one URL. */
+export function primingRequestPayloadId(cyclotronId: string, requestId: string): string {
+  return `knowledge-raw-payload-cyclotron-priming-request-${safeId(cyclotronId)}-${safeId(requestId)}`;
+}
+
+export type PrimingRequest = {
+  requestId: string;
+  url: string;
+  label: string;
+  explanation: string;
+  requestedBy: string;
+  requestedAt: string;
+};
+
+export type PrimingOutcome =
+  | { state: "applied"; version: number; at: string; itemId?: string }
+  | { state: "failed"; message: string; at: string };
+
+/** A saved request with the sweep's outcome, once there is one. */
+export type PrimingRequestView = { request: PrimingRequest; outcome: PrimingOutcome | null };
+
+export function buildPrimingRequest(
+  input: { url: string; label: string; explanation?: string },
+  requestedBy: string,
+  labels: readonly string[],
+  now: Date = new Date(),
+  requestId: string = `${now.getTime().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+): PrimingRequest {
+  let parsed: URL | null = null;
+  try {
+    parsed = new URL(input.url.trim());
+  } catch {
+    parsed = null;
+  }
+  if (!parsed || parsed.protocol !== "https:") throw new Error("Paste an https URL.");
+  if (!labels.includes(input.label)) throw new Error(`Choose a label: ${labels.join(" or ")}.`);
+  return {
+    requestId,
+    url: parsed.toString(),
+    label: input.label,
+    explanation: (input.explanation ?? "").trim(),
+    requestedBy,
+    requestedAt: now.toISOString(),
+  };
+}
+
+export function isPrimingOutcome(value: unknown): value is PrimingOutcome {
+  if (!value || typeof value !== "object") return false;
+  const outcome = value as Record<string, unknown>;
+  return (outcome.state === "applied" && typeof outcome.version === "number")
+    || (outcome.state === "failed" && typeof outcome.message === "string");
+}
+
+/** In words: waiting for the next sweep, applied as version N, or failed with the reason. */
+export function primingStateText(view: PrimingRequestView): string {
+  if (!view.outcome) return "Waiting for the next sweep";
+  return view.outcome.state === "applied"
+    ? `Applied as version ${view.outcome.version}`
+    : `Failed: ${view.outcome.message}`;
+}

package/lib/reporting-story-budget.ts

@@ -106,7 +106,7 @@ export type ReportingStoryBudgetInput = {
   messagePayloads?: Record<string, unknown>;
 };
 
-const REPORTING_ASSIGNMENT_TYPE = "reporting.edition-candidate";
+const REPORTING_ASSIGNMENT_TYPE = "reporting.candidate";
 const REPORTING_PACKET_KIND = "reporting_context_packet";
 const RESEARCH_PACKET_KIND = "research_packet";
 
@@ -331,7 +331,7 @@ function buildResearchPacketIdsByReportingAssignment(assignments: AssignmentReco
     if (relation.subjectKind === "assignment" && relation.objectKind === "assignment") {
       const reporting = assignmentById.get(relation.subjectId);
       const research = assignmentById.get(relation.objectId);
-      if (reporting?.assignmentTypeKey !== REPORTING_ASSIGNMENT_TYPE || research?.assignmentTypeKey !== "research.edition-candidate") continue;
+      if (reporting?.assignmentTypeKey !== REPORTING_ASSIGNMENT_TYPE || research?.assignmentTypeKey !== "research.candidate") continue;
       for (const packetId of producedResearchPacketsByAssignment.get(research.id) ?? []) {
         result.set(reporting.id, addToSet(result.get(reporting.id), packetId));
       }

package/lib/semantic-graph.ts

@@ -41,7 +41,7 @@ export type SemanticPredicateId =
   | "has_editorial_form"
   | "about"
   | "comment"
-  | "insight_about"
+  | "note_about"
   | "ingestion_rationale"
   | "uses_evidence"
   | "uses_signal"
@@ -77,7 +77,7 @@ export const SEMANTIC_PREDICATES: SemanticPredicateDefinition[] = [
   { id: "reference_summary_1000_tokens", label: "1000-token reference summary", group: "summarization", inverseLabel: "1000-token summary for", contextPackTags: ["reference_curation", "research", "context_ranking"] },
   { id: "mentions", label: "mentions", group: "ontology", inverseLabel: "mentioned by" },
   { id: "has_editorial_form", label: "has editorial form", group: "editorial", inverseLabel: "items by editorial form", contextPackTags: ["editing", "publication", "assignment_context"] },
-  { id: "insight_about", label: "insight about", group: "knowledge", inverseLabel: "insights", contextPackTags: ["research", "reference_graph", "editing"] },
+  { id: "note_about", label: "note about", group: "knowledge", inverseLabel: "notes", contextPackTags: ["research", "reference_graph", "editing"] },
   { id: "about", label: "about", group: "commentary", inverseLabel: "commentary" },
   { id: "comment", label: "comments on", group: "commentary", inverseLabel: "commented on by", contextPackTags: ["reference_curation", "editing", "research", "assignment_context"] },
   { id: "ingestion_rationale", label: "ingestion rationale for", group: "commentary", inverseLabel: "ingestion rationale", contextPackTags: ["reference_curation", "editing", "research", "assignment_context"] },
@@ -317,13 +317,13 @@ export class SemanticGraphSnapshot {
     return ranked.map((entry) => entry.message);
   }
 
-  insightsFor(kind: string, lineageId: string): MessageRecord[] {
+  notesFor(kind: string, lineageId: string): MessageRecord[] {
     return this.incoming(kind, lineageId)
       .filter((relation) => relation.subjectKind === "message")
-      .filter((relation) => relationTypeKey(relation) === "insight_about" || relation.predicate === "insight_about")
+      .filter((relation) => relationTypeKey(relation) === "note_about" || relation.predicate === "note_about")
       .map((relation) => this.messagesById.get(relation.subjectId))
       .filter((message): message is MessageRecord => Boolean(message))
-      .filter((message) => message.messageKind === "insight" && message.messageDomain === "knowledge")
+      .filter((message) => message.messageKind === "note" && message.messageDomain === "knowledge")
       .sort((left, right) => right.createdAt.localeCompare(left.createdAt));
   }
 

package/lib/site-brand.ts

@@ -1,3 +1,5 @@
+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";
@@ -22,6 +24,8 @@ export type SiteBrandId = string;
 
 /** Brand-specific replacements for generic Pretext components. */
 export type SiteBrandComponents = {
+  /** The mark shown at the top of the newsroom CMS sidebar in place of the app title. */
+  NewsroomLogo?: ComponentType<{ className?: string }>;
   PictogramFigure?: ComponentType<PictogramFigureProps>;
   BlogPageBackground?: ComponentType<BlogPageBackgroundProps>;
 };
@@ -78,8 +82,15 @@ export type ContentItemName = {
 
 export const DEFAULT_CONTENT_ITEM_NAME: ContentItemName = { singular: "Story", plural: "Stories" };
 
+/** Browser-tab icon files under `public/`, as site-root paths. The dark variant defaults to the light one. */
+export type SiteBrandIcons = { light: string; dark?: string; appleTouch?: string };
+
+export const DEFAULT_SITE_BRAND_ICONS: Required<Pick<SiteBrandIcons, "light" | "dark">> & { fallback: string } = { light: "/icon-light.png", dark: "/icon-dark.png", fallback: "/icon.png" };
+
 export type SiteBrand = {
   id: SiteBrandId;
+  /** The browser-tab icon. Omit to use the Papyrus plant. */
+  icons?: SiteBrandIcons;
   appTitle: string;
   appDescription: string;
   mastheadTitle: string;
@@ -147,6 +158,11 @@ export type SiteBrand = {
   fonts?: SiteBrandFont[];
   demoEdition?: SiteBrandDemoEdition;
   video?: SiteBrandVideo;
+  /**
+   * Editions are an optional setting, off unless `{ enabled: true }`. When off the
+   * publication is a plain stream of items: no edition date routes, archive or masthead date.
+   */
+  editions?: { enabled: boolean };
 };
 
 const SERIF_TEXT_FONT = 'Georgia, "Times New Roman", serif';
@@ -184,11 +200,17 @@ const REFERENCE_SITE_BRANDS: Record<SiteBrandId, SiteBrand> = {
  * The Papyrus reference brand plus whatever the publication registered in its
  * own `papyrus.config.ts` (resolved through the `papyrus-site` alias).
  */
-const SITE_BRANDS: Record<SiteBrandId, SiteBrand> = {
+const REGISTERED_SITE_BRANDS: Record<SiteBrandId, SiteBrand> = {
   ...REFERENCE_SITE_BRANDS,
   ...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;
+
 export function normalizeSiteBrandId(value: string | undefined | null): SiteBrandId | null {
   if (!value) return null;
   const trimmed = value.trim();
@@ -237,6 +259,11 @@ export function getRootRoute(brand: SiteBrand = SITE_BRAND): RootRouteConfig {
 
 export const rootRoute = getRootRoute();
 
+/** The brand setting wins when present; otherwise the PAPYRUS_EDITIONS_ENABLED switch decides. */
+export function editionsEnabled(brand: Pick<SiteBrand, "editions"> = SITE_BRAND): boolean {
+  return brand.editions?.enabled ?? areEditionsEnabled();
+}
+
 export function enforcePresentation(presentation: EditionPresentationFormat): EditionPresentationFormat {
   return SITE_BRAND.forcedPresentation ?? presentation;
 }

package/lib/site-env.ts

@@ -20,6 +20,11 @@ export function getSiteEnv(environment: EnvironmentVariables = process.env): Sit
   return configured as SiteEnv;
 }
 
+export function areEditionsEnabled(environment: EnvironmentVariables = process.env): boolean {
+  const configured = (environment.PAPYRUS_EDITIONS_ENABLED ?? "").trim().toLowerCase();
+  return configured === "true" || configured === "1" || configured === "yes" || configured === "on";
+}
+
 export function getContentSource(environment: EnvironmentVariables = process.env): ContentSource {
   const configured = (environment.PAPYRUS_CONTENT_SOURCE ?? "").trim();
   if (!configured) return "published";