@claude-flow/cli 3.33.0 → 3.35.0

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

@@ -2392,7 +2392,18 @@ export async function bridgeHealthCheck(dbPath) {
             const s = cache.stats();
             cacheStats = { size: s.size ?? 0, hits: s.hits ?? 0, misses: s.misses ?? 0 };
         }
-        return { available: true, controllers, attestationCount, cacheStats };
+        // #2887: cacheStats alone let a "successful" hierarchical-store coexist
+        // with an empty store. Report the backing table's real row count so the
+        // inconsistency is visible instead of inferred.
+        let hierarchicalMemory;
+        const hm = registry.get('hierarchicalMemory');
+        if (hm) {
+            hierarchicalMemory = {
+                ...describeHierarchicalStore(hm, getHierarchicalFallback(registry)),
+                persistedRows: typeof hm.countPersisted === 'function' ? hm.countPersisted() : null,
+            };
+        }
+        return { available: true, controllers, attestationCount, cacheStats, hierarchicalMemory };
     }
     catch {
         return null;
@@ -2417,6 +2428,34 @@ export async function bridgeHealthCheck(dbPath) {
  *   temporal fields are stored in metadata, and supersede is reported as
  *   unsupported (no public update API) rather than silently dropped.
  */
+/**
+ * Describe which store `agentdb_hierarchical-*` actually landed on and
+ * whether its writes survive the process (#2887).
+ *
+ * agentdb removed its `HierarchicalMemory` export at 3.0.0-alpha.17, so the
+ * @claude-flow/memory TieredMemoryStore fallback is the live path. It is only
+ * durable when it was handed a SQLite connection — callers must not report a
+ * volatile write as a success.
+ */
+export function describeHierarchicalStore(hm, fallback) {
+    // Only the tiered fallback exposes isDurable(); the native controller
+    // (should agentdb reintroduce it) writes to agentdb's own tables.
+    if (typeof hm?.isDurable !== 'function') {
+        return { controller: 'hierarchicalMemory', durable: true, persistence: 'agentdb' };
+    }
+    return {
+        controller: 'tieredMemoryStore',
+        fallbackFrom: fallback?.reason ?? 'hierarchicalMemory',
+        durable: hm.isDurable() === true,
+        persistence: typeof hm.getPersistence === 'function' ? hm.getPersistence() : 'unknown',
+    };
+}
+/** Read `getHierarchicalFallback()` off a registry that may predate it. */
+function getHierarchicalFallback(registry) {
+    return typeof registry?.getHierarchicalFallback === 'function'
+        ? registry.getHierarchicalFallback()
+        : null;
+}
 export async function bridgeHierarchicalStore(params) {
     const registry = await getRegistry();
     if (!registry)
@@ -2439,7 +2478,10 @@ export async function bridgeHierarchicalStore(params) {
                 metadata,
                 tags: [params.key],
             });
-            const result = { success: true, id, key: params.key, tier };
+            const result = {
+                success: true, id, key: params.key, tier,
+                controller: 'hierarchicalMemory', durable: true, persistence: 'agentdb',
+            };
             if (params.supersedes) {
                 // No public update/invalidate API on agentdb HierarchicalMemory —
                 // surface the limitation honestly instead of silently dropping it.
@@ -2448,17 +2490,28 @@ export async function bridgeHierarchicalStore(params) {
             }
             return result;
         }
-        // TieredMemoryStore fallback (temporal-aware) / legacy stub
+        // TieredMemoryStore fallback (temporal-aware) / legacy stub.
+        // agentdb dropped its HierarchicalMemory export at 3.0.0-alpha.17, so
+        // this is the live path — and it is only trustworthy when the store is
+        // backed by SQLite. A volatile write must NOT report success (#2887).
         const storeResult = hm.store(params.key, params.value, tier, {
             validFrom: params.validFrom,
             validUntil: params.validUntil,
             supersedes: params.supersedes,
         });
-        if (storeResult && typeof storeResult === 'object') {
-            return { success: true, ...storeResult };
+        const info = describeHierarchicalStore(hm, getHierarchicalFallback(registry));
+        const base = {
+            ...info,
+            ...(storeResult && typeof storeResult === 'object' ? storeResult : { key: params.key, tier }),
+        };
+        if (!info.durable) {
+            return {
+                ...base,
+                success: false,
+                error: `hierarchical-store is running on the ${info.persistence} tiered fallback (${info.fallbackFrom}); the entry is NOT persisted to disk and will be lost when this process exits. Use memory_store for durable key-value persistence.`,
+            };
         }
-        // Legacy stub (returns void) — temporal options were ignored
-        return { success: true, key: params.key, tier };
+        return { success: true, ...base };
     }
     catch (e) {
         return { success: false, error: e.message };
@@ -2523,7 +2576,7 @@ export async function bridgeHierarchicalRecall(params) {
         const filtered = params.tier
             ? results.filter((r) => r.tier === params.tier)
             : results;
-        return { results: filtered, controller: 'hierarchicalMemory' };
+        return { results: filtered, ...describeHierarchicalStore(hm, getHierarchicalFallback(registry)) };
     }
     catch (e) {
         return { results: [], error: e.message };

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

@@ -547,9 +547,15 @@ export declare function deleteEntry(options: {
 }>;
 /**
  * Advisory O_EXCL lock scoped to a single memory.db file (`<dbPath>.lock`),
- * same stale-takeover pattern as services/global-ai-budget.ts. Only
- * meaningful between callers that opt into it (purgeNamespace does); it
- * cannot coordinate against writers that don't call this helper.
+ * same stale-takeover pattern as services/global-ai-budget.ts.
+ *
+ * #2878: sql.js persists by rewriting the whole database image, so every
+ * `load → mutate → export → write` sequence is a read-modify-write that a
+ * concurrent writer can clobber — both callers report success and the loser's
+ * rows vanish, with `PRAGMA integrity_check` still clean. Every such sequence
+ * in this module now runs inside this lock. It is advisory, so it still
+ * cannot coordinate against a writer that bypasses this module entirely
+ * (a native WAL connection — see hasNativeWalSidecars).
  */
 export declare function withMemoryDbLock<T>(dbPath: string, fn: () => Promise<T> | T): Promise<T>;
 export declare function purgeNamespace(options: {