claude-flow 3.32.35 → 3.32.37

package/v3/@claude-flow/cli/dist/src/mcp-tools/embeddings-tools.js

@@ -50,13 +50,16 @@ async function getRealEmbeddingFunction() {
     }
     return realEmbeddingFn;
 }
-// Generate real ONNX embedding (falls back to deterministic hash if ONNX unavailable)
 async function generateRealEmbedding(text, dimension) {
     const realFn = await getRealEmbeddingFunction();
     if (realFn) {
         try {
             const result = await realFn(text);
-            return result.embedding;
+            return {
+                embedding: result.embedding,
+                backend: result.backend ?? 'onnx',
+                model: result.model,
+            };
         }
         catch {
             // Fall through to fallback
@@ -75,7 +78,11 @@ async function generateRealEmbedding(text, dimension) {
     }
     // L2 normalize
     const norm = Math.sqrt(embedding.reduce((sum, x) => sum + x * x, 0));
-    return embedding.map(x => x / norm);
+    return {
+        embedding: embedding.map(x => x / norm),
+        backend: 'mock',
+        model: 'hash-fallback',
+    };
 }
 // Convert Euclidean embedding to Poincaré ball
 function toPoincare(euclidean, curvature) {
@@ -238,7 +245,8 @@ export const embeddingsTools = [
             }
             const useHyperbolic = input.hyperbolic === true && config.hyperbolic.enabled;
             // Generate real ONNX embedding
-            const embedding = await generateRealEmbedding(text, config.dimension);
+            const generated = await generateRealEmbedding(text, config.dimension);
+            const embedding = generated.embedding;
             let result;
             let geometry;
             if (useHyperbolic) {
@@ -254,6 +262,8 @@ export const embeddingsTools = [
                 embedding: result,
                 metadata: {
                     model: config.model,
+                    embeddingBackend: generated.backend,
+                    semanticGrounded: generated.backend === 'onnx',
                     dimension: config.dimension,
                     geometry,
                     curvature: useHyperbolic ? config.hyperbolic.curvature : null,
@@ -309,10 +319,13 @@ export const embeddingsTools = [
                     return { success: false, error: v.error };
             }
             // Generate real ONNX embeddings for both texts
-            const [emb1, emb2] = await Promise.all([
+            const [generated1, generated2] = await Promise.all([
                 generateRealEmbedding(text1, config.dimension),
                 generateRealEmbedding(text2, config.dimension)
             ]);
+            const emb1 = generated1.embedding;
+            const emb2 = generated2.embedding;
+            const embeddingBackend = generated1.backend === 'onnx' && generated2.backend === 'onnx' ? 'onnx' : 'mock';
             let similarity;
             let distance;
             switch (metric) {
@@ -341,14 +354,21 @@ export const embeddingsTools = [
                 similarity,
                 distance,
                 metric,
+                embeddingBackend,
+                semanticGrounded: embeddingBackend === 'onnx',
                 texts: {
                     text1: { length: text1.length, preview: text1.slice(0, 50) },
                     text2: { length: text2.length, preview: text2.slice(0, 50) },
                 },
-                interpretation: similarity > 0.8 ? 'very similar' :
-                    similarity > 0.6 ? 'similar' :
-                        similarity > 0.4 ? 'somewhat similar' :
-                            similarity > 0.2 ? 'different' : 'very different',
+                interpretation: embeddingBackend === 'onnx'
+                    ? similarity > 0.8 ? 'very similar'
+                        : similarity > 0.6 ? 'similar'
+                            : similarity > 0.4 ? 'somewhat similar'
+                                : similarity > 0.2 ? 'different' : 'very different'
+                    : null,
+                warning: embeddingBackend === 'mock'
+                    ? 'Hash fallback scores are deterministic but not semantically meaningful.'
+                    : undefined,
             };
         },
     },
@@ -426,6 +446,8 @@ export const embeddingsTools = [
                     })),
                     metadata: {
                         model: config.model,
+                        embeddingBackend: queryEmbedding.backend,
+                        semanticGrounded: queryEmbedding.backend === 'onnx',
                         topK,
                         threshold,
                         namespace: namespace || 'all',
@@ -433,6 +455,9 @@ export const embeddingsTools = [
                         indexType: config.hyperbolic.enabled ? 'HNSW (hyperbolic)' : 'HNSW (euclidean)',
                         resultCount: searchResult.results.length
                     },
+                    warning: queryEmbedding.backend === 'mock'
+                        ? 'Results use a hash fallback and are not semantically ranked.'
+                        : undefined,
                 };
             }
             catch {
@@ -444,12 +469,17 @@ export const embeddingsTools = [
                     results: [],
                     metadata: {
                         model: config.model,
+                        embeddingBackend: queryEmbedding.backend,
+                        semanticGrounded: queryEmbedding.backend === 'onnx',
                         topK,
                         threshold,
                         namespace: namespace || 'all',
                         searchTime: `${searchTime}ms`,
                         indexType: config.hyperbolic.enabled ? 'HNSW (hyperbolic)' : 'HNSW (euclidean)',
                     },
+                    warning: queryEmbedding.backend === 'mock'
+                        ? 'Hash fallback is active; semantic search is unavailable.'
+                        : undefined,
                     message: 'No embeddings indexed yet. Use memory store to add documents.',
                 };
             }
@@ -795,6 +825,8 @@ export const embeddingsTools = [
             }
             catch { /* not installed */ }
             const ruvectorEnabled = config.neural.ruvector?.enabled ?? false;
+            const backendProbe = await generateRealEmbedding('ruflo embedding backend probe', config.dimension);
+            const semanticGrounded = backendProbe.backend === 'onnx';
             return {
                 success: true,
                 initialized: true,
@@ -822,11 +854,20 @@ export const embeddingsTools = [
                     models: config.modelPath,
                 },
                 initializedAt: config.initialized,
+                embeddingBackend: backendProbe.backend,
+                semanticGrounded,
+                warning: semanticGrounded
+                    ? undefined
+                    : 'Hash fallback is active. Similarity scores are deterministic but not semantically meaningful.',
                 capabilities: {
                     onnxModels: ['Xenova/all-MiniLM-L6-v2', 'Xenova/all-mpnet-base-v2'],
                     geometries: ['euclidean', 'poincare'],
                     normalizations: ['L2', 'L1', 'minmax', 'zscore'],
-                    features: ['semantic search', 'hyperbolic projection', 'neural substrate'],
+                    features: [
+                        ...(semanticGrounded ? ['semantic search'] : []),
+                        'hyperbolic projection',
+                        'neural substrate',
+                    ],
                 },
             };
         },

package/v3/@claude-flow/cli/dist/src/mcp-tools/hooks-tools.js

@@ -439,6 +439,20 @@ function getIntelligenceStatsFromMemory() {
         const category = e.metadata?.category || 'general';
         categories[category] = (categories[category] || 0) + 1;
     });
+    const successfulPatterns = patternEntries.filter(e => e.metadata?.success === true).length;
+    const failedPatterns = patternEntries.filter(e => e.metadata?.success === false).length;
+    const describedPatterns = patternEntries.filter(e => {
+        if (typeof e.metadata?.task === 'string' && e.metadata.task.trim())
+            return true;
+        try {
+            const value = typeof e.value === 'string' ? JSON.parse(e.value) : e.value;
+            return typeof value?.task === 'string' &&
+                Boolean(String(value.task).trim());
+        }
+        catch {
+            return false;
+        }
+    }).length;
     // Count routing decisions
     const routingEntries = entries.filter(e => e.key.includes('routing') ||
         e.metadata?.type === 'routing-decision');
@@ -472,6 +486,10 @@ function getIntelligenceStatsFromMemory() {
         },
         patterns: {
             learned: patternEntries.length,
+            successful: successfulPatterns,
+            failed: failedPatterns,
+            unknown: Math.max(0, patternEntries.length - successfulPatterns - failedPatterns),
+            described: describedPatterns,
             categories,
         },
         memory: {
@@ -1074,21 +1092,28 @@ export const hooksMetrics = {
                 agentCounts[o.agent] = (agentCounts[o.agent] || 0) + 1;
         }
         const topAgent = Object.entries(agentCounts).sort((a, b) => b[1] - a[1])[0]?.[0] ?? null;
-        const successful = stats.trajectories.successful;
-        const total = stats.trajectories.total;
-        const failed = Math.max(0, total - successful);
         return {
             _real: true,
             _dataSource: 'intelligence-stats + routing-outcomes',
             period,
             patterns: {
                 total: stats.patterns.learned,
-                successful,
-                failed,
+                successful: stats.patterns.successful,
+                failed: stats.patterns.failed,
+                unknown: stats.patterns.unknown,
+                described: stats.patterns.described,
+                descriptionCoverage: stats.patterns.learned > 0
+                    ? stats.patterns.described / stats.patterns.learned
+                    : null,
                 avgConfidence: stats.routing.avgConfidence || null,
             },
             agents: {
-                routingAccuracy: stats.routing.avgConfidence || null,
+                // Confidence is a model self-score, not observed routing accuracy
+                // (#2809). Keep the old key as an explicit null for compatibility
+                // while exposing the truthful additive field.
+                routingAccuracy: null,
+                averageConfidence: stats.routing.avgConfidence || null,
+                outcomeSuccessRate: successRate,
                 totalRoutes: stats.routing.decisions,
                 topAgent,
             },
@@ -1097,7 +1122,7 @@ export const hooksMetrics = {
                 successRate,
                 avgRiskScore: null,
             },
-            _note: total === 0 && totalCommands === 0
+            _note: stats.patterns.learned === 0 && totalCommands === 0
                 ? 'No metrics data collected yet. Run hooks_post-task / hooks_intelligence_trajectory-end / hooks_route to populate.'
                 : undefined,
             lastUpdated: new Date().toISOString(),
@@ -1311,6 +1336,7 @@ export const hooksPostTask = {
             const bridge = await import('../memory/memory-bridge.js');
             feedbackResult = await bridge.bridgeRecordFeedback({
                 taskId,
+                task: params.task || undefined,
                 success,
                 quality,
                 agent,
@@ -3136,7 +3162,7 @@ export const hooksIntelligenceStats = {
         catch {
             memoryStats = {
                 trajectories: { total: 0, successful: 0 },
-                patterns: { learned: 0, categories: {} },
+                patterns: { learned: 0, successful: 0, failed: 0, unknown: 0, described: 0, categories: {} },
                 memory: { indexSize: 0, totalAccessCount: 0, memorySizeBytes: 0 },
                 routing: { decisions: 0, avgConfidence: 0 },
             };

package/v3/@claude-flow/cli/dist/src/mcp-tools/metaharness-tools.js

@@ -199,7 +199,7 @@ export const metaharnessTools = [
     },
     {
         name: 'metaharness_genome',
-        description: 'ADR-150 — 7-section categorical readiness report from `metaharness genome <path>` (repo_type / agent_topology / risk_score / mcp_surface / test_confidence / publish_readiness). Use when you need the categorical view (vs numeric score). Pair with metaharness_score for the full readiness picture — score-alone is wrong because two harnesses with the same harnessFit can have very different agent_topology and mcp_surface. ' + MCP_SUCCESS_SEMANTIC,
+        description: 'ADR-150 — 7-section categorical readiness report from `metaharness genome <path>` (repo_type / agent_topology / risk_score / mcp_surface / test_confidence / publish_readiness). Upstream needs-work/blocked exit statuses are valid verdicts and return successfully as data.verdict + data.verdictExitCode; only a missing or malformed report is an error. Use when you need the categorical view (vs numeric score). Pair with metaharness_score for the full readiness picture — score-alone is wrong because two harnesses with the same harnessFit can have very different agent_topology and mcp_surface. ' + MCP_SUCCESS_SEMANTIC,
         category: 'metaharness',
         inputSchema: {
             type: 'object',

package/v3/@claude-flow/cli/dist/src/memory/memory-bridge.d.ts

@@ -275,6 +275,16 @@ export declare function getControllerRegistry(dbPath?: string): Promise<any | nu
  * operator learns the cause instead of only the symptom.
  */
 export declare function getBridgeFailureReason(): string | null;
+/**
+ * Install a pre-initialized registry for deterministic bridge tests.
+ *
+ * The CLI test runner intentionally externalizes the optional
+ * `@claude-flow/memory` package so an unbuilt workspace can still exercise
+ * fallback paths. That also makes module-level mocking of ControllerRegistry
+ * environment-dependent. This narrow seam keeps native SQL regression tests
+ * independent of package build order without changing production startup.
+ */
+export declare function __setMemoryBridgeRegistryForTests(registry: any | null): void;
 /**
  * Shutdown the bridge and release resources.
  *
@@ -322,6 +332,8 @@ export declare function bridgeSearchPatterns(options: {
  */
 export declare function bridgeRecordFeedback(options: {
     taskId: string;
+    /** Human-readable task text used as the semantic learning signal. */
+    task?: string;
     success: boolean;
     quality: number;
     agent?: string;

package/v3/@claude-flow/cli/dist/src/memory/memory-bridge.js

@@ -23,6 +23,10 @@ import { createRequire } from 'node:module';
 let registryPromise = null;
 let registryInstance = null;
 let bridgeAvailable = null;
+// #2652/#2120: rows created before the status column existed receive NULL
+// during migration. They are live rows, not tombstones. Every user-facing
+// read/delete path must agree with list() about their visibility.
+const ACTIVE_MEMORY_ROW_SQL = `(status = 'active' OR status IS NULL)`;
 /**
  * Why the bridge is unavailable, when it is.
  *
@@ -994,7 +998,7 @@ export async function bridgeSearchEntries(options) {
             const stmt = ctx.db.prepare(`
         SELECT id, key, namespace, content, embedding, provenance_type
         FROM memory_entries
-        WHERE status = 'active' ${whereExtra}
+        WHERE ${ACTIVE_MEMORY_ROW_SQL} ${whereExtra}
         LIMIT 1000
       `);
             rows = filterParams.length > 0 ? stmt.all(...filterParams) : stmt.all();
@@ -1114,7 +1118,7 @@ export async function bridgeListEntries(options) {
         // the `status = 'active'` filter matched zero. Treat NULL as
         // "legacy-active" — the safe default for any entry that predates the
         // status column.
-        const statusFilter = `(status = 'active' OR status IS NULL)`;
+        const statusFilter = ACTIVE_MEMORY_ROW_SQL;
         // Count
         let total = 0;
         try {
@@ -1206,7 +1210,7 @@ export async function bridgeGetEntry(options) {
             const stmt = ctx.db.prepare(`
         SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at, tags
         FROM memory_entries
-        WHERE status = 'active' AND key = ? AND namespace = ?
+        WHERE ${ACTIVE_MEMORY_ROW_SQL} AND key = ? AND namespace = ?
         LIMIT 1
       `);
             row = stmt.get(key, namespace);
@@ -1274,7 +1278,7 @@ export async function bridgeDeleteEntry(options) {
             const result = ctx.db.prepare(`
         UPDATE memory_entries
         SET status = 'deleted', updated_at = ?
-        WHERE key = ? AND namespace = ? AND status = 'active'
+        WHERE key = ? AND namespace = ? AND ${ACTIVE_MEMORY_ROW_SQL}
       `).run(Date.now(), key, namespace);
             changes = result?.changes ?? 0;
         }
@@ -1306,7 +1310,7 @@ export async function bridgeDeleteEntry(options) {
         }
         let remaining = 0;
         try {
-            const row = ctx.db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active'`).get();
+            const row = ctx.db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE ${ACTIVE_MEMORY_ROW_SQL}`).get();
             remaining = row?.cnt ?? 0;
         }
         catch {
@@ -1659,6 +1663,21 @@ export async function getControllerRegistry(dbPath) {
 export function getBridgeFailureReason() {
     return bridgeFailureReason;
 }
+/**
+ * Install a pre-initialized registry for deterministic bridge tests.
+ *
+ * The CLI test runner intentionally externalizes the optional
+ * `@claude-flow/memory` package so an unbuilt workspace can still exercise
+ * fallback paths. That also makes module-level mocking of ControllerRegistry
+ * environment-dependent. This narrow seam keeps native SQL regression tests
+ * independent of package build order without changing production startup.
+ */
+export function __setMemoryBridgeRegistryForTests(registry) {
+    registryInstance = registry;
+    registryPromise = registry ? Promise.resolve(registry) : null;
+    bridgeAvailable = registry ? true : null;
+    bridgeFailureReason = null;
+}
 /**
  * Shutdown the bridge and release resources.
  *
@@ -1840,11 +1859,15 @@ export async function bridgeRecordFeedback(options) {
         try {
             const intelligence = await import('./intelligence.js');
             const verdict = options.success ? 'success' : 'failure';
+            const taskContext = options.task?.trim();
             const recorded = await intelligence.recordTrajectory([{
                     type: 'action',
-                    content: `Task ${options.taskId} completed by ${options.agent || 'unknown'} — success=${options.success}, quality=${options.quality.toFixed(3)}`,
+                    // Put the task description first so the embedding represents the
+                    // work, not just the bookkeeping suffix (#2812).
+                    content: `${taskContext ? `${taskContext} — ` : ''}Task ${options.taskId} completed by ${options.agent || 'unknown'} — success=${options.success}, quality=${options.quality.toFixed(3)}`,
                     metadata: {
                         taskId: options.taskId,
+                        task: taskContext,
                         agent: options.agent,
                         quality: options.quality,
                         duration: options.duration,

package/v3/@claude-flow/cli/dist/src/memory/memory-initializer.js

@@ -153,6 +153,10 @@ export function resolveDbPath(cliFlag) {
     }
     return path.join(getMemoryRoot(), 'memory.db');
 }
+// #2652/#2120: legacy rows with NULL status predate soft-delete semantics and
+// are active. Keep fallback retrieve/delete aligned with list and the native
+// bridge instead of making a row visible to one command but not another.
+const ACTIVE_MEMORY_ROW_SQL = `(status = 'active' OR status IS NULL)`;
 // ADR-053: Lazy import of AgentDB v3 bridge
 let _bridge;
 async function getBridge() {
@@ -1608,8 +1612,7 @@ export async function repairVectorIndexes(dbPath, opts = {}) {
  */
 export async function initializeMemoryDatabase(options) {
     const { backend = 'hybrid', dbPath: customPath, force = false, verbose = false, migrate = true } = options;
-    const swarmDir = getMemoryRoot();
-    const dbPath = customPath || path.join(swarmDir, 'memory.db');
+    const dbPath = resolveDbPath(customPath);
     const dbDir = path.dirname(dbPath);
     try {
         // Create directory if needed
@@ -2857,7 +2860,7 @@ export async function listEntries(options) {
         // that predate the status column may have NULL after migration.
         // See memory-bridge.ts:bridgeListEntries for full context.
         // Get total count
-        const whereClauses = [`(status = 'active' OR status IS NULL)`];
+        const whereClauses = [ACTIVE_MEMORY_ROW_SQL];
         const whereParams = [];
         if (namespace) {
             whereClauses.push('namespace = ?');
@@ -2967,7 +2970,7 @@ export async function getEntry(options) {
         const getStmt = db.prepare(`
       SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at, tags
       FROM memory_entries
-      WHERE status = 'active'
+      WHERE ${ACTIVE_MEMORY_ROW_SQL}
         AND key = ?
         AND namespace = ?
       LIMIT 1
@@ -3081,7 +3084,7 @@ export async function deleteEntry(options) {
         // Check if entry exists first
         const checkStmt = db.prepare(`
       SELECT id FROM memory_entries
-      WHERE status = 'active'
+      WHERE ${ACTIVE_MEMORY_ROW_SQL}
         AND key = ?
         AND namespace = ?
       LIMIT 1
@@ -3095,7 +3098,7 @@ export async function deleteEntry(options) {
         const checkResult = checkRows.length > 0 ? [{ values: checkRows }] : [];
         if (!checkResult[0]?.values?.[0]) {
             // Get remaining count before closing
-            const countResult = db.exec(`SELECT COUNT(*) FROM memory_entries WHERE status = 'active'`);
+            const countResult = db.exec(`SELECT COUNT(*) FROM memory_entries WHERE ${ACTIVE_MEMORY_ROW_SQL}`);
             const remainingEntries = countResult[0]?.values?.[0]?.[0] || 0;
             db.close();
             return {
@@ -3116,10 +3119,10 @@ export async function deleteEntry(options) {
           updated_at = strftime('%s', 'now') * 1000
       WHERE key = ?
         AND namespace = ?
-        AND status = 'active'
+        AND ${ACTIVE_MEMORY_ROW_SQL}
     `, [key, namespace]);
         // Get remaining count
-        const countResult = db.exec(`SELECT COUNT(*) FROM memory_entries WHERE status = 'active'`);
+        const countResult = db.exec(`SELECT COUNT(*) FROM memory_entries WHERE ${ACTIVE_MEMORY_ROW_SQL}`);
         const remainingEntries = countResult[0]?.values?.[0]?.[0] || 0;
         // Save updated database
         const data = db.export();

package/v3/@claude-flow/cli/dist/src/services/memory-distillation.d.ts

@@ -20,6 +20,7 @@ export interface DistillOptions {
 export interface DistillReport {
     processed: number;
     episodes: number;
+    episodeEmbeddings: number;
     patterns: number;
     patternEmbeddings: number;
     causalEdges: number;

package/v3/@claude-flow/cli/dist/src/services/memory-distillation.js

@@ -3,7 +3,8 @@
  *
  * Turns raw `memory_entries` (what ruflo has been RECORDING for thousands of
  * commits) into the structured intelligence substrate it has never populated:
- * `episodes` → `reasoning_patterns` (+ `pattern_embeddings`) → `causal_edges`.
+ * `episodes` (+ `episode_embeddings`) → `reasoning_patterns`
+ * (+ `pattern_embeddings`) → `causal_edges`.
  * This is the DISTILL/CONSOLIDATE half of the RETRIEVE→JUDGE→DISTILL→CONSOLIDATE
  * pipeline; RETRIEVE (embeddings) was already populated, the rest was empty
  * because the daemon's `consolidate` worker was a stub (see ADR-174 root cause).
@@ -28,7 +29,8 @@ import * as path from 'path';
 import { distillTrajectoryContent, serialiseDistilled } from '../memory/structured-distill.js';
 function emptyReport(dryRun, extra = {}) {
     return {
-        processed: 0, episodes: 0, patterns: 0, patternEmbeddings: 0, causalEdges: 0,
+        processed: 0, episodes: 0, episodeEmbeddings: 0,
+        patterns: 0, patternEmbeddings: 0, causalEdges: 0,
         promoted: 0, byProvenance: {}, namespaces: [], dryRun, spendUsd: 0, ...extra,
     };
 }
@@ -74,6 +76,20 @@ function judgeFeedback(content) {
     catch { /* not JSON — treat as neutral */ }
     return { success: true, reward: 0.5 };
 }
+/** Preserve an execution-observed lesson for Reflexion without presenting
+ * proxy/structural summaries as genuine self-critique. */
+function feedbackCritique(content) {
+    try {
+        const value = JSON.parse(content);
+        for (const key of ['critique', 'error', 'message', 'summary', 'stderr']) {
+            if (typeof value[key] === 'string' && value[key].trim()) {
+                return value[key].trim().slice(0, 2000);
+            }
+        }
+    }
+    catch { /* retain the original execution feedback below */ }
+    return `Observed execution feedback: ${content}`.slice(0, 2000);
+}
 /**
  * Distill accumulated memory into the structured intelligence tables.
  * Incremental, $0, transactional, provenance-tagged.
@@ -115,6 +131,17 @@ export async function runDistillation(options) {
             db.close();
             return { ...report, corrupt: true, skipped: 'memory DB reports corruption — run recoverMemoryDatabase first' };
         }
+        // #2677 — older AgentDB stores may have episodes but no embedding table.
+        // Create the stable AgentDB v1 table only after the corruption gate, and
+        // never create it during a dry-run.
+        if (!dryRun && !tableExists('episode_embeddings')) {
+            db.exec(`CREATE TABLE episode_embeddings (
+        episode_id INTEGER PRIMARY KEY,
+        embedding BLOB NOT NULL,
+        embedding_model TEXT DEFAULT 'all-MiniLM-L6-v2',
+        FOREIGN KEY(episode_id) REFERENCES episodes(id) ON DELETE CASCADE
+      )`);
+        }
         // M0: incremental cursor table (per namespace, by monotonic rowid).
         db.exec(`CREATE TABLE IF NOT EXISTS distill_state (
       namespace TEXT PRIMARY KEY,
@@ -128,10 +155,54 @@ export async function runDistillation(options) {
         const getCursor = db.prepare('SELECT last_rowid FROM distill_state WHERE namespace = ?');
         const setCursor = db.prepare('INSERT INTO distill_state (namespace, last_rowid, last_run_at) VALUES (?, ?, ?) ' +
             'ON CONFLICT(namespace) DO UPDATE SET last_rowid = excluded.last_rowid, last_run_at = excluded.last_run_at');
-        const insEpisode = db.prepare('INSERT INTO episodes (session_id, task, input, output, reward, success, tags, metadata) VALUES (?,?,?,?,?,?,?,?)');
+        const insEpisode = db.prepare('INSERT INTO episodes (session_id, task, input, output, critique, reward, success, tags, metadata) VALUES (?,?,?,?,?,?,?,?,?)');
+        const insEpisodeEmbedding = dryRun ? null : db.prepare('INSERT OR REPLACE INTO episode_embeddings (episode_id, embedding) VALUES (?, ?)');
         const insPattern = db.prepare('INSERT INTO reasoning_patterns (task_type, approach, success_rate, uses, avg_reward, tags, metadata) VALUES (?,?,?,?,?,?,?)');
         const insPatEmb = db.prepare('INSERT OR REPLACE INTO pattern_embeddings (pattern_id, embedding) VALUES (?, ?)');
         const insEdge = db.prepare('INSERT INTO causal_edges (from_memory_id, from_memory_type, to_memory_id, to_memory_type, similarity, confidence, mechanism, metadata) VALUES (?,?,?,?,?,?,?,?)');
+        // Repair episodes produced by older distillation releases. Their metadata
+        // records sourceIds; if that provenance is absent, exact input matching is
+        // a conservative fallback. Never invent a vector or call a model.
+        if (!dryRun) {
+            const missingEpisodes = db.prepare(`
+        SELECT e.id, e.input, e.metadata
+        FROM episodes e
+        LEFT JOIN episode_embeddings ee ON ee.episode_id = e.id
+        WHERE ee.episode_id IS NULL AND e.session_id LIKE 'distill:%'
+      `).all();
+            const embeddingById = db.prepare('SELECT embedding FROM memory_entries WHERE id = ? AND embedding IS NOT NULL');
+            const embeddingByContent = db.prepare('SELECT embedding FROM memory_entries WHERE content = ? AND embedding IS NOT NULL LIMIT 1');
+            const missingCritiques = db.prepare(`
+        SELECT id, input FROM episodes
+        WHERE session_id LIKE 'distill:feedback%'
+          AND length(trim(coalesce(critique,''))) = 0
+      `).all();
+            const updateCritique = db.prepare('UPDATE episodes SET critique = ? WHERE id = ?');
+            const backfill = db.transaction(() => {
+                for (const episode of missingEpisodes) {
+                    let sourceId;
+                    try {
+                        const metadata = JSON.parse(episode.metadata ?? '{}');
+                        if (Array.isArray(metadata.sourceIds) && typeof metadata.sourceIds[0] === 'string') {
+                            sourceId = metadata.sourceIds[0];
+                        }
+                    }
+                    catch { /* use exact-content fallback */ }
+                    let raw = sourceId ? embeddingById.get(sourceId)?.embedding : undefined;
+                    if (!raw)
+                        raw = embeddingByContent.get(episode.input ?? '')?.embedding;
+                    const vector = parseEmbedding(raw);
+                    if (!vector)
+                        continue;
+                    insEpisodeEmbedding.run(episode.id, Buffer.from(Float32Array.from(vector).buffer));
+                    report.episodeEmbeddings++;
+                }
+                for (const episode of missingCritiques) {
+                    updateCritique.run(feedbackCritique(episode.input ?? ''), episode.id);
+                }
+            });
+            backfill();
+        }
         let remaining = typeof maxEntries === 'number' ? maxEntries : Infinity;
         for (const ns of nsList) {
             if (remaining <= 0)
@@ -200,8 +271,14 @@ export async function runDistillation(options) {
                                 sourceIds: cl.members.map(m => m.id).slice(0, 25),
                                 paths: distilled.paths.slice(0, 10), namespace: ns, distilledBy: 'structural',
                             };
-                            const epInfo = insEpisode.run(`distill:${ns}`, approach, cl.rep.content.slice(0, 2000), '', avgReward, promoted && cl.successCount > 0 ? 1 : 0, JSON.stringify(distilled.labels), JSON.stringify(provMeta));
+                            const epInfo = insEpisode.run(`distill:${ns}`, approach, cl.rep.content.slice(0, 2000), '', cl.provenance === 'oracle:test-exec' ? feedbackCritique(cl.rep.content) : null, avgReward, promoted && cl.successCount > 0 ? 1 : 0, JSON.stringify(distilled.labels), JSON.stringify(provMeta));
                             report.episodes++;
+                            const epId = Number(epInfo.lastInsertRowid);
+                            // ReflexionMemory.retrieveRelevant() INNER JOINs this table.
+                            // Reuse the source embedding so every distilled episode is
+                            // immediately retrievable without an embedding-model call.
+                            insEpisodeEmbedding.run(epId, Buffer.from(Float32Array.from(embVec).buffer));
+                            report.episodeEmbeddings++;
                             const patInfo = insPattern.run(taskType, approach, successRate, uses, avgReward, JSON.stringify(distilled.labels), JSON.stringify(provMeta));
                             const patternId = Number(patInfo.lastInsertRowid);
                             report.patterns++;
@@ -217,7 +294,6 @@ export async function runDistillation(options) {
                             // rowids). Explicitly typed co-occurrence / proxy-tier / non-
                             // promoted: may rank retrieval, must NOT justify autonomous action
                             // (ADR-174 edge contract).
-                            const epId = Number(epInfo.lastInsertRowid);
                             if (prevEpId !== null) {
                                 insEdge.run(prevEpId, 'episode', epId, 'episode', 0, 0.3, 'co-occurrence', JSON.stringify({
                                     edge_type: 'cooccurrence',

package/v3/@claude-flow/cli/dist/src/services/worker-daemon.js

@@ -1545,6 +1545,7 @@ export class WorkerDaemon extends EventEmitter {
             // instead of becoming their own distinct pattern.
             duplicatesRemoved: Math.max(0, report.processed - report.patterns),
             episodes: report.episodes,
+            episodeEmbeddings: report.episodeEmbeddings,
             patternEmbeddings: report.patternEmbeddings,
             causalEdges: report.causalEdges,
             promoted: report.promoted,

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.32.35",
+  "version": "3.32.37",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",