claude-flow 3.32.35 → 3.32.36

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.36",
   "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",