@claude-flow/cli 3.38.0 → 3.38.1

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

@@ -1,6 +1,6 @@
 {
   "manifest": {
-    "version": "3.38.0",
+    "version": "3.38.1",
     "files": {
       "auto-memory-hook.mjs": "85fe05c757421c52137c0bc8545a0896bab6b4714538c2a11d1d0835bfcc8c1c",
       "hook-handler.cjs": "dae295fb9ae2626b89899c19a20cc911541af82b52d2eeb9b214d618b96e9a86",
@@ -8,6 +8,6 @@
       "statusline.cjs": "0457fe53f8cd2c56458ff178392536a5868efd1a573665fa43bc01d2d95ca677"
     }
   },
-  "signature": "KDmhF8M4Fz1bTODUCbObwx77UqNUnPWCiF/k/TrpKlga0vFmu0Ax1k/JAPKLi5LmVvtZBpl1NWKm+SHnavP+Cg==",
+  "signature": "TN6Fpt7mR59UgYj2KM7wxDSHnm16eeq2BlouGa8YAxI+ZbrePbCpIUfUMNhED5vSbEPJhRvbiMnfO5JsYI8CBA==",
   "algorithm": "ed25519"
 }

package/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 4,
-  "generatedAt": "2026-08-11T22:42:24.276Z",
-  "gitSha": "6b01dc5a",
+  "generatedAt": "2026-08-12T14:05:18.962Z",
+  "gitSha": "b8c37da8",
   "catalog": {
     "agents": 164,
     "tools": 397,

package/dist/src/commands/memory.js

@@ -214,7 +214,15 @@ const storeCommand = {
                 ]
             });
             output.writeln();
-            output.printSuccess('Data stored successfully');
+            if (result.persistWarning) {
+                // #2968: the write ran, but the checkpoint signal indicates it may
+                // not have reached disk (sql.js fallback driver) — do not print an
+                // unconditional green success for a write that might vanish.
+                output.printWarning(`Data stored, but persistence is not guaranteed: ${result.persistWarning}`);
+            }
+            else {
+                output.printSuccess('Data stored successfully');
+            }
             return { success: true, data: { ...storeData, id: result.id, embedding: result.embedding, provenanceType: provenance || 'unknown' } };
         }
         catch (error) {

package/dist/src/memory/memory-bridge.d.ts

@@ -67,6 +67,13 @@ export declare function bridgeStoreEntry(options: {
     cached?: boolean;
     attested?: boolean;
     error?: string;
+    /** #2968: set when the post-write checkpoint failed in a way that
+     *  indicates this connection may not durably persist writes at all
+     *  (the sql.js fallback driver, engaged when better-sqlite3's native
+     *  binding is missing). The write above still ran and `success` is
+     *  still true — this is advisory, not a failure — but callers should
+     *  surface it instead of only printing an unconditional success message. */
+    persistWarning?: string;
 } | null>;
 /**
  * Search entries via AgentDB v3.

package/dist/src/memory/memory-bridge.js

@@ -897,12 +897,27 @@ export async function bridgeStoreEntry(options) {
         // `sqlite3` vector count) then see a stale/empty main DB file and report
         // "0 vectors" / empty search. A PASSIVE checkpoint flushes committed pages
         // into the main file without blocking writers. Best-effort, never fatal.
+        let persistWarning;
         try {
             if (typeof ctx.db.pragma === 'function') {
                 ctx.db.pragma('wal_checkpoint(PASSIVE)');
             }
         }
-        catch { /* non-WAL, busy, or unsupported — non-fatal */ }
+        catch (checkpointErr) {
+            // #2968: on the sql.js fallback driver (engaged when better-sqlite3's
+            // native binding never got built — e.g. a skipped optionalDependency
+            // postinstall), this PRAGMA isn't implemented and throws "Invalid
+            // PRAGMA command". sql.js has no WAL journal to checkpoint at all, so
+            // this specific failure is the strongest signal available here that
+            // the insert above may exist only in this process's in-memory image
+            // and never reach disk — not the ordinary "non-WAL, busy, or
+            // unsupported" case the old blanket catch assumed. Surface it rather
+            // than swallow it silently; other pragma failures stay non-fatal.
+            const msg = checkpointErr instanceof Error ? checkpointErr.message : String(checkpointErr);
+            if (/Invalid PRAGMA/i.test(msg)) {
+                persistWarning = `sql.js fallback driver in use — this write may not be durably persisted to disk (${msg}). Install better-sqlite3's native binding to restore durable writes (see issue #2968: npm rebuild better-sqlite3, or reinstall with install scripts enabled).`;
+            }
+        }
         // Phase 2: Write-through to TieredCache
         const safeNs = String(namespace).replace(/:/g, '_');
         const safeKey = String(key).replace(/:/g, '_');
@@ -918,6 +933,7 @@ export async function bridgeStoreEntry(options) {
             guarded: true,
             cached: true,
             attested: true,
+            ...(persistWarning ? { persistWarning } : {}),
         };
     }
     catch (err) {
@@ -995,10 +1011,17 @@ export async function bridgeSearchEntries(options) {
         const whereExtra = filters.length > 0 ? `AND ${filters.join(' AND ')}` : '';
         let rows;
         try {
+            // #2982/#2976: this pre-rank SELECT truncates the corpus to 1000 rows
+            // before BM25/embedding scoring runs. Without ORDER BY, SQLite returns
+            // rows in arbitrary storage order (effectively oldest-inserted-first at
+            // scale), so on any corpus over 1000 entries the newest — and often
+            // most relevant — rows never reach scoring at all. bridgeListEntries()
+            // already orders by updated_at DESC for the same reason; mirror it here.
             const stmt = ctx.db.prepare(`
         SELECT id, key, namespace, content, embedding, provenance_type
         FROM memory_entries
         WHERE ${ACTIVE_MEMORY_ROW_SQL} ${whereExtra}
+        ORDER BY updated_at DESC
         LIMIT 1000
       `);
             rows = filterParams.length > 0 ? stmt.all(...filterParams) : stmt.all();
@@ -1506,10 +1529,14 @@ export async function bridgeSearchHNSW(queryEmbedding, options, dbPath) {
             : '';
         let rows;
         try {
+            // #2982/#2976: same unordered pre-rank truncation as bridgeSearchEntries
+            // above — without ORDER BY, a corpus over 10000 rows silently drops
+            // its newest entries before cosine scoring ever runs.
             const stmt = ctx.db.prepare(`
         SELECT id, key, namespace, content, embedding
         FROM memory_entries
         WHERE status = 'active' AND embedding IS NOT NULL ${nsFilter}
+        ORDER BY updated_at DESC
         LIMIT 10000
       `);
             rows = nsFilter

package/dist/src/memory/memory-initializer.d.ts

@@ -448,6 +448,9 @@ export declare function storeEntry(options: {
         model: string;
     };
     error?: string;
+    /** #2968: set when the bridge's checkpoint failed in a way indicating
+     *  this write may not be durably persisted (sql.js fallback driver). */
+    persistWarning?: string;
 }>;
 /**
  * Search entries using sql.js with vector similarity

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.38.0",
+  "version": "3.38.1",
   "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",