@lucern/confidence 1.0.28 → 1.0.30

package/dist/v1/index.js

@@ -135,14 +135,91 @@ function computeConditionalDeductionBaseRate(opinionA, ifTrue, ifFalse, fallback
 }
 function safeCorrectionTerm(numerator, denominator) {
   if (Math.abs(denominator) <= EPSILON) {
-    return void 0;
+    return;
   }
   const value = numerator / denominator;
   if (!Number.isFinite(value)) {
-    return void 0;
+    return;
   }
   return Math.max(0, value);
 }
+function correctionOrZero(numerator, denominator) {
+  return safeCorrectionTerm(numerator, denominator) ?? 0;
+}
+function hasNoConditionalDeductionCorrection(ifTrue, ifFalse) {
+  return ifTrue.b > ifFalse.b && ifTrue.d > ifFalse.d || ifTrue.b <= ifFalse.b && ifTrue.d <= ifFalse.d;
+}
+function usesLowerVacuousBranch(context) {
+  return context.projectedVacuousDeduction <= context.projectedConditionalA;
+}
+function usesLowerAntecedentBranch(context) {
+  return context.projectedAntecedent <= context.opinionA.a;
+}
+function computeTrueDominantDeductionCorrection(context) {
+  const beliefGap = context.ifTrue.b - context.ifFalse.b;
+  const disbeliefGap = context.ifFalse.d - context.ifTrue.d;
+  const lowerVacuous = usesLowerVacuousBranch(context);
+  const lowerAntecedent = usesLowerAntecedentBranch(context);
+  if (lowerVacuous && lowerAntecedent) {
+    return correctionOrZero(
+      context.opinionA.a * context.opinionA.u * (context.intermediateBelief - context.ifTrue.b),
+      context.projectedAntecedent * context.childBaseRate
+    );
+  }
+  if (lowerVacuous) {
+    return correctionOrZero(
+      context.opinionA.a * context.opinionA.u * (context.intermediateDisbelief - context.ifTrue.d) * beliefGap,
+      context.projectedAntecedentComplement * context.childBaseRate * disbeliefGap
+    );
+  }
+  if (lowerAntecedent) {
+    return correctionOrZero(
+      (1 - context.opinionA.a) * context.opinionA.u * (context.intermediateBelief - context.ifTrue.b) * disbeliefGap,
+      context.projectedAntecedent * (1 - context.childBaseRate) * beliefGap
+    );
+  }
+  return correctionOrZero(
+    (1 - context.opinionA.a) * context.opinionA.u * (context.intermediateDisbelief - context.ifTrue.d),
+    context.projectedAntecedentComplement * (1 - context.childBaseRate)
+  );
+}
+function computeFalseDominantDeductionCorrection(context) {
+  const beliefGap = context.ifFalse.b - context.ifTrue.b;
+  const disbeliefGap = context.ifTrue.d - context.ifFalse.d;
+  const lowerVacuous = usesLowerVacuousBranch(context);
+  const lowerAntecedent = usesLowerAntecedentBranch(context);
+  if (lowerVacuous && lowerAntecedent) {
+    return correctionOrZero(
+      (1 - context.opinionA.a) * context.opinionA.u * (context.intermediateDisbelief - context.ifTrue.d) * beliefGap,
+      context.projectedAntecedent * context.childBaseRate * disbeliefGap
+    );
+  }
+  if (lowerVacuous) {
+    return correctionOrZero(
+      (1 - context.opinionA.a) * context.opinionA.u * (context.intermediateBelief - context.ifTrue.b),
+      context.projectedAntecedentComplement * context.childBaseRate
+    );
+  }
+  if (lowerAntecedent) {
+    return correctionOrZero(
+      context.opinionA.a * context.opinionA.u * (context.intermediateDisbelief - context.ifTrue.d),
+      context.projectedAntecedent * (1 - context.childBaseRate)
+    );
+  }
+  return correctionOrZero(
+    context.opinionA.a * context.opinionA.u * (context.intermediateBelief - context.ifTrue.b) * disbeliefGap,
+    context.projectedAntecedentComplement * (1 - context.childBaseRate) * beliefGap
+  );
+}
+function computeConditionalDeductionCorrection(context) {
+  if (hasNoConditionalDeductionCorrection(context.ifTrue, context.ifFalse)) {
+    return 0;
+  }
+  if (context.ifTrue.b > context.ifFalse.b && context.ifTrue.d <= context.ifFalse.d) {
+    return computeTrueDominantDeductionCorrection(context);
+  }
+  return computeFalseDominantDeductionCorrection(context);
+}
 function conditionalDeduction(opinionA, ifTrue, ifFalse, fallbackBaseRate) {
   const fallbackChildBaseRate = childBaseRateFallback(
     ifTrue,
@@ -162,58 +239,18 @@ function conditionalDeduction(opinionA, ifTrue, ifFalse, fallbackBaseRate) {
   const intermediateUncertainty = opinionA.b * ifTrue.u + opinionA.d * ifFalse.u + opinionA.u * (ifTrue.u * opinionA.a + ifFalse.u * (1 - opinionA.a));
   const projectedVacuousDeduction = ifTrue.b * opinionA.a + ifFalse.b * (1 - opinionA.a) + childBaseRate * (ifTrue.u * opinionA.a + ifFalse.u * (1 - opinionA.a));
   const projectedConditionalA = ifTrue.b + childBaseRate * (1 - ifTrue.b - ifTrue.d);
-  let correction = 0;
-  if (ifTrue.b > ifFalse.b && ifTrue.d > ifFalse.d || ifTrue.b <= ifFalse.b && ifTrue.d <= ifFalse.d) {
-    correction = 0;
-  } else if (ifTrue.b > ifFalse.b && ifTrue.d <= ifFalse.d) {
-    const beliefGap = ifTrue.b - ifFalse.b;
-    const disbeliefGap = ifFalse.d - ifTrue.d;
-    if (projectedVacuousDeduction <= projectedConditionalA && projectedAntecedent <= opinionA.a) {
-      correction = safeCorrectionTerm(
-        opinionA.a * opinionA.u * (intermediateBelief - ifTrue.b),
-        projectedAntecedent * childBaseRate
-      ) ?? 0;
-    } else if (projectedVacuousDeduction <= projectedConditionalA && projectedAntecedent > opinionA.a) {
-      correction = safeCorrectionTerm(
-        opinionA.a * opinionA.u * (intermediateDisbelief - ifTrue.d) * beliefGap,
-        projectedAntecedentComplement * childBaseRate * disbeliefGap
-      ) ?? 0;
-    } else if (projectedVacuousDeduction > projectedConditionalA && projectedAntecedent <= opinionA.a) {
-      correction = safeCorrectionTerm(
-        (1 - opinionA.a) * opinionA.u * (intermediateBelief - ifTrue.b) * disbeliefGap,
-        projectedAntecedent * (1 - childBaseRate) * beliefGap
-      ) ?? 0;
-    } else {
-      correction = safeCorrectionTerm(
-        (1 - opinionA.a) * opinionA.u * (intermediateDisbelief - ifTrue.d),
-        projectedAntecedentComplement * (1 - childBaseRate)
-      ) ?? 0;
-    }
-  } else {
-    const beliefGap = ifFalse.b - ifTrue.b;
-    const disbeliefGap = ifTrue.d - ifFalse.d;
-    if (projectedVacuousDeduction <= projectedConditionalA && projectedAntecedent <= opinionA.a) {
-      correction = safeCorrectionTerm(
-        (1 - opinionA.a) * opinionA.u * (intermediateDisbelief - ifTrue.d) * beliefGap,
-        projectedAntecedent * childBaseRate * disbeliefGap
-      ) ?? 0;
-    } else if (projectedVacuousDeduction <= projectedConditionalA && projectedAntecedent > opinionA.a) {
-      correction = safeCorrectionTerm(
-        (1 - opinionA.a) * opinionA.u * (intermediateBelief - ifTrue.b),
-        projectedAntecedentComplement * childBaseRate
-      ) ?? 0;
-    } else if (projectedVacuousDeduction > projectedConditionalA && projectedAntecedent <= opinionA.a) {
-      correction = safeCorrectionTerm(
-        opinionA.a * opinionA.u * (intermediateDisbelief - ifTrue.d),
-        projectedAntecedent * (1 - childBaseRate)
-      ) ?? 0;
-    } else {
-      correction = safeCorrectionTerm(
-        opinionA.a * opinionA.u * (intermediateBelief - ifTrue.b) * disbeliefGap,
-        projectedAntecedentComplement * (1 - childBaseRate) * beliefGap
-      ) ?? 0;
-    }
-  }
+  const correction = computeConditionalDeductionCorrection({
+    childBaseRate,
+    ifFalse,
+    ifTrue,
+    intermediateBelief,
+    intermediateDisbelief,
+    opinionA,
+    projectedAntecedent,
+    projectedAntecedentComplement,
+    projectedConditionalA,
+    projectedVacuousDeduction
+  });
   return opinion(
     intermediateBelief - childBaseRate * correction,
     intermediateDisbelief - (1 - childBaseRate) * correction,
@@ -353,7 +390,7 @@ function toEpochMs(value) {
     const epochMs = value.getTime();
     return Number.isFinite(epochMs) ? epochMs : void 0;
   }
-  return void 0;
+  return;
 }
 function normalizeHalfLifeMs(halfLifeMs) {
   if (halfLifeMs === void 0 || !Number.isFinite(halfLifeMs)) {
@@ -375,9 +412,14 @@ function temporalDecay(sourceOpinion, now, decayParams) {
   if (ageMs === 0) {
     return { ...sourceOpinion };
   }
-  const retainedEvidenceWeight = Math.pow(0.5, ageMs / halfLifeMs);
+  const retainedEvidenceWeight = 0.5 ** (ageMs / halfLifeMs);
   return trustDiscount(
-    mkOpinion(sourceOpinion.b, sourceOpinion.d, sourceOpinion.u, sourceOpinion.a),
+    mkOpinion(
+      sourceOpinion.b,
+      sourceOpinion.d,
+      sourceOpinion.u,
+      sourceOpinion.a
+    ),
     retainedEvidenceWeight
   );
 }
@@ -408,7 +450,9 @@ function normalizeBaseRateVector(baseRate, size) {
   const normalized = baseRate.map((value) => clampNonNegative(value));
   const total = normalized.reduce((sum, value) => sum + value, 0);
   if (total === 0) {
-    throw new Error("Base-rate vector must contain at least one positive value.");
+    throw new Error(
+      "Base-rate vector must contain at least one positive value."
+    );
   }
   return normalized.map((value) => value / total);
 }
@@ -437,11 +481,10 @@ function projectDirichletOpinion(opinion2) {
   );
 }
 function opinionFromBeta(alpha, beta, nonInformativeWeight, baseRate) {
-  const dirichlet = opinionFromDirichlet(
-    [alpha, beta],
-    nonInformativeWeight,
-    [clamp01(baseRate), 1 - clamp01(baseRate)]
-  );
+  const dirichlet = opinionFromDirichlet([alpha, beta], nonInformativeWeight, [
+    clamp01(baseRate),
+    1 - clamp01(baseRate)
+  ]);
   return mkOpinion(
     dirichlet.b[0] ?? 0,
     dirichlet.b[1] ?? 0,
@@ -464,417 +507,542 @@ function betaFromOpinion(opinion2, nonInformativeWeight = DEFAULT_NON_INFORMATIV
   };
 }
 
-// src/v1/operations/scoring.ts
-function finiteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+// src/v1/operations/contracts/epistemicContract.ts
+var BUILT_IN_EVIDENTIAL_EVALUATOR = "evidential";
+var BUILT_IN_EVIDENTIAL_ALIASES = /* @__PURE__ */ new Set([
+  BUILT_IN_EVIDENTIAL_EVALUATOR,
+  "built_in_evidential",
+  "builtin_evidential"
+]);
+var BUILT_IN_METRIC_CHECKER = "metric_checker";
+var BUILT_IN_REFERENCE_CHECK_COUNTER = "reference_check_counter";
+var BUILT_IN_TEMPORAL_DEADLINE = "temporal_deadline";
+var BUILT_IN_MARKET_INDEX_COMPARATOR = "market_index_comparator";
+function clampConfidence(value) {
+  return Math.max(0, Math.min(1, value));
 }
-function requiredOpinionNumber(label, ...values) {
-  for (const value of values) {
-    const numberValue = finiteNumber(value);
-    if (numberValue !== void 0) {
-      return numberValue;
-    }
+function generateContractId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
   }
-  throw new Error(`Opinion record is missing required ${label}.`);
+  return `contract-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
 }
-function clamp012(value) {
-  return Math.max(0, Math.min(1, value));
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function confidenceFromOpinion(opinion2) {
-  return clamp012(opinion2.b + opinion2.a * opinion2.u);
+function deriveContractStatus(result, currentStatus) {
+  if (currentStatus === "archived") {
+    return currentStatus;
+  }
+  switch (result) {
+    case "confirmed":
+      return "satisfied";
+    case "disconfirmed":
+      return "violated";
+    case "expired":
+      return "expired";
+    default:
+      if (currentStatus === "satisfied" || currentStatus === "violated" || currentStatus === "expired") {
+        return "active";
+      }
+      return currentStatus;
+  }
 }
-function confidenceFromSL(belief, _disbelief, uncertainty, baseRate) {
-  return confidenceFromOpinion({
-    b: belief,
-    u: uncertainty,
-    a: baseRate
-  });
+function deriveVerificationTrigger(result) {
+  switch (result) {
+    case "confirmed":
+      return "verification_confirmed";
+    case "disconfirmed":
+      return "verification_disconfirmed";
+    case "expired":
+      return "verification_expired";
+    case "partial":
+      return "verification_partial";
+    default:
+      return null;
+  }
 }
-function toStoredOpinionFields(opinion2) {
+function deriveContractModulationPlan(args) {
+  const trigger = deriveVerificationTrigger(args.result);
+  if (!trigger) {
+    return null;
+  }
+  if (args.result === "confirmed") {
+    const rawNext = args.currentConfidence + args.modulation.onConfirmed.delta;
+    const confidenceAfter = clampConfidence(
+      Math.min(
+        args.modulation.onConfirmed.ceiling ?? Number.POSITIVE_INFINITY,
+        rawNext
+      )
+    );
+    return {
+      trigger,
+      confidenceBefore: args.currentConfidence,
+      confidenceAfter,
+      confidenceDelta: confidenceAfter - args.currentConfidence
+    };
+  }
+  if (args.result === "disconfirmed") {
+    const rawNext = args.currentConfidence + args.modulation.onDisconfirmed.delta;
+    const confidenceAfter = clampConfidence(
+      Math.max(args.modulation.onDisconfirmed.floor ?? 0, rawNext)
+    );
+    return {
+      trigger,
+      confidenceBefore: args.currentConfidence,
+      confidenceAfter,
+      confidenceDelta: confidenceAfter - args.currentConfidence
+    };
+  }
+  if (args.result === "expired" && args.modulation.onExpired) {
+    const confidenceAfter = clampConfidence(
+      args.currentConfidence + args.modulation.onExpired.delta
+    );
+    return {
+      trigger,
+      confidenceBefore: args.currentConfidence,
+      confidenceAfter,
+      confidenceDelta: confidenceAfter - args.currentConfidence
+    };
+  }
+  if (args.result === "partial" && args.modulation.onPartial) {
+    if ((args.resultConfidence ?? 0) < args.modulation.onPartial.threshold) {
+      return null;
+    }
+    const confidenceAfter = clampConfidence(
+      args.currentConfidence + args.modulation.onPartial.delta
+    );
+    return {
+      trigger,
+      confidenceBefore: args.currentConfidence,
+      confidenceAfter,
+      confidenceDelta: confidenceAfter - args.currentConfidence
+    };
+  }
+  return null;
+}
+function createInheritedContractRecord(contract, args) {
   return {
-    belief: opinion2.b,
-    disbelief: opinion2.d,
-    uncertainty: opinion2.u,
-    baseRate: opinion2.a
+    beliefNodeId: args.beliefNodeId,
+    contractId: generateContractId(),
+    title: contract.title,
+    description: contract.description,
+    conditionType: contract.conditionType,
+    direction: contract.direction,
+    condition: contract.condition,
+    deadline: contract.deadline,
+    compositeOf: contract.compositeOf,
+    compositeOperator: contract.compositeOperator,
+    modulation: contract.modulation,
+    evaluationSchedule: contract.evaluationSchedule,
+    periodicIntervalMs: contract.periodicIntervalMs,
+    status: "active",
+    lineageSource: "inherited",
+    inheritedFromContractId: contract.contractId,
+    inheritedFromBeliefNodeId: contract.beliefNodeId,
+    inheritedAt: args.now,
+    topicId: args.topicId,
+    createdAt: args.now,
+    createdBy: args.createdBy,
+    updatedAt: args.now
   };
 }
-function readOpinionFromRecord(source) {
-  const record = source && typeof source === "object" ? source : {};
-  return mkOpinion(
-    requiredOpinionNumber(
-      "belief",
-      record.b,
-      record.belief,
-      record.slBelief,
-      record.opinion_b
-    ),
-    requiredOpinionNumber(
-      "disbelief",
-      record.d,
-      record.disbelief,
-      record.slDisbelief,
-      record.opinion_d
-    ),
-    requiredOpinionNumber(
-      "uncertainty",
-      record.u,
-      record.uncertainty,
-      record.slUncertainty,
-      record.opinion_u
-    ),
-    requiredOpinionNumber(
-      "baseRate",
-      record.a,
-      record.baseRate,
-      record.slBaseRate,
-      record.opinion_a
-    )
+function normalizeEvidentialAction(value) {
+  return value === "append_sl_scoring" || value === "flag_review" || value === "archive" ? value : void 0;
+}
+function parseComparisonOperator(value, evaluatorName) {
+  if (value === "gte" || value === "lte" || value === "eq" || value === "gt" || value === "lt") {
+    return value;
+  }
+  throw new Error(
+    `${evaluatorName} requires operator to be one of gte, lte, eq, gt, or lt.`
   );
 }
-function opinionFromScalar(value, mode, options) {
-  const clampedValue = clamp012(value);
-  const baseRate = options?.baseRate === void 0 ? void 0 : clamp012(options.baseRate);
-  switch (mode) {
-    case "base_rate":
-      return mkOpinion(0, 0, 1, clampedValue);
-    case "dogmatic":
-      if (baseRate === void 0) {
-        throw new Error('opinionFromScalar(value, "dogmatic") requires options.baseRate.');
-      }
-      return mkOpinion(clampedValue, 1 - clampedValue, 0, baseRate);
-    case "projected_with_u": {
-      if (baseRate === void 0) {
-        throw new Error(
-          'opinionFromScalar(value, "projected_with_u") requires options.baseRate.'
-        );
-      }
-      const uncertainty = options?.uncertainty;
-      if (uncertainty === void 0) {
-        throw new Error(
-          'opinionFromScalar(value, "projected_with_u") requires options.uncertainty.'
-        );
-      }
-      const clampedUncertainty = clamp012(uncertainty);
-      const evidenceWeight = 1 - clampedUncertainty;
-      return mkOpinion(
-        clampedValue * evidenceWeight,
-        (1 - clampedValue) * evidenceWeight,
-        clampedUncertainty,
-        baseRate
-      );
+function parseNumericThreshold(value, evaluatorName) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  throw new Error(`${evaluatorName} requires a finite numeric threshold.`);
+}
+function pickFiniteNumber(config, keys) {
+  for (const key of keys) {
+    const value = config[key];
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
     }
   }
-  throw new Error(`Unsupported opinionFromScalar mode: ${mode}`);
+  return;
 }
-function toDogmaticOpinion(confidence, baseRate) {
-  return opinionFromScalar(confidence, "dogmatic", { baseRate });
+function getEvaluatorInputRecord(inputData, nestedKey) {
+  if (!isRecord(inputData)) {
+    return {};
+  }
+  const nested = inputData[nestedKey];
+  if (isRecord(nested)) {
+    return nested;
+  }
+  return inputData;
 }
-function opinionFromBaseRate(probability) {
-  return vacuous(clamp012(probability));
+function parseEvidentialEvaluatorConfig(value) {
+  if (!isRecord(value)) {
+    throw new Error(
+      "Evidential contracts require condition.evaluatorConfig with metric/operator/threshold."
+    );
+  }
+  const config = value;
+  const metric = config.metric;
+  const operator = config.operator;
+  const threshold = config.threshold;
+  if (metric !== "evidence_count" && metric !== "contradiction_status" && metric !== "edge_freshness" && metric !== "dependent_count") {
+    throw new Error(`Unsupported evidential metric: ${String(metric)}`);
+  }
+  if (operator !== "gte" && operator !== "lte" && operator !== "eq" && operator !== "gt" && operator !== "lt") {
+    throw new Error(`Unsupported evidential operator: ${String(operator)}`);
+  }
+  if (typeof threshold !== "number" || !Number.isFinite(threshold)) {
+    throw new Error("Evidential contracts require a numeric threshold.");
+  }
+  const actionParams = isRecord(config.actionParams) ? config.actionParams : void 0;
+  return {
+    metric,
+    operator,
+    threshold,
+    action: normalizeEvidentialAction(config.action),
+    actionParams: actionParams && (typeof actionParams.targetConfidence === "number" || typeof actionParams.rationale === "string") ? {
+      targetConfidence: typeof actionParams.targetConfidence === "number" ? actionParams.targetConfidence : void 0,
+      rationale: typeof actionParams.rationale === "string" ? actionParams.rationale : void 0
+    } : void 0
+  };
 }
-function opinionFromDogmatic(probability, baseRate) {
-  return dogmatic(clamp012(probability), clamp012(baseRate));
+function compareMetricValue(operator, left, right) {
+  switch (operator) {
+    case "gte":
+      return left >= right;
+    case "lte":
+      return left <= right;
+    case "eq":
+      return left === right;
+    case "gt":
+      return left > right;
+    case "lt":
+      return left < right;
+    default:
+      return false;
+  }
 }
-function opinionFromProjected(probability, uncertainty, baseRate) {
-  const p = clamp012(probability);
-  const u = clamp012(uncertainty);
-  const remainingMass = 1 - u;
-  return mkOpinion(p * remainingMass, (1 - p) * remainingMass, u, clamp012(baseRate));
+function resolveComparisonResult(direction, comparisonSatisfied) {
+  if (direction === "falsifies") {
+    return comparisonSatisfied ? "disconfirmed" : "confirmed";
+  }
+  return comparisonSatisfied ? "confirmed" : "disconfirmed";
 }
-function hasProjectedOpinionChanged(current, next, tolerance = 0.01) {
-  return Math.abs(confidenceFromOpinion(next) - confidenceFromOpinion(current)) >= tolerance;
+function buildComparisonRationale(args) {
+  const renderedObserved = args.observedValue === null ? "no data" : `${args.observedValue}${args.unit ? ` ${args.unit}` : ""}`;
+  const renderedThreshold = `${args.threshold}${args.unit ? ` ${args.unit}` : ""}`;
+  const clause = `${args.label} observed ${renderedObserved} against ${args.operator} ${renderedThreshold}`;
+  if (args.observedValue === null) {
+    return `${clause}; evaluator returned ${args.result} because no current data was available.`;
+  }
+  return `${clause}; comparison ${args.comparisonSatisfied ? "passed" : "failed"}, resulting in ${args.result}.`;
 }
-
-// src/v1/operations/contradiction/detectTupleContradiction.ts
-var DEFAULT_TUPLE_CONTRADICTION_BELIEF_THRESHOLD = 0.7;
-var DEFAULT_TUPLE_CONTRADICTION_DISBELIEF_THRESHOLD = 0.7;
-function normalizeTupleContradictionPolicy(policy = {}) {
+function buildEvidentialRationale(args) {
+  const observed = args.snapshot.value === null ? "no data" : String(args.snapshot.value);
+  const clause = `${args.snapshot.metric} observed ${observed} against ${args.config.operator} ${args.config.threshold}`;
+  if (args.snapshot.value === null) {
+    return `${clause}; evidential evaluator treated the comparison as unmet, resulting in ${args.result}.`;
+  }
+  return `${clause}; comparison ${args.comparisonSatisfied ? "passed" : "failed"}, resulting in ${args.result}.`;
+}
+function parseMetricCheckerConfig(value) {
+  if (!isRecord(value)) {
+    throw new Error(
+      "metric_checker requires condition.evaluatorConfig with observedValue/operator/threshold."
+    );
+  }
+  const config = value;
   return {
-    beliefThreshold: clamp012(
-      policy.beliefThreshold ?? DEFAULT_TUPLE_CONTRADICTION_BELIEF_THRESHOLD
-    ),
-    disbeliefThreshold: clamp012(
-      policy.disbeliefThreshold ?? DEFAULT_TUPLE_CONTRADICTION_DISBELIEF_THRESHOLD
-    )
+    metric: typeof config.metric === "string" && config.metric.length > 0 ? config.metric : void 0,
+    operator: parseComparisonOperator(config.operator, BUILT_IN_METRIC_CHECKER),
+    threshold: parseNumericThreshold(config.threshold, BUILT_IN_METRIC_CHECKER),
+    observedValue: pickFiniteNumber(config, ["observedValue", "value"]),
+    currentValue: pickFiniteNumber(config, ["currentValue"]),
+    metricValue: pickFiniteNumber(config, ["metricValue"]),
+    unit: typeof config.unit === "string" && config.unit.length > 0 ? config.unit : void 0
   };
 }
-function detectTupleContradiction(opinion2, tauB = DEFAULT_TUPLE_CONTRADICTION_BELIEF_THRESHOLD, tauD = DEFAULT_TUPLE_CONTRADICTION_DISBELIEF_THRESHOLD) {
-  return opinion2.b > tauB && opinion2.d > tauD;
-}
-function evaluateTupleContradictionTransition(args) {
-  const policy = normalizeTupleContradictionPolicy(args.policy);
-  const tupleContradicted = detectTupleContradiction(
-    args.opinion,
-    policy.beliefThreshold,
-    policy.disbeliefThreshold
-  );
-  const previousTupleContradicted = Boolean(args.previousTupleContradicted);
+function parseReferenceCheckCounterConfig(value) {
+  if (!isRecord(value)) {
+    throw new Error(
+      "reference_check_counter requires condition.evaluatorConfig with tag/operator/threshold."
+    );
+  }
+  const config = value;
+  if (typeof config.tag !== "string" || config.tag.trim().length === 0) {
+    throw new Error("reference_check_counter requires a non-empty tag.");
+  }
   return {
-    tupleContradicted,
-    crossedIntoTupleContradiction: !previousTupleContradicted && tupleContradicted,
-    crossedOutOfTupleContradiction: previousTupleContradicted && !tupleContradicted,
-    policy
+    tag: config.tag.trim(),
+    operator: parseComparisonOperator(
+      config.operator,
+      BUILT_IN_REFERENCE_CHECK_COUNTER
+    ),
+    threshold: parseNumericThreshold(
+      config.threshold,
+      BUILT_IN_REFERENCE_CHECK_COUNTER
+    ),
+    caseSensitive: config.caseSensitive === true
   };
 }
-
-// src/v1/operations/dynamics/cascade.ts
-function dampedDependencyOpinion(dependencyOpinion, beliefOpinion, mode = "continuous", threshold = 0.3) {
-  const dependencyProjection = project(
-    mkOpinion(
-      dependencyOpinion.b,
-      dependencyOpinion.d,
-      dependencyOpinion.u,
-      dependencyOpinion.a
-    )
-  );
-  if (mode === "threshold") {
-    if (dependencyProjection < threshold) {
-      return opinion(
-        0,
-        beliefOpinion.d + beliefOpinion.b * 0.5,
-        0.5,
-        beliefOpinion.a
-      );
-    }
-    return beliefOpinion;
+function parseTemporalDeadlineConfig(value) {
+  if (!isRecord(value)) {
+    return {};
   }
-  const dampingFactor = Math.pow(dependencyProjection, 0.5);
-  return opinion(
-    beliefOpinion.b * dampingFactor,
-    beliefOpinion.d + beliefOpinion.b * (1 - dampingFactor) * 0.3,
-    beliefOpinion.u + beliefOpinion.b * (1 - dampingFactor) * 0.7,
-    beliefOpinion.a
-  );
-}
-function dampedDependencyCascade(dependencyOpinion, beliefOpinion, mode = "continuous") {
+  const config = value;
   return {
-    opinion: dampedDependencyOpinion(dependencyOpinion, beliefOpinion, mode),
-    operator: "dependency_cascade",
-    rationale: `Damped dependency cascade (${mode}): prerequisite at ${project(
-      mkOpinion(
-        dependencyOpinion.b,
-        dependencyOpinion.d,
-        dependencyOpinion.u,
-        dependencyOpinion.a
-      )
-    ).toFixed(2)}`
+    label: typeof config.label === "string" && config.label.length > 0 ? config.label : void 0,
+    completed: config.completed === true,
+    completedAt: pickFiniteNumber(config, ["completedAt"]),
+    observedAt: pickFiniteNumber(config, ["observedAt"]),
+    satisfiedAt: pickFiniteNumber(config, ["satisfiedAt"]),
+    achievedAt: pickFiniteNumber(config, ["achievedAt"])
   };
 }
-
-// src/v1/operations/dynamics/defeat.ts
-function applyNegativeSupport(source, target, weight, metadata = {}) {
-  const sourceOpinion = mkOpinion(source.b, source.d, source.u, source.a);
-  const targetOpinion = mkOpinion(target.b, target.d, target.u, target.a);
-  if (metadata.constraint === "xor") {
-    const result = constraintFusion(
-      sourceOpinion,
-      targetOpinion,
-      metadata.normalization ?? "pressure"
+function parseMarketIndexComparatorConfig(value) {
+  if (!isRecord(value)) {
+    throw new Error(
+      "market_index_comparator requires condition.evaluatorConfig with subjectValue/benchmarkValue/operator/threshold."
     );
-    return {
-      opinion: result.o2,
-      operator: "constraint_fusion",
-      rationale: `XOR constraint: source belief at ${project(
-        sourceOpinion
-      ).toFixed(2)} pressures target`
-    };
   }
-  const discounted = trustDiscount(negate(sourceOpinion), Math.abs(weight));
+  const config = value;
   return {
-    opinion: cumulativeFusion(targetOpinion, discounted),
-    operator: "cumulative_fusion",
-    rationale: `Contradicting evidence (weight=${weight.toFixed(
-      2
-    )}) from source at ${project(sourceOpinion).toFixed(2)}`
-  };
-}
-function applyNegativeEvidence(source, target, weight) {
-  const sourceOpinion = mkOpinion(source.b, source.d, source.u, source.a);
-  const targetOpinion = mkOpinion(target.b, target.d, target.u, target.a);
-  const discounted = trustDiscount(negate(sourceOpinion), Math.abs(weight));
-  return {
-    opinion: cumulativeFusion(targetOpinion, discounted),
-    operator: "cumulative_fusion",
-    rationale: `Contradicting evidence (weight=${weight.toFixed(2)})`
+    subject: typeof config.subject === "string" && config.subject.length > 0 ? config.subject : void 0,
+    subjectValue: pickFiniteNumber(config, ["subjectValue", "leftValue"]),
+    primaryValue: pickFiniteNumber(config, ["primaryValue"]),
+    benchmark: typeof config.benchmark === "string" && config.benchmark.length > 0 ? config.benchmark : void 0,
+    benchmarkValue: pickFiniteNumber(config, ["benchmarkValue", "rightValue"]),
+    comparisonValue: pickFiniteNumber(config, ["comparisonValue"]),
+    operator: parseComparisonOperator(
+      config.operator,
+      BUILT_IN_MARKET_INDEX_COMPARATOR
+    ),
+    threshold: parseNumericThreshold(
+      config.threshold,
+      BUILT_IN_MARKET_INDEX_COMPARATOR
+    )
   };
 }
 
-// src/v1/operations/dynamics/propagation.ts
-var EDGE_PROPAGATION_RULES = {
-  supports: {
-    direction: "outgoing",
-    handler: (source, target, weight, metadata) => {
-      const sourceOpinion = mkOpinion(source.b, source.d, source.u, source.a);
-      const targetOpinion = mkOpinion(target.b, target.d, target.u, target.a);
-      if (weight < 0) {
-        return applyNegativeSupport(sourceOpinion, targetOpinion, weight, metadata);
-      }
-      const discounted = trustDiscount(sourceOpinion, weight);
-      return {
-        opinion: cumulativeFusion(targetOpinion, discounted),
-        operator: "cumulative_fusion",
-        rationale: `Supporting evidence (weight=${weight.toFixed(
-          2
-        )}) from source at ${project(sourceOpinion).toFixed(2)}`
-      };
+// src/v1/operations/scoring.ts
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function requiredOpinionNumber(label, ...values) {
+  for (const value of values) {
+    const numberValue = finiteNumber(value);
+    if (numberValue !== void 0) {
+      return numberValue;
     }
-  },
-  informs: {
-    direction: "outgoing",
-    handler: (source, target, weight) => {
-      const sourceOpinion = mkOpinion(source.b, source.d, source.u, source.a);
-      const targetOpinion = mkOpinion(target.b, target.d, target.u, target.a);
-      if (weight < 0) {
-        return applyNegativeEvidence(sourceOpinion, targetOpinion, weight);
+  }
+  throw new Error(`Opinion record is missing required ${label}.`);
+}
+function clamp012(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function confidenceFromOpinion(opinion2) {
+  return clamp012(opinion2.b + opinion2.a * opinion2.u);
+}
+function confidenceFromSL(belief, _disbelief, uncertainty, baseRate) {
+  return confidenceFromOpinion({
+    b: belief,
+    u: uncertainty,
+    a: baseRate
+  });
+}
+function toStoredOpinionFields(opinion2) {
+  return {
+    belief: opinion2.b,
+    disbelief: opinion2.d,
+    uncertainty: opinion2.u,
+    baseRate: opinion2.a
+  };
+}
+function readOpinionFromRecord(source) {
+  const record = source && typeof source === "object" ? source : {};
+  return mkOpinion(
+    requiredOpinionNumber(
+      "belief",
+      record.b,
+      record.belief,
+      record.slBelief,
+      record.opinion_b
+    ),
+    requiredOpinionNumber(
+      "disbelief",
+      record.d,
+      record.disbelief,
+      record.slDisbelief,
+      record.opinion_d
+    ),
+    requiredOpinionNumber(
+      "uncertainty",
+      record.u,
+      record.uncertainty,
+      record.slUncertainty,
+      record.opinion_u
+    ),
+    requiredOpinionNumber(
+      "baseRate",
+      record.a,
+      record.baseRate,
+      record.slBaseRate,
+      record.opinion_a
+    )
+  );
+}
+function opinionFromScalar(value, mode, options) {
+  const clampedValue = clamp012(value);
+  const baseRate = options?.baseRate === void 0 ? void 0 : clamp012(options.baseRate);
+  switch (mode) {
+    case "base_rate":
+      return mkOpinion(0, 0, 1, clampedValue);
+    case "dogmatic":
+      if (baseRate === void 0) {
+        throw new Error(
+          'opinionFromScalar(value, "dogmatic") requires options.baseRate.'
+        );
       }
-      const discounted = trustDiscount(sourceOpinion, Math.abs(weight));
-      return {
-        opinion: cumulativeFusion(targetOpinion, discounted),
-        operator: "cumulative_fusion",
-        rationale: `Supporting evidence (weight=${weight.toFixed(2)})`
-      };
-    }
-  },
-  depends_on: {
-    direction: "incoming",
-    handler: (source, target, _weight, metadata) => {
-      const sourceOpinion = mkOpinion(source.b, source.d, source.u, source.a);
-      const targetOpinion = mkOpinion(target.b, target.d, target.u, target.a);
-      if (metadata.conditionalA && metadata.conditionalNotA) {
-        return {
-          opinion: conditionalDeduction(
-            sourceOpinion,
-            mkOpinion(
-              metadata.conditionalA.b,
-              metadata.conditionalA.d,
-              metadata.conditionalA.u,
-              metadata.conditionalA.a
-            ),
-            mkOpinion(
-              metadata.conditionalNotA.b,
-              metadata.conditionalNotA.d,
-              metadata.conditionalNotA.u,
-              metadata.conditionalNotA.a
-            ),
-            targetOpinion.a
-          ),
-          operator: "conditional_deduction",
-          rationale: `Conditional deduction: prerequisite at ${project(
-            sourceOpinion
-          ).toFixed(2)}`
-        };
+      return mkOpinion(clampedValue, 1 - clampedValue, 0, baseRate);
+    case "projected_with_u": {
+      if (baseRate === void 0) {
+        throw new Error(
+          'opinionFromScalar(value, "projected_with_u") requires options.baseRate.'
+        );
       }
-      return dampedDependencyCascade(
-        sourceOpinion,
-        targetOpinion,
-        metadata.propagation ?? "continuous"
+      const uncertainty = options?.uncertainty;
+      if (uncertainty === void 0) {
+        throw new Error(
+          'opinionFromScalar(value, "projected_with_u") requires options.uncertainty.'
+        );
+      }
+      const clampedUncertainty = clamp012(uncertainty);
+      const evidenceWeight = 1 - clampedUncertainty;
+      return mkOpinion(
+        clampedValue * evidenceWeight,
+        (1 - clampedValue) * evidenceWeight,
+        clampedUncertainty,
+        baseRate
       );
     }
-  },
-  derived_from: {
-    direction: "incoming",
-    handler: (_source, target) => ({
-      opinion: target,
-      operator: "trust_discount",
-      rationale: "Provenance edge \u2014 no confidence propagation"
-    })
-  },
-  contains: {
-    direction: "outgoing",
-    handler: (_source, target) => ({
-      opinion: target,
-      operator: "trust_discount",
-      rationale: "Containment edge \u2014 no confidence propagation"
-    })
-  },
-  tests: {
-    direction: "outgoing",
-    handler: (_source, target) => ({
-      opinion: target,
-      operator: "trust_discount",
-      rationale: "Testing edge \u2014 no confidence propagation"
-    })
+    default:
+      throw new Error(`Unsupported opinionFromScalar mode: ${mode}`);
   }
-};
-var PROPAGATION_TRAVERSAL_SPECS = Object.entries(EDGE_PROPAGATION_RULES).map(([edgeType, rule]) => ({
-  edgeType,
-  direction: rule.direction
-}));
-function isPropagationEdgeType(edgeType) {
-  return edgeType in EDGE_PROPAGATION_RULES;
 }
-function getPropagationTraversalSpecs() {
-  return PROPAGATION_TRAVERSAL_SPECS;
+function toDogmaticOpinion(confidence, baseRate) {
+  return opinionFromScalar(confidence, "dogmatic", { baseRate });
 }
-function propagateThroughEdge(sourceOpinion, targetOpinion, edgeType, weight = 1, metadata = {}) {
-  const handler = isPropagationEdgeType(edgeType) ? EDGE_PROPAGATION_RULES[edgeType].handler : void 0;
-  if (!handler) {
-    return {
-      opinion: targetOpinion,
-      operator: "no_op",
-      rationale: `Unknown edge type: ${edgeType} \u2014 no propagation`
-    };
-  }
-  return handler(sourceOpinion, targetOpinion, weight, metadata);
+function opinionFromBaseRate(probability) {
+  return vacuous(clamp012(probability));
 }
-function propagateAllEdges(currentOpinion, incomingEdges) {
-  let result = currentOpinion;
-  const rationales = [];
-  for (const edgeType of ["depends_on", "informs", "supports"]) {
-    for (const incoming of incomingEdges.filter((edge) => edge.edgeType === edgeType)) {
-      const propagated = propagateThroughEdge(
-        incoming.sourceOpinion,
-        result,
-        incoming.edgeType,
-        incoming.weight,
-        incoming.metadata
-      );
-      result = propagated.opinion;
-      rationales.push(propagated.rationale);
-    }
-  }
-  return {
-    opinion: result,
-    operator: "cumulative_fusion",
-    rationale: rationales.join("; ")
-  };
+function opinionFromDogmatic(probability, baseRate) {
+  return dogmatic(clamp012(probability), clamp012(baseRate));
 }
-
-// src/v1/operations/dynamics/revision.ts
-function clamp013(value) {
-  return Math.max(0, Math.min(1, value));
+function representableProjectedUncertainty(probability, uncertainty, baseRate) {
+  const maxBeliefUncertainty = baseRate > 0 ? probability / baseRate : Number.POSITIVE_INFINITY;
+  const maxDisbeliefUncertainty = baseRate < 1 ? (1 - probability) / (1 - baseRate) : Number.POSITIVE_INFINITY;
+  return clamp012(
+    Math.min(uncertainty, maxBeliefUncertainty, maxDisbeliefUncertainty)
+  );
 }
-function toEvidence(probability, weight) {
-  const safeProbability = clamp013(probability);
-  const safeWeight = Number.isFinite(weight) ? Math.max(0, weight) : 0;
+function opinionFromProjected(probability, uncertainty, baseRate) {
+  const p = clamp012(probability);
+  const a = clamp012(baseRate);
+  const u = representableProjectedUncertainty(p, clamp012(uncertainty), a);
+  return mkOpinion(
+    Math.max(0, p - a * u),
+    Math.max(0, 1 - p - (1 - a) * u),
+    u,
+    a
+  );
+}
+function hasProjectedOpinionChanged(current, next, tolerance = 0.01) {
+  return Math.abs(confidenceFromOpinion(next) - confidenceFromOpinion(current)) >= tolerance;
+}
+
+// src/v1/operations/contradiction/detectTupleContradiction.ts
+var DEFAULT_TUPLE_CONTRADICTION_BELIEF_THRESHOLD = 0.7;
+var DEFAULT_TUPLE_CONTRADICTION_DISBELIEF_THRESHOLD = 0.7;
+function normalizeTupleContradictionPolicy(policy = {}) {
   return {
-    alpha: safeProbability * safeWeight,
-    beta: (1 - safeProbability) * safeWeight
+    beliefThreshold: clamp012(
+      policy.beliefThreshold ?? DEFAULT_TUPLE_CONTRADICTION_BELIEF_THRESHOLD
+    ),
+    disbeliefThreshold: clamp012(
+      policy.disbeliefThreshold ?? DEFAULT_TUPLE_CONTRADICTION_DISBELIEF_THRESHOLD
+    )
   };
 }
-function bayesianUpdate(priorConfidence, priorWeight, newAssessment, newWeight, options) {
-  return reviseConfidence({
-    priorConfidence,
-    priorWeight,
-    newAssessment,
-    newWeight,
-    baseRate: options?.baseRate,
-    nonInformativeWeight: options?.nonInformativeWeight
-  });
+function detectTupleContradiction(opinion2, tauB = DEFAULT_TUPLE_CONTRADICTION_BELIEF_THRESHOLD, tauD = DEFAULT_TUPLE_CONTRADICTION_DISBELIEF_THRESHOLD) {
+  return opinion2.b > tauB && opinion2.d > tauD;
 }
-function reviseConfidence(args) {
-  return project(reviseConfidenceOpinion(args));
+function evaluateTupleContradictionTransition(args) {
+  const policy = normalizeTupleContradictionPolicy(args.policy);
+  const tupleContradicted = detectTupleContradiction(
+    args.opinion,
+    policy.beliefThreshold,
+    policy.disbeliefThreshold
+  );
+  const previousTupleContradicted = Boolean(args.previousTupleContradicted);
+  return {
+    tupleContradicted,
+    crossedIntoTupleContradiction: !previousTupleContradicted && tupleContradicted,
+    crossedOutOfTupleContradiction: previousTupleContradicted && !tupleContradicted,
+    policy
+  };
 }
-function reviseConfidenceOpinion(args) {
-  const priorEvidence = toEvidence(args.priorConfidence, args.priorWeight);
-  const newEvidence = toEvidence(args.newAssessment, args.newWeight ?? 1);
-  return opinionFromBeta(
-    priorEvidence.alpha + newEvidence.alpha,
-    priorEvidence.beta + newEvidence.beta,
-    args.nonInformativeWeight ?? DEFAULT_NON_INFORMATIVE_WEIGHT,
-    args.baseRate
+
+// src/v1/operations/dynamics/cascade.ts
+function dampedDependencyOpinion(dependencyOpinion, beliefOpinion, mode = "continuous", threshold = 0.3) {
+  const dependencyProjection = project(
+    mkOpinion(
+      dependencyOpinion.b,
+      dependencyOpinion.d,
+      dependencyOpinion.u,
+      dependencyOpinion.a
+    )
+  );
+  if (mode === "threshold") {
+    if (dependencyProjection < threshold) {
+      return opinion(
+        0,
+        beliefOpinion.d + beliefOpinion.b * 0.5,
+        0.5,
+        beliefOpinion.a
+      );
+    }
+    return beliefOpinion;
+  }
+  const dampingFactor = dependencyProjection ** 0.5;
+  return opinion(
+    beliefOpinion.b * dampingFactor,
+    beliefOpinion.d + beliefOpinion.b * (1 - dampingFactor) * 0.3,
+    beliefOpinion.u + beliefOpinion.b * (1 - dampingFactor) * 0.7,
+    beliefOpinion.a
   );
 }
+function dampedDependencyCascade(dependencyOpinion, beliefOpinion, mode = "continuous") {
+  return {
+    opinion: dampedDependencyOpinion(dependencyOpinion, beliefOpinion, mode),
+    operator: "dependency_cascade",
+    rationale: `Damped dependency cascade (${mode}): prerequisite at ${project(
+      mkOpinion(
+        dependencyOpinion.b,
+        dependencyOpinion.d,
+        dependencyOpinion.u,
+        dependencyOpinion.a
+      )
+    ).toFixed(2)}`
+  };
+}
 
 // src/v1/operations/dynamics/decay.ts
 var DECAY_TIERS = {
@@ -974,22 +1142,118 @@ function resolveLifecycleBucket(args) {
   if (normalizeBeliefConfidence(args.confidence) === 0 || normalizeBeliefConfidence(args.confidence) === 1 || hasResolvedPredictionOutcome(args.predictionMeta)) {
     return "fact";
   }
-  if (args.beliefStatus === "assumption" || args.beliefStatus === "hypothesis" || args.beliefStatus === "belief" || args.beliefStatus === "fact") {
-    if (normalizeBeliefConfidence(args.confidence) !== null && (args.beliefStatus === "assumption" || args.beliefStatus === "hypothesis")) {
-      return "belief";
-    }
-    return args.beliefStatus;
+  if (args.beliefStatus === "assumption" || args.beliefStatus === "hypothesis" || args.beliefStatus === "belief" || args.beliefStatus === "fact") {
+    if (normalizeBeliefConfidence(args.confidence) !== null && (args.beliefStatus === "assumption" || args.beliefStatus === "hypothesis")) {
+      return "belief";
+    }
+    return args.beliefStatus;
+  }
+  return "assumption";
+}
+function lifecycleMultiplier(status) {
+  if (status === "assumption") {
+    return 0.65;
+  }
+  if (status === "hypothesis") {
+    return 0.8;
+  }
+  return 1;
+}
+function resolveLifecycleRescore(context) {
+  if (context.isOverdue && context.lifecycleStatus === "assumption") {
+    return {
+      priority: "critical",
+      reason: `Untested assumption is stale (${Math.round(context.decayState.ageDays)}d) \u2014 validate or supersede`
+    };
+  }
+  if (context.isOverdue && context.lifecycleStatus === "hypothesis" || context.lifecycleStatus === "hypothesis" && context.daysUntilRescore < 7) {
+    return {
+      priority: "high",
+      reason: `Hypothesis aging without validation (${Math.round(context.decayState.ageDays)}d) \u2014 run/finish sprint testing`
+    };
+  }
+}
+function resolveDeadlineRescore(context) {
+  const urgency = context.decayState.urgency;
+  if (urgency?.isOverdue) {
+    return {
+      priority: "critical",
+      reason: `Prediction deadline passed ${Math.abs(urgency.daysToDeadline)}d ago \u2014 validate or archive`
+    };
+  }
+  if (urgency?.urgencyTier.label === "critical") {
+    return {
+      priority: "critical",
+      reason: `Deadline in ${urgency.daysToDeadline}d \u2014 needs immediate rescoring`
+    };
+  }
+  if (urgency?.urgencyTier.label === "imminent") {
+    return {
+      priority: "high",
+      reason: `Deadline in ${urgency.daysToDeadline}d \u2014 weekly rescoring required`
+    };
+  }
+}
+function resolveStalenessRescore(context) {
+  if (context.isOverdue && context.decayState.baseTier.label === "expired") {
+    return {
+      priority: "critical",
+      reason: `Not scored in ${Math.round(context.decayState.ageDays)}d \u2014 confidence severely degraded`
+    };
+  }
+  if (context.isOverdue && context.decayState.baseTier.label === "stale") {
+    return {
+      priority: "high",
+      reason: `Stale (${Math.round(context.decayState.ageDays)}d since scoring) \u2014 evidence update required`
+    };
+  }
+  if (context.isOverdue) {
+    return {
+      priority: "high",
+      reason: `Rescore overdue by ${Math.abs(Math.round(context.daysUntilRescore))}d`
+    };
+  }
+}
+function resolveRoutineRescore(context) {
+  if (context.temporalNature === "forecast" && context.daysUntilRescore < 7) {
+    return {
+      priority: "medium",
+      reason: `Forecast belief \u2014 next rescore due in ${Math.round(context.daysUntilRescore)}d`
+    };
+  }
+  if (context.daysUntilRescore < 14) {
+    return {
+      priority: "medium",
+      reason: `Rescore due in ${Math.round(context.daysUntilRescore)}d`
+    };
   }
-  return "assumption";
+  return {
+    priority: "low",
+    reason: `On schedule \u2014 next rescore in ${Math.round(context.daysUntilRescore)}d`
+  };
 }
-function lifecycleMultiplier(status) {
-  if (status === "assumption") {
-    return 0.65;
+function escalateHighConfidenceRescore(result, context) {
+  if ((context.confidence ?? 0) >= 0.8 && context.decayState.baseTier.label !== "fresh" && result.priority === "medium") {
+    return {
+      priority: "high",
+      reason: `High-confidence belief (${((context.confidence ?? 0) * 100).toFixed(0)}%) aging without rescore \u2014 ${result.reason}`
+    };
   }
-  if (status === "hypothesis") {
-    return 0.8;
+  return result;
+}
+var RESCORING_RULES = [
+  resolveLifecycleRescore,
+  resolveDeadlineRescore,
+  resolveStalenessRescore
+];
+function resolveRescoringPriority(context) {
+  for (const rule of RESCORING_RULES) {
+    const result = rule(context);
+    if (result) {
+      return escalateHighConfidenceRescore(result, context);
+    }
   }
-  return 1;
+  return escalateHighConfidenceRescore(resolveRoutineRescore(context), context);
 }
 function computeBaseDecay(lastScoredAt) {
   const ageDays = (Date.now() - lastScoredAt) / (1e3 * 60 * 60 * 24);
@@ -1062,46 +1326,14 @@ function getRescoringSchedule(opts) {
   );
   const daysUntilRescore = (decayState.rescoreByDate - Date.now()) / (1e3 * 60 * 60 * 24);
   const isOverdue = daysUntilRescore < 0;
-  let priority;
-  let reason;
-  if (isOverdue && lifecycleStatus === "assumption") {
-    priority = "critical";
-    reason = `Untested assumption is stale (${Math.round(decayState.ageDays)}d) \u2014 validate or supersede`;
-  } else if (isOverdue && lifecycleStatus === "hypothesis" || lifecycleStatus === "hypothesis" && daysUntilRescore < 7) {
-    priority = "high";
-    reason = `Hypothesis aging without validation (${Math.round(decayState.ageDays)}d) \u2014 run/finish sprint testing`;
-  } else if (decayState.urgency?.isOverdue) {
-    priority = "critical";
-    reason = `Prediction deadline passed ${Math.abs(decayState.urgency.daysToDeadline)}d ago \u2014 validate or archive`;
-  } else if (isOverdue && decayState.baseTier.label === "expired") {
-    priority = "critical";
-    reason = `Not scored in ${Math.round(decayState.ageDays)}d \u2014 confidence severely degraded`;
-  } else if (isOverdue && decayState.baseTier.label === "stale") {
-    priority = "high";
-    reason = `Stale (${Math.round(decayState.ageDays)}d since scoring) \u2014 evidence update required`;
-  } else if (decayState.urgency && decayState.urgency.urgencyTier.label === "critical") {
-    priority = "critical";
-    reason = `Deadline in ${decayState.urgency.daysToDeadline}d \u2014 needs immediate rescoring`;
-  } else if (decayState.urgency && decayState.urgency.urgencyTier.label === "imminent") {
-    priority = "high";
-    reason = `Deadline in ${decayState.urgency.daysToDeadline}d \u2014 weekly rescoring required`;
-  } else if (isOverdue) {
-    priority = "high";
-    reason = `Rescore overdue by ${Math.abs(Math.round(daysUntilRescore))}d`;
-  } else if (opts.temporalNature === "forecast" && daysUntilRescore < 7) {
-    priority = "medium";
-    reason = `Forecast belief \u2014 next rescore due in ${Math.round(daysUntilRescore)}d`;
-  } else if (daysUntilRescore < 14) {
-    priority = "medium";
-    reason = `Rescore due in ${Math.round(daysUntilRescore)}d`;
-  } else {
-    priority = "low";
-    reason = `On schedule \u2014 next rescore in ${Math.round(daysUntilRescore)}d`;
-  }
-  if ((opts.confidence ?? 0) >= 0.8 && decayState.baseTier.label !== "fresh" && priority === "medium") {
-    priority = "high";
-    reason = `High-confidence belief (${((opts.confidence ?? 0) * 100).toFixed(0)}%) aging without rescore \u2014 ${reason}`;
-  }
+  const { priority, reason } = resolveRescoringPriority({
+    confidence: opts.confidence,
+    daysUntilRescore,
+    decayState,
+    isOverdue,
+    lifecycleStatus,
+    temporalNature: opts.temporalNature
+  });
   return {
     nextRescoreBy: decayState.rescoreByDate,
     daysUntilRescore: Math.round(daysUntilRescore),
@@ -1115,7 +1347,7 @@ function decay(current, daysSinceLastUpdate, halfLifeDays = 90) {
   if (daysSinceLastUpdate <= 0) {
     return current;
   }
-  const decayFactor = Math.pow(0.5, daysSinceLastUpdate / halfLifeDays);
+  const decayFactor = 0.5 ** (daysSinceLastUpdate / halfLifeDays);
   const certainty = current.b + current.d;
   const lostCertainty = certainty - certainty * decayFactor;
   return opinion(
@@ -1126,323 +1358,226 @@ function decay(current, daysSinceLastUpdate, halfLifeDays = 90) {
   );
 }
 
-// src/v1/operations/contracts/epistemicContract.ts
-var BUILT_IN_EVIDENTIAL_EVALUATOR = "evidential";
-var BUILT_IN_EVIDENTIAL_ALIASES = /* @__PURE__ */ new Set([
-  BUILT_IN_EVIDENTIAL_EVALUATOR,
-  "built_in_evidential",
-  "builtin_evidential"
-]);
-var BUILT_IN_METRIC_CHECKER = "metric_checker";
-var BUILT_IN_REFERENCE_CHECK_COUNTER = "reference_check_counter";
-var BUILT_IN_TEMPORAL_DEADLINE = "temporal_deadline";
-var BUILT_IN_MARKET_INDEX_COMPARATOR = "market_index_comparator";
-function clampConfidence(value) {
-  return Math.max(0, Math.min(1, value));
-}
-function generateContractId() {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-    return crypto.randomUUID();
-  }
-  return `contract-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
-}
-function isRecord(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function deriveContractStatus(result, currentStatus) {
-  if (currentStatus === "archived") {
-    return currentStatus;
-  }
-  switch (result) {
-    case "confirmed":
-      return "satisfied";
-    case "disconfirmed":
-      return "violated";
-    case "expired":
-      return "expired";
-    default:
-      return currentStatus === "satisfied" || currentStatus === "violated" || currentStatus === "expired" ? "active" : currentStatus;
-  }
-}
-function deriveVerificationTrigger(result) {
-  switch (result) {
-    case "confirmed":
-      return "verification_confirmed";
-    case "disconfirmed":
-      return "verification_disconfirmed";
-    case "expired":
-      return "verification_expired";
-    case "partial":
-      return "verification_partial";
-    default:
-      return null;
-  }
-}
-function deriveContractModulationPlan(args) {
-  const trigger = deriveVerificationTrigger(args.result);
-  if (!trigger) {
-    return null;
-  }
-  if (args.result === "confirmed") {
-    const rawNext = args.currentConfidence + args.modulation.onConfirmed.delta;
-    const confidenceAfter = clampConfidence(
-      Math.min(
-        args.modulation.onConfirmed.ceiling ?? Number.POSITIVE_INFINITY,
-        rawNext
-      )
-    );
-    return {
-      trigger,
-      confidenceBefore: args.currentConfidence,
-      confidenceAfter,
-      confidenceDelta: confidenceAfter - args.currentConfidence
-    };
-  }
-  if (args.result === "disconfirmed") {
-    const rawNext = args.currentConfidence + args.modulation.onDisconfirmed.delta;
-    const confidenceAfter = clampConfidence(
-      Math.max(args.modulation.onDisconfirmed.floor ?? 0, rawNext)
-    );
-    return {
-      trigger,
-      confidenceBefore: args.currentConfidence,
-      confidenceAfter,
-      confidenceDelta: confidenceAfter - args.currentConfidence
-    };
-  }
-  if (args.result === "expired" && args.modulation.onExpired) {
-    const confidenceAfter = clampConfidence(
-      args.currentConfidence + args.modulation.onExpired.delta
+// src/v1/operations/dynamics/defeat.ts
+function applyNegativeSupport(source, target, weight, metadata = {}) {
+  const sourceOpinion = mkOpinion(source.b, source.d, source.u, source.a);
+  const targetOpinion = mkOpinion(target.b, target.d, target.u, target.a);
+  if (metadata.constraint === "xor") {
+    const result = constraintFusion(
+      sourceOpinion,
+      targetOpinion,
+      metadata.normalization ?? "pressure"
     );
     return {
-      trigger,
-      confidenceBefore: args.currentConfidence,
-      confidenceAfter,
-      confidenceDelta: confidenceAfter - args.currentConfidence
+      opinion: result.o2,
+      operator: "constraint_fusion",
+      rationale: `XOR constraint: source belief at ${project(
+        sourceOpinion
+      ).toFixed(2)} pressures target`
     };
   }
-  if (args.result === "partial" && args.modulation.onPartial) {
-    if ((args.resultConfidence ?? 0) < args.modulation.onPartial.threshold) {
-      return null;
+  const discounted = trustDiscount(negate(sourceOpinion), Math.abs(weight));
+  return {
+    opinion: cumulativeFusion(targetOpinion, discounted),
+    operator: "cumulative_fusion",
+    rationale: `Contradicting evidence (weight=${weight.toFixed(
+      2
+    )}) from source at ${project(sourceOpinion).toFixed(2)}`
+  };
+}
+function applyNegativeEvidence(source, target, weight) {
+  const sourceOpinion = mkOpinion(source.b, source.d, source.u, source.a);
+  const targetOpinion = mkOpinion(target.b, target.d, target.u, target.a);
+  const discounted = trustDiscount(negate(sourceOpinion), Math.abs(weight));
+  return {
+    opinion: cumulativeFusion(targetOpinion, discounted),
+    operator: "cumulative_fusion",
+    rationale: `Contradicting evidence (weight=${weight.toFixed(2)})`
+  };
+}
+
+// src/v1/operations/dynamics/propagation.ts
+var EDGE_PROPAGATION_RULES = {
+  supports: {
+    direction: "outgoing",
+    handler: (source, target, weight, metadata) => {
+      const sourceOpinion = mkOpinion(source.b, source.d, source.u, source.a);
+      const targetOpinion = mkOpinion(target.b, target.d, target.u, target.a);
+      if (weight < 0) {
+        return applyNegativeSupport(
+          sourceOpinion,
+          targetOpinion,
+          weight,
+          metadata
+        );
+      }
+      const discounted = trustDiscount(sourceOpinion, weight);
+      return {
+        opinion: cumulativeFusion(targetOpinion, discounted),
+        operator: "cumulative_fusion",
+        rationale: `Supporting evidence (weight=${weight.toFixed(
+          2
+        )}) from source at ${project(sourceOpinion).toFixed(2)}`
+      };
     }
-    const confidenceAfter = clampConfidence(
-      args.currentConfidence + args.modulation.onPartial.delta
-    );
-    return {
-      trigger,
-      confidenceBefore: args.currentConfidence,
-      confidenceAfter,
-      confidenceDelta: confidenceAfter - args.currentConfidence
-    };
+  },
+  informs: {
+    direction: "outgoing",
+    handler: (source, target, weight) => {
+      const sourceOpinion = mkOpinion(source.b, source.d, source.u, source.a);
+      const targetOpinion = mkOpinion(target.b, target.d, target.u, target.a);
+      if (weight < 0) {
+        return applyNegativeEvidence(sourceOpinion, targetOpinion, weight);
+      }
+      const discounted = trustDiscount(sourceOpinion, Math.abs(weight));
+      return {
+        opinion: cumulativeFusion(targetOpinion, discounted),
+        operator: "cumulative_fusion",
+        rationale: `Supporting evidence (weight=${weight.toFixed(2)})`
+      };
+    }
+  },
+  depends_on: {
+    direction: "incoming",
+    handler: (source, target, _weight, metadata) => {
+      const sourceOpinion = mkOpinion(source.b, source.d, source.u, source.a);
+      const targetOpinion = mkOpinion(target.b, target.d, target.u, target.a);
+      if (metadata.conditionalA && metadata.conditionalNotA) {
+        return {
+          opinion: conditionalDeduction(
+            sourceOpinion,
+            mkOpinion(
+              metadata.conditionalA.b,
+              metadata.conditionalA.d,
+              metadata.conditionalA.u,
+              metadata.conditionalA.a
+            ),
+            mkOpinion(
+              metadata.conditionalNotA.b,
+              metadata.conditionalNotA.d,
+              metadata.conditionalNotA.u,
+              metadata.conditionalNotA.a
+            ),
+            targetOpinion.a
+          ),
+          operator: "conditional_deduction",
+          rationale: `Conditional deduction: prerequisite at ${project(
+            sourceOpinion
+          ).toFixed(2)}`
+        };
+      }
+      return dampedDependencyCascade(
+        sourceOpinion,
+        targetOpinion,
+        metadata.propagation ?? "continuous"
+      );
+    }
+  },
+  derived_from: {
+    direction: "incoming",
+    handler: (_source, target) => ({
+      opinion: target,
+      operator: "trust_discount",
+      rationale: "Provenance edge \u2014 no confidence propagation"
+    })
+  },
+  contains: {
+    direction: "outgoing",
+    handler: (_source, target) => ({
+      opinion: target,
+      operator: "trust_discount",
+      rationale: "Containment edge \u2014 no confidence propagation"
+    })
+  },
+  tests: {
+    direction: "outgoing",
+    handler: (_source, target) => ({
+      opinion: target,
+      operator: "trust_discount",
+      rationale: "Testing edge \u2014 no confidence propagation"
+    })
   }
-  return null;
-}
-function createInheritedContractRecord(contract, args) {
-  return {
-    beliefNodeId: args.beliefNodeId,
-    contractId: generateContractId(),
-    title: contract.title,
-    description: contract.description,
-    conditionType: contract.conditionType,
-    direction: contract.direction,
-    condition: contract.condition,
-    deadline: contract.deadline,
-    compositeOf: contract.compositeOf,
-    compositeOperator: contract.compositeOperator,
-    modulation: contract.modulation,
-    evaluationSchedule: contract.evaluationSchedule,
-    periodicIntervalMs: contract.periodicIntervalMs,
-    status: "active",
-    lineageSource: "inherited",
-    inheritedFromContractId: contract.contractId,
-    inheritedFromBeliefNodeId: contract.beliefNodeId,
-    inheritedAt: args.now,
-    topicId: args.topicId,
-    createdAt: args.now,
-    createdBy: args.createdBy,
-    updatedAt: args.now
-  };
-}
-function normalizeEvidentialAction(value) {
-  return value === "append_sl_scoring" || value === "flag_review" || value === "archive" ? value : void 0;
+};
+var PROPAGATION_TRAVERSAL_SPECS = Object.entries(EDGE_PROPAGATION_RULES).map(([edgeType, rule]) => ({
+  edgeType,
+  direction: rule.direction
+}));
+function isPropagationEdgeType(edgeType) {
+  return edgeType in EDGE_PROPAGATION_RULES;
 }
-function parseComparisonOperator(value, evaluatorName) {
-  if (value === "gte" || value === "lte" || value === "eq" || value === "gt" || value === "lt") {
-    return value;
-  }
-  throw new Error(
-    `${evaluatorName} requires operator to be one of gte, lte, eq, gt, or lt.`
-  );
+function getPropagationTraversalSpecs() {
+  return PROPAGATION_TRAVERSAL_SPECS;
 }
-function parseNumericThreshold(value, evaluatorName) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value;
+function propagateThroughEdge(sourceOpinion, targetOpinion, edgeType, weight = 1, metadata = {}) {
+  const handler = isPropagationEdgeType(edgeType) ? EDGE_PROPAGATION_RULES[edgeType].handler : void 0;
+  if (!handler) {
+    return {
+      opinion: targetOpinion,
+      operator: "no_op",
+      rationale: `Unknown edge type: ${edgeType} \u2014 no propagation`
+    };
   }
-  throw new Error(`${evaluatorName} requires a finite numeric threshold.`);
+  return handler(sourceOpinion, targetOpinion, weight, metadata);
 }
-function pickFiniteNumber(config, keys) {
-  for (const key of keys) {
-    const value = config[key];
-    if (typeof value === "number" && Number.isFinite(value)) {
-      return value;
+function propagateAllEdges(currentOpinion, incomingEdges) {
+  let result = currentOpinion;
+  const rationales = [];
+  for (const edgeType of ["depends_on", "informs", "supports"]) {
+    for (const incoming of incomingEdges.filter(
+      (edge) => edge.edgeType === edgeType
+    )) {
+      const propagated = propagateThroughEdge(
+        incoming.sourceOpinion,
+        result,
+        incoming.edgeType,
+        incoming.weight,
+        incoming.metadata
+      );
+      result = propagated.opinion;
+      rationales.push(propagated.rationale);
     }
   }
-  return void 0;
-}
-function getEvaluatorInputRecord(inputData, nestedKey) {
-  if (!isRecord(inputData)) {
-    return {};
-  }
-  const nested = inputData[nestedKey];
-  if (isRecord(nested)) {
-    return nested;
-  }
-  return inputData;
-}
-function parseEvidentialEvaluatorConfig(value) {
-  if (!isRecord(value)) {
-    throw new Error(
-      "Evidential contracts require condition.evaluatorConfig with metric/operator/threshold."
-    );
-  }
-  const config = value;
-  const metric = config.metric;
-  const operator = config.operator;
-  const threshold = config.threshold;
-  if (metric !== "evidence_count" && metric !== "contradiction_status" && metric !== "edge_freshness" && metric !== "dependent_count") {
-    throw new Error(`Unsupported evidential metric: ${String(metric)}`);
-  }
-  if (operator !== "gte" && operator !== "lte" && operator !== "eq" && operator !== "gt" && operator !== "lt") {
-    throw new Error(`Unsupported evidential operator: ${String(operator)}`);
-  }
-  if (typeof threshold !== "number" || !Number.isFinite(threshold)) {
-    throw new Error("Evidential contracts require a numeric threshold.");
-  }
-  const actionParams = isRecord(config.actionParams) ? config.actionParams : void 0;
   return {
-    metric,
-    operator,
-    threshold,
-    action: normalizeEvidentialAction(config.action),
-    actionParams: actionParams && (typeof actionParams.targetConfidence === "number" || typeof actionParams.rationale === "string") ? {
-      targetConfidence: typeof actionParams.targetConfidence === "number" ? actionParams.targetConfidence : void 0,
-      rationale: typeof actionParams.rationale === "string" ? actionParams.rationale : void 0
-    } : void 0
+    opinion: result,
+    operator: "cumulative_fusion",
+    rationale: rationales.join("; ")
   };
 }
-function compareMetricValue(operator, left, right) {
-  switch (operator) {
-    case "gte":
-      return left >= right;
-    case "lte":
-      return left <= right;
-    case "eq":
-      return left === right;
-    case "gt":
-      return left > right;
-    case "lt":
-      return left < right;
-    default:
-      return false;
-  }
-}
-function resolveComparisonResult(direction, comparisonSatisfied) {
-  return direction === "falsifies" ? comparisonSatisfied ? "disconfirmed" : "confirmed" : comparisonSatisfied ? "confirmed" : "disconfirmed";
-}
-function buildComparisonRationale(args) {
-  const renderedObserved = args.observedValue === null ? "no data" : `${args.observedValue}${args.unit ? ` ${args.unit}` : ""}`;
-  const renderedThreshold = `${args.threshold}${args.unit ? ` ${args.unit}` : ""}`;
-  const clause = `${args.label} observed ${renderedObserved} against ${args.operator} ${renderedThreshold}`;
-  if (args.observedValue === null) {
-    return `${clause}; evaluator returned ${args.result} because no current data was available.`;
-  }
-  return `${clause}; comparison ${args.comparisonSatisfied ? "passed" : "failed"}, resulting in ${args.result}.`;
-}
-function buildEvidentialRationale(args) {
-  const observed = args.snapshot.value === null ? "no data" : String(args.snapshot.value);
-  const clause = `${args.snapshot.metric} observed ${observed} against ${args.config.operator} ${args.config.threshold}`;
-  if (args.snapshot.value === null) {
-    return `${clause}; evidential evaluator treated the comparison as unmet, resulting in ${args.result}.`;
-  }
-  return `${clause}; comparison ${args.comparisonSatisfied ? "passed" : "failed"}, resulting in ${args.result}.`;
+
+// src/v1/operations/dynamics/revision.ts
+function clamp013(value) {
+  return Math.max(0, Math.min(1, value));
 }
-function parseMetricCheckerConfig(value) {
-  if (!isRecord(value)) {
-    throw new Error(
-      "metric_checker requires condition.evaluatorConfig with observedValue/operator/threshold."
-    );
-  }
-  const config = value;
+function toEvidence(probability, weight) {
+  const safeProbability = clamp013(probability);
+  const safeWeight = Number.isFinite(weight) ? Math.max(0, weight) : 0;
   return {
-    metric: typeof config.metric === "string" && config.metric.length > 0 ? config.metric : void 0,
-    operator: parseComparisonOperator(config.operator, BUILT_IN_METRIC_CHECKER),
-    threshold: parseNumericThreshold(config.threshold, BUILT_IN_METRIC_CHECKER),
-    observedValue: pickFiniteNumber(config, ["observedValue", "value"]),
-    currentValue: pickFiniteNumber(config, ["currentValue"]),
-    metricValue: pickFiniteNumber(config, ["metricValue"]),
-    unit: typeof config.unit === "string" && config.unit.length > 0 ? config.unit : void 0
+    alpha: safeProbability * safeWeight,
+    beta: (1 - safeProbability) * safeWeight
   };
 }
-function parseReferenceCheckCounterConfig(value) {
-  if (!isRecord(value)) {
-    throw new Error(
-      "reference_check_counter requires condition.evaluatorConfig with tag/operator/threshold."
-    );
-  }
-  const config = value;
-  if (typeof config.tag !== "string" || config.tag.trim().length === 0) {
-    throw new Error("reference_check_counter requires a non-empty tag.");
-  }
-  return {
-    tag: config.tag.trim(),
-    operator: parseComparisonOperator(
-      config.operator,
-      BUILT_IN_REFERENCE_CHECK_COUNTER
-    ),
-    threshold: parseNumericThreshold(
-      config.threshold,
-      BUILT_IN_REFERENCE_CHECK_COUNTER
-    ),
-    caseSensitive: config.caseSensitive === true
-  };
+function bayesianUpdate(priorConfidence, priorWeight, newAssessment, newWeight, options) {
+  return reviseConfidence({
+    priorConfidence,
+    priorWeight,
+    newAssessment,
+    newWeight,
+    baseRate: options?.baseRate,
+    nonInformativeWeight: options?.nonInformativeWeight
+  });
 }
-function parseTemporalDeadlineConfig(value) {
-  if (!isRecord(value)) {
-    return {};
-  }
-  const config = value;
-  return {
-    label: typeof config.label === "string" && config.label.length > 0 ? config.label : void 0,
-    completed: config.completed === true,
-    completedAt: pickFiniteNumber(config, ["completedAt"]),
-    observedAt: pickFiniteNumber(config, ["observedAt"]),
-    satisfiedAt: pickFiniteNumber(config, ["satisfiedAt"]),
-    achievedAt: pickFiniteNumber(config, ["achievedAt"])
-  };
+function reviseConfidence(args) {
+  return project(reviseConfidenceOpinion(args));
 }
-function parseMarketIndexComparatorConfig(value) {
-  if (!isRecord(value)) {
-    throw new Error(
-      "market_index_comparator requires condition.evaluatorConfig with subjectValue/benchmarkValue/operator/threshold."
-    );
-  }
-  const config = value;
-  return {
-    subject: typeof config.subject === "string" && config.subject.length > 0 ? config.subject : void 0,
-    subjectValue: pickFiniteNumber(config, ["subjectValue", "leftValue"]),
-    primaryValue: pickFiniteNumber(config, ["primaryValue"]),
-    benchmark: typeof config.benchmark === "string" && config.benchmark.length > 0 ? config.benchmark : void 0,
-    benchmarkValue: pickFiniteNumber(config, ["benchmarkValue", "rightValue"]),
-    comparisonValue: pickFiniteNumber(config, ["comparisonValue"]),
-    operator: parseComparisonOperator(
-      config.operator,
-      BUILT_IN_MARKET_INDEX_COMPARATOR
-    ),
-    threshold: parseNumericThreshold(
-      config.threshold,
-      BUILT_IN_MARKET_INDEX_COMPARATOR
-    )
-  };
+function reviseConfidenceOpinion(args) {
+  const priorEvidence = toEvidence(args.priorConfidence, args.priorWeight);
+  const newEvidence = toEvidence(args.newAssessment, args.newWeight ?? 1);
+  return opinionFromBeta(
+    priorEvidence.alpha + newEvidence.alpha,
+    priorEvidence.beta + newEvidence.beta,
+    args.nonInformativeWeight ?? DEFAULT_NON_INFORMATIVE_WEIGHT,
+    args.baseRate
+  );
 }
 
 // src/v1/operations/approximation.ts