claude-flow 3.56.10 → 3.57.1

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

@@ -92,13 +92,13 @@ export class CLI {
             const parseResult = this.parser.parse(args);
             const { command: commandPath, flags, positional } = parseResult;
             // Handle global flags
+            if (flags.noColor || flags.color === false) {
+                this.output.setColorEnabled(false);
+            }
             if (flags.version || flags.V) {
                 this.showVersion();
                 return;
             }
-            if (flags.noColor) {
-                this.output.setColorEnabled(false);
-            }
             // Set verbosity level based on flags
             if (flags.quiet) {
                 this.output.setVerbosity('quiet');
@@ -114,7 +114,7 @@ export class CLI {
                 this.output.printDebug(`CWD: ${process.cwd()}`);
             }
             // Run startup update check (non-blocking, silent on skip)
-            if (!flags.noUpdate && commandPath[0] !== 'update') {
+            if (!flags.noUpdate && flags.update !== false && commandPath[0] !== 'update' && !(commandPath[0] === 'doctor' && flags.json)) {
                 this.checkForUpdatesOnStartup().catch(() => { });
             }
             // Version-stamped helper auto-refresh — propagate hook fixes to an already
@@ -536,7 +536,7 @@ export class CLI {
         catch (error) {
             // Config loading is optional - don't fail if it doesn't exist
             if (process.env.DEBUG) {
-                this.output.writeln(this.output.dim(`Config loading failed: ${error.message}`));
+                this.output.writeErrorln(this.output.dim(`Config loading failed: ${error.message}`));
             }
             return undefined;
         }

package/v3/@claude-flow/cli/dist/src/init/settings-generator.js

@@ -27,7 +27,6 @@ export function generateSettings(options) {
         allow: [
             'Bash(npx @claude-flow*)',
             'Bash(npx claude-flow*)',
-            'Bash(node .claude/*)',
             'mcp__claude-flow__*',
         ],
         deny: [
@@ -201,7 +200,7 @@ function generateHooksConfig(config, scope) {
     const hooks = {};
     // Node.js scripts handle errors internally via try/catch.
     // No shell-level error suppression needed (2>/dev/null || true breaks Windows).
-    // PreToolUse — validate commands and edits before execution
+    // PreToolUse — validate shell commands before execution
     if (config.preToolUse) {
         hooks.PreToolUse = [
             {
@@ -214,19 +213,9 @@ function generateHooksConfig(config, scope) {
                     },
                 ],
             },
-            {
-                matcher: 'Write|Edit|MultiEdit',
-                hooks: [
-                    {
-                        type: 'command',
-                        command: hookHandlerCmd('pre-edit', scope),
-                        timeout: config.timeout,
-                    },
-                ],
-            },
         ];
     }
-    // PostToolUse — record edits and commands for session metrics / learning
+    // PostToolUse — record edits for session metrics / learning
     if (config.postToolUse) {
         hooks.PostToolUse = [
             {
@@ -239,16 +228,6 @@ function generateHooksConfig(config, scope) {
                     },
                 ],
             },
-            {
-                matcher: 'Bash',
-                hooks: [
-                    {
-                        type: 'command',
-                        command: hookHandlerCmd('post-bash', scope),
-                        timeout: config.timeout,
-                    },
-                ],
-            },
         ];
     }
     // UserPromptSubmit — intelligent task routing
@@ -312,16 +291,13 @@ function generateHooksConfig(config, scope) {
             },
         ];
     }
-    // PreCompact — preserve context before compaction
+    // PreCompact — end the current session before compaction. The handler has no
+    // manual/automatic compaction-specific command, so don't wire no-op hooks.
     if (config.preCompact) {
         hooks.PreCompact = [
             {
                 matcher: 'manual',
                 hooks: [
-                    {
-                        type: 'command',
-                        command: hookHandlerCmd('compact-manual', scope),
-                    },
                     {
                         type: 'command',
                         command: hookHandlerCmd('session-end', scope),
@@ -332,10 +308,6 @@ function generateHooksConfig(config, scope) {
             {
                 matcher: 'auto',
                 hooks: [
-                    {
-                        type: 'command',
-                        command: hookHandlerCmd('compact-auto', scope),
-                    },
                     {
                         type: 'command',
                         command: hookHandlerCmd('session-end', scope),
@@ -345,18 +317,6 @@ function generateHooksConfig(config, scope) {
             },
         ];
     }
-    // SubagentStart — status update when a sub-agent is spawned
-    hooks.SubagentStart = [
-        {
-            hooks: [
-                {
-                    type: 'command',
-                    command: hookHandlerCmd('status', scope),
-                    timeout: 3000,
-                },
-            ],
-        },
-    ];
     // SubagentStop — track agent completion for metrics
     // NOTE: The valid event is "SubagentStop" (not "SubagentEnd")
     hooks.SubagentStop = [
@@ -370,20 +330,6 @@ function generateHooksConfig(config, scope) {
             ],
         },
     ];
-    // Notification — capture Claude Code notifications for logging
-    if (config.notification) {
-        hooks.Notification = [
-            {
-                hooks: [
-                    {
-                        type: 'command',
-                        command: hookHandlerCmd('notify', scope),
-                        timeout: 3000,
-                    },
-                ],
-            },
-        ];
-    }
     // NOTE: TeammateIdle, TaskCompleted, and PostCompact are NOT accepted by
     // Claude Code's settings.json validator (rejected as "Invalid key in record").
     // Agent Teams coordination lives in claudeFlow.agentTeams.hooks instead.

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

@@ -9,7 +9,7 @@
  *
  * @module v3/cli/mcp-tools/memory-tools
  */
-import type { MCPTool } from './types.js';
+import { type MCPTool } from './types.js';
 export declare const DANGEROUS_KEY_PATTERN: RegExp;
 /**
  * #3570: the one key rule for every memory write path (MCP store, CLI store,

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

@@ -11,8 +11,10 @@
  */
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
-import { join, resolve } from 'path';
+import { basename, dirname, join, resolve } from 'path';
+import { execFileSync } from 'node:child_process';
 import { createHash } from 'crypto';
+import { getProjectCwd } from './types.js';
 import { validateIdentifier } from './validate-input.js';
 import { DEFAULT_SEARCH_THRESHOLD, nearMisses } from '../memory/search-defaults.js';
 // #1604: Align with memory-initializer.ts — single source of truth is .swarm/memory.db
@@ -146,7 +148,24 @@ function resolveProjectMemoryDir(claudeProjectsDir, projectPathOverride) {
         sources.push(projectPathOverride);
     }
     else {
-        sources.push(process.cwd());
+        const project = getProjectCwd();
+        sources.push(project);
+        // Claude Code shares auto-memory across linked Git worktrees under the
+        // main checkout's project slug. Preserve the direct-path match first,
+        // then try the common Git directory's parent. Explicit overrides above
+        // remain authoritative, and non-Git projects need no Git dependency.
+        try {
+            const commonDir = execFileSync('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], {
+                cwd: project,
+                encoding: 'utf-8',
+                timeout: 1000,
+                windowsHide: true,
+                stdio: ['ignore', 'pipe', 'ignore'],
+            }).trim();
+            if (basename(commonDir) === '.git')
+                sources.push(dirname(resolve(project, commonDir)));
+        }
+        catch { /* Git unavailable or not a repository: use the project path */ }
     }
     for (const source of sources) {
         // Candidate 1: legacy POSIX hash — what shipped before #1883
@@ -1066,6 +1085,7 @@ export const memoryTools = [
             }
             let imported = 0;
             let skipped = 0;
+            const importErrors = [];
             // #1791.8 — Claude Code's `~/.claude/projects/` accumulates historical
             // project_id directories (truncated forms, sandbox cwds, renamed
             // workspaces) that all contain copies of the same memory files. The
@@ -1105,7 +1125,7 @@ export const memoryTools = [
                         // #1884 — sanitize key so memory_delete can later remove it. Without
                         // this, dangerous chars from frontmatter `name` strand the key.
                         const key = sanitizeMemoryKey(`claude:${memFile.project}:${name}`);
-                        const stored = await storeEntry({ key, value: body, namespace: ns, generateEmbeddingFlag: true });
+                        const stored = await storeEntry({ key, value: body, namespace: ns, generateEmbeddingFlag: true, upsert: true });
                         if (!stored.success)
                             throw new Error(stored.error || `Failed to store ${key}`);
                         imported++;
@@ -1120,15 +1140,19 @@ export const memoryTools = [
                             // #1884 — sanitize so any dangerous chars in the heading don't
                             // produce keys memory_delete will reject.
                             const key = sanitizeMemoryKey(`claude:${memFile.project}:${name}:${sectionTitle.slice(0, 50)}`);
-                            const stored = await storeEntry({ key, value: sectionBody, namespace: ns, generateEmbeddingFlag: true });
+                            const stored = await storeEntry({ key, value: sectionBody, namespace: ns, generateEmbeddingFlag: true, upsert: true });
                             if (!stored.success)
                                 throw new Error(stored.error || `Failed to store ${key}`);
                             imported++;
                         }
                     }
                 }
-                catch {
+                catch (err) {
                     skipped++;
+                    // Say why a file was skipped instead of returning a bare failure (#4197).
+                    if (importErrors.length < 5) {
+                        importErrors.push(`${memFile.path}: ${err instanceof Error ? err.message : String(err)}`);
+                    }
                 }
             }
             // AUDIT #3: report the embedding backend truthfully — a hash-fallback
@@ -1147,6 +1171,7 @@ export const memoryTools = [
                 skipped,
                 duplicatesSkipped,
                 excludedByPattern,
+                ...(importErrors.length > 0 ? { errors: importErrors } : {}),
                 files: memoryFiles.length,
                 projects: projects.size,
                 namespace: ns,

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

@@ -399,7 +399,7 @@ export const metaharnessTools = [
     },
     // ───────────────────────────────────────────────────────────────────────
     // ADR-153 — @metaharness/darwin integration (3 tools).
-    // Backed by the separate `@metaharness/darwin@~0.10.2` npm package, NOT
+    // Backed by the separate `@metaharness/darwin@~0.12.0` npm package, NOT
     // the umbrella `metaharness`. Plugin scripts shell out via _darwin.mjs.
     // Same {success, data, degraded, exitCode} contract.
     // ───────────────────────────────────────────────────────────────────────

package/v3/@claude-flow/cli/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/v3/@claude-flow/cli/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/v3/@claude-flow/cli/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/v3/@claude-flow/cli/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/v3/@claude-flow/cli/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