@validation-os/dashboard 0.4.0 → 0.6.0

package/dist/index.d.ts

@@ -1,7 +1,334 @@
 import * as react from 'react';
 import { ReactNode } from 'react';
 import { Collection, AnyRecord, Relation } from '@validation-os/core';
-import { Progress, MoverKind, TrajectoryPoint } from '@validation-os/core/derivation';
+import { PortfolioProgress, StageExperimentInput, MoveKind, NextMoveInput, JourneyEvent, BeliefStage, NextMove, Progress, MoverKind, TrajectoryPoint } from '@validation-os/core/derivation';
+export { StageKey } from '@validation-os/core/derivation';
+
+/**
+ * Everything the instance passes — config only, never secrets. The API base
+ * path points at where the Clerk-gated `@validation-os/api` routes are mounted;
+ * the backend label (from the connector config) shows in the topbar; branding
+ * and the signed-in user are optional cosmetics. Auth is the instance's Clerk
+ * provider that this renders within — no credential reaches the package.
+ */
+interface DashboardConfig {
+    /** Where the API is mounted (default `/api`). */
+    basePath?: string;
+    /** Topbar backend indicator, e.g. "Firestore · doshi-crm". */
+    backendLabel?: string;
+    /** Optional product branding for the sidebar. */
+    branding?: {
+        /** Product name shown next to the mark (default "Validation-OS"). */
+        name?: string;
+        /** One or two letters for the square mark (default "V"). */
+        initials?: string;
+        /** A logo image for the square mark; overrides `initials` when set. */
+        logoUrl?: string;
+    };
+    /** Optional agent label shown in the topbar, e.g. "Claude Code". */
+    agentLabel?: string;
+    /** The signed-in user, for the topbar avatar + name. */
+    user?: {
+        name?: string;
+        caption?: string;
+    };
+    /** Restrict/reorder the registers shown; defaults to all, in order. */
+    registers?: Collection[];
+}
+interface ValidationOSDashboardProps {
+    config?: DashboardConfig;
+}
+/**
+ * The entire styled dashboard as one mountable app (spec OPS-1280): the frame —
+ * sidebar composing the workflow + register nav with live counts, topbar with
+ * the backend indicator and user — and the surfaces it routes between across
+ * the three altitudes (front door → pipeline → per-belief drill-in) plus the
+ * kept register tables. Navigation is owned here, not the host router: the
+ * active route lives in client state, synced to the URL hash (OPS-1298), so the
+ * instance mounts this at one route and wires no routing. Styled by the
+ * package's own token sheet — the instance imports `styles.css` once and builds
+ * no UI.
+ *
+ * The front-door (`#next`) and pipeline (`#pipeline`) surfaces are now live;
+ * OPS-1282's record page (`#record/<id>`) still fills its pane as it ships.
+ * Records is the browse-everything / manual-override surface — the register
+ * browser, kept from the original scheme.
+ */
+declare function ValidationOSDashboard({ config }: ValidationOSDashboardProps): react.JSX.Element;
+
+/**
+ * Pure presentation logic for the dashboard's visual primitives — status→tone,
+ * risk→fraction/level, the sparkline path, and count/number formatting. Kept
+ * free of React and the DOM so the mapping that drives every pill, bar and
+ * sparkline is unit-tested at this seam (spec story 13), and the components stay
+ * thin wrappers over it.
+ */
+/** A pill/fill tone — maps onto the `--vos-good/warn/crit/accent` tokens. */
+type Tone = "good" | "warn" | "crit" | "accent" | "neutral";
+/**
+ * A record's Status → a pill tone. Live/concluded read good, testing/running
+ * read warn, invalidated/rejected read crit; everything else (Proposed, and any
+ * status we don't recognise) stays neutral rather than guessing a colour. Case-
+ * and whitespace-insensitive.
+ */
+declare function statusTone(status: string | null | undefined): Tone;
+/**
+ * Risk band thresholds — Critical ≥ 70, High 40–69, Watch < 40 (OPS-1287). A
+ * belief is critical at ≥ `RISK_CRIT`, watch/high at ≥ `RISK_WARN`. These are a
+ * prioritisation setting (a config knob), not a record property; overriding them
+ * is `configureRiskBands`. Kept dashboard-wide so the flat-table risk cell, the
+ * group-by risk-band axis, and the hero meter all band a number the same way.
+ */
+declare let RISK_CRIT: number;
+declare let RISK_WARN: number;
+/** The three fixed risk bands, strongest first (OPS-1287 story 19). */
+type RiskBand = "Critical" | "High" | "Watch";
+/**
+ * Override the two risk-band thresholds (the config knob). Left as a setter over
+ * module state rather than threaded through every call, so an instance can retune
+ * the bands once at startup and every risk rendering follows.
+ */
+declare function configureRiskBands(crit: number, warn: number): void;
+/** Risk (0–100) → its band label. Grouping uses this; sort stays continuous. */
+declare function riskBand(risk: number): RiskBand;
+/** Risk (0–100) → a tone for the bar fill and the number. */
+declare function riskLevel(risk: number): Tone;
+/** Risk (0–100) → the bar's fill fraction (0–1), clamped. */
+declare function riskFraction(risk: number): number;
+/** Confidence (signed) → the tone for its number: negative reads crit. */
+declare function confidenceTone(confidence: number): Tone;
+/** A signed number rendered with an explicit sign: `+6`, `-3`, `0`. */
+declare function formatSigned(n: number): string;
+/** A count for the nav/tiles, thousands-separated. */
+declare function formatCount(n: number): string;
+/**
+ * An SVG polyline `d` for a sparkline over `values`, fit to a `width`×`height`
+ * box with a 2px inset. The vertical domain defaults to the data's own range
+ * (with 0 always included, so a signed series keeps its baseline meaningful);
+ * pass `min`/`max` to pin it — e.g. −100…100 for Confidence. Returns "" for
+ * fewer than two points (nothing to draw).
+ */
+declare function sparklinePath(values: number[], width: number, height: number, min?: number, max?: number): string;
+
+/** A colored status pill — tone from the status, the label shown verbatim. */
+declare function StatusPill({ status }: {
+    status: string | null | undefined;
+}): react.JSX.Element;
+/**
+ * A risk bar (0–100) plus its number, both toned by threshold: a longer, redder
+ * bar means a riskier belief the eye should land on first (spec story 5).
+ */
+declare function RiskBar({ risk }: {
+    risk: number;
+}): react.JSX.Element;
+/**
+ * A signed confidence reading: a tiny sparkline of its trajectory when a
+ * history is available, always the +/- number (negative reads crit) — so a row
+ * shows both where a belief stands and, when known, which way it is trending
+ * (spec story 6). With no history the number stands alone; the list endpoint
+ * carries no per-row series, so the in-row sparkline appears wherever a caller
+ * does have one (e.g. the drawer trajectory uses `Sparkline` directly).
+ */
+declare function ConfidenceCell({ confidence, history, }: {
+    confidence: number;
+    history?: number[];
+}): react.JSX.Element;
+/**
+ * A signed sparkline over `values`. A zero baseline is drawn whenever the domain
+ * spans it, so a line dipping below zero reads as a belief losing ground. The
+ * last point gets a dot. `fill` shades the area under the line. Pure geometry
+ * comes from `sparklinePath`/`sparklineY`.
+ */
+declare function Sparkline({ values, width, height, min, max, tone, fill, ariaLabel, }: {
+    values: number[];
+    width?: number;
+    height?: number;
+    min?: number;
+    max?: number;
+    tone?: Tone;
+    fill?: boolean;
+    ariaLabel?: string;
+}): react.JSX.Element | null;
+/**
+ * A glanceable stat tile — a label, a big number, and an optional sub-caption.
+ * Becomes a button when `onClick` is given (counts that double as nav). Pure
+ * presentation; the caller supplies the value.
+ */
+declare function StatTile({ label, value, sub, onClick, active, }: {
+    label: string;
+    value: number;
+    sub?: ReactNode;
+    onClick?: () => void;
+    active?: boolean;
+}): react.JSX.Element;
+
+/**
+ * The list-surface view-model (OPS-1287) — the pure shaped-query layer above the
+ * flat `RegisterTable`. Given a register's records (plus, for the cross-register
+ * views, the other registers), it computes the canonical derived-view tabs, the
+ * group-by boards, the filtered/sorted rows, the readings-under-plan nesting, and
+ * the needs-a-human counts. DOM-free and unit-tested at this seam exactly like
+ * `columns.ts`; `RegisterBrowser` renders what it returns.
+ *
+ * The tabs are **derived views, never stored** — each is a predicate over the
+ * records (and, where the ontology's derived view needs it, the other
+ * registers). Membership is recomputed on every read, so renames, new readings,
+ * and status changes are always reflected. Saved views are the same shaped query
+ * under a user name, kept as a separate list from these canonical tabs.
+ */
+
+/** A group-by axis. Only assumptions expose the full set; see `groupByAxesFor`. */
+type GroupByAxis = "Lens" | "Theme" | "Risk band" | "Status" | "Owner";
+interface SortSpec {
+    /** A record field or a `derived.*` key (risk / confidence / strength …). */
+    key: string;
+    dir: "asc" | "desc";
+}
+/** The query that shapes a register view — all optional, all recomputable. */
+interface ViewDescriptor {
+    /** Which canonical tab; defaults to the register's default tab. */
+    tabId?: string;
+    /** Group rows by an axis, or null for a flat list. */
+    groupBy?: GroupByAxis | null;
+    /** Sort override; null falls back to the tab's default sort. */
+    sort?: SortSpec | null;
+    /** Free-text filter over Title + Description, case-insensitive. */
+    query?: string;
+}
+/** A saved view is a named shaped query, kept apart from the canonical tabs. */
+interface SavedView extends ViewDescriptor {
+    name: string;
+}
+/**
+ * The other registers a cross-register tab reads (Testing/Proven/In-tension),
+ * plus the reference date overdue is measured against. Everything optional: a
+ * tab whose context is absent simply matches nothing rather than throwing.
+ */
+interface RegisterContext {
+    assumptions?: AnyRecord[];
+    experiments?: AnyRecord[];
+    readings?: AnyRecord[];
+    decisions?: AnyRecord[];
+    /** ISO date "now" for the Overdue view; omitted → nothing reads overdue. */
+    asOf?: string;
+}
+/** A tab as the caller sees it — id + label, and whether it flags a human. */
+interface TabDef {
+    id: string;
+    label: string;
+    /** The register lands here first. */
+    isDefault?: boolean;
+    /** A state that needs a human — surfaced as a nav count badge too (story 20). */
+    needsHuman?: boolean;
+}
+/** The canonical derived-view tabs for a register, in display order. */
+declare function tabsFor(register: Collection): TabDef[];
+/** The default tab id for a register (the curated front door, story 15). */
+declare function defaultTabId(register: Collection): string;
+/** The group-by axes a register offers. Assumptions get the full set (story 18);
+ * the others expose Status, the one axis every register shares. */
+declare function groupByAxesFor(register: Collection): GroupByAxis[];
+interface GroupBucket {
+    /** Stable bucket key. */
+    key: string;
+    /** Plain-language bucket heading. */
+    label: string;
+    records: AnyRecord[];
+}
+/**
+ * Group records by an axis. Risk band uses the three fixed bands in
+ * strongest-first order; multi-value axes (Theme, Owner) place a record in every
+ * bucket it belongs to, with an explicit empty-value bucket. Single-value axes
+ * (Lens, Status) bucket once, empty → an "—" bucket. Bucket order is stable:
+ * risk band by severity, everything else first-appearance.
+ */
+declare function groupRecords(records: AnyRecord[], axis: GroupByAxis): GroupBucket[];
+/** Case-insensitive substring filter over Title + Description. */
+declare function filterRecords(records: AnyRecord[], query: string): AnyRecord[];
+/** A stable sort by one key; numbers compare numerically, everything else by
+ * locale string. Missing values sort last regardless of direction. */
+declare function sortRecords(records: AnyRecord[], sort: SortSpec): AnyRecord[];
+interface NestedGroup {
+    /** The experiment id, or null for bare/found readings. */
+    experimentId: string | null;
+    /** The plan's title, or a plain label for the bare bucket. */
+    label: string;
+    readings: AnyRecord[];
+}
+/** Nest readings under their originating evidence plan (story 21). Bare/found
+ * readings (no `experimentId`) collect in a trailing "No plan" group. Plans keep
+ * the order they first appear in `experiments`. */
+declare function nestReadingsByPlan(readings: AnyRecord[], experiments: AnyRecord[]): NestedGroup[];
+interface ShapedRegister {
+    tabs: TabDef[];
+    activeTabId: string;
+    groupByAxes: GroupByAxis[];
+    activeGroupBy: GroupByAxis | null;
+    sort: SortSpec | null;
+    query: string;
+    /** Rows after tab predicate + filter + sort (the flat list). */
+    rows: AnyRecord[];
+    /** Group buckets when an axis is active, else null. */
+    groups: GroupBucket[] | null;
+    /** Readings-under-plan nesting when the active tab nests, else null. */
+    nested: NestedGroup[] | null;
+}
+/**
+ * Shape a register into its tabs, active rows, groups and nesting from a view
+ * descriptor. Pure: the same records + descriptor always give the same view. The
+ * descriptor round-trips — a saved view's tab/group/sort/query reproduce here.
+ */
+declare function shapeRegister(register: Collection, records: AnyRecord[], descriptor?: ViewDescriptor, ctx?: RegisterContext): ShapedRegister;
+/** The needs-a-human counts that surface as nav badges (story 20). */
+interface NeedsHumanCounts {
+    /** Live beliefs in the kill zone awaiting a human verdict. */
+    killLane: number;
+    /** Running plans past their deadline. */
+    overdue: number;
+    /** Standing decisions resting on a belief that turned against them. */
+    inTension: number;
+}
+/** Count the needs-a-human states across the registers, reusing the same tab
+ * predicates so a badge and its tab never disagree. */
+declare function needsHumanCounts(ctx: RegisterContext): NeedsHumanCounts;
+
+/**
+ * The dashboard's client-owned navigation state, across the three workflow
+ * altitudes plus the kept register tables (OPS-1298). One `<ValidationOSDashboard/>`
+ * mounts at a single host route and drives everything off the URL hash — there
+ * is no second entry point (OPS-1280).
+ *
+ *  - `next`     — the front door ("what's my next move"); the default landing.
+ *  - `pipeline` — the step-back portfolio pipeline.
+ *  - `records`  — one register's browse table (the manual-override surface,
+ *                 kept from the original scheme).
+ *  - `record`   — the per-belief drill-in (full record page).
+ */
+type Route = {
+    name: "next";
+} | {
+    name: "pipeline";
+} | {
+    name: "records";
+    register: Collection;
+} | {
+    name: "record";
+    id: string;
+};
+/**
+ * Parse a URL hash into a Route. The empty hash and anything unrecognised fall
+ * back to the front door. A bare register name (`#assumptions`) stays
+ * backward-compatible with the original `#<register>` scheme, so it resolves to
+ * that register's Records table; `registers` is the set the instance allows, so
+ * an unknown or disallowed register name falls through to the default.
+ */
+declare function parseRoute(hash: string, registers: Collection[]): Route;
+/**
+ * The hash fragment (no leading `#`) for a Route — the inverse of `parseRoute`.
+ * `records` serialises to the bare register name to keep deep links stable with
+ * the original scheme.
+ */
+declare function formatRoute(route: Route): string;
 
 type Counts = Partial<Record<Collection, number>>;
 interface UseCountsResult {
@@ -16,25 +343,279 @@ interface UseCountsResult {
  * HTTP, so no backend credentials ever reach the browser.
  */
 declare function useCounts(basePath?: string): UseCountsResult;
+/** The needs-a-human counts mapped to the register that owns each badge — kill
+ * lane → assumptions, overdue → experiments, in-tension → decisions. */
+type NeedsHumanByRegister = Partial<Record<Collection, number>>;
+interface UseNeedsHumanResult {
+    counts: NeedsHumanCounts;
+    byRegister: NeedsHumanByRegister;
+}
+/**
+ * Client hook: load the assumptions / experiments / decisions registers and
+ * derive the needs-a-human counts (kill lane, overdue, in tension) so the nav
+ * can carry a persistent badge on the register that needs a human (story 20).
+ * Reuses the same `needsHumanCounts` view-model the tabs and their badges use, so
+ * a nav badge and its tab never disagree.
+ */
+declare function useNeedsHuman(basePath?: string): UseNeedsHumanResult;
+
+interface SidebarNavProps {
+    /** The active route — drives which item is highlighted. A `record` route
+     * highlights nothing (the drill-in has no nav item; OPS-1298). */
+    route: Route;
+    /** Called when a nav item is chosen, with the route it selects. */
+    onNavigate: (route: Route) => void;
+    /** Live per-register counts; a middle dot shows until they load. */
+    counts?: Counts | null;
+    /** Per-register needs-a-human counts — a persistent alert badge on the
+     * register that needs attention (kill lane, overdue plans, tensions; story 20). */
+    needsHuman?: Partial<Record<Collection, number>>;
+    /** The registers shown under Records, in order. */
+    registers: Collection[];
+}
+/**
+ * The sidebar nav across the two groups (OPS-1298): a **Workflow** group — Next
+ * move (the default landing, badged `home`) and Pipeline — above the **Records**
+ * group of register tables (kept, not subsumed; the browse-everything /
+ * manual-override surface). A presentational brick: the caller owns the active
+ * route and supplies the counts. The assembled `<ValidationOSDashboard/>`
+ * composes this; it's also exported for anyone building their own surface.
+ * Styled with the package's own token sheet — no host Tailwind.
+ */
+declare function SidebarNav({ route, onNavigate, counts, needsHuman, registers, }: SidebarNavProps): react.JSX.Element;
+
+interface RecordPageProps {
+    /** The record being drilled into (`#record/<id>`). */
+    recordId: string;
+    /** Navigate elsewhere — the breadcrumb, backlinks and glossary links use it. */
+    onNavigate: (route: Route) => void;
+    /** Where the "Records" breadcrumb returns to before the record's own register
+     * is known (resolved once the record loads). */
+    backRegister: Collection;
+    /** API base path (default `/api`). */
+    basePath?: string;
+}
+/**
+ * The canonical full record page (OPS-1286) — promoted from the enriched drawer
+ * to the one place a record lives, reachable identically from a table, a
+ * backlink or a search (story 12). It loads the registers once (the related set
+ * every panel reads), resolves which register the id belongs to, and renders the
+ * pure `buildRecordPage` model: a status + derived lane/queue header, leading
+ * scores as meters with a "Why?" attribution (reusing the understanding layer),
+ * the genuine human-input free text (glossary auto-linked), backlink panels
+ * grouped by relation with score chips, and a history/audit view. A belief's
+ * page also hosts the per-belief journey (built by the OPS-1289 map).
+ */
+declare function RecordPage({ recordId, onNavigate, backRegister, basePath, }: RecordPageProps): react.JSX.Element;
+
+interface SurfacePlaceholderProps {
+    /** The surface's title, shown as the pane heading. */
+    title: string;
+    /** A one-line description under the title. */
+    subtitle: string;
+    /** What fills this pane, and which build ships it. */
+    detail: ReactNode;
+}
+/**
+ * A pane the navigation shell reserves for a surface built in its own step
+ * (OPS-1298: "the shell can land first; each surface fills its pane as it
+ * ships"). It renders the surface's heading and a labelled placeholder so the
+ * route, nav slot, and title are real and reachable while the surface itself is
+ * still to come. Each later build swaps this out for the real component.
+ */
+declare function SurfacePlaceholder({ title, subtitle, detail, }: SurfacePlaceholderProps): react.JSX.Element;
+
+/**
+ * The step-back portfolio pipeline (OPS-1300) — the middle altitude of the
+ * workflow dashboard. One row per live belief, sorted riskiest first, each
+ * carrying the four loop meters (Framed → Planned → Tested → Known) as a
+ * connected track, with a stage-aware next move on hover. Above them, the
+ * single burn-up headline: "% of risk bought down". Resolved beliefs are set
+ * apart behind a disclosure; the raw Impact shows only as a faint bar.
+ *
+ * It lazy-loads the assumption, experiment and reading registers and derives
+ * everything through the pure `pipeline` view-model — no number is computed
+ * here (spec: explain from inputs). Clicking a belief, its next move, or its
+ * Journey link routes to that belief's record page (OPS-1298), the review
+ * surface where step-in happens.
+ */
+declare function PipelineSurface({ basePath, onNavigate, }: {
+    basePath?: string;
+    onNavigate: (route: Route) => void;
+}): react.JSX.Element;
+
+/**
+ * The portfolio pipeline's view-model (OPS-1300) — pure, no React, no I/O, so
+ * the whole "where does everything stand" mapping is unit-tested at this seam
+ * (like `understanding.ts` for the drawer). It joins the assumption, reading
+ * and experiment registers into: one row per live belief carrying the four
+ * loop meters (Framed → Planned → Tested → Known) and its stage-aware next
+ * move, the resolved beliefs set apart, and the portfolio burn-up headline.
+ *
+ * Every number is derived through `@validation-os/core` — the stored per-belief
+ * derived numbers, `assumptionCompleteness` for Framed, and `portfolioProgress`
+ * for the cross-belief roll-up — so the pipeline reconciles with the drawer and
+ * the agent, and computes fresh on read.
+ */
+
+/** One live belief's row on the board. */
+interface PipelineRow {
+    id: string;
+    statement: string;
+    /** Derived Impact — shown only as a faint bar (machinery, not the move). */
+    impact: number;
+    risk: number;
+    /** crit / warn / good — the severity stripe, risk number and bar tone. */
+    riskTone: Extract<Tone, "crit" | "warn" | "good">;
+    confidence: number;
+    /** Sign bucket for the confidence chip / Known gauge direction. */
+    confSign: "pos" | "neg" | "zero";
+    /** Conf ≤ −50 — the Known meter flips to a red re-test flag. */
+    killZone: boolean;
+    /** Meter 1 — framing completeness, 0–100. */
+    framed: number;
+    /** Meter 2 — a test with a bar line naming this belief has been designed. */
+    planned: boolean;
+    /** Meter 3 — pre-registered bars settled / total, across all experiments. */
+    tested: {
+        settled: number;
+        total: number;
+    };
+    /** The stage-aware verb the front door offers (navigates to the record). */
+    nextMove: string;
+}
+/** A belief taken off the board — killed (Invalidated) or made moot. */
+interface ResolvedRow {
+    id: string;
+    statement: string;
+    kind: "killed" | "moot";
+    /** Risk retired by resolving it. */
+    retired: number;
+}
+interface PipelineView {
+    /** Live beliefs, riskiest first. */
+    rows: PipelineRow[];
+    /** Resolved beliefs, set apart. */
+    resolved: ResolvedRow[];
+    /** The burn-up headline: identified / retired / live / percent. */
+    progress: PortfolioProgress;
+    /** Σ risk retired across the resolved set — the disclosure's summary. */
+    resolvedRetired: number;
+}
+/**
+ * Reduce an experiment record to the shape the shared meter logic reads: each
+ * bar line naming a belief (with whether it has settled) plus the convenience
+ * projection. Shared with the journey view-model so the board and a belief's
+ * rail derive test state one way.
+ */
+declare function toStageExperimentInput(exp: AnyRecord): StageExperimentInput;
+/**
+ * Build the whole board from the three registers. Pass the full assumption
+ * register (resolved rows included) — `portfolioProgress` needs the whole set
+ * or the burn-up denominator understates.
+ */
+declare function buildPipeline(assumptions: AnyRecord[], experiments: AnyRecord[]): PipelineView;
+/**
+ * The headline's "this week" delta, in percentage points, or null when it
+ * can't be told honestly. It time-travels through the readings' own dates:
+ * recompute every belief's Confidence (and thus Risk) from only the readings
+ * dated on or before a cutoff, roll the portfolio up at "now" and at a week
+ * ago, and report the change. Structure and resolved-status are held at their
+ * current value (the system keeps no history of those), so this is the
+ * evidence-driven movement, not a full snapshot diff — hence "this week" reads
+ * as "what landing evidence moved", which is the honest claim.
+ *
+ * Returns null when no reading carries a parseable date (nothing to travel
+ * through) — the surface then simply omits the delta rather than inventing one.
+ */
+declare function weekOverWeekDelta(assumptions: AnyRecord[], readings: AnyRecord[], now: Date): number | null;
+
+/**
+ * Front-door presentation logic for the next-move ranking (build OPS-1304).
+ * Two pure seams, kept free of React/DOM so they're unit-tested like
+ * `columns.ts` / `primitives.ts`:
+ *
+ *  - `toNextMoveInput` maps the fetched register records onto the shape
+ *    `packages/core`'s `rankNextMoves` consumes (the ranking rule itself lives
+ *    once in core — `ontology.yaml → derived_views.next_move`, OPS-1292);
+ *  - `movePresentation` maps each act to its front-door copy and whether it's a
+ *    human step-in form or an agent-run act shown for review (OPS-1291/1294).
+ */
+
+/** The four registers the ranking reads, as fetched from the API. */
+interface NextMoveRecords {
+    assumptions: AnyRecord[];
+    experiments: AnyRecord[];
+    readings: AnyRecord[];
+    decisions: AnyRecord[];
+}
+/**
+ * Fold the fetched records into `rankNextMoves`' input: the derived Risk /
+ * Confidence come straight off each assumption (the server keeps them current,
+ * OPS-1251 — never recomputed here), and concluded readings are counted per
+ * belief so the stage logic can tell "no evidence yet" from "evidence in".
+ */
+declare function toNextMoveInput(records: NextMoveRecords): NextMoveInput;
+/** Which step-in form an act opens, or null for an agent-run act. */
+type StepInForm = "score-impact" | "write-decision";
+interface MovePresentation {
+    /** Imperative CTA on the hero's act button. */
+    cta: string;
+    /** Short label for the "On deck" act pill. */
+    pill: string;
+    /**
+     * A human step-in form (the dashboard is a review surface, OPS-1294) vs an
+     * agent-run act the front door only visualises for review.
+     */
+    steppable: boolean;
+    /** The form the act opens when steppable; null for agent-run acts. */
+    form: StepInForm | null;
+}
+/** The front-door copy + step-in modality for one act. */
+declare function movePresentation(kind: MoveKind): MovePresentation;
+
+/** A journey event with its front-door copy attached. */
+interface JourneyEventView extends JourneyEvent {
+    /** Plain-language label the story renders. */
+    label: string;
+}
+interface JourneyView {
+    id: string;
+    /** The belief statement — the drill-in's headline. */
+    statement: string;
+    /** The rail: where the belief sits at rest, with its four meters. */
+    stage: BeliefStage;
+    /** The story: the belief's life, oldest first, `now` last. */
+    events: JourneyEventView[];
+    /** The ranked next move for this belief; null once it is resolved. */
+    nextMove: NextMove | null;
+    /** Killed (Invalidated) / moot / null — the drill-in's terminal state. */
+    resolved: "killed" | "moot" | null;
+}
+/**
+ * Build one belief's journey from the four registers. Returns null when the
+ * belief id isn't in the assumptions register. `now` is passed in (an ISO date)
+ * so the view-model stays pure — the surface supplies it.
+ */
+declare function buildJourney(assumptionId: string, records: NextMoveRecords, now: string): JourneyView | null;
 
 interface RegisterCountsProps {
     counts: Counts;
     /** Optional caption under the tiles (e.g. the backend the numbers came from). */
     caption?: string;
-    /**
-     * Optional link target per register. When supplied, each tile becomes a link
-     * (a plain anchor — works with any router), so counts double as navigation
-     * into the browse tables.
-     */
-    hrefFor?: (register: Collection) => string;
+    /** Optional click handler per register — makes each tile a nav button. */
+    onSelect?: (register: Collection) => void;
+    /** The active register, highlighted when tiles are nav. */
+    active?: Collection | null;
 }
 /**
  * A glanceable grid of stat tiles — one per register, the register's row count
- * as the hero number. Presentational: the caller reads the counts (server-side,
- * through the adapter) and hands them in. Styled with Tailwind utility classes;
- * the host app provides Tailwind.
+ * as the hero number. A brick kept for a counts landing; the assembled app
+ * surfaces the same counts in the sidebar nav. Presentational: the caller reads
+ * the counts (server-side, through the adapter) and hands them in. Rendered in
+ * the package's own token sheet — no host Tailwind.
  */
-declare function RegisterCounts({ counts, caption, hrefFor }: RegisterCountsProps): react.JSX.Element;
+declare function RegisterCounts({ counts, caption, onSelect, active, }: RegisterCountsProps): react.JSX.Element;
 
 interface RegisterTableProps {
     register: Collection;
@@ -46,9 +627,11 @@ interface RegisterTableProps {
 }
 /**
  * A list table for one register — a row per record, the register's key fields
- * as columns (assumptions show Impact, Confidence and Risk). Presentational:
- * the caller supplies the rows. Clicking a row opens the read-only drawer.
- * Styled with Tailwind utilities the host app provides.
+ * as columns. Assumptions read their state at a glance: a colored Status pill, a
+ * signed Confidence, and a threshold-toned Risk bar (spec stories 4–6). Which
+ * cells render as pills/bars/sparklines is declared on the column (`kind`), so
+ * the treatment stays testable at the columns seam and this component stays a
+ * dumb renderer. Presentational: the caller supplies the rows.
  */
 declare function RegisterTable({ register, records, onRowClick, selectedId, }: RegisterTableProps): react.JSX.Element;
 
@@ -67,20 +650,24 @@ interface RecordDrawerProps {
     /** Re-fetch the record + its list — called after a save, and the re-fetch
      * path offered when a concurrent edit is detected. */
     onChanged?: () => void;
+    /** Open this record's canonical full page (story 12). When set, the header
+     * shows a "Full page" link; the drawer stays the quick read/edit peek. */
+    onOpenFull?: () => void;
     /** Extra content below the fields in read mode — e.g. the relation editor. */
     children?: ReactNode;
 }
 /**
- * A record drawer that reads and edits, and wires relations. Derived numbers
- * always lead as the hero, explicitly marked computed and never editable (spec
- * user story 4) — a "Why?" affordance on Confidence explains how the number was
- * earned. Editing recomputes those numbers server-side on save (story 11); a
- * concurrent edit surfaces as a gentle, jargon-free prompt with a re-fetch path
- * (story 12). In read mode the drawer also hosts the relation editor (`children`,
- * story 14). The slide-over chrome is shared with the create drawer via
- * `DrawerShell`.
+ * A record drawer that reads and edits, and wires relations. The derived
+ * numbers lead as a visually distinct "computed — not editable" hero (spec
+ * stories 4/10): a bordered box, each number big and mono, Confidence toned by
+ * sign and Risk by threshold, with a "Why?" reveal opening the understanding
+ * layer in the same accent/pill language (story 11). Editing recomputes those
+ * numbers server-side on save; a concurrent edit surfaces as a gentle, jargon-
+ * free prompt with a re-fetch path (story 12). In read mode the drawer hosts
+ * the relation editor (`children`). Chrome is shared via `DrawerShell`; styled
+ * with the package's own token sheet, no host Tailwind.
  */
-declare function RecordDrawer({ register, record, loading, error, open, onClose, basePath, onChanged, children, }: RecordDrawerProps): react.JSX.Element;
+declare function RecordDrawer({ register, record, loading, error, open, onClose, basePath, onChanged, onOpenFull, children, }: RecordDrawerProps): react.JSX.Element;
 
 interface RecordFormProps {
     register: Collection;
@@ -118,11 +705,12 @@ declare function RelationEditor({ register, recordId, basePath, onLinked, }: Rel
 /**
  * The understanding layer behind the Confidence "Why?" (OPS-1276): which
  * experiments move the number (ranked by push) and how close each running
- * experiment is to concluding, the goal/direct evidence that also moves it,
- * and Confidence over time. It lazy-loads the readings + experiments registers
- * (it only mounts when the Reveal is open), then derives everything through the
- * shared derivation module. The derived box stays the hero; this is the tucked-
- * away detail.
+ * experiment is to concluding, the goal/direct evidence that also moves it, and
+ * Confidence over time. It lazy-loads the readings + experiments registers (it
+ * only mounts when the Reveal is open), then derives everything through the
+ * shared derivation module. Restyled into the drawer's accent/pill language
+ * (spec story 11): signed push tracks and a signed trajectory sparkline, in the
+ * package's own token sheet — no host Tailwind.
  */
 declare function UnderstandingPanel({ assumption, basePath, }: {
     assumption: AnyRecord;
@@ -157,11 +745,11 @@ interface ExperimentView {
     /** Concluded/closed — reads as done rather than in-flight. */
     done: boolean;
 }
-/** Goal-rung or direct evidence that moves Confidence but is not an experiment. */
+/** Direct evidence that moves Confidence but is not tied to an experiment
+ * (a bare/found reading, or a Market-rung reading with no plan). */
 interface OtherMover {
     key: string;
     kind: Exclude<MoverKind, "experiment">;
-    goalId: string | null;
     contribution: number;
     magnitude: number;
     readingCount: number;
@@ -184,18 +772,92 @@ interface RegisterBrowserProps {
     register: Collection;
     /** API base path (default `/api`). */
     basePath?: string;
+    /** A one-line description under the register title (spec story 7/9). */
+    subtitle?: string;
+    /** Open a record's canonical full page (story 12). When set, the drawer
+     * offers a "Full page" link; reads/edits still happen in the peek drawer. */
+    onOpenRecord?: (id: string) => void;
+}
+/**
+ * The browse-create-edit surface for one register. Above the flat table sits the
+ * list-surface (OPS-1287): canonical derived-view tabs (a curated default first),
+ * a group-by board (assumptions by Lens / Theme / Risk band / Status / Owner),
+ * free-text search and sort, readings nested under their evidence plan, and a
+ * count badge on the states that need a human. Everything visible is computed by
+ * the pure `shapeRegister` view-model; this component just renders it and owns
+ * the descriptor state.
+ *
+ * The write surface is unchanged: a row opens the read/edit/relations drawer, a
+ * "New" button opens the create form, and all reads/writes go over the Clerk-
+ * gated API (which recomputes derived fields on write). The canonical full record
+ * page is reachable via the drawer's "Full page" link when `onOpenRecord` is set.
+ */
+declare function RegisterBrowser({ register, basePath, subtitle, onOpenRecord, }: RegisterBrowserProps): react.JSX.Element;
+
+/**
+ * The front door — "what's my next move" (design OPS-1295, build OPS-1304): the
+ * map's headline surface. One belief, one act, all machinery behind one "Why
+ * this?" (progressive disclosure — the hero stays clean). The single riskiest
+ * unresolved belief leads (Model A, OPS-1291); a kill-lane belief (Confidence ≤
+ * −50) raises a crit banner above the hero; three runners-up sit "On deck"; and
+ * a quiet pick-list lets you act on any belief the ranking wouldn't pick (manual
+ * override). Step-in adapts to the act (OPS-1294): human acts open a form here,
+ * agent-run acts point at the record for review.
+ *
+ * The ranking itself lives once in `packages/core` (OPS-1292); this surface only
+ * fetches the registers, folds them into that function, and renders the result.
+ */
+interface NextMoveSurfaceProps {
+    basePath?: string;
+    /** Navigate across the shell (belief → record, override → records). */
+    onNavigate: (route: Route) => void;
+}
+declare function NextMoveSurface({ basePath, onNavigate }: NextMoveSurfaceProps): react.JSX.Element;
+
+interface ScoreImpactFormProps {
+    /** The assumption being weighted (its version guards the write). */
+    assumption: AnyRecord;
+    basePath?: string;
+    /** Called after a successful save. */
+    onDone: () => void;
+    onCancel: () => void;
+}
+/**
+ * Score a belief's Impact — a real input (a slider tied to a number), not a bare
+ * cell edit (OPS-1294). Impact is the one hand-scored number Risk propagates
+ * from, so scoring it is what lets an unweighted belief take its place in the
+ * ranking. The optional justification records *why* that weight.
+ */
+declare function ScoreImpactForm({ assumption, basePath, onDone, onCancel, }: ScoreImpactFormProps): react.JSX.Element;
+interface WriteDecisionFormProps {
+    /** The belief the decision rests on or resolves. */
+    assumption: AnyRecord;
+    basePath?: string;
+    /**
+     * A kill-lane decision (Confidence ≤ −50) defaults to *resolving* (retiring)
+     * the belief; an ordinary decide defaults to resting *on* it.
+     */
+    kill?: boolean;
+    onDone: () => void;
+    onCancel: () => void;
 }
 /**
- * The browse-create-edit surface for one register: a list table that opens a
- * record drawer on row click, a "New" button that opens the create form, and a
- * relation editor in the drawer for wiring links. All reads and writes go over
- * HTTP through the Clerk-gated API (which recomputes derived fields on write),
- * so the browser never touches Firestore directly. After an edit saves, both
- * the drawer's record and the list re-fetch so recomputed derived numbers show
- * everywhere. The thin host app renders this with a `register` — that's the
- * whole page.
+ * Write a decision against a belief (OPS-1294) — create the Decision record and
+ * wire it to the belief in one step, honouring the method's `based on` vs
+ * `resolves` split: a decision that *rests on* a belief keeps the question open
+ * (rationale); one that *resolves* it retires the question without a test
+ * (Impact → 0, it goes moot). The kill lane defaults to resolving.
  */
-declare function RegisterBrowser({ register, basePath }: RegisterBrowserProps): react.JSX.Element;
+declare function WriteDecisionForm({ assumption, basePath, kill, onDone, onCancel, }: WriteDecisionFormProps): react.JSX.Element;
+
+interface UseSavedViewsResult {
+    views: SavedView[];
+    /** Save (or overwrite by name) the current shaped query under a name. */
+    save: (name: string, descriptor: ViewDescriptor) => void;
+    /** Drop a saved view by name. */
+    remove: (name: string) => void;
+}
+declare function useSavedViews(register: Collection): UseSavedViewsResult;
 
 interface UseListResult {
     records: AnyRecord[] | null;
@@ -203,8 +865,13 @@ interface UseListResult {
     error: string | null;
     refresh: () => void;
 }
-/** Fetch every row of a register. */
-declare function useList(register: Collection, basePath?: string): UseListResult;
+/**
+ * Fetch every row of a register. `enabled` (default true) gates the fetch: pass
+ * false to keep the hook idle — the list-surface loads a *context* register
+ * (e.g. experiments, for the assumptions "Testing" view) only when the current
+ * register's tabs actually need it, without breaking the rules-of-hooks.
+ */
+declare function useList(register: Collection, basePath?: string, enabled?: boolean): UseListResult;
 interface UseRecordResult {
     record: AnyRecord | null;
     loading: boolean;
@@ -333,6 +1000,14 @@ declare function hasEdits(register: Collection, original: AnyRecord, draft: Draf
  * headers are plain language and derived numbers are shown, never hidden.
  */
 
+/**
+ * How a cell renders. `text` is plain formatted text; `status` is a colored
+ * pill; `risk` is a threshold-toned bar + number; `confidence` is a signed
+ * number (with a sparkline when a trajectory is available). Keeping this on the
+ * column — not branching by key in the table — is what makes the visual
+ * treatment declarative and testable at this seam (spec story 13).
+ */
+type CellKind = "text" | "status" | "risk" | "confidence";
 interface ColumnDef {
     /** Stable key; also the default field read from the record. */
     key: string;
@@ -344,6 +1019,8 @@ interface ColumnDef {
     align?: "left" | "right";
     /** Marks a column whose value is computed, never hand-typed (spec story 4). */
     derived?: boolean;
+    /** How the cell renders; defaults to `text`. */
+    kind?: CellKind;
 }
 /** The columns to render for a register. */
 declare function columnsFor(register: Collection): ColumnDef[];
@@ -407,13 +1084,215 @@ interface LinkChoice {
 /** The relations a record of `register` can initiate, in table order. */
 declare function linkChoicesFrom(register: Collection): LinkChoice[];
 
+/**
+ * Glossary auto-linking (OPS-1285) — the pure render-time pass that turns
+ * glossary Titles appearing in prose into links, computed fresh on every render
+ * so renames / retirements / status changes are always reflected with nothing
+ * stored. Kept DOM-free at this seam and unit-tested exactly like
+ * `link-choices.ts`; the `GlossaryText` component renders what it returns.
+ *
+ * The four forks the OPS-1285 prototype resolved are the rules here:
+ *  - match on **Title only** (no alias list), case-insensitive, word-boundary,
+ *    **longest title wins** (Derived Impact over Impact), **every** occurrence;
+ *  - **Active + Provisional** terms link, **Superseded never**, and never a
+ *    term inside its own record;
+ *  - **no false-positive machinery** — a generic word that is a term links
+ *    harmlessly; the simplicity is the decision.
+ */
+
+/** A glossary term reduced to what linking needs — the normalised input. */
+interface GlossaryTerm {
+    id: string;
+    title: string;
+    /** "Active" | "Provisional" | "Superseded". */
+    status: string;
+    definition: string;
+    howItDiffers: string;
+}
+/** A "don't confuse with" neighbour — a chip that is itself a link. */
+interface NeighbourChip {
+    id: string;
+    title: string;
+}
+/** The definition-preview payload a link node carries (the hover popover). */
+interface TermPreview {
+    id: string;
+    title: string;
+    status: string;
+    definition: string;
+    /** Neighbours named in this term's "How it differs" (story 29/30). */
+    dontConfuseWith: NeighbourChip[];
+}
+/** One piece of linkified prose: literal text, or a link to a term. */
+type LinkifyNode = {
+    kind: "text";
+    text: string;
+} | {
+    kind: "link";
+    text: string;
+    term: TermPreview;
+};
+interface LinkifyOptions {
+    /** The id of the record the prose belongs to — its own term never links. */
+    selfId?: string;
+}
+/**
+ * The terms named in a term's "How it differs" prose — the neighbour chips.
+ * Excludes the term itself and any non-linkable (Superseded) neighbour, and is
+ * de-duplicated in first-appearance order.
+ */
+declare function dontConfuseWith(term: GlossaryTerm, terms: GlossaryTerm[]): NeighbourChip[];
+/**
+ * Linkify `text` against the glossary. Returns an ordered list of text and link
+ * nodes; a link node carries the term's definition-preview payload. Pure and
+ * render-time — nothing is stored.
+ */
+declare function linkify(text: string, terms: GlossaryTerm[], options?: LinkifyOptions): LinkifyNode[];
+/** Normalise glossary records into the linking input, dropping blank-title
+ * rows (they can never match). Tolerates missing optional fields. */
+declare function toGlossaryTerms(records: AnyRecord[]): GlossaryTerm[];
+
+interface GlossaryTextProps {
+    /** The prose to linkify — body text or a short-text field (story 27). */
+    text: string;
+    /** The live glossary, already normalised (see `toGlossaryTerms`). */
+    terms: GlossaryTerm[];
+    /** The record this prose belongs to — its own term never self-links. */
+    selfId?: string;
+    /** Open a term's record (from a link or a neighbour chip; story 30). */
+    onOpenTerm?: (id: string) => void;
+}
+declare function GlossaryText({ text, terms, selfId, onOpenTerm, }: GlossaryTextProps): react.JSX.Element;
+
+/**
+ * The record-page view-model (OPS-1286) — the pure join behind the canonical
+ * full record page. Given a record and the related registers, it computes the
+ * header lane/queue pills (all derived), the leading-score meters per register,
+ * the genuine human-input free-text remainder, and the backlink panels grouped
+ * by relation (each row carrying a glance-readable score chip, an empty relation
+ * kept as a "none yet" panel rather than dropped). DOM-free and unit-tested at
+ * this seam; `RecordPage` renders what it returns and the understanding layer
+ * supplies the "Why?" attribution unchanged.
+ */
+
+/** The registers a record page reads to resolve its relations. All optional —
+ * a panel whose register is absent simply resolves to "none yet". */
+interface RelatedSet {
+    assumptions?: AnyRecord[];
+    experiments?: AnyRecord[];
+    readings?: AnyRecord[];
+    decisions?: AnyRecord[];
+    glossary?: AnyRecord[];
+}
+interface RecordPageOptions {
+    /** ISO date "now" for the Overdue pill; omitted → nothing reads overdue. */
+    asOf?: string;
+}
+/** A header pill: a short derived label toned by meaning. */
+interface Pill {
+    label: string;
+    tone: Tone;
+}
+/**
+ * The derived lane/queue pills for a record header (story 2). Every register
+ * leads with its Status pill; assumptions add Moot / Kill lane / Testing,
+ * experiments add Concluded / Overdue, decisions mark Standing. All derived —
+ * none is a stored field.
+ */
+declare function headerPills(register: Collection, record: AnyRecord, related?: RelatedSet, options?: RecordPageOptions): Pill[];
+/** A leading-score meter. `bar`/`signed` carry a number in a min…max domain;
+ * `pill` carries a categorical value shown as a toned pill. */
+interface Meter {
+    key: string;
+    label: string;
+    kind: "bar" | "signed" | "pill";
+    /** Number (bar/signed) or category (pill); null when the record has no value. */
+    value: number | string | null;
+    tone: Tone;
+    /** For bar/signed: the domain the fill maps onto. */
+    min?: number;
+    max?: number;
+    /** True when a "Why?" attribution is available (Confidence only). */
+    hasWhy?: boolean;
+}
+/**
+ * The register's leading scores as meters (story 4). Reads only what the
+ * migrated schema actually stores — a derived number becomes a bar/signed meter,
+ * a categorical leading field becomes a pill; nothing is invented where the
+ * schema carries no number. Confidence is flagged `hasWhy` — the understanding
+ * layer decomposes it.
+ */
+declare function leadingMeters(register: Collection, record: AnyRecord): Meter[];
+/** The genuine human-input free-text remainder — clearly separated from what
+ * the system computed. Auto-linked against the glossary at render time. */
+interface HumanText {
+    key: string;
+    label: string;
+    text: string;
+}
+/** The human-input fields a register carries text for (empty ones dropped). */
+declare function humanInputFields(register: Collection, record: AnyRecord): HumanText[];
+/** A glance-readable score chip for a linked record (story 9). */
+interface ScoreChip {
+    label: string;
+    value: string;
+    tone: Tone;
+}
+interface BacklinkItem {
+    id: string;
+    register: Collection;
+    title: string;
+    chip: ScoreChip;
+}
+/** A relation panel — the inbound/outbound edges of one relation, grouped and
+ * labelled. Kept even when empty (story 10). */
+interface RelationPanel {
+    id: string;
+    label: string;
+    register: Collection;
+    items: BacklinkItem[];
+}
+/** The linked record's headline score, glance-readable (story 9). */
+declare function scoreChip(register: Collection, record: AnyRecord): ScoreChip;
+/** The backlink panels for a record, grouped by relation, each row carrying a
+ * score chip. Empty relations are kept (items: []) so a missing connection reads
+ * as "none yet", not an absent section (story 8/10). */
+declare function backlinkPanels(register: Collection, record: AnyRecord, related?: RelatedSet): RelationPanel[];
+type RecordTabId = "overview" | "evidence" | "connections" | "history";
+interface RecordPageModel {
+    register: Collection;
+    title: string;
+    pills: Pill[];
+    meters: Meter[];
+    humanText: HumanText[];
+    panels: RelationPanel[];
+    /** The tabs this record shows, in order (story 3 + 11). */
+    tabs: RecordTabId[];
+    /** True when the belief journey drill-in can mount here (story 13). */
+    hasJourney: boolean;
+}
+/** Assemble the whole record-page model. Pure: same record + related always
+ * gives the same page. */
+declare function buildRecordPage(register: Collection, record: AnyRecord, related?: RelatedSet, options?: RecordPageOptions): RecordPageModel;
+
 /** Plain-language labels — the register is a surface a non-technical
  * teammate meets, so no jargon and no code-y plurals. */
 declare const REGISTER_LABEL: Record<Collection, string>;
 /** Singular labels — for "New {thing}" affordances (never a naive de-pluralise
- * that would read "New Peopl" / "New Glossary"). */
+ * that would read "New Glossary"). */
 declare const REGISTER_SINGULAR: Record<Collection, string>;
 /** The order tiles read left-to-right, top-to-bottom. */
 declare const REGISTER_ORDER: Collection[];
+/** A one-line description shown under each register's title (spec story 9). */
+declare const REGISTER_SUBTITLE: Record<Collection, string>;
+/** A single-glyph icon per register for the sidebar nav (matches the prototype
+ * feel; a glyph, not an icon font, so nothing external is pulled in). */
+declare const REGISTER_ICON: Record<Collection, string>;
+/** The sidebar groups — all five registers now sit in one set (the retired
+ * `people` reference collection was the only "Reference" member). */
+declare const REGISTER_GROUPS: {
+    label: string;
+    registers: Collection[];
+}[];
 
-export { CONFLICT_MESSAGE, type ColumnDef, type Counts, type Draft, type ExperimentView, type FieldEditor, type FieldKind, type FormField, type LinkArgs, type LinkChoice, type OtherMover, REGISTER_LABEL, REGISTER_ORDER, REGISTER_SINGULAR, RecordDrawer, type RecordDrawerProps, RecordForm, type RecordFormProps, RegisterBrowser, type RegisterBrowserProps, RegisterCounts, type RegisterCountsProps, RegisterTable, type RegisterTableProps, RelationEditor, type RelationEditorProps, type SaveResult, type Understanding, UnderstandingPanel, type UseCountsResult, type UseCreateResult, type UseLinkResult, type UseListResult, type UseRecordResult, type UseUpdateResult, buildPatch, buildUnderstanding, cellValue, columnsFor, draftFrom, editableFields, emptyDraft, formFieldsFor, formatValue, hasEdits, interpretSave, linkChoicesFrom, missingRequired, primaryLabel, toCreatePayload, useCounts, useCreate, useLink, useList, useRecord, useUpdate };
+export { type BacklinkItem, CONFLICT_MESSAGE, type CellKind, type ColumnDef, ConfidenceCell, type Counts, type DashboardConfig, type Draft, type ExperimentView, type FieldEditor, type FieldKind, type FormField, type GlossaryTerm, GlossaryText, type GlossaryTextProps, type GroupBucket, type GroupByAxis, type HumanText, type JourneyEventView, type JourneyView, type LinkArgs, type LinkChoice, type LinkifyNode, type LinkifyOptions, type Meter, type MovePresentation, type NeedsHumanByRegister, type NeedsHumanCounts, type NeighbourChip, type NestedGroup, type NextMoveRecords, NextMoveSurface, type NextMoveSurfaceProps, type OtherMover, type Pill, type PipelineRow, PipelineSurface, type PipelineView, REGISTER_GROUPS, REGISTER_ICON, REGISTER_LABEL, REGISTER_ORDER, REGISTER_SINGULAR, REGISTER_SUBTITLE, RISK_CRIT, RISK_WARN, RecordDrawer, type RecordDrawerProps, RecordForm, type RecordFormProps, RecordPage, type RecordPageModel, type RecordPageProps, type RecordTabId, RegisterBrowser, type RegisterBrowserProps, type RegisterContext, RegisterCounts, type RegisterCountsProps, RegisterTable, type RegisterTableProps, type RelatedSet, RelationEditor, type RelationEditorProps, type RelationPanel, type ResolvedRow, type RiskBand, RiskBar, type Route, type SaveResult, type SavedView, type ScoreChip, ScoreImpactForm, type ScoreImpactFormProps, type ShapedRegister, SidebarNav, type SidebarNavProps, type SortSpec, Sparkline, StatTile, StatusPill, type StepInForm, SurfacePlaceholder, type SurfacePlaceholderProps, type TabDef, type TermPreview, type Tone, type Understanding, UnderstandingPanel, type UseCountsResult, type UseCreateResult, type UseLinkResult, type UseListResult, type UseNeedsHumanResult, type UseRecordResult, type UseSavedViewsResult, type UseUpdateResult, ValidationOSDashboard, type ValidationOSDashboardProps, type ViewDescriptor, WriteDecisionForm, type WriteDecisionFormProps, backlinkPanels, buildJourney, buildPatch, buildPipeline, buildRecordPage, buildUnderstanding, cellValue, columnsFor, confidenceTone, configureRiskBands, defaultTabId, dontConfuseWith, draftFrom, editableFields, emptyDraft, filterRecords, formFieldsFor, formatCount, formatRoute, formatSigned, formatValue, groupByAxesFor, groupRecords, hasEdits, headerPills, humanInputFields, interpretSave, leadingMeters, linkChoicesFrom, linkify, missingRequired, movePresentation, needsHumanCounts, nestReadingsByPlan, parseRoute, primaryLabel, riskBand, riskFraction, riskLevel, scoreChip, shapeRegister, sortRecords, sparklinePath, statusTone, tabsFor, toCreatePayload, toGlossaryTerms, toNextMoveInput, toStageExperimentInput, useCounts, useCreate, useLink, useList, useNeedsHuman, useRecord, useSavedViews, useUpdate, weekOverWeekDelta };