@girardmedia/bootspring 1.2.0 → 2.0.3

package/intelligence/prd.js

@@ -103,7 +103,7 @@ function getNextStory(prd) {
 /**
  * Update story status
  */
-function updateStoryStatus(prd, storyId, status) {
+function updateStoryStatus(prd, storyId, status, options = {}) {
   const story = prd.stories.find(s => s.id === storyId);
   if (!story) {
     throw new Error(`Story not found: ${storyId}`);
@@ -112,11 +112,95 @@ function updateStoryStatus(prd, storyId, status) {
   story.status = status;
   if (status === 'complete') {
     story.completedAt = new Date().toISOString();
+
+    // Notify workflow system if integrated
+    if (options.notifyWorkflow !== false) {
+      try {
+        const orchestrator = require('./orchestrator');
+        orchestrator.onPrdStoryComplete(prd.name, storyId);
+      } catch {
+        // Orchestrator not available or PRD not linked
+      }
+    }
   }
 
   return prd;
 }
 
+/**
+ * Link this PRD to a workflow for automatic progress tracking
+ * @param {object} prd - The PRD object
+ * @param {string} workflowName - Name of the workflow to link
+ * @param {object} options - Optional configuration
+ * @param {object} options.manualMapping - Manual story->phase mapping { storyId: phaseIndex }
+ * @param {boolean} options.autoAdvance - Auto-advance workflow on phase completion (default: true)
+ */
+function linkToWorkflow(prd, workflowName, options = {}) {
+  const orchestrator = require('./orchestrator');
+  return orchestrator.linkPrdToWorkflow(prd, workflowName, options);
+}
+
+/**
+ * Get workflow link status for this PRD
+ * @param {string} prdName - Name of the PRD
+ */
+function getWorkflowStatus(prdName) {
+  const orchestrator = require('./orchestrator');
+  return orchestrator.getPrdWorkflowStatus(prdName);
+}
+
+/**
+ * Get stories assigned to a specific workflow phase
+ * @param {string} prdName - Name of the PRD
+ * @param {number} phaseIndex - Index of the workflow phase
+ */
+function getStoriesForPhase(prdName, phaseIndex) {
+  const orchestrator = require('./orchestrator');
+  return orchestrator.getPhaseStories(prdName, phaseIndex);
+}
+
+/**
+ * Reassign a story to a different workflow phase
+ * @param {string} prdName - Name of the PRD
+ * @param {string} storyId - ID of the story
+ * @param {number} newPhaseIndex - New phase index to assign
+ */
+function reassignStoryPhase(prdName, storyId, newPhaseIndex) {
+  const orchestrator = require('./orchestrator');
+  return orchestrator.reassignStoryToPhase(prdName, storyId, newPhaseIndex);
+}
+
+/**
+ * Unlink a PRD from its workflow
+ * @param {string} prdName - Name of the PRD
+ */
+function unlinkFromWorkflow(prdName) {
+  const orchestrator = require('./orchestrator');
+  return orchestrator.unlinkPrdFromWorkflow(prdName);
+}
+
+/**
+ * Get combined PRD and workflow progress
+ * @param {object} prd - The PRD object
+ */
+function getFullProgress(prd) {
+  const prdProgress = getProgress(prd);
+  const workflowStatus = getWorkflowStatus(prd.name);
+
+  return {
+    prd: prdProgress,
+    workflow: workflowStatus ? {
+      linked: true,
+      workflowName: workflowStatus.workflowName,
+      currentPhase: workflowStatus.currentPhaseName,
+      phaseProgress: workflowStatus.phaseProgress,
+      autoAdvance: workflowStatus.autoAdvance
+    } : {
+      linked: false
+    }
+  };
+}
+
 /**
  * Get PRD progress summary
  */
@@ -442,6 +526,13 @@ module.exports = {
   parseMarkdownPRD,
   toMarkdown,
   validateStorySize,
+  // Workflow integration
+  linkToWorkflow,
+  getWorkflowStatus,
+  getStoriesForPhase,
+  reassignStoryPhase,
+  unlinkFromWorkflow,
+  getFullProgress,
   DEFAULT_PRD_DIR,
   DEFAULT_PRD_FILE
 };

package/intelligence/recommendation-weights.json

@@ -7,12 +7,24 @@
     "completionRateMultiplier": 20,
     "contextMatch": 12,
     "packBonus": 3,
-    "premiumUnlock": 4
+    "premiumUnlock": 4,
+    "learningBonus": 8,
+    "learningSuccessRateMultiplier": 15,
+    "correlationBonus": 6,
+    "antiPatternPenalty": 12
   },
   "skill": {
     "base": 25,
     "usage": 4,
-    "premiumUnlock": 3
+    "premiumUnlock": 3,
+    "learningSuccessRateMultiplier": 10,
+    "antiPatternPenalty": 8
+  },
+  "learning": {
+    "minConfidence": 0.5,
+    "minSampleSize": 3,
+    "successRateThreshold": 0.7,
+    "antiPatternFailureThreshold": 0.6
   },
   "eventWindowLimit": 1000
 }

package/intelligence/recommendations.js

@@ -1,10 +1,19 @@
 /**
  * Recommendation engine v1
  * Ranks workflows and skills from context + telemetry outcomes.
+ * Enhanced with pattern learning insights.
+ *
+ * Learning Integration:
+ * - Boosts recommendations based on type/phase success rates
+ * - Penalizes workflows/skills associated with anti-patterns
+ * - Leverages correlations to recommend related successful patterns
+ * - Weighs recommendations by confidence from sample size
  */
 
 const fs = require('fs');
 const path = require('path');
+const patternLearner = require('./learning/pattern-learner');
+const decisionTracker = require('./memory/decision-tracker');
 
 const DEFAULT_WEIGHTS_PATH = path.join(__dirname, 'recommendation-weights.json');
 
@@ -59,6 +68,333 @@ function buildSkillUsage(events) {
   return { usage, premiumUnlocks };
 }
 
+/**
+ * Calculate impact-based score adjustment for a workflow
+ * Uses decision tracker's impact scoring to boost high-impact patterns
+ * @param {Object} workflow - The workflow being scored
+ * @param {Object} weights - Resolved weights configuration
+ * @returns {Object} - { scoreAdjustment, reasons }
+ */
+function calculateImpactBoost(workflow, weights) {
+  const adjustment = { score: 0, reasons: [] };
+
+  try {
+    // Get impact-boosted patterns from decision tracker
+    const impactPatterns = decisionTracker.getImpactBoostedPatterns({
+      minScore: weights.impact?.minScore || 3.0,
+      minSuccessRate: weights.impact?.minSuccessRate || 0.6
+    });
+
+    if (!impactPatterns || impactPatterns.length === 0) {
+      return adjustment;
+    }
+
+    // Find patterns that match this workflow
+    const workflowKey = (workflow.key || '').toLowerCase();
+    const workflowName = (workflow.name || '').toLowerCase();
+    const combined = `${workflowKey} ${workflowName}`;
+
+    for (const pattern of impactPatterns) {
+      const patternDecision = (pattern.decision || '').toLowerCase();
+      const patternType = (pattern.type || '').toLowerCase();
+
+      // Check if workflow matches the high-impact pattern
+      const matchesDecision = combined.includes(patternDecision.slice(0, 20)) ||
+                              patternDecision.includes(workflowKey);
+      const matchesType = inferWorkflowType(workflow) === patternType;
+
+      if (matchesDecision || matchesType) {
+        // Calculate boost based on pattern's boost factor
+        const boost = Math.round(
+          pattern.boostFactor * Number(weights.impact?.impactBoostMultiplier || 10)
+        );
+        adjustment.score += boost;
+        adjustment.reasons.push(
+          `matches high-impact pattern: ${pattern.type} (${(pattern.successRate * 100).toFixed(0)}% success, ` +
+          `${pattern.averageImpactScore.toFixed(1)} impact score)`
+        );
+
+        // Only apply one impact boost per workflow
+        break;
+      }
+    }
+  } catch {
+    // Impact scoring not available, skip silently
+  }
+
+  return adjustment;
+}
+
+/**
+ * Calculate learning-based score adjustment for a workflow
+ * @param {Object} workflow - The workflow being scored
+ * @param {Object} learningInsights - Insights from pattern learner
+ * @param {Object} analysis - Context analysis with phase info
+ * @param {Object} weights - Resolved weights configuration
+ * @returns {Object} - { scoreAdjustment, reasons }
+ */
+function calculateLearningBoost(workflow, learningInsights, analysis, weights) {
+  const adjustment = { score: 0, reasons: [] };
+
+  if (!learningInsights || learningInsights.using_defaults) {
+    return adjustment;
+  }
+
+  const learningWeights = weights.learning || {};
+  const minConfidence = learningWeights.minConfidence || 0.5;
+  const minSampleSize = learningWeights.minSampleSize || 3;
+  const successRateThreshold = learningWeights.successRateThreshold || 0.7;
+
+  // 1. Phase-based boost: If current phase has high success rate, boost matching workflows
+  const currentPhase = analysis.phase;
+  const phaseRec = learningInsights.recommendations?.by_phase?.[currentPhase];
+  if (phaseRec && !phaseRec.is_default && phaseRec.sample_size >= minSampleSize) {
+    if (phaseRec.success_rate >= successRateThreshold) {
+      const boost = Math.round(
+        phaseRec.success_rate * Number(weights.workflow?.learningSuccessRateMultiplier || 15)
+      );
+      adjustment.score += boost;
+      adjustment.reasons.push(`phase "${currentPhase}" has ${(phaseRec.success_rate * 100).toFixed(0)}% success rate`);
+    }
+  }
+
+  // 2. Type-based boost: Match workflow tags/type with learned type success rates
+  const workflowType = workflow.type || inferWorkflowType(workflow);
+  const typeRec = learningInsights.recommendations?.by_type?.[workflowType];
+  if (typeRec && !typeRec.is_default && typeRec.sample_size >= minSampleSize) {
+    if (typeRec.success_rate >= successRateThreshold) {
+      const boost = Math.round(
+        typeRec.success_rate * Number(weights.workflow?.learningSuccessRateMultiplier || 15)
+      );
+      adjustment.score += boost;
+      adjustment.reasons.push(`type "${workflowType}" has ${(typeRec.success_rate * 100).toFixed(0)}% success rate`);
+    } else if (typeRec.success_rate < 0.4) {
+      // Penalty for consistently failing types
+      const penalty = Math.round(
+        (1 - typeRec.success_rate) * Number(weights.workflow?.antiPatternPenalty || 12) * 0.5
+      );
+      adjustment.score -= penalty;
+      adjustment.reasons.push(`type "${workflowType}" has low success rate (${(typeRec.success_rate * 100).toFixed(0)}%)`);
+    }
+  }
+
+  // 3. Correlation boost: If workflow relates to recently successful patterns
+  const correlations = learningInsights.correlations || [];
+  for (const corr of correlations) {
+    const workflowMatches = workflow.key?.includes(corr.type_a) ||
+      workflow.key?.includes(corr.type_b) ||
+      workflow.name?.toLowerCase().includes(corr.decision_a?.toLowerCase()) ||
+      workflow.name?.toLowerCase().includes(corr.decision_b?.toLowerCase());
+
+    if (workflowMatches && corr.occurrences >= 2) {
+      adjustment.score += Number(weights.workflow?.correlationBonus || 6);
+      adjustment.reasons.push(`correlates with successful pattern: ${corr.decision_a} → ${corr.decision_b}`);
+      break; // Only apply one correlation bonus
+    }
+  }
+
+  // 4. Anti-pattern penalty: Penalize workflows matching known anti-patterns
+  const antiPatterns = learningInsights.anti_patterns || [];
+  for (const ap of antiPatterns) {
+    if (ap.is_default) continue; // Skip default anti-patterns
+    const matchesAntiPattern = workflow.key?.toLowerCase().includes(ap.decision?.toLowerCase()) ||
+      workflow.name?.toLowerCase().includes(ap.decision?.toLowerCase());
+
+    if (matchesAntiPattern && ap.failure_rate >= (learningWeights.antiPatternFailureThreshold || 0.6)) {
+      const penalty = Math.round(
+        ap.failure_rate * Number(weights.workflow?.antiPatternPenalty || 12)
+      );
+      adjustment.score -= penalty;
+      adjustment.reasons.push(`matches anti-pattern: "${ap.decision}" (${(ap.failure_rate * 100).toFixed(0)}% failure rate)`);
+    }
+  }
+
+  // 5. Insight-based adjustments from high-confidence insights
+  const insights = learningInsights.insights || [];
+  for (const insight of insights) {
+    if (insight.confidence < minConfidence) continue;
+
+    if (insight.type === 'type_performance' && insight.level === 'positive') {
+      if (workflowType === insight.subject) {
+        adjustment.score += Number(weights.workflow?.learningBonus || 8);
+        adjustment.reasons.push(`high-performing type: ${insight.message}`);
+      }
+    }
+  }
+
+  return adjustment;
+}
+
+/**
+ * Calculate impact-based score adjustment for a skill
+ * Uses decision tracker's impact scoring to boost high-impact skill patterns
+ * @param {string} skillId - The skill ID
+ * @param {Object} metadata - Skill metadata
+ * @param {Object} weights - Resolved weights configuration
+ * @returns {Object} - { scoreAdjustment, reasons }
+ */
+function calculateSkillImpactBoost(skillId, metadata, weights) {
+  const adjustment = { score: 0, reasons: [] };
+
+  try {
+    // Get impact-boosted patterns from decision tracker
+    const impactPatterns = decisionTracker.getImpactBoostedPatterns({
+      minScore: weights.impact?.minScore || 3.0,
+      minSuccessRate: weights.impact?.minSuccessRate || 0.6
+    });
+
+    if (!impactPatterns || impactPatterns.length === 0) {
+      return adjustment;
+    }
+
+    // Find patterns that match this skill
+    const skillIdLower = (skillId || '').toLowerCase();
+    const skillName = (metadata?.name || '').toLowerCase();
+    const skillType = inferSkillType(skillId);
+
+    for (const pattern of impactPatterns) {
+      const patternDecision = (pattern.decision || '').toLowerCase();
+      const patternType = (pattern.type || '').toLowerCase();
+
+      // Check if skill matches the high-impact pattern
+      const matchesDecision = skillIdLower.includes(patternDecision.slice(0, 15)) ||
+                              patternDecision.includes(skillIdLower.slice(0, 15)) ||
+                              skillName.includes(patternDecision.slice(0, 15));
+      const matchesType = skillType === patternType;
+
+      if (matchesDecision || matchesType) {
+        // Calculate boost based on pattern's boost factor (slightly lower for skills)
+        const boost = Math.round(
+          pattern.boostFactor * Number(weights.impact?.skillImpactBoostMultiplier || 7)
+        );
+        adjustment.score += boost;
+        adjustment.reasons.push(
+          `matches high-impact pattern: ${pattern.type} (${(pattern.successRate * 100).toFixed(0)}% success)`
+        );
+
+        // Only apply one impact boost per skill
+        break;
+      }
+    }
+  } catch {
+    // Impact scoring not available, skip silently
+  }
+
+  return adjustment;
+}
+
+/**
+ * Calculate learning-based score adjustment for a skill
+ * @param {string} skillId - The skill ID
+ * @param {Object} metadata - Skill metadata
+ * @param {Object} learningInsights - Insights from pattern learner
+ * @param {Object} weights - Resolved weights configuration
+ * @returns {Object} - { scoreAdjustment, reasons }
+ */
+function calculateSkillLearningBoost(skillId, metadata, learningInsights, weights) {
+  const adjustment = { score: 0, reasons: [] };
+
+  if (!learningInsights || learningInsights.using_defaults) {
+    return adjustment;
+  }
+
+  const learningWeights = weights.learning || {};
+  const minSampleSize = learningWeights.minSampleSize || 3;
+  const successRateThreshold = learningWeights.successRateThreshold || 0.7;
+
+  // Infer skill type from id/metadata
+  const skillType = metadata?.type || inferSkillType(skillId);
+
+  // Type-based boost for skills
+  const typeRec = learningInsights.recommendations?.by_type?.[skillType];
+  if (typeRec && !typeRec.is_default && typeRec.sample_size >= minSampleSize) {
+    if (typeRec.success_rate >= successRateThreshold) {
+      const boost = Math.round(
+        typeRec.success_rate * Number(weights.skill?.learningSuccessRateMultiplier || 10)
+      );
+      adjustment.score += boost;
+      adjustment.reasons.push(`skill type "${skillType}" has ${(typeRec.success_rate * 100).toFixed(0)}% success rate`);
+    }
+  }
+
+  // Anti-pattern penalty for skills
+  const antiPatterns = learningInsights.anti_patterns || [];
+  for (const ap of antiPatterns) {
+    if (ap.is_default) continue;
+    const matchesAntiPattern = skillId.toLowerCase().includes(ap.decision?.toLowerCase()) ||
+      (metadata?.name || '').toLowerCase().includes(ap.decision?.toLowerCase());
+
+    if (matchesAntiPattern && ap.failure_rate >= (learningWeights.antiPatternFailureThreshold || 0.6)) {
+      const penalty = Math.round(
+        ap.failure_rate * Number(weights.skill?.antiPatternPenalty || 8)
+      );
+      adjustment.score -= penalty;
+      adjustment.reasons.push(`skill matches anti-pattern: "${ap.decision}"`);
+    }
+  }
+
+  return adjustment;
+}
+
+/**
+ * Infer workflow type from workflow metadata
+ */
+function inferWorkflowType(workflow) {
+  const key = (workflow.key || '').toLowerCase();
+  const name = (workflow.name || '').toLowerCase();
+  const combined = `${key} ${name}`;
+
+  if (combined.includes('database') || combined.includes('db') || combined.includes('migration')) {
+    return 'database';
+  }
+  if (combined.includes('api') || combined.includes('endpoint') || combined.includes('route')) {
+    return 'api';
+  }
+  if (combined.includes('ui') || combined.includes('component') || combined.includes('style')) {
+    return 'ui';
+  }
+  if (combined.includes('test') || combined.includes('spec')) {
+    return 'testing';
+  }
+  if (combined.includes('security') || combined.includes('auth') || combined.includes('permission')) {
+    return 'security';
+  }
+  if (combined.includes('deploy') || combined.includes('release') || combined.includes('ci')) {
+    return 'deployment';
+  }
+  if (combined.includes('architecture') || combined.includes('design') || combined.includes('refactor')) {
+    return 'architecture';
+  }
+  return 'general';
+}
+
+/**
+ * Infer skill type from skill ID
+ */
+function inferSkillType(skillId) {
+  const id = (skillId || '').toLowerCase();
+
+  if (id.includes('database') || id.includes('db') || id.includes('prisma') || id.includes('sql')) {
+    return 'database';
+  }
+  if (id.includes('api') || id.includes('rest') || id.includes('graphql')) {
+    return 'api';
+  }
+  if (id.includes('component') || id.includes('style') || id.includes('css') || id.includes('ui')) {
+    return 'ui';
+  }
+  if (id.includes('test') || id.includes('spec') || id.includes('jest') || id.includes('vitest')) {
+    return 'testing';
+  }
+  if (id.includes('security') || id.includes('auth') || id.includes('encrypt')) {
+    return 'security';
+  }
+  if (id.includes('deploy') || id.includes('docker') || id.includes('ci')) {
+    return 'deployment';
+  }
+  return 'general';
+}
+
 function workflowMatchesContext(workflow, tokens) {
   if (tokens.length === 0) return false;
   const haystack = [
@@ -91,6 +427,19 @@ function mergeWeights(overrides = {}) {
       ...(base.skill || {}),
       ...((overrides.skill) || {})
     },
+    learning: {
+      ...(base.learning || {}),
+      ...((overrides.learning) || {})
+    },
+    impact: {
+      // Default impact scoring configuration
+      minScore: 3.0,              // Minimum impact score for boosting
+      minSuccessRate: 0.6,        // Minimum success rate for boosting
+      impactBoostMultiplier: 10,  // Multiplier for workflow impact boost
+      skillImpactBoostMultiplier: 7, // Multiplier for skill impact boost
+      ...(base.impact || {}),
+      ...((overrides.impact) || {})
+    },
     eventWindowLimit: Number(overrides.eventWindowLimit || base.eventWindowLimit || 1000)
   };
 }
@@ -126,6 +475,15 @@ function createRecommendationsEngine({ intelligence, telemetry, skills, entitlem
       const workflowStats = buildWorkflowStats(events);
       const skillStats = buildSkillUsage(events);
 
+      // Get learning insights
+      let learningInsights = null;
+      try {
+        learningInsights = patternLearner.analyze();
+      } catch {
+        // Learning not available yet
+        learningInsights = patternLearner.getDefaults();
+      }
+
       const available = intelligence.listWorkflows();
       const accessible = entitlements.filterAccessibleWorkflows(available, accessOptions).allowed;
       const workflows = accessible
@@ -162,6 +520,20 @@ function createRecommendationsEngine({ intelligence, telemetry, skills, entitlem
             reasons.push(`premium unlocks ${stats.premiumUnlocks}`);
           }
 
+          // Apply comprehensive learning insights
+          const learningBoost = calculateLearningBoost(workflow, learningInsights, analysis, resolvedWeights);
+          score += learningBoost.score;
+          reasons.push(...learningBoost.reasons);
+
+          // Apply impact-based boost from decision tracking
+          const impactBoost = calculateImpactBoost(workflow, resolvedWeights);
+          score += impactBoost.score;
+          reasons.push(...impactBoost.reasons);
+
+          // Combine learning and impact adjustments
+          const totalLearningAdjustment = learningBoost.score + impactBoost.score;
+          const allFactors = [...learningBoost.reasons, ...impactBoost.reasons];
+
           return {
             key: workflow.key,
             name: workflow.name,
@@ -175,7 +547,15 @@ function createRecommendationsEngine({ intelligence, telemetry, skills, entitlem
               checkpoints: stats.checkpoints,
               premiumUnlocks: stats.premiumUnlocks,
               completionRate
-            }
+            },
+            learningImpact: totalLearningAdjustment !== 0 ? {
+              adjustment: totalLearningAdjustment,
+              factors: allFactors,
+              breakdown: {
+                learningBoost: learningBoost.score,
+                impactBoost: impactBoost.score
+              }
+            } : null
           };
         })
         .sort((a, b) => b.score - a.score)
@@ -192,24 +572,97 @@ function createRecommendationsEngine({ intelligence, telemetry, skills, entitlem
           const metadata = skills.getSkillMetadata(skillId) || {};
           const usage = skillStats.usage.get(skillId) || 0;
           const premiumUnlocks = skillStats.premiumUnlocks.get(skillId) || 0;
+
+          let score = Number(resolvedWeights.skill.base || 25)
+            + (usage * Number(resolvedWeights.skill.usage || 4))
+            + (premiumUnlocks * Number(resolvedWeights.skill.premiumUnlock || 3));
+
+          const reasons = [
+            'suggested by context analysis',
+            ...(usage > 0 ? [`used ${usage} time(s) in prior sessions`] : []),
+            ...(premiumUnlocks > 0 ? [`premium unlocks ${premiumUnlocks}`] : [])
+          ];
+
+          // Apply learning-based adjustments for skills
+          const skillLearningBoost = calculateSkillLearningBoost(skillId, metadata, learningInsights, resolvedWeights);
+          score += skillLearningBoost.score;
+          reasons.push(...skillLearningBoost.reasons);
+
+          // Apply impact-based boost for skills
+          const skillImpactBoost = calculateSkillImpactBoost(skillId, metadata, resolvedWeights);
+          score += skillImpactBoost.score;
+          reasons.push(...skillImpactBoost.reasons);
+
+          // Combine learning and impact adjustments
+          const totalSkillAdjustment = skillLearningBoost.score + skillImpactBoost.score;
+          const allSkillFactors = [...skillLearningBoost.reasons, ...skillImpactBoost.reasons];
+
           return {
             id: skillId,
             name: metadata.name || skillId,
             description: metadata.description || '',
             source: metadata.source || 'built-in',
-            score: Number(resolvedWeights.skill.base || 25)
-              + (usage * Number(resolvedWeights.skill.usage || 4))
-              + (premiumUnlocks * Number(resolvedWeights.skill.premiumUnlock || 3)),
-            reasons: [
-              'suggested by context analysis',
-              ...(usage > 0 ? [`used ${usage} time(s) in prior sessions`] : []),
-              ...(premiumUnlocks > 0 ? [`premium unlocks ${premiumUnlocks}`] : [])
-            ]
+            score,
+            reasons,
+            learningImpact: totalSkillAdjustment !== 0 ? {
+              adjustment: totalSkillAdjustment,
+              factors: allSkillFactors,
+              breakdown: {
+                learningBoost: skillLearningBoost.score,
+                impactBoost: skillImpactBoost.score
+              }
+            } : null
           };
         })
         .sort((a, b) => b.score - a.score)
         .slice(0, maxItems);
 
+      // Extract relevant learning data with enhanced context
+      const currentPhase = analysis.phase;
+
+      // Get impact statistics and patterns
+      let impactStats = null;
+      let impactBoostedPatterns = [];
+      try {
+        impactStats = decisionTracker.getImpactStats();
+        impactBoostedPatterns = decisionTracker.getImpactBoostedPatterns({
+          minScore: resolvedWeights.impact?.minScore || 3.0,
+          minSuccessRate: resolvedWeights.impact?.minSuccessRate || 0.6
+        }).slice(0, 5);
+      } catch {
+        // Impact tracking not available yet
+      }
+
+      const learningData = {
+        // Anti-patterns to avoid (filtered to non-defaults if real data exists)
+        antiPatterns: (learningInsights?.anti_patterns || [])
+          .filter(ap => !learningInsights?.using_defaults || ap.is_default)
+          .slice(0, 5),
+        // Top insights sorted by confidence
+        insights: (learningInsights?.insights || [])
+          .sort((a, b) => (b.confidence || 0) - (a.confidence || 0))
+          .slice(0, 5),
+        // Phase-specific recommendation for current context
+        phaseRecommendation: learningInsights?.recommendations?.by_phase?.[currentPhase] || null,
+        // General recommendations
+        generalRecommendations: learningInsights?.recommendations?.general?.slice(0, 3) || [],
+        // Relevant correlations that might inform workflow sequencing
+        correlations: (learningInsights?.correlations || [])
+          .filter(c => c.occurrences >= 2)
+          .slice(0, 3),
+        // Summary metrics
+        summary: learningInsights?.analysis_summary || null,
+        // Status flags
+        usingDefaults: learningInsights?.using_defaults || false,
+        lastAnalysis: learningInsights?.last_analysis || null,
+        // Impact-based insights (from decision tracking)
+        impact: {
+          stats: impactStats,
+          boostedPatterns: impactBoostedPatterns,
+          recentTrend: impactStats?.recentTrend || null
+        }
+      };
+
       return {
         context: {
           phase: analysis.phase,
@@ -218,6 +671,7 @@ function createRecommendationsEngine({ intelligence, telemetry, skills, entitlem
         },
         workflows,
         skills: skillsRanked,
+        learning: learningData,
         telemetryWindow: {
           eventsAnalyzed: events.length
         },