claude-flow 3.53.0 → 3.54.1

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

@@ -150,6 +150,10 @@ export const agentdbPatternStore = {
             const confidence = validateScore(params.confidence, 0.8);
             const bridge = await getBridge();
             const result = await bridge.bridgeStorePattern({ pattern, type, confidence });
+            if (result && result.success === false) {
+                // #3691: the write was refused/not persisted — never acknowledge it.
+                return { success: false, error: `Pattern store failed: ${result.error ?? 'write not persisted'}`, controller: result.controller };
+            }
             if (result) {
                 // #3288: `controller: 'reasoningBank'` is the ONLY label that means
                 // the healthy path ran. Every other label bridgeStorePattern can
@@ -176,12 +180,20 @@ export const agentdbPatternStore = {
                 const { storeEntry } = await import('../memory/memory-initializer.js');
                 const patternId = `pattern-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
                 const value = JSON.stringify({ pattern, type, confidence, _fallback: 'reasoningBank-unavailable' });
-                await storeEntry({
+                const stored = await storeEntry({
                     key: patternId,
                     value,
                     namespace: 'pattern',
                     tags: [type, 'reasoning-pattern', 'fallback'],
                 });
+                // #3691: storeEntry reports failure as {success:false}, not a throw.
+                if (!stored || stored.success !== true) {
+                    return {
+                        success: false,
+                        error: `Pattern store failed: memory_store fallback did not persist (${stored?.error ?? 'no result'})`,
+                        recommendation: 'Run agentdb_health to inspect controller registration and check that .swarm/memory.db is writable.',
+                    };
+                }
                 return {
                     success: true,
                     // #3288: a caller must not have to already know to distrust a

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

@@ -3406,7 +3406,7 @@ export const hooksPatternStore = {
         }
         // Fallback: persist using memory-initializer store
         let storeResult = { success: false };
-        if (!reasoningResult) {
+        if (!reasoningResult?.success) {
             const storeFn = await getRealStoreFunction();
             if (storeFn) {
                 try {

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

@@ -5,6 +5,7 @@
  */
 import { existsSync, readFileSync, readdirSync, unlinkSync, statSync, writeFileSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
+import { gunzipSync } from 'node:zlib';
 import { join } from 'node:path';
 import { getProjectCwd } from './types.js';
 import { mkdirRestricted, readFileMaybeEncrypted, writeFileRestricted, } from '../fs-secure.js';
@@ -683,7 +684,9 @@ export const sessionTools = [
                 if (!existsSync(inputPath))
                     return { error: `File not found: ${inputPath}` };
                 try {
-                    parsed = JSON.parse(readFileSync(inputPath, 'utf-8'));
+                    const bytes = readFileSync(inputPath);
+                    const content = bytes[0] === 0x1f && bytes[1] === 0x8b ? gunzipSync(bytes) : bytes;
+                    parsed = JSON.parse(content.toString('utf-8'));
                 }
                 catch (e) {
                     return { error: `Invalid session JSON: ${e.message}` };

package/v3/@claude-flow/cli/dist/src/memory/embedding-q8.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ADR-472: a stored embedding as int8 + scale, for `memory list --embeddings`. Pure; no store access.
+ */
+/** Most embeddings `memory list --embeddings` will emit per call, and the longest vector it will encode. */
+export declare const MAX_LIST_EMBEDDINGS = 500;
+export declare const MAX_EMBEDDING_DIMS = 4096;
+/** A stored embedding as int8 with one scale, base64: ~1/4 the bytes of rounded JSON floats, enough for a 2D projection or a cosine screen. */
+export type EmbeddingQ8 = {
+    dims: number;
+    scale: number;
+    b64: string;
+};
+/**
+ * Read-only view of a stored embedding (a JSON array in the `embedding` column) as int8 + scale. Returns undefined for a missing,
+ * malformed, non-finite, constant-zero or over-long vector, so a caller never gets a guessed one. Each value is within scale/2 of the
+ * original (scale = max|v| / 127); cosine against the original stays above 0.9999 for unit-scale text embeddings.
+ */
+export declare function encodeEmbeddingQ8(stored: unknown): EmbeddingQ8 | undefined;
+//# sourceMappingURL=embedding-q8.d.ts.map

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

@@ -0,0 +1,38 @@
+/**
+ * ADR-472: a stored embedding as int8 + scale, for `memory list --embeddings`. Pure; no store access.
+ */
+/** Most embeddings `memory list --embeddings` will emit per call, and the longest vector it will encode. */
+export const MAX_LIST_EMBEDDINGS = 500;
+export const MAX_EMBEDDING_DIMS = 4096;
+/**
+ * Read-only view of a stored embedding (a JSON array in the `embedding` column) as int8 + scale. Returns undefined for a missing,
+ * malformed, non-finite, constant-zero or over-long vector, so a caller never gets a guessed one. Each value is within scale/2 of the
+ * original (scale = max|v| / 127); cosine against the original stays above 0.9999 for unit-scale text embeddings.
+ */
+export function encodeEmbeddingQ8(stored) {
+    if (stored === null || stored === undefined)
+        return undefined;
+    let values;
+    try {
+        values = typeof stored === 'string' ? JSON.parse(stored) : stored;
+    }
+    catch {
+        return undefined;
+    }
+    if (!Array.isArray(values) || values.length < 2 || values.length > MAX_EMBEDDING_DIMS)
+        return undefined;
+    let max = 0;
+    for (const v of values) {
+        if (typeof v !== 'number' || !Number.isFinite(v))
+            return undefined;
+        max = Math.max(max, Math.abs(v));
+    }
+    if (max === 0)
+        return undefined;
+    const scale = max / 127;
+    const bytes = new Int8Array(values.length);
+    for (let i = 0; i < values.length; i++)
+        bytes[i] = Math.max(-127, Math.min(127, Math.round(values[i] / scale)));
+    return { dims: values.length, scale: Number(scale.toPrecision(6)), b64: Buffer.from(bytes.buffer).toString('base64') };
+}
+//# sourceMappingURL=embedding-q8.js.map

package/v3/@claude-flow/cli/dist/src/memory/graph-edge-writer.js

@@ -34,6 +34,7 @@ import * as fs from 'fs';
 import * as crypto from 'crypto';
 import { getMemoryRoot } from './memory-initializer.js';
 import { encodeEmbedding } from './embedding-quantization.js';
+import { loadBetterSqlite3 } from './shared-sqlite.js';
 // ============================================================================
 // Lazy-cached better-sqlite3 db handle
 // ============================================================================
@@ -152,8 +153,8 @@ export async function getBridgeDb(customDbPath, opts) {
         // the try/catch below.
         let BetterSqlite3;
         try {
-            const mod = 'better-sqlite3';
-            BetterSqlite3 = (await import(mod)).default;
+            // #3693: share AgentDB's better-sqlite3 so the idle close cannot detach its handle.
+            BetterSqlite3 = await loadBetterSqlite3();
         }
         catch {
             return null;

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

@@ -159,34 +159,26 @@ function step3(w) {
     }
     return w;
 }
+// Longest suffixes first: Porter step 4 selects the longest matching suffix
+// ONCE and applies its condition; a failed condition must not fall through to
+// a shorter suffix (e.g. "argument": "ment" fails m>1, so "ent" is not tried).
 const STEP4_SUFFIXES = [
-    'al', 'ance', 'ence', 'er', 'ic', 'able', 'ible', 'ant', 'ement', 'ment',
-    'ent', 'ou', 'ism', 'ate', 'iti', 'ous', 'ive', 'ize',
+    'ement', 'ance', 'ence', 'able', 'ible', 'ment', 'ant', 'ent', 'ism',
+    'ate', 'iti', 'ous', 'ive', 'ize', 'ion', 'al', 'er', 'ic', 'ou',
 ];
 function step4(w) {
     for (const suf of STEP4_SUFFIXES) {
-        if (w.endsWith(suf)) {
-            const stem = w.slice(0, w.length - suf.length);
-            if (measure(stem) > 1) {
-                if (suf === 'ion') {
-                    const last = stem[stem.length - 1];
-                    if (last === 's' || last === 't')
-                        return stem;
-                }
-                else {
-                    return stem;
-                }
-            }
-        }
-    }
-    // ION special-case
-    if (w.endsWith('ion')) {
-        const stem = w.slice(0, -3);
+        if (!w.endsWith(suf))
+            continue;
+        const stem = w.slice(0, w.length - suf.length);
         if (measure(stem) > 1) {
+            if (suf !== 'ion')
+                return stem;
             const last = stem[stem.length - 1];
             if (last === 's' || last === 't')
                 return stem;
         }
+        return w;
     }
     return w;
 }

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

@@ -136,6 +136,8 @@ export declare function bridgeListEntries(options: {
     includeContent?: boolean;
     /** ADR-323: restrict rows to these provenance types. */
     provenanceFilter?: string[];
+    /** ADR-472: include each entry's embedding as int8+scale (`embeddingQ8`); at most MAX_LIST_EMBEDDINGS rows. */
+    includeEmbedding?: boolean;
 }): Promise<{
     success: boolean;
     entries: {
@@ -150,6 +152,11 @@ export declare function bridgeListEntries(options: {
         /** #2073: Present when `includeContent: true` was requested. */
         content?: string;
         provenanceType?: string;
+        embeddingQ8?: {
+            dims: number;
+            scale: number;
+            b64: string;
+        };
     }[];
     total: number;
     error?: string;
@@ -346,6 +353,7 @@ export declare function bridgeStorePattern(options: {
     controller: string;
     hasEmbedding?: boolean;
     embeddingError?: string;
+    error?: string;
 } | null>;
 /**
  * Search patterns via ReasoningBank controller.

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

@@ -17,6 +17,8 @@
  * @module v3/cli/memory-bridge
  */
 import { liveMemoryRowSql } from './live-memory-row.js';
+import { resolveAgentdbBetterSqlite3 } from './shared-sqlite.js';
+import { encodeEmbeddingQ8, MAX_LIST_EMBEDDINGS } from './embedding-q8.js';
 import * as path from 'path';
 import * as crypto from 'crypto';
 import { realpathSync } from 'node:fs';
@@ -449,7 +451,8 @@ async function getRegistry(dbPath) {
                                     try {
                                         const attestationFile = path.join(adbDir, 'dist/src/security/AttestationLog.js');
                                         if (fs.existsSync(attestationFile)) {
-                                            const Database = cjsRequire('better-sqlite3');
+                                            // #3693: same better-sqlite3 copy AgentDB uses, so closing this handle cannot disturb its WAL.
+                                            const Database = (resolveAgentdbBetterSqlite3() ?? cjsRequire('better-sqlite3'));
                                             const swarmDir = path.resolve(process.cwd(), '.swarm');
                                             if (!fs.existsSync(swarmDir))
                                                 fs.mkdirSync(swarmDir, { recursive: true });
@@ -1430,7 +1433,7 @@ export async function bridgeListEntries(options) {
         ORDER BY updated_at DESC
         LIMIT ? OFFSET ?
       `);
-            const rows = stmt.all(...filterParams, limit, offset);
+            const rows = stmt.all(...filterParams, options.includeEmbedding ? Math.min(limit, MAX_LIST_EMBEDDINGS) : limit, offset);
             for (const row of rows) {
                 const entry = {
                     // #2073: don't truncate id when content is requested — callers
@@ -1448,6 +1451,11 @@ export async function bridgeListEntries(options) {
                 if (options.includeContent) {
                     entry.content = row.content || '';
                 }
+                if (options.includeEmbedding) {
+                    const q8 = encodeEmbeddingQ8(row.embedding);
+                    if (q8)
+                        entry.embeddingQ8 = q8;
+                }
                 entries.push(entry);
             }
         }
@@ -2105,6 +2113,17 @@ export async function bridgeStorePattern(options) {
         });
         if (!result)
             return null;
+        // #3691: bridgeStoreEntry reports data-level failures (MutationGuard
+        // rejection, nothing written) as a truthy {success:false}. Do not turn
+        // that into a success receipt — refuse at this boundary.
+        if (!result.success) {
+            return {
+                success: false,
+                patternId: '',
+                controller: 'bridge-fallback',
+                error: result.error ?? 'pattern write was not persisted',
+            };
+        }
         // Add to HNSW index for fast semantic search (bridgeStoreEntry stores SQL only)
         if (result.rawEmbedding) {
             try {

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

@@ -8,6 +8,7 @@
  *
  * @module v3/cli/memory-initializer
  */
+import { type EmbeddingQ8 } from './embedding-q8.js';
 /**
  * ADR-323 — typed memory provenance. Distinguishes WHO/WHAT wrote a memory
  * entry (a user's stated claim vs an agent's own output vs a tool result vs
@@ -504,6 +505,8 @@ export declare function listEntries(options: {
     includeContent?: boolean;
     /** ADR-323: restrict rows to these provenance types. */
     provenanceFilter?: string[];
+    /** ADR-472: include each entry's embedding as int8+scale (`embeddingQ8`); at most MAX_LIST_EMBEDDINGS rows. Read-only. */
+    includeEmbedding?: boolean;
 }): Promise<{
     success: boolean;
     entries: {
@@ -518,6 +521,8 @@ export declare function listEntries(options: {
         /** #2073: Present when `includeContent: true` was requested. */
         content?: string;
         provenanceType?: string;
+        /** ADR-472: present when `includeEmbedding: true` and the row has a valid stored vector. */
+        embeddingQ8?: EmbeddingQ8;
     }[];
     total: number;
     error?: string;

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

@@ -8,7 +8,9 @@
  *
  * @module v3/cli/memory-initializer
  */
+import { loadBetterSqlite3 } from './shared-sqlite.js';
 import { liveMemoryRowSql } from './live-memory-row.js';
+import { encodeEmbeddingQ8, MAX_LIST_EMBEDDINGS } from './embedding-q8.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import { AsyncLocalStorage } from 'node:async_hooks';
@@ -1407,8 +1409,8 @@ export async function recoverMemoryDatabase(dbPath, opts = {}) {
     try {
         // Module name behind a variable so TS does not statically resolve the
         // optional native dep's types at build time (CI may not install them).
-        const mod = 'better-sqlite3';
-        Database = (await import(mod)).default;
+        // #3693: same better-sqlite3 identity as AgentDB (see shared-sqlite.ts).
+        Database = await loadBetterSqlite3();
     }
     catch {
         return await restoreFromBackup('no-native');
@@ -1556,8 +1558,8 @@ export async function repairVectorIndexes(dbPath, opts = {}) {
     try {
         // Module name behind a variable so TS does not statically resolve the
         // optional native dep's types at build time (CI may not install them).
-        const mod = 'better-sqlite3';
-        Database = (await import(mod)).default;
+        // #3693: same better-sqlite3 identity as AgentDB (see shared-sqlite.ts).
+        Database = await loadBetterSqlite3();
     }
     catch {
         // Native module absent (e.g. WASM-only host). Statusline fix still covers
@@ -3018,7 +3020,7 @@ export async function listEntries(options) {
         const countResult = countRows.length > 0 ? [{ values: countRows }] : [];
         const total = countResult[0]?.values?.[0]?.[0] || 0;
         // Get entries
-        const safeLimit = parseInt(String(limit), 10) || 100;
+        const safeLimit = Math.min(parseInt(String(limit), 10) || 100, options.includeEmbedding ? MAX_LIST_EMBEDDINGS : Number.MAX_SAFE_INTEGER);
         const safeOffset = parseInt(String(offset), 10) || 0;
         // #2120 — same NULL-as-active acceptance as the count above.
         const listStmt = db.prepare(`SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at, provenance_type
@@ -3051,6 +3053,11 @@ export async function listEntries(options) {
                 if (options.includeContent) {
                     entry.content = content || '';
                 }
+                if (options.includeEmbedding) {
+                    const q8 = encodeEmbeddingQ8(embedding);
+                    if (q8)
+                        entry.embeddingQ8 = q8;
+                }
                 entries.push(entry);
             }
         }

package/v3/@claude-flow/cli/dist/src/memory/shared-sqlite.d.ts

@@ -0,0 +1,7 @@
+type DbCtor = new (path: string, opts?: Record<string, unknown>) => any;
+/** Test seam: pass `from` to resolve relative to another entry file. */
+export declare function resolveAgentdbBetterSqlite3(from?: string): DbCtor | null;
+/** Constructor shared with AgentDB when possible, else the CLI's own copy. */
+export declare function loadBetterSqlite3(): Promise<DbCtor>;
+export {};
+//# sourceMappingURL=shared-sqlite.d.ts.map

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

@@ -0,0 +1,45 @@
+/**
+ * #3693 — one better-sqlite3 identity per process.
+ *
+ * AgentDB (via @claude-flow/memory) owns a live native handle on memory.db. If
+ * the CLI opens its own handle through a DIFFERENT installed copy of
+ * better-sqlite3 (a nested `agentdb/node_modules/better-sqlite3` next to a
+ * hoisted one is the common layout), the two copies each statically link their
+ * own SQLite and keep separate per-process file bookkeeping. Closing the CLI's
+ * handle (graph-edge idle release: wal_checkpoint(TRUNCATE) + close) then looks
+ * like "last connection" to that copy and deletes the -wal/-shm sidecars out
+ * from under AgentDB's still-open handle.
+ *
+ * Resolve the constructor from the same place AgentDB resolves it, so both
+ * share one SQLite instance (and its connection bookkeeping). Falls back to the
+ * CLI's own copy when agentdb cannot be resolved.
+ */
+import { createRequire } from 'node:module';
+let cached;
+/** Test seam: pass `from` to resolve relative to another entry file. */
+export function resolveAgentdbBetterSqlite3(from) {
+    if (!from && cached !== undefined)
+        return cached;
+    let found = null;
+    try {
+        const own = createRequire(import.meta.url);
+        const agentdbEntry = from ?? own.resolve('agentdb');
+        const mod = createRequire(agentdbEntry)('better-sqlite3');
+        found = (mod?.default ?? mod);
+    }
+    catch {
+        found = null;
+    }
+    if (!from)
+        cached = found;
+    return found;
+}
+/** Constructor shared with AgentDB when possible, else the CLI's own copy. */
+export async function loadBetterSqlite3() {
+    const shared = resolveAgentdbBetterSqlite3();
+    if (shared)
+        return shared;
+    const mod = 'better-sqlite3';
+    return (await import(mod)).default;
+}
+//# sourceMappingURL=shared-sqlite.js.map

package/v3/@claude-flow/cli/dist/src/mods/probe.d.ts

@@ -29,5 +29,12 @@ export interface ProbeInputs {
     /** Reads for the plugin-resolution findings; the real filesystem when absent. */
     fs?: ReadFs;
 }
+declare const LEGACY_EVENTS: {
+    readonly route: "UserPromptSubmit";
+    readonly 'post-edit': "PostToolUse";
+};
+/** Which of route/post-edit the settings run through the CLI's own `hooks` command, in any of the files. */
+export declare function legacyCliHooks(files: readonly string[]): Array<keyof typeof LEGACY_EVENTS>;
 export declare function probeMods(inputs: ProbeInputs): Finding[];
+export {};
 //# sourceMappingURL=probe.d.ts.map

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

@@ -33,6 +33,26 @@ export function managedSettingsPath(os = platform()) {
         return 'C:\\ProgramData\\ClaudeCode\\managed-settings.json';
     return '/etc/claude-code/managed-settings.json';
 }
+const LEGACY_EVENTS = { route: 'UserPromptSubmit', 'post-edit': 'PostToolUse' };
+/** Which of route/post-edit the settings run through the CLI's own `hooks` command, in any of the files. */
+export function legacyCliHooks(files) {
+    const commands = (event) => files.flatMap((f) => {
+        let groups;
+        try {
+            groups = get(readSettingsFile(f), 'hooks', event);
+        }
+        catch {
+            return [];
+        }
+        return Array.isArray(groups)
+            ? groups.flatMap((g) => (Array.isArray(g?.hooks) ? g.hooks.map((h) => h?.command).filter((c) => typeof c === 'string') : []))
+            : [];
+    });
+    return Object.keys(LEGACY_EVENTS).filter((sub) => {
+        const word = new RegExp(`(?:^|[\\s/"'])(?:@claude-flow/cli|claude-flow|ruflo)(?:@[\\w.-]+)?["']?\\s+hooks\\s+${sub}(?![\\w-])`);
+        return commands(LEGACY_EVENTS[sub]).some((c) => word.test(c));
+    });
+}
 export function probeMods(inputs) {
     const root = resolve(inputs.projectRoot);
     const home = inputs.home ?? homedir();
@@ -104,6 +124,14 @@ export function probeMods(inputs) {
     findings.push(managedOnly !== undefined && managedOnly !== false
         ? { name: 'managed policy', status: 'warn', message: 'allowManagedModsOnly is set: Claude Code refuses user mods; classic hooks stay in charge' }
         : { name: 'managed policy', status: 'pass', message: managed === undefined ? 'no managed settings' : 'user mods allowed (allowManagedModsOnly not set)' });
+    // 4a. Settings that still run the CLI's own `hooks route|post-edit` (what init
+    // wrote before hook-handler.cjs). That command never reads the handshake, so
+    // the mod stands down for those events (plugins/ruflo-mods/hooks/ownership.ts,
+    // legacyCliConfigured: keep the two patterns in step).
+    const legacy = legacyCliHooks(files);
+    if (legacy.length) {
+        findings.push({ name: 'legacy CLI hooks', status: 'warn', message: `settings run the CLI's own \`hooks ${legacy.join('` and `hooks ')}\`: the mod stands down for ${legacy.join(' and ')}, which that command keeps`, fix: 'ruflo init upgrade --settings (regenerate the settings hooks)' });
+    }
     // 4. Every classic helper a hook could run honours the handshake (the mod's
     // own rule, plugins/ruflo-mods/hooks/session.ts); else the mod stands down.
     const helpers = [...new Set([join(root, '.claude', 'helpers', 'hook-handler.cjs'), join(home, '.claude', 'helpers', 'hook-handler.cjs')])].filter(existsSync);
@@ -116,7 +144,7 @@ export function probeMods(inputs) {
         }
     });
     findings.push(helpers.length === 0
-        ? { name: 'classic handshake', status: 'pass', message: 'no hook-handler.cjs: the mod owns route and post-edit outright' }
+        ? { name: 'classic handshake', status: 'pass', message: legacy.length ? 'no hook-handler.cjs (see legacy CLI hooks)' : 'no hook-handler.cjs: the mod owns route and post-edit outright' }
         : stale.length === 0
             ? { name: 'classic handshake', status: 'pass', message: `${helpers.join(', ')} hand route and post-edit to the mod while it runs` }
             : { name: 'classic handshake', status: 'warn', message: `${stale.join(', ')} predate${stale.length === 1 ? 's' : ''} the handshake: the mod stands down and classic hooks keep route/post-edit`, fix: 'ruflo init --upgrade (refresh helpers in the project and in ~/.claude)' });

package/v3/@claude-flow/cli/dist/src/production/monitoring.d.ts

@@ -147,6 +147,8 @@ export declare class MonitoringHooks {
      */
     reset(): void;
     private checkAlerts;
+    /** Drop metrics older than retentionMs (also applied on reads, #3855). */
+    private expireMetrics;
     private cleanupMetrics;
 }
 /**

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

@@ -243,6 +243,7 @@ export class MonitoringHooks {
      * Get metrics for a specific name
      */
     getMetrics(name, since) {
+        this.expireMetrics();
         let filtered = this.metrics.filter(m => m.name === name);
         if (since) {
             filtered = filtered.filter(m => m.timestamp >= since);
@@ -253,6 +254,7 @@ export class MonitoringHooks {
      * Get all metrics summary
      */
     getMetricsSummary() {
+        this.expireMetrics();
         const summary = {};
         for (const metric of this.metrics) {
             if (!summary[metric.name]) {
@@ -320,11 +322,14 @@ export class MonitoringHooks {
             }
         }
     }
+    /** Drop metrics older than retentionMs (also applied on reads, #3855). */
+    expireMetrics() {
+        const cutoff = Date.now() - this.config.retentionMs;
+        this.metrics = this.metrics.filter(m => m.timestamp > cutoff);
+    }
     cleanupMetrics() {
-        const now = Date.now();
-        const cutoff = now - this.config.retentionMs;
         // Remove old metrics
-        this.metrics = this.metrics.filter(m => m.timestamp > cutoff);
+        this.expireMetrics();
         // Limit total metrics
         if (this.metrics.length > this.config.maxMetrics) {
             this.metrics = this.metrics.slice(-this.config.maxMetrics);

package/v3/@claude-flow/cli/dist/src/production/rate-limiter.js

@@ -41,12 +41,15 @@ export class RateLimiter {
         const limits = this.getLimits(operation);
         const now = Date.now();
         // Get or create bucket
-        const bucketKey = userId && this.config.perUserLimits
+        const trackedUser = userId && this.config.perUserLimits ? userId : undefined;
+        const bucketKey = trackedUser
             ? `${operation}:${userId}`
             : `global:${operation}`;
         let bucket = this.buckets.get(bucketKey);
         if (!bucket) {
             bucket = this.createBucket();
+            bucket.operation = operation;
+            bucket.userId = trackedUser;
             this.buckets.set(bucketKey, bucket);
             this.cleanupBuckets();
         }
@@ -133,10 +136,10 @@ export class RateLimiter {
     getStats() {
         const operationCounts = new Map();
         const users = new Set();
-        for (const [key, bucket] of this.buckets) {
-            const [operation, userId] = key.split(':');
-            if (userId)
-                users.add(userId);
+        for (const bucket of this.buckets.values()) {
+            const operation = bucket.operation;
+            if (bucket.userId)
+                users.add(bucket.userId);
             const current = operationCounts.get(operation) || 0;
             operationCounts.set(operation, current + bucket.requests.length);
         }

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

@@ -54,6 +54,8 @@ function calculateDelay(attempt, config, strategy = 'exponential') {
         const jitterRange = delay * config.jitter;
         delay += (Math.random() - 0.5) * 2 * jitterRange;
     }
+    // Enforce the configured maximum on the final (jittered) delay
+    delay = Math.min(delay, config.maxDelayMs);
     return Math.round(Math.max(0, delay));
 }
 /**

package/v3/@claude-flow/cli/dist/src/services/git-workspace-identity.js

@@ -24,7 +24,7 @@
 import { createHash } from 'crypto';
 import { resolve } from 'path';
 import * as fs from 'fs';
-import { safeGitTextSync } from '@claude-flow/security/safe-git';
+import { safeGitBufferSync, safeGitTextSync } from '@claude-flow/security/safe-git';
 const GIT_TIMEOUT_MS = 3000;
 function git(cwd, ...args) {
     try {
@@ -37,6 +37,23 @@ function git(cwd, ...args) {
         return null;
     }
 }
+/**
+ * Path-valued git output: git terminates the record with a single LF, so strip
+ * only that. A full trim() would corrupt valid paths ending in whitespace.
+ */
+function gitPath(cwd, ...args) {
+    try {
+        const out = safeGitBufferSync(cwd, args, {
+            timeoutMs: GIT_TIMEOUT_MS,
+            stderr: 'ignore',
+        }).toString('utf8');
+        const rec = out.endsWith('\n') ? out.slice(0, -1) : out;
+        return rec.length > 0 ? rec : null;
+    }
+    catch {
+        return null;
+    }
+}
 function sha256(input) {
     return createHash('sha256').update(input).digest('hex');
 }
@@ -50,7 +67,7 @@ export function resolveGitWorkspaceIdentity(dir) {
     const resolved = resolve(dir);
     let stable = identityCache.get(resolved);
     if (!stable) {
-        const worktreeRoot = git(resolved, 'rev-parse', '--show-toplevel');
+        const worktreeRoot = gitPath(resolved, 'rev-parse', '--show-toplevel');
         if (!worktreeRoot) {
             stable = {
                 worktreeRoot: resolved,
@@ -63,7 +80,7 @@ export function resolveGitWorkspaceIdentity(dir) {
         else {
             // --git-common-dir may be relative to the worktree root (git < 2.31
             // and some invocation contexts) — resolve against it.
-            const rawCommon = git(worktreeRoot, 'rev-parse', '--git-common-dir') ?? '.git';
+            const rawCommon = gitPath(worktreeRoot, 'rev-parse', '--git-common-dir') ?? '.git';
             const commonGitDir = resolve(worktreeRoot, rawCommon);
             stable = {
                 worktreeRoot,

package/v3/@claude-flow/cli/dist/src/services/worker-queue.d.ts

@@ -103,6 +103,7 @@ export declare class WorkerQueue extends EventEmitter {
     private workerId;
     private heartbeatTimer?;
     private processingTasks;
+    private retryTimers;
     private isShuttingDown;
     private maxConcurrent;
     private initialized;