@girardmedia/bootspring 1.2.0 → 2.0.3

package/intelligence/memory/decision-tracker.js

@@ -15,7 +15,18 @@ const crypto = require('crypto');
 // Paths
 const memoryDir = __dirname;
 const decisionsFile = path.join(memoryDir, 'decisions.jsonl');
+const outcomesFile = path.join(memoryDir, 'outcomes.jsonl');
 const patternsFile = path.join(memoryDir, 'patterns.json');
+const indexFile = path.join(memoryDir, 'decisions.index.json');
+
+// Compaction thresholds
+const COMPACTION_THRESHOLD_COUNT = 100;  // Compact after this many outcomes
+const COMPACTION_THRESHOLD_BYTES = 1024 * 1024;  // Compact when outcomes file exceeds 1MB
+
+// In-memory decision index for O(1) lookups
+// Maps decisionId -> { lineOffset, timestamp, type }
+let decisionIndex = null;
+let indexDirty = false;
 
 /**
  * Decision types that can be tracked
@@ -75,6 +86,258 @@ function ensureDecisionsFile() {
   }
 }
 
+/**
+ * Load the decision index from disk or rebuild from decisions file
+ * The index provides O(1) lookups for decision existence checks
+ * @returns {Map} The decision index
+ */
+function loadDecisionIndex() {
+  if (decisionIndex !== null) {
+    return decisionIndex;
+  }
+
+  decisionIndex = new Map();
+
+  // Try to load from index file first
+  if (fs.existsSync(indexFile)) {
+    try {
+      const indexData = JSON.parse(fs.readFileSync(indexFile, 'utf-8'));
+      if (indexData.version === '1.0.0' && indexData.entries) {
+        for (const [id, meta] of Object.entries(indexData.entries)) {
+          decisionIndex.set(id, meta);
+        }
+        return decisionIndex;
+      }
+    } catch {
+      // Index corrupted, will rebuild
+    }
+  }
+
+  // Rebuild index from decisions file
+  rebuildIndex();
+  return decisionIndex;
+}
+
+/**
+ * Rebuild the decision index from the decisions file
+ * Called when index is missing/corrupted or after compaction
+ */
+function rebuildIndex() {
+  decisionIndex = new Map();
+  ensureDecisionsFile();
+
+  const content = fs.readFileSync(decisionsFile, 'utf-8').trim();
+  if (!content) return;
+
+  let lineOffset = 0;
+  content.split('\n').filter(Boolean).forEach((line, idx) => {
+    try {
+      const d = JSON.parse(line);
+      decisionIndex.set(d.id, {
+        lineOffset: idx,
+        timestamp: d.timestamp,
+        type: d.type,
+        confidence: d.confidence
+      });
+    } catch {
+      // Skip malformed lines
+    }
+    lineOffset++;
+  });
+
+  // Save the rebuilt index
+  saveIndex();
+}
+
+/**
+ * Save the decision index to disk
+ */
+function saveIndex() {
+  const indexData = {
+    version: '1.0.0',
+    updated: getTimestamp(),
+    count: decisionIndex.size,
+    entries: Object.fromEntries(decisionIndex)
+  };
+  fs.writeFileSync(indexFile, JSON.stringify(indexData));
+  indexDirty = false;
+}
+
+/**
+ * Add a decision to the index
+ * @param {string} id Decision ID
+ * @param {object} meta Decision metadata
+ */
+function addToIndex(id, meta) {
+  loadDecisionIndex();
+  decisionIndex.set(id, meta);
+  indexDirty = true;
+
+  // Batch index saves - only save every 10 additions or on explicit save
+  if (decisionIndex.size % 10 === 0) {
+    saveIndex();
+  }
+}
+
+/**
+ * Check if a decision exists in the index (O(1) lookup)
+ * @param {string} decisionId Decision ID
+ * @returns {boolean} Whether the decision exists
+ */
+function decisionExists(decisionId) {
+  loadDecisionIndex();
+  return decisionIndex.has(decisionId);
+}
+
+/**
+ * Get decision metadata from index (O(1) lookup)
+ * @param {string} decisionId Decision ID
+ * @returns {object|null} Decision metadata or null
+ */
+function getDecisionMeta(decisionId) {
+  loadDecisionIndex();
+  return decisionIndex.get(decisionId) || null;
+}
+
+/**
+ * Invalidate the in-memory index (forces reload on next access)
+ */
+function invalidateIndex() {
+  decisionIndex = null;
+  indexDirty = false;
+}
+
+/**
+ * Flush any pending index changes to disk
+ */
+function flushIndex() {
+  if (indexDirty && decisionIndex !== null) {
+    saveIndex();
+  }
+}
+
+/**
+ * Ensure outcomes file exists
+ */
+function ensureOutcomesFile() {
+  if (!fs.existsSync(memoryDir)) {
+    fs.mkdirSync(memoryDir, { recursive: true });
+  }
+  if (!fs.existsSync(outcomesFile)) {
+    fs.writeFileSync(outcomesFile, '');
+  }
+}
+
+/**
+ * Read all outcomes from the outcomes file
+ * @returns {Map} Map of decisionId -> outcome
+ */
+function readOutcomes() {
+  ensureOutcomesFile();
+  const content = fs.readFileSync(outcomesFile, 'utf-8').trim();
+  if (!content) return new Map();
+
+  const outcomes = new Map();
+  content.split('\n').filter(Boolean).forEach(line => {
+    try {
+      const entry = JSON.parse(line);
+      outcomes.set(entry.decisionId, entry);
+    } catch {
+      // Skip malformed lines
+    }
+  });
+  return outcomes;
+}
+
+/**
+ * Get the number of outcome entries
+ * @returns {number} Number of outcome entries
+ */
+function getOutcomeCount() {
+  ensureOutcomesFile();
+  const content = fs.readFileSync(outcomesFile, 'utf-8').trim();
+  if (!content) return 0;
+  return content.split('\n').filter(Boolean).length;
+}
+
+/**
+ * Get the size of the outcomes file in bytes
+ * @returns {number} File size in bytes
+ */
+function getOutcomesFileSize() {
+  ensureOutcomesFile();
+  try {
+    const stats = fs.statSync(outcomesFile);
+    return stats.size;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Check if compaction is needed based on thresholds
+ * @returns {boolean} Whether compaction should be performed
+ */
+function shouldCompact() {
+  const count = getOutcomeCount();
+  const size = getOutcomesFileSize();
+  return count >= COMPACTION_THRESHOLD_COUNT || size >= COMPACTION_THRESHOLD_BYTES;
+}
+
+/**
+ * Compact outcomes into decisions file
+ * Merges all outcomes into the main decisions file and clears outcomes
+ * @param {object} options Compaction options
+ * @param {boolean} options.force Force compaction even if thresholds not met
+ * @returns {object} Compaction results
+ */
+function compact(options = {}) {
+  ensureDecisionsFile();
+  ensureOutcomesFile();
+
+  const outcomes = readOutcomes();
+  if (outcomes.size === 0) return { compacted: 0, skipped: true };
+
+  // Read raw decisions
+  const content = fs.readFileSync(decisionsFile, 'utf-8').trim();
+  if (!content) return { compacted: 0, skipped: true };
+
+  const decisions = content.split('\n').filter(Boolean).map(line => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
+
+  // Merge outcomes into decisions
+  let compactedCount = 0;
+  const updatedDecisions = decisions.map(d => {
+    const outcome = outcomes.get(d.id);
+    if (outcome) {
+      d.outcome = outcome.outcome;
+      d.outcome_recorded_at = outcome.outcome_recorded_at;
+      compactedCount++;
+    }
+    return d;
+  });
+
+  // Rewrite decisions file with merged data
+  fs.writeFileSync(decisionsFile, updatedDecisions.map(d => JSON.stringify(d)).join('\n') + '\n');
+
+  // Clear outcomes file
+  fs.writeFileSync(outcomesFile, '');
+
+  // Rebuild index after compaction (line offsets may have changed due to outcome data)
+  rebuildIndex();
+
+  return {
+    compacted: compactedCount,
+    totalDecisions: decisions.length,
+    skipped: false
+  };
+}
+
 /**
  * Ensure patterns file exists
  */
@@ -126,9 +389,16 @@ function logDecision(options) {
     files_affected: options.files_affected || []
   };
 
-  // Append to JSONL file
+  // Append to JSONL file (O(1) operation)
   fs.appendFileSync(decisionsFile, JSON.stringify(decision) + '\n');
 
+  // Add to index for O(1) lookups
+  addToIndex(decision.id, {
+    timestamp: decision.timestamp,
+    type: decision.type,
+    confidence: decision.confidence
+  });
+
   // Update patterns stats
   updateStats('total_decisions', 1);
 
@@ -137,6 +407,7 @@ function logDecision(options) {
 
 /**
  * Record the outcome of a decision
+ * Uses O(1) index lookup to verify decision exists, then O(1) append for outcome
  * @param {string} decisionId The decision ID
  * @param {Object} outcome Outcome details
  * @param {string} outcome.status Status (success, partial, failure, reverted)
@@ -146,46 +417,111 @@ function logDecision(options) {
  */
 function recordOutcome(decisionId, outcome) {
   ensureDecisionsFile();
+  ensureOutcomesFile();
 
-  const decisions = readAllDecisions();
-  let found = false;
+  // O(1) lookup using index instead of O(n) file scan
+  const decisionMeta = getDecisionMeta(decisionId);
+  if (!decisionMeta) {
+    return null;
+  }
 
-  const updatedDecisions = decisions.map(d => {
-    if (d.id === decisionId) {
-      found = true;
-      d.outcome = {
-        status: outcome.status || OUTCOME_STATUS.PENDING,
-        metrics: outcome.metrics || {},
-        notes: outcome.notes || '',
-        actual_confidence: outcome.actual_confidence || d.confidence
-      };
-      d.outcome_recorded_at = getTimestamp();
+  // Create outcome entry
+  const outcomeEntry = {
+    decisionId,
+    outcome: {
+      status: outcome.status || OUTCOME_STATUS.PENDING,
+      metrics: outcome.metrics || {},
+      notes: outcome.notes || '',
+      actual_confidence: outcome.actual_confidence || decisionMeta.confidence || 0.5
+    },
+    outcome_recorded_at: getTimestamp()
+  };
 
-      // Update stats based on outcome
-      if (outcome.status === OUTCOME_STATUS.SUCCESS) {
-        updateStats('successful_decisions', 1);
-      } else if (outcome.status === OUTCOME_STATUS.FAILURE) {
-        updateStats('failed_decisions', 1);
-      }
-    }
-    return d;
-  });
+  // Append to outcomes file (O(1) operation)
+  fs.appendFileSync(outcomesFile, JSON.stringify(outcomeEntry) + '\n');
+
+  // Update stats based on outcome
+  if (outcome.status === OUTCOME_STATUS.SUCCESS) {
+    updateStats('successful_decisions', 1);
+  } else if (outcome.status === OUTCOME_STATUS.FAILURE) {
+    updateStats('failed_decisions', 1);
+  }
 
-  if (!found) {
+  // Auto-compact if thresholds reached (count or size)
+  if (shouldCompact()) {
+    compact();
+  }
+
+  // For pattern checking and return value, we need the full decision
+  // This is acceptable because it's only done once per outcome recording
+  // and pattern checking is a secondary operation
+  const fullDecision = getDecisionById(decisionId);
+  if (fullDecision) {
+    const completeDecision = {
+      ...fullDecision,
+      outcome: outcomeEntry.outcome,
+      outcome_recorded_at: outcomeEntry.outcome_recorded_at
+    };
+
+    // Check if this creates a pattern
+    checkForPatterns(completeDecision);
+
+    return completeDecision;
+  }
+
+  // Fallback return with minimal data
+  return {
+    id: decisionId,
+    ...decisionMeta,
+    outcome: outcomeEntry.outcome,
+    outcome_recorded_at: outcomeEntry.outcome_recorded_at
+  };
+}
+
+/**
+ * Get a single decision by ID
+ * Optimized to use index for existence check, then reads full data if needed
+ * @param {string} decisionId Decision ID
+ * @returns {Object|null} Decision or null if not found
+ */
+function getDecisionById(decisionId) {
+  // O(1) check if decision exists
+  if (!decisionExists(decisionId)) {
     return null;
   }
 
-  // Rewrite the file with updated decisions
-  fs.writeFileSync(decisionsFile, updatedDecisions.map(d => JSON.stringify(d)).join('\n') + '\n');
+  ensureDecisionsFile();
+  const content = fs.readFileSync(decisionsFile, 'utf-8').trim();
+  if (!content) return null;
 
-  // Check if this creates a pattern
-  checkForPatterns(updatedDecisions.find(d => d.id === decisionId));
+  // Find the decision in the file
+  const lines = content.split('\n').filter(Boolean);
+  for (const line of lines) {
+    try {
+      const d = JSON.parse(line);
+      if (d.id === decisionId) {
+        // Merge with any pending outcome
+        const outcomes = readOutcomes();
+        const pendingOutcome = outcomes.get(decisionId);
+        if (pendingOutcome) {
+          return {
+            ...d,
+            outcome: pendingOutcome.outcome,
+            outcome_recorded_at: pendingOutcome.outcome_recorded_at
+          };
+        }
+        return d;
+      }
+    } catch {
+      // Skip malformed lines
+    }
+  }
 
-  return updatedDecisions.find(d => d.id === decisionId);
+  return null;
 }
 
 /**
- * Read all decisions from the JSONL file
+ * Read all decisions from the JSONL file, merged with any pending outcomes
  * @returns {Array} Array of decisions
  */
 function readAllDecisions() {
@@ -194,13 +530,31 @@ function readAllDecisions() {
   const content = fs.readFileSync(decisionsFile, 'utf-8').trim();
   if (!content) return [];
 
-  return content.split('\n').filter(Boolean).map(line => {
+  const decisions = content.split('\n').filter(Boolean).map(line => {
     try {
       return JSON.parse(line);
     } catch {
       return null;
     }
   }).filter(Boolean);
+
+  // Merge with any pending outcomes
+  const outcomes = readOutcomes();
+  if (outcomes.size > 0) {
+    return decisions.map(d => {
+      const outcome = outcomes.get(d.id);
+      if (outcome) {
+        return {
+          ...d,
+          outcome: outcome.outcome,
+          outcome_recorded_at: outcome.outcome_recorded_at
+        };
+      }
+      return d;
+    });
+  }
+
+  return decisions;
 }
 
 /**
@@ -407,6 +761,12 @@ function clearHistory() {
   if (fs.existsSync(decisionsFile)) {
     fs.writeFileSync(decisionsFile, '');
   }
+  if (fs.existsSync(outcomesFile)) {
+    fs.writeFileSync(outcomesFile, '');
+  }
+  if (fs.existsSync(indexFile)) {
+    fs.unlinkSync(indexFile);
+  }
   if (fs.existsSync(patternsFile)) {
     fs.writeFileSync(patternsFile, JSON.stringify({
       version: '1.0.0',
@@ -420,14 +780,1028 @@ function clearHistory() {
       }
     }, null, 2));
   }
+  // Clear in-memory index
+  invalidateIndex();
+}
+
+/**
+ * Impact scoring constants
+ */
+const IMPACT_LEVELS = {
+  CRITICAL: 5,    // System-wide or security impact
+  HIGH: 4,        // Major feature or performance impact
+  MEDIUM: 3,      // Moderate feature impact
+  LOW: 2,         // Minor feature impact
+  MINIMAL: 1      // Cosmetic or trivial impact
+};
+
+/**
+ * Time decay configuration for recency weighting
+ */
+const TIME_DECAY = {
+  HALF_LIFE_DAYS: 14,        // Score halves every 14 days
+  MIN_WEIGHT: 0.1,           // Minimum weight for very old decisions
+  MAX_AGE_DAYS: 180          // Decisions older than this use minimum weight
+};
+
+/**
+ * Impact factors used in scoring
+ */
+const IMPACT_FACTORS = {
+  // Type-based base scores
+  typeWeights: {
+    [DECISION_TYPES.ARCHITECTURE]: 1.5,
+    [DECISION_TYPES.DATABASE]: 1.4,
+    [DECISION_TYPES.SECURITY]: 1.6,
+    [DECISION_TYPES.API]: 1.3,
+    [DECISION_TYPES.UI]: 1.0,
+    [DECISION_TYPES.TESTING]: 1.1,
+    [DECISION_TYPES.DEPLOYMENT]: 1.4,
+    [DECISION_TYPES.PERFORMANCE]: 1.3,
+    [DECISION_TYPES.AGENT_SELECTION]: 1.0,
+    [DECISION_TYPES.WORKFLOW_CHOICE]: 1.1,
+    [DECISION_TYPES.SKILL_USAGE]: 1.0,
+    [DECISION_TYPES.REFACTOR]: 1.2,
+    [DECISION_TYPES.BUG_FIX]: 1.1
+  },
+  // Outcome multipliers
+  outcomeMultipliers: {
+    [OUTCOME_STATUS.SUCCESS]: 1.0,
+    [OUTCOME_STATUS.PARTIAL]: 0.7,
+    [OUTCOME_STATUS.FAILURE]: 0.5,
+    [OUTCOME_STATUS.REVERTED]: 0.3,
+    [OUTCOME_STATUS.PENDING]: 0.8
+  },
+  // Downstream impact multipliers based on outcome propagation
+  downstreamSuccessBonus: 0.15,   // Bonus per successful downstream decision
+  downstreamFailurePenalty: 0.1,  // Penalty per failed downstream decision
+  maxDownstreamBonus: 1.0,        // Cap for downstream bonuses
+  maxDownstreamPenalty: 0.5       // Cap for downstream penalties
+};
+
+/**
+ * Decision chain tracking - stores parent-child relationships
+ * Maps decisionId -> { parent: parentId, children: [childIds] }
+ */
+const decisionChainFile = path.join(memoryDir, 'decision-chains.json');
+
+/**
+ * Impact scores cache file for performance
+ */
+const impactScoresFile = path.join(memoryDir, 'impact-scores.json');
+
+/**
+ * Calculate time decay weight for recency
+ * Recent decisions are weighted more heavily
+ * @param {string} timestamp - ISO timestamp
+ * @returns {number} Decay weight between MIN_WEIGHT and 1.0
+ */
+function calculateTimeDecay(timestamp) {
+  if (!timestamp) return TIME_DECAY.MIN_WEIGHT;
+
+  const decisionDate = new Date(timestamp);
+  const now = new Date();
+  const ageInDays = (now - decisionDate) / (1000 * 60 * 60 * 24);
+
+  if (ageInDays > TIME_DECAY.MAX_AGE_DAYS) {
+    return TIME_DECAY.MIN_WEIGHT;
+  }
+
+  // Exponential decay: weight = 0.5^(age/halfLife)
+  const decayFactor = Math.pow(0.5, ageInDays / TIME_DECAY.HALF_LIFE_DAYS);
+  return Math.max(TIME_DECAY.MIN_WEIGHT, decayFactor);
+}
+
+/**
+ * Ensure decision chains file exists
+ */
+function ensureDecisionChainsFile() {
+  if (!fs.existsSync(decisionChainFile)) {
+    fs.writeFileSync(decisionChainFile, JSON.stringify({
+      version: '1.0.0',
+      updated: getTimestamp(),
+      chains: {}
+    }, null, 2));
+  }
+}
+
+/**
+ * Load decision chains from file
+ * @returns {Object} Decision chains data
+ */
+function loadDecisionChains() {
+  ensureDecisionChainsFile();
+  try {
+    return JSON.parse(fs.readFileSync(decisionChainFile, 'utf-8'));
+  } catch {
+    return { version: '1.0.0', updated: getTimestamp(), chains: {} };
+  }
+}
+
+/**
+ * Save decision chains to file
+ * @param {Object} chainsData - Chains data to save
+ */
+function saveDecisionChains(chainsData) {
+  chainsData.updated = getTimestamp();
+  fs.writeFileSync(decisionChainFile, JSON.stringify(chainsData, null, 2));
+}
+
+/**
+ * Link a decision to its parent decision (creates decision chain)
+ * @param {string} childId - The decision that was influenced
+ * @param {string} parentId - The decision that influenced it
+ * @param {string} relationship - Type of relationship (e.g., 'caused_by', 'follows', 'extends')
+ */
+function linkDecisions(childId, parentId, relationship = 'influenced_by') {
+  const chainsData = loadDecisionChains();
+
+  // Initialize entries if needed
+  if (!chainsData.chains[childId]) {
+    chainsData.chains[childId] = { parents: [], children: [] };
+  }
+  if (!chainsData.chains[parentId]) {
+    chainsData.chains[parentId] = { parents: [], children: [] };
+  }
+
+  // Add relationship
+  const existingParent = chainsData.chains[childId].parents.find(p => p.id === parentId);
+  if (!existingParent) {
+    chainsData.chains[childId].parents.push({
+      id: parentId,
+      relationship,
+      linked_at: getTimestamp()
+    });
+  }
+
+  const existingChild = chainsData.chains[parentId].children.find(c => c.id === childId);
+  if (!existingChild) {
+    chainsData.chains[parentId].children.push({
+      id: childId,
+      relationship,
+      linked_at: getTimestamp()
+    });
+  }
+
+  saveDecisionChains(chainsData);
+}
+
+/**
+ * Get all downstream decisions in the chain (recursive)
+ * @param {string} decisionId - Starting decision ID
+ * @param {Set} visited - Already visited IDs (for cycle detection)
+ * @returns {Array} Array of downstream decision info objects
+ */
+function getDownstreamDecisions(decisionId, visited = new Set()) {
+  if (visited.has(decisionId)) return [];
+  visited.add(decisionId);
+
+  const chainsData = loadDecisionChains();
+  const chainEntry = chainsData.chains[decisionId];
+
+  if (!chainEntry || !chainEntry.children.length) return [];
+
+  const downstream = [];
+  for (const child of chainEntry.children) {
+    const childDecision = getDecisionById(child.id);
+    if (childDecision) {
+      downstream.push({
+        id: child.id,
+        relationship: child.relationship,
+        decision: childDecision,
+        depth: 1
+      });
+
+      // Recursively get children of children
+      const grandchildren = getDownstreamDecisions(child.id, visited);
+      grandchildren.forEach(gc => {
+        gc.depth++;
+        downstream.push(gc);
+      });
+    }
+  }
+
+  return downstream;
+}
+
+/**
+ * Get all upstream decisions in the chain (recursive)
+ * @param {string} decisionId - Starting decision ID
+ * @param {Set} visited - Already visited IDs (for cycle detection)
+ * @returns {Array} Array of upstream decision info objects
+ */
+function getUpstreamDecisions(decisionId, visited = new Set()) {
+  if (visited.has(decisionId)) return [];
+  visited.add(decisionId);
+
+  const chainsData = loadDecisionChains();
+  const chainEntry = chainsData.chains[decisionId];
+
+  if (!chainEntry || !chainEntry.parents.length) return [];
+
+  const upstream = [];
+  for (const parent of chainEntry.parents) {
+    const parentDecision = getDecisionById(parent.id);
+    if (parentDecision) {
+      upstream.push({
+        id: parent.id,
+        relationship: parent.relationship,
+        decision: parentDecision,
+        depth: 1
+      });
+
+      // Recursively get parents of parents
+      const grandparents = getUpstreamDecisions(parent.id, visited);
+      grandparents.forEach(gp => {
+        gp.depth++;
+        upstream.push(gp);
+      });
+    }
+  }
+
+  return upstream;
+}
+
+/**
+ * Calculate downstream impact based on outcome propagation
+ * @param {string} decisionId - Decision ID
+ * @returns {Object} Downstream impact details
+ */
+function calculateDownstreamImpact(decisionId) {
+  const downstream = getDownstreamDecisions(decisionId);
+
+  if (downstream.length === 0) {
+    // Fallback to temporal-based counting for decisions without explicit links
+    return calculateTemporalDownstreamImpact(decisionId);
+  }
+
+  let successCount = 0;
+  let failureCount = 0;
+  let totalWeight = 0;
+
+  for (const d of downstream) {
+    const depthWeight = 1 / d.depth; // Closer decisions have more weight
+    const timeWeight = calculateTimeDecay(d.decision.timestamp);
+    const weight = depthWeight * timeWeight;
+
+    if (d.decision.outcome?.status === OUTCOME_STATUS.SUCCESS) {
+      successCount += weight;
+    } else if (d.decision.outcome?.status === OUTCOME_STATUS.FAILURE ||
+               d.decision.outcome?.status === OUTCOME_STATUS.REVERTED) {
+      failureCount += weight;
+    }
+    totalWeight += weight;
+  }
+
+  const successBonus = Math.min(
+    successCount * IMPACT_FACTORS.downstreamSuccessBonus,
+    IMPACT_FACTORS.maxDownstreamBonus
+  );
+
+  const failurePenalty = Math.min(
+    failureCount * IMPACT_FACTORS.downstreamFailurePenalty,
+    IMPACT_FACTORS.maxDownstreamPenalty
+  );
+
+  return {
+    downstreamCount: downstream.length,
+    weightedSuccesses: Math.round(successCount * 100) / 100,
+    weightedFailures: Math.round(failureCount * 100) / 100,
+    successBonus: Math.round(successBonus * 100) / 100,
+    failurePenalty: Math.round(failurePenalty * 100) / 100,
+    netImpact: Math.round((successBonus - failurePenalty) * 100) / 100,
+    hasExplicitChain: true
+  };
+}
+
+/**
+ * Calculate downstream impact based on temporal proximity (fallback)
+ * @param {string} decisionId - Decision ID
+ * @returns {Object} Downstream impact details
+ */
+function calculateTemporalDownstreamImpact(decisionId) {
+  const decisions = readAllDecisions();
+  const decision = decisions.find(d => d.id === decisionId);
+
+  if (!decision) {
+    return {
+      downstreamCount: 0,
+      weightedSuccesses: 0,
+      weightedFailures: 0,
+      successBonus: 0,
+      failurePenalty: 0,
+      netImpact: 0,
+      hasExplicitChain: false
+    };
+  }
+
+  const timestamp = new Date(decision.timestamp);
+  const relatedTypes = getRelatedTypes(decision.type);
+
+  const downstream = decisions.filter(d => {
+    const dTime = new Date(d.timestamp);
+    return dTime > timestamp && relatedTypes.includes(d.type);
+  });
+
+  let successCount = 0;
+  let failureCount = 0;
+
+  for (const d of downstream) {
+    const timeWeight = calculateTimeDecay(d.timestamp);
+
+    if (d.outcome?.status === OUTCOME_STATUS.SUCCESS) {
+      successCount += timeWeight;
+    } else if (d.outcome?.status === OUTCOME_STATUS.FAILURE ||
+               d.outcome?.status === OUTCOME_STATUS.REVERTED) {
+      failureCount += timeWeight;
+    }
+  }
+
+  const successBonus = Math.min(
+    successCount * IMPACT_FACTORS.downstreamSuccessBonus,
+    IMPACT_FACTORS.maxDownstreamBonus
+  );
+
+  const failurePenalty = Math.min(
+    failureCount * IMPACT_FACTORS.downstreamFailurePenalty,
+    IMPACT_FACTORS.maxDownstreamPenalty
+  );
+
+  return {
+    downstreamCount: downstream.length,
+    weightedSuccesses: Math.round(successCount * 100) / 100,
+    weightedFailures: Math.round(failureCount * 100) / 100,
+    successBonus: Math.round(successBonus * 100) / 100,
+    failurePenalty: Math.round(failurePenalty * 100) / 100,
+    netImpact: Math.round((successBonus - failurePenalty) * 100) / 100,
+    hasExplicitChain: false
+  };
+}
+
+/**
+ * Calculate impact score for a decision
+ * Enhanced with time decay, downstream tracking, and outcome propagation
+ * @param {object} decision - Decision object
+ * @param {object} options - Scoring options
+ * @param {boolean} options.includeDownstream - Include downstream impact (default: true)
+ * @param {boolean} options.applyTimeDecay - Apply time decay weighting (default: true)
+ * @returns {object} Impact score details
+ */
+function calculateImpactScore(decision, options = {}) {
+  const { includeDownstream = true, applyTimeDecay = true } = options;
+
+  if (!decision) return { score: 0, level: 'UNKNOWN', factors: {} };
+
+  // Base score from type
+  const typeWeight = IMPACT_FACTORS.typeWeights[decision.type] || 1.0;
+
+  // Confidence contribution
+  const confidenceScore = decision.confidence || 0.5;
+
+  // Outcome multiplier
+  const outcomeStatus = decision.outcome?.status || OUTCOME_STATUS.PENDING;
+  const outcomeMultiplier = IMPACT_FACTORS.outcomeMultipliers[outcomeStatus] || 0.8;
+
+  // Time decay for recency weighting
+  const timeDecayWeight = applyTimeDecay ? calculateTimeDecay(decision.timestamp) : 1.0;
+
+  // Calculate downstream impact
+  let downstreamImpact = { netImpact: 0, downstreamCount: 0 };
+  if (includeDownstream) {
+    downstreamImpact = calculateDownstreamImpact(decision.id);
+  }
+
+  // Calculate raw score with all factors
+  const baseScore = typeWeight * confidenceScore * outcomeMultiplier;
+  const weightedScore = baseScore * timeDecayWeight;
+  const finalScore = weightedScore + downstreamImpact.netImpact;
+
+  // Normalize to 1-5 scale
+  const normalizedScore = Math.min(Math.max(finalScore * 2.5, 1), 5);
+
+  // Determine level
+  let level = 'MINIMAL';
+  if (normalizedScore >= 4.5) level = 'CRITICAL';
+  else if (normalizedScore >= 3.5) level = 'HIGH';
+  else if (normalizedScore >= 2.5) level = 'MEDIUM';
+  else if (normalizedScore >= 1.5) level = 'LOW';
+
+  return {
+    score: Math.round(normalizedScore * 100) / 100,
+    rawScore: Math.round(finalScore * 100) / 100,
+    level,
+    factors: {
+      typeWeight,
+      confidenceScore,
+      outcomeMultiplier,
+      timeDecayWeight: Math.round(timeDecayWeight * 100) / 100,
+      downstreamImpact: downstreamImpact.netImpact,
+      downstreamCount: downstreamImpact.downstreamCount
+    },
+    downstream: includeDownstream ? downstreamImpact : null
+  };
+}
+
+/**
+ * Count downstream decisions affected by this decision (legacy support)
+ * @param {string} decisionId - Decision ID
+ * @returns {number} Count of downstream decisions
+ */
+function countDownstreamDecisions(decisionId) {
+  const impact = calculateDownstreamImpact(decisionId);
+  return impact.downstreamCount;
+}
+
+/**
+ * Get related decision types
+ * @param {string} type - Decision type
+ * @returns {Array} Related types
+ */
+function getRelatedTypes(type) {
+  const relationships = {
+    [DECISION_TYPES.ARCHITECTURE]: [DECISION_TYPES.DATABASE, DECISION_TYPES.API, DECISION_TYPES.DEPLOYMENT],
+    [DECISION_TYPES.DATABASE]: [DECISION_TYPES.API, DECISION_TYPES.PERFORMANCE],
+    [DECISION_TYPES.API]: [DECISION_TYPES.UI, DECISION_TYPES.TESTING],
+    [DECISION_TYPES.SECURITY]: [DECISION_TYPES.DATABASE, DECISION_TYPES.API, DECISION_TYPES.DEPLOYMENT],
+    [DECISION_TYPES.UI]: [DECISION_TYPES.TESTING, DECISION_TYPES.PERFORMANCE],
+    [DECISION_TYPES.TESTING]: [],
+    [DECISION_TYPES.DEPLOYMENT]: [DECISION_TYPES.PERFORMANCE],
+    [DECISION_TYPES.PERFORMANCE]: [],
+    [DECISION_TYPES.AGENT_SELECTION]: [DECISION_TYPES.WORKFLOW_CHOICE, DECISION_TYPES.SKILL_USAGE],
+    [DECISION_TYPES.WORKFLOW_CHOICE]: [DECISION_TYPES.SKILL_USAGE],
+    [DECISION_TYPES.SKILL_USAGE]: [],
+    [DECISION_TYPES.REFACTOR]: [DECISION_TYPES.TESTING, DECISION_TYPES.PERFORMANCE],
+    [DECISION_TYPES.BUG_FIX]: [DECISION_TYPES.TESTING]
+  };
+
+  return [type, ...(relationships[type] || [])];
+}
+
+/**
+ * Track successful outcomes and their decision chains
+ * @param {string} decisionId - Decision ID that succeeded
+ * @returns {Object} Success chain analysis
+ */
+function trackSuccessChain(decisionId) {
+  const decision = getDecisionById(decisionId);
+  if (!decision || decision.outcome?.status !== OUTCOME_STATUS.SUCCESS) {
+    return null;
+  }
+
+  const upstream = getUpstreamDecisions(decisionId);
+  const downstream = getDownstreamDecisions(decisionId);
+
+  // Find all decisions in the chain that also succeeded
+  const successfulUpstream = upstream.filter(
+    u => u.decision.outcome?.status === OUTCOME_STATUS.SUCCESS
+  );
+  const successfulDownstream = downstream.filter(
+    d => d.decision.outcome?.status === OUTCOME_STATUS.SUCCESS
+  );
+
+  // Calculate chain success rate
+  const totalInChain = upstream.length + downstream.length + 1;
+  const successfulInChain = successfulUpstream.length + successfulDownstream.length + 1;
+  const chainSuccessRate = totalInChain > 0 ? successfulInChain / totalInChain : 1;
+
+  return {
+    decisionId,
+    decision: decision.decision,
+    type: decision.type,
+    chainLength: totalInChain,
+    chainSuccessRate: Math.round(chainSuccessRate * 100) / 100,
+    successfulUpstream: successfulUpstream.map(u => ({
+      id: u.id,
+      decision: u.decision.decision,
+      type: u.decision.type
+    })),
+    successfulDownstream: successfulDownstream.map(d => ({
+      id: d.id,
+      decision: d.decision.decision,
+      type: d.decision.type
+    })),
+    timestamp: decision.timestamp
+  };
+}
+
+/**
+ * Get decisions that led to successful outcomes
+ * Identifies patterns and decision chains that correlate with success
+ * @param {Object} options - Filter options
+ * @param {number} options.minSuccessRate - Minimum chain success rate (0-1)
+ * @param {number} options.minChainLength - Minimum chain length
+ * @param {number} options.limit - Maximum results to return
+ * @returns {Array} Successful decision patterns
+ */
+function getSuccessfulDecisionPatterns(options = {}) {
+  const {
+    minSuccessRate = 0.7,
+    minChainLength = 2,
+    limit = 20
+  } = options;
+
+  const decisions = readAllDecisions();
+  const successfulDecisions = decisions.filter(
+    d => d.outcome?.status === OUTCOME_STATUS.SUCCESS
+  );
+
+  const patterns = [];
+
+  for (const decision of successfulDecisions) {
+    const chain = trackSuccessChain(decision.id);
+    if (chain &&
+        chain.chainSuccessRate >= minSuccessRate &&
+        chain.chainLength >= minChainLength) {
+      patterns.push({
+        ...chain,
+        impact: calculateImpactScore(decision)
+      });
+    }
+  }
+
+  // Sort by impact score and chain success rate
+  return patterns
+    .sort((a, b) => {
+      const scoreA = a.impact.score * a.chainSuccessRate;
+      const scoreB = b.impact.score * b.chainSuccessRate;
+      return scoreB - scoreA;
+    })
+    .slice(0, limit);
+}
+
+/**
+ * Get highest impact decisions with enhanced analysis
+ * @param {number} limit - Number of decisions to return
+ * @param {Object} options - Filter options
+ * @param {boolean} options.onlySuccessful - Only include successful decisions
+ * @param {string} options.type - Filter by decision type
+ * @param {number} options.minScore - Minimum impact score
+ * @returns {Array} Decisions sorted by impact score
+ */
+function getHighImpactDecisions(limit = 10, options = {}) {
+  const {
+    onlySuccessful = false,
+    type = null,
+    minScore = 0
+  } = options;
+
+  let decisions = readAllDecisions();
+
+  // Apply filters
+  if (onlySuccessful) {
+    decisions = decisions.filter(d => d.outcome?.status === OUTCOME_STATUS.SUCCESS);
+  }
+  if (type) {
+    decisions = decisions.filter(d => d.type === type);
+  }
+
+  const withImpact = decisions
+    .map(d => ({
+      ...d,
+      impact: calculateImpactScore(d)
+    }))
+    .filter(d => d.impact.score >= minScore);
+
+  return withImpact
+    .sort((a, b) => b.impact.score - a.impact.score)
+    .slice(0, limit);
+}
+
+/**
+ * Generate comprehensive impact report for decision analysis
+ * @param {Object} options - Report options
+ * @param {number} options.days - Number of days to analyze
+ * @param {boolean} options.includeChains - Include decision chain analysis
+ * @param {boolean} options.includePatterns - Include pattern analysis
+ * @returns {Object} Comprehensive impact report
+ */
+function generateImpactReport(options = {}) {
+  const {
+    days = 30,
+    includeChains = true,
+    includePatterns = true
+  } = options;
+
+  const cutoffDate = new Date();
+  cutoffDate.setDate(cutoffDate.getDate() - days);
+
+  const decisions = readAllDecisions();
+  const recentDecisions = decisions.filter(
+    d => new Date(d.timestamp) >= cutoffDate
+  );
+
+  // Calculate impact for all recent decisions
+  const withImpact = recentDecisions.map(d => ({
+    ...d,
+    impact: calculateImpactScore(d)
+  }));
+
+  // Group by impact level
+  const byLevel = {};
+  for (const level of Object.keys(IMPACT_LEVELS)) {
+    byLevel[level] = withImpact.filter(d => d.impact.level === level);
+  }
+
+  // Group by type
+  const byType = {};
+  for (const d of withImpact) {
+    if (!byType[d.type]) {
+      byType[d.type] = { decisions: [], totalScore: 0, successCount: 0 };
+    }
+    byType[d.type].decisions.push(d);
+    byType[d.type].totalScore += d.impact.score;
+    if (d.outcome?.status === OUTCOME_STATUS.SUCCESS) {
+      byType[d.type].successCount++;
+    }
+  }
+
+  // Calculate type stats
+  const typeStats = Object.entries(byType).map(([type, data]) => ({
+    type,
+    count: data.decisions.length,
+    averageScore: Math.round((data.totalScore / data.decisions.length) * 100) / 100,
+    successRate: Math.round((data.successCount / data.decisions.length) * 100) / 100,
+    highestImpact: data.decisions.sort((a, b) => b.impact.score - a.impact.score)[0]
+  })).sort((a, b) => b.averageScore - a.averageScore);
+
+  // Overall stats
+  const totalScore = withImpact.reduce((sum, d) => sum + d.impact.score, 0);
+  const successfulDecisions = withImpact.filter(
+    d => d.outcome?.status === OUTCOME_STATUS.SUCCESS
+  );
+
+  // Time trend analysis
+  const weeklyTrends = calculateWeeklyTrends(withImpact, days);
+
+  // Build report
+  const report = {
+    generated: getTimestamp(),
+    period: {
+      days,
+      from: cutoffDate.toISOString(),
+      to: new Date().toISOString()
+    },
+    summary: {
+      totalDecisions: withImpact.length,
+      averageImpactScore: withImpact.length > 0
+        ? Math.round((totalScore / withImpact.length) * 100) / 100
+        : 0,
+      successfulDecisions: successfulDecisions.length,
+      successRate: withImpact.length > 0
+        ? Math.round((successfulDecisions.length / withImpact.length) * 100) / 100
+        : 0,
+      highImpactCount: byLevel.HIGH?.length || 0 + (byLevel.CRITICAL?.length || 0)
+    },
+    byLevel: Object.entries(byLevel).map(([level, decisions]) => ({
+      level,
+      count: decisions.length,
+      percentage: withImpact.length > 0
+        ? Math.round((decisions.length / withImpact.length) * 100)
+        : 0
+    })),
+    byType: typeStats,
+    trends: weeklyTrends,
+    topDecisions: withImpact
+      .sort((a, b) => b.impact.score - a.impact.score)
+      .slice(0, 10)
+      .map(d => ({
+        id: d.id,
+        decision: d.decision,
+        type: d.type,
+        score: d.impact.score,
+        level: d.impact.level,
+        outcome: d.outcome?.status,
+        timestamp: d.timestamp
+      }))
+  };
+
+  // Add chain analysis if requested
+  if (includeChains) {
+    const chainsData = loadDecisionChains();
+    const chainedDecisionIds = Object.keys(chainsData.chains);
+    const chainedCount = chainedDecisionIds.length;
+
+    report.chainAnalysis = {
+      totalChainedDecisions: chainedCount,
+      percentageChained: withImpact.length > 0
+        ? Math.round((chainedCount / decisions.length) * 100)
+        : 0,
+      longestChains: findLongestChains(5)
+    };
+  }
+
+  // Add pattern analysis if requested
+  if (includePatterns) {
+    report.successPatterns = getSuccessfulDecisionPatterns({
+      minSuccessRate: 0.7,
+      minChainLength: 2,
+      limit: 10
+    });
+
+    report.highImpactPatterns = identifyHighImpactPatterns(withImpact);
+  }
+
+  return report;
+}
+
+/**
+ * Calculate weekly trends for impact scores
+ * @param {Array} decisions - Decisions with impact scores
+ * @param {number} days - Number of days to analyze
+ * @returns {Array} Weekly trend data
+ */
+function calculateWeeklyTrends(decisions, days) {
+  const weeks = Math.ceil(days / 7);
+  const trends = [];
+  const now = new Date();
+
+  for (let i = 0; i < weeks; i++) {
+    const weekEnd = new Date(now);
+    weekEnd.setDate(weekEnd.getDate() - (i * 7));
+    const weekStart = new Date(weekEnd);
+    weekStart.setDate(weekStart.getDate() - 7);
+
+    const weekDecisions = decisions.filter(d => {
+      const dDate = new Date(d.timestamp);
+      return dDate >= weekStart && dDate < weekEnd;
+    });
+
+    const totalScore = weekDecisions.reduce((sum, d) => sum + d.impact.score, 0);
+    const successCount = weekDecisions.filter(
+      d => d.outcome?.status === OUTCOME_STATUS.SUCCESS
+    ).length;
+
+    trends.unshift({
+      week: weeks - i,
+      weekStart: weekStart.toISOString().split('T')[0],
+      weekEnd: weekEnd.toISOString().split('T')[0],
+      decisionCount: weekDecisions.length,
+      averageScore: weekDecisions.length > 0
+        ? Math.round((totalScore / weekDecisions.length) * 100) / 100
+        : 0,
+      successRate: weekDecisions.length > 0
+        ? Math.round((successCount / weekDecisions.length) * 100) / 100
+        : 0
+    });
+  }
+
+  return trends;
+}
+
+/**
+ * Find the longest decision chains
+ * @param {number} limit - Number of chains to return
+ * @returns {Array} Longest chains
+ */
+function findLongestChains(limit = 5) {
+  const chainsData = loadDecisionChains();
+  const chainLengths = [];
+
+  for (const decisionId of Object.keys(chainsData.chains)) {
+    const upstream = getUpstreamDecisions(decisionId);
+    const downstream = getDownstreamDecisions(decisionId);
+    const totalLength = upstream.length + downstream.length + 1;
+
+    chainLengths.push({
+      decisionId,
+      totalLength,
+      upstreamCount: upstream.length,
+      downstreamCount: downstream.length
+    });
+  }
+
+  return chainLengths
+    .sort((a, b) => b.totalLength - a.totalLength)
+    .slice(0, limit);
+}
+
+/**
+ * Identify high-impact patterns from decisions
+ * @param {Array} decisions - Decisions with impact scores
+ * @returns {Object} Pattern analysis
+ */
+function identifyHighImpactPatterns(decisions) {
+  const highImpact = decisions.filter(d =>
+    d.impact.level === 'HIGH' || d.impact.level === 'CRITICAL'
+  );
+
+  // Group by decision text similarity
+  const patternGroups = {};
+  for (const d of highImpact) {
+    const key = `${d.type}:${normalizeDecisionText(d.decision)}`;
+    if (!patternGroups[key]) {
+      patternGroups[key] = {
+        type: d.type,
+        pattern: d.decision,
+        decisions: [],
+        totalScore: 0,
+        successCount: 0
+      };
+    }
+    patternGroups[key].decisions.push(d);
+    patternGroups[key].totalScore += d.impact.score;
+    if (d.outcome?.status === OUTCOME_STATUS.SUCCESS) {
+      patternGroups[key].successCount++;
+    }
+  }
+
+  // Convert to array and sort by frequency and score
+  return Object.values(patternGroups)
+    .filter(p => p.decisions.length >= 2)
+    .map(p => ({
+      type: p.type,
+      pattern: p.pattern,
+      occurrences: p.decisions.length,
+      averageScore: Math.round((p.totalScore / p.decisions.length) * 100) / 100,
+      successRate: Math.round((p.successCount / p.decisions.length) * 100) / 100
+    }))
+    .sort((a, b) => (b.occurrences * b.averageScore) - (a.occurrences * a.averageScore))
+    .slice(0, 10);
+}
+
+/**
+ * Normalize decision text for pattern matching
+ * @param {string} text - Decision text
+ * @returns {string} Normalized text
+ */
+function normalizeDecisionText(text) {
+  return (text || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, 50);
+}
+
+/**
+ * Get impact-boosted patterns for recommendations integration
+ * Returns patterns that have proven high-impact and successful
+ * @param {Object} options - Options
+ * @param {number} options.minScore - Minimum impact score
+ * @param {number} options.minSuccessRate - Minimum success rate
+ * @returns {Array} High-impact patterns for boosting recommendations
+ */
+function getImpactBoostedPatterns(options = {}) {
+  const {
+    minScore = 3.0,
+    minSuccessRate = 0.6
+  } = options;
+
+  const decisions = readAllDecisions();
+  const withImpact = decisions.map(d => ({
+    ...d,
+    impact: calculateImpactScore(d)
+  }));
+
+  // Group by type and decision pattern
+  const patterns = {};
+  for (const d of withImpact) {
+    if (d.impact.score < minScore) continue;
+
+    const key = `${d.type}:${normalizeDecisionText(d.decision)}`;
+    if (!patterns[key]) {
+      patterns[key] = {
+        type: d.type,
+        decision: d.decision,
+        decisions: [],
+        totalScore: 0,
+        successCount: 0,
+        totalTimeDecayWeight: 0
+      };
+    }
+    patterns[key].decisions.push(d);
+    patterns[key].totalScore += d.impact.score;
+    patterns[key].totalTimeDecayWeight += d.impact.factors.timeDecayWeight;
+    if (d.outcome?.status === OUTCOME_STATUS.SUCCESS) {
+      patterns[key].successCount++;
+    }
+  }
+
+  // Filter and format for recommendations
+  return Object.values(patterns)
+    .filter(p => {
+      const successRate = p.successCount / p.decisions.length;
+      return p.decisions.length >= 2 && successRate >= minSuccessRate;
+    })
+    .map(p => {
+      const successRate = p.successCount / p.decisions.length;
+      const avgScore = p.totalScore / p.decisions.length;
+      const avgRecency = p.totalTimeDecayWeight / p.decisions.length;
+
+      // Calculate boost factor for recommendations
+      // Higher for recent, successful, high-impact patterns
+      const boostFactor = avgScore * successRate * (0.5 + avgRecency * 0.5);
+
+      return {
+        type: p.type,
+        decision: p.decision,
+        occurrences: p.decisions.length,
+        averageImpactScore: Math.round(avgScore * 100) / 100,
+        successRate: Math.round(successRate * 100) / 100,
+        recencyWeight: Math.round(avgRecency * 100) / 100,
+        boostFactor: Math.round(boostFactor * 100) / 100,
+        recommendation: successRate >= 0.8 ? 'STRONGLY_RECOMMENDED' :
+          successRate >= 0.6 ? 'RECOMMENDED' : 'NEUTRAL'
+      };
+    })
+    .sort((a, b) => b.boostFactor - a.boostFactor);
+}
+
+/**
+ * Get impact statistics with enhanced analysis
+ * @returns {object} Impact statistics
+ */
+function getImpactStats() {
+  const decisions = readAllDecisions();
+
+  if (decisions.length === 0) {
+    return {
+      totalDecisions: 0,
+      byLevel: {},
+      averageScore: 0,
+      highestImpact: null,
+      recentTrend: null,
+      impactBoostedPatterns: []
+    };
+  }
+
+  const withImpact = decisions.map(d => ({
+    ...d,
+    impact: calculateImpactScore(d)
+  }));
+
+  const byLevel = {};
+  let totalScore = 0;
+  let highestImpact = null;
+
+  for (const d of withImpact) {
+    const level = d.impact.level;
+    byLevel[level] = (byLevel[level] || 0) + 1;
+    totalScore += d.impact.score;
+
+    if (!highestImpact || d.impact.score > highestImpact.impact.score) {
+      highestImpact = d;
+    }
+  }
+
+  // Calculate recent trend (last 7 days vs previous 7 days)
+  const now = new Date();
+  const oneWeekAgo = new Date(now);
+  oneWeekAgo.setDate(oneWeekAgo.getDate() - 7);
+  const twoWeeksAgo = new Date(now);
+  twoWeeksAgo.setDate(twoWeeksAgo.getDate() - 14);
+
+  const recentDecisions = withImpact.filter(d => new Date(d.timestamp) >= oneWeekAgo);
+  const previousDecisions = withImpact.filter(d => {
+    const dt = new Date(d.timestamp);
+    return dt >= twoWeeksAgo && dt < oneWeekAgo;
+  });
+
+  const recentAvg = recentDecisions.length > 0
+    ? recentDecisions.reduce((sum, d) => sum + d.impact.score, 0) / recentDecisions.length
+    : 0;
+  const previousAvg = previousDecisions.length > 0
+    ? previousDecisions.reduce((sum, d) => sum + d.impact.score, 0) / previousDecisions.length
+    : 0;
+
+  const trendDirection = recentAvg > previousAvg ? 'improving' :
+    recentAvg < previousAvg ? 'declining' : 'stable';
+
+  return {
+    totalDecisions: decisions.length,
+    byLevel,
+    averageScore: Math.round((totalScore / decisions.length) * 100) / 100,
+    highestImpact: highestImpact ? {
+      id: highestImpact.id,
+      type: highestImpact.type,
+      decision: highestImpact.decision,
+      score: highestImpact.impact.score,
+      level: highestImpact.impact.level
+    } : null,
+    recentTrend: {
+      direction: trendDirection,
+      recentAverage: Math.round(recentAvg * 100) / 100,
+      previousAverage: Math.round(previousAvg * 100) / 100,
+      recentCount: recentDecisions.length,
+      previousCount: previousDecisions.length
+    },
+    impactBoostedPatterns: getImpactBoostedPatterns({ minScore: 3.0, minSuccessRate: 0.6 }).slice(0, 5)
+  };
 }
 
 module.exports = {
+  // Constants
   DECISION_TYPES,
   OUTCOME_STATUS,
+  IMPACT_LEVELS,
+  TIME_DECAY,
+  IMPACT_FACTORS,
+
+  // Core decision tracking
   logDecision,
   recordOutcome,
   readAllDecisions,
+  getDecisionById,
   getDecisionsByType,
   getDecisionsByOutcome,
   getRecentDecisions,
@@ -435,5 +1809,31 @@ module.exports = {
   getRecommendation,
   getStats,
   getPatterns,
-  clearHistory
+  clearHistory,
+  compact,
+  shouldCompact,
+  flushIndex,
+  rebuildIndex,
+
+  // Impact scoring (enhanced)
+  calculateImpactScore,
+  calculateTimeDecay,
+  calculateDownstreamImpact,
+  getHighImpactDecisions,
+  getImpactStats,
+
+  // Decision chains
+  linkDecisions,
+  getDownstreamDecisions,
+  getUpstreamDecisions,
+  trackSuccessChain,
+  getSuccessfulDecisionPatterns,
+
+  // Impact reports and analysis
+  generateImpactReport,
+  getImpactBoostedPatterns,
+
+  // Utility functions
+  getRelatedTypes,
+  countDownstreamDecisions
 };