@lucern/confidence 0.3.0-alpha.0 → 0.3.0-alpha.10

package/README.md

@@ -13,12 +13,16 @@ This module contains the pure logic for confidence updates. Convex-facing adapte
 Constraints:
 - `modulateConfidence` remains append-only at the mutation boundary
 - Confidence history continues to be written through the existing belief-confidence ledger
-- Public mutation signatures do not change; only the pure scoring and evaluation math moves here
+- Belief creation starts from the canonical vacuous prior `(b=0, d=0, u=1, a=0.5)` unless the caller supplies an explicit prior
+- Belief/disbelief mass only moves when a confidence modulation cites a truth-bearing artifact: evidence, an answered question or answer node, a contradiction, or a worktree outcome
+- Public mutation callers must provide opinion-space tuple fields; scalar confidence is a derived projection, not a write contract
 
 ## SL rigor
 
 - The canonical confidence shape is the 4-tuple `(b, d, u, a)`.
 - `b + d + u = 1`, and the projected scalar remains `P = b + a*u`.
+- A newly created belief is vacuous by default: `b=0`, `d=0`, `u=1`, `a=0.5`.
+- `modulateConfidence` is provenance-bound. `manual` and `decay` are not confidence triggers; direct human or agent assessments must still cite evidence, an answered question/answer, a contradiction, or a worktree outcome.
 - Use `opinionFromScalar(value, mode, options?)` for scalar conversion.
 - Supported modes are `base_rate`, `dogmatic`, and `projected_with_u`.
 - `toDogmaticOpinion()` remains as a deprecated shim to the explicit dogmatic mode.

package/dist/index.d.ts

@@ -1,10 +1,11 @@
-export { BeliefLifecycleBucket, ConfidencePolicyConfig, ConfidenceScoringMode, ContractConfirmedRule, ContractDisconfirmedRule, ContractExpiredRule, ContractModulationPlan, ContractPartialRule, DeadlineUrgency, DeadlineUrgencyLabel, DeadlineUrgencyTier, DecayTier, DecayTierLabel, DirichletOpinion, EdgeConstraint, EdgeMetadata, EdgeNormalization, EffectiveDecay, EpistemicContractCompositeOperator, EpistemicContractCondition, EpistemicContractConditionType, EpistemicContractDirection, EpistemicContractEvaluationResult, EpistemicContractLineageSource, EpistemicContractModulation, EpistemicContractRecord, EpistemicContractSchedule, EpistemicContractStatus, EvidentialAction, EvidentialEvaluatorConfig, EvidentialMetric, EvidentialMetricSnapshot, EvidentialOperator, MarketIndexComparatorConfig, MetricCheckerEvaluatorConfig, Opinion, PropagationMode, PropagationResult, ReferenceCheckCounterConfig, RescoringSchedule, SLOperator, StoredOpinionFields, TemporalDeadlineEvaluatorConfig, TupleContradictionPolicy, TupleContradictionTransition, VerificationConfidenceTrigger } from './v1/types.js';
+export { BeliefLifecycleBucket, ConfidencePolicyConfig, ConfidenceScoringMode, ContractConfirmedRule, ContractDisconfirmedRule, ContractExpiredRule, ContractModulationPlan, ContractPartialRule, DeadlineUrgency, DeadlineUrgencyLabel, DeadlineUrgencyTier, DecayTier, DecayTierLabel, DirichletOpinion, EdgeConstraint, EdgeMetadata, EdgeNormalization, EffectiveDecay, EpistemicContractCompositeOperator, EpistemicContractCondition, EpistemicContractConditionType, EpistemicContractDirection, EpistemicContractEvaluationResult, EpistemicContractLineageSource, EpistemicContractModulation, EpistemicContractRecord, EpistemicContractSchedule, EpistemicContractStatus, EvidentialAction, EvidentialEvaluatorConfig, EvidentialMetric, EvidentialMetricSnapshot, EvidentialOperator, MarketIndexComparatorConfig, MetricCheckerEvaluatorConfig, Opinion, PropagationMode, PropagationResult, ReferenceCheckCounterConfig, RescoringSchedule, SLOperator, SLOpinion, StoredOpinionFields, TemporalDeadlineEvaluatorConfig, TupleContradictionPolicy, TupleContradictionTransition, VerificationConfidenceTrigger } from './v1/types.js';
+export { FromStorageResult, SLOpinionRefinement, fromStorage, toStorage } from './v1/codec.js';
 export { ConfidenceEngine, ContractEvaluatorPort, SubjectiveLogicOperatorPort } from './v1/interfaces.js';
 export { DEFAULT_TEMPORAL_DECAY_HALF_LIFE_MS, TemporalDecayParams, temporalDecay } from './v1/operations/temporalDecay.js';
 export { DEFAULT_NON_INFORMATIVE_WEIGHT, betaFromOpinion, opinionFromBeta, opinionFromDirichlet, projectDirichletOpinion } from './v1/operations/bridge/index.js';
-export { OpinionFromScalarMode, clamp01, confidenceFromOpinion, confidenceFromSL, hasProjectedOpinionChanged, opinionFromBaseRate, opinionFromDogmatic, opinionFromProjected, opinionFromScalar, readOpinionFromRecord, toDogmaticOpinion, toStoredOpinionFields } from './v1/operations/scoring.js';
+export { OpinionFromScalarMode, OpinionFromScalarOptions, clamp01, confidenceFromOpinion, confidenceFromSL, hasProjectedOpinionChanged, opinionFromBaseRate, opinionFromDogmatic, opinionFromProjected, opinionFromScalar, readOpinionFromRecord, toDogmaticOpinion, toStoredOpinionFields } from './v1/operations/scoring.js';
 export { DEFAULT_TUPLE_CONTRADICTION_BELIEF_THRESHOLD, DEFAULT_TUPLE_CONTRADICTION_DISBELIEF_THRESHOLD, detectTupleContradiction, evaluateTupleContradictionTransition, normalizeTupleContradictionPolicy } from './v1/operations/contradiction/detectTupleContradiction.js';
-export { areTensioned, averagingFusion, conditionalAbduction, conditionalDeduction, confidenceLevel, constraintFusion, cumulativeFusion, dogmatic, evidenceBalance, informationGain, negate, opinion, project, trustDiscount, vacuous } from './v1/operations/subjectiveLogic/index.js';
+export { areTensioned, averagingFusion, conditionalAbduction, conditionalDeduction, confidenceLevel, constraintFusion, cumulativeFusion, dogmatic, evidenceBalance, informationGain, mkOpinion, negate, opinion, project, trustDiscount, vacuous } from './v1/operations/subjectiveLogic/index.js';
 export { PROPAGATION_TRAVERSAL_SPECS, PropagationEdgeType, PropagationTraversalDirection, PropagationTraversalSpec, getPropagationTraversalSpecs, isPropagationEdgeType, propagateAllEdges, propagateThroughEdge } from './v1/operations/dynamics/propagation.js';
 export { bayesianUpdate, reviseConfidence, reviseConfidenceOpinion } from './v1/operations/dynamics/revision.js';
 export { DEADLINE_URGENCY, DECAY_TIERS, computeBaseDecay, computeDeadlineUrgency, computeEffectiveDecay, decay, getRescoringSchedule } from './v1/operations/dynamics/decay.js';
@@ -12,6 +13,7 @@ export { applyNegativeEvidence, applyNegativeSupport } from './v1/operations/dyn
 export { dampedDependencyCascade, dampedDependencyOpinion } from './v1/operations/dynamics/cascade.js';
 export { BUILT_IN_EVIDENTIAL_ALIASES, BUILT_IN_EVIDENTIAL_EVALUATOR, BUILT_IN_MARKET_INDEX_COMPARATOR, BUILT_IN_METRIC_CHECKER, BUILT_IN_REFERENCE_CHECK_COUNTER, BUILT_IN_TEMPORAL_DEADLINE, buildComparisonRationale, buildEvidentialRationale, compareMetricValue, createInheritedContractRecord, deriveContractModulationPlan, deriveContractStatus, deriveVerificationTrigger, getEvaluatorInputRecord, normalizeEvidentialAction, parseComparisonOperator, parseEvidentialEvaluatorConfig, parseMarketIndexComparatorConfig, parseMetricCheckerConfig, parseNumericThreshold, parseReferenceCheckCounterConfig, parseTemporalDeadlineConfig, pickFiniteNumber, resolveComparisonResult } from './v1/operations/contracts/epistemicContract.js';
 export { ConfidenceOperatorName, OPERATOR_TAXONOMY, OPERATOR_TAXONOMY_BY_TAG, OPERATOR_TAXONOMY_ENTRIES, OPERATOR_TAXONOMY_TAGS, OperatorTaxonomyEntry, OperatorTaxonomyTag, PUBLIC_OPERATOR_EXPORT_NAMES } from './v1/operations/operatorTaxonomy.js';
+import 'zod';
 import './v1/operations/approximation.js';
 import './v1/operations/canonical.js';
 import './v1/operations/lucern.js';

package/dist/index.js

@@ -1,8 +1,12 @@
+import { z } from 'zod';
+
+// src/v1/codec.ts
+
 // src/v1/operations/subjectiveLogic/index.ts
-function opinion(belief, disbelief, uncertainty, baseRate = 0.5) {
-  const b = Math.max(0, Math.min(1, belief));
-  const d = Math.max(0, Math.min(1, disbelief));
-  const u = Math.max(0, Math.min(1, uncertainty));
+function mkOpinion(belief, disbelief, uncertainty, baseRate) {
+  const b = Number.isFinite(belief) ? Math.max(0, belief) : 0;
+  const d = Number.isFinite(disbelief) ? Math.max(0, disbelief) : 0;
+  const u = Number.isFinite(uncertainty) ? Math.max(0, uncertainty) : 0;
   const a = Math.max(0, Math.min(1, baseRate));
   const sum = b + d + u;
   if (sum === 0) {
@@ -15,12 +19,13 @@ function opinion(belief, disbelief, uncertainty, baseRate = 0.5) {
     a
   };
 }
-function vacuous(baseRate = 0.5) {
-  return { b: 0, d: 0, u: 1, a: baseRate };
+var opinion = mkOpinion;
+function vacuous(baseRate) {
+  return mkOpinion(0, 0, 1, baseRate);
 }
-function dogmatic(probability, baseRate = 0.5) {
+function dogmatic(probability, baseRate) {
   const p = Math.max(0, Math.min(1, probability));
-  return { b: p, d: 1 - p, u: 0, a: baseRate };
+  return mkOpinion(p, 1 - p, 0, baseRate);
 }
 function project(o) {
   return o.b + o.a * o.u;
@@ -217,7 +222,7 @@ function conditionalAbduction(opinionY, ifTrue, ifFalse, baseRateX) {
   );
 }
 function negate(o) {
-  return { b: o.d, d: o.b, u: o.u, a: 1 - o.a };
+  return mkOpinion(o.d, o.b, o.u, 1 - o.a);
 }
 function constraintFusion(left, right, mode = "pressure") {
   if (mode === "redistribute") {
@@ -280,6 +285,43 @@ function informationGain(o) {
   return o.u * (1 - Math.abs(o.b - o.d));
 }
 
+// src/v1/codec.ts
+var SL_EPSILON = 1e-9;
+var SLOpinionRefinement = z.object({
+  b: z.number(),
+  d: z.number(),
+  u: z.number(),
+  a: z.number()
+}).refine((o) => Math.abs(o.b + o.d + o.u - 1) < SL_EPSILON, {
+  message: "SL invariant b+d+u=1 violated"
+});
+function fromStorage(fields) {
+  const sum = fields.belief + fields.disbelief + fields.uncertainty;
+  const opinion2 = mkOpinion(
+    fields.belief,
+    fields.disbelief,
+    fields.uncertainty,
+    fields.baseRate
+  );
+  if (Math.abs(sum - 1) < SL_EPSILON) {
+    return { ok: true, opinion: opinion2 };
+  }
+  return {
+    ok: false,
+    opinion: opinion2,
+    repairNeeded: true,
+    reason: `Stored fields sum to ${sum.toFixed(6)}, not 1; normalized on read`
+  };
+}
+function toStorage(opinion2) {
+  return {
+    belief: opinion2.b,
+    disbelief: opinion2.d,
+    uncertainty: opinion2.u,
+    baseRate: opinion2.a
+  };
+}
+
 // src/v1/operations/temporalDecay.ts
 var DEFAULT_TEMPORAL_DECAY_HALF_LIFE_MS = 90 * 24 * 60 * 60 * 1e3;
 function toEpochMs(value) {
@@ -313,7 +355,10 @@ function temporalDecay(sourceOpinion, now, decayParams) {
     return { ...sourceOpinion };
   }
   const retainedEvidenceWeight = Math.pow(0.5, ageMs / halfLifeMs);
-  return trustDiscount(sourceOpinion, retainedEvidenceWeight);
+  return trustDiscount(
+    mkOpinion(sourceOpinion.b, sourceOpinion.d, sourceOpinion.u, sourceOpinion.a),
+    retainedEvidenceWeight
+  );
 }
 
 // src/v1/operations/bridge/index.ts
@@ -334,10 +379,6 @@ function normalizeBaseRateVector(baseRate, size) {
   if (size === 0) {
     return [];
   }
-  const fallback = Array.from({ length: size }, () => 1 / size);
-  if (!baseRate) {
-    return fallback;
-  }
   if (baseRate.length !== size) {
     throw new Error(
       `Base-rate vector length ${baseRate.length} must match evidence vector length ${size}.`
@@ -346,11 +387,11 @@ function normalizeBaseRateVector(baseRate, size) {
   const normalized = baseRate.map((value) => clampNonNegative(value));
   const total = normalized.reduce((sum, value) => sum + value, 0);
   if (total === 0) {
-    return fallback;
+    throw new Error("Base-rate vector must contain at least one positive value.");
   }
   return normalized.map((value) => value / total);
 }
-function opinionFromDirichlet(alpha, nonInformativeWeight = DEFAULT_NON_INFORMATIVE_WEIGHT, baseRate) {
+function opinionFromDirichlet(alpha, nonInformativeWeight, baseRate) {
   const evidence = alpha.map((value) => clampNonNegative(value));
   const safeWeight = normalizeNonInformativeWeight(nonInformativeWeight);
   const normalizedBaseRate = normalizeBaseRateVector(baseRate, evidence.length);
@@ -374,18 +415,18 @@ function projectDirichletOpinion(opinion2) {
     (belief, index) => belief + (opinion2.a[index] ?? 0) * opinion2.u
   );
 }
-function opinionFromBeta(alpha, beta, nonInformativeWeight = DEFAULT_NON_INFORMATIVE_WEIGHT, baseRate = 0.5) {
+function opinionFromBeta(alpha, beta, nonInformativeWeight, baseRate) {
   const dirichlet = opinionFromDirichlet(
     [alpha, beta],
     nonInformativeWeight,
     [clamp01(baseRate), 1 - clamp01(baseRate)]
   );
-  return {
-    b: dirichlet.b[0] ?? 0,
-    d: dirichlet.b[1] ?? 0,
-    u: dirichlet.u,
-    a: dirichlet.a[0] ?? clamp01(baseRate)
-  };
+  return mkOpinion(
+    dirichlet.b[0] ?? 0,
+    dirichlet.b[1] ?? 0,
+    dirichlet.u,
+    dirichlet.a[0] ?? clamp01(baseRate)
+  );
 }
 function betaFromOpinion(opinion2, nonInformativeWeight = DEFAULT_NON_INFORMATIVE_WEIGHT) {
   if (opinion2.u === 0) {
@@ -406,13 +447,22 @@ function betaFromOpinion(opinion2, nonInformativeWeight = DEFAULT_NON_INFORMATIV
 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;
+    }
+  }
+  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 = 0.5) {
+function confidenceFromSL(belief, _disbelief, uncertainty, baseRate) {
   return confidenceFromOpinion({
     b: belief,
     u: uncertainty,
@@ -427,34 +477,56 @@ function toStoredOpinionFields(opinion2) {
     baseRate: opinion2.a
   };
 }
-function readOpinionFromRecord(source, fallback = {}) {
+function readOpinionFromRecord(source) {
   const record = source && typeof source === "object" ? source : {};
-  return {
-    b: finiteNumber(record.b) ?? finiteNumber(record.belief) ?? finiteNumber(record.slBelief) ?? finiteNumber(record.opinion_b) ?? fallback.b ?? 0,
-    d: finiteNumber(record.d) ?? finiteNumber(record.disbelief) ?? finiteNumber(record.slDisbelief) ?? finiteNumber(record.opinion_d) ?? fallback.d ?? 0,
-    u: finiteNumber(record.u) ?? finiteNumber(record.uncertainty) ?? finiteNumber(record.slUncertainty) ?? finiteNumber(record.opinion_u) ?? fallback.u ?? 1,
-    a: finiteNumber(record.a) ?? finiteNumber(record.baseRate) ?? finiteNumber(record.slBaseRate) ?? finiteNumber(record.opinion_a) ?? fallback.a ?? 0.5
-  };
+  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 = clamp012(options?.baseRate ?? 0.5);
+  const baseRate = options?.baseRate === void 0 ? void 0 : clamp012(options.baseRate);
   switch (mode) {
     case "base_rate":
-      return {
-        b: 0,
-        d: 0,
-        u: 1,
-        a: clampedValue
-      };
+      return mkOpinion(0, 0, 1, clampedValue);
     case "dogmatic":
-      return {
-        b: clampedValue,
-        d: 1 - clampedValue,
-        u: 0,
-        a: baseRate
-      };
+      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(
@@ -463,35 +535,30 @@ function opinionFromScalar(value, mode, options) {
       }
       const clampedUncertainty = clamp012(uncertainty);
       const evidenceWeight = 1 - clampedUncertainty;
-      return {
-        b: clampedValue * evidenceWeight,
-        d: (1 - clampedValue) * evidenceWeight,
-        u: clampedUncertainty,
-        a: baseRate
-      };
+      return mkOpinion(
+        clampedValue * evidenceWeight,
+        (1 - clampedValue) * evidenceWeight,
+        clampedUncertainty,
+        baseRate
+      );
     }
   }
   throw new Error(`Unsupported opinionFromScalar mode: ${mode}`);
 }
-function toDogmaticOpinion(confidence, baseRate = 0.5) {
+function toDogmaticOpinion(confidence, baseRate) {
   return opinionFromScalar(confidence, "dogmatic", { baseRate });
 }
 function opinionFromBaseRate(probability) {
   return vacuous(clamp012(probability));
 }
-function opinionFromDogmatic(probability, baseRate = 0.5) {
+function opinionFromDogmatic(probability, baseRate) {
   return dogmatic(clamp012(probability), clamp012(baseRate));
 }
-function opinionFromProjected(probability, uncertainty, baseRate = 0.5) {
+function opinionFromProjected(probability, uncertainty, baseRate) {
   const p = clamp012(probability);
   const u = clamp012(uncertainty);
   const remainingMass = 1 - u;
-  return {
-    b: p * remainingMass,
-    d: (1 - p) * remainingMass,
-    u,
-    a: clamp012(baseRate)
-  };
+  return mkOpinion(p * remainingMass, (1 - p) * remainingMass, u, clamp012(baseRate));
 }
 function hasProjectedOpinionChanged(current, next, tolerance = 0.01) {
   return Math.abs(confidenceFromOpinion(next) - confidenceFromOpinion(current)) >= tolerance;
@@ -531,7 +598,14 @@ function evaluateTupleContradictionTransition(args) {
 
 // src/v1/operations/dynamics/cascade.ts
 function dampedDependencyOpinion(dependencyOpinion, beliefOpinion, mode = "continuous", threshold = 0.3) {
-  const dependencyProjection = project(dependencyOpinion);
+  const dependencyProjection = project(
+    mkOpinion(
+      dependencyOpinion.b,
+      dependencyOpinion.d,
+      dependencyOpinion.u,
+      dependencyOpinion.a
+    )
+  );
   if (mode === "threshold") {
     if (dependencyProjection < threshold) {
       return opinion(
@@ -556,40 +630,49 @@ function dampedDependencyCascade(dependencyOpinion, beliefOpinion, mode = "conti
     opinion: dampedDependencyOpinion(dependencyOpinion, beliefOpinion, mode),
     operator: "dependency_cascade",
     rationale: `Damped dependency cascade (${mode}): prerequisite at ${project(
-      dependencyOpinion
+      mkOpinion(
+        dependencyOpinion.b,
+        dependencyOpinion.d,
+        dependencyOpinion.u,
+        dependencyOpinion.a
+      )
     ).toFixed(2)}`
   };
 }
 
 // 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(
-      source,
-      target,
+      sourceOpinion,
+      targetOpinion,
       metadata.normalization ?? "pressure"
     );
     return {
       opinion: result.o2,
       operator: "constraint_fusion",
-      rationale: `XOR constraint: source belief at ${project(source).toFixed(
-        2
-      )} pressures target`
+      rationale: `XOR constraint: source belief at ${project(
+        sourceOpinion
+      ).toFixed(2)} pressures target`
     };
   }
-  const discounted = trustDiscount(negate(source), Math.abs(weight));
+  const discounted = trustDiscount(negate(sourceOpinion), Math.abs(weight));
   return {
-    opinion: cumulativeFusion(target, discounted),
+    opinion: cumulativeFusion(targetOpinion, discounted),
     operator: "cumulative_fusion",
     rationale: `Contradicting evidence (weight=${weight.toFixed(
       2
-    )}) from source at ${project(source).toFixed(2)}`
+    )}) from source at ${project(sourceOpinion).toFixed(2)}`
   };
 }
 function applyNegativeEvidence(source, target, weight) {
-  const discounted = trustDiscount(negate(source), Math.abs(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(target, discounted),
+    opinion: cumulativeFusion(targetOpinion, discounted),
     operator: "cumulative_fusion",
     rationale: `Contradicting evidence (weight=${weight.toFixed(2)})`
   };
@@ -600,28 +683,32 @@ 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(source, target, weight, metadata);
+        return applyNegativeSupport(sourceOpinion, targetOpinion, weight, metadata);
       }
-      const discounted = trustDiscount(source, weight);
+      const discounted = trustDiscount(sourceOpinion, weight);
       return {
-        opinion: cumulativeFusion(target, discounted),
+        opinion: cumulativeFusion(targetOpinion, discounted),
         operator: "cumulative_fusion",
         rationale: `Supporting evidence (weight=${weight.toFixed(
           2
-        )}) from source at ${project(source).toFixed(2)}`
+        )}) from source at ${project(sourceOpinion).toFixed(2)}`
       };
     }
   },
   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(source, target, weight);
+        return applyNegativeEvidence(sourceOpinion, targetOpinion, weight);
       }
-      const discounted = trustDiscount(source, Math.abs(weight));
+      const discounted = trustDiscount(sourceOpinion, Math.abs(weight));
       return {
-        opinion: cumulativeFusion(target, discounted),
+        opinion: cumulativeFusion(targetOpinion, discounted),
         operator: "cumulative_fusion",
         rationale: `Supporting evidence (weight=${weight.toFixed(2)})`
       };
@@ -630,23 +717,35 @@ var EDGE_PROPAGATION_RULES = {
   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(
-            source,
-            metadata.conditionalA,
-            metadata.conditionalNotA,
-            target.a
+            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(
-            source
+            sourceOpinion
           ).toFixed(2)}`
         };
       }
       return dampedDependencyCascade(
-        source,
-        target,
+        sourceOpinion,
+        targetOpinion,
         metadata.propagation ?? "continuous"
       );
     }
@@ -752,7 +851,7 @@ function reviseConfidenceOpinion(args) {
     priorEvidence.alpha + newEvidence.alpha,
     priorEvidence.beta + newEvidence.beta,
     args.nonInformativeWeight ?? DEFAULT_NON_INFORMATIVE_WEIGHT,
-    args.baseRate ?? 0.5
+    args.baseRate
   );
 }
 
@@ -1026,6 +1125,9 @@ function generateContractId() {
   }
   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;
@@ -1167,18 +1269,17 @@ function pickFiniteNumber(config, keys) {
   return void 0;
 }
 function getEvaluatorInputRecord(inputData, nestedKey) {
-  if (!inputData || typeof inputData !== "object") {
+  if (!isRecord(inputData)) {
     return {};
   }
-  const root = inputData;
-  const nested = root[nestedKey];
-  if (nested && typeof nested === "object") {
+  const nested = inputData[nestedKey];
+  if (isRecord(nested)) {
     return nested;
   }
-  return root;
+  return inputData;
 }
 function parseEvidentialEvaluatorConfig(value) {
-  if (!value || typeof value !== "object") {
+  if (!isRecord(value)) {
     throw new Error(
       "Evidential contracts require condition.evaluatorConfig with metric/operator/threshold."
     );
@@ -1196,7 +1297,7 @@ function parseEvidentialEvaluatorConfig(value) {
   if (typeof threshold !== "number" || !Number.isFinite(threshold)) {
     throw new Error("Evidential contracts require a numeric threshold.");
   }
-  const actionParams = config.actionParams && typeof config.actionParams === "object" && config.actionParams !== null ? config.actionParams : void 0;
+  const actionParams = isRecord(config.actionParams) ? config.actionParams : void 0;
   return {
     metric,
     operator,
@@ -1245,7 +1346,7 @@ function buildEvidentialRationale(args) {
   return `${clause}; comparison ${args.comparisonSatisfied ? "passed" : "failed"}, resulting in ${args.result}.`;
 }
 function parseMetricCheckerConfig(value) {
-  if (!value || typeof value !== "object") {
+  if (!isRecord(value)) {
     throw new Error(
       "metric_checker requires condition.evaluatorConfig with observedValue/operator/threshold."
     );
@@ -1262,7 +1363,7 @@ function parseMetricCheckerConfig(value) {
   };
 }
 function parseReferenceCheckCounterConfig(value) {
-  if (!value || typeof value !== "object") {
+  if (!isRecord(value)) {
     throw new Error(
       "reference_check_counter requires condition.evaluatorConfig with tag/operator/threshold."
     );
@@ -1285,7 +1386,7 @@ function parseReferenceCheckCounterConfig(value) {
   };
 }
 function parseTemporalDeadlineConfig(value) {
-  if (!value || typeof value !== "object") {
+  if (!isRecord(value)) {
     return {};
   }
   const config = value;
@@ -1299,7 +1400,7 @@ function parseTemporalDeadlineConfig(value) {
   };
 }
 function parseMarketIndexComparatorConfig(value) {
-  if (!value || typeof value !== "object") {
+  if (!isRecord(value)) {
     throw new Error(
       "market_index_comparator requires condition.evaluatorConfig with subjectValue/benchmarkValue/operator/threshold."
     );
@@ -1338,6 +1439,7 @@ var SL_APPROXIMATION_OPERATOR_NAMES = [
 
 // src/v1/operations/canonical.ts
 var SL_CANONICAL_OPERATOR_NAMES = [
+  "mkOpinion",
   "opinion",
   "vacuous",
   "dogmatic",
@@ -1355,6 +1457,8 @@ var SL_CANONICAL_OPERATOR_NAMES = [
 // src/v1/operations/lucern.ts
 var LUCERN_SPECIFIC_OPERATOR_NAMES = [
   "clamp01",
+  "fromStorage",
+  "toStorage",
   "toStoredOpinionFields",
   "readOpinionFromRecord",
   "opinionFromScalar",
@@ -1375,6 +1479,7 @@ var LUCERN_SPECIFIC_OPERATOR_NAMES = [
   "propagateAllEdges",
   "bayesianUpdate",
   "reviseConfidence",
+  "reviseConfidenceOpinion",
   "computeBaseDecay",
   "computeDeadlineUrgency",
   "computeEffectiveDecay",
@@ -1414,6 +1519,12 @@ var PUBLIC_OPERATOR_EXPORT_NAMES = [
   ...LUCERN_SPECIFIC_OPERATOR_NAMES
 ];
 var OPERATOR_TAXONOMY_ENTRIES = [
+  {
+    operator: "mkOpinion",
+    tag: "SL_CANONICAL",
+    sourceModule: "operations/subjectiveLogic/index.ts",
+    rationale: "Constructs the canonical binomial SL opinion tuple and normalizes it into valid mass components."
+  },
   {
     operator: "opinion",
     tag: "SL_CANONICAL",
@@ -1546,6 +1657,18 @@ var OPERATOR_TAXONOMY_ENTRIES = [
     sourceModule: "operations/scoring.ts",
     rationale: "Implementation helper for Lucern APIs; it has no direct J\xF8sang operator analogue."
   },
+  {
+    operator: "fromStorage",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "codec.ts",
+    rationale: "Reads Lucern storage fields into a normalized opinion and reports repair metadata; it is storage glue, not SL algebra."
+  },
+  {
+    operator: "toStorage",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "codec.ts",
+    rationale: "Serializes a normalized opinion into Lucern storage fields rather than implementing an SL algebra operator."
+  },
   {
     operator: "toStoredOpinionFields",
     tag: "LUCERN_SPECIFIC",
@@ -1666,6 +1789,12 @@ var OPERATOR_TAXONOMY_ENTRIES = [
     sourceModule: "operations/dynamics/revision.ts",
     rationale: "Lucern wrapper around the scalar Bayesian revision helper rather than a direct SL operator."
   },
+  {
+    operator: "reviseConfidenceOpinion",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/dynamics/revision.ts",
+    rationale: "Lucern revision helper that exposes the Beta-bridge opinion behind scalar confidence revision."
+  },
   {
     operator: "computeBaseDecay",
     tag: "LUCERN_SPECIFIC",
@@ -1828,6 +1957,6 @@ var OPERATOR_TAXONOMY_BY_TAG = Object.freeze({
   LUCERN_SPECIFIC: LUCERN_SPECIFIC_OPERATOR_NAMES
 });
 
-export { BUILT_IN_EVIDENTIAL_ALIASES, BUILT_IN_EVIDENTIAL_EVALUATOR, BUILT_IN_MARKET_INDEX_COMPARATOR, BUILT_IN_METRIC_CHECKER, BUILT_IN_REFERENCE_CHECK_COUNTER, BUILT_IN_TEMPORAL_DEADLINE, DEADLINE_URGENCY, DECAY_TIERS, DEFAULT_NON_INFORMATIVE_WEIGHT, DEFAULT_TEMPORAL_DECAY_HALF_LIFE_MS, DEFAULT_TUPLE_CONTRADICTION_BELIEF_THRESHOLD, DEFAULT_TUPLE_CONTRADICTION_DISBELIEF_THRESHOLD, OPERATOR_TAXONOMY, OPERATOR_TAXONOMY_BY_TAG, OPERATOR_TAXONOMY_ENTRIES, OPERATOR_TAXONOMY_TAGS, PROPAGATION_TRAVERSAL_SPECS, PUBLIC_OPERATOR_EXPORT_NAMES, applyNegativeEvidence, applyNegativeSupport, areTensioned, averagingFusion, bayesianUpdate, betaFromOpinion, buildComparisonRationale, buildEvidentialRationale, clamp012 as clamp01, compareMetricValue, computeBaseDecay, computeDeadlineUrgency, computeEffectiveDecay, conditionalAbduction, conditionalDeduction, confidenceFromOpinion, confidenceFromSL, confidenceLevel, constraintFusion, createInheritedContractRecord, cumulativeFusion, dampedDependencyCascade, dampedDependencyOpinion, decay, deriveContractModulationPlan, deriveContractStatus, deriveVerificationTrigger, detectTupleContradiction, dogmatic, evaluateTupleContradictionTransition, evidenceBalance, getEvaluatorInputRecord, getPropagationTraversalSpecs, getRescoringSchedule, hasProjectedOpinionChanged, informationGain, isPropagationEdgeType, negate, normalizeEvidentialAction, normalizeTupleContradictionPolicy, opinion, opinionFromBaseRate, opinionFromBeta, opinionFromDirichlet, opinionFromDogmatic, opinionFromProjected, opinionFromScalar, parseComparisonOperator, parseEvidentialEvaluatorConfig, parseMarketIndexComparatorConfig, parseMetricCheckerConfig, parseNumericThreshold, parseReferenceCheckCounterConfig, parseTemporalDeadlineConfig, pickFiniteNumber, project, projectDirichletOpinion, propagateAllEdges, propagateThroughEdge, readOpinionFromRecord, resolveComparisonResult, reviseConfidence, reviseConfidenceOpinion, temporalDecay, toDogmaticOpinion, toStoredOpinionFields, trustDiscount, vacuous };
+export { BUILT_IN_EVIDENTIAL_ALIASES, BUILT_IN_EVIDENTIAL_EVALUATOR, BUILT_IN_MARKET_INDEX_COMPARATOR, BUILT_IN_METRIC_CHECKER, BUILT_IN_REFERENCE_CHECK_COUNTER, BUILT_IN_TEMPORAL_DEADLINE, DEADLINE_URGENCY, DECAY_TIERS, DEFAULT_NON_INFORMATIVE_WEIGHT, DEFAULT_TEMPORAL_DECAY_HALF_LIFE_MS, DEFAULT_TUPLE_CONTRADICTION_BELIEF_THRESHOLD, DEFAULT_TUPLE_CONTRADICTION_DISBELIEF_THRESHOLD, OPERATOR_TAXONOMY, OPERATOR_TAXONOMY_BY_TAG, OPERATOR_TAXONOMY_ENTRIES, OPERATOR_TAXONOMY_TAGS, PROPAGATION_TRAVERSAL_SPECS, PUBLIC_OPERATOR_EXPORT_NAMES, SLOpinionRefinement, applyNegativeEvidence, applyNegativeSupport, areTensioned, averagingFusion, bayesianUpdate, betaFromOpinion, buildComparisonRationale, buildEvidentialRationale, clamp012 as clamp01, compareMetricValue, computeBaseDecay, computeDeadlineUrgency, computeEffectiveDecay, conditionalAbduction, conditionalDeduction, confidenceFromOpinion, confidenceFromSL, confidenceLevel, constraintFusion, createInheritedContractRecord, cumulativeFusion, dampedDependencyCascade, dampedDependencyOpinion, decay, deriveContractModulationPlan, deriveContractStatus, deriveVerificationTrigger, detectTupleContradiction, dogmatic, evaluateTupleContradictionTransition, evidenceBalance, fromStorage, getEvaluatorInputRecord, getPropagationTraversalSpecs, getRescoringSchedule, hasProjectedOpinionChanged, informationGain, isPropagationEdgeType, mkOpinion, negate, normalizeEvidentialAction, normalizeTupleContradictionPolicy, opinion, opinionFromBaseRate, opinionFromBeta, opinionFromDirichlet, opinionFromDogmatic, opinionFromProjected, opinionFromScalar, parseComparisonOperator, parseEvidentialEvaluatorConfig, parseMarketIndexComparatorConfig, parseMetricCheckerConfig, parseNumericThreshold, parseReferenceCheckCounterConfig, parseTemporalDeadlineConfig, pickFiniteNumber, project, projectDirichletOpinion, propagateAllEdges, propagateThroughEdge, readOpinionFromRecord, resolveComparisonResult, reviseConfidence, reviseConfidenceOpinion, temporalDecay, toDogmaticOpinion, toStorage, toStoredOpinionFields, trustDiscount, vacuous };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map