claude-flow 3.32.8 → 3.32.9

package/.claude/helpers/statusline.cjs

@@ -633,12 +633,55 @@ function compareVersions(a, b) {
   return 0;
 }
 
+// #2742: when CWD is a linked git worktree, it has no node_modules of its
+// own (worktrees don't get their own `npm install`), so every CWD-relative
+// probe in getPkgVersion() misses and the version silently falls back to
+// the baked-in default — even though the main repo's install a few
+// directories away is perfectly resolvable. A linked worktree's `.git` is
+// a plain FILE (not a directory) containing `gitdir: <main>/.git/worktrees/
+// <name>`; walk up from CWD to find it, parse the pointer, and strip the
+// trailing `.git/worktrees/<name>` segment to recover the main repo root.
+// Pure fs — no `git rev-parse` spawn (statusline renders are latency-
+// sensitive; this doc comment's neighbors are explicit about avoiding
+// spawns in the render path).
+function resolveWorktreeMainRoot() {
+  try {
+    let dir = CWD;
+    for (;;) {
+      const dotGit = path.join(dir, '.git');
+      if (fs.existsSync(dotGit)) {
+        if (fs.statSync(dotGit).isFile()) {
+          const contents = fs.readFileSync(dotGit, 'utf-8');
+          const m = contents.match(/^gitdir:\s*(.+)$/m);
+          const wtGitDir = m && m[1].trim();
+          if (wtGitDir) {
+            // Git writes this pointer with forward slashes even on Windows
+            // (a git-for-windows convention for its own internal files) —
+            // path.sep (backslash on win32) never matches, so normalize
+            // before searching rather than building an OS-specific marker.
+            const normalized = wtGitDir.replace(/\\/g, '/');
+            const marker = '/.git/worktrees/';
+            const idx = normalized.lastIndexOf(marker);
+            if (idx > 0) return normalized.slice(0, idx);
+          }
+        }
+        return null; // a real (non-worktree) .git dir — nothing to resolve
+      }
+      const parent = path.dirname(dir);
+      if (parent === dir) return null; // reached filesystem root
+      dir = parent;
+    }
+  } catch {
+    return null;
+  }
+}
+
 function getPkgVersion() {
   // Baked in at generation time from the real running CLI's own resolved
   // version (see generateStatuslineScript()'s doc comment) — correct even
   // when this renders via a pure npx invocation with no local install for
   // the candidate scan below to find.
-  let ver = "3.28.0";
+  let ver = "3.32.8";
   try {
     const home = os.homedir();
     const pkgPaths = [
@@ -647,6 +690,17 @@ function getPkgVersion() {
       path.join(CWD, 'node_modules', 'ruflo', 'package.json'),
       path.join(CWD, 'v3', '@claude-flow', 'cli', 'package.json'),
     ];
+    // #2742: CWD is a linked git worktree with no node_modules of its own —
+    // probe the main repo's install too, so a worktree session shows the
+    // same version a main-repo session would.
+    const worktreeMainRoot = resolveWorktreeMainRoot();
+    if (worktreeMainRoot) {
+      pkgPaths.push(
+        path.join(worktreeMainRoot, 'node_modules', '@claude-flow', 'cli', 'package.json'),
+        path.join(worktreeMainRoot, 'node_modules', 'ruflo', 'package.json'),
+        path.join(worktreeMainRoot, 'v3', '@claude-flow', 'cli', 'package.json'),
+      );
+    }
     // #2221: global installs (npm i -g ruflo) live outside CWD/node_modules, so the
     // probes above all miss and the version falls back to the hard-coded default.
     // Derive the global node_modules dir from the running node binary (no npm spawn —

package/.claude-plugin/hooks/hooks.json

@@ -1,7 +1,9 @@
 {
   "_note": "#1921 — hook commands invoke scripts/ruflo-hook.sh (resilient shim): prefers a locally-installed `ruflo`/`claude-flow` binary, falls back to `npx --prefer-offline`, and always exits 0 so a CLI/install failure (e.g. arborist `Invalid Version` on npm 10.8.x) never surfaces an error in Claude Code or blocks a turn. The trailing `|| true` guards the case where $CLAUDE_PLUGIN_ROOT is unset (older Claude Code) — the hook then no-ops silently. DO NOT revert to a bare `npx <pkg>@alpha hooks …` per fire.",
   "_platform": "posix",
-  "_platform_note": "#2132 — This hooks.json uses /bin/bash, POSIX pipelines (jq, xargs, tr), and .sh scripts. It is intentionally POSIX-only (Mac/Linux). On Windows, ruflo init writes a .claude/settings.json that overrides these entries with node-based equivalents via plugins/ruflo-core/scripts/ruflo-hook.cjs. The audit exempts files with _platform:posix from the cross-platform check.",
+  "_platform_note": "#2132 — This hooks.json uses /bin/bash, POSIX pipelines (jq, xargs, tr), and .sh scripts. It is intentionally POSIX-only (Mac/Linux) today and known-broken on native Windows (#2721 shape). The previous claim here that `ruflo init` overrides these entries with node-based equivalents on Windows was never actually implemented and is incorrect — Claude Code merges plugin-declared hooks additively with any init-generated settings.json, it does not replace them. This package (separate from plugins/ruflo-core, which got the #2721 fix) still needs its own Windows-compatible rewrite; see _legacy_unaudited_shim below.",
+  "_legacy_unaudited_shim": true,
+  "_legacy_unaudited_shim_note": "#2721 fixed plugins/ruflo-core and plugins/ruflo-cost-tracker (marketplace-listed in .claude-plugin/marketplace.json) by rewiring hooks.json to a `node -e` bootstrap around scripts/ruflo-hook.cjs. This older, separately-published \"claude-flow\" plugin package (not in the ruflo marketplace list) has its own, larger jq/xargs-based hook set and its own scripts/ruflo-hook.cjs that hooks.json never references — same underlying bug shape, NOT fixed as part of #2721. Needs its own audited pass before this flag can be removed.",
   "hooks": {
     "PreToolUse": [
       {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.32.8",
+  "version": "3.32.9",
   "description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",
@@ -78,11 +78,12 @@
     "@ruvector/router-linux-x64-gnu": "^0.1.30",
     "@ruvector/sona": "^0.1.5",
     "agentdb": "^3.0.0-alpha.17",
-    "agentic-flow": "^2.0.14"
+    "agentic-flow": "^2.0.14",
+    "better-sqlite3": "12.9.0"
   },
   "overrides": {
     "ruvector": "^0.2.27",
-    "better-sqlite3": ">=12.8.0",
+    "better-sqlite3": "12.9.0",
     "js-yaml": ">=4.3.0",
     "hono": ">=4.12.25",
     "@ruvector/rvf-wasm": "0.1.5",
@@ -131,6 +132,11 @@
     "typescript": "^5.0.0",
     "vitest": "^3.2.6"
   },
+  "pnpm": {
+    "overrides": {
+      "better-sqlite3": "12.9.0"
+    }
+  },
   "engines": {
     "node": ">=20.0.0"
   },

package/v3/@claude-flow/cli/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 1,
-  "generatedAt": "2026-07-18T22:28:26.547Z",
-  "gitSha": "fb2f92bb",
+  "generatedAt": "2026-07-20T23:20:52.239Z",
+  "gitSha": "745dfbe3",
   "catalog": {
     "agents": 164,
     "tools": 387,

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

@@ -5,7 +5,7 @@
  * Created with ruv.io
  */
 import { output } from '../output.js';
-import { existsSync, readFileSync, statSync } from 'fs';
+import { existsSync, readFileSync, statSync, openSync, readSync, closeSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { createHash } from 'crypto';
@@ -216,6 +216,16 @@ async function checkDaemonStatus() {
     }
 }
 // Check memory database
+//
+// #2737: renamed the reported row from "Memory Database" to "Memory Database
+// Presence" — this check is existsSync()+statSync() ONLY, it never opens the
+// file or queries it, so it PASSES for any file that exists and can be
+// stat'd, corrupt or not. It was the ONLY memory probe in the default
+// `allChecks` run (the real integrity checks were --component memory only),
+// so a corrupt .swarm/memory.db could sail through a bare `doctor` run as
+// "healthy". The name change makes the check's actual scope honest; the
+// behavior below is unchanged. See checkMemoryStructuralIntegrity below for
+// the new default-run check that actually opens the file.
 async function checkMemoryDatabase() {
     // Authoritative path comes from `getMemoryRoot()` (honors
     // `CLAUDE_FLOW_MEMORY_PATH`, claude-flow.config.json's `memory.persistPath`,
@@ -238,14 +248,14 @@ async function checkMemoryDatabase() {
             try {
                 const stats = statSync(dbPath);
                 const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
-                return { name: 'Memory Database', status: 'pass', message: `${dbPath} (${sizeMB} MB)` };
+                return { name: 'Memory Database Presence', status: 'pass', message: `${dbPath} (${sizeMB} MB) — existence/size only, not a health check (see Memory Structural Integrity)` };
             }
             catch {
-                return { name: 'Memory Database', status: 'warn', message: `${dbPath} (unable to stat)` };
+                return { name: 'Memory Database Presence', status: 'warn', message: `${dbPath} (unable to stat)` };
             }
         }
     }
-    return { name: 'Memory Database', status: 'warn', message: 'Not initialized', fix: 'claude-flow memory configure --backend hybrid' };
+    return { name: 'Memory Database Presence', status: 'warn', message: 'Not initialized', fix: 'claude-flow memory configure --backend hybrid' };
 }
 // ═══════════════════════════════════════════════════════════════════════════
 // #2677 — memory doctor: functional checks (stuinfla)
@@ -305,46 +315,282 @@ async function tryOpenSqlJs(dbPath) {
         return null;
     }
 }
-// Check 1 — sql.js can open it AND PRAGMA integrity_check returns 'ok'.
-// Two fail modes handled distinctly per "UNKNOWN is never PASS":
-//   - Open fails: warn ("cannot open; encrypted DB or corrupt — doctor
-//     can't distinguish from this side")
-//   - Open succeeds but pragma != 'ok': fail (definite corruption)
+// ── #2737 shared helpers: encryption-at-rest carve-out ─────────────────────
+//
+// "file is not a database" / "malformed" from sql.js or better-sqlite3 is
+// EXACTLY the signal a legitimately RFE1-encrypted-at-rest memory.db also
+// produces when opened without decrypting (ADR-096). Before either the new
+// default-run check or the strengthened checkMemoryIntegrity below concludes
+// "malformed = fail", they sniff for the RFE1 magic using the SAME detector
+// checkEncryptionAtRest uses (isEncryptedBlob), so the two checks can never
+// disagree about what counts as "encrypted".
+/** Read just the first `len` bytes of a file without loading the whole file
+ * into memory — a multi-GB memory.db shouldn't get fully buffered just to
+ * check a 4-byte magic. Returns fewer bytes (or empty) when the file is
+ * shorter than `len`; isEncryptedBlob() correctly treats a too-short blob
+ * as "not encrypted", so callers don't need to special-case that. */
+function readHeaderBytes(path, len) {
+    const fd = openSync(path, 'r');
+    try {
+        const buf = Buffer.alloc(len);
+        const bytesRead = readSync(fd, buf, 0, len, 0);
+        return buf.subarray(0, bytesRead);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+// RFE1 wire format is magic(4) + iv(12) + ciphertext(N) + tag(16); the
+// shortest possible blob is 32 bytes. 64 gives headroom without importing
+// vault.ts's private MIN_BLOB_LEN constant.
+const ENCRYPTION_SNIFF_LEN = 64;
+/** True iff `dbPath` is a legitimately RFE1-encrypted-at-rest file. A read
+ * failure (permissions, races) is treated as "not encrypted" — callers
+ * still hit their own open/query error handling right after, so nothing
+ * gets silently swallowed. */
+function isMemoryDbEncryptedAtRest(dbPath) {
+    try {
+        return isEncryptedBlob(readHeaderBytes(dbPath, ENCRYPTION_SNIFF_LEN));
+    }
+    catch {
+        return false;
+    }
+}
+// #2737 part 1 — bare `doctor` (no --component flag) never actually opened
+// memory.db: checkMemoryDatabase above is existsSync()+statSync() only, so
+// it PASSES on any file that exists and can be stat'd, corrupt or not, and
+// it was the ONLY memory probe `allChecks` ran. The real integrity checks
+// (checkMemoryIntegrity/Content/EmbeddingCoverage below) were, and remain,
+// --component memory only.
+//
+// This is a NEW, cheaper, native check added to the default `allChecks` run
+// (not a replacement for the deep trio):
+//   - better-sqlite3 (native) instead of sql.js: it's WAL-aware because
+//     SQLite itself resolves any sibling -wal file next to the main image;
+//     sql.js is WAL-blind — tryOpenSqlJs() above only readFileSync()s the
+//     main file and hands the raw bytes to the WASM build, so any
+//     committed-but-not-checkpointed rows sitting in a -wal file are
+//     invisible to it.
+//   - PRAGMA quick_check, not integrity_check: per sqlite.org, quick_check
+//     "is like integrity_check except that it does not verify UNIQUE
+//     constraints and does not verify that index content matches table
+//     content" — bounded enough to run unconditionally on every bare
+//     `doctor` call. The full integrity_check (with those extra
+//     cross-checks) is what the strengthened checkMemoryIntegrity below
+//     runs when better-sqlite3 is available.
+// Explicitly labeled "structural-only" in both the row name and every
+// message so nobody mistakes this cheap default-run probe for the deeper
+// --component memory one.
+async function checkMemoryStructuralIntegrity() {
+    const NAME = 'Memory Structural Integrity (quick_check)';
+    const dbPath = await resolveMemoryDbPath();
+    if (!dbPath) {
+        // Not-yet-initialized project — Memory Database Presence above already
+        // surfaces this; "UNKNOWN is never PASS" still applies, so this stays a
+        // warn rather than a silent skip, but doesn't pile on a second red for
+        // the same root cause.
+        return {
+            name: NAME,
+            status: 'warn',
+            message: 'no memory.db found (see Memory Database Presence above) — structural-only check skipped',
+        };
+    }
+    // Encryption-at-rest carve-out (#2737 part 3) — see helpers above.
+    if (isMemoryDbEncryptedAtRest(dbPath)) {
+        return {
+            name: NAME,
+            status: 'warn',
+            message: `${dbPath} — RFE1-encrypted at rest; structural-only check can't run without decrypting (expected, not corruption — see Encryption at Rest)`,
+        };
+    }
+    let Database;
+    try {
+        Database = (await import('better-sqlite3')).default;
+    }
+    catch {
+        return {
+            name: NAME,
+            status: 'warn',
+            message: `${dbPath} — better-sqlite3 not installed; structural-only check skipped (optional native module)`,
+            fix: 'npm install better-sqlite3  (enables WAL-aware structural checks on every `doctor` run)',
+        };
+    }
+    let db;
+    try {
+        db = new Database(dbPath, { readonly: true, fileMustExist: true });
+    }
+    catch (e) {
+        const msg = e.message || String(e);
+        // Encryption already ruled out above — an unencrypted file
+        // better-sqlite3 can't even open is definitive corruption.
+        // #2737 part 3: fail, not warn.
+        return {
+            name: NAME,
+            status: 'fail',
+            message: `${dbPath} — better-sqlite3 failed to open: ${msg} (unencrypted; definitively malformed) [structural-only]`,
+            fix: 'back up .swarm/memory.db then `claude-flow memory init --force`',
+        };
+    }
+    try {
+        const rows = db.pragma('quick_check');
+        const values = rows.map((r) => String(Object.values(r)[0]));
+        if (values.length === 1 && values[0] === 'ok') {
+            return {
+                name: NAME,
+                status: 'pass',
+                message: `${dbPath} — PRAGMA quick_check: ok [structural-only, native + WAL-aware]`,
+            };
+        }
+        return {
+            name: NAME,
+            status: 'fail',
+            message: `${dbPath} — PRAGMA quick_check: ${values.slice(0, 3).join('; ')}${values.length > 3 ? ` (+${values.length - 3} more)` : ''} [structural-only]`,
+            fix: 'back up .swarm/memory.db then `claude-flow memory init --force`',
+        };
+    }
+    catch (e) {
+        const msg = e.message || String(e);
+        // Encryption ruled out above; DB opened but the pragma itself threw —
+        // still definitive, unencrypted breakage. Fail, not warn.
+        return {
+            name: NAME,
+            status: 'fail',
+            message: `${dbPath} — quick_check probe threw: ${msg} (unencrypted) [structural-only]`,
+            fix: 'back up .swarm/memory.db then `claude-flow memory init --force`',
+        };
+    }
+    finally {
+        try {
+            db.close();
+        }
+        catch { /* best-effort */ }
+    }
+}
+// Check 1 (--component memory, deep path) — #2737 part 2 strengthens this:
+// prefer native better-sqlite3 PRAGMA integrity_check (adds index↔table
+// cross-checking + UNIQUE verification that quick_check above deliberately
+// skips, and is WAL-aware — see checkMemoryStructuralIntegrity's comment)
+// when better-sqlite3 is available, falling back to the original sql.js
+// probe when it's not. The sql.js fallback is main-image-only (WAL-blind);
+// its message says so explicitly so operators know its limits.
+//
+// #2737 part 3: with the encryption carve-out applied up front on BOTH
+// paths, a "file is not a database" / "malformed" result is now definitive,
+// unencrypted corruption in every branch below — fail, not warn (the
+// previous version treated this as an ambiguous warn because it couldn't
+// tell corruption from encryption; that ambiguity is what the carve-out
+// resolves).
 async function checkMemoryIntegrity() {
     const dbPath = await resolveMemoryDbPath();
     if (!dbPath)
-        return { name: 'Memory Integrity', status: 'warn', message: 'no memory.db found (see Memory Database check above)' };
+        return { name: 'Memory Integrity', status: 'warn', message: 'no memory.db found (see Memory Database Presence check above)' };
+    if (isMemoryDbEncryptedAtRest(dbPath)) {
+        return {
+            name: 'Memory Integrity',
+            status: 'warn',
+            message: `${dbPath} — RFE1-encrypted at rest; integrity check can't run without decrypting (expected, not corruption — see Encryption at Rest)`,
+        };
+    }
+    // Prefer native better-sqlite3 (WAL-aware, full integrity_check). Module
+    // load is isolated in its own try/catch so ONLY "not installed" falls
+    // through to the sql.js fallback below — once the module loaded, any
+    // open/query failure is resolved (fail) right here, not silently
+    // reclassified as "sql.js fallback, main-image-only" by an outer catch.
+    let Database;
+    try {
+        Database = (await import('better-sqlite3')).default;
+    }
+    catch {
+        Database = null; // not installed — fall through to the sql.js fallback below.
+    }
+    if (Database) {
+        let db;
+        try {
+            db = new Database(dbPath, { readonly: true, fileMustExist: true });
+        }
+        catch (e) {
+            const msg = e.message || String(e);
+            return {
+                name: 'Memory Integrity',
+                status: 'fail',
+                message: `${dbPath} — better-sqlite3 failed to open: ${msg} (unencrypted; definitively malformed) [native, WAL-aware]`,
+                fix: 'back up .swarm/memory.db then `claude-flow memory init --force`',
+            };
+        }
+        try {
+            const rows = db.pragma('integrity_check');
+            const values = rows.map((r) => String(Object.values(r)[0]));
+            if (values.length === 1 && values[0] === 'ok') {
+                return { name: 'Memory Integrity', status: 'pass', message: `${dbPath} — PRAGMA integrity_check: ok [native, WAL-aware]` };
+            }
+            return {
+                name: 'Memory Integrity',
+                status: 'fail',
+                message: `${dbPath} — PRAGMA integrity_check: ${values.slice(0, 3).join('; ')}${values.length > 3 ? ` (+${values.length - 3} more)` : ''} [native, WAL-aware]`,
+                fix: 'back up .swarm/memory.db then `claude-flow memory init --force`',
+            };
+        }
+        catch (e) {
+            // DB opened but the pragma itself threw — still definitive,
+            // unencrypted breakage (encryption ruled out above). Fail, not warn,
+            // and NOT a fall-through to the sql.js fallback: better-sqlite3 IS
+            // installed and just gave us the answer.
+            const msg = e.message || String(e);
+            return {
+                name: 'Memory Integrity',
+                status: 'fail',
+                message: `${dbPath} — integrity_check probe threw: ${msg} (unencrypted; definitively malformed) [native, WAL-aware]`,
+                fix: 'back up .swarm/memory.db then `claude-flow memory init --force`',
+            };
+        }
+        finally {
+            try {
+                db.close();
+            }
+            catch { /* best-effort */ }
+        }
+    }
+    // Fallback: sql.js — main-image-only (WAL-blind). tryOpenSqlJs()
+    // readFileSync()s the base file directly, so any committed-but-not-
+    // checkpointed rows sitting in a sibling -wal file are invisible here.
+    // Install better-sqlite3 for the WAL-aware path above.
     const db = await tryOpenSqlJs(dbPath);
     if (!db) {
+        // Encryption already ruled out above — an unencrypted file sql.js can't
+        // even open is definitive corruption too.
         return {
             name: 'Memory Integrity',
-            status: 'warn',
-            message: `${dbPath} — sql.js can't open (encrypted DB or corrupt; doctor can't tell which from outside)`,
-            fix: 'if encrypted: expected. if not: back up + `claude-flow memory init --force` to rebuild',
+            status: 'fail',
+            message: `${dbPath} — sql.js can't open (unencrypted; definitively malformed) [main-image-only fallback — install better-sqlite3 for WAL-aware checking]`,
+            fix: 'back up .swarm/memory.db then `claude-flow memory init --force`',
         };
     }
     try {
         const res = db.exec('PRAGMA integrity_check');
         const rows = res[0]?.values?.map((v) => String(v[0])) ?? [];
         if (rows.length === 1 && rows[0] === 'ok') {
-            return { name: 'Memory Integrity', status: 'pass', message: `${dbPath} — PRAGMA integrity_check: ok` };
+            return { name: 'Memory Integrity', status: 'pass', message: `${dbPath} — PRAGMA integrity_check: ok [main-image-only fallback — sql.js can't see WAL-only data; install better-sqlite3 for full coverage]` };
         }
         return {
             name: 'Memory Integrity',
             status: 'fail',
-            message: `${dbPath} — PRAGMA integrity_check: ${rows.slice(0, 3).join('; ')}${rows.length > 3 ? ` (+${rows.length - 3} more)` : ''}`,
+            message: `${dbPath} — PRAGMA integrity_check: ${rows.slice(0, 3).join('; ')}${rows.length > 3 ? ` (+${rows.length - 3} more)` : ''} [main-image-only fallback]`,
             fix: 'back up .swarm/memory.db then `claude-flow memory init --force`',
         };
     }
     catch (e) {
         const msg = e.message || String(e);
-        const encryptedOrCorrupt = msg.includes('file is not a database') || msg.includes('malformed');
+        const definitivelyMalformed = msg.includes('file is not a database') || msg.includes('malformed');
+        // Encryption already ruled out above, so — matched pattern or not —
+        // this is a query refusal on a file we KNOW isn't RFE1-encrypted.
+        // #2737 part 3: fail, not warn.
         return {
             name: 'Memory Integrity',
-            status: 'warn',
-            message: encryptedOrCorrupt
-                ? `${dbPath} — DB refused query: ${msg} (encrypted DB or corruption; see Memory Integrity above)`
-                : `${dbPath} — probe threw: ${msg}`,
+            status: 'fail',
+            message: definitivelyMalformed
+                ? `${dbPath} — DB refused query: ${msg} (unencrypted; definitively malformed) [main-image-only fallback]`
+                : `${dbPath} — probe threw: ${msg} (unencrypted — encryption ruled out above) [main-image-only fallback]`,
+            fix: 'back up .swarm/memory.db then `claude-flow memory init --force`',
         };
     }
     finally {
@@ -1715,6 +1961,7 @@ export const doctorCommand = {
             checkStaleSettingsNpx, // #2448 — runaway `npx @latest` in statusLine/hooks
             checkDaemonStatus,
             checkMemoryDatabase,
+            checkMemoryStructuralIntegrity, // #2737 — bounded, native quick_check on every default run
             checkLearningBridge, // #2545 — can the auto-memory hook actually load @claude-flow/memory?
             checkApiKeys,
             checkMcpServers,

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

@@ -3485,12 +3485,54 @@ const statuslineCommand = {
             const contextPct = Math.min(100, Math.floor(learning.sessions * 5));
             return { memoryMB, contextPct, intelligencePct, subAgents };
         }
+        // #2733: Claude Code pipes session JSON (incl. the real active model) on
+        // stdin to statusline commands. Read it synchronously the same way
+        // .claude/helpers/statusline.cjs's getModelFromStdin() does, so this CLI
+        // subcommand is correct standalone — not just when the generated helper
+        // happens to override its output. Read once, memoized per invocation
+        // (mirrors statusline.cjs's _stdinData cache).
+        let _stdinData;
+        let _stdinRead = false;
+        function getStdinData() {
+            if (_stdinRead)
+                return _stdinData;
+            _stdinRead = true;
+            try {
+                if (process.stdin.isTTY) {
+                    _stdinData = null;
+                    return null;
+                }
+                const chunks = [];
+                const buf = Buffer.alloc(4096);
+                let bytesRead;
+                try {
+                    while ((bytesRead = fs.readSync(0, buf, 0, buf.length, null)) > 0) {
+                        chunks.push(Buffer.from(buf.subarray(0, bytesRead)));
+                    }
+                }
+                catch { /* EOF or read error */ }
+                const raw = Buffer.concat(chunks).toString('utf-8').trim();
+                _stdinData = (raw && raw.startsWith('{')) ? JSON.parse(raw) : null;
+            }
+            catch {
+                _stdinData = null;
+            }
+            return _stdinData;
+        }
+        function getModelFromStdin() {
+            const data = getStdinData();
+            return (data && data.model && typeof data.model.display_name === 'string') ? data.model.display_name : null;
+        }
         // Get user info
         function getUserInfo() {
             const identityMode = (process.env.RUFLO_STATUSLINE_IDENTITY || 'project').toLowerCase();
             let name = path.basename(process.cwd()) || 'project';
             let gitBranch = '';
-            const modelName = 'Opus 4.6 (1M context)';
+            // Real active model from Claude Code's stdin payload when available;
+            // this string is only a last-resort label for direct/manual CLI
+            // invocation with no stdin (e.g. a bare terminal run) — never shown
+            // when Claude Code itself is the caller.
+            const modelName = getModelFromStdin() || 'Claude Code';
             const isWindows = process.platform === 'win32';
             try {
                 const rootCmd = isWindows

package/v3/@claude-flow/cli/dist/src/funnel/message-transport.d.ts

@@ -5,16 +5,23 @@
  *
  * Design discipline:
  *   1. **Never blocks the render.** The statusline reads only the local
- *      cache. This module refreshes the cache in the background; a fresh
- *      install shows the in-code fallback pool until the first refresh
- *      lands (usually seconds after CLI startup).
+ *      cache. This module refreshes the cache in the background; per
+ *      ADR-311 "zero local promo content" there is NO in-code fallback
+ *      pool — a genuinely fresh install (empty cache) shows nothing on
+ *      the promo/disclosure row until the first background refresh lands
+ *      (see hook-handler.cjs's SessionStart-triggered detached
+ *      `hooks refresh-funnel`, usually within seconds of CLI startup, but
+ *      contingent on network reachability to the messages endpoint). This
+ *      comment previously (incorrectly) described an in-code fallback
+ *      pool; there has never been one since ADR-311 — see disclosure.ts's
+ *      own "fail-closed" doc comment for the authoritative statement.
  *   2. **Content pipeline stays authoritative.** Every message the server
  *      returns is validated by `isValidMessage()` from `messages.ts` —
  *      same schema, same host allowlist, same control-char strip, same
  *      80-column cap. A tampered or accidentally-broken remote feed can
  *      pollute nothing.
  *   3. **Fail silent.** Any network/parse/validation failure leaves the
- *      previously-cached (or in-code) pool intact.
+ *      previously-cached pool intact (empty, if nothing has landed yet).
  *   4. **Bounded cache size.** ≤ 128 KiB and ≤ 200 messages — matches
  *      ADR-309's bounded-local-queue discipline.
  *   5. **Kill switch.** `RUFLO_FUNNEL_MESSAGES=0` (or `RUFLO_FUNNEL=0`)

package/v3/@claude-flow/cli/dist/src/funnel/message-transport.js

@@ -5,16 +5,23 @@
  *
  * Design discipline:
  *   1. **Never blocks the render.** The statusline reads only the local
- *      cache. This module refreshes the cache in the background; a fresh
- *      install shows the in-code fallback pool until the first refresh
- *      lands (usually seconds after CLI startup).
+ *      cache. This module refreshes the cache in the background; per
+ *      ADR-311 "zero local promo content" there is NO in-code fallback
+ *      pool — a genuinely fresh install (empty cache) shows nothing on
+ *      the promo/disclosure row until the first background refresh lands
+ *      (see hook-handler.cjs's SessionStart-triggered detached
+ *      `hooks refresh-funnel`, usually within seconds of CLI startup, but
+ *      contingent on network reachability to the messages endpoint). This
+ *      comment previously (incorrectly) described an in-code fallback
+ *      pool; there has never been one since ADR-311 — see disclosure.ts's
+ *      own "fail-closed" doc comment for the authoritative statement.
  *   2. **Content pipeline stays authoritative.** Every message the server
  *      returns is validated by `isValidMessage()` from `messages.ts` —
  *      same schema, same host allowlist, same control-char strip, same
  *      80-column cap. A tampered or accidentally-broken remote feed can
  *      pollute nothing.
  *   3. **Fail silent.** Any network/parse/validation failure leaves the
- *      previously-cached (or in-code) pool intact.
+ *      previously-cached pool intact (empty, if nothing has landed yet).
  *   4. **Bounded cache size.** ≤ 128 KiB and ≤ 200 messages — matches
  *      ADR-309's bounded-local-queue discipline.
  *   5. **Kill switch.** `RUFLO_FUNNEL_MESSAGES=0` (or `RUFLO_FUNNEL=0`)

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

@@ -90,6 +90,15 @@ export declare function countGraphEdges(dbPath?: string): Promise<number>;
  * #2431 fix: also explicitly closes the prior handle so file locks
  * release immediately — better-sqlite3 holds an OS-level file handle
  * which the prior sql.js implementation did not.
+ *
+ * #2736-followup fix: `close()` alone only checkpoints the WAL back into
+ * the main file as a best-effort PASSIVE checkpoint when SQLite considers
+ * this the last connection — which is not guaranteed to fully flush under
+ * contention, and was observed leaving writes invisible to a same-process
+ * sql.js reader that re-reads the raw file immediately after close() on
+ * Linux CI runners (not reproduced on Windows). Force a blocking TRUNCATE
+ * checkpoint before close so cross-engine readers always see committed
+ * writes deterministically, regardless of platform/timing.
  */
 export declare function _resetBridgeDb(): void;
 //# sourceMappingURL=graph-edge-writer.d.ts.map

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

@@ -203,9 +203,22 @@ export async function countGraphEdges(dbPath) {
  * #2431 fix: also explicitly closes the prior handle so file locks
  * release immediately — better-sqlite3 holds an OS-level file handle
  * which the prior sql.js implementation did not.
+ *
+ * #2736-followup fix: `close()` alone only checkpoints the WAL back into
+ * the main file as a best-effort PASSIVE checkpoint when SQLite considers
+ * this the last connection — which is not guaranteed to fully flush under
+ * contention, and was observed leaving writes invisible to a same-process
+ * sql.js reader that re-reads the raw file immediately after close() on
+ * Linux CI runners (not reproduced on Windows). Force a blocking TRUNCATE
+ * checkpoint before close so cross-engine readers always see committed
+ * writes deterministically, regardless of platform/timing.
  */
 export function _resetBridgeDb() {
     if (_db) {
+        try {
+            _db.pragma('wal_checkpoint(TRUNCATE)');
+        }
+        catch { /* best-effort */ }
         try {
             _db.close();
         }

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

@@ -23,6 +23,28 @@ import { createRequire } from 'node:module';
 let registryPromise = null;
 let registryInstance = null;
 let bridgeAvailable = null;
+// #2735 — the native-bridge -> sql.js whole-image fallback used to be
+// completely silent: a registry init failure cached `bridgeAvailable =
+// false` for the rest of the process, and a per-operation bridge exception
+// swallowed itself with a bare `catch { return null; }` — in both cases the
+// caller fell back to memory-initializer.ts's unsafe whole-image sql.js
+// path with zero diagnostic trail. When that path corrupted a database, the
+// demotion that caused it was structurally unknowable after the fact. Log
+// once per distinct reason (not once per call — a hot per-op catch could
+// otherwise spam stderr on every single memory operation) so the first
+// occurrence is attributable. Stderr only — never stdout, which callers may
+// be parsing as JSON.
+const loggedDemotions = new Set();
+function logDemotionOnce(where, reason) {
+    const dedupeKey = `${where}:${reason}`;
+    if (loggedDemotions.has(dedupeKey))
+        return;
+    loggedDemotions.add(dedupeKey);
+    try {
+        process.stderr.write(`[memory-bridge] demoted to sql.js fallback in ${where}: ${reason}\n`);
+    }
+    catch { /* stderr unavailable — nothing more we can do */ }
+}
 /**
  * Resolve database path with path traversal protection.
  * Only allows paths within or below the project's working directory,
@@ -350,9 +372,10 @@ async function getRegistry(dbPath) {
                 bridgeAvailable = true;
                 return registry;
             }
-            catch {
+            catch (err) {
                 bridgeAvailable = false;
                 registryPromise = null;
+                logDemotionOnce('getRegistry (process-wide, cached for the rest of this process)', err instanceof Error ? err.message : String(err));
                 return null;
             }
         })();
@@ -737,7 +760,8 @@ export async function bridgeStoreEntry(options) {
             attested: true,
         };
     }
-    catch {
+    catch (err) {
+        logDemotionOnce('bridgeStoreEntry', err instanceof Error ? err.message : String(err));
         return null;
     }
 }
@@ -1017,7 +1041,8 @@ export async function bridgeGetEntry(options) {
         await cacheSet(registry, cacheKey, entry);
         return { success: true, found: true, cacheHit: false, entry };
     }
-    catch {
+    catch (err) {
+        logDemotionOnce('bridgeGetEntry', err instanceof Error ? err.message : String(err));
         return null;
     }
 }
@@ -1077,7 +1102,8 @@ export async function bridgeDeleteEntry(options) {
             guarded: true,
         };
     }
-    catch {
+    catch (err) {
+        logDemotionOnce('bridgeDeleteEntry', err instanceof Error ? err.message : String(err));
         return null;
     }
 }
@@ -1128,7 +1154,8 @@ export async function bridgePurgeNamespace(options) {
             guarded: true,
         };
     }
-    catch {
+    catch (err) {
+        logDemotionOnce('bridgePurgeNamespace', err instanceof Error ? err.message : String(err));
         return null;
     }
 }

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

@@ -35,6 +35,33 @@ function isRuvectorCoreResolvable() {
     }
     return _ruvectorCoreResolvable;
 }
+/**
+ * #2735 — before a whole-image sql.js read-modify-persist (export() +
+ * rename over the live database path), refuse if there is evidence of a
+ * live native (better-sqlite3) WAL connection: `-wal`/`-shm` sidecar files
+ * on disk. A native connection in WAL mode keeps its sidecars present for
+ * its entire lifetime (removed only on the last connection's clean close),
+ * so their presence is strong evidence of a live native holder — and their
+ * absence means the image is a clean, checkpointed, standalone file that
+ * sql.js can safely read-modify-write.
+ *
+ * This is a scoped-down version of the fuller "scan live process holders"
+ * design discussed in #2735: it does not close the narrow assess-then-write
+ * race (a native opener could still attach in the gap between this check
+ * and the write), but it directly closes the demonstrated corruption
+ * mechanism — a whole-image write proceeding while an ALREADY-OPEN native
+ * connection's sidecars are on disk — with no platform-specific process
+ * scanning. Fails closed (treats a stat error as "unsafe") because this is
+ * a safety gate, not a best-effort probe.
+ */
+function hasNativeWalSidecars(dbPath) {
+    try {
+        return fs.existsSync(`${dbPath}-wal`) || fs.existsSync(`${dbPath}-shm`);
+    }
+    catch {
+        return true;
+    }
+}
 /**
  * #1854: previously every site that needed the memory directory hardcoded
  * `getMemoryRoot()`, so the documented config entry
@@ -2304,6 +2331,22 @@ export async function storeEntry(options) {
         if (!fs.existsSync(dbPath)) {
             return { success: false, id: '', error: 'Database not initialized. Run: claude-flow memory init' };
         }
+        // #2735 — refuse an unsafe whole-image write while a native WAL
+        // connection appears to be attached (sidecars on disk). See
+        // hasNativeWalSidecars()'s doc comment for the corruption mechanism
+        // this closes and its known residual (the narrow assess-then-write
+        // race). This check gates ensureSchemaColumns()'s own whole-image
+        // write below too, not just this function's.
+        if (hasNativeWalSidecars(dbPath)) {
+            return {
+                success: false,
+                id: '',
+                error: 'memory database has an active native WAL connection ' +
+                    '(found -wal/-shm sidecar files) — refusing an unsafe sql.js ' +
+                    'whole-image write. Retry once the native writer completes, or ' +
+                    'restore the native better-sqlite3 bridge.',
+            };
+        }
         // Ensure schema has all required columns (migration for older DBs)
         await ensureSchemaColumns(dbPath);
         const initSqlJs = (await import('sql.js')).default;
@@ -2672,6 +2715,20 @@ export async function getEntry(options) {
         if (!fs.existsSync(dbPath)) {
             return { success: false, found: false, error: 'Database not found' };
         }
+        // #2735 — see storeEntry's identical gate for the corruption mechanism
+        // this closes. Applies here too because the fallback's access_count
+        // bump is itself a whole-image write, not a lightweight read, even
+        // though this function's contract reads as a "get".
+        if (hasNativeWalSidecars(dbPath)) {
+            return {
+                success: false,
+                found: false,
+                error: 'memory database has an active native WAL connection ' +
+                    '(found -wal/-shm sidecar files) — refusing an unsafe sql.js ' +
+                    'whole-image read/write. Retry once the native writer completes, ' +
+                    'or restore the native better-sqlite3 bridge.',
+            };
+        }
         // Ensure schema has all required columns (migration for older DBs)
         await ensureSchemaColumns(dbPath);
         const initSqlJs = (await import('sql.js')).default;
@@ -2783,6 +2840,21 @@ export async function deleteEntry(options) {
                 error: 'Database not found'
             };
         }
+        // #2735 — see storeEntry's identical gate for the corruption mechanism
+        // this closes.
+        if (hasNativeWalSidecars(dbPath)) {
+            return {
+                success: false,
+                deleted: false,
+                key,
+                namespace,
+                remainingEntries: 0,
+                error: 'memory database has an active native WAL connection ' +
+                    '(found -wal/-shm sidecar files) — refusing an unsafe sql.js ' +
+                    'whole-image write. Retry once the native writer completes, or ' +
+                    'restore the native better-sqlite3 bridge.',
+            };
+        }
         // Ensure schema has all required columns (migration for older DBs)
         await ensureSchemaColumns(dbPath);
         const initSqlJs = (await import('sql.js')).default;

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.32.8",
+  "version": "3.32.9",
   "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",
@@ -115,6 +115,7 @@
     "@claude-flow/security": "^3.0.0-alpha.12",
     "agentdb": "^3.0.0-alpha.17",
     "agentic-flow": "^3.0.0-alpha.1",
+    "better-sqlite3": "^12.9.0",
     "ruvector": "^0.2.27"
   },
   "publishConfig": {
@@ -130,6 +131,7 @@
     "@opentelemetry/resources": ">=2.8.0",
     "@opentelemetry/sdk-trace-base": ">=2.8.0",
     "@opentelemetry/sdk-node": ">=0.220.0",
-    "agentdb": "$agentdb"
+    "agentdb": "$agentdb",
+    "better-sqlite3": "^12.9.0"
   }
 }