@validation-os/core 0.15.6 → 0.16.1

package/dist/{chunk-HMAHBGOJ.js → chunk-TCKAMOAK.js}

@@ -7,8 +7,12 @@ var derivation_exports = {};
 __export(derivation_exports, {
   COMMITMENT_FOUND: () => COMMITMENT_FOUND,
   COMPLETENESS_SLOTS: () => COMPLETENESS_SLOTS,
+  CONFIDENCE_FLOOR_BY_STAGE: () => CONFIDENCE_FLOOR_BY_STAGE,
+  DEFAULT_QUESTION_TYPE: () => DEFAULT_QUESTION_TYPE,
+  INFERABLE_QUESTION_TYPES: () => INFERABLE_QUESTION_TYPES,
   KILL_LANE_THRESHOLD: () => KILL_LANE_THRESHOLD,
   MAX_STRENGTH: () => MAX_STRENGTH,
+  RISK_THRESHOLD_BY_STAGE: () => RISK_THRESHOLD_BY_STAGE,
   RUNG_ANCHOR: () => RUNG_ANCHOR,
   W0: () => W0,
   W0_BY_RUNG: () => W0_BY_RUNG,
@@ -17,23 +21,31 @@ __export(derivation_exports, {
   assumptionCompleteness: () => assumptionCompleteness,
   beliefRisk: () => beliefRisk,
   beliefTestMeters: () => beliefTestMeters,
+  ceilingAnchor: () => ceilingAnchor,
   classifyStage: () => classifyStage,
   commitmentFactor: () => commitmentFactor,
   completenessSlotPresence: () => completenessSlotPresence,
   confidence: () => confidence,
   confidenceAttribution: () => confidenceAttribution,
+  confidenceFloorForStage: () => confidenceFloorForStage,
   confidenceTrajectory: () => confidenceTrajectory,
   deriveBeliefStage: () => deriveBeliefStage,
   derivedImpacts: () => derivedImpacts,
   emptyTestMeter: () => emptyTestMeter,
   experimentConfidence: () => experimentConfidence,
   experimentProgress: () => experimentProgress,
+  hasClearedThreshold: () => hasClearedThreshold,
+  inferQuestionType: () => inferQuestionType,
   isConcluded: () => isConcluded,
+  isNonEvidence: () => isNonEvidence,
+  migrateRegister: () => migrateRegister,
   missingCompletenessSlots: () => missingCompletenessSlots,
+  needsReview: () => needsReview,
   portfolioProgress: () => portfolioProgress,
   rankNextMoves: () => rankNextMoves,
   readingStrength: () => readingStrength,
   risk: () => risk,
+  riskThresholdForStage: () => riskThresholdForStage,
   round2: () => round2,
   scoreAndDedupe: () => scoreAndDedupe,
   sign: () => sign,
@@ -47,14 +59,114 @@ function round2(n) {
 }
 
 // src/derivation/rung.ts
+var Z = { Low: 0, Typical: 0, High: 0 };
+function band(low, typical, high) {
+  return { Low: low, Typical: typical, High: high };
+}
 var RUNG_ANCHOR = {
-  Talk: { Low: 3, Typical: 6, High: 10 },
-  "Desk research": { Low: 15, Typical: 15, High: 15 },
-  "Signed up": { Low: 30, Typical: 50, High: 70 },
-  "Observed usage": { Low: 30, Typical: 50, High: 70 },
-  "Signed intent": { Low: 30, Typical: 50, High: 70 },
-  "Paying users": { Low: 30, Typical: 50, High: 70 }
+  Existence: {
+    Talk: band(10, 20, 30),
+    "Desk research": band(15, 15, 15),
+    "Signed up": Z,
+    "Observed usage": band(20, 35, 50),
+    "Signed intent": Z,
+    "Paying users": Z
+  },
+  Prevalence: {
+    Talk: Z,
+    "Desk research": band(15, 15, 15),
+    "Signed up": Z,
+    "Observed usage": band(25, 40, 50),
+    "Signed intent": Z,
+    "Paying users": Z
+  },
+  CausalEffect: {
+    Talk: Z,
+    "Desk research": Z,
+    "Signed up": Z,
+    "Observed usage": band(30, 50, 70),
+    "Signed intent": band(30, 50, 70),
+    "Paying users": band(50, 70, 90)
+  },
+  WillingnessToPay: {
+    Talk: Z,
+    "Desk research": Z,
+    "Signed up": band(30, 50, 70),
+    "Observed usage": Z,
+    "Signed intent": band(50, 70, 85),
+    "Paying users": band(75, 88, 99)
+  },
+  ValueUtility: {
+    Talk: band(10, 20, 30),
+    "Desk research": Z,
+    "Signed up": Z,
+    "Observed usage": band(30, 50, 70),
+    "Signed intent": Z,
+    "Paying users": Z
+  },
+  Regulatory: {
+    Talk: Z,
+    "Desk research": band(30, 50, 70),
+    "Signed up": Z,
+    "Observed usage": Z,
+    "Signed intent": Z,
+    "Paying users": Z
+  },
+  Feasibility: {
+    Talk: Z,
+    "Desk research": band(15, 15, 15),
+    "Signed up": Z,
+    "Observed usage": band(30, 50, 70),
+    "Signed intent": Z,
+    "Paying users": Z
+  }
+};
+function isNonEvidence(questionType, rung) {
+  const anchors = RUNG_ANCHOR[questionType]?.[rung];
+  if (!anchors) return false;
+  return anchors.Low === 0 && anchors.Typical === 0 && anchors.High === 0;
+}
+function ceilingAnchor(questionType, rung) {
+  return RUNG_ANCHOR[questionType]?.[rung]?.High ?? 0;
+}
+var RISK_THRESHOLD_BY_STAGE = {
+  Discovery: 30,
+  // two-way door — act on weak evidence
+  Validation: 15,
+  // becoming one-way — need more before committing
+  Scale: 10,
+  // one-way door — strong evidence before scaling
+  Maturity: 5
+  // defensive, often regulatory — strongest evidence
+};
+var CONFIDENCE_FLOOR_BY_STAGE = {
+  Discovery: 10,
+  // any signal counts for a two-way door
+  Validation: 25,
+  // need a real reading, not just vibes
+  Scale: 40,
+  // need solid evidence before scaling
+  Maturity: 60
+  // need strong evidence for a one-way door
 };
+function riskThresholdForStage(stage) {
+  if (stage && stage in RISK_THRESHOLD_BY_STAGE) {
+    return RISK_THRESHOLD_BY_STAGE[stage];
+  }
+  return RISK_THRESHOLD_BY_STAGE.Maturity;
+}
+function confidenceFloorForStage(stage) {
+  if (stage && stage in CONFIDENCE_FLOOR_BY_STAGE) {
+    return CONFIDENCE_FLOOR_BY_STAGE[stage];
+  }
+  return CONFIDENCE_FLOOR_BY_STAGE.Maturity;
+}
+function hasClearedThreshold(risk2, stage, confidence2) {
+  const riskCleared = risk2 <= riskThresholdForStage(stage);
+  if (confidence2 === void 0) return riskCleared;
+  const confCleared = confidence2 >= confidenceFloorForStage(stage);
+  return riskCleared && confCleared;
+}
 
 // src/derivation/completeness.ts
 var COMPLETENESS_SLOTS = [
@@ -62,7 +174,8 @@ var COMPLETENESS_SLOTS = [
   "Lens",
   "Impact",
   "Scoring justification",
-  "Dependencies traced"
+  "Dependencies traced",
+  "Question Type"
 ];
 function hasText(value) {
   return typeof value === "string" && value.trim().length > 0;
@@ -79,7 +192,8 @@ function completenessSlotPresence(record) {
     Lens: hasText(record.Lens),
     Impact: hasNumber(record.Impact),
     "Scoring justification": hasText(record["Scoring justification"]),
-    "Dependencies traced": hasAny(record.dependsOnIds) || hasAny(record.enablesIds)
+    "Dependencies traced": hasAny(record.dependsOnIds) || hasAny(record.enablesIds),
+    "Question Type": hasText(record["Question Type"])
   };
 }
 function missingCompletenessSlots(record) {
@@ -107,8 +221,271 @@ function isConcluded(result) {
 function readingStrength(input) {
   const s = sign(input.result);
   if (s === 0) return 0;
-  const band = input.magnitudeBand ?? "Typical";
-  return (RUNG_ANCHOR[input.rung]?.[band] ?? 0) * s;
+  const band2 = input.magnitudeBand ?? "Typical";
+  return (RUNG_ANCHOR[input.questionType]?.[input.rung]?.[band2] ?? 0) * s;
+}
+
+// src/derivation/question-type.ts
+var DEFAULT_QUESTION_TYPE = "Existence";
+var RULES = [
+  {
+    type: "Regulatory",
+    patterns: [
+      /\bregulat(?:or|ion)\s+(?:prohibits|rul(?:es|ed)\s+against)\b/,
+      /\bregulator\b.*\bagainst\b/,
+      /\bcompliance\s+audit\s+fails?\b/,
+      /\bprohibits?\b.*\bscoring\b/,
+      // Positive bar patterns (the register's rightIf text):
+      /\bregulat(?:or|ion)s?\s+(?:approve|accept|confirm|permit)\b/,
+      /\bfca\b.*\bconfirm\b/,
+      /\blegal\s+opinion\b.*\bstate/i,
+      /\bnon[-\s]?compliant\b.*\boutputs?\b/,
+      /\bconduct\s+layer\b.*\b(?:safe|within|comply)\b/,
+      /\bconsumer\s+duty\b/,
+      /\bguardrails?\b.*\b(?:regulat|comply|within)\b/,
+      /\beducation\b.*\bguidance\b.*\bwithin\b/
+    ]
+  },
+  {
+    type: "WillingnessToPay",
+    patterns: [
+      /\b(?:don't|do not|won't|will not)\s+pay\b/,
+      /\bfake[-\s]?door\s+(?:signup\s+)?rate\s+below\b/,
+      /\bfake[-\s]?door\b.*\brate\b/,
+      /\bdon't\s+sign\s+up\b/,
+      /\bno\s+(?:buyer|user)s?\s+(?:sign|pay|commit)\b/,
+      /\bsigns?\s+(?:an\s+)?loi\b/,
+      /\bput(?:s|ting)?\s+down\s+(?:a\s+)?deposit\b/,
+      /\bdon't\s+commit\b/,
+      /\boffered\s+users?\s+pay\b/,
+      /\bpay(?:ing)?\s+(?:rate|share)?\s*(?:is\s+)?below\b/,
+      /\bfewer\s+than\s+\d+\s+of\s+\d+\s+offered\s+users?\s+pay\b/,
+      // Positive bar patterns:
+      /\bsign\s+(?:a\s+)?(?:design[-\s]?partner|pilot)\s+agreement\b/,
+      /\bsigned\s+intent\b/i,
+      /\bcommit(?:s|ting)?\s+(?:before|to\s+pay|to\s+a)\b/,
+      /\badopt\s*(?:and\s*)?pay\b/,
+      /\bpay\s+for\b.*\b(?:layer|harness|governed)\b/,
+      /\bagree\s+(?:in\s+writing|to\s+ingest|to\s+sign)\b/,
+      /\b(?:design|pilot)\s+partner\b.*\bagreement\b/
+    ]
+  },
+  {
+    type: "ValueUtility",
+    patterns: [
+      /\bstop\s+using\s+(?:it|the)\b/,
+      /\bdrop[-\s]?off\s+exceeds\b/,
+      /\bsustained\s+usage\s+falls?\s+below\b/,
+      /\bretention\s+(?:drops?|falls?)\s+below\b/,
+      /\bweek-\d+\s+retention\s+drops?\s+below\b/,
+      /\bdisuse\b/,
+      // Positive bar patterns:
+      /\bengage\s+(?:turn[-\s]by[-\s]turn|with|positively)\b/i,
+      /\bengage(?:s|ment)?\s+with\b/i,
+      /\breact\s+positively\b/i,
+      /\bcomfortable\s+with\b.*\b(?:bank|storing|context)\b/i,
+      /\bchoose\s+(?:voice|as\s+their\s+primary)\b/i,
+      /\bsustained\s+(?:retention|usage|engagement)\b/i,
+      /\bcome\s+back\b.*\bsession/i,
+      /\bprefer\b.*\b(?:modality|interface|experience)\b/i
+    ]
+  },
+  {
+    type: "CausalEffect",
+    patterns: [
+      /\btreatment\s+group(?:'s)?\s+doesn'?t\s+differ\s+from\s+control\b/,
+      /\bno\s+causal\s+effect\s+of\b/,
+      /\bvariant\s+doesn'?t\s+outperform\s+control\b/,
+      /\bdiffer\s+from\s+control\b/,
+      /\boutperform\s+control\b/,
+      /\btreatment\s+vs\.?\s+control\b/,
+      // Positive bar patterns:
+      /\bbeats?\s+(?:a\s+)?\w+[-\s]only\s+(?:model|baseline|control)\b/i,
+      /\brelative\s+lift\b/i,
+      /\breplicated\s+in\b.*\bcohort/i,
+      /\bwins?\s+≥?\s*\d+\s*[×x]\b/i,
+      /\bframing\s+wins\b/i
+    ]
+  },
+  {
+    type: "Prevalence",
+    patterns: [
+      /\brate\s+is\s+below\b/,
+      /\bfewer\s+than\s+\d+\s+of\s+\d+\s+(?:interviewed|surveyed|of)\b/,
+      /\bfewer\s+than\s+\d+%\s+of\s+\w+\s+hit\b/,
+      /\bthe\s+(?:rate|share|proportion)\s+is\s+below\b/,
+      /\b(?:in\s+)?surveyed\s+teams\b/,
+      /\bshare\s+(?:of\s+\w+\s+)?(?:is\s+)?below\b/,
+      /\bproportion\s+is\s+below\b/,
+      // Positive bar patterns:
+      /\b[≥>]\s*\d+%\s+of\b/i,
+      /\b[≥>]\s*\d+\s+of\b/i,
+      /\bnamed\b.*\b(?:as|in)\s+a\s+top[-\s]\d\b/i,
+      /\b[≥>]\s*\d+\s+(?:of\s+\d+\s+)?(?:institutions?|consumers?|users?|buyers?|banks?|teams?)\b/i
+    ]
+  },
+  {
+    type: "Feasibility",
+    patterns: [
+      /\bcan'?t\s+complete\s+the\s+flow\b/,
+      /\bsystem\s+can'?t\s+(?:do|ingest|handle|build)\b/,
+      /\bcan'?t\s+be\s+built\b/,
+      /\bcan'?t\s+ingest\b/,
+      /\bprototype\s+can'?t\s+be\s+built\b/,
+      /\bcan'?t\s+\w+\s+(?:unaided|without\s+(?:help|regressions))\b/,
+      // Positive bar patterns:
+      /\bcomplete\s+the\s+(?:flow|setup|wizard)\b.*\b(?:unaided|without\s+help)\b/i,
+      /\bingest\b.*\b(?:rows?|records?)\b.*\b(?:under|in)\s+\d+/i,
+      /\b(?:can|able\s+to)\s+(?:build|ship|deliver)\b.*\b(?:without|no)\s+(?:regress|break)/i
+    ]
+  },
+  {
+    type: "Existence",
+    patterns: [
+      /\bno\s+one\s+(?:we\s+interview\s+)?(?:describes|reports|mentions)\b/,
+      /\bno\s+interviewee(?:s)?\s+(?:describe|report|mention)s?\b/,
+      /\bcan'?t\s+describe\s+the\s+mechanism\b/,
+      /\bno\s+one\s+reports\s+caring\b/,
+      /\bno\s+one\s+describes\b/,
+      // Positive bar patterns:
+      /\bindependently\s+states?\b.*\b(?:needs?|wants?|values?|sees)\b/i,
+      /\bindependently\s+(?:report|state|confirm)s?\b/i,
+      /\bsay\s+they'?d\s+(?:be\s+)?(?:comfortable|prefer)\b/i,
+      /\b(?:credible|independent)\b.*\b(?:states?|reports?|confirms?)\b/i
+    ]
+  }
+];
+function normalize(s) {
+  return s.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function inferQuestionType(description, wrongIfBar) {
+  const bar = normalize(wrongIfBar ?? "");
+  const desc = normalize(description ?? "");
+  const hay = bar.length > 0 ? `${bar} ${desc}` : desc;
+  for (const rule of RULES) {
+    for (const re of rule.patterns) {
+      if (re.test(hay)) return rule.type;
+    }
+  }
+  return DEFAULT_QUESTION_TYPE;
+}
+var INFERABLE_QUESTION_TYPES = [
+  "Existence",
+  "Prevalence",
+  "CausalEffect",
+  "WillingnessToPay",
+  "ValueUtility",
+  "Regulatory",
+  "Feasibility"
+];
+function needsReview(description, wrongIfBar, inferred) {
+  if (wrongIfBar == null || wrongIfBar.trim() === "") return true;
+  const bar = normalize(wrongIfBar);
+  for (const rule of RULES) {
+    if (rule.type === inferred) {
+      for (const re of rule.patterns) {
+        if (re.test(bar)) return false;
+      }
+    }
+  }
+  return true;
+}
+
+// src/derivation/migrate.ts
+function migrateRegister(assumptions, readings) {
+  const questionTypeById = /* @__PURE__ */ new Map();
+  const reviewNeededById = /* @__PURE__ */ new Set();
+  for (const a of assumptions) {
+    const existing = a["Question Type"];
+    let qt;
+    let review = false;
+    if (existing && ["Existence", "Prevalence", "CausalEffect", "WillingnessToPay", "ValueUtility", "Regulatory", "Feasibility"].includes(existing)) {
+      qt = existing;
+    } else {
+      qt = inferQuestionType(a.Description ?? "", a.wrongIfBar ?? "");
+      review = needsReview(a.Description ?? "", a.wrongIfBar ?? "", qt);
+      if (review) reviewNeededById.add(a.id);
+    }
+    questionTypeById.set(a.id, qt);
+  }
+  const migratedReadings = [];
+  let nonEvidenceFlagCount = 0;
+  for (const r of readings) {
+    const questionType = questionTypeById.get(r.assumptionId) ?? "Existence";
+    const band2 = r.magnitudeBand ?? "Typical";
+    const newStrength = readingStrength({
+      questionType,
+      rung: r.Rung,
+      result: r.Result,
+      magnitudeBand: band2
+    });
+    const oldStrength = r.derived?.strength ?? 0;
+    const nonEvidence = isNonEvidence(questionType, r.Rung);
+    if (nonEvidence) nonEvidenceFlagCount += 1;
+    migratedReadings.push({
+      id: r.id,
+      assumptionId: r.assumptionId,
+      Rung: r.Rung,
+      newStrength,
+      oldStrength,
+      nonEvidence
+    });
+  }
+  const inputsByAssumption = /* @__PURE__ */ new Map();
+  for (const a of assumptions) inputsByAssumption.set(a.id, []);
+  for (const r of readings) {
+    const questionType = questionTypeById.get(r.assumptionId) ?? "Existence";
+    inputsByAssumption.get(r.assumptionId)?.push({
+      id: r.id,
+      source: r.Source,
+      rung: r.Rung,
+      result: r.Result,
+      questionType,
+      representativeness: r.Representativeness,
+      credibility: r.Credibility,
+      date: r.Date,
+      magnitudeBand: r.magnitudeBand ?? void 0,
+      experimentId: r.experimentId
+    });
+  }
+  const migratedAssumptions = assumptions.map((a) => {
+    const questionType = questionTypeById.get(a.id) ?? "Existence";
+    const oldConfidence = a.derived?.confidence ?? 0;
+    const newConfidence = confidence(inputsByAssumption.get(a.id) ?? []);
+    const stage = a.Stage ?? null;
+    return {
+      ...a,
+      "Question Type": questionType,
+      questionTypeReviewNeeded: reviewNeededById.has(a.id),
+      newConfidence,
+      oldConfidence,
+      confidenceDelta: Math.round((newConfidence - oldConfidence) * 100) / 100,
+      riskThreshold: riskThresholdForStage(stage)
+    };
+  });
+  const confidenceDeltas = migratedAssumptions.map((a) => ({
+    id: a.id,
+    delta: a.confidenceDelta,
+    oldConfidence: a.oldConfidence,
+    newConfidence: a.newConfidence
+  })).sort((a, b) => Math.abs(b.delta) - Math.abs(a.delta));
+  const oldRanked = [...assumptions].map((a) => ({ id: a.id, c: a.derived?.confidence ?? 0 })).sort((a, b) => b.c - a.c || a.id.localeCompare(b.id));
+  const newRanked = [...migratedAssumptions].map((a) => ({ id: a.id, c: a.newConfidence })).sort((a, b) => b.c - a.c || a.id.localeCompare(b.id));
+  const oldRank = new Map(oldRanked.map((r, i) => [r.id, i + 1]));
+  const newRank = new Map(newRanked.map((r, i) => [r.id, i + 1]));
+  const rankingShifts = migratedAssumptions.map((a) => {
+    const o = oldRank.get(a.id) ?? 0;
+    const n = newRank.get(a.id) ?? 0;
+    return { id: a.id, oldRank: o, newRank: n, shift: n - o };
+  }).filter((r) => r.oldRank > 0 && r.newRank > 0).sort((a, b) => Math.abs(b.shift) - Math.abs(a.shift));
+  return {
+    assumptions: migratedAssumptions,
+    readings: migratedReadings,
+    nonEvidenceFlagCount,
+    reviewQueueCount: reviewNeededById.size,
+    confidenceDeltas,
+    rankingShifts
+  };
 }
 
 // src/derivation/source-quality.ts
@@ -131,6 +508,16 @@ var TESTING_RUNGS = [
   "Observed usage"
 ];
 var MARKET_RUNG_VALUES = ["Signed intent", "Paying users"];
+var STAGES = ["Discovery", "Validation", "Scale", "Maturity"];
+var QUESTION_TYPES = [
+  "Existence",
+  "Prevalence",
+  "CausalEffect",
+  "WillingnessToPay",
+  "ValueUtility",
+  "Regulatory",
+  "Feasibility"
+];
 
 // src/derivation/confidence.ts
 var MARKET_RUNG_SET = new Set(MARKET_RUNG_VALUES);
@@ -615,6 +1002,8 @@ export {
   REGISTERS,
   TESTING_RUNGS,
   MARKET_RUNG_VALUES,
+  STAGES,
+  QUESTION_TYPES,
   COMPLETENESS_SLOTS,
   completenessSlotPresence,
   missingCompletenessSlots,
@@ -622,9 +1011,21 @@ export {
   assumptionComplete,
   round2,
   RUNG_ANCHOR,
+  isNonEvidence,
+  ceilingAnchor,
+  RISK_THRESHOLD_BY_STAGE,
+  CONFIDENCE_FLOOR_BY_STAGE,
+  riskThresholdForStage,
+  confidenceFloorForStage,
+  hasClearedThreshold,
   sign,
   isConcluded,
   readingStrength,
+  DEFAULT_QUESTION_TYPE,
+  inferQuestionType,
+  INFERABLE_QUESTION_TYPES,
+  needsReview,
+  migrateRegister,
   sourceQuality,
   W0_BY_RUNG,
   w0ForRung,
@@ -651,4 +1052,4 @@ export {
   assembleJourney,
   derivation_exports
 };
-//# sourceMappingURL=chunk-HMAHBGOJ.js.map
+//# sourceMappingURL=chunk-TCKAMOAK.js.map