@claude-flow/cli 3.56.10 → 3.57.1

package/dist/src/mcp-tools/neural-tools.js

@@ -908,9 +908,6 @@ export const neuralTools = [
                 if (!v.valid)
                     return { success: false, error: v.error };
             }
-            // Resolve provider so embeddingProvider in the result matches the old
-            // eager-init reporting.
-            await ensureEmbeddings();
             const store = loadNeuralStore();
             const method = input.method || 'quantize';
             const targetReduction = input.targetSize || 0.5;
@@ -919,38 +916,25 @@ export const neuralTools = [
                 return { success: false, error: 'No patterns to compress. Train patterns first with neural_train.' };
             }
             const beforeCount = patterns.length;
-            const beforeSize = patterns.reduce((s, p) => s + (p.embedding?.length || 0) * 4, 0); // Float32 = 4 bytes
             if (method === 'quantize') {
-                try {
-                    const { quantizeInt8, getQuantizationStats } = await import('../memory/memory-initializer.js');
-                    let totalCompressed = 0;
-                    for (const pattern of patterns) {
-                        if (pattern.embedding && pattern.embedding.length > 0) {
-                            const stats = getQuantizationStats(pattern.embedding);
-                            const quantized = quantizeInt8(pattern.embedding);
-                            // Store quantized metadata (keep original embedding for search)
-                            pattern._quantized = {
-                                scale: quantized.scale,
-                                zeroPoint: quantized.zeroPoint,
-                                compressionRatio: stats.compressionRatio,
-                            };
-                            totalCompressed++;
-                        }
-                    }
-                    saveNeuralStore(store);
-                    return {
-                        success: true, _real: true, method,
-                        embeddingProvider: embeddingServiceName,
-                        patternsCompressed: totalCompressed,
-                        compressionRatio: '3.92x (Int8)',
-                        beforeBytes: beforeSize,
-                        afterBytes: Math.round(beforeSize / 3.92),
-                    };
-                }
-                catch {
-                    return { success: false, error: 'Quantization requires memory-initializer. Run `memory init` first.' };
-                }
+                // Neural-store readers consume `embedding` as a full-precision number[]
+                // (search, prediction, deduplication, and optimization). The former
+                // implementation discarded the Int8 vector, persisted only metadata,
+                // and reported a calculated 3.92x reduction. Refuse until the store has
+                // a persisted representation with a reader-side decode contract.
+                const storedBytes = readFileSync(getNeuralPath()).byteLength;
+                return {
+                    success: false,
+                    error: 'Quantized embeddings are not persisted: neural-store readers require full-precision embedding arrays.',
+                    method,
+                    patternsCompressed: 0,
+                    beforeBytes: storedBytes,
+                    afterBytes: storedBytes,
+                    compressionRatio: '1.00x (unchanged JSON storage)',
+                };
             }
+            // Resolve provider only for operations that actually use embeddings.
+            await ensureEmbeddings();
             if (method === 'prune') {
                 // Prune patterns with low usage count below threshold (targetReduction as min usage)
                 const threshold = targetReduction;
@@ -1136,24 +1120,10 @@ export const neuralTools = [
                 if (duplicatesRemoved > 0)
                     actions.push(`Removed ${duplicatesRemoved} near-duplicate patterns`);
             }
-            // memory / balanced: quantize large embeddings
+            // memory / balanced: report the unsupported persisted representation
+            // instead of attaching metadata for a discarded Int8 vector.
             if (target === 'memory' || target === 'balanced') {
-                try {
-                    const { quantizeInt8, getQuantizationStats } = await import('../memory/memory-initializer.js');
-                    for (const p of Object.values(store.patterns)) {
-                        if (p.embedding && p.embedding.length > 0 && !p._quantized) {
-                            const stats = getQuantizationStats(p.embedding);
-                            const q = quantizeInt8(p.embedding);
-                            p._quantized = { scale: q.scale, zeroPoint: q.zeroPoint, compressionRatio: stats.compressionRatio };
-                            patternsQuantized++;
-                        }
-                    }
-                    if (patternsQuantized > 0)
-                        actions.push(`Quantized ${patternsQuantized} pattern embeddings (Int8, ~3.92x)`);
-                }
-                catch {
-                    actions.push('Quantization skipped (memory-initializer not available)');
-                }
+                actions.push('Quantization skipped: neural-store readers require persisted full-precision embedding arrays.');
             }
             // accuracy / balanced: prune low-usage, zero-embedding patterns
             if (target === 'accuracy' || target === 'balanced') {

package/dist/src/mcp-tools/policy-tools.js

@@ -24,9 +24,11 @@ export const policyTools = [
         category: 'security',
         inputSchema: {
             type: 'object',
-            properties: {},
+            properties: {
+                full: { type: 'boolean', description: 'Also replay the archived receipts to verify the complete historical ledger, not just the retained hot tail (#3164)' },
+            },
         },
-        handler: async (_input, context) => {
+        handler: async (input, context) => {
             const root = typeof context?.projectRoot === 'string' ? context.projectRoot : process.cwd();
             const state = loadPolicyState(root);
             return {
@@ -39,7 +41,7 @@ export const policyTools = [
                     approvals: state.approvals.length,
                     receipts: state.receipts.length,
                 },
-                ledger: await verifyPolicyLedger(root),
+                ledger: await verifyPolicyLedger(root, { full: input.full === true }),
             };
         },
     },

package/dist/src/memory/intelligence.js

@@ -16,6 +16,7 @@ import { createRequire } from 'node:module';
 import { join } from 'node:path';
 import { resolveTrainingBackend } from '../ruvector/lora-adapter.js';
 import { getProjectCwd } from '../mcp-tools/types.js';
+import { withStatsFileLock } from './stats-file-lock.js';
 // ============================================================================
 // Persistence Configuration
 // ============================================================================
@@ -664,11 +665,9 @@ function bumpStat(key, n = 1) {
 }
 function readStatsFile() {
     try {
-        const path = getStatsPath();
-        if (!existsSync(path))
-            return null;
-        const data = JSON.parse(readFileSync(path, 'utf-8'));
-        return data && typeof data === 'object' ? data : null;
+        // Read-only callers keep their unavailable-on-error contract, while invalid
+        // disk values cannot poison local state and a later repaired-file flush.
+        return readStatsForWrite(getStatsPath());
     }
     catch {
         return null;
@@ -701,33 +700,79 @@ function maxTimestamp(a, b) {
         return a;
     return Math.max(a, b);
 }
-/**
- * Save stats to disk: merge this process's unsaved deltas into whatever is
- * currently on disk (read-merge-write, atomic rename), then adopt the merged
- * totals locally so this process also sees other writers' progress.
- */
+/** Missing files are first use; unreadable or invalid files must not be replaced. */
+function readStatsForWrite(path) {
+    let text;
+    try {
+        text = readFileSync(path, 'utf-8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        throw Object.assign(new Error('Invalid learning stats JSON'), { code: 'EINVALIDSTATS' });
+    }
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+        throw Object.assign(new Error('Invalid learning stats object'), { code: 'EINVALIDSTATS' });
+    }
+    for (const key of ['trajectoriesRecorded', 'patternsLearned', 'signalsProcessed']) {
+        const value = data[key];
+        // Older files may omit a counter, but present counters must be exact counts.
+        if (value === undefined)
+            continue;
+        if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {
+            throw Object.assign(new Error(`Invalid learning stats field: ${key}`), { code: 'EINVALIDSTATS' });
+        }
+    }
+    const timestamp = data.lastAdaptation;
+    if (timestamp != null && (typeof timestamp !== 'number' || !Number.isFinite(timestamp) || timestamp < 0)) {
+        throw Object.assign(new Error('Invalid learning stats timestamp'), { code: 'EINVALIDSTATS' });
+    }
+    return data;
+}
+/** Merge pending deltas under the cooperating-writer lock, then adopt committed totals. */
 function savePersistedStats() {
+    let statsPath;
     try {
-        ensureDataDir();
-        const path = getStatsPath();
-        const disk = readStatsFile();
-        const merged = disk
-            ? {
-                trajectoriesRecorded: (disk.trajectoriesRecorded ?? 0) + pendingDelta.trajectoriesRecorded,
-                patternsLearned: (disk.patternsLearned ?? 0) + pendingDelta.patternsLearned,
-                signalsProcessed: (disk.signalsProcessed ?? 0) + pendingDelta.signalsProcessed,
-                lastAdaptation: maxTimestamp(disk.lastAdaptation ?? null, globalStats.lastAdaptation),
+        statsPath = join(ensureDataDir(), 'stats.json');
+        withStatsFileLock(statsPath, (path) => {
+            const disk = readStatsForWrite(path);
+            const merged = disk
+                ? {
+                    trajectoriesRecorded: (disk.trajectoriesRecorded ?? 0) + pendingDelta.trajectoriesRecorded,
+                    patternsLearned: (disk.patternsLearned ?? 0) + pendingDelta.patternsLearned,
+                    signalsProcessed: (disk.signalsProcessed ?? 0) + pendingDelta.signalsProcessed,
+                    lastAdaptation: maxTimestamp(disk.lastAdaptation ?? null, globalStats.lastAdaptation),
+                }
+                : { ...globalStats };
+            for (const key of ['trajectoriesRecorded', 'patternsLearned', 'signalsProcessed']) {
+                if (!Number.isSafeInteger(merged[key]) || merged[key] < 0) {
+                    throw Object.assign(new Error('Learning stats counter overflow'), { code: 'EINVALIDSTATS' });
+                }
+            }
+            if (merged.lastAdaptation != null &&
+                (!Number.isFinite(merged.lastAdaptation) || merged.lastAdaptation < 0)) {
+                throw Object.assign(new Error('Invalid merged learning stats timestamp'), { code: 'EINVALIDSTATS' });
             }
-            : { ...globalStats };
-        const tmp = `${path}.${process.pid}.tmp`;
-        writeFileSync(tmp, JSON.stringify(merged, null, 2), 'utf-8');
-        renameSync(tmp, path);
-        globalStats = merged;
-        pendingDelta = { trajectoriesRecorded: 0, patternsLearned: 0, signalsProcessed: 0 };
-        persistedStatsLoaded = true;
+            const tmp = `${path}.${process.pid}.tmp`;
+            writeFileSync(tmp, JSON.stringify(merged, null, 2), 'utf-8');
+            renameSync(tmp, path);
+            // Commit local state before release: a failed release must not replay it.
+            globalStats = merged;
+            pendingDelta = { trajectoriesRecorded: 0, patternsLearned: 0, signalsProcessed: 0 };
+            persistedStatsLoaded = true;
+        });
     }
-    catch {
-        // Ignore save errors (deltas are retained for the next save)
+    catch (error) {
+        const { code = 'UNKNOWN', path = statsPath || 'neural stats directory' } = error;
+        // Do not print file contents, which may be malformed or user-controlled.
+        console.warn(`[intelligence] Could not persist learning stats at ${path} (${code}); pending increments retained`);
     }
 }
 /**
@@ -1015,13 +1060,15 @@ export async function recordTrajectory(steps, verdict) {
                 const avgQuality = verdict === 'success' ? 1.0 : verdict === 'partial' ? 0.5 : 0.0;
                 ruvllmCoord.recordTrajectory({
                     steps: enrichedSteps.map(s => ({
-                        state: s.content,
-                        action: s.type,
-                        reward: avgQuality,
-                        embedding: s.embedding || []
+                        type: ['query', 'route', 'generate', 'memory', 'feedback'].includes(s.type)
+                            ? s.type : 'generate',
+                        input: s.content,
+                        output: '',
+                        durationMs: 0,
+                        confidence: avgQuality
                     })),
                     totalReward: avgQuality,
-                    success: verdict === 'success'
+                    outcome: verdict
                 });
             }
             catch {

package/dist/src/memory/stats-file-lock.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Serialize cooperating local writers without stealing a paused writer's lock.
+ * Abnormal termination can leave an orphan: recovery requires confirming that
+ * no writer still owns the directory before removing it. Never age-reap it.
+ */
+export declare function withStatsFileLock<T>(file: string, write: (canonicalFile: string) => T): T;
+//# sourceMappingURL=stats-file-lock.d.ts.map

package/dist/src/memory/stats-file-lock.js

@@ -0,0 +1,53 @@
+import { mkdirSync, realpathSync, rmdirSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+/**
+ * Serialize cooperating local writers without stealing a paused writer's lock.
+ * Abnormal termination can leave an orphan: recovery requires confirming that
+ * no writer still owns the directory before removing it. Never age-reap it.
+ */
+export function withStatsFileLock(file, write) {
+    const canonicalFile = join(realpathSync(dirname(file)), basename(file));
+    const lock = `${canonicalFile}.lock`;
+    const deadline = performance.now() + 1000;
+    const sleeper = new Int32Array(new SharedArrayBuffer(4));
+    for (;;) {
+        try {
+            mkdirSync(lock, { mode: 0o700 });
+            break;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            const remaining = deadline - performance.now();
+            if (remaining <= 0) {
+                throw Object.assign(new Error('Learning stats lock is busy'), { code: 'ELOCKED', path: lock });
+            }
+            Atomics.wait(sleeper, 0, 0, Math.min(10, remaining));
+        }
+    }
+    const cleanup = () => {
+        // Only remove our empty directory. Never recursively remove foreign data.
+        rmdirSync(lock);
+    };
+    const onExit = () => {
+        try {
+            cleanup();
+        }
+        catch { /* abnormal exits may require deliberate recovery */ }
+    };
+    process.once('exit', onExit);
+    try {
+        return write(canonicalFile);
+    }
+    finally {
+        process.removeListener('exit', onExit);
+        try {
+            cleanup();
+        }
+        catch (error) {
+            const code = error.code || 'UNKNOWN';
+            console.warn(`[intelligence] Could not release learning stats lock at ${lock} (${code}); verify ownership before recovery`);
+        }
+    }
+}
+//# sourceMappingURL=stats-file-lock.js.map