@claude-flow/cli 3.53.0 → 3.54.1

package/dist/src/blocking-stdio.js

@@ -0,0 +1,23 @@
+/**
+ * #3851: stdout/stderr writes to a pipe are asynchronous on POSIX, so the
+ * `process.exit()` calls that follow a command (bin wrappers, CLI.run error
+ * paths, commands that exit themselves) discard whatever the consumer has not
+ * read yet, i.e. everything past the pipe buffer (64 KiB). Switching the pipe
+ * handles to blocking mode makes every write complete before it returns, so
+ * every exit path is safe. Same technique as the MCP stdio server.
+ * Files and TTYs are already synchronous and are left alone.
+ */
+export function ensureBlockingStdio() {
+    for (const stream of [process.stdout, process.stderr]) {
+        const s = stream;
+        if (s.isTTY)
+            continue;
+        try {
+            s._handle?.setBlocking?.(true);
+        }
+        catch {
+            // best effort: never fail the CLI because stdio could not be switched
+        }
+    }
+}
+//# sourceMappingURL=blocking-stdio.js.map

package/dist/src/commands/memory.js

@@ -9,6 +9,7 @@ import { distillCommand } from './memory-distill.js';
 import { backupCommand } from './memory-backup.js';
 import { countSiblingStoreRows } from '../memory/sibling-store.js';
 import { resolveDbPath } from '../memory/memory-initializer.js';
+import { MAX_LIST_EMBEDDINGS } from '../memory/embedding-q8.js';
 import { existsSync } from 'node:fs';
 import { siblingAgentDbPath } from '../memory/memory-bridge.js';
 import { validateIdentifier } from '../mcp-tools/validate-input.js';
@@ -778,16 +779,23 @@ const listCommand = {
             type: 'number',
             default: 20
         },
+        {
+            name: 'embeddings',
+            description: `ADR-472: with --format json, add each entry's stored embedding as int8+scale (embeddingQ8: {dims, scale, b64}); read-only, at most ${MAX_LIST_EMBEDDINGS} entries per call`,
+            type: 'boolean',
+            default: false
+        },
         DB_PATH_OPTION
     ],
     action: async (ctx) => {
         const namespace = ctx.flags.namespace;
         const limit = ctx.flags.limit;
+        const includeEmbedding = ctx.flags.embeddings === true && ctx.flags.format === 'json';
         // Use sql.js directly for consistent data access
         try {
             const { listEntries, resolveDbPath: _rdbList } = await import('../memory/memory-initializer.js');
             const dbPathList = _rdbList(ctx.flags.path);
-            const listResult = await listEntries({ namespace, limit, offset: 0, dbPath: dbPathList });
+            const listResult = await listEntries({ namespace, limit, offset: 0, dbPath: dbPathList, ...(includeEmbedding && { includeEmbedding: true }) });
             if (!listResult.success) {
                 output.printError(`Failed to list: ${listResult.error}`);
                 return { success: false, exitCode: 1 };

package/dist/src/commands/session.js

@@ -7,6 +7,8 @@ import { confirm, input, select } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import * as fs from 'fs';
 import * as path from 'path';
+import { stringify as stringifyYaml } from 'yaml';
+import { gzipSync, gunzipSync } from 'node:zlib';
 // Format date for display
 function formatDate(dateStr) {
     if (!dateStr)
@@ -561,7 +563,7 @@ const exportCommand = {
             // Format output
             let content;
             if (exportFormat === 'yaml') {
-                content = toSimpleYaml(result.data);
+                content = stringifyYaml(result.data);
             }
             else {
                 content = JSON.stringify(result.data, null, 2);
@@ -570,7 +572,8 @@ const exportCommand = {
             const absolutePath = path.isAbsolute(outputPath)
                 ? outputPath
                 : path.join(ctx.cwd, outputPath);
-            fs.writeFileSync(absolutePath, content, 'utf-8');
+            const bytes = compress ? gzipSync(content) : Buffer.from(content, 'utf-8');
+            fs.writeFileSync(absolutePath, bytes);
             spinner.succeed('Session exported');
             output.writeln();
             // session_export returns the whole record under `data`; its stats live there.
@@ -587,14 +590,14 @@ const exportCommand = {
                     { property: 'Agents', value: exportStats.agentCount ?? exportStats.agents ?? 0 },
                     { property: 'Tasks', value: exportStats.taskCount ?? exportStats.tasks ?? 0 },
                     { property: 'Memory Entries', value: exportStats.memoryEntries ?? 0 },
-                    { property: 'File Size', value: formatSize(content.length) }
+                    { property: 'File Size', value: formatSize(bytes.length) }
                 ]
             });
             output.writeln();
             output.printSuccess(`Session exported to ${outputPath}`);
             return {
                 success: true,
-                data: { sessionId, outputPath, format: exportFormat, size: content.length }
+                data: { sessionId, outputPath, format: exportFormat, size: bytes.length }
             };
         }
         catch (error) {
@@ -647,9 +650,11 @@ const importCommand = {
         try {
             // The YAML written by `session export --format yaml` is display-only;
             // there is no YAML parser here, so say so instead of failing obscurely.
-            if (absolutePath.endsWith('.yaml') || absolutePath.endsWith('.yml')) {
+            if (/\.ya?ml(?:\.gz)?$/i.test(absolutePath)) {
                 try {
-                    JSON.parse(fs.readFileSync(absolutePath, 'utf-8'));
+                    const bytes = fs.readFileSync(absolutePath);
+                    const content = bytes[0] === 0x1f && bytes[1] === 0x8b ? gunzipSync(bytes) : bytes;
+                    JSON.parse(content.toString('utf-8'));
                 }
                 catch {
                     spinner.fail('Failed to import session');
@@ -783,37 +788,6 @@ function formatDuration(ms) {
     }
     return `${seconds}s`;
 }
-function toSimpleYaml(obj, indent = 0) {
-    // Simple YAML serializer (for basic types)
-    if (obj === null)
-        return 'null';
-    if (typeof obj === 'boolean')
-        return String(obj);
-    if (typeof obj === 'number')
-        return String(obj);
-    if (typeof obj === 'string')
-        return obj.includes(':') ? `"${obj}"` : obj;
-    const spaces = '  '.repeat(indent);
-    let result = '';
-    if (Array.isArray(obj)) {
-        for (const item of obj) {
-            result += `${spaces}- ${toSimpleYaml(item, indent + 1).trim()}\n`;
-        }
-        return result;
-    }
-    if (typeof obj === 'object') {
-        for (const [key, value] of Object.entries(obj)) {
-            if (typeof value === 'object' && value !== null) {
-                result += `${spaces}${key}:\n${toSimpleYaml(value, indent + 1)}`;
-            }
-            else {
-                result += `${spaces}${key}: ${toSimpleYaml(value, indent)}\n`;
-            }
-        }
-        return result;
-    }
-    return String(obj);
-}
 // Main session command
 export const sessionCommand = {
     name: 'session',

package/dist/src/index.js

@@ -19,6 +19,7 @@ import { output } from './output.js';
 import { commands, getCommandsByCategory, getCommand, getCommandAsync, getCommandNames, getLazyCommandNames, hasCommand } from './commands/index.js';
 import { suggestCommand } from './suggest.js';
 import { runStartupUpdateCheck } from './update/index.js';
+import { ensureBlockingStdio } from './blocking-stdio.js';
 // Read version from package.json at runtime
 function getPackageVersion() {
     try {
@@ -66,6 +67,8 @@ export class CLI {
      * Run the CLI with given arguments
      */
     async run(args = process.argv.slice(2)) {
+        // #3851: keep piped output intact across the process.exit() calls below
+        ensureBlockingStdio();
         try {
             // #1791.2 — If the user invoked a lazy command (e.g. `hive-mind task`),
             // pre-load it BEFORE parsing so the parser can build scoped flag

package/dist/src/init/executor.js

@@ -1464,6 +1464,7 @@ data/
 logs/
 sessions/
 neural/
+console/
 *.log
 *.tmp
 `;

package/dist/src/init/helpers-generator.js

@@ -436,6 +436,7 @@ module.exports = commands;
 // Literal-word root guard mirrored in the mod and both shipped classic helpers.
 const ROOT_DELETE_CHECK_SOURCE = String.raw `function hasRootDelete(command, depth = 0) {
   let word = '', quote = '', started = false, redirect = false
+  let ansiNul = false // a NUL inside $'...' ends that string, as in bash
   let inRm = false, optionsEnded = false, recursive = false, force = false, root = false
   const isRoot = (operand) => {
     if (!operand.startsWith('/')) return false
@@ -447,22 +448,55 @@ const ROOT_DELETE_CHECK_SOURCE = String.raw `function hasRootDelete(command, dep
     }
     return parts.length === 0 || /[*?\[]/.test(parts[0])
   }
+  // One backslash escape inside $'...', from the character after the backslash.
+  // Returns the text it stands for and the index of its last character. An unknown escape keeps its backslash.
+  // The command arrives lowercased, so an uppercase-U escape reads as a lowercase one: eight digits starting 0000 are one code point.
+  const ansiEscape = (s, at) => {
+    const c = s[at]
+    const simple = { a: '\x07', b: '\b', e: '\x1b', f: '\f', n: '\n', r: '\r', t: '\t', v: '\v', '\\': '\\', "'": "'", '"': '"', '?': '?' }
+    if (simple[c] !== undefined) return [simple[c], at]
+    const digits = (from, max, pattern) => pattern.exec(s.slice(from, from + max))?.[0]
+    const octal = digits(at, 3, /^[0-7]+/)
+    if (octal) return [String.fromCharCode(parseInt(octal, 8) & 255), at + octal.length - 1]
+    const hex = c === 'x' ? digits(at + 1, 2, /^[0-9a-f]+/) : undefined
+    if (hex) return [String.fromCharCode(parseInt(hex, 16)), at + hex.length]
+    const wide = c === 'u' ? (digits(at + 1, 8, /^0000[0-9a-f]{4}$/) ?? digits(at + 1, 4, /^[0-9a-f]+/)) : undefined
+    if (wide) return [String.fromCodePoint(parseInt(wide, 16)), at + wide.length]
+    if (c === 'c' && at + 1 < s.length) return [String.fromCharCode(s.charCodeAt(at + 1) & 31), at + 1]
+    return ['\\' + c, at]
+  }
   const finishWord = () => {
     if (!started) return false
     // Literal shell strings (e.g. sh -c 'rm -rf /') also carried the old guard.
     // Bound rescanning to four levels; beyond that retain its conservative check.
-    if (word.includes('rm') && /[\s;&|()]/.test(word)) {
+    if (/[\s;&|()\x60]/.test(word)) {
       if (depth < 4 ? hasRootDelete(word, depth + 1) : word.includes('rm -rf /')) return true
     }
     if (!inRm) inRm = word === 'rm' || word.endsWith('/rm')
     else if (!optionsEnded && word === '--') optionsEnded = true
     else if (!optionsEnded && word.startsWith('-')) {
-      recursive = recursive || word === '--recursive' || /^-[a-z]*r[a-z]*$/.test(word)
-      force = force || word === '--force' || /^-[a-z]*f[a-z]*$/.test(word)
+      // GNU getopt accepts any unambiguous long-option prefix: --r, --recur, --forc.
+      recursive = recursive || (word.length > 2 && '--recursive'.startsWith(word)) || /^-[a-z]*r[a-z]*$/.test(word)
+      force = force || (word.length > 2 && '--force'.startsWith(word)) || /^-[a-z]*f[a-z]*$/.test(word)
     } else root = root || isRoot(word)
     word = ''; started = false
     return inRm && recursive && force && root
   }
+  // A command substitution's body, from just after its opening backtick. Bash removes a
+  // backslash only before $, a backtick or a backslash (and " inside double quotes) and
+  // drops backslash-newline; any other backslash stays for the nested scan.
+  const substitution = (from, inDouble) => {
+    let body = '', j = from
+    for (; j < command.length && command[j] !== '\x60'; j++) {
+      const next = command[j + 1]
+      if (command[j] === '\\' && j + 1 < command.length) {
+        if (next === '\n') { j++; continue }
+        if (next === '$' || next === '\x60' || next === '\\' || (inDouble && next === '"')) { body += next; j++; continue }
+      }
+      body += command[j]
+    }
+    return [j, depth < 4 ? hasRootDelete(body, depth + 1) : body.includes('rm -rf /')]
+  }
   const finishCommand = () => {
     const denied = inRm && recursive && force && root
     inRm = optionsEnded = recursive = force = root = false
@@ -473,7 +507,25 @@ const ROOT_DELETE_CHECK_SOURCE = String.raw `function hasRootDelete(command, dep
     const redirectionAmpersand = char === '&' && (redirect || command[i + 1] === '>')
     redirect = false
     if (quote) {
+      if (quote === "$'") {
+        if (char === "'") { quote = ''; ansiNul = false }
+        else if (char === '\\' && i + 1 < command.length) {
+          const [text, last] = ansiEscape(command, i + 1)
+          i = last
+          if (!ansiNul) { const nul = text.indexOf('\0'); if (nul < 0) word += text; else { word += text.slice(0, nul); ansiNul = true } }
+        } else if (!ansiNul) word += char
+        continue
+      }
       if (char === quote) quote = ''
+      else if (quote === '"' && char === '\x60' && command.indexOf('\x60', i + 1) > i) {
+        const [end, denied] = substitution(i + 1, true)
+        if (denied) return true
+        // The substitution is gone from the word, as bash's empty output is (a quoted empty substitution glued to -rf leaves -rf).
+        // A # right after it is still inside the word: a placeholder keeps a rescan (sh -c "...")
+        // from reading it as the start of a comment.
+        if (command[end + 1] === '#') word += '\u0001'
+        i = end
+      }
       else if (quote === '"' && char === '\\' && i + 1 < command.length &&
         (command[i + 1] === '"' || command[i + 1] === '\\' || command[i + 1] === '$' ||
           command.charCodeAt(i + 1) === 96 || command[i + 1] === '\n')) {
@@ -485,6 +537,16 @@ const ROOT_DELETE_CHECK_SOURCE = String.raw `function hasRootDelete(command, dep
     if (char === '\\' && i + 1 < command.length) {
       const next = command[++i]
       if (next !== '\n') { word += next; started = true }
+    } else if (char === '\x60' && command.indexOf('\x60', i + 1) > i) {
+      // Command substitution: scan the body as its own command; the substitution
+      // stays inside the enclosing word, so the rm being parsed keeps its state,
+      // and the word has started (a # right after it is not a comment).
+      const [end, denied] = substitution(i + 1, false)
+      if (denied) return true
+      i = end; started = true
+    } else if (char === '$' && (command[i + 1] === "'" || command[i + 1] === '"')) {
+      // ANSI-C ($'...': escapes decoded) and locale ($"...") quoting: the $ is not part of the word.
+      quote = command[i + 1] === "'" ? "$'" : '"'; started = true; i++
     } else if (char === '"' || char === "'") {
       quote = char; started = true
     } else if (char === '#' && !started) {

package/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/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/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/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/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/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/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/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/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/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/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);
             }
         }