claude-flow 3.62.0 → 3.63.1

package/v3/@claude-flow/cli/dist/src/mcp-tools/managed-learning-tool.js

@@ -0,0 +1,46 @@
+/** Learning MCP boundary, kept separate from provider transport and native workers. */
+import { getProjectCwd } from './types.js';
+export const managedLearningTool = {
+    inputSchema: { type: 'object', properties: {
+            action: { type: 'string', enum: ['status', 'record', 'recommend', 'evaluate', 'index', 'recall', 'cycle'] },
+            evidence: { type: 'object', description: 'Closed version1 observation and optional host signature; caller trust labels rejected' },
+            scope: { type: 'object', description: 'Exact taskType, policyHash and evaluatorHash cohort' },
+            manifest: { type: 'object', description: 'Frozen unique heldout taskHashes and at least three trials' },
+            cycle: { type: 'object', description: 'Closed scope/evidence batch, optional index, maxP95Ms and evaluation; no commands, keys or promotion flags' },
+            baselineId: { type: 'string' }, candidateId: { type: 'string' }, id: { type: 'string' }, maxP95Ms: { type: 'number' },
+        }, required: ['action'] },
+    handler: async (input) => {
+        if (input.action !== 'status' && process.env.RUFLO_MANAGED_LEARNING !== '1')
+            return { success: false, error: 'Managed learning writes require host RUFLO_MANAGED_LEARNING=1' };
+        const root = getProjectCwd(), key = process.env.RUFLO_MANAGED_VERIFIER_PUBLIC_KEY;
+        const authorize = () => process.env.RUFLO_MANAGED_LEARNING === '1' && process.env.RUFLO_MANAGED_VERIFIER_PUBLIC_KEY === key && getProjectCwd() === root;
+        try {
+            const learning = await import('../services/managed-learning-store.js');
+            if (input.action !== 'status' && !authorize())
+                throw new Error('Host learning policy changed');
+            if (input.action === 'cycle') {
+                if (Object.keys(input).some(k => !['action', 'cycle'].includes(k)))
+                    throw new Error('Invalid cycle envelope');
+                const { cycleLearning } = await import('../services/managed-learning-loop.js');
+                return { success: true, ...await cycleLearning(root, input.cycle, key, authorize) };
+            }
+            if (input.action === 'status')
+                return { success: true, ...learning.learningStatus(root, key) };
+            if (input.action === 'record')
+                return { success: true, ...learning.recordLearning(root, input.evidence, key) };
+            if (input.action === 'recommend')
+                return { success: true, ...learning.recommendLearning(root, input.scope, key, input.maxP95Ms) };
+            if (input.action === 'evaluate')
+                return { success: true, ...learning.evaluateLearning(root, { scope: input.scope, manifest: input.manifest, baselineId: String(input.baselineId ?? ''), candidateId: String(input.candidateId ?? '') }, key) };
+            if (input.action === 'recall')
+                return { success: true, ...await learning.recallLearning(root, input.scope, key, authorize) };
+            if (input.action === 'index')
+                return { success: true, ...await learning.indexLearning(root, String(input.id ?? ''), key, authorize) };
+            return { success: false, error: 'Unknown managed learning action' };
+        }
+        catch {
+            return { success: false, error: 'Managed learning failed: validate metadata, verifier and store; state may persist, inspect status before retrying; no default changed' };
+        }
+    },
+};
+//# sourceMappingURL=managed-learning-tool.js.map

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

@@ -1466,13 +1466,16 @@ export const memoryTools = [
                 }
                 catch { /* namespace may not exist */ }
             }
-            // Sort by score, deduplicate by key, take top N
+            // Sort by score, deduplicate by (namespace, key), take top N. An entry is
+            // identified by both (see #2271), so the same key in another namespace is
+            // a different entry and must not be dropped as a duplicate.
             allResults.sort((a, b) => b.score - a.score);
             const seen = new Set();
             const deduplicated = allResults.filter(r => {
-                if (seen.has(r.key))
+                const id = JSON.stringify([r.namespace, r.key]);
+                if (seen.has(id))
                     return false;
-                seen.add(r.key);
+                seen.add(id);
                 return true;
             }).slice(0, limit);
             return {

package/v3/@claude-flow/cli/dist/src/missions/schemas.d.ts

@@ -77,6 +77,10 @@ export declare const missionRecordSchema: z.ZodObject<{
     updatedAt: string;
     schemaVersion: 1;
     state: "completed" | "cancelled" | "failed" | "blocked" | "running" | "paused" | "queued" | "draft" | "planned" | "awaitingAuthorization" | "pauseRequested" | "verifying" | "cancelRequested";
+    acceptance: {
+        revision: number;
+        criteriaDigest: string;
+    };
     plan: {
         revision: number;
         digest: string;
@@ -92,10 +96,6 @@ export declare const missionRecordSchema: z.ZodObject<{
     budgetRef: string;
     executionMode: "durable-executor" | "session-bound";
     evidenceRefs: string[];
-    acceptance: {
-        revision: number;
-        criteriaDigest: string;
-    };
     lastEventSequence: number;
     authorizationRef?: string | undefined;
 }, {
@@ -103,6 +103,10 @@ export declare const missionRecordSchema: z.ZodObject<{
     updatedAt: string;
     schemaVersion: 1;
     state: "completed" | "cancelled" | "failed" | "blocked" | "running" | "paused" | "queued" | "draft" | "planned" | "awaitingAuthorization" | "pauseRequested" | "verifying" | "cancelRequested";
+    acceptance: {
+        revision: number;
+        criteriaDigest: string;
+    };
     plan: {
         revision: number;
         digest: string;
@@ -118,10 +122,6 @@ export declare const missionRecordSchema: z.ZodObject<{
     budgetRef: string;
     executionMode: "durable-executor" | "session-bound";
     evidenceRefs: string[];
-    acceptance: {
-        revision: number;
-        criteriaDigest: string;
-    };
     lastEventSequence: number;
     authorizationRef?: string | undefined;
 }>;
@@ -397,11 +397,11 @@ export declare const createInputSchema: z.ZodObject<{
     requestId: z.ZodString;
     objective: z.ZodString;
 }, "strict", z.ZodTypeAny, {
-    objective: string;
     requestId: string;
-}, {
     objective: string;
+}, {
     requestId: string;
+    objective: string;
 }>;
 export declare const planInputSchema: z.ZodObject<{
     requestId: z.ZodString;
@@ -580,6 +580,7 @@ export declare const planInputSchema: z.ZodObject<{
         } | undefined;
     }>;
 }, "strict", z.ZodTypeAny, {
+    requestId: string;
     plan: {
         tasks: {
             id: string;
@@ -616,10 +617,10 @@ export declare const planInputSchema: z.ZodObject<{
             baseline?: string | undefined;
         }[];
     };
-    requestId: string;
     missionId: string;
     expectedRevision: number;
 }, {
+    requestId: string;
     plan: {
         tasks: {
             id: string;
@@ -656,7 +657,6 @@ export declare const planInputSchema: z.ZodObject<{
             capabilities?: string[] | undefined;
         } | undefined;
     };
-    requestId: string;
     missionId: string;
     expectedRevision: number;
 }>;

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

@@ -0,0 +1,78 @@
+/**
+ * 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

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

@@ -0,0 +1,310 @@
+/**
+ * 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
+ */
+// ===== Lazy loading =====
+let diskannInstance = null;
+let diskannAvailable = null;
+let activeBackend = 'cosine-js';
+/**
+ * Check if @ruvector/diskann is available
+ */
+export async function isDiskAnnAvailable() {
+    if (diskannAvailable !== null)
+        return diskannAvailable;
+    try {
+        const { createRequire } = await import('module');
+        const require2 = createRequire(import.meta.url);
+        const mod = require2('@ruvector/diskann');
+        diskannAvailable = typeof mod.DiskAnn === 'function';
+        return diskannAvailable;
+    }
+    catch {
+        diskannAvailable = false;
+        return false;
+    }
+}
+/**
+ * Create or get a DiskANN index instance
+ */
+export async function getDiskAnnIndex(config) {
+    if (diskannInstance)
+        return { index: diskannInstance, backend: activeBackend };
+    // Try DiskANN first
+    if (await isDiskAnnAvailable()) {
+        try {
+            const { createRequire } = await import('module');
+            const require2 = createRequire(import.meta.url);
+            const { DiskAnn } = require2('@ruvector/diskann');
+            const index = new DiskAnn({
+                dim: config.dim,
+                maxDegree: config.maxDegree ?? 64,
+                buildBeam: config.buildBeam ?? 128,
+                searchBeam: config.searchBeam ?? 64,
+                alpha: config.alpha ?? 1.2,
+                pqSubspaces: config.pqSubspaces ?? 0,
+                storagePath: config.storagePath,
+            });
+            diskannInstance = index;
+            activeBackend = 'diskann';
+            return { index, backend: 'diskann' };
+        }
+        catch {
+            // Fall through
+        }
+    }
+    // Try HNSW (@ruvector/router VectorDb) as fallback
+    try {
+        const { createRequire } = await import('module');
+        const require2 = createRequire(import.meta.url);
+        const router = require2('@ruvector/router');
+        if (router.VectorDb && router.DistanceMetric) {
+            const index = new router.VectorDb({
+                dimensions: config.dim,
+                distanceMetric: router.DistanceMetric.Cosine,
+                hnswM: 16,
+                hnswEfConstruction: 200,
+                hnswEfSearch: 100,
+            });
+            diskannInstance = index;
+            activeBackend = 'hnsw';
+            return { index, backend: 'hnsw' };
+        }
+    }
+    catch {
+        // Fall through
+    }
+    // Pure JS fallback
+    const jsIndex = createJsFallbackIndex(config.dim);
+    diskannInstance = jsIndex;
+    activeBackend = 'cosine-js';
+    return { index: jsIndex, backend: 'cosine-js' };
+}
+/**
+ * Get the active backend name
+ */
+export function getActiveBackend() {
+    return activeBackend;
+}
+/**
+ * Reset the index (for testing)
+ */
+export function resetIndex() {
+    diskannInstance = null;
+    diskannAvailable = null;
+    activeBackend = 'cosine-js';
+}
+// ===== Unified search interface =====
+/**
+ * Insert a vector into the active backend
+ */
+export async function insertVector(id, vector, config = { dim: 384 }) {
+    const { index, backend } = await getDiskAnnIndex(config);
+    if (backend === 'diskann') {
+        index.insert(id, vector);
+    }
+    else if (backend === 'hnsw') {
+        index.insert(id, vector);
+    }
+    else {
+        index.insert(id, vector);
+    }
+    return { backend };
+}
+/**
+ * Build the index (required for DiskANN before search)
+ */
+export async function buildIndex(config = { dim: 384 }) {
+    const { index, backend } = await getDiskAnnIndex(config);
+    if (backend === 'diskann' && typeof index.build === 'function') {
+        index.build();
+    }
+    // HNSW and JS fallback don't need explicit build
+}
+/**
+ * Search for k nearest neighbors
+ */
+export async function searchVectors(query, k, config = { dim: 384 }) {
+    const { index, backend } = await getDiskAnnIndex(config);
+    if (backend === 'diskann') {
+        const results = index.search(query, k);
+        return results.map((r) => ({
+            id: r.id,
+            distance: r.distance,
+            score: 1 / (1 + r.distance), // Convert L2 distance to similarity
+        }));
+    }
+    if (backend === 'hnsw') {
+        const results = index.search(query, k);
+        return results.map((r) => ({
+            id: r.id,
+            distance: r.score, // VectorDb returns distance as 'score'
+            score: 1 / (1 + r.score),
+        }));
+    }
+    // JS fallback
+    return index.search(query, k);
+}
+// ===== Pure JS fallback =====
+function createJsFallbackIndex(dim) {
+    const vectors = new Map();
+    return {
+        insert(id, vector) {
+            vectors.set(id, new Float32Array(vector));
+        },
+        search(query, k) {
+            const results = [];
+            for (const [id, vec] of vectors) {
+                let dot = 0, normQ = 0, normV = 0;
+                for (let i = 0; i < dim; i++) {
+                    dot += query[i] * vec[i];
+                    normQ += query[i] * query[i];
+                    normV += vec[i] * vec[i];
+                }
+                const cosine = dot / (Math.sqrt(normQ) * Math.sqrt(normV) || 1);
+                const distance = 1 - cosine;
+                results.push({ id, distance, score: cosine });
+            }
+            return results.sort((a, b) => a.distance - b.distance).slice(0, k);
+        },
+        count() { return vectors.size; },
+        delete(id) { return vectors.delete(id); },
+        build() { },
+    };
+}
+/**
+ * Run a benchmark comparing available backends
+ */
+export async function benchmark(opts = {}) {
+    const dim = opts.dim ?? 384;
+    const n = opts.vectorCount ?? 1000;
+    const k = opts.k ?? 10;
+    const queryCount = opts.queries ?? 100;
+    const results = [];
+    // Generate random vectors
+    const vectors = [];
+    for (let i = 0; i < n; i++) {
+        const v = new Float32Array(dim);
+        for (let j = 0; j < dim; j++)
+            v[j] = Math.random() * 2 - 1;
+        // Normalize
+        let norm = 0;
+        for (let j = 0; j < dim; j++)
+            norm += v[j] * v[j];
+        norm = Math.sqrt(norm);
+        for (let j = 0; j < dim; j++)
+            v[j] /= norm;
+        vectors.push([`vec-${i}`, v]);
+    }
+    // Generate query vectors
+    const queries = [];
+    for (let i = 0; i < queryCount; i++) {
+        const q = new Float32Array(dim);
+        for (let j = 0; j < dim; j++)
+            q[j] = Math.random() * 2 - 1;
+        let norm = 0;
+        for (let j = 0; j < dim; j++)
+            norm += q[j] * q[j];
+        norm = Math.sqrt(norm);
+        for (let j = 0; j < dim; j++)
+            q[j] /= norm;
+        queries.push(q);
+    }
+    // Brute force ground truth
+    function bruteForceSearch(query) {
+        const scores = [];
+        for (const [id, vec] of vectors) {
+            let dist = 0;
+            for (let j = 0; j < dim; j++) {
+                const d = query[j] - vec[j];
+                dist += d * d;
+            }
+            scores.push({ id, dist });
+        }
+        scores.sort((a, b) => a.dist - b.dist);
+        return scores.slice(0, k).map(s => s.id);
+    }
+    const groundTruth = queries.map(q => bruteForceSearch(q));
+    // Test each available backend
+    for (const backendName of ['diskann', 'hnsw', 'cosine-js']) {
+        resetIndex();
+        try {
+            let index;
+            const memBefore = process.memoryUsage().heapUsed;
+            if (backendName === 'diskann') {
+                if (!(await isDiskAnnAvailable()))
+                    continue;
+                const { createRequire } = await import('module');
+                const require2 = createRequire(import.meta.url);
+                const { DiskAnn } = require2('@ruvector/diskann');
+                index = new DiskAnn({ dim, maxDegree: 64, buildBeam: 128, searchBeam: 64 });
+            }
+            else if (backendName === 'hnsw') {
+                try {
+                    const { createRequire } = await import('module');
+                    const require2 = createRequire(import.meta.url);
+                    const router = require2('@ruvector/router');
+                    if (!router.VectorDb)
+                        continue;
+                    index = new router.VectorDb({ dimensions: dim, distanceMetric: router.DistanceMetric.Cosine });
+                }
+                catch {
+                    continue;
+                }
+            }
+            else {
+                index = createJsFallbackIndex(dim);
+            }
+            // Insert
+            const insertStart = performance.now();
+            for (const [id, vec] of vectors) {
+                index.insert(id, vec);
+            }
+            const insertTime = performance.now() - insertStart;
+            // Build
+            const buildStart = performance.now();
+            if (typeof index.build === 'function')
+                index.build();
+            const buildTime = performance.now() - buildStart;
+            // Search
+            const searchStart = performance.now();
+            const searchResults = [];
+            for (const q of queries) {
+                const r = index.search(q, k);
+                searchResults.push(r.map((x) => x.id));
+            }
+            const searchTime = performance.now() - searchStart;
+            // Recall vs ground truth
+            let totalRecall = 0;
+            for (let i = 0; i < queryCount; i++) {
+                const truth = new Set(groundTruth[i]);
+                const found = searchResults[i].filter(id => truth.has(id)).length;
+                totalRecall += found / k;
+            }
+            const recall = totalRecall / queryCount;
+            const memAfter = process.memoryUsage().heapUsed;
+            results.push({
+                backend: backendName,
+                dim,
+                vectorCount: n,
+                insertTimeMs: Math.round(insertTime * 100) / 100,
+                buildTimeMs: Math.round(buildTime * 100) / 100,
+                searchTimeMs: Math.round(searchTime * 100) / 100,
+                searchesPerSecond: Math.round(queryCount / (searchTime / 1000)),
+                recall: Math.round(recall * 1000) / 1000,
+                memoryMB: Math.round((memAfter - memBefore) / 1024 / 1024 * 100) / 100,
+            });
+        }
+        catch {
+            // Backend failed, skip
+        }
+    }
+    resetIndex();
+    return results;
+}
+//# sourceMappingURL=diskann-backend.js.map

package/v3/@claude-flow/cli/dist/src/services/flywheel-transaction.js

@@ -91,6 +91,11 @@ function atomicWriteJson(file, value) {
         fs.closeSync(fd);
     }
     fs.renameSync(tmp, file);
+    // Windows cannot flush a directory handle (FlushFileBuffers fails with EPERM on NTFS), and there the journaled rename needs no such step.
+    // Skipping it there is the same rule policy-runtime's syncDirectory follows (#3398). On POSIX a failure here means the rename may not be
+    // durable, so it still reaches the caller (#4492).
+    if (process.platform === 'win32')
+        return;
     const dirFd = fs.openSync(path.dirname(file), fs.constants.O_RDONLY);
     try {
         fs.fsyncSync(dirFd);

package/v3/@claude-flow/cli/dist/src/services/managed-learning-loop.d.ts

@@ -0,0 +1,79 @@
+export type ManagedCycleInput = {
+    scope: unknown;
+    evidence: unknown[];
+    index?: boolean;
+    maxP95Ms?: number;
+    evaluation?: {
+        manifest: unknown;
+        baselineId: string;
+        candidateId: string;
+    };
+};
+/** authorize is host-owned and rechecked across asynchronous boundaries. */
+export declare function cycleLearning(root: string, value: unknown, publicKey: string | undefined, authorize: () => boolean): Promise<{
+    cycleId: string;
+    phases: string[];
+    recorded: string[];
+    duplicates: string[];
+    indexed: string[];
+    deferred: string[];
+    recommendation: {
+        advisory: boolean;
+        selected: {
+            strategy: {
+                id: string;
+                model: string;
+                workers: number;
+                template: string;
+            };
+            samples: number;
+            successes: number;
+            successRate: number;
+            successesPerDollar: number;
+            p95Ms: number;
+            evidenceIds: string[];
+        };
+        candidates: {
+            strategy: {
+                id: string;
+                model: string;
+                workers: number;
+                template: string;
+            };
+            samples: number;
+            successes: number;
+            successRate: number;
+            successesPerDollar: number;
+            p95Ms: number;
+            evidenceIds: string[];
+        }[];
+        abstained: boolean;
+        reason: string;
+        defaultsChanged: boolean;
+    };
+    evaluation: {
+        advisory: boolean;
+        eligible: boolean;
+        baselineP95Ms: number;
+        candidateP95Ms: number;
+        delta: number;
+        baselineEfficiency: number;
+        candidateEfficiency: number;
+        pairedResults: number;
+        corpusHash: string;
+        noRegression: boolean;
+        metaharness: import("./harness-benchmark.js").AcceptResult;
+        defaultsChanged: boolean;
+        evidenceIds: string[];
+    } | null;
+    memory: {
+        available: boolean;
+        recalled: number;
+        backend: string;
+    } | null;
+    elapsedMs: number;
+    advisory: boolean;
+    defaultsChanged: boolean;
+    promotionRequested: boolean;
+}>;
+//# sourceMappingURL=managed-learning-loop.d.ts.map