@anthusai/papyrus 1.0.0-next.60 → 1.0.0-next.61

package/app/tailwind.css

@@ -1,4 +1,5 @@
 @import "tailwindcss";
+@source "../../../cyclotron/trace-ui/src/**/*.{ts,tsx}";
 @source "../components/**/*.{ts,tsx}";
 @source "../app/**/*.{ts,tsx}";
 @source "../lib/**/*.{ts,tsx}";

package/components/newsroom-curation-provider.tsx

@@ -0,0 +1,17 @@
+'use client';
+
+import {createContext,useContext,useMemo,useRef,type ReactNode} from 'react';
+import {createCurationSession,requestCuration,type CurationBootstrap,type CurationRequest,type CurationSession} from '../lib/curation-client';
+import type {PublicationScope} from '../lib/publication-cyclotron';
+
+const Context=createContext<CurationSession|null>(null);
+
+/** Host opt-in. Absence preserves the released CMS and performs no new reads. */
+export function NewsroomCurationProvider({bootstrap,request=requestCuration,children}:{bootstrap:CurationBootstrap|null;request?:CurationRequest;children:ReactNode}){
+  const selected=useRef<PublicationScope|null>(bootstrap?.scope??null);
+  selected.current=bootstrap?.scope??null;
+  const session=useMemo(()=>bootstrap?createCurationSession(bootstrap,request,()=>selected.current):null,[bootstrap,request]);
+  return <Context.Provider value={session}>{children}</Context.Provider>;
+}
+
+export function useNewsroomCuration(){return useContext(Context);}

package/components/newsroom-references-view.tsx

@@ -1,5 +1,9 @@
 "use client";
 
+import type { PrimingPanelProps } from "cyclotron/components/priming-panel";
+import { ReferencePriming } from "./reference-priming";
+import { ReferenceCurationControls } from "./reference-curation-controls";
+
 import {
   ArchiveIcon,
   ChevronLeftIcon,
@@ -54,6 +58,8 @@ import {
 } from "./news-desk-taxonomy-client";
 
 type NewsroomReferencesViewProps = {
+  /** Present only when the host has configured optional example priming. */
+  priming?: PrimingPanelProps;
   /** The relevance cyclotron's status snapshot, shown above the list. */
   cyclotronStatus?: CyclotronStatus | null;
   /** Present for editors who may ask for a manual review rate. */
@@ -391,6 +397,7 @@ function ReferenceDetailPanel({
 }
 
 export function NewsroomReferencesView({
+  priming,
   cyclotronStatus,
   decisions,
   onRequestReviewRate,
@@ -507,6 +514,8 @@ export function NewsroomReferencesView({
             Review source intake before it becomes accepted evidence.
           </p>
         </div>
+        <ReferenceCurationControls disabled={disabled} />
+        {priming && !disabled ? <ReferencePriming {...priming} /> : null}
         {cyclotronStatus ? (
           <div className="shrink-0">
             <ReferenceCyclotronStatus onRequestRate={disabled ? undefined : onRequestReviewRate} status={cyclotronStatus} />

package/components/publication-cyclotron-panel.tsx

@@ -0,0 +1,57 @@
+'use client';
+
+import {useRef,useState} from 'react';
+import {ReviewControl,type ReviewControlReview} from 'cyclotron/components/review-control';
+import {CyclotronStatusView} from 'cyclotron/components/cyclotron-status';
+import {assertPublicationScope,publicationScopeKey,publicationReviewPayload,type PublicationStatus,type PublicationHistory,type PublicationHistoryRow,type PublicationReviewPayload} from '../lib/publication-cyclotron';
+
+function requestId(){
+ const bytes=crypto.getRandomValues(new Uint8Array(16));
+ return Array.from(bytes,value=>value.toString(16).padStart(2,'0')).join('');
+}
+
+/** Data-only shared operator panel. The authorized host owns reads, writes and refresh. */
+type PublicationPanelProps={mode:'embedded'|'remote';status:PublicationStatus;history:PublicationHistory;onReview?:(payload:PublicationReviewPayload)=>Promise<void>;onSteer?:(classifier:string)=>void};
+export function PublicationCyclotronPanel(props:PublicationPanelProps){
+ assertPublicationScope(props.status,props.history);
+ // Remount all drafts, retry identities, pending messages and busy state on scope change.
+ return <PublicationControls key={publicationScopeKey(props.status)} {...props}/>;
+}
+function PublicationControls({mode,status,history,onReview,onSteer}:PublicationPanelProps){
+ assertPublicationScope(status,history);
+ const context=publicationScopeKey(status);const current=useRef(context);current.current=context;
+ const [message,setMessage]=useState<{context:string;key:string;error:boolean;text:string}|null>(null);const [busy,setBusy]=useState<string|null>(null);
+ const [editing,setEditing]=useState<Record<string,boolean>>({});const requests=useRef<Record<string,{signature:string;id:string}>>({});
+ async function submit(row:PublicationHistoryRow,classifier:string,review:ReviewControlReview){
+  const key=`${context}:${row.decision.decisionId}:${classifier}:${row.context?.contextId??'legacy'}`;
+  try{
+   const signature=JSON.stringify(review);const previous=requests.current[key];
+   const id=previous?.signature===signature?previous.id:requestId();requests.current[key]={signature,id};
+   const payload=publicationReviewPayload(status,row,classifier,review,id);
+   if(!onReview)throw new Error('This host has not enabled human review');
+   setBusy(key);setMessage(null);await onReview(payload);
+   if(current.current===context){setMessage({context,key,error:false,text:'Human label acknowledged.'});setEditing(old=>({...old,[key]:false}));}
+  }catch(error){if(current.current===context)setMessage({context,key,error:true,text:error instanceof Error?error.message:'Review failed; its outcome must be checked before retrying.'});}
+  finally{if(current.current===context)setBusy(null);}
+ }
+ return <section data-publication-scope={context} aria-label="Publication Cyclotron controls" className="space-y-4">
+  <header><h2 className="text-lg font-semibold">Cyclotron · {status.publicationId}</h2><p className="text-sm text-muted-foreground">{mode==='embedded'?'Classifier data owned by this deployment.':'Canonical classifier data owned by the shared remote lab.'}</p></header>
+  {status.outputs.map(output=><section key={`${context}:${output.id}`} aria-label={output.question} className="space-y-3 rounded-md border p-3">
+   <CyclotronStatusView status={status.classifiers[output.id]} classifierName={output.question} variant="card"/>
+   {onSteer?<button type="button" disabled={Boolean(busy)} onClick={()=>onSteer(output.id)}>Evaluate classifier proposal</button>:null}
+   {history.history.map(row=>{
+    const prediction=row.decision.classifiers[output.id];if(!prediction)return null;
+    const key=`${context}:${row.decision.decisionId}:${output.id}:${row.context?.contextId??'legacy'}`;const saved=row.reviews[output.id];const historical=Boolean(row.historicalContext||row.provenanceUnavailable||row.feedbackReconciliationRequired);
+    return <article key={key} className="space-y-2 rounded-md border p-3">
+     {historical?<p className="text-sm">Historical source or binding revision · read-only</p>:null}{row.feedbackReconciliationRequired?<p role="status">Canonical feedback changed; provenance reconciliation is required before replay.</p>:null}<h3 className="font-medium">{String(row.item.title??row.decision.itemId)}</h3>
+     <p className="whitespace-pre-wrap text-sm">{String(row.item.abstract??row.item.text??'')}</p>
+     {!saved||editing[key]?<p className="text-sm" role="status">{historical?'This source revision is read-only.':!onReview?'Human review is unavailable in this session.':busy===key?'Submitting review… Your selection is preserved; wait for acknowledgement.':'Choose a label to enable Submit review. Explanation is optional.'}</p>:null}
+     <ReviewControl key={`${key}:${Boolean(editing[key])}`} itemId={`${row.decision.itemId}:${Array.from(new TextEncoder().encode(context+':'+output.id+':'+(row.context?.contextId??'legacy')),byte=>byte.toString(16).padStart(2,'0')).join('')}`} decision={{decisionId:row.decision.decisionId,...prediction,classes:output.classes}} question={output.question} mode="labels" positiveLabel={output.positiveLabel??undefined} disabled={Boolean(busy)||!onReview||historical} value={saved&&!editing[key]?{label:saved.label,reasonCode:saved.reasonCode,explanation:saved.explanation}:undefined} onReview={review=>void submit(row,output.id,{...review,itemId:row.decision.itemId})}/>
+     {message?.context===context&&message.key===key?<p role={message.error?'alert':'status'} className="text-sm">{message.text}</p>:null}
+     {saved&&onReview&&!historical&&!editing[key]?<button type="button" disabled={Boolean(busy)} onClick={()=>setEditing(old=>({...old,[key]:true}))}>Correct human label</button>:null}
+     <details><summary>Decision provenance and version</summary><pre className="max-h-64 overflow-auto whitespace-pre-wrap text-xs">{JSON.stringify({itemId:row.decision.itemId,source:row.item.source_uri,decisionId:row.decision.decisionId,prediction,bindingRevision:row.context?.binding.values.revision??status.bindingRevision,sourceRef:row.context?.sourceRef,contextId:row.context?.contextId},null,2)}</pre></details>
+    </article>;
+   })}
+  </section>)}
+ </section>;
+}

package/components/reference-curation-controls.tsx

@@ -0,0 +1,77 @@
+'use client';
+
+import {useCallback,useEffect,useRef,useState} from 'react';
+import {useNewsroomCuration} from './newsroom-curation-provider';
+import {PublicationCyclotronPanel} from './publication-cyclotron-panel';
+import {ReferencePriming} from './reference-priming';
+import {Button} from './ui/button';
+import {publicationSteeringPayload,type PublicationHistory,type PublicationStatus} from '../lib/publication-cyclotron';
+import type {CurationSession} from '../lib/curation-client';
+
+export function ReferenceCurationControls({disabled=false}:{disabled?:boolean}){
+  const session=useNewsroomCuration();
+  return session&&!disabled?<Controls key={session.key} session={session} disabled={disabled}/>:null;
+}
+
+function Controls({session,disabled}:{session:CurationSession;disabled:boolean}){
+  const [snapshot,setSnapshot]=useState<{status:PublicationStatus;history:PublicationHistory}|null>(null);
+  const [error,setError]=useState('');
+  const [loading,setLoading]=useState(true);
+  const [primingMessage,setPrimingMessage]=useState('');
+  const [steering,setSteering]=useState<string|null>(null);
+  const [rubric,setRubric]=useState('');
+  const [explanation,setExplanation]=useState('');
+  const [busy,setBusy]=useState(false);
+  const [trial,setTrial]=useState<{fingerprint:string;improved:boolean}|null>(null);
+  const [steeringMessage,setSteeringMessage]=useState('');
+  const steeringRequests=useRef<Record<string,string>>({});
+  const canReview=!disabled&&session.bootstrap.capabilities.includes('review');
+  const canSteer=!disabled&&session.bootstrap.capabilities.includes('steer');
+  const refresh=useCallback(async()=>{
+    setLoading(true);setError('');
+    try{setSnapshot(await session.snapshot());}
+    catch(failure){setSnapshot(null);setError(failure instanceof Error?failure.message:'Curation status unavailable');}
+    finally{setLoading(false);}
+  },[session]);
+  useEffect(()=>{
+    let active=true;
+    void session.snapshot().then(value=>{if(active){setSnapshot(value);setError('');}}).catch(failure=>{if(active){setSnapshot(null);setError(failure instanceof Error?failure.message:'Curation status unavailable');}}).finally(()=>{if(active)setLoading(false);});
+    return()=>{active=false;};
+  },[session]);
+  async function steer(action:'evaluate'|'promote'){
+    if(!snapshot||!steering||!session.bootstrap.bindingRef)return;
+    setBusy(true);setSteeringMessage('');
+    try{
+      const identity=JSON.stringify([action,steering,rubric.trim(),explanation.trim(),trial?.fingerprint??'',snapshot.status.classifiers[steering].cyclotron.fingerprint]);
+      const requestId=steeringRequests.current[identity]??=crypto.randomUUID();
+      const command=action==='evaluate'?{action,proposal:{rubric:rubric.trim()},explanation,requestId} as const:{action,trialFingerprint:trial?.fingerprint??'',explanation,requestId} as const;
+      const payload=publicationSteeringPayload(snapshot.status,steering,session.bootstrap.bindingRef,command);
+      const receipt=await session.publication.steer(payload);
+      const result=(receipt.steering as {result?:{trial_fingerprint?:string;improved?:boolean;promoted?:boolean}}|undefined)?.result;
+      if(action==='evaluate')setTrial(result?.trial_fingerprint?{fingerprint:result.trial_fingerprint,improved:result.improved===true}:null);
+      setSteeringMessage(action==='promote'?'Evaluated proposal promoted.':result?.improved?'Evaluation complete: the candidate improved the measured result.':'Evaluation complete: no improvement was reported.');
+      await refresh();
+    }catch(failure){setSteeringMessage(failure instanceof Error?failure.message:'Proposal outcome unavailable; check before retrying');}
+    finally{setBusy(false);}
+  }
+  return <section aria-label="Publication curation" className="max-h-[55dvh] min-h-0 shrink-0 space-y-3 overflow-y-auto rounded-md border p-3" data-curation-mode={session.bootstrap.mode}>
+    <div className="flex items-center justify-between gap-3"><h3 className="font-semibold">Publication curation</h3><Button variant="outline" size="sm" disabled={loading||busy} onClick={()=>void refresh()}>Refresh curation</Button></div>
+    <p className="text-xs text-muted-foreground">{session.bootstrap.mode==='remote'?'Remote workspace':'Embedded workspace'} · {session.bootstrap.scope.publicationId}</p>
+    {loading?<p role="status">Loading publication monitoring…</p>:null}
+    {error?<p role="alert">{error}</p>:null}
+    {snapshot?<PublicationCyclotronPanel mode={session.bootstrap.mode} status={snapshot.status} history={snapshot.history}
+      onReview={canReview?async payload=>{await session.publication.review(payload);await refresh();}:undefined}
+      onSteer={canSteer&&snapshot.status.features?.steering&&session.bootstrap.bindingRef?classifier=>{setSteering(classifier);setRubric('');setExplanation('');setTrial(null);setSteeringMessage('');}:undefined}/>:null}
+    {steering?<form aria-label="Classifier proposal" className="space-y-3 rounded-md border p-3" onSubmit={event=>{event.preventDefault();void steer('evaluate');}}>
+      <h4 className="font-semibold">Evaluate classifier proposal</h4>
+      <p className="text-sm">A proposal is evaluated before an explicit promotion. Existing classifications are not relabeled by opening this form.</p>
+      <label className="block text-sm">Proposed instructions<textarea className="mt-1 block min-h-24 w-full rounded border bg-background p-2" required value={rubric} onChange={event=>{setRubric(event.target.value);setTrial(null);}}/></label>
+      <label className="block text-sm">Why make this change?<textarea className="mt-1 block min-h-20 w-full rounded border bg-background p-2" required value={explanation} onChange={event=>setExplanation(event.target.value)}/></label>
+      <div className="flex flex-wrap gap-2"><Button type="submit" disabled={busy||!canSteer||!rubric.trim()||!explanation.trim()}>Evaluate proposal</Button><Button type="button" variant="outline" disabled={busy||!canSteer||!trial?.improved||!explanation.trim()} onClick={()=>void steer('promote')}>Promote evaluated proposal</Button><Button type="button" variant="ghost" disabled={busy} onClick={()=>setSteering(null)}>Close proposal</Button></div>
+      {steeringMessage?<p role="status">{steeringMessage}</p>:null}
+    </form>:null}
+    {session.bootstrap.priming&&canReview?<ReferencePriming client={session.priming} listId={session.bootstrap.priming.listId} classifiers={session.bootstrap.priming.classifiers}
+      onAccepted={draft=>{setPrimingMessage(`Accepted ${draft.rows.length} example item${draft.rows.length===1?'':'s'} for this pinned publication. Operation remains available without priming.`);void refresh();}}/>:null}
+    {primingMessage?<p role="status">{primingMessage}</p>:null}
+  </section>;
+}

package/components/reference-priming.tsx

@@ -0,0 +1,18 @@
+"use client";
+
+import { useState } from "react";
+import { PrimingPanel, type PrimingPanelProps } from "cyclotron/components/priming-panel";
+import { Button } from "./ui/button";
+
+/** Papyrus supplies its transport/configuration; Cyclotron owns preview and labels. */
+export function ReferencePriming(props: PrimingPanelProps) {
+  const [open, setOpen] = useState(false);
+  return (
+    <section className="shrink-0 space-y-3" aria-label="Representative reference examples">
+      <Button aria-expanded={open} onClick={() => setOpen((value) => !value)} variant="outline">
+        {open ? "Hide example priming" : "Curate reference examples (optional)"}
+      </Button>
+      {open ? <div className="max-h-[55dvh] space-y-3 overflow-y-auto pr-1"><p className="text-sm text-muted-foreground">Corrections to extracted content: describe what needs fixing, then enter the corrected title and abstract or summary. The note is saved with your correction; it does not automatically regenerate the content. Choose Publish / Not publish separately. An explanation of that judgment is optional.</p><PrimingPanel {...props} renderItem={props.renderItem ?? ((item) => <div className="space-y-2"><p className="whitespace-pre-wrap text-sm">{String(item.values.abstract ?? item.values.text ?? "")}</p><p className="break-all text-xs text-muted-foreground">{String(item.values.source_uri ?? "")}</p></div>)} /></div> : null}
+    </section>
+  );
+}

package/lib/curation-client.ts

@@ -0,0 +1,61 @@
+import {createPrimingClient} from 'cyclotron/priming-client';
+import {assertPublicationScope,createPublicationClient,publicationScopeKey,type PublicationEnvelope,type PublicationRevisionRef,type PublicationScope} from './publication-cyclotron';
+
+export type CurationBootstrap={
+  scope:PublicationScope;
+  mode:'embedded'|'remote';
+  priming:{listId:string;classifiers:{id:string;revision:number}[]}|null;
+  capabilities:readonly string[];
+  bindingRef:PublicationRevisionRef|null;
+};
+export type CurationRequest=<T>(path:string,body:Record<string,unknown>,scope:Readonly<PublicationScope>)=>Promise<T>;
+
+/** Same-origin only. The server verifies these expected pins against its session. */
+export const requestCuration:CurationRequest=async<T,>(path:string,body:Record<string,unknown>,scope:Readonly<PublicationScope>)=>{
+  if(!path.startsWith('/api/newsroom/curation/'))throw new Error('Same-origin curation route required');
+  const controller=new AbortController();
+  const timer=setTimeout(()=>controller.abort(),15000);
+  let response:Response;
+  let result;
+  try{
+  response=await fetch(path,{method:'POST',credentials:'same-origin',signal:controller.signal,headers:{
+    'Content-Type':'application/json','X-Cyclotron-Account':scope.accountId,
+    'X-Papyrus-Publication':scope.publicationId,'X-Papyrus-Binding':scope.bindingRevision,
+  },body:JSON.stringify(body)});
+  result=await response.json().catch(()=>null);
+  }catch(error){
+    const timeout=controller.signal.aborted||(error instanceof Error&&error.name==='AbortError');
+    throw new Error(timeout?'Curation request timed out. Your selection is preserved. Check the server and saved history before retrying; do not resubmit automatically.':'Cannot reach the curation server. Your selection is preserved. Check the preview is running and saved history before retrying; do not resubmit automatically.');
+  }finally{clearTimeout(timer);}
+  if(response.status===401)throw new Error('Sign in again: the curation session expired. Your selection is preserved.');
+  if(response.status===403)throw new Error('Your session does not have permission for this curation action. Your selection is preserved.');
+  if(!response.ok||!result||result.errors)throw new Error(`Curation request failed (HTTP ${response.status}): ${result?.error??result?.errors?.[0]?.message??'invalid server response'}. Check saved history before retrying; your selection is preserved.`);
+  return result as T;
+};
+
+/** One controller contract for both modes; no browser-selected service URL. */
+export function createCurationSession(bootstrap:CurationBootstrap,request:CurationRequest,currentScope:()=>PublicationScope|null){
+  const pinned=Object.freeze({...bootstrap.scope});
+  const scopeKey=publicationScopeKey(pinned);
+  const assertCurrent=()=>{
+    const selected=currentScope();
+    if(!selected||publicationScopeKey(selected)!==scopeKey)throw new Error('Curation account selection changed; refresh context');
+  };
+  const publication=createPublicationClient(pinned,(operation,payload,scope)=>request<PublicationEnvelope&Record<string,unknown>>('/api/newsroom/curation/publication',{operation,payload},scope),currentScope);
+  const priming=createPrimingClient(async<T,>(query:string,variables:Record<string,unknown>):Promise<T>=>{
+    assertCurrent();
+    const result=await request<{data:T}>('/api/newsroom/curation/priming',{query,variables},pinned);
+    assertCurrent();
+    return result.data;
+  });
+  return {
+    key:JSON.stringify([bootstrap.mode,scopeKey]),bootstrap,publication,priming,
+    async snapshot(){
+      const [status,history]=await Promise.all([publication.status(),publication.history()]);
+      assertCurrent();assertPublicationScope(status,history);
+      return {status,history};
+    },
+  };
+}
+
+export type CurationSession=ReturnType<typeof createCurationSession>;

package/lib/publication-cyclotron.ts

@@ -0,0 +1,74 @@
+import type {CyclotronDecision,CyclotronReview} from 'cyclotron/sdk-types';
+import type {CyclotronStatus} from 'cyclotron/cyclotron-status';
+import type {ReviewControlReview} from 'cyclotron/components/review-control';
+
+export type PublicationScope={accountId:string;publicationId:string;bindingRevision:string};
+export type PublicationEnvelope=PublicationScope&{contractVersion:'cyclotron-publication/v1';publicationId:string;bindingRevision:string;features?:{frozenContext:boolean;replayExport:boolean;steering:boolean};outputs:Array<{id:string;question:string;classes:string[];positiveLabel:string|null}>};
+export type PublicationStatus=PublicationEnvelope&{classifiers:Record<string,CyclotronStatus>};
+export type PublicationRevisionRef={listId:string;itemId:string;revision:number;contentHash:string};
+export type PublicationContext={contextId:string;decisionId:string;publicationId:string;sourceRef:PublicationRevisionRef;bindingRef:PublicationRevisionRef;source:{id:string;values:Record<string,unknown>};binding:{values:{accountId:string;publicationId:string;revision:string;outputs:string[]}}};
+export type PublicationHistoryRow={decision:CyclotronDecision;item:Record<string,unknown>;state?:string;reviews:Record<string,CyclotronReview>;context?:PublicationContext;historicalContext?:boolean;provenanceUnavailable?:boolean;feedbackReconciliationRequired?:boolean};
+export type PublicationHistory=PublicationEnvelope&{history:PublicationHistoryRow[]};
+export type PublicationReviewPayload={bindingRevision:string;decisionId:string;classifier:string;predictionVersion:number;predictionFingerprint:string;requestId:string;label:string;explanation:string;reasonCode:string|null;contextId?:string};
+export type PublicationSteeringInput={requestId:string;explanation:string}&({action:'evaluate';proposal:Record<string,unknown>}|{action:'promote';trialFingerprint:string});
+export type PublicationSteeringPayload=PublicationSteeringInput&{bindingRevision:string;bindingRef:PublicationRevisionRef;classifier:string;expectedFingerprint:string};
+
+function ordered(value:unknown):unknown{
+ if(Array.isArray(value))return value.map(ordered);
+ if(value&&typeof value==='object')return Object.fromEntries(Object.entries(value).sort(([a],[b])=>a.localeCompare(b)).map(([key,item])=>[key,ordered(item)]));
+ return value;
+}
+
+/** Stable cache/component identity; length-safe even when IDs contain delimiters. */
+export function publicationScopeKey(scope:PublicationScope):string{
+ if([scope.accountId,scope.publicationId,scope.bindingRevision].some(value=>typeof value!=='string'||!value.trim()))throw new Error('Complete publication account scope required');
+ return JSON.stringify([scope.accountId,scope.publicationId,scope.bindingRevision]);
+}
+
+export function assertPublicationScope(status:PublicationStatus,history:PublicationHistory){
+ if(status.contractVersion!=='cyclotron-publication/v1'||history.contractVersion!==status.contractVersion||publicationScopeKey(status)!==publicationScopeKey(history)||status.publicationId!==history.publicationId||status.bindingRevision!==history.bindingRevision)throw new Error('Publication snapshot binding mismatch');
+ const outputs=new Set(status.outputs.map(output=>output.id));
+ if(!outputs.size||outputs.size!==status.outputs.length||status.outputs.some(output=>status.classifiers[output.id]?.cyclotron.classifier!==output.id)||JSON.stringify(history.outputs)!==JSON.stringify(status.outputs))throw new Error('Publication snapshot is incomplete');
+ if(Object.keys(status.classifiers).some(id=>!outputs.has(id))||history.outputs.some(output=>!outputs.has(output.id))||history.history.some(row=>[...Object.keys(row.decision.classifiers),...Object.keys(row.reviews)].some(id=>!outputs.has(id))))throw new Error('Snapshot includes an output outside this publication');
+ if(history.history.some(row=>row.context&&(row.context.binding.values.accountId!==status.accountId||row.context.publicationId!==status.publicationId||row.context.decisionId!==row.decision.decisionId||JSON.stringify(ordered(row.context.source.values))!==JSON.stringify(ordered(row.item)))))throw new Error('Historical source context mismatch');
+}
+
+/** Explicit output target and incumbent pin; never a global review-rate mutation. */
+export function publicationSteeringPayload(status:PublicationStatus,classifier:string,bindingRef:PublicationRevisionRef,command:PublicationSteeringInput):PublicationSteeringPayload{
+ if(!status.outputs.some(output=>output.id===classifier)||!status.classifiers[classifier])throw new Error('Steering output is outside this publication');
+ if(!command.requestId.trim()||!command.explanation.trim())throw new Error('Steering needs a stable identity and explicit explanation');
+ const fingerprint=status.classifiers[classifier].cyclotron.fingerprint;
+ if(!fingerprint)throw new Error('Active classifier fingerprint unavailable');
+ if(command.action==='evaluate'){
+  if(!Object.keys(command.proposal).length||Object.keys(command.proposal).some(key=>!['rubric','tasks','example_ids','dynamic_elements'].includes(key)))throw new Error('Native proposal fields required');
+ }else if(command.action!=='promote'||!command.trialFingerprint.trim())throw new Error('An explicitly evaluated trial is required');
+ return {...command,explanation:command.explanation.trim(),bindingRevision:status.bindingRevision,bindingRef,classifier,expectedFingerprint:fingerprint};
+}
+
+export function publicationReviewPayload(binding:PublicationEnvelope,row:PublicationHistoryRow,classifier:string,review:ReviewControlReview,requestId:string):PublicationReviewPayload{
+ if(row.context&&row.context.binding.values.accountId!==binding.accountId)throw new Error('Review account context mismatch');
+ if(row.historicalContext||row.provenanceUnavailable||row.feedbackReconciliationRequired||row.context&&row.context.binding.values.revision!==binding.bindingRevision)throw new Error('Historical source or binding revision is read-only');
+ const output=binding.outputs.find(output=>output.id===classifier);const prediction=row.decision.classifiers[classifier];
+ if(!output||!prediction||review.decisionId!==row.decision.decisionId||review.itemId!==row.decision.itemId)throw new Error('Review does not match the displayed publication decision');
+ if(!review.label||!output.classes.includes(review.label))throw new Error('Choose an explicit classification label');
+ if(!requestId.trim())throw new Error('A stable review request identity is required');
+ return {bindingRevision:binding.bindingRevision,decisionId:row.decision.decisionId,classifier,predictionVersion:prediction.version,predictionFingerprint:prediction.fingerprint,requestId,label:review.label,explanation:review.explanation?.trim()??'',reasonCode:review.reasonCode,...(row.context?{contextId:row.context.contextId}:{})};
+}
+
+/** Host chooses an authenticated same-origin BFF; storage mode never changes UI semantics. */
+export function createPublicationClient(scope:PublicationScope,request:(operation:string,payload:Record<string,unknown>,scope:Readonly<PublicationScope>)=>Promise<PublicationEnvelope&Record<string,unknown>>,currentScope:()=>PublicationScope|null){
+ const pinned=Object.freeze({accountId:scope.accountId,publicationId:scope.publicationId,bindingRevision:scope.bindingRevision});
+ const key=publicationScopeKey(pinned);
+ const assertSelected=()=>{const current=currentScope();if(!current||publicationScopeKey(current)!==key)throw new Error('Publication account selection changed; refresh context');};
+ const command=async(operation:string,payload:Record<string,unknown>)=>{
+  assertSelected();
+  if('bindingRevision' in payload&&payload.bindingRevision!==pinned.bindingRevision)throw new Error('Publication binding changed; refresh context');
+  const value=await request(operation,payload,pinned);
+  assertSelected();
+  if(value.contractVersion!=='cyclotron-publication/v1'||publicationScopeKey(value)!==key)throw new Error('Publication response contract mismatch');
+  return value;
+ };
+ return {scope:pinned,cacheKey:key,command,status:async()=>await command('status',{}) as PublicationStatus,history:async()=>await command('history',{}) as PublicationHistory,
+  review:async(payload:PublicationReviewPayload)=>command('review',payload),
+  steer:async(payload:PublicationSteeringPayload)=>command('steer',payload),replayRecords:async()=>command('replay',{})};
+}

package/package.json

@@ -88,6 +88,7 @@
     "./components/newsroom-assignments-view": "./components/newsroom-assignments-view.tsx",
     "./components/newsroom-board-view": "./components/newsroom-board-view.tsx",
     "./components/newsroom-client-shell": "./components/newsroom-client-shell.tsx",
+    "./components/newsroom-curation-provider": "./components/newsroom-curation-provider.tsx",
     "./components/newsroom-ops-overview": "./components/newsroom-ops-overview.tsx",
     "./components/newsroom-ops-shell": "./components/newsroom-ops-shell.tsx",
     "./components/newsroom-organizer-shell": "./components/newsroom-organizer-shell.tsx",
@@ -98,11 +99,14 @@
     "./components/presentation-footer": "./components/presentation-footer.tsx",
     "./components/presentation-header": "./components/presentation-header.tsx",
     "./components/presentation-rhythm-hrule": "./components/presentation-rhythm-hrule.tsx",
+    "./components/publication-cyclotron-panel": "./components/publication-cyclotron-panel.tsx",
     "./components/reader-auth-control": "./components/reader-auth-control.tsx",
     "./components/reader-auth-state": "./components/reader-auth-state.ts",
     "./components/reader-settings": "./components/reader-settings.ts",
     "./components/reader-theme-control": "./components/reader-theme-control.tsx",
+    "./components/reference-curation-controls": "./components/reference-curation-controls.tsx",
     "./components/reference-cyclotron-status": "./components/reference-cyclotron-status.tsx",
+    "./components/reference-priming": "./components/reference-priming.tsx",
     "./components/reference-relevance-review": "./components/reference-relevance-review.tsx",
     "./components/reference-source-preview": "./components/reference-source-preview.tsx",
     "./components/settings-page": "./components/settings-page.tsx",
@@ -153,6 +157,7 @@
     "./lib/content-repository": "./lib/content-repository.ts",
     "./lib/content-source-context": "./lib/content-source-context.ts",
     "./lib/content-types": "./lib/content-types.ts",
+    "./lib/curation-client": "./lib/curation-client.ts",
     "./lib/define-site": "./lib/define-site.ts",
     "./lib/demo-amplify-outputs": "./lib/demo-amplify-outputs.ts",
     "./lib/dev-sandbox-editor-auth": "./lib/dev-sandbox-editor-auth.ts",
@@ -201,6 +206,7 @@
     "./lib/presentation-footer": "./lib/presentation-footer.ts",
     "./lib/pretext-layout": "./lib/pretext-layout.ts",
     "./lib/public-placeholder-config": "./lib/public-placeholder-config.ts",
+    "./lib/publication-cyclotron": "./lib/publication-cyclotron.ts",
     "./lib/publication-items": "./lib/publication-items.ts",
     "./lib/rate-limit-retry": "./lib/rate-limit-retry.ts",
     "./lib/reader-base-path": "./lib/reader-base-path.ts",
@@ -319,7 +325,7 @@
       "optional": true
     }
   },
-  "version": "1.0.0-next.60",
+  "version": "1.0.0-next.61",
   "dependencies": {
     "@aws-amplify/adapter-nextjs": "^1.7.3",
     "@aws-sdk/client-cognito-identity-provider": "3.1045.0",
@@ -342,7 +348,7 @@
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
-    "cyclotron": "https://github.com/AnthusAI/Cyclotron/releases/download/ui-v0.2.1/cyclotron-0.2.1.tgz",
+    "cyclotron": "https://github.com/AnthusAI/Cyclotron/releases/download/ui-v0.2.2/cyclotron-0.2.2.tgz",
     "esbuild": "^0.28.2",
     "gray-matter": "^4.0.3",
     "gsap": "^3.15.0",

package/routes.manifest.json

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