@validation-os/core 0.5.0 → 0.6.1

package/dist/index-BlXH_thK.d.ts

@@ -0,0 +1,577 @@
+import { k as MarketRung, j as MagnitudeBand, q as TestingRung, p as Rung, o as Result, F as Feasibility } from './types-BAyl0w2E.js';
+
+/**
+ * Round to 2 decimals, matching the migration's `+(n).toFixed(2)`.
+ * Derived values are stored/displayed rounded; full precision is only used
+ * transiently inside a single computation.
+ */
+declare function round2(n: number): number;
+
+/**
+ * The evidence ladder anchors that feed Strength.
+ *
+ * Source of truth: `skills/_shared/ontology.yaml` → `vocabularies.rung`.
+ * Testing rungs carry a single anchor; Market rungs (the category formerly
+ * called "Goals", OPS-1305) carry a magnitude band (Low/Typical/High) picked
+ * from the absolute outcome. The anchors are unchanged by the rename.
+ */
+
+declare const RUNG_ANCHOR: Record<TestingRung, number>;
+declare const MARKET_RUNG_ANCHOR: Record<MarketRung, Record<MagnitudeBand, number>>;
+declare function isMarketRung(rung: Rung): rung is MarketRung;
+
+/**
+ * Assumption completeness — a derived readiness meter, never stored.
+ *
+ * Replaces the old Gaps / presence-field machinery (OPS-1305): an assumption's
+ * Draft-vs-Live readiness is the structural presence of its slots, not a set of
+ * hand-maintained tags. `Completeness %` is `filled slots / all slots`; a
+ * fully-filled assumption reads 100 and is Live-ready, an empty draft reads low.
+ *
+ * Slots (each an equal fifth):
+ *   Description · Lens · Impact · Scoring justification · Dependencies traced
+ *
+ * Pure, no backend dependency — the same function the recompute pass stamps
+ * into the derived tuple and the audit checks readiness against.
+ */
+/** The structural slots whose presence makes an assumption Live-ready. */
+declare const COMPLETENESS_SLOTS: readonly ["Description", "Lens", "Impact", "Scoring justification", "Dependencies traced"];
+type CompletenessSlot = (typeof COMPLETENESS_SLOTS)[number];
+/** The record shape completeness reads — an assumption's structural fields. */
+interface CompletenessInput {
+    Description?: unknown;
+    Lens?: unknown;
+    Impact?: unknown;
+    "Scoring justification"?: unknown;
+    dependsOnIds?: unknown;
+    enablesIds?: unknown;
+}
+/** Whether each slot is structurally present. */
+declare function completenessSlotPresence(record: CompletenessInput): Record<CompletenessSlot, boolean>;
+/** The slots that are absent or blank on a record. */
+declare function missingCompletenessSlots(record: CompletenessInput): CompletenessSlot[];
+/** Completeness as a whole-number percentage (0, 20, 40, 60, 80, 100). */
+declare function assumptionCompleteness(record: CompletenessInput): number;
+/** True when every slot is present — the structural precondition to be Live. */
+declare function assumptionComplete(record: CompletenessInput): boolean;
+
+/**
+ * Strength — the signed reading value `s` the Confidence average reads.
+ *
+ * Formula (`ontology.yaml` → `derivations.strength`):
+ *   rung anchor (Market rungs: × magnitude band) × sign(Result)
+ *   — Validated positive, Invalidated negative; 0 unless Validated/Invalidated.
+ */
+
+declare function sign(result: Result): -1 | 0 | 1;
+/** A reading counts toward Confidence only once concluded either way; an
+ * Inconclusive reading carries no signal. The single definition the whole
+ * derivation module (and its record→input mappers) share. */
+declare function isConcluded(result: Result): boolean;
+interface StrengthInput {
+    rung: Rung;
+    result: Result;
+    /** Only read for Market rungs; defaults to "Typical" when absent. */
+    magnitudeBand?: MagnitudeBand;
+}
+declare function readingStrength(input: StrengthInput): number;
+
+declare function sourceQuality(representativeness: number, credibility: number): number;
+
+/**
+ * Confidence — signed −100…100, 0 = no evidence.
+ *
+ * Formula (`ontology.yaml` → `derivations.confidence`):
+ *   (w0·0 + Σ wi·si) / (w0 + Σ wi),  w0 = 100,
+ *   wi = |si| × Source quality,  si = the reading's signed Strength.
+ *
+ * Only concluded Validated/Invalidated readings enter. Readings sharing a
+ * Source against one belief dedupe to the strongest (largest |si|, most
+ * recent on ties). Market-rung readings never dedupe (each closed commitment
+ * is its own unit). No corroboration bump.
+ */
+
+/** The neutral prior weight — a hard floor per the guardrails. */
+declare const W0 = 100;
+interface ConfidenceReadingInput {
+    id: string;
+    /** The independence-dedupe key. Null falls back to the reading's own id. */
+    source: string | null;
+    rung: Rung;
+    result: Result;
+    representativeness: number;
+    credibility: number;
+    /** ISO date; used only as the dedupe tie-break (most recent wins). */
+    date?: string | null;
+    magnitudeBand?: MagnitudeBand;
+}
+interface Scored {
+    input: ConfidenceReadingInput;
+    strength: number;
+    sq: number;
+    /** The reading's weight in the average: |strength| × Source quality. */
+    weight: number;
+}
+/**
+ * Score every concluded reading and resolve the Source dedupe — the shared
+ * front half of the Confidence average. `confidence()` reduces the winners to
+ * a number; `confidenceAttribution()` reuses the same winners so the movers it
+ * reports always decompose the very number the drawer shows. Market rungs never
+ * dedupe (each closed commitment is its own unit).
+ */
+declare function scoreAndDedupe(readings: ConfidenceReadingInput[]): Scored[];
+declare function confidence(readings: ConfidenceReadingInput[]): number;
+
+/**
+ * Confidence attribution — the "what's moving the number" half of the
+ * understanding layer (OPS-1276). Decomposes an assumption's Confidence into
+ * the experiments (and direct readings) contributing to it, ranked by how hard
+ * each pushes the number up or down.
+ *
+ * A winner's contribution is its signed share of the average:
+ *   cᵢ = (weightᵢ · strengthᵢ) / den,  den = w0 + Σ weight
+ * so Σ contributions = Σ(wᵢ·sᵢ)/den = Confidence (the w0·0 prior term is 0).
+ * The reveal therefore literally adds up to the hero number. Contributions are
+ * grouped by the reading's experiment (experiment-less readings — bare/found —
+ * fall into a "direct" bucket), then ranked by |contribution|. A reading's
+ * origin is an experiment or nothing; the retired Goal container is gone
+ * (OPS-1305).
+ */
+
+interface AttributionReadingInput extends ConfidenceReadingInput {
+    /** The experiment that produced the reading, if any. */
+    experimentId?: string | null;
+}
+/** What a mover is anchored to — an experiment, or nothing (direct). */
+type MoverKind = "experiment" | "direct";
+interface Mover {
+    /** Stable grouping key: the experiment id, or "direct". */
+    key: string;
+    kind: MoverKind;
+    /** The experiment id when `kind === "experiment"`, else null. */
+    experimentId: string | null;
+    /** Signed push on Confidence; the whole set sums to `confidence`. */
+    contribution: number;
+    /** |contribution| — the rank key and the "how hard" magnitude. */
+    magnitude: number;
+    /** How many (deduped) readings back this mover. */
+    readingCount: number;
+    /** The winning readings' ids, for drill-through. */
+    readingIds: string[];
+}
+interface Attribution {
+    /** The same Confidence the derived box shows (from the same winners). */
+    confidence: number;
+    /** Movers ranked by |contribution|, strongest first. */
+    movers: Mover[];
+}
+declare function confidenceAttribution(readings: AttributionReadingInput[]): Attribution;
+
+/**
+ * Progress-to-conclusion — how close a running experiment is to concluding
+ * (OPS-1276). An experiment concludes when every pre-registered bar line has
+ * been given a Bar verdict; progress is the count of settled bars against the
+ * total. Bar verdict is a report, never a Confidence input (nosql-schema.md),
+ * so reading it here is exactly its intended use.
+ */
+interface BarLineInput {
+    /** null/"" until the bar is judged at closure. */
+    barVerdict?: string | null;
+}
+interface Progress {
+    /** Pre-registered bar lines on the experiment. */
+    total: number;
+    /** Bars that have a verdict. */
+    settled: number;
+    /** Bars still awaiting a verdict. */
+    toGo: number;
+    /** True once every bar is settled (and there is at least one). */
+    concluded: boolean;
+}
+declare function experimentProgress(bars: BarLineInput[]): Progress;
+
+/**
+ * Confidence over time — the story of how the number got where it is
+ * (OPS-1276). At each date a concluded reading was dated, we recompute
+ * Confidence over every concluded reading up to and including that date, using
+ * the very same `confidence()` the derived box uses (so the last point equals
+ * the hero number). Undated concluded readings have no place on the timeline
+ * but still bear on the belief, so they are treated as always-present — folded
+ * into every point — which keeps the final point equal to today's Confidence.
+ */
+
+interface TrajectoryPoint {
+    /** ISO date at which Confidence took this value. */
+    date: string;
+    confidence: number;
+}
+declare function confidenceTrajectory(readings: ConfidenceReadingInput[]): TrajectoryPoint[];
+
+interface ImpactAssumptionInput {
+    id: string;
+    /** The hand-scored seed (0–100); null treated as 0. */
+    impact: number | null;
+    moot?: boolean;
+    /** Ids this assumption depends on. */
+    dependsOnIds: string[];
+}
+/**
+ * @param assumptions the full register (never a filtered slice — a filter
+ *   silently drops dependents from the propagation).
+ * @param basedOnCounts id → number of standing decisions with a `Based on`
+ *   link to that assumption. Each contributes +100 to S.
+ */
+declare function derivedImpacts(assumptions: ImpactAssumptionInput[], basedOnCounts?: Record<string, number>): Map<string, number>;
+
+declare function risk(derivedImpact: number, confidence: number): number;
+
+interface PortfolioBeliefInput {
+    id: string;
+    /** Derived Impact — the belief's risk at Confidence ≤ 0 (0 when moot). */
+    derivedImpact: number;
+    /** The hand-scored seed Impact; the ever-identified floor when moot zeroes
+     * Derived Impact. Null/absent treated as 0. */
+    seedImpact: number | null;
+    /** The belief's current live Risk (stored `derived.risk`). */
+    risk: number;
+    /** Resolved — Invalidated (killed) or moot. Its live risk reads 0 (fully
+     * retired), whatever the stored Risk number says. */
+    resolved: boolean;
+}
+/** One belief's contribution to the burn-up. */
+interface BeliefRisk {
+    /** Risk-ever-identified — the denominator's per-belief share. */
+    identified: number;
+    /** Live risk still carried (0 once resolved). */
+    live: number;
+    /** Risk bought down — the numerator's per-belief share. */
+    retired: number;
+}
+interface PortfolioProgress {
+    /** Σ risk-ever-identified — the burn-up denominator. */
+    identified: number;
+    /** Σ risk bought down — the burn-up numerator. */
+    retired: number;
+    /** Σ risk still live. */
+    live: number;
+    /** Retired ÷ identified as a percentage (0 when nothing is identified). */
+    percent: number;
+    /** Beliefs still in play (not resolved). */
+    liveCount: number;
+    /** Beliefs resolved (killed or moot). */
+    resolvedCount: number;
+}
+/** One belief's identified / live / retired risk — the rule in one place. */
+declare function beliefRisk(b: PortfolioBeliefInput): BeliefRisk;
+/**
+ * Roll every belief up into the portfolio burn-up. Pass the *whole* set
+ * (resolved rows included) — a filtered slice understates the denominator and
+ * makes fresh or retired risk read as backsliding.
+ */
+declare function portfolioProgress(beliefs: PortfolioBeliefInput[]): PortfolioProgress;
+
+/**
+ * Next-move ranking — the front door's single source of truth for "what should
+ * I do next" (build OPS-1304; placement OPS-1292; action vocabulary OPS-1291).
+ *
+ * Ranks *beliefs* — Model A: point at one belief, not a heterogeneous triage
+ * queue (OPS-1291) — by the method's Feasibility × Risk rule (`docs/method.md`,
+ * `ontology.yaml` → `derived_views.next_move`), and names the single act each
+ * belief's stage demands. A belief at Confidence ≤ −50 jumps into a distinct
+ * kill/re-test lane that sorts above the Feasibility × Risk order regardless of
+ * rank — the one place act-urgency beats belief-risk (`derived_views.kill_lane`).
+ *
+ * Computed fresh on read: a whole-set ordering, so it stays OUT of the OPS-1251
+ * on-write recompute — it reads the derived numbers (Risk, Confidence) those
+ * writes already keep current. Pure: no I/O, no caching, no weights framework —
+ * the enum→multiplier map below IS the formula (OPS-1292: "no weights /
+ * strategies / caching / framework").
+ */
+
+/** The kill/re-test threshold — Confidence at or below this is the kill lane. */
+declare const KILL_LANE_THRESHOLD = -50;
+/**
+ * The acts the front door can name, one per belief-stage. The front door
+ * *names* all of them; only a subset are human step-in forms — the rest are
+ * agent-run / off-dashboard (OPS-1294). Which is which is a presentation
+ * concern the dashboard owns, not this ranking.
+ */
+type MoveKind = "score-impact" | "design-experiment" | "record-reading" | "decide" | "retest";
+/**
+ * One belief's next move. `move`/`score`/`reason` are the OPS-1292 output
+ * contract; the rest is context the front door renders (the risk chip, the kill
+ * banner, the step-in adaptation) — every field read from the inputs, nothing
+ * new computed here.
+ */
+interface NextMove {
+    /** The act this belief's stage demands. */
+    move: MoveKind;
+    assumptionId: string;
+    /** The belief statement — the hero headline. */
+    title: string;
+    /** Feasibility × Risk. Kill-lane rows carry their Risk and sort first. */
+    score: number;
+    /** Plain-language "why this" — explains from the inputs, no jargon. */
+    reason: string;
+    /** The belief's live derived Risk (0–100). */
+    risk: number;
+    /** The belief's live derived Confidence (signed −100…100). */
+    confidence: number;
+    /** The feasibility that fed the score; null when no test plans it yet. */
+    feasibility: Feasibility | null;
+    /** Confidence ≤ −50 — the override lane. */
+    killLane: boolean;
+}
+/** A belief and its live derived numbers (the ranking's primary input). */
+interface NextMoveAssumptionInput {
+    id: string;
+    title: string;
+    /** AssumptionStatus; `Invalidated` rows are already killed and drop out. */
+    status: string;
+    /** The hand-scored seed (0–100); null means unscored → "score impact". */
+    impact: number | null;
+    /** Mooted beliefs (Impact pinned to 0 by a decision) drop out of ranking. */
+    moot: boolean;
+    /** Derived Risk (already recomputed on write — read, never recomputed). */
+    risk: number;
+    /** Derived Confidence (already recomputed on write). */
+    confidence: number;
+    /** How many concluded (Validated/Invalidated) readings back this belief. */
+    concludedReadings: number;
+}
+/** An experiment, reduced to what stage + feasibility resolution needs. */
+interface NextMoveExperimentInput {
+    /** ExperimentStatus — "Running" | "Closed". */
+    status: string;
+    feasibility: Feasibility | null;
+    /** The assumption ids this experiment's bar lines name. */
+    assumptionIds: string[];
+}
+/** A decision, reduced to which beliefs it rests on or resolves. */
+interface NextMoveDecisionInput {
+    /** DecisionStatus; only standing (Active/Provisional) decisions count. */
+    status: string;
+    /** The assumption ids this decision rests on (`based on`) or resolves. */
+    assumptionIds: string[];
+}
+interface NextMoveInput {
+    assumptions: NextMoveAssumptionInput[];
+    experiments: NextMoveExperimentInput[];
+    decisions: NextMoveDecisionInput[];
+}
+/**
+ * Rank every unresolved belief into its next move (Model A). Returns a plain
+ * sorted list, most-pressing first: the kill lane on top (by Risk), then the
+ * rest by Feasibility × Risk, tie-broken by the most-negative Confidence
+ * (`derived_views.test_next_surface`), then by id for a stable order. The front
+ * door takes the head as the hero and the tail as "On deck" / manual override.
+ */
+declare function rankNextMoves(input: NextMoveInput): NextMove[];
+
+/** The four loop stages a belief travels, in order (OPS-1293). */
+type StageKey = "framed" | "planned" | "tested" | "known";
+/** Sign of a belief's Confidence — the Known meter's direction. */
+type ConfSign = "pos" | "neg" | "zero";
+/** One belief's test state, aggregated across every experiment aimed at it. */
+interface TestMeter {
+    /** A bar line (or the convenience projection) names this belief. */
+    planned: boolean;
+    /** Pre-registered bars that have a verdict. */
+    settled: number;
+    /** Pre-registered bars in total. */
+    total: number;
+}
+/** A test's bar lines, reduced to what the meter needs (register-agnostic). */
+interface StageExperimentInput {
+    /** Each bar line naming a belief, and whether it has settled (has a verdict). */
+    bars: {
+        assumptionId: string;
+        settled: boolean;
+    }[];
+    /** Beliefs this test plans via the convenience projection (bars may be unexpanded). */
+    plannedAssumptionIds: string[];
+}
+/** The reduced inputs one belief's stage is derived from. */
+interface BeliefStageInput {
+    /** Framing completeness, 0–100 (`assumptionCompleteness`). */
+    framed: number;
+    /** Live derived Confidence (signed −100…100). */
+    confidence: number;
+    /** This belief's aggregated test state. */
+    test: TestMeter;
+}
+/** One belief's position on the spine plus its four meters. */
+interface BeliefStage {
+    /** Where the belief sits: framed → planned → tested → known. */
+    stage: StageKey;
+    /** Meter 1 — framing completeness, 0–100. */
+    framed: number;
+    /** Meter 2 — a test has been designed against this belief. */
+    planned: boolean;
+    /** Meter 3 — pre-registered bars settled / total. */
+    tested: {
+        settled: number;
+        total: number;
+    };
+    /** Meter 4 — signed Known: the belief's Confidence. */
+    confidence: number;
+    /** Sign bucket for the Known gauge direction. */
+    confSign: ConfSign;
+    /** Confidence ≤ −50 — the kill/re-test overlay (the same lane as the front door). */
+    killZone: boolean;
+}
+/** An empty test state — a belief no experiment has named yet. */
+declare function emptyTestMeter(): TestMeter;
+/**
+ * For every belief, the state of the tests aimed at it — whether one is designed
+ * and how many of its pre-registered bars have settled, aggregated across all
+ * experiments. Factored out of the pipeline row-builder so the board and a
+ * single belief's rail agree by construction.
+ */
+declare function beliefTestMeters(experiments: StageExperimentInput[]): Map<string, TestMeter>;
+/**
+ * Classify a belief on the spine from its meters. The kill-zone overlay is
+ * *not* a stage — a belief whose evidence has turned is still structurally
+ * wherever its framing/tests put it (a re-test moves it backward via the Known
+ * meter, OPS-1300), so this stays pure status.
+ */
+declare function classifyStage(framed: number, test: TestMeter): StageKey;
+/** One belief's stage + four meters — the rail's data. */
+declare function deriveBeliefStage(input: BeliefStageInput): BeliefStage;
+
+/**
+ * The per-belief journey event log (OPS-1329) — the belief's life ordered into
+ * dated events: bet → score → experiment → readings → confidence-cross → now.
+ * It is the *story* half of the journey drill-in (the *rail* half is `stage.ts`).
+ *
+ * No new maths: Confidence at each point is read off `confidenceTrajectory`
+ * (the very numbers the understanding layer already shows), and the current
+ * number off `confidence()`. Nothing is invented — an event whose underlying
+ * datum is absent (no impact score, no experiment, no concluded reading, no
+ * kill-zone cross) is simply omitted, and no date is ever faked (an event with
+ * no real date carries `date: null` and takes its place by structural order).
+ *
+ * Pure and label-free: the dashboard journey view-model adds the copy. Computed
+ * fresh on read, out of the OPS-1251 on-write recompute.
+ */
+
+/** The kinds of event a belief's life produces, in structural order. */
+type JourneyEventKind = "bet" | "score" | "experiment" | "reading" | "confidence-cross" | "now";
+/** One event in a belief's life. Label-free — the view-model adds the copy. */
+interface JourneyEvent {
+    kind: JourneyEventKind;
+    /** ISO date, or null when no real date exists (never faked). */
+    date: string | null;
+    /** Confidence known at this event (reading / cross / now); null otherwise. */
+    confidence: number | null;
+    /** The reading's verdict, for `reading` events; null otherwise. */
+    result: Result | null;
+    /** The source record id (reading id, experiment id) when the event has one. */
+    refId: string | null;
+}
+/** The belief itself, reduced to what the log needs. */
+interface JourneyBeliefInput {
+    /** When the bet was written — the `bet` event's date. */
+    createdAt: string | null;
+    /** Impact has been scored (a non-null seed) — emits the `score` event. */
+    impactScored: boolean;
+}
+/** A test aimed at this belief, reduced to what the log needs. */
+interface JourneyExperimentInput {
+    id: string;
+    /** When the test was designed; null when unknown (event still emitted, undated). */
+    date: string | null;
+}
+interface AssembleJourneyInput {
+    belief: JourneyBeliefInput;
+    /** The belief's own readings (already filtered to this assumption). */
+    readings: AttributionReadingInput[];
+    /** The experiments testing this belief. */
+    experiments: JourneyExperimentInput[];
+    /** "Now" as an ISO date — passed in so the log stays pure. */
+    now: string;
+}
+/**
+ * Assemble one belief's chronological event log. Events sort by date, undated
+ * events anchored to the bet's date and ordered structurally; `now` is always
+ * last.
+ */
+declare function assembleJourney(input: AssembleJourneyInput): JourneyEvent[];
+
+/**
+ * The shared derivation module — pure functions, no I/O.
+ *
+ * The same module the dashboard, the API (derive-on-write), and Claude Code
+ * audits all call, so every writer computes the four derived numbers
+ * identically. Ported from `doshi-validation-os/migration/remodel.mjs` and
+ * kept in lock-step with `skills/_shared/ontology.yaml`.
+ */
+
+type index_AssembleJourneyInput = AssembleJourneyInput;
+type index_Attribution = Attribution;
+type index_AttributionReadingInput = AttributionReadingInput;
+type index_BarLineInput = BarLineInput;
+type index_BeliefRisk = BeliefRisk;
+type index_BeliefStage = BeliefStage;
+type index_BeliefStageInput = BeliefStageInput;
+declare const index_COMPLETENESS_SLOTS: typeof COMPLETENESS_SLOTS;
+type index_CompletenessInput = CompletenessInput;
+type index_CompletenessSlot = CompletenessSlot;
+type index_ConfSign = ConfSign;
+type index_ConfidenceReadingInput = ConfidenceReadingInput;
+type index_ImpactAssumptionInput = ImpactAssumptionInput;
+type index_JourneyBeliefInput = JourneyBeliefInput;
+type index_JourneyEvent = JourneyEvent;
+type index_JourneyEventKind = JourneyEventKind;
+type index_JourneyExperimentInput = JourneyExperimentInput;
+declare const index_KILL_LANE_THRESHOLD: typeof KILL_LANE_THRESHOLD;
+declare const index_MARKET_RUNG_ANCHOR: typeof MARKET_RUNG_ANCHOR;
+type index_MoveKind = MoveKind;
+type index_Mover = Mover;
+type index_MoverKind = MoverKind;
+type index_NextMove = NextMove;
+type index_NextMoveAssumptionInput = NextMoveAssumptionInput;
+type index_NextMoveDecisionInput = NextMoveDecisionInput;
+type index_NextMoveExperimentInput = NextMoveExperimentInput;
+type index_NextMoveInput = NextMoveInput;
+type index_PortfolioBeliefInput = PortfolioBeliefInput;
+type index_PortfolioProgress = PortfolioProgress;
+type index_Progress = Progress;
+declare const index_RUNG_ANCHOR: typeof RUNG_ANCHOR;
+type index_Scored = Scored;
+type index_StageExperimentInput = StageExperimentInput;
+type index_StageKey = StageKey;
+type index_StrengthInput = StrengthInput;
+type index_TestMeter = TestMeter;
+type index_TrajectoryPoint = TrajectoryPoint;
+declare const index_W0: typeof W0;
+declare const index_assembleJourney: typeof assembleJourney;
+declare const index_assumptionComplete: typeof assumptionComplete;
+declare const index_assumptionCompleteness: typeof assumptionCompleteness;
+declare const index_beliefRisk: typeof beliefRisk;
+declare const index_beliefTestMeters: typeof beliefTestMeters;
+declare const index_classifyStage: typeof classifyStage;
+declare const index_completenessSlotPresence: typeof completenessSlotPresence;
+declare const index_confidence: typeof confidence;
+declare const index_confidenceAttribution: typeof confidenceAttribution;
+declare const index_confidenceTrajectory: typeof confidenceTrajectory;
+declare const index_deriveBeliefStage: typeof deriveBeliefStage;
+declare const index_derivedImpacts: typeof derivedImpacts;
+declare const index_emptyTestMeter: typeof emptyTestMeter;
+declare const index_experimentProgress: typeof experimentProgress;
+declare const index_isConcluded: typeof isConcluded;
+declare const index_isMarketRung: typeof isMarketRung;
+declare const index_missingCompletenessSlots: typeof missingCompletenessSlots;
+declare const index_portfolioProgress: typeof portfolioProgress;
+declare const index_rankNextMoves: typeof rankNextMoves;
+declare const index_readingStrength: typeof readingStrength;
+declare const index_risk: typeof risk;
+declare const index_round2: typeof round2;
+declare const index_scoreAndDedupe: typeof scoreAndDedupe;
+declare const index_sign: typeof sign;
+declare const index_sourceQuality: typeof sourceQuality;
+declare namespace index {
+  export { type index_AssembleJourneyInput as AssembleJourneyInput, type index_Attribution as Attribution, type index_AttributionReadingInput as AttributionReadingInput, type index_BarLineInput as BarLineInput, type index_BeliefRisk as BeliefRisk, type index_BeliefStage as BeliefStage, type index_BeliefStageInput as BeliefStageInput, index_COMPLETENESS_SLOTS as COMPLETENESS_SLOTS, type index_CompletenessInput as CompletenessInput, type index_CompletenessSlot as CompletenessSlot, type index_ConfSign as ConfSign, type index_ConfidenceReadingInput as ConfidenceReadingInput, type index_ImpactAssumptionInput as ImpactAssumptionInput, type index_JourneyBeliefInput as JourneyBeliefInput, type index_JourneyEvent as JourneyEvent, type index_JourneyEventKind as JourneyEventKind, type index_JourneyExperimentInput as JourneyExperimentInput, index_KILL_LANE_THRESHOLD as KILL_LANE_THRESHOLD, index_MARKET_RUNG_ANCHOR as MARKET_RUNG_ANCHOR, type index_MoveKind as MoveKind, type index_Mover as Mover, type index_MoverKind as MoverKind, type index_NextMove as NextMove, type index_NextMoveAssumptionInput as NextMoveAssumptionInput, type index_NextMoveDecisionInput as NextMoveDecisionInput, type index_NextMoveExperimentInput as NextMoveExperimentInput, type index_NextMoveInput as NextMoveInput, type index_PortfolioBeliefInput as PortfolioBeliefInput, type index_PortfolioProgress as PortfolioProgress, type index_Progress as Progress, index_RUNG_ANCHOR as RUNG_ANCHOR, type index_Scored as Scored, type index_StageExperimentInput as StageExperimentInput, type index_StageKey as StageKey, type index_StrengthInput as StrengthInput, type index_TestMeter as TestMeter, type index_TrajectoryPoint as TrajectoryPoint, index_W0 as W0, index_assembleJourney as assembleJourney, index_assumptionComplete as assumptionComplete, index_assumptionCompleteness as assumptionCompleteness, index_beliefRisk as beliefRisk, index_beliefTestMeters as beliefTestMeters, index_classifyStage as classifyStage, index_completenessSlotPresence as completenessSlotPresence, index_confidence as confidence, index_confidenceAttribution as confidenceAttribution, index_confidenceTrajectory as confidenceTrajectory, index_deriveBeliefStage as deriveBeliefStage, index_derivedImpacts as derivedImpacts, index_emptyTestMeter as emptyTestMeter, index_experimentProgress as experimentProgress, index_isConcluded as isConcluded, index_isMarketRung as isMarketRung, index_missingCompletenessSlots as missingCompletenessSlots, index_portfolioProgress as portfolioProgress, index_rankNextMoves as rankNextMoves, index_readingStrength as readingStrength, index_risk as risk, index_round2 as round2, index_scoreAndDedupe as scoreAndDedupe, index_sign as sign, index_sourceQuality as sourceQuality };
+}
+
+export { derivedImpacts as $, type AttributionReadingInput as A, type BarLineInput as B, COMPLETENESS_SLOTS as C, type Progress as D, type StageExperimentInput as E, type StageKey as F, type StrengthInput as G, type TrajectoryPoint as H, type ImpactAssumptionInput as I, type JourneyBeliefInput as J, KILL_LANE_THRESHOLD as K, assembleJourney as L, MARKET_RUNG_ANCHOR as M, type NextMove as N, beliefRisk as O, type PortfolioBeliefInput as P, beliefTestMeters as Q, RUNG_ANCHOR as R, type Scored as S, type TestMeter as T, classifyStage as U, completenessSlotPresence as V, W0 as W, confidence as X, confidenceAttribution as Y, confidenceTrajectory as Z, deriveBeliefStage as _, type CompletenessSlot as a, emptyTestMeter as a0, experimentProgress as a1, isConcluded as a2, isMarketRung as a3, portfolioProgress as a4, rankNextMoves as a5, risk as a6, round2 as a7, scoreAndDedupe as a8, sign as a9, type CompletenessInput as b, assumptionCompleteness as c, assumptionComplete as d, type AssembleJourneyInput as e, type Attribution as f, type BeliefRisk as g, type BeliefStage as h, index as i, type BeliefStageInput as j, type ConfSign as k, type ConfidenceReadingInput as l, missingCompletenessSlots as m, type JourneyEvent as n, type JourneyEventKind as o, type JourneyExperimentInput as p, type MoveKind as q, readingStrength as r, sourceQuality as s, type Mover as t, type MoverKind as u, type NextMoveAssumptionInput as v, type NextMoveDecisionInput as w, type NextMoveExperimentInput as x, type NextMoveInput as y, type PortfolioProgress as z };

package/dist/index.d.ts

@@ -1,33 +1,8 @@
-import { R as Relation, C as Collection, A as AssumptionRecord, a as ReadingRecord, D as DecisionRecord, b as AssumptionDerived, c as AnyRecord } from './types-B3eI7ASx.js';
-export { d as AssumptionStatus, B as BarLine, e as BaseRecord, f as DecisionStatus, E as ExperimentRecord, g as ExperimentStatus, F as Feasibility, G as GOAL_RUNG_VALUES, h as GlossaryRecord, i as GlossaryStatus, j as GoalRecord, k as GoalRung, l as GoalStatus, M as MagnitudeBand, m as REGISTERS, n as RecordRef, o as Register, p as Result, q as Rung, S as SourceQualityPick, T as TESTING_RUNGS, r as TestingRung } from './types-B3eI7ASx.js';
-export { D as DataProvider, N as NotFoundError, S as StaleVersionError, i as isNotFoundError, a as isStaleVersionError } from './provider-hW8Hxf-n.js';
-import { A as AttributionReadingInput } from './index-CieW13mJ.js';
-export { i as derivation, s as recomputeSourceQuality, r as recomputeStrength } from './index-CieW13mJ.js';
-
-/**
- * Presence checks — the structural half of the assumption write guardrail.
- *
- * `5 Whys`, `Metric for truth`, and `Scoring justification` used to live as
- * body prose audited as *semantic* Gaps (the audit had to parse markdown and
- * guess). OPS-1273 promotes them to first-class fields, so their PRESENCE is a
- * cheap structural check: non-empty is required to move an assumption to
- * `Live` — the presence half of the Draft→Live gaps invariant (OPS-1251).
- *
- * These are pure functions with no backend dependency: the primitive the CRUD
- * write model is to block a Draft→Live write on (write-time enforcement lands
- * with the write slice, OPS-1256), and that the audit reports as an error-level
- * finding meanwhile (`presence-field-missing` in `ontology.yaml`).
- */
-/** The assumption fields whose presence is structurally required to go `Live`. */
-declare const ASSUMPTION_PRESENCE_FIELDS: readonly ["5 Whys", "Metric for truth", "Scoring justification"];
-type AssumptionPresenceField = (typeof ASSUMPTION_PRESENCE_FIELDS)[number];
-/** The presence fields that are absent or blank on a record. */
-declare function missingPresenceFields(record: Partial<Record<AssumptionPresenceField, unknown>>): AssumptionPresenceField[];
-/**
- * True when every presence field is non-blank — the structural precondition
- * for an assumption to be `Live`. A `Draft` may legally fail this.
- */
-declare function assumptionPresenceComplete(record: Partial<Record<AssumptionPresenceField, unknown>>): boolean;
+import { R as Relation, C as Collection, A as AssumptionRecord, a as ReadingRecord, D as DecisionRecord, b as AssumptionDerived, c as AnyRecord } from './types-BAyl0w2E.js';
+export { d as AssumptionStatus, B as BarLine, e as BaseRecord, f as DecisionStatus, E as ExperimentRecord, g as ExperimentStatus, F as Feasibility, G as GlossaryAvoid, h as GlossaryRecord, i as GlossaryStatus, M as MARKET_RUNG_VALUES, j as MagnitudeBand, k as MarketRung, l as REGISTERS, m as RecordRef, n as Register, o as Result, p as Rung, S as SourceQualityPick, T as TESTING_RUNGS, q as TestingRung } from './types-BAyl0w2E.js';
+export { D as DataProvider, N as NotFoundError, S as StaleVersionError, i as isNotFoundError, a as isStaleVersionError } from './provider-DGr5Xq5U.js';
+import { A as AttributionReadingInput } from './index-BlXH_thK.js';
+export { C as ASSUMPTION_PRESENCE_SLOTS, a as AssumptionPresenceSlot, b as CompletenessInput, c as assumptionCompleteness, d as assumptionPresenceComplete, i as derivation, m as missingPresenceSlots, s as recomputeSourceQuality, r as recomputeStrength } from './index-BlXH_thK.js';
 
 /**
  * Relation config — the single table describing, for each linkable relation,
@@ -78,4 +53,4 @@ declare function recomputeDerived(input: RecomputeInput): Map<string, Assumption
 /** Map a reading record (canonical Title-cased fields) to its derivation input. */
 declare function toReadingInput(r: AnyRecord): AttributionReadingInput;
 
-export { ASSUMPTION_PRESENCE_FIELDS, AnyRecord, AssumptionDerived, type AssumptionPresenceField, AssumptionRecord, Collection, DecisionRecord, RELATIONS, ReadingRecord, type RecomputeInput, Relation, type RelationEnd, type RelationSpec, assumptionPresenceComplete, missingPresenceFields, recomputeDerived, toReadingInput };
+export { AnyRecord, AssumptionDerived, AssumptionRecord, Collection, DecisionRecord, RELATIONS, ReadingRecord, type RecomputeInput, Relation, type RelationEnd, type RelationSpec, recomputeDerived, toReadingInput };