@claude-flow/cli 3.32.21 → 3.32.23

package/.claude/helpers/.helpers-version

@@ -1 +1 @@
-3.32.19
+3.32.9

package/.claude/helpers/helpers.manifest.json

@@ -1,6 +1,6 @@
 {
   "manifest": {
-    "version": "3.32.21",
+    "version": "3.32.23",
     "files": {
       "auto-memory-hook.mjs": "e3e1033b24704992ddef6b31c7fa9dd7fcd9e1af7935dd77ef73402b916b31e6",
       "hook-handler.cjs": "f87ec28684bfc5fd0a54c46bd2a53a3fb037defe71d0ea4b8a5cb88a2cd87a3f",
@@ -8,6 +8,6 @@
       "statusline.cjs": "10f74a1aa9af217d0623c0a9839d82825b0eed31a4707a7531a85c6116869a6c"
     }
   },
-  "signature": "/u6cu5Rvxtw6aRDpqL1ZUGcCxrzoRUfDRtDI13Yd8RQres08uHFd1tSWJgDDw+fYYNHvmR/yfJS3Hb9KCccTAQ==",
+  "signature": "8EdHRlBpW8Om3t9dixEctCh/RW66gA+IIlo3YxKvRnJYbyeHrV48tSCJqaNAlGgaksGIFqQtzfMjM5LyeZY/BA==",
   "algorithm": "ed25519"
 }

package/.claude/proven-config.json

@@ -1,5 +1,5 @@
 {
-  "adoptedAt": 1785103598198,
+  "adoptedAt": 1785208363552,
   "championId": "sha256:6141a8ea990c5063b77e090ae8f37f9c539d8aa8f58dcceb30f3a82f97e57319",
   "manifest": {
     "schema": "ruflo.proven-config/v1",

package/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 1,
-  "generatedAt": "2026-07-27T03:27:12.952Z",
-  "gitSha": "6b6eef90",
+  "generatedAt": "2026-07-28T03:16:55.798Z",
+  "gitSha": "7b5e7d84",
   "catalog": {
     "agents": 164,
     "tools": 387,

package/dist/src/commands/memory.js

@@ -78,10 +78,13 @@ const storeCommand = {
             // on the value BEFORE persistence and refuse the write if a
             // finding is present. Opt-in per-call; RUFLO_MEMORY_SCAN_ON_WRITE=1
             // enables it globally.
+            // NOTE: no `default:` here — needed so the ADR-125 CLI-flag-wins
+            // precedence (`ctx.flags.scanContent ?? envVar`) can distinguish
+            // "user didn't pass the flag" (undefined) from "user explicitly
+            // said --no-scan-content" (false). Fixes #2794.
             name: 'scan-content',
             description: 'Scan the value for injection payloads before persisting (dream-cycle #2752 MemPoison gate)',
             type: 'boolean',
-            default: false
         },
         DB_PATH_OPTION
     ],
@@ -126,9 +129,11 @@ const storeCommand = {
             return { success: false, exitCode: 1 };
         }
         // #2752 MemPoison gate — scan before persist when opted in.
-        const scanContentFlag = ctx.flags.scanContent;
-        const scanContentEnv = /^(1|true|yes|on)$/i.test(String(process.env.RUFLO_MEMORY_SCAN_ON_WRITE ?? ''));
-        if (scanContentFlag || scanContentEnv) {
+        // CLI flag ctx.flags.scanContent takes precedence over RUFLO_MEMORY_SCAN_ON_WRITE env var
+        // (ADR-125 §"CLI flag wins" / ADR-130 §env-var-config-precedence — fix for #2794).
+        const scanContent = ctx.flags.scanContent
+            ?? /^(1|true|yes|on)$/i.test(String(process.env.RUFLO_MEMORY_SCAN_ON_WRITE ?? ''));
+        if (scanContent) {
             try {
                 const { scanChannelMessage } = await import('../security/channel-guard.js');
                 const scan = scanChannelMessage(value);

package/dist/src/commands/swarm.js

@@ -50,6 +50,29 @@ function getSwarmStatus(swarmId) {
             // Ignore
         }
     }
+    // #2799 — `agent spawn` never writes `.swarm/agents/*.json`; it records
+    // the count in `.claude-flow/metrics/swarm-activity.json` (via
+    // updateSwarmActivityMetrics in commands/agent.ts). So when the agents
+    // dir is empty, reconcile against that authoritative activity file
+    // instead of reporting Total 0 while `agent list` shows N agents.
+    if (totalAgents === 0) {
+        try {
+            const activityPath = path.join(process.cwd(), '.claude-flow', 'metrics', 'swarm-activity.json');
+            if (fs.existsSync(activityPath)) {
+                const activity = JSON.parse(fs.readFileSync(activityPath, 'utf-8'));
+                const count = Math.max(0, Number((activity?.swarm?.agent_count)) || 0);
+                if (count > 0) {
+                    totalAgents = count;
+                    // swarm-activity.json tracks a count, not per-agent status; treat
+                    // a coordination-active swarm's agents as active, else idle.
+                    activeAgents = activity?.swarm?.coordination_active ? count : 0;
+                }
+            }
+        }
+        catch {
+            // Ignore — fall back to 0
+        }
+    }
     // Get session count
     let sessionCount = 0;
     if (fs.existsSync(sessionDir)) {

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

@@ -418,10 +418,21 @@ function getIntelligenceStatsFromMemory() {
         (e.metadata?.type === 'trajectory'));
     const successfulTrajectories = trajectoryEntries.filter(e => e.metadata?.success === true ||
         (typeof e.value === 'object' && e.value !== null && e.value.success === true));
-    // Count patterns
+    // Count patterns (#2797). The original filter matched only
+    // `key.includes('pattern')` / `metadata.type==='pattern'` /
+    // `learned-*`, but NO writer in the codebase ever produces that
+    // shape — so Pattern Learning was permanently 0. The post-task
+    // dual-write (#2786 fix-2) persists learned patterns as
+    // `routing-decision:*` entries in the `patterns` namespace with
+    // `metadata.type: 'routing-decision'`. Those ARE the learned
+    // patterns the metric is meant to count, so include them: any entry
+    // whose namespace is `patterns`, plus the original shapes for
+    // forward-compatibility with a future explicit `pattern` writer.
     const patternEntries = entries.filter(e => e.key.includes('pattern') ||
         e.metadata?.type === 'pattern' ||
-        e.key.startsWith('learned-'));
+        e.key.startsWith('learned-') ||
+        e.namespace === 'patterns' ||
+        e.metadata?.type === 'routing-decision');
     // Categorize patterns
     const categories = {};
     patternEntries.forEach(e => {

package/dist/src/services/memory-backup.js

@@ -51,6 +51,51 @@ export async function backupMemoryDb(opts = {}) {
             db?.close();
         }
         catch { /* */ }
+        // #2798 — under CLAUDE_FLOW_ENCRYPT_AT_REST the source is an RFE1
+        // blob, not native SQLite, so better-sqlite3's online-backup API
+        // throws "file is not a database" and the run was silently recorded
+        // as skipped (users with encryption had ZERO backups behind a green
+        // status). The online-backup API only exists to avoid tearing a live
+        // WAL-mode DB; that concern doesn't apply to the encrypted file (sql.js
+        // rewrites it wholesale per flush), so a plain byte copy is a valid
+        // snapshot. Fall back to it before giving up.
+        try {
+            fs.copyFileSync(dbPath, destPath);
+            const copiedBytes = fs.statSync(destPath).size;
+            if (copiedBytes > 0) {
+                // Fall through to rotation/offsite/return below via a flag path.
+                // (Mirror the success path's tail by re-using the same code.)
+                const keep = typeof opts.keep === 'number' && opts.keep > 0 ? opts.keep : 7;
+                const rotatedAway = [];
+                try {
+                    const snaps = fs.readdirSync(destDir).filter(f => /^memory-.*\.db$/.test(f)).sort();
+                    while (snaps.length > keep) {
+                        const old = snaps.shift();
+                        try {
+                            fs.rmSync(path.join(destDir, old), { force: true });
+                            rotatedAway.push(old);
+                        }
+                        catch { /* */ }
+                    }
+                }
+                catch { /* */ }
+                let gcsUri;
+                if (opts.gcs) {
+                    try {
+                        const { execFileSync } = await import('child_process');
+                        const dest = opts.gcs.replace(/\/+$/, '') + '/' + path.basename(destPath);
+                        execFileSync('gcloud', ['storage', 'cp', destPath, dest], { stdio: ['ignore', 'ignore', 'inherit'] });
+                        gcsUri = dest;
+                    }
+                    catch { /* offsite failed — local snapshot stands */ }
+                }
+                if (opts.verbose) {
+                    console.log(`memory DB backed up (byte-copy, encrypted-at-rest) → ${destPath} (${Math.round(copiedBytes / 1024)} KB)`);
+                }
+                return { backedUp: true, path: destPath, sizeBytes: copiedBytes, rotatedAway, gcsUri };
+            }
+        }
+        catch { /* byte-copy also failed — report the original error */ }
         return { backedUp: false, skipped: `backup failed: ${e?.message ?? e}` };
     }
     let sizeBytes = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.32.21",
+  "version": "3.32.23",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",