claude-flow 3.41.4 → 3.42.1

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

@@ -250,10 +250,20 @@ class LocalSonaCoordinator {
                     const oldConfidence = pattern.confidence;
                     // Check EWC penalty before applying update
                     if (ewcConsolidator) {
-                        const oldWeights = [oldConfidence];
                         const proposedConfidence = Math.min(1.0, oldConfidence + this.config.loraLearningRate * reward);
-                        const newWeights = [proposedConfidence];
-                        const penalty = ewcConsolidator.getPenalty(oldWeights, newWeights);
+                        // Use computeConfidencePenalty (averages the full Fisher diagonal),
+                        // not getPenalty([oldConf],[newConf]) — that call shape collapses
+                        // to fisherDiag[0] only (Math.min(1,1,384) === 1), an arbitrary
+                        // single dimension instead of the full accumulated Fisher signal.
+                        // computeConfidencePenalty exists precisely for this
+                        // scalar-confidence case (see its docstring) but was unwired.
+                        // Note: neither call shape differentiates between patterns — both
+                        // take only a confidence delta, not a per-pattern embedding, so
+                        // two patterns with the same delta under the same consolidator
+                        // state get the same penalty either way. This fix corrects which
+                        // shared Fisher signal informs that penalty; it does not add
+                        // per-pattern discrimination (see ewc-distill-confidence-gate.test.ts).
+                        const penalty = ewcConsolidator.computeConfidencePenalty(oldConfidence, proposedConfidence);
                         totalEwcPenalty += penalty;
                         // If penalty is too high, reduce the update magnitude
                         if (penalty > this.config.ewcLambda) {
@@ -279,13 +289,14 @@ class LocalSonaCoordinator {
                 }
             }
         }
-        // Update EWC Fisher matrix with confidence changes
+        // Update EWC Fisher matrix with confidence changes. updateFisherFromConfidences
+        // takes the full per-pattern embedding + confidence-delta batch directly (it
+        // computes the same squared confidence-delta-scaled-embedding gradient proxy
+        // internally) — replaces the previous per-change recordGradient loop, which
+        // updated the full 384-dim globalFisher but fed a signal that getPenalty's
+        // 1-element call shape then read back only at index 0.
         if (ewcConsolidator && confidenceChanges.length > 0) {
-            for (const change of confidenceChanges) {
-                // Use confidence delta as gradient proxy
-                const gradient = change.embedding.map(e => e * Math.abs(change.newConf - change.oldConf));
-                ewcConsolidator.recordGradient(change.id, gradient, true);
-            }
+            ewcConsolidator.updateFisherFromConfidences(confidenceChanges);
         }
         // Persist updated patterns
         bank.flushToDisk();
@@ -467,7 +478,17 @@ class LocalReasoningBank {
         this.saveToDisk();
     }
     /**
-     * Find similar patterns by embedding
+     * Find similar patterns by embedding.
+     *
+     * `confidence` on each result is the pattern's own learned reliability
+     * (unchanged from storage) — NOT how well it matches this query. The
+     * per-query cosine score is returned separately as `similarity`. Callers
+     * that want "how good a semantic match is this" must read `.similarity`;
+     * callers that want "how reliable has this pattern proven to be" read
+     * `.confidence`. Prior to this fix both were conflated (confidence was
+     * overwritten with the cosine score), which silently broke any consumer
+     * that needed to tell them apart (found during the 2026-09-12 dream-cycle
+     * intelligence-surface review).
      */
     findSimilar(queryEmbedding, options) {
         const { k = 5, threshold = 0.5, type } = options;
@@ -489,7 +510,7 @@ class LocalReasoningBank {
             // Update usage
             s.pattern.usageCount++;
             s.pattern.lastUsedAt = Date.now();
-            return { ...s.pattern, confidence: s.score };
+            return { ...s.pattern, similarity: s.score };
         });
     }
     /**
@@ -985,7 +1006,7 @@ export async function findSimilarPatterns(query, options) {
             usageCount: r.usageCount,
             createdAt: r.createdAt,
             lastUsedAt: r.lastUsedAt,
-            similarity: r.similarity ?? r.confidence ?? 0.5
+            similarity: r.similarity
         }));
     }
     catch {

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

@@ -1866,7 +1866,12 @@ export async function bridgeStorePattern(options) {
             }
             catch { /* HNSW is best-effort */ }
         }
-        return { success: true, patternId: result.id, controller: 'bridge-fallback' };
+        // #3324: bridgeStoreEntry's `result.id` is its OWN internally generated
+        // row id (generateId('entry')), a different value from the `key` the row
+        // was actually stored under. getEntry/memory_retrieve look up by `key`,
+        // so returning result.id here handed the caller a handle that can never
+        // be read back — return `patternId` (the real key) instead.
+        return { success: true, patternId, controller: 'bridge-fallback' };
     }
     catch {
         return null;
@@ -1915,10 +1920,13 @@ export async function bridgeSearchPatterns(options) {
                 const qEmb = await generateEmbedding(options.query);
                 if (qEmb && Array.isArray(qEmb.embedding) && qEmb.embedding.length > 0) {
                     const hits = reasoningBank.findSimilar(qEmb.embedding, { k, threshold });
+                    // findSimilar() no longer overwrites confidence with the query-match
+                    // score — prefer similarity (the actual match strength) for search ranking,
+                    // falling back to confidence/score only for older/foreign result shapes.
                     mapped = (Array.isArray(hits) ? hits : []).map((r) => ({
                         id: r.id ?? '',
                         content: r.content ?? '',
-                        score: r.confidence ?? r.score ?? 0,
+                        score: r.similarity ?? r.confidence ?? r.score ?? 0,
                     }));
                 }
             }

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

@@ -1855,12 +1855,15 @@ export async function checkMemoryInitialization(dbPath) {
     if (!fs.existsSync(path_)) {
         return { initialized: false };
     }
+    // #3249: declared outside the try so the handle can be released on the
+    // failure path as well as the success path.
+    let db;
     try {
         // Try to load with sql.js
         const initSqlJs = (await import('sql.js')).default;
         const SQL = await initSqlJs();
         const fileBuffer = fs.readFileSync(path_);
-        const db = new SQL.Database(fileBuffer);
+        db = new SQL.Database(fileBuffer);
         // Check for metadata table
         const tables = db.exec("SELECT name FROM sqlite_master WHERE type='table'");
         const tableNames = tables[0]?.values?.map(v => v[0]) || [];
@@ -1876,7 +1879,6 @@ export async function checkMemoryInitialization(dbPath) {
         catch {
             // Metadata table might not exist
         }
-        db.close();
         return {
             initialized: true,
             version,
@@ -1893,6 +1895,21 @@ export async function checkMemoryInitialization(dbPath) {
         // Could not read database
         return { initialized: false };
     }
+    finally {
+        // #3249: release the handle on every path. An RFE1-encrypted image is not
+        // parseable as SQLite, so the schema query above throws and the catch
+        // returns — which used to skip the inline db.close() entirely, leaving the
+        // sql.js Database and its MEMFS copy open for the life of the process.
+        // Every memory MCP tool call runs this check, so a long session accumulates
+        // one unclosed handle per call. Measured retention is a few hundred KiB per
+        // leaked handle (it does not scale with image size).
+        try {
+            db?.close();
+        }
+        catch {
+            // Already closed, or never successfully constructed.
+        }
+    }
 }
 /**
  * Apply temporal decay to patterns

package/v3/@claude-flow/cli/dist/src/ruvector/graph-backend.js

@@ -13,51 +13,137 @@
  */
 import { join } from 'path';
 // Lazy-loaded graph-node module
-let graphNodeModule = null;
-let graphDb = null;
-let graphBackendLoaded = false;
+let graphNodeModulePromise = null;
+let graphDbPromise = null;
 let graphBackendAvailable = false;
 const DEFAULT_EMBEDDING_DIM = 8; // Minimal embedding for graph structure
+const DEFAULT_DISTANCE_METRIC = 'Cosine';
 /**
- * Load @ruvector/graph-node via createRequire (CJS package)
+ * Load @ruvector/graph-node via createRequire (CJS package).
+ *
+ * The promise is the memo rather than a "loaded" flag. The flag was set
+ * BEFORE its own `await`, so a caller arriving inside that window would take
+ * the early return and read `graphNodeModule` while it was still `null`.
+ * I could not make that window observable -- `import('module')` resolves a
+ * builtin before another caller gets a turn -- so this is hardening on the
+ * same shape as the open memo below, not a defect with a reproduction behind
+ * it.
  */
 async function loadGraphNode() {
-    if (graphBackendLoaded)
-        return graphNodeModule;
-    graphBackendLoaded = true;
-    try {
-        const { createRequire } = await import('module');
-        const requireCjs = createRequire(import.meta.url);
-        graphNodeModule = requireCjs('@ruvector/graph-node');
-        graphBackendAvailable = true;
-        return graphNodeModule;
+    if (!graphNodeModulePromise) {
+        graphNodeModulePromise = (async () => {
+            try {
+                const { createRequire } = await import('module');
+                const requireCjs = createRequire(import.meta.url);
+                const mod = requireCjs('@ruvector/graph-node');
+                graphBackendAvailable = true;
+                return mod;
+            }
+            catch {
+                graphBackendAvailable = false;
+                return null;
+            }
+        })();
     }
-    catch {
-        graphBackendAvailable = false;
-        return null;
+    return graphNodeModulePromise;
+}
+/**
+ * Report a graph-backend problem.
+ *
+ * No "already warned" flag: the open runs once per process because
+ * `getGraphDb` memoizes the promise, and a second flag would only hide it if
+ * that ever stopped being true.
+ */
+function warnGraphInit(message) {
+    console.warn(`[graph-backend] ${message}`);
+}
+/**
+ * Whether this handle is actually backed by the file we asked for.
+ *
+ * `@ruvector/graph-node` 2.1.0 accepts a bare path STRING without throwing
+ * and hands back a volatile in-memory instance -- `isPersistent() === false`,
+ * `getStoragePath() === null`. Nothing downstream notices: writes succeed,
+ * reads succeed, and the graph is gone at exit. Passing the options object
+ * fixes that, and this check is what makes the fix self-reporting instead of
+ * something a future signature change can quietly undo.
+ *
+ * A build that exposes neither accessor cannot be interrogated, so it is
+ * accepted rather than refused -- this guards against a silent downgrade, not
+ * against an unfamiliar version.
+ */
+function isPersistentAt(db, storagePath) {
+    const canReport = typeof db?.isPersistent === 'function' || typeof db?.getStoragePath === 'function';
+    if (!canReport)
+        return true;
+    if (typeof db.isPersistent === 'function' && db.isPersistent() !== true)
+        return false;
+    if (typeof db.getStoragePath === 'function' && db.getStoragePath() !== storagePath) {
+        return false;
     }
+    return true;
 }
 /**
- * Get or create the singleton graph database instance
+ * Open the graph database, or return null with a stated reason.
+ *
+ * The old fallback replaced an open failure with `new mod.GraphDatabase()` --
+ * an empty in-memory graph that answers every query successfully and persists
+ * nothing. A permission error, a lock held by another process and a healthy
+ * database were indistinguishable from the outside. Callers already handle
+ * `null` by degrading to `backend: 'unavailable'`, which is the honest shape
+ * for "the graph is not there".
  */
-async function getGraphDb() {
-    if (graphDb)
-        return graphDb;
+async function openGraphDb() {
     const mod = await loadGraphNode();
     if (!mod)
         return null;
-    // Use persistent path if available, otherwise in-memory
     const dataDir = join(process.cwd(), '.claude-flow', 'graph');
+    const storagePath = join(dataDir, 'agents.db');
+    let db;
     try {
         const fs = await import('fs');
         fs.mkdirSync(dataDir, { recursive: true });
-        graphDb = new mod.GraphDatabase(join(dataDir, 'agents.db'));
+        // The options object, not the path string: see `isPersistentAt`.
+        db = new mod.GraphDatabase({
+            storagePath,
+            dimensions: DEFAULT_EMBEDDING_DIM,
+            distanceMetric: DEFAULT_DISTANCE_METRIC,
+        });
     }
-    catch {
-        // Fallback to in-memory
-        graphDb = new mod.GraphDatabase();
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        warnGraphInit(`could not open ${storagePath}: ${reason}. Graph backend disabled.`);
+        return null;
+    }
+    if (!isPersistentAt(db, storagePath)) {
+        const reported = typeof db?.getStoragePath === 'function' ? db.getStoragePath() : 'unknown';
+        warnGraphInit(`opened a non-persistent graph (storage path ${String(reported)}, wanted ${storagePath}). ` +
+            'Graph backend disabled rather than writing to a graph that vanishes at exit.');
+        try {
+            db?.close?.();
+        }
+        catch {
+            // A handle we are already discarding.
+        }
+        return null;
+    }
+    return db;
+}
+/**
+ * Get or create the singleton graph database instance.
+ *
+ * The promise is the singleton, not the handle: two callers racing the first
+ * call used to each run the constructor, and the second overwrote the first's
+ * `graphDb` while nodes were already being written through it.
+ */
+async function getGraphDb() {
+    if (!graphDbPromise) {
+        graphDbPromise = openGraphDb().catch((error) => {
+            const reason = error instanceof Error ? error.message : String(error);
+            warnGraphInit(`initialization failed: ${reason}. Graph backend disabled.`);
+            return null;
+        });
     }
-    return graphDb;
+    return graphDbPromise;
 }
 /**
  * Create a minimal embedding for non-vector graph operations.

package/v3/@claude-flow/cli/dist/src/services/policy-runtime.js

@@ -1,4 +1,4 @@
-import { AgenticPolicyEngine, createLegacyCompatibleState, } from '@claude-flow/security';
+import { AgenticPolicyEngine, createLegacyCompatibleState, isMcpCallerAuthEnabled, decodeTokenEnvelope, publicKeyFromHex, verifyInvocationToken, } from '@claude-flow/security';
 import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
@@ -257,6 +257,67 @@ export async function revokePolicyApproval(id, projectRoot = process.cwd()) {
 export async function verifyPolicyLedger(projectRoot = process.cwd()) {
     return withPolicyTransaction(projectRoot, (engine) => engine.verifyLedger());
 }
+/**
+ * Resolve the caller identity for `authorizeMcpTool`.
+ *
+ * ADR-377 Phase 3 (dream-cycle candidate, 2026-08-26) — off by default. By
+ * default (`isMcpCallerAuthEnabled()` false), this reproduces the exact
+ * pre-existing two-line behavior: the plain, unsigned `CLAUDE_FLOW_PRINCIPAL_ID`
+ * env var is trusted outright. That is the byte-identical-when-disabled
+ * requirement for this candidate — nothing about this branch's shape or
+ * output changes when the flag is off.
+ *
+ * When the flag is on, `CLAUDE_FLOW_PRINCIPAL_ID` alone is no longer
+ * sufficient — any process can set an arbitrary env var with zero proof.
+ * Instead this requires (and verifies) an Ed25519-signed `InvocationToken`
+ * that only a private-key holder (the DualModeOrchestrator that spawned this
+ * worker) could have minted, per `mcp-caller-identity.ts`. Missing, corrupt,
+ * forged, or expired tokens fail closed — this function throws rather than
+ * falling back to the unverified env var, matching the existing fail-closed
+ * pattern already used above in this function (`invalid-worker-capability-envelope`,
+ * `authoritative-worker-policy-root-unavailable`).
+ *
+ * Scope trade-off (deliberate — see mcp-caller-identity.ts's file header and
+ * orchestrator.ts's `workerEnvironment` for the fuller rationale): the token
+ * is minted once per worker spawn with a worker-lifetime TTL and a wildcard
+ * `toolName: '*'`, not the single-tool, 30s-TTL shape `InvocationToken` was
+ * originally designed for — so `opts.toolName` is deliberately not passed to
+ * `verifyInvocationToken` here, and the tool-mismatch check is not exercised
+ * for this use case. What this retains: a process that never received the
+ * signed token cannot forge one, so it cannot impersonate `agent:<workerId>`.
+ * What it does NOT retain: a compromised worker process can still use its
+ * own valid token for every MCP call for the rest of its lifetime — the
+ * token does not limit blast radius to a single call.
+ */
+function resolveMcpCallerIdentity() {
+    if (!isMcpCallerAuthEnabled()) {
+        return {
+            id: process.env.CLAUDE_FLOW_PRINCIPAL_ID ?? 'legacy-cli',
+            type: process.env.CLAUDE_FLOW_PRINCIPAL_ID ? 'agent' : 'legacy',
+        };
+    }
+    const encodedToken = process.env.CLAUDE_FLOW_MCP_INVOCATION_TOKEN;
+    const publicKeyHex = process.env.CLAUDE_FLOW_MCP_CALLER_PUBKEY;
+    if (!encodedToken || !publicKeyHex) {
+        throw new Error('mcp-caller-auth-enabled-but-no-token');
+    }
+    const token = decodeTokenEnvelope(encodedToken);
+    if (!token) {
+        throw new Error('mcp-caller-auth-enabled-but-no-token');
+    }
+    let publicKey;
+    try {
+        publicKey = publicKeyFromHex(publicKeyHex);
+    }
+    catch {
+        throw new Error('mcp-caller-auth-enabled-but-no-token');
+    }
+    const result = verifyInvocationToken(token, publicKey, {});
+    if (!result.valid) {
+        throw new Error(`mcp-caller-auth-verification-failed:${result.reason}`);
+    }
+    return { id: token.callerId, type: 'agent' };
+}
 export async function authorizeMcpTool(toolName, input, context = {}, attributes = {}) {
     let projectRoot = typeof context.projectRoot === 'string' ? context.projectRoot : process.cwd();
     let processEnvelope;
@@ -284,10 +345,7 @@ export async function authorizeMcpTool(toolName, input, context = {}, attributes
         }
     }
     return evaluatePolicyRequest({
-        identity: {
-            id: process.env.CLAUDE_FLOW_PRINCIPAL_ID ?? 'legacy-cli',
-            type: process.env.CLAUDE_FLOW_PRINCIPAL_ID ? 'agent' : 'legacy',
-        },
+        identity: resolveMcpCallerIdentity(),
         action: {
             type: attributes.actionType ?? 'mcp.tool.call',
             resource: toolName,

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.41.4",
+  "version": "3.42.1",
   "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",

package/v3/@claude-flow/cli/dist/src/ruvector/diskann-backend.d.ts

@@ -1,78 +0,0 @@
-/**
- * DiskANN Vector Search Backend
- *
- * SSD-friendly approximate nearest neighbor search using Vamana graph.
- * Falls back gracefully to HNSW (@ruvector/router VectorDb) or
- * pure-JS cosine similarity when DiskANN is unavailable.
- *
- * @module v3/cli/ruvector/diskann-backend
- */
-export interface DiskAnnConfig {
-    dim: number;
-    maxDegree?: number;
-    buildBeam?: number;
-    searchBeam?: number;
-    alpha?: number;
-    pqSubspaces?: number;
-    storagePath?: string;
-}
-export interface SearchResult {
-    id: string;
-    distance: number;
-    score: number;
-}
-export type VectorBackend = 'diskann' | 'hnsw' | 'cosine-js';
-/**
- * Check if @ruvector/diskann is available
- */
-export declare function isDiskAnnAvailable(): Promise<boolean>;
-/**
- * Create or get a DiskANN index instance
- */
-export declare function getDiskAnnIndex(config: DiskAnnConfig): Promise<{
-    index: any;
-    backend: VectorBackend;
-}>;
-/**
- * Get the active backend name
- */
-export declare function getActiveBackend(): VectorBackend;
-/**
- * Reset the index (for testing)
- */
-export declare function resetIndex(): void;
-/**
- * Insert a vector into the active backend
- */
-export declare function insertVector(id: string, vector: Float32Array, config?: DiskAnnConfig): Promise<{
-    backend: VectorBackend;
-}>;
-/**
- * Build the index (required for DiskANN before search)
- */
-export declare function buildIndex(config?: DiskAnnConfig): Promise<void>;
-/**
- * Search for k nearest neighbors
- */
-export declare function searchVectors(query: Float32Array, k: number, config?: DiskAnnConfig): Promise<SearchResult[]>;
-export interface BenchmarkResult {
-    backend: VectorBackend;
-    dim: number;
-    vectorCount: number;
-    insertTimeMs: number;
-    buildTimeMs: number;
-    searchTimeMs: number;
-    searchesPerSecond: number;
-    recall: number;
-    memoryMB: number;
-}
-/**
- * Run a benchmark comparing available backends
- */
-export declare function benchmark(opts?: {
-    dim?: number;
-    vectorCount?: number;
-    k?: number;
-    queries?: number;
-}): Promise<BenchmarkResult[]>;
-//# sourceMappingURL=diskann-backend.d.ts.map