fix(memory): address Copilot review feedback on reflection-engine

- Use nullish coalescing (??) instead of || for durationMs, lesson,
  context fields to correctly preserve falsy values like 0
- Add null check for p.tags in injectContext() to prevent TypeError
  when patterns lack tags
- Add _recomputePatterns() method that rebuilds patterns from remaining
  reflections after pruning
- Call _recomputePatterns() in prune() and after maxReflections eviction
  to keep patterns consistent with remaining data
- Copy reflection-engine.js to .aiox-core/core/memory/ for rebranded
  package path compatibility (keeps .aios-core version too)

Author: nikolasdehor

.aios-core/core/memory/reflection-engine.js

@@ -171,9 +171,9 @@ class ReflectionEngine extends EventEmitter {
       strategy: reflection.strategy,
       description: reflection.description || '',
       tags: reflection.tags || [],
-      durationMs: reflection.durationMs || null,
-      lesson: reflection.lesson || null,
-      context: reflection.context || null,
+      durationMs: reflection.durationMs ?? null,
+      lesson: reflection.lesson ?? null,
+      context: reflection.context ?? null,
       createdAt: new Date().toISOString(),
     };
 
@@ -183,6 +183,7 @@ class ReflectionEngine extends EventEmitter {
     if (this.reflections.length > this.config.maxReflections) {
       const removed = this.reflections.shift();
       this.emit(Events.REFLECTIONS_PRUNED, { count: 1, reason: 'max_limit', removed: [removed.id] });
+      this._recomputePatterns();
     }
 
     // Check for new patterns
@@ -289,7 +290,7 @@ class ReflectionEngine extends EventEmitter {
   injectContext(context) {
     const recommendations = this.getRecommendations(context);
     const relevantPatterns = this.patterns.filter(
-      (p) => p.taskType === context.taskType || (context.tags && context.tags.some((t) => p.tags.includes(t))),
+      (p) => p.taskType === context.taskType || (p.tags && context.tags && context.tags.some((t) => p.tags.includes(t))),
     );
 
     return {
@@ -377,6 +378,7 @@ class ReflectionEngine extends EventEmitter {
 
     const pruned = before - this.reflections.length;
     if (pruned > 0) {
+      this._recomputePatterns();
       this.emit(Events.REFLECTIONS_PRUNED, { count: pruned, reason: 'retention_window', removed });
     }
     return pruned;
@@ -471,6 +473,50 @@ class ReflectionEngine extends EventEmitter {
     }
   }
 
+
+  /**
+   * Recompute all patterns from the current set of reflections.
+   * Called after pruning to ensure patterns stay consistent with remaining data.
+   * @private
+   */
+  _recomputePatterns() {
+    // Group reflections by taskType + strategy
+    const groups = new Map();
+    for (const r of this.reflections) {
+      const key = `${r.taskType}::${r.strategy}`;
+      if (!groups.has(key)) {
+        groups.set(key, []);
+      }
+      groups.get(key).push(r);
+    }
+
+    const newPatterns = [];
+    for (const [, group] of groups) {
+      if (group.length < this.config.minReflectionsForPattern) continue;
+
+      const successes = group.filter((r) => r.outcome === Outcome.SUCCESS).length;
+      const successRate = successes / group.length;
+
+      const tagSet = new Set();
+      for (const r of group) {
+        if (r.tags) r.tags.forEach((t) => tagSet.add(t));
+      }
+
+      newPatterns.push({
+        taskType: group[0].taskType,
+        strategy: group[0].strategy,
+        sampleSize: group.length,
+        successRate,
+        tags: Array.from(tagSet),
+        confidence: Math.min(1.0, group.length / 10),
+        verdict: successRate >= 0.7 ? 'recommended' : successRate <= 0.3 ? 'avoid' : 'neutral',
+        updatedAt: new Date().toISOString(),
+      });
+    }
+
+    this.patterns = newPatterns;
+  }
+
   /**
    * Generate a unique ID
    * @private