@higher.archi/boe 1.0.7 → 1.0.8

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAOH,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAMlD,cAAc,QAAQ,CAAC;AAOvB,OAAO,EACL,uBAAuB,EACvB,qBAAqB,EACrB,kBAAkB,EAClB,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACV,WAAW,EACX,cAAc,EACd,aAAa,EACb,sBAAsB,EACtB,mBAAmB,EACnB,cAAc,EACd,aAAa,EACb,cAAc,EACd,aAAa,EACd,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,wBAAwB,EACxB,sBAAsB,EACtB,gBAAgB,EACjB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,YAAY,EACZ,eAAe,EACf,cAAc,EACd,uBAAuB,EACvB,eAAe,EACf,cAAc,EACd,SAAS,EACT,WAAW,EACZ,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACV,WAAW,EACX,cAAc,EACd,aAAa,EACb,sBAAsB,EACtB,cAAc,EACd,aAAa,EACb,qBAAqB,EACrB,aAAa,EACb,YAAY,EACZ,eAAe,EACf,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,eAAe,EACf,mBAAmB,EACnB,kBAAkB,EAClB,kBAAkB,EAClB,cAAc,EACd,0BAA0B,EAC1B,YAAY,EACb,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,kBAAkB,EAClB,wBAAwB,EACxB,kBAAkB,EACnB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,yBAAyB,EACzB,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EACL,aAAa,EACb,mBAAmB,EACnB,aAAa,EACb,oBAAoB,EACpB,eAAe,EACf,kBAAkB,EACnB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EACV,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,aAAa,EACb,SAAS,EACT,oBAAoB,EACpB,qBAAqB,EACrB,eAAe,EACf,eAAe,EAChB,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,mBAAmB,EACnB,gBAAgB,EAChB,eAAe,EACf,oBAAoB,EACrB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,YAAY,EACZ,eAAe,EACf,cAAc,EACd,uBAAuB,EACvB,oBAAoB,EACpB,eAAe,EACf,cAAc,EACd,UAAU,EACV,UAAU,EACV,YAAY,EACZ,eAAe,EACf,aAAa,EACb,kBAAkB,EAClB,aAAa,EACd,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACL,kBAAkB,EAClB,wBAAwB,EACxB,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,yBAAyB,EACzB,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,6BAA6B,EAC7B,oBAAoB,EACrB,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACV,sBAAsB,EACtB,kBAAkB,EAClB,eAAe,EACf,eAAe,EACf,8BAA8B,EAC9B,eAAe,EACf,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EACL,kBAAkB,EAClB,wBAAwB,EACxB,kBAAkB,EACnB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,kBAAkB,EAClB,UAAU,EACV,UAAU,EACV,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,yBAAyB,EACzB,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,mBAAmB,EACnB,cAAc,EACf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAGxD,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,kBAAkB,EAClB,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACV,gBAAgB,EAChB,WAAW,EACX,cAAc,EACd,aAAa,EACb,wBAAwB,EACxB,mBAAmB,EACnB,sBAAsB,EACtB,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,qBAAqB,EACtB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,gBAAgB,EAChB,wBAAwB,EACzB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,yBAAyB,EACzB,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EACL,YAAY,EACZ,cAAc,EACd,oBAAoB,EACpB,cAAc,EACd,eAAe,EACf,WAAW,EACX,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,UAAU,EACV,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,qBAAqB,EACrB,kBAAkB,EAClB,oBAAoB,EACpB,gBAAgB,EAChB,aAAa,EACb,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACb,oBAAoB,EACrB,MAAM,kBAAkB,CAAC;AAO1B,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,kBAAkB,EAClB,eAAe,EACf,aAAa,EACb,aAAa,EACb,kBAAkB,EAClB,eAAe,EACf,cAAc,EACd,YAAY,EACZ,aAAa,EACb,KAAK,EACL,iBAAiB,EACjB,WAAW,EAEX,UAAU,EACV,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAEV,YAAY,EACZ,YAAY,EAEZ,WAAW,EACX,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,WAAW,EACX,YAAY,EACZ,cAAc,EACd,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,KAAK,EACL,iBAAiB,EACjB,cAAc,EACd,UAAU,EACV,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,MAAM,EACN,kBAAkB,EAClB,mBAAmB,EACnB,eAAe,EACf,WAAW,EAEX,qBAAqB,EACrB,sBAAsB,EACtB,mBAAmB,EACnB,wBAAwB,EACxB,mBAAmB,EACnB,kBAAkB,EAClB,cAAc,EAEd,cAAc,EACd,aAAa,EACb,wBAAwB,EACxB,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,WAAW,EACX,cAAc,EACd,iBAAiB,EACjB,qBAAqB,EACtB,MAAM,mBAAmB,CAAC;AAM3B,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAG7E,OAAO,EACL,wBAAwB,EACxB,qBAAqB,EACtB,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACV,UAAU,EACV,aAAa,EACb,WAAW,EACX,SAAS,EACV,MAAM,yBAAyB,CAAC;AAMjC,cAAc,UAAU,CAAC"}

package/dist/index.js

@@ -30,7 +30,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compileUtilityRule = exports.compileUtilityRuleSet = exports.UtilityStrategy = exports.SEMANTIC_WEIGHTS = exports.constraintStrategy = exports.compileConstraintRuleSet = exports.ConstraintStrategy = exports.stateMachineStrategy = exports.compileStateMachineDefinition = exports.compileStateMachine = exports.StateMachineStrategy = exports.monteCarloStrategy = exports.compileMonteCarloRuleSet = exports.MonteCarloStrategy = exports.SEMANTIC_LIKELIHOODS = exports.parseLikelihood = exports.bayesianStrategy = exports.compileBayesianRule = exports.compileBayesianRuleSet = exports.BayesianStrategy = exports.autoAdjustCoverage = exports.analyzeCoverage = exports.compileFuzzyVariable = exports.fuzzyStrategy = exports.compileFuzzyRuleSet = exports.FuzzyStrategy = exports.sequentialStrategy = exports.compileSequentialRuleSet = exports.SequentialStrategy = exports.scoringStrategy = exports.compileScoringRuleSet = exports.ScoringStrategy = exports.backwardStrategy = exports.compileBackwardRuleSet = exports.BackwardChainingStrategy = exports.forwardStrategy = exports.compileForwardRule = exports.compileForwardRuleSet = exports.ForwardChainingStrategy = exports.PricingEngine = exports.UtilityEngine = exports.ConstraintEngine = exports.StateMachineEngine = exports.MonteCarloEngine = exports.BayesianEngine = exports.FuzzyEngine = exports.SequentialEngine = exports.ScoringEngine = exports.BackwardEngine = exports.ForwardEngine = void 0;
-exports.cosineSimilarity = exports.caverphone2 = exports.nysiis = exports.soundex = exports.getCurrencyInfo = exports.CURRENCIES = exports.applyMinMax = exports.calculateDiscount = exports.round = exports.formatPercent = exports.formatNumber = exports.formatCurrency = exports.calculateVolume = exports.calculateGraduated = exports.calculateFlat = exports.pricingEngine = exports.pricingStrategy = exports.compilePricingRule = exports.compilePricingRuleSet = exports.PricingStrategy = exports.buildAvailableRefs = exports.hasInterpolation = exports.interpolate = exports.compileTemplate = exports.expertStrategy = exports.compileExpertRuleSet = exports.ExpertStrategy = exports.ExpertEngine = exports.compileDefeasibleRuleSet = exports.DefeasibleEngine = exports.utilityStrategy = void 0;
+exports.resolveDecayTimestamp = exports.calculateDecayMultiplier = exports.cosineSimilarity = exports.caverphone2 = exports.nysiis = exports.soundex = exports.getCurrencyInfo = exports.CURRENCIES = exports.applyMinMax = exports.calculateDiscount = exports.round = exports.formatPercent = exports.formatNumber = exports.formatCurrency = exports.calculateVolume = exports.calculateGraduated = exports.calculateFlat = exports.pricingEngine = exports.pricingStrategy = exports.compilePricingRule = exports.compilePricingRuleSet = exports.PricingStrategy = exports.buildAvailableRefs = exports.hasInterpolation = exports.interpolate = exports.compileTemplate = exports.expertStrategy = exports.compileExpertRuleSet = exports.ExpertStrategy = exports.ExpertEngine = exports.compileDefeasibleRuleSet = exports.DefeasibleEngine = exports.utilityStrategy = void 0;
 // ========================================
 // Engines
 // ========================================
@@ -169,6 +169,10 @@ Object.defineProperty(exports, "soundex", { enumerable: true, get: function () {
 Object.defineProperty(exports, "nysiis", { enumerable: true, get: function () { return functions_1.nysiis; } });
 Object.defineProperty(exports, "caverphone2", { enumerable: true, get: function () { return functions_1.caverphone2; } });
 Object.defineProperty(exports, "cosineSimilarity", { enumerable: true, get: function () { return functions_1.cosineSimilarity; } });
+// Temporal Decay (re-exported from core for convenience)
+var decay_1 = require("./core/evaluation/decay");
+Object.defineProperty(exports, "calculateDecayMultiplier", { enumerable: true, get: function () { return decay_1.calculateDecayMultiplier; } });
+Object.defineProperty(exports, "resolveDecayTimestamp", { enumerable: true, get: function () { return decay_1.resolveDecayTimestamp; } });
 // ========================================
 // QFacts - Probabilistic Fact Hydration
 // ========================================

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@higher.archi/boe",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "A multi-strategy rule engine supporting forward chaining, backward chaining, scoring, sequential, fuzzy logic, and Bayesian inference",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/core/evaluation/decay.ts

@@ -0,0 +1,165 @@
+/**
+ * Temporal Decay Utilities
+ *
+ * Provides continuous decay multipliers (0→1) that degrade a rule's
+ * contribution based on how old its underlying data is.
+ *
+ * Complementary to temporal validity (binary gate) — validity runs first,
+ * decay modifies strength continuously.
+ */
+
+import { BindingContext, Fact } from '../types';
+
+// ========================================
+// Types
+// ========================================
+
+/**
+ * Decay curve shape
+ * - exponential: e^(-ln(2)/halfLife * age), smooth asymptotic decay
+ * - linear: 1 - age/maxAge, straight-line to zero
+ * - step: binary cutoff at threshold age
+ */
+export type DecayCurve = 'exponential' | 'linear' | 'step';
+
+/**
+ * Time unit for decay calculations
+ */
+export type DecayTimeUnit = 'hours' | 'days' | 'weeks' | 'months';
+
+/**
+ * Configuration for temporal decay
+ */
+export type DecayConfig = {
+  curve: DecayCurve;
+  timeUnit: DecayTimeUnit;
+  halfLife?: number;    // exponential: age at which multiplier = 0.5
+  maxAge?: number;      // linear: age at which multiplier = 0
+  threshold?: number;   // step: binary cutoff age
+  floor?: number;       // minimum multiplier (default 0)
+};
+
+/**
+ * Decay calculation result with audit trail
+ */
+export type DecayInfo = {
+  multiplier: number;
+  ageInUnits: number;
+  curve: DecayCurve;
+  timestamp: string;       // resolved ISO timestamp
+  fullyDecayed: boolean;
+};
+
+// ========================================
+// Time Unit Conversion
+// ========================================
+
+const MS_PER_HOUR = 3_600_000;
+const MS_PER_DAY = 86_400_000;
+const MS_PER_WEEK = 604_800_000;
+const MS_PER_MONTH = 2_592_000_000; // 30 days
+
+function msPerUnit(unit: DecayTimeUnit): number {
+  switch (unit) {
+    case 'hours':  return MS_PER_HOUR;
+    case 'days':   return MS_PER_DAY;
+    case 'weeks':  return MS_PER_WEEK;
+    case 'months': return MS_PER_MONTH;
+  }
+}
+
+// ========================================
+// Core Calculation
+// ========================================
+
+/**
+ * Calculate a decay multiplier based on age and configuration
+ *
+ * @param dataTimestamp - When the data was collected/created
+ * @param now - Current time reference point
+ * @param config - Decay configuration
+ * @returns DecayInfo with multiplier and audit data
+ */
+export function calculateDecayMultiplier(
+  dataTimestamp: Date,
+  now: Date,
+  config: DecayConfig
+): DecayInfo {
+  const ageMs = now.getTime() - dataTimestamp.getTime();
+  const ageInUnits = ageMs / msPerUnit(config.timeUnit);
+  const floor = config.floor ?? 0;
+
+  let rawMultiplier: number;
+
+  switch (config.curve) {
+    case 'exponential': {
+      const halfLife = config.halfLife ?? 1;
+      // e^(-ln(2)/halfLife * age)
+      rawMultiplier = Math.exp(-Math.LN2 / halfLife * ageInUnits);
+      break;
+    }
+
+    case 'linear': {
+      const maxAge = config.maxAge ?? 1;
+      rawMultiplier = 1 - ageInUnits / maxAge;
+      break;
+    }
+
+    case 'step': {
+      const threshold = config.threshold ?? 1;
+      rawMultiplier = ageInUnits < threshold ? 1.0 : 0.0;
+      break;
+    }
+  }
+
+  // Clamp to [floor, 1]
+  const multiplier = Math.max(floor, Math.min(1, rawMultiplier));
+
+  return {
+    multiplier,
+    ageInUnits,
+    curve: config.curve,
+    timestamp: dataTimestamp.toISOString(),
+    fullyDecayed: multiplier <= floor
+  };
+}
+
+/**
+ * Resolve a decay timestamp from a $-prefixed path in the binding context
+ *
+ * @param ref - A $-prefixed path like '$inspection.date'
+ * @param context - The current binding context
+ * @returns Resolved Date, or null if path is missing/invalid
+ */
+export function resolveDecayTimestamp(ref: string, context: BindingContext): Date | null {
+  if (!ref.startsWith('$')) return null;
+
+  const stripped = ref.slice(1);
+  const parts = stripped.split('.');
+  const param = parts[0];
+  const path = parts.slice(1);
+
+  const fact = context[param] as Fact | undefined;
+  if (!fact) return null;
+
+  let value: any = fact.data;
+  for (const key of path) {
+    if (value === null || value === undefined) return null;
+    value = value[key];
+  }
+
+  if (value === null || value === undefined) return null;
+
+  // Accept Date objects, ISO strings, or numeric timestamps
+  if (value instanceof Date) return value;
+  if (typeof value === 'string') {
+    const parsed = new Date(value);
+    return isNaN(parsed.getTime()) ? null : parsed;
+  }
+  if (typeof value === 'number') {
+    const parsed = new Date(value);
+    return isNaN(parsed.getTime()) ? null : parsed;
+  }
+
+  return null;
+}

package/src/core/evaluation/index.ts

@@ -18,3 +18,16 @@ export {
   getRuleTemporalInfo,
   RulesetMetadata
 } from './temporal';
+
+// Temporal decay utilities
+export {
+  calculateDecayMultiplier,
+  resolveDecayTimestamp
+} from './decay';
+
+export type {
+  DecayCurve,
+  DecayTimeUnit,
+  DecayConfig,
+  DecayInfo
+} from './decay';

package/src/engines/bayesian/compiler.ts

@@ -346,6 +346,17 @@ export function compileBayesianRule(
   const inputs = rule.inputs.map(compileInputParameter);
   const when = rule.when ? compileCondition(rule.when) : undefined;
 
+  // Compile decay — only pass through $-prefixed string timestamps
+  let compiledDecay: { timestamp: string; config?: any } | undefined;
+  if (rule.decay) {
+    const ts = rule.decay.timestamp;
+    if (typeof ts === 'string') {
+      compiledDecay = { timestamp: ts, config: rule.decay.config };
+    }
+    // Expression timestamps for Bayesian are not supported (would need runtime eval);
+    // only $-prefixed paths are supported
+  }
+
   return {
     id: rule.id,
     name: rule.name,
@@ -354,7 +365,8 @@ export function compileBayesianRule(
     index,
     inputs,
     when,
-    likelihood: compileLikelihoodMap(rule.likelihood, hypothesisNames, rule.id)
+    likelihood: compileLikelihoodMap(rule.likelihood, hypothesisNames, rule.id),
+    decay: compiledDecay
   };
 }
 
@@ -370,7 +382,8 @@ export function compileBayesianRuleSet(ruleSet: BayesianRuleSet): CompiledBayesi
   const config: BayesianConfig = {
     mode: 'bayesian',
     threshold: ruleSet.config?.threshold,
-    priorDefault: ruleSet.config?.priorDefault ?? 'uniform'
+    priorDefault: ruleSet.config?.priorDefault ?? 'uniform',
+    decay: ruleSet.config?.decay
   };
 
   // Get hypothesis names for validation

package/src/engines/bayesian/strategy.ts

@@ -13,6 +13,12 @@ import {
   Fact
 } from '../../core';
 import { IWorkingMemory } from '../../core/memory';
+import {
+  calculateDecayMultiplier,
+  resolveDecayTimestamp,
+  DecayConfig,
+  DecayInfo
+} from '../../core/evaluation/decay';
 
 import {
   CompiledBayesianRuleSet,
@@ -191,6 +197,8 @@ export class BayesianStrategy {
     const fired: string[] = [];
     const evidence: EvidenceEntry[] = [];
     let thresholdExceeded: string | undefined;
+    const decayInfoMap: Record<string, DecayInfo> = {};
+    const now = new Date();
 
     // Track which hypotheses were below threshold initially
     // (so we can detect when they cross it)
@@ -213,20 +221,59 @@ export class BayesianStrategy {
           fired.push(rule.id);
         }
 
+        // Compute decay for this rule's evidence
+        let effectiveLikelihoods = rule.likelihood;
+        let likelihoodsBeforeDecay: CompiledLikelihoodMap | undefined;
+        let ruleDecayInfo: DecayInfo | undefined;
+
+        const ruleDecay = rule.decay;
+        const engineDecay = config.decay;
+
+        if (ruleDecay || engineDecay) {
+          const tsRef = ruleDecay?.timestamp ?? (engineDecay?.timestamp as string | undefined);
+
+          if (typeof tsRef === 'string') {
+            const dataTimestamp = resolveDecayTimestamp(tsRef, activation.facts);
+
+            if (dataTimestamp) {
+              const decayConfig: DecayConfig = {
+                ...(engineDecay?.config ?? { curve: 'exponential', timeUnit: 'days' }),
+                ...ruleDecay?.config
+              } as DecayConfig;
+
+              const info = calculateDecayMultiplier(dataTimestamp, now, decayConfig);
+              ruleDecayInfo = info;
+              decayInfoMap[rule.id] = info;
+
+              // Decay likelihoods toward 1.0 (neutral)
+              // decayedLikelihood = 1.0 + (originalLikelihood - 1.0) * multiplier
+              if (info.multiplier < 1.0) {
+                likelihoodsBeforeDecay = { ...rule.likelihood };
+                effectiveLikelihoods = {};
+                for (const [h, lh] of Object.entries(rule.likelihood)) {
+                  effectiveLikelihoods[h] = 1.0 + (lh - 1.0) * info.multiplier;
+                }
+              }
+            }
+          }
+        }
+
         // Record evidence
         evidence.push({
           ruleId: rule.id,
           ruleName: rule.name,
-          likelihoods: rule.likelihood
+          likelihoods: effectiveLikelihoods,
+          likelihoodsBeforeDecay,
+          decayInfo: ruleDecayInfo
         });
 
         // Callback
         if (onFire) {
-          onFire(rule.id, activation.facts, rule.likelihood);
+          onFire(rule.id, activation.facts, effectiveLikelihoods);
         }
 
-        // Update posteriors with this evidence
-        posteriors = applyEvidence(posteriors, rule.likelihood);
+        // Update posteriors with this evidence (using decayed likelihoods)
+        posteriors = applyEvidence(posteriors, effectiveLikelihoods);
 
         // Check if any hypothesis crossed the threshold (from below to above)
         if (threshold !== undefined && thresholdExceeded === undefined) {
@@ -255,6 +302,8 @@ export class BayesianStrategy {
 
     const executionTimeMs = Math.round((performance.now() - startTime) * 100) / 100;
 
+    const hasDecay = Object.keys(decayInfoMap).length > 0;
+
     return {
       priors: normalizedPriors,
       posteriors,
@@ -263,6 +312,7 @@ export class BayesianStrategy {
       fired,
       evidence,
       thresholdExceeded,
+      ...(hasDecay ? { decayInfo: decayInfoMap } : {}),
       iterations: 1,
       executionTimeMs
     };

package/src/engines/bayesian/types.ts

@@ -17,6 +17,8 @@ import {
   BindingContext
 } from '../../core';
 
+import { DecayConfig, DecayInfo } from '../../core/evaluation/decay';
+
 // ========================================
 // Likelihood Value Types
 // ========================================
@@ -100,6 +102,10 @@ export type PriorDefault =
  */
 export type BayesianRule = BaseRule & {
   likelihood: LikelihoodMap;  // How this evidence affects each hypothesis
+  decay?: {
+    timestamp: string | Expression;  // e.g. '$sensor.readingDate'
+    config?: Partial<DecayConfig>;   // overrides engine-level defaults
+  };
 };
 
 /**
@@ -109,6 +115,10 @@ export type BayesianConfig = {
   mode: 'bayesian';
   threshold?: number;           // Flag if any posterior exceeds this (e.g., 0.5)
   priorDefault?: PriorDefault;  // How to fill missing priors (default: 'uniform')
+  decay?: {
+    timestamp?: string | Expression;  // default timestamp path for all rules
+    config: DecayConfig;              // engine-level decay config
+  };
 };
 
 /**
@@ -152,6 +162,10 @@ export type CompiledLikelihoodMap = Record<string, number>;
  */
 export type CompiledBayesianRule = CompiledBaseRule & {
   likelihood: CompiledLikelihoodMap;
+  decay?: {
+    timestamp: string;               // $-prefixed path
+    config?: Partial<DecayConfig>;
+  };
 };
 
 /**
@@ -176,6 +190,8 @@ export type EvidenceEntry = {
   ruleId: string;
   ruleName?: string;
   likelihoods: CompiledLikelihoodMap;
+  likelihoodsBeforeDecay?: CompiledLikelihoodMap;  // original likelihoods before decay
+  decayInfo?: DecayInfo;
 };
 
 /**
@@ -197,6 +213,7 @@ export type BayesianResult = {
   fired: string[];                       // Rules that matched and provided evidence
   evidence: EvidenceEntry[];             // Audit trail
   thresholdExceeded?: string;            // First hypothesis to exceed threshold (if any)
+  decayInfo?: Record<string, DecayInfo>; // per-rule decay audit
   iterations: 1;                         // Bayesian is always one-pass
   executionTimeMs: number;               // Processing time in milliseconds
 };

package/src/engines/defeasible/compiler.ts

@@ -34,7 +34,8 @@ const DEFAULT_CONFIG: Required<DefeasibleConfig> = {
   aggregation: 'average',
   threshold: 0.5,
   conflictResolution: 'specificity',
-  maxIterations: 100
+  maxIterations: 100,
+  decay: undefined as any  // Optional at runtime; Required<> demands a key
 };
 
 // ========================================
@@ -198,6 +199,19 @@ function compileRule(rule: DefeasibleRule, index: number): CompiledDefeasibleRul
   const inputs = (rule.inputs || []).map(compileInputParameter);
   const when = rule.when ? compileCondition(rule.when) : undefined;
 
+  // Compile decay — only pass through $-prefixed string timestamps
+  let compiledDecay: CompiledDefeasibleRule['decay'] | undefined;
+  if (rule.decay) {
+    const ts = rule.decay.timestamp;
+    if (typeof ts === 'string') {
+      compiledDecay = {
+        timestamp: ts,
+        config: rule.decay.config,
+        target: rule.decay.target
+      };
+    }
+  }
+
   return {
     id: rule.id,
     name: rule.name,
@@ -210,7 +224,8 @@ function compileRule(rule: DefeasibleRule, index: number): CompiledDefeasibleRul
     credibility: normalizeCredibility(rule.credibility),
     conclusion: compileConclusion(rule.conclude),
     defeats: (rule.defeats || []).map(normalizeDefeat),
-    specificity: countSpecificity(rule)
+    specificity: countSpecificity(rule),
+    decay: compiledDecay
   };
 }
 

package/src/engines/defeasible/strategy.ts

@@ -7,6 +7,12 @@
 
 import { match } from '../../core/matching';
 import { IWorkingMemory } from '../../core/memory';
+import {
+  calculateDecayMultiplier,
+  resolveDecayTimestamp,
+  DecayConfig,
+  DecayInfo
+} from '../../core/evaluation/decay';
 
 import {
   CompiledDefeasibleRuleSet,
@@ -101,17 +107,57 @@ export class DefeasibleStrategy {
     // Phase 1: Match all rules and collect fired rules
     const firedRules: FiredRule[] = [];
     const firedRuleIds: string[] = [];
+    const decayInfoMap: Record<string, DecayInfo> = {};
+    const decayMultipliersByRule: Record<string, number> = {};
+    const now = new Date();
 
     for (const rule of ruleSet.rules) {
       // Match inputs against working memory (includes when clause evaluation)
       const activations = match(rule, wm);
 
       for (const activation of activations) {
+        // Compute decay if configured
+        let effectiveCredibility = rule.credibility;
+        let credibilityBeforeDecay: number | undefined;
+        let ruleDecayInfo: DecayInfo | undefined;
+
+        const ruleDecay = rule.decay;
+        const engineDecay = config.decay;
+
+        if (ruleDecay || engineDecay) {
+          const tsRef = ruleDecay?.timestamp ?? (engineDecay?.timestamp as string | undefined);
+          const decayTarget = ruleDecay?.target ?? engineDecay?.target ?? 'credibility';
+
+          if (typeof tsRef === 'string') {
+            const dataTimestamp = resolveDecayTimestamp(tsRef, activation.facts);
+
+            if (dataTimestamp) {
+              const decayConfig: DecayConfig = {
+                ...(engineDecay?.config ?? { curve: 'exponential', timeUnit: 'days' }),
+                ...ruleDecay?.config
+              } as DecayConfig;
+
+              const info = calculateDecayMultiplier(dataTimestamp, now, decayConfig);
+              ruleDecayInfo = info;
+              decayInfoMap[rule.id] = info;
+              decayMultipliersByRule[rule.id] = info.multiplier;
+
+              // Apply decay to credibility if target includes it
+              if (decayTarget === 'credibility' || decayTarget === 'both') {
+                credibilityBeforeDecay = rule.credibility;
+                effectiveCredibility = rule.credibility * info.multiplier;
+              }
+            }
+          }
+        }
+
         // Rule fires
         firedRules.push({
           ruleId: rule.id,
           conclusion: rule.conclusion,
-          credibility: rule.credibility,
+          credibility: effectiveCredibility,
+          credibilityBeforeDecay,
+          decayInfo: ruleDecayInfo,
           bindings: activation.facts
         });
 
@@ -166,9 +212,21 @@ export class DefeasibleStrategy {
           if (!defeatsMap.has(defeat.rule)) {
             defeatsMap.set(defeat.rule, []);
           }
+
+          // Apply decay to defeat strength if target includes it
+          let effectiveStrength = defeat.strength;
+          const ruleDecay = rule.decay;
+          const engineDecay = config.decay;
+          const decayTarget = ruleDecay?.target ?? engineDecay?.target ?? 'credibility';
+
+          if ((decayTarget === 'defeat-strength' || decayTarget === 'both') &&
+              decayMultipliersByRule[fired.ruleId] !== undefined) {
+            effectiveStrength = defeat.strength * decayMultipliersByRule[fired.ruleId];
+          }
+
           defeatsMap.get(defeat.rule)!.push({
             by: fired.ruleId,
-            strength: defeat.strength
+            strength: effectiveStrength
           });
         }
       }
@@ -291,6 +349,7 @@ export class DefeasibleStrategy {
     };
 
     const executionTimeMs = Math.round((performance.now() - startTime) * 100) / 100;
+    const hasDecay = Object.keys(decayInfoMap).length > 0;
 
     return {
       conclusions,
@@ -300,6 +359,7 @@ export class DefeasibleStrategy {
       conflicts,
       fired: firedRuleIds,
       iterations: 1,  // Current implementation is single-pass
+      ...(hasDecay ? { decayInfo: decayInfoMap } : {}),
       executionTimeMs,
       query
     };

package/src/engines/defeasible/types.ts

@@ -20,9 +20,12 @@ import {
   CompiledBaseRule,
   CompiledBaseRuleSet,
   CompiledInputParameter,
+  Expression,
   BindingContext
 } from '../../core';
 
+import { DecayConfig, DecayInfo } from '../../core/evaluation/decay';
+
 // ========================================
 // Rule Strength Types
 // ========================================
@@ -167,6 +170,15 @@ export type DefeasibleRule = BaseRule & {
    * Useful for audit trails and explainability.
    */
   explanation?: string;
+
+  /**
+   * Temporal decay configuration for this rule
+   */
+  decay?: {
+    timestamp: string | Expression;
+    config?: Partial<DecayConfig>;
+    target?: 'credibility' | 'defeat-strength' | 'both';  // default: 'credibility'
+  };
 };
 
 /**
@@ -216,6 +228,15 @@ export type DefeasibleConfig = {
    * Maximum iterations for computing defeat cycles (default: 100)
    */
   maxIterations?: number;
+
+  /**
+   * Engine-level temporal decay configuration
+   */
+  decay?: {
+    timestamp?: string | Expression;
+    config: DecayConfig;
+    target?: 'credibility' | 'defeat-strength' | 'both';
+  };
 };
 
 /**
@@ -263,6 +284,11 @@ export type CompiledDefeasibleRule = CompiledBaseRule & {
   conclusion: CompiledConclusion | null;  // null for pure defeaters
   defeats: CompiledDefeat[];              // Normalized defeats
   specificity: number;                    // Number of conditions (for tie-breaking)
+  decay?: {
+    timestamp: string;                    // $-prefixed path
+    config?: Partial<DecayConfig>;
+    target?: 'credibility' | 'defeat-strength' | 'both';
+  };
 };
 
 /**
@@ -293,6 +319,8 @@ export type FiredRule = {
   ruleId: string;
   conclusion: CompiledConclusion | null;
   credibility: number;
+  credibilityBeforeDecay?: number;   // original credibility before decay
+  decayInfo?: DecayInfo;
   bindings: BindingContext;
 };
 
@@ -385,6 +413,11 @@ export type DefeasibleResult = {
    */
   iterations: number;
 
+  /**
+   * Per-rule decay audit trail
+   */
+  decayInfo?: Record<string, DecayInfo>;
+
   /**
    * Processing time in milliseconds
    */