@validation-os/core 0.15.6 → 0.16.1

package/dist/{index-DMPfDeEw.d.ts → index-DhQyc0Gj.d.ts}

@@ -1,4 +1,4 @@
-import { r as Rung, l as MagnitudeBand, q as Result, F as Feasibility } from './types-B845UmLh.js';
+import { u as Stage, n as QuestionType, s as Rung, l as MagnitudeBand, r as Result, F as Feasibility } from './types-DZIQEO4D.js';
 
 /**
  * Round to 2 decimals, matching the migration's `+(n).toFixed(2)`.
@@ -8,28 +8,128 @@ import { r as Rung, l as MagnitudeBand, q as Result, F as Feasibility } from './
 declare function round2(n: number): number;
 
 /**
- * The lens-aware ladder anchors (DEV-5879).
+ * The question-type-aware evidence ladder (DEV-5890).
  *
- * Source of truth: `skills/_shared/ontology.yaml` → `vocabularies.rung`. A
- * rung is an evidence TYPE; magnitude band (Low/Typical/High) is the intensity
- * within a type. The band applies to EVERY rung, so every rung looks up its
- * anchor through `RUNG_ANCHOR[rung][band]`.
+ * Source of truth: `skills/_shared/ontology.yaml` → `vocabularies.rung` +
+ * `vocabularies.question_type`. A rung is an evidence TYPE; magnitude band
+ * (Low/Typical/High) is the intensity within a type. The band applies to
+ * EVERY rung, so every rung looks up its anchor through the 3D table
+ * `RUNG_ANCHOR[questionType][rung][band]`.
  *
- *   Talk:           3 / 6 / 10   (Opinion / Pitch-deck / Anecdotal merged)
- *   Desk research:  15 / 15 / 15 (flat — desk research has no meaningful bands,
- *                                  but the field exists for uniformity)
- *   Signed up:      30 / 50 / 70 (consumer lens's first do-rung)
- *   Observed usage: 30 / 50 / 70 (consumer lens; was Prototype usage + Survey
- *                                  at scale, now collapsed)
- *   Signed intent:  30 / 50 / 70 (commercial/investor lens)
- *   Paying users:   30 / 50 / 70 (commercial/investor lens)
+ * Seven sub-ladders, one per question type. Evidence types that are
+ * **non-evidence** for a question type carry anchor `0` across all bands —
+ * they contribute `s=0` and are flagged at the UI/skill layer (not a write
+ * blocker). The `0` is structural, not a separate flag.
  *
- * The lens determines which "do" rungs are available; Talk + Desk work for
- * any lens. The rung-to-lens mapping is a grading guideline, not a schema
- * constraint — any Rung can appear on any assumption.
+ * The rung vocabulary itself (`Talk`, `Desk research`, `Signed up`,
+ * `Observed usage`, `Signed intent`, `Paying users`) is unchanged across
+ * all sub-ladders — the same six rungs exist in every sub-ladder, with
+ * different anchors (including `0` for non-evidence). This preserves the
+ * existing `Rung` type and all reading-row machinery.
+ *
+ * Research backing: EBM GRADE (evidence hierarchies are question-relative),
+ * Bayesian confirmation theory (probative value is hypothesis-relative),
+ * qualitative research methods (qual is the ceiling for mechanism/existence
+ * questions; saturation is a validity criterion), revealed preference
+ * (sustained usage is the cleanest utility signal; stated intent is
+ * non-evidence for WTP). See `docs/question-types.md`.
+ *
+ * W0 stays keyed by evidence type (within a question type), not by stage or
+ * question type — see `confidence.ts` → `W0_BY_RUNG`. The learning rate
+ * tracks the instrument's reliability, not the stakes or the claim kind.
+ * Empirical-Bayes per-question-type W0 tuning is flagged as v2 (out of scope).
  */
 
-declare const RUNG_ANCHOR: Record<Rung, Record<MagnitudeBand, number>>;
+/**
+ * The 3D anchor table — `RUNG_ANCHOR[questionType][rung][band]`.
+ *
+ * Seven sub-ladders. `0` entries are the non-evidence set for that question
+ * type (the reading contributes `s=0`, flagged at the UI/skill layer). The
+ * shape — what's probative, what's the ceiling, what's non-evidence — is
+ * the decision; the exact values are illustrative anchors calibrated against
+ * the research backing (see `docs/question-types.md`).
+ *
+ * Per the spec table:
+ *
+ * | Question Type     | Talk L/T/H   | Desk L/T/H   | Signed up L/T/H | Observed usage L/T/H | Signed intent L/T/H | Paying users L/T/H | Ceiling                |
+ * |-------------------|--------------|--------------|-----------------|----------------------|----------------------|--------------------|-----------------------|
+ * | Existence         | 10/20/30     | 15/15/15     | 0/0/0           | 20/35/50             | 0/0/0                | 0/0/0              | Observed usage High(50)|
+ * | Prevalence        | 0/0/0        | 15/15/15     | 0/0/0           | 25/40/50             | 0/0/0                | 0/0/0              | Observed usage High(50)|
+ * | CausalEffect      | 0/0/0        | 0/0/0        | 0/0/0           | 30/50/70             | 30/50/70             | 50/70/90           | Paying users High(90) |
+ * | WillingnessToPay  | 0/0/0        | 0/0/0        | 30/50/70        | 0/0/0                | 50/70/85             | 75/88/99           | Paying users High(99) |
+ * | ValueUtility      | 10/20/30     | 0/0/0        | 0/0/0           | 30/50/70             | 0/0/0                | 0/0/0              | Observed usage High(70)|
+ * | Regulatory        | 0/0/0        | 30/50/70     | 0/0/0           | 0/0/0                | 0/0/0                | 0/0/0              | Desk research High(70)|
+ * | Feasibility       | 0/0/0        | 15/15/15     | 0/0/0           | 30/50/70             | 0/0/0                | 0/0/0              | Observed usage High(70)|
+ */
+type BandRecord = Record<MagnitudeBand, number>;
+type RungAnchors = Record<Rung, BandRecord>;
+/** The seven sub-ladders, keyed by question type. */
+declare const RUNG_ANCHOR: Record<QuestionType, RungAnchors>;
+/**
+ * Is a rung **non-evidence** for a question type? A derived predicate — the
+ * reading is allowed (not a write blocker) but contributes `s=0` and is
+ * flagged at the UI/skill layer for human review ("reclassify the assumption
+ * or drop the reading"). Non-evidence is `0` anchor across all bands, by
+ * construction.
+ */
+declare function isNonEvidence(questionType: QuestionType, rung: Rung): boolean;
+/**
+ * The ceiling anchor for a (question type × rung) — the strongest band
+ * (`High`). Used by the dashboard to label the ceiling on each sub-ladder and
+ * by `/experiment-design` to size the next test against the question type's
+ * ceiling.
+ */
+declare function ceilingAnchor(questionType: QuestionType, rung: Rung): number;
+/**
+ * The Risk threshold below which an assumption is "validated enough" for its
+ * stage (DEV-5890). Pragmatic encroachment + Bezos two-way vs one-way doors;
+ * Stage is the reversibility proxy. The threshold does NOT flip a status —
+ * Live assumptions stay Live and ranked forever (`docs/validated.md`). It is
+ * consumed by the dashboard's test-next surface, the `/assumptions audit`
+ * skill, and the `/experiment-design` skill. It does NOT enter the
+ * Confidence formula.
+ *
+ * The threshold is the max Risk you can have and still "stop testing" for
+ * this stage. Later stages have LOWER thresholds because you need to drive
+ * Risk down further (more evidence) before acting on a one-way door.
+ * Discovery = 30: stop testing when Risk ≤ 30 (two-way door, little evidence
+ * needed). Maturity = 5: stop testing when Risk ≤ 5 (one-way door, lots of
+ * evidence needed). The bar being LOWER means the STANDARD is HIGHER — like
+ * a high-jump bar: a lower number means you have to clear more.
+ */
+declare const RISK_THRESHOLD_BY_STAGE: Record<Stage, number>;
+/**
+ * The minimum Confidence floor for "cleared" (DEV-5890 fix). A belief with
+ * Impact below the stage's Risk threshold could read Risk ≤ threshold with
+ * ZERO evidence (Risk = Impact × (1 − 0/100) = Impact). Without a Confidence
+ * floor, a low-Impact belief gets a free pass. The floor requires at least
+ * some evidence before "cleared" is honest. Tightens with stage, mirroring
+ * the Risk threshold.
+ */
+declare const CONFIDENCE_FLOOR_BY_STAGE: Record<Stage, number>;
+/**
+ * The Risk threshold for a given stage — the stopping rule for attention.
+ * Falls back to the tightest threshold (Maturity) when the stage is absent,
+ * so a missing stage never silently lowers the bar.
+ */
+declare function riskThresholdForStage(stage: Stage | null | undefined): number;
+/**
+ * The minimum Confidence floor for a given stage. Falls back to the tightest
+ * (Maturity) when absent.
+ */
+declare function confidenceFloorForStage(stage: Stage | null | undefined): number;
+/**
+ * Has the assumption cleared its stage's threshold? "Cleared" requires BOTH:
+ *   1. Risk ≤ the stage's Risk threshold (enough evidence to drive Risk down)
+ *   2. Confidence ≥ the stage's Confidence floor (at least some real evidence)
+ *
+ * The Confidence floor prevents a low-Impact belief from being "cleared" with
+ * zero evidence — Risk = Impact × (1 − 0/100) = Impact, so a belief with
+ * Impact below the threshold would read "cleared" without any readings. The
+ * floor requires at least a minimum Confidence signal before "cleared" is
+ * honest. "Needs evidence" = either condition fails — testing-priority.
+ */
+declare function hasClearedThreshold(risk: number, stage: Stage | null | undefined, confidence?: number): boolean;
 
 /**
  * Assumption completeness — a derived readiness meter, never stored.
@@ -39,14 +139,20 @@ declare const RUNG_ANCHOR: Record<Rung, Record<MagnitudeBand, number>>;
  * 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):
+ * Slots (each an equal sixth):
  *   Description · Lens · Impact · Scoring justification · Dependencies traced
+ *   · Question Type
+ *
+ * Question Type (DEV-5890) is the 6th slot: an assumption without a Question
+ * Type has `Completeness %` < 100 and cannot go Live. The grill infers the
+ * Question Type from the falsification test and confirms with the user
+ * (the gaming guard).
  *
  * 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"];
+declare const COMPLETENESS_SLOTS: readonly ["Description", "Lens", "Impact", "Scoring justification", "Dependencies traced", "Question Type"];
 type CompletenessSlot = (typeof COMPLETENESS_SLOTS)[number];
 /** The record shape completeness reads — an assumption's structural fields. */
 interface CompletenessInput {
@@ -56,6 +162,7 @@ interface CompletenessInput {
     "Scoring justification"?: unknown;
     dependsOnIds?: unknown;
     enablesIds?: unknown;
+    "Question Type"?: unknown;
 }
 /** Whether each slot is structurally present. */
 declare function completenessSlotPresence(record: CompletenessInput): Record<CompletenessSlot, boolean>;
@@ -70,10 +177,17 @@ declare function assumptionComplete(record: CompletenessInput): boolean;
  * Strength — the signed reading value `s` the Confidence average reads.
  *
  * Formula (`ontology.yaml` → `derivations.strength`):
- *   rung anchor × magnitude band × sign(Result)
+ *   `RUNG_ANCHOR[questionType][rung][band] × sign(Result)`
  *   — Validated positive, Invalidated negative; 0 unless Validated/Invalidated.
  *
- * Every rung now carries a magnitude band (0.14); the lookup is the same for
+ * The anchor lookup is 3D (DEV-5890): keyed by the linked assumption's
+ * Question Type, the reading's Rung, and the row's Magnitude band. A rung
+ * that is non-evidence for the assumption's question type carries anchor 0
+ * across all bands, so the reading contributes `s=0` and is flagged at the
+ * UI/skill layer (not a write blocker). `isNonEvidence(questionType, rung)`
+ * is derived, never stored.
+ *
+ * Every rung carries a magnitude band (0.14); the lookup is the same for
  * testing and market rungs.
  */
 
@@ -83,6 +197,8 @@ declare function sign(result: Result): -1 | 0 | 1;
  * derivation module (and its record→input mappers) share. */
 declare function isConcluded(result: Result): boolean;
 interface StrengthInput {
+    /** The linked assumption's question type — sets the anchor sub-ladder. */
+    questionType: QuestionType;
     rung: Rung;
     result: Result;
     /** Magnitude band; defaults to "Typical" when absent. Applies to ALL rungs. */
@@ -90,6 +206,180 @@ interface StrengthInput {
 }
 declare function readingStrength(input: StrengthInput): number;
 
+/**
+ * Question-type inference — the falsification-test rule (DEV-5890).
+ *
+ * The question type is set by what would prove the assumption WRONG, not by
+ * what evidence is cheap to gather. "Users will pay $50/mo" is falsified by
+ * offering it and watching them not pay → WillingnessToPay, regardless of how
+ * many interview quotes exist. The function is conservative: if the
+ * falsification test is ambiguous, it returns `Existence` (the most
+ * permissive sub-ladder) and flags for human review. The migration script
+ * runs this over all assumptions and produces a review queue for the ones it
+ * isn't confident on.
+ *
+ * The grill enforces the gaming guard: the inferred type (from the
+ * falsification bar) must match the stated type, or the assumption is rejected.
+ * This is the rule that stops a team reframing "will users pay?" as "do users
+ * express willingness to pay?" (existence question, qual ceiling) to avoid
+ * running a market test.
+ *
+ * Rules (matched in order; first match wins):
+ *
+ *   - Falsified by "the regulation prohibits / the regulator rules against
+ *     / the compliance audit fails" → Regulatory
+ *   - Falsified by "they don't pay / don't sign up / don't commit / fake-door
+ *     rate below X%" → WillingnessToPay
+ *   - Falsified by "they stop using it / drop-off exceeds X / sustained usage
+ *     falls below / retention" → ValueUtility
+ *   - Falsified by "the treatment group doesn't differ from control / no
+ *     causal effect / variant doesn't outperform" → CausalEffect
+ *   - Falsified by "the rate is below X% / fewer than N of N / the proportion
+ *     is below / the share is below" → Prevalence
+ *   - Falsified by "they can't complete the flow / the system can't do X /
+ *     can't be built" → Feasibility
+ *   - Falsified by "no one reports this pain / no one describes this
+ *     mechanism / no one reports caring" → Existence
+ *   - Otherwise (ambiguous) → Existence (flagged for human review)
+ *
+ * Regulatory is matched first because a regulator ruling against is a
+ * distinctive falsification that shouldn't be misread as a willingness-to-pay
+ * or feasibility claim. WillingnessToPay precedes ValueUtility because "they
+ * pay" is the WTP falsification and "they stop using" is the ValueUtility
+ * falsification — the keywords are distinct but WTP is the more specific claim
+ * kind. CausalEffect precedes Prevalence because "rate below X%" appears in
+ * both prevalence bars and A/B conversion-rate bars; the A/B framing
+ * ("treatment group", "control", "variant", "outperform") is matched first.
+ *
+ * The function is a pure string-matching heuristic — no NLP, no external
+ * calls. The migration's review queue is the backstop for cases the
+ * heuristic misses.
+ */
+
+/** The default question type for an ambiguous falsification test — the most
+ * permissive sub-ladder, and the migration's flagged-for-review default. */
+declare const DEFAULT_QUESTION_TYPE: QuestionType;
+/**
+ * Infer the Question Type from an assumption's description and falsification
+ * bar. The falsification bar (`wrongIfBar`) carries the signal — the
+ * description is only consulted as a fallback context. Returns the most
+ * permissive type (`Existence`) for an ambiguous bar; the migration's review
+ * queue is the backstop.
+ */
+declare function inferQuestionType(description: string, wrongIfBar: string): QuestionType;
+/** The set of question types the inference rule can return. Exported for
+ * the migration's "covered types" assertion. */
+declare const INFERABLE_QUESTION_TYPES: readonly QuestionType[];
+/** Whether an inferred question type should be flagged for human review.
+ * Conservative: only the confident matches are clean; the default
+ * (Existence-from-ambiguous) is always flagged. A match is "confident" if the
+ * bar matched a rule other than the Existence fallback. */
+declare function needsReview(description: string, wrongIfBar: string, inferred: QuestionType): boolean;
+
+/** A minimal assumption shape for migration input. */
+interface MigrationAssumption {
+    id: string;
+    Description?: string;
+    /** The falsification test — the "we're wrong if" bar from the grill. */
+    wrongIfBar?: string;
+    /** The existing question type, if any (otherwise inferred). */
+    "Question Type"?: QuestionType | null;
+    /** Existing derived Confidence (for the delta report). */
+    derived?: {
+        confidence?: number;
+    } | null;
+    /** The assumption's Stage, for the threshold comparison in the summary. */
+    Stage?: string | null;
+    Impact?: number | null;
+    moot?: boolean;
+    dependsOnIds?: string[];
+    enablesIds?: string[];
+}
+/** A minimal reading shape for migration input. */
+interface MigrationReading {
+    id: string;
+    /** The assumption id this reading's belief scores (single-belief migration). */
+    assumptionId: string;
+    Rung: Rung;
+    Result: Result;
+    magnitudeBand?: "Low" | "Typical" | "High" | null;
+    Source: string | null;
+    Representativeness: number;
+    Credibility: number;
+    Date: string | null;
+    experimentId: string | null;
+    /** Existing derived Strength (for the delta report). */
+    derived?: {
+        strength?: number;
+    } | null;
+}
+/** The output shape for a migrated assumption. */
+interface MigratedAssumption extends MigrationAssumption {
+    "Question Type": QuestionType;
+    /** Whether the inferred question type was flagged for human review. */
+    questionTypeReviewNeeded: boolean;
+    /** The new derived Confidence (recomputed under the new sub-ladder). */
+    newConfidence: number;
+    /** The pre-migration Confidence (for the delta report). */
+    oldConfidence: number;
+    /** The Confidence delta (new − old). */
+    confidenceDelta: number;
+    /** The stage's Risk threshold (for the summary). */
+    riskThreshold: number;
+}
+/** The output shape for a migrated reading's belief. */
+interface MigratedReading {
+    id: string;
+    assumptionId: string;
+    Rung: Rung;
+    /** The recomputed Strength (s) under the new sub-ladder. */
+    newStrength: number;
+    /** The pre-migration Strength (for diffing). */
+    oldStrength: number;
+    /** True if the rung is non-evidence for the linked assumption's question type. */
+    nonEvidence: boolean;
+}
+/** The full migration result. */
+interface MigrationResult {
+    assumptions: MigratedAssumption[];
+    readings: MigratedReading[];
+    /** The number of readings flagged as non-evidence. */
+    nonEvidenceFlagCount: number;
+    /** The number of assumptions flagged for human review of their question type. */
+    reviewQueueCount: number;
+    /** Per-assumption Confidence deltas, sorted by |delta| descending. */
+    confidenceDeltas: {
+        id: string;
+        delta: number;
+        oldConfidence: number;
+        newConfidence: number;
+    }[];
+    /** Per-assumption ranking shifts in the Risk-ranked register (oldRank →
+     * newRank, 1-indexed; positive = moved down the ranking, negative = moved
+     * up). Sorted by |shift| descending. */
+    rankingShifts: {
+        id: string;
+        oldRank: number;
+        newRank: number;
+        shift: number;
+    }[];
+}
+/**
+ * Migrate an old-shape register to the new question-type-aware shape. Pure —
+ * no I/O. The caller reads the register, calls this, and writes the result;
+ * the backup is the caller's responsibility (write a dated copy of the input
+ * before calling `migrateRegister`).
+ *
+ * The migration:
+ * 1. Infers `Question Type` for each assumption from its falsification bar.
+ * 2. Recomputes each reading's `s` via `RUNG_ANCHOR[questionType][rung][band]`.
+ * 3. Flags readings whose rung is non-evidence for the linked assumption's
+ *    question type (keeps the would-have-been `s` visible for diffing).
+ * 4. Recomputes each assumption's Confidence under the new sub-ladder.
+ * 5. Produces a summary report of Confidence deltas and flag counts.
+ */
+declare function migrateRegister(assumptions: MigrationAssumption[], readings: MigrationReading[]): MigrationResult;
+
 declare function sourceQuality(representativeness: number, credibility: number): number;
 
 /**
@@ -148,6 +438,8 @@ interface ConfidenceReadingInput {
     source: string | null;
     rung: Rung;
     result: Result;
+    /** The linked assumption's question type — sets the anchor sub-ladder. */
+    questionType: QuestionType;
     representativeness: number;
     credibility: number;
     /** ISO date; used only as the dedupe tie-break (most recent wins). */
@@ -290,6 +582,8 @@ interface ExperimentConfidenceReadingInput {
     source: string | null;
     rung: Rung;
     result: Result;
+    /** The linked assumption's question type — sets the anchor sub-ladder. */
+    questionType: QuestionType;
     magnitudeBand?: MagnitudeBand;
     representativeness: number;
     credibility: number;
@@ -629,12 +923,15 @@ type index_BeliefStage = BeliefStage;
 type index_BeliefStageInput = BeliefStageInput;
 declare const index_COMMITMENT_FOUND: typeof COMMITMENT_FOUND;
 declare const index_COMPLETENESS_SLOTS: typeof COMPLETENESS_SLOTS;
+declare const index_CONFIDENCE_FLOOR_BY_STAGE: typeof CONFIDENCE_FLOOR_BY_STAGE;
 type index_CompletenessInput = CompletenessInput;
 type index_CompletenessSlot = CompletenessSlot;
 type index_ConfSign = ConfSign;
 type index_ConfidenceReadingInput = ConfidenceReadingInput;
+declare const index_DEFAULT_QUESTION_TYPE: typeof DEFAULT_QUESTION_TYPE;
 type index_ExperimentConfidenceBarInput = ExperimentConfidenceBarInput;
 type index_ExperimentConfidenceReadingInput = ExperimentConfidenceReadingInput;
+declare const index_INFERABLE_QUESTION_TYPES: typeof INFERABLE_QUESTION_TYPES;
 type index_ImpactAssumptionInput = ImpactAssumptionInput;
 type index_JourneyBeliefInput = JourneyBeliefInput;
 type index_JourneyEvent = JourneyEvent;
@@ -642,6 +939,11 @@ type index_JourneyEventKind = JourneyEventKind;
 type index_JourneyExperimentInput = JourneyExperimentInput;
 declare const index_KILL_LANE_THRESHOLD: typeof KILL_LANE_THRESHOLD;
 declare const index_MAX_STRENGTH: typeof MAX_STRENGTH;
+type index_MigratedAssumption = MigratedAssumption;
+type index_MigratedReading = MigratedReading;
+type index_MigrationAssumption = MigrationAssumption;
+type index_MigrationReading = MigrationReading;
+type index_MigrationResult = MigrationResult;
 type index_MoveKind = MoveKind;
 type index_Mover = Mover;
 type index_MoverKind = MoverKind;
@@ -653,6 +955,7 @@ type index_NextMoveInput = NextMoveInput;
 type index_PortfolioBeliefInput = PortfolioBeliefInput;
 type index_PortfolioProgress = PortfolioProgress;
 type index_Progress = Progress;
+declare const index_RISK_THRESHOLD_BY_STAGE: typeof RISK_THRESHOLD_BY_STAGE;
 declare const index_RUNG_ANCHOR: typeof RUNG_ANCHOR;
 type index_Scored = Scored;
 type index_StageExperimentInput = StageExperimentInput;
@@ -667,30 +970,38 @@ 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_ceilingAnchor: typeof ceilingAnchor;
 declare const index_classifyStage: typeof classifyStage;
 declare const index_commitmentFactor: typeof commitmentFactor;
 declare const index_completenessSlotPresence: typeof completenessSlotPresence;
 declare const index_confidence: typeof confidence;
 declare const index_confidenceAttribution: typeof confidenceAttribution;
+declare const index_confidenceFloorForStage: typeof confidenceFloorForStage;
 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_experimentConfidence: typeof experimentConfidence;
 declare const index_experimentProgress: typeof experimentProgress;
+declare const index_hasClearedThreshold: typeof hasClearedThreshold;
+declare const index_inferQuestionType: typeof inferQuestionType;
 declare const index_isConcluded: typeof isConcluded;
+declare const index_isNonEvidence: typeof isNonEvidence;
+declare const index_migrateRegister: typeof migrateRegister;
 declare const index_missingCompletenessSlots: typeof missingCompletenessSlots;
+declare const index_needsReview: typeof needsReview;
 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_riskThresholdForStage: typeof riskThresholdForStage;
 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 const index_w0ForRung: typeof w0ForRung;
 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_COMMITMENT_FOUND as COMMITMENT_FOUND, 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_ExperimentConfidenceBarInput as ExperimentConfidenceBarInput, type index_ExperimentConfidenceReadingInput as ExperimentConfidenceReadingInput, 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_MAX_STRENGTH as MAX_STRENGTH, 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_W0_BY_RUNG as W0_BY_RUNG, 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_commitmentFactor as commitmentFactor, 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_experimentConfidence as experimentConfidence, index_experimentProgress as experimentProgress, index_isConcluded as isConcluded, 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, index_w0ForRung as w0ForRung };
+  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_COMMITMENT_FOUND as COMMITMENT_FOUND, index_COMPLETENESS_SLOTS as COMPLETENESS_SLOTS, index_CONFIDENCE_FLOOR_BY_STAGE as CONFIDENCE_FLOOR_BY_STAGE, type index_CompletenessInput as CompletenessInput, type index_CompletenessSlot as CompletenessSlot, type index_ConfSign as ConfSign, type index_ConfidenceReadingInput as ConfidenceReadingInput, index_DEFAULT_QUESTION_TYPE as DEFAULT_QUESTION_TYPE, type index_ExperimentConfidenceBarInput as ExperimentConfidenceBarInput, type index_ExperimentConfidenceReadingInput as ExperimentConfidenceReadingInput, index_INFERABLE_QUESTION_TYPES as INFERABLE_QUESTION_TYPES, 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_MAX_STRENGTH as MAX_STRENGTH, type index_MigratedAssumption as MigratedAssumption, type index_MigratedReading as MigratedReading, type index_MigrationAssumption as MigrationAssumption, type index_MigrationReading as MigrationReading, type index_MigrationResult as MigrationResult, 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_RISK_THRESHOLD_BY_STAGE as RISK_THRESHOLD_BY_STAGE, 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_W0_BY_RUNG as W0_BY_RUNG, index_assembleJourney as assembleJourney, index_assumptionComplete as assumptionComplete, index_assumptionCompleteness as assumptionCompleteness, index_beliefRisk as beliefRisk, index_beliefTestMeters as beliefTestMeters, index_ceilingAnchor as ceilingAnchor, index_classifyStage as classifyStage, index_commitmentFactor as commitmentFactor, index_completenessSlotPresence as completenessSlotPresence, index_confidence as confidence, index_confidenceAttribution as confidenceAttribution, index_confidenceFloorForStage as confidenceFloorForStage, index_confidenceTrajectory as confidenceTrajectory, index_deriveBeliefStage as deriveBeliefStage, index_derivedImpacts as derivedImpacts, index_emptyTestMeter as emptyTestMeter, index_experimentConfidence as experimentConfidence, index_experimentProgress as experimentProgress, index_hasClearedThreshold as hasClearedThreshold, index_inferQuestionType as inferQuestionType, index_isConcluded as isConcluded, index_isNonEvidence as isNonEvidence, index_migrateRegister as migrateRegister, index_missingCompletenessSlots as missingCompletenessSlots, index_needsReview as needsReview, index_portfolioProgress as portfolioProgress, index_rankNextMoves as rankNextMoves, index_readingStrength as readingStrength, index_risk as risk, index_riskThresholdForStage as riskThresholdForStage, index_round2 as round2, index_scoreAndDedupe as scoreAndDedupe, index_sign as sign, index_sourceQuality as sourceQuality, index_w0ForRung as w0ForRung };
 }
 
-export { completenessSlotPresence as $, type AttributionReadingInput as A, type BarLineInput as B, COMPLETENESS_SLOTS as C, type NextMoveInput as D, type ExperimentConfidenceBarInput as E, type PortfolioProgress as F, type Progress as G, type StageExperimentInput as H, type ImpactAssumptionInput as I, type JourneyBeliefInput as J, KILL_LANE_THRESHOLD as K, type StageKey as L, MAX_STRENGTH as M, type NextMove as N, type StrengthInput as O, type PortfolioBeliefInput as P, type TrajectoryPoint as Q, RUNG_ANCHOR as R, type Scored as S, type TestMeter as T, W0_BY_RUNG as U, assembleJourney as V, W0 as W, beliefRisk as X, beliefTestMeters as Y, classifyStage as Z, commitmentFactor as _, type CompletenessSlot as a, confidence as a0, confidenceAttribution as a1, confidenceTrajectory as a2, deriveBeliefStage as a3, derivedImpacts as a4, emptyTestMeter as a5, experimentConfidence as a6, experimentProgress as a7, isConcluded as a8, portfolioProgress as a9, rankNextMoves as aa, risk as ab, round2 as ac, scoreAndDedupe as ad, sign as ae, w0ForRung as af, 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, COMMITMENT_FOUND as k, type ConfSign as l, missingCompletenessSlots as m, type ConfidenceReadingInput as n, type ExperimentConfidenceReadingInput as o, type JourneyEvent as p, type JourneyEventKind as q, readingStrength as r, sourceQuality as s, type JourneyExperimentInput as t, type MoveKind as u, type Mover as v, type MoverKind as w, type NextMoveAssumptionInput as x, type NextMoveDecisionInput as y, type NextMoveExperimentInput as z };
+export { type TestMeter as $, type AttributionReadingInput as A, type BarLineInput as B, COMPLETENESS_SLOTS as C, DEFAULT_QUESTION_TYPE as D, type ExperimentConfidenceBarInput as E, type MigrationResult as F, type MoveKind as G, type Mover as H, INFERABLE_QUESTION_TYPES as I, type JourneyBeliefInput as J, KILL_LANE_THRESHOLD as K, type MoverKind as L, MAX_STRENGTH as M, type NextMove as N, type NextMoveAssumptionInput as O, type NextMoveDecisionInput as P, type NextMoveExperimentInput as Q, type NextMoveInput as R, type PortfolioBeliefInput as S, type PortfolioProgress as T, type Progress as U, RISK_THRESHOLD_BY_STAGE as V, RUNG_ANCHOR as W, type Scored as X, type StageExperimentInput as Y, type StageKey as Z, type StrengthInput as _, type CompletenessSlot as a, type TrajectoryPoint as a0, W0 as a1, W0_BY_RUNG as a2, assembleJourney as a3, beliefRisk as a4, beliefTestMeters as a5, ceilingAnchor as a6, classifyStage as a7, commitmentFactor as a8, completenessSlotPresence as a9, confidence as aa, confidenceAttribution as ab, confidenceFloorForStage as ac, confidenceTrajectory as ad, deriveBeliefStage as ae, derivedImpacts as af, emptyTestMeter as ag, experimentConfidence as ah, experimentProgress as ai, hasClearedThreshold as aj, inferQuestionType as ak, isConcluded as al, isNonEvidence as am, migrateRegister as an, needsReview as ao, portfolioProgress as ap, rankNextMoves as aq, risk as ar, riskThresholdForStage as as, round2 as at, scoreAndDedupe as au, sign as av, w0ForRung as aw, 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, COMMITMENT_FOUND as k, CONFIDENCE_FLOOR_BY_STAGE as l, missingCompletenessSlots as m, type ConfSign as n, type ConfidenceReadingInput as o, type ExperimentConfidenceReadingInput as p, type ImpactAssumptionInput as q, readingStrength as r, sourceQuality as s, type JourneyEvent as t, type JourneyEventKind as u, type JourneyExperimentInput as v, type MigratedAssumption as w, type MigratedReading as x, type MigrationAssumption as y, type MigrationReading as z };

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { R as Relation, C as Collection, A as AssumptionRecord, a as ReadingRecord, D as DecisionRecord, b as AssumptionDerived, E as ExperimentRecord, c as ExperimentDerived, d as AnyRecord } from './types-B845UmLh.js';
-export { e as AssumptionStatus, B as BarLine, f as BaseRecord, g as BeliefScore, h as DecisionStatus, i as ExperimentStatus, F as Feasibility, G as GlossaryAvoid, j as GlossaryRecord, k as GlossaryStatus, M as MARKET_RUNG_VALUES, l as MagnitudeBand, m as MarketRung, n as REGISTERS, o as RecordRef, p as Register, q as Result, r as Rung, S as SourceQualityPick, T as TESTING_RUNGS, s as TestingRung } from './types-B845UmLh.js';
-export { D as DataProvider, N as NotFoundError, S as StaleVersionError, i as isNotFoundError, a as isStaleVersionError } from './provider-biEHIhDh.js';
-import { A as AttributionReadingInput } from './index-DMPfDeEw.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-DMPfDeEw.js';
+import { R as Relation, C as Collection, A as AssumptionRecord, a as ReadingRecord, D as DecisionRecord, b as AssumptionDerived, E as ExperimentRecord, c as ExperimentDerived, d as AnyRecord } from './types-DZIQEO4D.js';
+export { e as AssumptionStatus, B as BarLine, f as BaseRecord, g as BeliefScore, h as DecisionStatus, i as ExperimentStatus, F as Feasibility, G as GlossaryAvoid, j as GlossaryRecord, k as GlossaryStatus, M as MARKET_RUNG_VALUES, l as MagnitudeBand, m as MarketRung, Q as QUESTION_TYPES, n as QuestionType, o as REGISTERS, p as RecordRef, q as Register, r as Result, s as Rung, S as STAGES, t as SourceQualityPick, u as Stage, T as TESTING_RUNGS, v as TestingRung } from './types-DZIQEO4D.js';
+export { D as DataProvider, N as NotFoundError, S as StaleVersionError, i as isNotFoundError, a as isStaleVersionError } from './provider-BAip4ABo.js';
+import { A as AttributionReadingInput } from './index-DhQyc0Gj.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-DhQyc0Gj.js';
 
 /**
  * Relation config — the single table describing, for each linkable relation,
@@ -46,11 +46,14 @@ declare function recomputeDerived(input: RecomputeInput): Map<string, Assumption
  * Recompute the derived numbers for every experiment in the register.
  *
  * Groups readings by `experimentId`, filters each experiment's readings to its
- * `barLineAssumptionIds`, and calls {@link experimentConfidence}.
+ * `barLineAssumptionIds`, and calls {@link experimentConfidence}. DEV-5890:
+ * the assumption's Question Type is looked up from the assumptions register so
+ * Strength reads the right sub-ladder.
  */
 declare function recomputeExperimentDerived(input: {
     experiments: ExperimentRecord[];
     readings: ReadingRecord[];
+    assumptions?: AssumptionRecord[];
 }): Map<string, ExperimentDerived>;
 
 /**
@@ -66,6 +69,15 @@ declare function recomputeExperimentDerived(input: {
  * rationale vary per belief. `readingBeliefInputs` fans a row out into one
  * derivation input per belief, stamping the row-level fields onto each and
  * pairing the row rung with that belief's own Result.
+ *
+ * DEV-5890: each belief input also carries the linked assumption's
+ * `questionType`, looked up from the assumption register via the optional
+ * `assumptionsById` map. The question type sets the anchor sub-ladder
+ * (`RUNG_ANCHOR[questionType][rung][band]`). When the map is absent or a
+ * belief's assumption is missing, the question type defaults to
+ * `Existence` — the most permissive sub-ladder, and the migration default for
+ * ambiguous cases. The recompute pass always supplies the map; the dashboard's
+ * understanding layer supplies it when it can.
  */
 
 /**
@@ -75,14 +87,19 @@ declare function recomputeExperimentDerived(input: {
 type BeliefReadingInput = AttributionReadingInput & {
     assumptionId: string;
 };
+/** A minimal assumption record shape — only what we need to read Question Type. */
+interface AssumptionLike {
+    "Question Type"?: unknown;
+}
 /**
  * Fan a reading row out into one derivation input per belief. Each input pairs
  * the ROW's rung / magnitude band / Source / source-quality picks / date /
- * experiment (which drives the commitment factor) with the belief's own Result.
- * The input's `id` is the row id — within a single assumption's group each row
- * contributes one belief, so the id stays a stable dedupe fallback and
- * drill-through key.
+ * experiment (which drives the commitment factor) with the belief's own Result
+ * and the linked assumption's Question Type (looked up via the optional
+ * `assumptionsById` map; defaults to `Existence` when absent). The input's
+ * `id` is the row id — within a single assumption's group each row contributes
+ * one belief, so the id stays a stable dedupe fallback and drill-through key.
  */
-declare function readingBeliefInputs(r: AnyRecord): BeliefReadingInput[];
+declare function readingBeliefInputs(r: AnyRecord, assumptionsById?: ReadonlyMap<string, any>): BeliefReadingInput[];
 
-export { AnyRecord, AssumptionDerived, AssumptionRecord, type BeliefReadingInput, Collection, DecisionRecord, ExperimentDerived, ExperimentRecord, RELATIONS, ReadingRecord, type RecomputeInput, Relation, type RelationEnd, type RelationSpec, readingBeliefInputs, recomputeDerived, recomputeExperimentDerived };
+export { AnyRecord, AssumptionDerived, type AssumptionLike, AssumptionRecord, type BeliefReadingInput, Collection, DecisionRecord, ExperimentDerived, ExperimentRecord, RELATIONS, ReadingRecord, type RecomputeInput, Relation, type RelationEnd, type RelationSpec, readingBeliefInputs, recomputeDerived, recomputeExperimentDerived };