@higher.archi/boe 1.0.7 → 1.0.9

package/src/engines/monte-carlo/strategy.ts

@@ -14,7 +14,7 @@
 
 import { IWorkingMemory } from '../../core/memory';
 import { Fact } from '../../core/types/fact';
-import { compileCondition, evaluateCondition, Condition } from '../../core';
+import { compileCondition, evaluateCondition, Condition, RuntimeError } from '../../core';
 
 import {
   CompiledMonteCarloRuleSet,
@@ -137,7 +137,7 @@ function sampleVariable(
     case 'discrete':
       return sampleDiscrete(params.options!, params.weights!, random);
     default:
-      throw new Error(`Unknown distribution: ${distribution}`);
+      throw new RuntimeError(`Unknown distribution: ${distribution}`);
   }
 }
 

package/src/engines/pricing/compiler.ts

@@ -9,7 +9,8 @@
 
 import {
   compileCondition,
-  compileOperand
+  compileOperand,
+  CompilationError
 } from '../../core';
 
 import {
@@ -61,7 +62,7 @@ function validateScenarioValues(
     for (const [field, schema] of Object.entries(scenarioSchema)) {
       if (schema.required && values[field] === undefined && schema.default === undefined) {
         if (strict) {
-          throw new Error(
+          throw new CompilationError(
             `Component '${component.sku}' missing required scenario value '${field}' for scenario '${scenarioId}'`
           );
         }
@@ -72,7 +73,7 @@ function validateScenarioValues(
     for (const [field, value] of Object.entries(values)) {
       const schema = scenarioSchema[field];
       if (!schema) {
-        throw new Error(
+        throw new CompilationError(
           `Component '${component.sku}' has unknown scenario field '${field}' for scenario '${scenarioId}'`
         );
       }
@@ -94,19 +95,19 @@ function validateValue(
 
   const actualType = Array.isArray(value) ? 'array' : typeof value;
   if (actualType !== schema.type) {
-    throw new Error(
+    throw new CompilationError(
       `Invalid type for '${path}': expected ${schema.type}, got ${actualType}`
     );
   }
 
   if (schema.type === 'number' && typeof value === 'number') {
     if (schema.min !== undefined && value < schema.min) {
-      throw new Error(
+      throw new CompilationError(
         `Value for '${path}' is below minimum: ${value} < ${schema.min}`
       );
     }
     if (schema.max !== undefined && value > schema.max) {
-      throw new Error(
+      throw new CompilationError(
         `Value for '${path}' exceeds maximum: ${value} > ${schema.max}`
       );
     }
@@ -114,7 +115,7 @@ function validateValue(
 
   if (schema.type === 'string' && schema.enum && typeof value === 'string') {
     if (!schema.enum.includes(value)) {
-      throw new Error(
+      throw new CompilationError(
         `Invalid value for '${path}': '${value}' not in [${schema.enum.join(', ')}]`
       );
     }
@@ -161,7 +162,7 @@ function compilePricingMode(pricing: PricingMode): CompiledPricingMode {
       // Validate tiers are in order
       for (let i = 1; i < pricing.tiers.length; i++) {
         if (pricing.tiers[i].upTo <= pricing.tiers[i - 1].upTo) {
-          throw new Error(
+          throw new CompilationError(
             `Graduated tiers must be in ascending order by 'upTo' value`
           );
         }
@@ -175,7 +176,7 @@ function compilePricingMode(pricing: PricingMode): CompiledPricingMode {
       // Validate brackets are in order
       for (let i = 1; i < pricing.brackets.length; i++) {
         if (pricing.brackets[i].minVolume <= pricing.brackets[i - 1].minVolume) {
-          throw new Error(
+          throw new CompilationError(
             `Volume brackets must be in ascending order by 'minVolume' value`
           );
         }
@@ -362,7 +363,7 @@ export function compilePricingRuleSet(ruleSet: PricingRuleSet): CompiledPricingR
       currencyInfo,
       precision
     },
-    rules: ruleSet.rules.map(rule =>
+    rules: ruleSet.rules.filter(r => !r.disabled).map(rule =>
       compileRule(rule, productTypes, scenarioIds, strict)
     )
   };

package/src/engines/pricing/strategy.ts

@@ -8,7 +8,7 @@
  * - Computes metrics for comparison
  */
 
-import { CompiledOperand, CompiledCondition } from '../../core';
+import { CompiledOperand, CompiledCondition, RuntimeError } from '../../core';
 
 import {
   CompiledPricingRuleSet,
@@ -218,7 +218,7 @@ function executePricingMode(
     }
 
     case 'multi-meter':
-      throw new Error('Multi-meter should be handled by executeMeter');
+      throw new RuntimeError('Multi-meter should be handled by executeMeter');
   }
 }
 
@@ -564,7 +564,7 @@ export class PricingStrategy {
     // Find the rule
     const rule = ruleSet.rules.find(r => r.id === ruleId);
     if (!rule) {
-      throw new Error(`Rule not found: ${ruleId}`);
+      throw new RuntimeError(`Rule not found: ${ruleId}`);
     }
 
     // Determine scenario
@@ -573,12 +573,12 @@ export class PricingStrategy {
       || Object.keys(ruleSet.scenarios.definitions)[0];
 
     if (!scenarioId) {
-      throw new Error('No scenario specified and no default scenario defined');
+      throw new RuntimeError('No scenario specified and no default scenario defined');
     }
 
     const scenarioDefinition = ruleSet.scenarios.definitions[scenarioId];
     if (!scenarioDefinition && Object.keys(ruleSet.scenarios.definitions).length > 0) {
-      throw new Error(`Unknown scenario: ${scenarioId}`);
+      throw new RuntimeError(`Unknown scenario: ${scenarioId}`);
     }
 
     // Execute components
@@ -678,7 +678,7 @@ export class PricingStrategy {
       || Object.keys(ruleSet.scenarios.definitions);
 
     if (scenarios.length === 0) {
-      throw new Error('No scenarios to calculate');
+      throw new RuntimeError('No scenarios to calculate');
     }
 
     // Calculate each scenario
@@ -687,7 +687,7 @@ export class PricingStrategy {
     for (const scenarioId of scenarios) {
       const scenarioDefinition = ruleSet.scenarios.definitions[scenarioId];
       if (!scenarioDefinition) {
-        throw new Error(`Unknown scenario: ${scenarioId}`);
+        throw new RuntimeError(`Unknown scenario: ${scenarioId}`);
       }
 
       const pricingResult = this.calculate(ruleSet, ruleId, { scenario: scenarioId });

package/src/engines/pricing/types.ts

@@ -430,6 +430,8 @@ export type PricingRule = {
   name?: string;
   /** Description */
   description?: string;
+  /** Skip this rule during compilation (default: false) */
+  disabled?: boolean;
   /** Input bindings (for potential future filtering) */
   inputs?: PricingInput[];
   /** The pricing package */

package/src/engines/scoring/compiler.ts

@@ -5,7 +5,8 @@
 import {
   compileCondition,
   normalizeShape,
-  Condition
+  Condition,
+  CompilationError
 } from '../../core';
 
 import {
@@ -77,7 +78,18 @@ function compileInputParameter(input: any) {
 // ========================================
 
 function compileScoringAction(action: any): CompiledScoringAction {
-  const { score, weight, normalize, reason, nullHandling } = action;
+  const { score, weight, normalize, reason, nullHandling, decay } = action;
+
+  // Compile decay timestamp if it's an expression
+  let compiledDecay: CompiledScoringAction['decay'] | undefined;
+  if (decay) {
+    compiledDecay = {
+      timestamp: Array.isArray(decay.timestamp)
+        ? compileCondition(decay.timestamp as Condition)
+        : decay.timestamp,
+      config: decay.config
+    };
+  }
 
   // Handle expression scores
   if (Array.isArray(score)) {
@@ -87,7 +99,8 @@ function compileScoringAction(action: any): CompiledScoringAction {
       weight,
       normalize,
       reason,
-      nullHandling
+      nullHandling,
+      decay: compiledDecay
     };
   }
 
@@ -98,7 +111,8 @@ function compileScoringAction(action: any): CompiledScoringAction {
     weight,
     normalize,
     reason,
-    nullHandling
+    nullHandling,
+    decay: compiledDecay
   };
 }
 
@@ -136,6 +150,7 @@ function compileOverride(override: OverrideDefinition): CompiledOverrideDefiniti
 // ========================================
 
 export function compileScoringRuleSet(ruleSet: ScoringRuleSet): CompiledScoringRuleSet {
+  const activeRules = ruleSet.rules.filter(r => !r.disabled);
   const categories = ruleSet.config?.categories;
 
   // Validate categories if defined
@@ -143,14 +158,14 @@ export function compileScoringRuleSet(ruleSet: ScoringRuleSet): CompiledScoringR
     const categoryIds = new Set(categories.map(c => c.id));
 
     // Every rule must reference a valid category
-    for (const rule of ruleSet.rules) {
+    for (const rule of activeRules) {
       if (!rule.category) {
-        throw new Error(
+        throw new CompilationError(
           `Rule "${rule.id}" is missing a category. When categories are defined, every rule must have a category.`
         );
       }
       if (!categoryIds.has(rule.category)) {
-        throw new Error(
+        throw new CompilationError(
           `Rule "${rule.id}" references unknown category "${rule.category}". Valid categories: ${[...categoryIds].join(', ')}`
         );
       }
@@ -176,12 +191,12 @@ export function compileScoringRuleSet(ruleSet: ScoringRuleSet): CompiledScoringR
       // Validate tier effects reference valid tiers
       if (override.effect === 'force_tier' || override.effect === 'floor_tier' || override.effect === 'cap_tier') {
         if (!tierIds.size) {
-          throw new Error(
+          throw new CompilationError(
             `Override "${override.id}" uses effect "${override.effect}" but no tiers are defined.`
           );
         }
         if (!tierIds.has(override.targetTier)) {
-          throw new Error(
+          throw new CompilationError(
             `Override "${override.id}" references unknown tier "${override.targetTier}". Valid tiers: ${[...tierIds].join(', ')}`
           );
         }
@@ -200,7 +215,8 @@ export function compileScoringRuleSet(ruleSet: ScoringRuleSet): CompiledScoringR
     tiers: ruleSet.config?.tiers,
     categories,
     overrides,
-    nullHandling: ruleSet.config?.nullHandling
+    nullHandling: ruleSet.config?.nullHandling,
+    decay: ruleSet.config?.decay
   };
 
   return {
@@ -208,7 +224,7 @@ export function compileScoringRuleSet(ruleSet: ScoringRuleSet): CompiledScoringR
     name: ruleSet.name,
     mode: 'scoring',
     schema: ruleSet.shape ? normalizeShape(ruleSet.shape) : { type: 'object' },
-    rules: ruleSet.rules.map((rule, index) => compileScoringRule(rule, index)),
+    rules: activeRules.map((rule, index) => compileScoringRule(rule, index)),
     config,
     overrides: compiledOverrides
   };

package/src/engines/scoring/strategy.ts

@@ -7,9 +7,16 @@
 
 import {
   match,
-  evaluateCondition
+  evaluateCondition,
+  RuntimeError
 } from '../../core';
 import { IWorkingMemory } from '../../core/memory';
+import {
+  calculateDecayMultiplier,
+  resolveDecayTimestamp,
+  DecayConfig,
+  DecayInfo
+} from '../../core/evaluation/decay';
 
 import {
   CompiledScoringRuleSet,
@@ -49,8 +56,12 @@ export class ScoringStrategy {
     const weights: Record<string, number> = {};
     const fired: string[] = [];
     const rawScores: Record<string, number[]> = {}; // Track raw scores for adaptive
+    const decayInfoMap: Record<string, DecayInfo> = {};
+    const decayMultipliers: Record<string, number> = {};
 
     // Phase 1: Calculate base scores
+    const now = new Date();
+
     for (const rule of ruleSet.rules) {
       const activations = match(rule, wm);
 
@@ -64,14 +75,42 @@ export class ScoringStrategy {
         } else if (typeof ruleAction.score === 'string') {
           const scoreFunc = scoreFunctions[ruleAction.score];
           if (!scoreFunc) {
-            throw new Error(`Score function not found: ${ruleAction.score}`);
+            throw new RuntimeError(`Score function not found: ${ruleAction.score}`);
           }
           baseScore = scoreFunc(activation.facts);
         } else if (typeof ruleAction.score === 'object' && 'op' in ruleAction.score) {
           const result = evaluateCondition(ruleAction.score as any, activation.facts);
           baseScore = typeof result === 'number' ? result : 0;
         } else {
-          throw new Error(`Invalid score type: ${typeof ruleAction.score}`);
+          throw new RuntimeError(`Invalid score type: ${typeof ruleAction.score}`);
+        }
+
+        // Apply temporal decay if configured
+        if (!decayMultipliers[rule.id]) {
+          const ruleDecay = ruleAction.decay;
+          const engineDecay = config.decay;
+
+          if (ruleDecay || engineDecay) {
+            // Resolve timestamp: rule-level overrides engine-level
+            const tsRef = ruleDecay?.timestamp ?? engineDecay?.timestamp;
+            let dataTimestamp: Date | null = null;
+
+            if (typeof tsRef === 'string') {
+              dataTimestamp = resolveDecayTimestamp(tsRef, activation.facts);
+            }
+
+            if (dataTimestamp) {
+              // Merge decay config: rule-level overrides engine-level
+              const decayConfig: DecayConfig = {
+                ...(engineDecay?.config ?? { curve: 'exponential', timeUnit: 'days' }),
+                ...ruleDecay?.config
+              } as DecayConfig;
+
+              const info = calculateDecayMultiplier(dataTimestamp, now, decayConfig);
+              decayInfoMap[rule.id] = info;
+              decayMultipliers[rule.id] = info.multiplier;
+            }
+          }
         }
 
         // Store raw scores for adaptive strategy
@@ -139,6 +178,20 @@ export class ScoringStrategy {
       contributions[rule.id] = accumulatedScore;
     }
 
+    // Phase 2.25: Apply decay multipliers to contributions
+    const hasDecay = Object.keys(decayInfoMap).length > 0;
+    let contributionsBeforeDecay: Record<string, number> | undefined;
+
+    if (hasDecay) {
+      contributionsBeforeDecay = {};
+      for (const ruleId in contributions) {
+        contributionsBeforeDecay[ruleId] = contributions[ruleId];
+        if (decayMultipliers[ruleId] !== undefined) {
+          contributions[ruleId] *= decayMultipliers[ruleId];
+        }
+      }
+    }
+
     // Phase 2.5: Null handling — treat unfired 'zero' rules as fired with score 0
     for (const rule of ruleSet.rules) {
       if (!fired.includes(rule.id)) {
@@ -501,6 +554,12 @@ export class ScoringStrategy {
 
     const executionTimeMs = Math.round((performance.now() - startTime) * 100) / 100;
 
+    // Compute totalScoreBeforeDecay if decay was applied
+    let totalScoreBeforeDecay: number | undefined;
+    if (hasDecay && contributionsBeforeDecay) {
+      totalScoreBeforeDecay = baseScore + Object.values(contributionsBeforeDecay).reduce((sum, s) => sum + s, 0);
+    }
+
     return {
       totalScore,
       confidence,
@@ -511,6 +570,11 @@ export class ScoringStrategy {
       tier,
       categoryBreakdown,
       override: overrideResult,
+      ...(hasDecay ? {
+        totalScoreBeforeDecay,
+        contributionsBeforeDecay,
+        decayInfo: decayInfoMap
+      } : {}),
       executionTimeMs
     };
   }

package/src/engines/scoring/types.ts

@@ -13,6 +13,8 @@ import {
   BindingContext
 } from '../../core';
 
+import { DecayConfig, DecayInfo } from '../../core/evaluation/decay';
+
 // ========================================
 // Scoring Method Types
 // ========================================
@@ -268,6 +270,10 @@ export type ScoringAction = {
   normalize?: { min: number; max: number };  // Optional normalization bounds
   reason?: string;  // Optional human-readable explanation for the score
   nullHandling?: NullHandling;  // How to handle if this signal is missing (default: 'exclude')
+  decay?: {
+    timestamp: string | Expression;  // e.g. '$inspection.date'
+    config?: Partial<DecayConfig>;   // overrides engine-level defaults
+  };
 };
 
 /**
@@ -300,6 +306,10 @@ export type ScoringConfig = {
   categories?: ScoringCategory[]; // Optional category grouping for two-level weight hierarchy
   overrides?: OverrideDefinition[]; // Optional post-scoring overrides evaluated in order (first match wins)
   nullHandling?: NullHandling;  // Default null handling for all rules (default: 'exclude')
+  decay?: {
+    timestamp?: string | Expression;  // default timestamp path for all rules
+    config: DecayConfig;              // engine-level decay config
+  };
 };
 
 // ========================================
@@ -316,6 +326,10 @@ export type CompiledScoringAction = {
   normalize?: { min: number; max: number };
   reason?: string;  // Preserved from source for reporting
   nullHandling?: NullHandling;  // Preserved from source
+  decay?: {
+    timestamp: string | CompiledCondition;  // string = $path, CompiledCondition = expression
+    config?: Partial<DecayConfig>;
+  };
 };
 
 /**
@@ -384,5 +398,8 @@ export type ScoringResult = {
   tier?: ScoringTierMatch;  // Matched tier (if tiers configured)
   categoryBreakdown?: CategoryResult[];  // Per-category breakdown (if categories configured)
   override?: OverrideResult;  // Override that fired (if any)
+  totalScoreBeforeDecay?: number;                        // undecayed total for comparison
+  contributionsBeforeDecay?: Record<string, number>;     // undecayed per-rule contributions
+  decayInfo?: Record<string, DecayInfo>;                 // per-rule decay audit
   executionTimeMs: number;  // Processing time in milliseconds
 };

package/src/engines/sequential/compiler.ts

@@ -8,7 +8,8 @@ import {
   parsePath,
   normalizeShape,
   Condition,
-  PropertyRef
+  PropertyRef,
+  CompilationError
 } from '../../core';
 
 import {
@@ -77,7 +78,7 @@ function compileActionItem(item: ActionItem): CompiledActionItem {
 
     for (const [targetPath, value] of Object.entries(item.set)) {
       if (!isPropertyRef(targetPath)) {
-        throw new Error(`Set target must be a property reference, got: ${targetPath}`);
+        throw new CompilationError(`Set target must be a property reference, got: ${targetPath}`);
       }
 
       if (isExpression(value)) {
@@ -101,7 +102,7 @@ function compileActionItem(item: ActionItem): CompiledActionItem {
   if ('retract' in item) {
     const ref = item.retract;
     if (!isPropertyRef(ref)) {
-      throw new Error(`Retract must be a property reference, got: ${ref}`);
+      throw new CompilationError(`Retract must be a property reference, got: ${ref}`);
     }
     const paramName = ref.slice(1).split('.')[0];
     return { retract: paramName };
@@ -117,7 +118,7 @@ function compileActionItem(item: ActionItem): CompiledActionItem {
     return { halt: true };
   }
 
-  throw new Error(`Unknown action item type: ${JSON.stringify(item)}`);
+  throw new CompilationError(`Unknown action item type: ${JSON.stringify(item)}`);
 }
 
 function normalizeThenValue(value: ThenValue): ActionItem[] {
@@ -195,7 +196,7 @@ export function compileSequentialRuleSet(ruleSet: SequentialRuleSet): CompiledSe
     name: ruleSet.name,
     mode: 'sequential',
     schema: ruleSet.shape ? normalizeShape(ruleSet.shape) : { type: 'object' },
-    rules: ruleSet.rules.map((rule, index) => compileSequentialRule(rule, index)),
+    rules: ruleSet.rules.filter(r => !r.disabled).map((rule, index) => compileSequentialRule(rule, index)),
     config
   };
 }

package/src/engines/sequential/strategy.ts

@@ -5,7 +5,7 @@
  * and executes the first matching rule only.
  */
 
-import { match } from '../../core';
+import { match, RuntimeError } from '../../core';
 import { IWorkingMemory } from '../../core/memory';
 
 import {
@@ -93,7 +93,7 @@ export class SequentialStrategy {
           if ('call' in item) {
             const handler = actions[item.call];
             if (!handler) {
-              throw new Error(`Action not found: ${item.call}`);
+              throw new RuntimeError(`Action not found: ${item.call}`);
             }
             handler(activation.facts, wm);
           }

package/src/engines/state-machine/compiler.ts

@@ -4,7 +4,7 @@
  * Compiles state machine definitions into an optimized format for execution.
  */
 
-import { compileCondition } from '../../core';
+import { compileCondition, CompilationError } from '../../core';
 
 import {
   StateMachineDefinition,
@@ -70,7 +70,7 @@ function compileAction(action: StateMachineActionItem): CompiledStateMachineActi
     };
   }
 
-  throw new Error(`Unknown action format: ${JSON.stringify(action)}`);
+  throw new CompilationError(`Unknown action format: ${JSON.stringify(action)}`);
 }
 
 function compileActions(actions?: StateMachineActionItem[]): CompiledStateMachineAction[] {
@@ -160,7 +160,7 @@ function buildStateMap(
 function validateStateMachine(definition: StateMachineDefinition): void {
   // Check initial state exists
   if (!definition.states[definition.initial]) {
-    throw new Error(`Initial state '${definition.initial}' does not exist`);
+    throw new CompilationError(`Initial state '${definition.initial}' does not exist`);
   }
 
   // Validate all transition targets exist
@@ -201,7 +201,7 @@ function validateStateMachine(definition: StateMachineDefinition): void {
         const targetExists = possibleTargets.some(t => allStateNames.has(t));
 
         if (!targetExists && !allStateNames.has(target)) {
-          throw new Error(
+          throw new CompilationError(
             `Invalid transition target '${transition.target}' from state '${fullName}'`
           );
         }
@@ -209,7 +209,7 @@ function validateStateMachine(definition: StateMachineDefinition): void {
 
       // Validate compound state has initial
       if (state.states && !state.initial) {
-        throw new Error(`Compound state '${fullName}' must have an 'initial' property`);
+        throw new CompilationError(`Compound state '${fullName}' must have an 'initial' property`);
       }
 
       // Recursively validate nested states

package/src/engines/state-machine/strategy.ts

@@ -5,6 +5,8 @@
  * Each instance tracks its own state, context, and history.
  */
 
+import { RuntimeError } from '../../core';
+
 import {
   CompiledStateMachineDefinition,
   CompiledStateDefinition,
@@ -557,7 +559,7 @@ class StateMachineInstance implements IStateMachineInstance {
             );
             executed.push(`call:${action.handler}`);
           } else if (this.definition.config.strict) {
-            throw new Error(`Action handler not found: ${action.handler}`);
+            throw new RuntimeError(`Action handler not found: ${action.handler}`);
           }
         }
         break;

package/src/engines/utility/compiler.ts

@@ -5,7 +5,8 @@
 import {
   compileCondition,
   normalizeShape,
-  Condition
+  Condition,
+  CompilationError
 } from '../../core';
 
 import {
@@ -88,7 +89,7 @@ function resolveWeight(weight: number | string): number {
   if (isSemanticPriority(weight)) {
     return SEMANTIC_PRIORITY_VALUES[weight];
   }
-  throw new Error(`Invalid weight value: ${weight}. Must be a number (0-1) or SemanticPriority`);
+  throw new CompilationError(`Invalid weight value: ${weight}. Must be a number (0-1) or SemanticPriority`);
 }
 
 /**
@@ -100,7 +101,7 @@ function compileCriterion(criterion: UtilityCriterion): CompiledUtilityCriterion
 
   // For numeric weights, validate 0-1 range (semantic weights use different scale)
   if (typeof criterion.weight === 'number' && (numericWeight < 0 || numericWeight > 1)) {
-    throw new Error(`Numeric criterion weight must be between 0 and 1, got ${numericWeight} for "${criterion.id}"`);
+    throw new CompilationError(`Numeric criterion weight must be between 0 and 1, got ${numericWeight} for "${criterion.id}"`);
   }
 
   return {
@@ -119,7 +120,7 @@ function normalizeWeights(criteria: CompiledUtilityCriterion[]): void {
   const totalWeight = criteria.reduce((sum, c) => sum + c.weight, 0);
 
   if (totalWeight === 0) {
-    throw new Error('At least one criterion must have a non-zero weight');
+    throw new CompilationError('At least one criterion must have a non-zero weight');
   }
 
   for (const criterion of criteria) {
@@ -158,7 +159,7 @@ export function compileUtilityRule(rule: UtilityRule, index: number = 0): Compil
 export function compileUtilityRuleSet(ruleSet: UtilityRuleSet): CompiledUtilityRuleSet {
   // Validate criteria
   if (!ruleSet.criteria || ruleSet.criteria.length === 0) {
-    throw new Error('UtilityRuleSet must have at least one criterion');
+    throw new CompilationError('UtilityRuleSet must have at least one criterion');
   }
 
   // Check if any criteria use semantic weights
@@ -176,7 +177,7 @@ export function compileUtilityRuleSet(ruleSet: UtilityRuleSet): CompiledUtilityR
     // Numeric weights: validate they sum to ~1.0, then normalize for precision
     const totalWeight = compiledCriteria.reduce((sum, c) => sum + c.weight, 0);
     if (Math.abs(totalWeight - 1.0) > 0.01) {
-      throw new Error(`Criterion weights must sum to 1.0, got ${totalWeight.toFixed(4)}`);
+      throw new CompilationError(`Criterion weights must sum to 1.0, got ${totalWeight.toFixed(4)}`);
     }
     // Normalize for floating point precision
     normalizeWeights(compiledCriteria);
@@ -186,7 +187,7 @@ export function compileUtilityRuleSet(ruleSet: UtilityRuleSet): CompiledUtilityR
   const criterionIds = new Set(compiledCriteria.map(c => c.id));
   for (const rule of ruleSet.rules) {
     if (!criterionIds.has(rule.criterion)) {
-      throw new Error(`Rule "${rule.id}" references unknown criterion "${rule.criterion}"`);
+      throw new CompilationError(`Rule "${rule.id}" references unknown criterion "${rule.criterion}"`);
     }
   }
 
@@ -202,7 +203,7 @@ export function compileUtilityRuleSet(ruleSet: UtilityRuleSet): CompiledUtilityR
     mode: 'utility',
     schema: ruleSet.shape ? normalizeShape(ruleSet.shape) : { type: 'object' },
     criteria: compiledCriteria,
-    rules: ruleSet.rules.map((rule, index) => compileUtilityRule(rule, index)),
+    rules: ruleSet.rules.filter(r => !r.disabled).map((rule, index) => compileUtilityRule(rule, index)),
     config
   };
 }

package/src/index.ts

@@ -375,6 +375,22 @@ export type {
 
 export { soundex, nysiis, caverphone2, cosineSimilarity } from './functions';
 
+// Typed Errors (re-exported from core for convenience)
+export { BOEError, CompilationError, RuntimeError } from './core/errors';
+export type { ErrorContext } from './core/errors';
+
+// Temporal Decay (re-exported from core for convenience)
+export {
+  calculateDecayMultiplier,
+  resolveDecayTimestamp
+} from './core/evaluation/decay';
+export type {
+  DecayCurve,
+  DecayTimeUnit,
+  DecayConfig,
+  DecayInfo
+} from './core/evaluation/decay';
+
 // ========================================
 // QFacts - Probabilistic Fact Hydration
 // ========================================