@claude-flow/cli 3.42.4 → 3.43.0

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

@@ -1,6 +1,6 @@
 {
   "manifest": {
-    "version": "3.42.4",
+    "version": "3.43.0",
     "files": {
       "auto-memory-hook.mjs": "85fe05c757421c52137c0bc8545a0896bab6b4714538c2a11d1d0835bfcc8c1c",
       "hook-handler.cjs": "209d9fafe10e17d1be0866727f6f9cf9ac66f9a0793f1c793a4f58319e8e4583",
@@ -8,6 +8,6 @@
       "statusline.cjs": "4a48353b4f1566fa4379b00fd0321b6676a22b6cc91fbbd8380ac5183d619468"
     }
   },
-  "signature": "zyopDoOW51Qkc0k2PpDbEv/puqT45lcx8EFnRQmwioIEDI/mv8KV140ZWcjEaa7lvIDW/epdB333K7bMW122Dw==",
+  "signature": "OlZvg4x9E5xfjdOatTAJz53uTxtK9dOj56GdkqnvqSWjFOKYCWWmbdijaMeVugo9e/u1y06VtWDGXrKSL82xDA==",
   "algorithm": "ed25519"
 }

package/.claude/helpers/router.js

@@ -30,7 +30,7 @@ const AGENT_CAPABILITIES = {
 const TASK_PATTERNS = [
   // Code patterns
   { tokens: ['implement', 'create', 'build', 'add', 'write code', 'refactor', 'debug'], agent: 'coder' },
-  { tokens: ['test', 'tests', 'spec', 'coverage', 'unit test', 'integration test'], agent: 'tester' },
+  { tokens: ['test', 'tests', 'testing', 'spec', 'specs', 'coverage', 'unit test', 'integration test'], agent: 'tester' },
   { tokens: ['review', 'audit', 'check', 'validate', 'security'], agent: 'reviewer' },
   { tokens: ['research', 'find', 'search', 'documentation', 'explore'], agent: 'researcher' },
   { tokens: ['design', 'architect', 'architecture', 'structure', 'plan'], agent: 'architect' },

package/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 6,
-  "generatedAt": "2026-09-17T21:28:47.530Z",
-  "gitSha": "702d1461",
+  "generatedAt": "2026-09-23T15:00:55.000Z",
+  "gitSha": "025842bb",
   "catalog": {
     "agents": 167,
     "tools": 418,

package/dist/src/commands/doctor.js

@@ -2059,6 +2059,26 @@ async function checkMetaharness() {
         };
     }
 }
+// Opt-in @ruvector/typesafe task router (optional peer). `--component typesafe` only.
+async function checkTypesafeRouter() {
+    const name = '@ruvector/typesafe router';
+    const { readTypesafeConfig } = await import('../ruvector/typesafe-router.js');
+    const cfg = readTypesafeConfig();
+    const gate = cfg.enabled ? `enabled (${cfg.embedder === 'hash' ? 'hash embedder, uncalibrated' : 'onnx embedder'})` : 'disabled (set CLAUDE_FLOW_ROUTER_TYPESAFE=1)';
+    try {
+        const { createRequire } = await import('module');
+        const pj = createRequire(import.meta.url)('@ruvector/typesafe/package.json');
+        return { name, status: 'pass', message: `v${pj.version ?? '?'} installed; ${gate}` };
+    }
+    catch {
+        return {
+            name,
+            status: cfg.enabled ? 'warn' : 'pass',
+            message: `Not installed; ${gate} — hooks_route uses the built-in router`,
+            ...(cfg.enabled ? { fix: 'npm install @ruvector/typesafe  # optional peer' } : {}),
+        };
+    }
+}
 async function checkClaudeCode() {
     try {
         const version = await runCommand('claude --version');
@@ -2252,7 +2272,7 @@ export const doctorCommand = {
         {
             name: 'component',
             short: 'c',
-            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, mcp-overhead, claude, disk, typescript, agentic-flow, encryption, federation, funnel, proxy, auth, metaharness)',
+            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, mcp-overhead, claude, disk, typescript, agentic-flow, encryption, federation, funnel, proxy, auth, typesafe, metaharness)',
             type: 'string'
         },
         {
@@ -2435,6 +2455,7 @@ export const doctorCommand = {
             // a user would actually debug them (is it installed? running? exposed?).
             'proxy': [checkProxySponsoredConsent, checkProxyBinary, checkProxyProcess, checkProxyBindAddress],
             'auth': checkAuth, // ADR-306
+            'typesafe': checkTypesafeRouter, // opt-in @ruvector/typesafe task router
         };
         let checksToRun = allChecks;
         if (component && componentMap[component]) {

package/dist/src/commands/hooks.js

@@ -1811,6 +1811,12 @@ const postTaskCommand = {
             }
             output.writeln();
             output.printSuccess(`Task outcome recorded: ${success ? 'SUCCESS' : 'FAILED'}`);
+            // #3353: only show observed learning results; say so when degraded.
+            const lu = result.learningUpdates;
+            if (lu.available === false) {
+                output.writeln();
+                output.printWarning(`Learning degraded: ${lu.reason ?? 'feedback not recorded'} — no pattern updates were observed`);
+            }
             output.writeln();
             output.writeln(output.bold('Learning Updates'));
             output.printTable({
@@ -1819,10 +1825,10 @@ const postTaskCommand = {
                     { key: 'value', header: 'Value', width: 20, align: 'right' }
                 ],
                 data: [
-                    { metric: 'Patterns Updated', value: result.learningUpdates.patternsUpdated },
-                    { metric: 'New Patterns', value: result.learningUpdates.newPatterns },
+                    { metric: 'Patterns Updated', value: lu.patternsUpdated },
+                    { metric: 'New Patterns', value: lu.newPatterns ?? 'unknown' },
+                    { metric: 'Trajectory Recorded', value: result.trajectory ? (result.trajectory.recorded ? 'yes' : 'no') : 'unknown' },
                     { metric: 'Duration', value: `${(result.duration / 1000).toFixed(1)}s` },
-                    { metric: 'Trajectory ID', value: result.learningUpdates.trajectoryId }
                 ]
             });
             return { success: true, data: result };

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

@@ -283,7 +283,7 @@ const AGENT_CAPABILITIES = {
 // the whitespace acts as a natural boundary.
 const TASK_PATTERNS = [
   { tokens: ['implement', 'create', 'build', 'add', 'write code', 'refactor', 'debug'], agent: 'coder' },
-  { tokens: ['test', 'tests', 'spec', 'coverage', 'unit test', 'integration test'], agent: 'tester' },
+  { tokens: ['test', 'tests', 'testing', 'spec', 'specs', 'coverage', 'unit test', 'integration test'], agent: 'tester' },
   { tokens: ['review', 'audit', 'check', 'validate', 'security'], agent: 'reviewer' },
   { tokens: ['research', 'find', 'search', 'documentation', 'explore'], agent: 'researcher' },
   { tokens: ['design', 'architect', 'architecture', 'structure', 'plan'], agent: 'architect' },
@@ -329,15 +329,16 @@ function routeTask(task) {
   };
 }
 
-// CLI
-const task = process.argv.slice(2).join(' ');
-
-if (task) {
-  const result = routeTask(task);
-  console.log(JSON.stringify(result, null, 2));
-} else {
-  console.log('Usage: router.js <task description>');
-  console.log('\\nAvailable agents:', Object.keys(AGENT_CAPABILITIES).join(', '));
+// CLI — only when executed directly, not when require()d by hook-handler.cjs
+if (require.main === module) {
+  const task = process.argv.slice(2).join(' ');
+  if (task) {
+    const result = routeTask(task);
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log('Usage: router.js <task description>');
+    console.log('\\nAvailable agents:', Object.keys(AGENT_CAPABILITIES).join(', '));
+  }
 }
 
 module.exports = { routeTask, AGENT_CAPABILITIES, TASK_PATTERNS, buildPattern };

package/dist/src/mcp-tools/capability-brain.js

@@ -125,7 +125,7 @@ export const CAPABILITY_DOMAINS = [
     {
         id: 'guidance',
         name: 'Capability Guidance',
-        prefixes: ['guidance_'],
+        prefixes: ['guidance_', 'seraphina_'],
         description: 'Live capability inventory, task routing, workflow guidance, and system discovery.',
         taskSignals: ['guidance', 'discover', 'capability', 'what can ruflo do'],
         commands: ['guidance compile', 'guidance retrieve', 'guidance gates', 'guidance optimize'],
@@ -430,7 +430,7 @@ export const CAPABILITY_DOMAINS = [
         id: 'business-collaboration',
         name: 'AgentBBS & Business Pods',
         // Metadata classification only; execution remains behind the existing loadAgentbbs guard.
-        prefixes: ['agentbbs_', 'business_pod_', 'federation_bbs_'],
+        prefixes: ['agentbbs_', 'business_pod_', 'federation_bbs_', 'x_federation_'],
         description: 'Federated business rooms, domain-affinity routing, and business-pod validation.',
         taskSignals: ['business pod', 'bbs', 'room', 'domain affinity'],
         commands: [],
@@ -551,6 +551,8 @@ const TOOL_OWNERSHIP = [
     { prefixes: ['testgen_'], packageOwner: '@claude-flow/cli', pluginOwner: 'ruflo-testgen' },
     { prefixes: ['managed_agent_', 'wasm_agent_', 'wasm_gallery_'], packageOwner: '@claude-flow/cli', pluginOwner: 'ruflo-agent' },
     { prefixes: ['guidance_'], packageOwner: '@claude-flow/guidance', pluginOwner: 'ruflo-core' },
+    { prefixes: ['seraphina_'], packageOwner: '@claude-flow/cli', pluginOwner: 'ruflo-core' },
+    { prefixes: ['x_federation_'], packageOwner: '@claude-flow/cli', pluginOwner: 'ruflo-x-gateway' },
 ];
 function ownershipForTool(toolName, definition) {
     const explicit = TOOL_OWNERSHIP.find((entry) => entry.prefixes.some((prefix) => toolName.startsWith(prefix)));

package/dist/src/mcp-tools/hooks-tools.d.ts

@@ -13,6 +13,11 @@ import { type MCPTool } from './types.js';
  * the tag names untouched.
  */
 export declare function scrubReasoningBlocks(text: string): string;
+/** Exported for tests. */
+export declare function suggestAgentsForTask(task: string): {
+    agents: string[];
+    confidence: number;
+};
 export declare const hooksPreEdit: MCPTool;
 export declare const hooksPostEdit: MCPTool;
 export declare const hooksPreCommand: MCPTool;

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

@@ -9,6 +9,7 @@ import { getProjectCwd } from './types.js';
 import { validateIdentifier, validateText, validatePath } from './validate-input.js';
 import { checkCommandLoop, recordCommandOutcome } from './tool-loop-guardrail.js';
 import { buildLearnedRoutingPatterns, } from '../services/learned-routing.js';
+import { applyTypesafeRouting, getTypesafeRouter } from '../ruvector/typesafe-router.js';
 // Real vector search functions - lazy loaded to avoid circular imports
 let searchEntriesFn = null;
 /**
@@ -269,6 +270,10 @@ const TASK_PATTERNS = {
         agents: ['memory-specialist', 'architect', 'coder'],
     },
 };
+/** Wrap hooks_route so the opt-in typesafe router (src/ruvector/typesafe-router.ts) can override the legacy pick. */
+function withTypesafeRouting(legacy) {
+    return async (params) => applyTypesafeRouting(params, (await legacy(params)), TASK_PATTERNS, getTypesafeRouter());
+}
 /**
  * Get the semantic router with environment detection.
  * Tries native VectorDb first (HNSW, 16k routes/s), falls back to pure JS (47k routes/s cosine).
@@ -621,11 +626,21 @@ function suggestAgentsForFile(filePath) {
     }
     return AGENT_PATTERNS[ext] || ['coder', 'architect'];
 }
-function suggestAgentsForTask(task) {
-    const taskLower = task.toLowerCase();
+// Whole-word matchers for KEYWORD_PATTERNS. A bare `includes()` matched
+// substrings: 'test' hit "latest" (tester @ 0.95), 'auth' hit "author",
+// 'fix' hit "prefix", 'api' hit "capitalize". Single words get \b anchors plus
+// simple inflections (tests, testing, fixes, deployed); phrases containing
+// whitespace or '/' (e.g. 'ci/cd') match literally between word boundaries.
+const KEYWORD_MATCHERS = Object.entries(KEYWORD_PATTERNS).map(([keyword, result]) => {
+    const escaped = keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const body = /[\s/]/.test(keyword) ? escaped : `${escaped}(?:s|es|ing|ed)?`;
+    return { regex: new RegExp(`\\b${body}\\b`, 'i'), result };
+});
+/** Exported for tests. */
+export function suggestAgentsForTask(task) {
     // Check static keyword patterns first
-    for (const [pattern, result] of Object.entries(KEYWORD_PATTERNS)) {
-        if (taskLower.includes(pattern)) {
+    for (const { regex, result } of KEYWORD_MATCHERS) {
+        if (regex.test(task)) {
             return result;
         }
     }
@@ -950,7 +965,8 @@ export const hooksRoute = {
         },
         required: ['task'],
     },
-    handler: async (params) => {
+    // Opt-in @ruvector/typesafe augmentation (CLAUDE_FLOW_ROUTER_TYPESAFE=1); returns the legacy result unchanged when unset.
+    handler: withTypesafeRouting(async (params) => {
         const task = params.task;
         const context = params.context;
         const useSemanticRouter = params.useSemanticRouter !== false;
@@ -1131,7 +1147,7 @@ export const hooksRoute = {
                 coordination: 'queen-led',
             } : null,
         };
-    },
+    }),
 };
 export const hooksMetrics = {
     name: 'hooks_metrics',
@@ -1439,10 +1455,12 @@ export const hooksPostTask = {
         catch {
             // Non-fatal
         }
-        // Record trajectory via intelligence module (SONA + ReasoningBank)
+        // Record trajectory via intelligence module (SONA + ReasoningBank).
+        // #3353: keep the observed result instead of discarding it.
+        let trajectoryRecorded = false;
         try {
             const intelligence = await import('../memory/intelligence.js');
-            await intelligence.recordTrajectory([{ type: 'result', content: params.task || taskId, metadata: { success, agent, quality }, timestamp: Date.now() }], success ? 'success' : 'failure');
+            trajectoryRecorded = (await intelligence.recordTrajectory([{ type: 'result', content: params.task || taskId, metadata: { success, agent, quality }, timestamp: Date.now() }], success ? 'success' : 'failure')) === true;
         }
         catch {
             // Intelligence module not available — non-fatal
@@ -1582,17 +1600,32 @@ export const hooksPostTask = {
             writeFileSync(storePath, JSON.stringify(store, null, 2), 'utf-8');
         }
         catch { /* non-critical */ }
+        // #3353: report only observed learning results. The previous
+        // `feedbackResult?.updated || (success ? 2 : 1)` / `newPatterns: success ? 1 : 0`
+        // invented counts whenever the feedback controller was unavailable (and the
+        // `||` turned an observed 0 into 2). No path reports pattern *creation*, so
+        // newPatterns is null (unknown) rather than a guess; the trajectory has no
+        // real id to surface, so trajectoryId is null.
+        const feedbackRecorded = feedbackResult?.success === true;
+        const learningAvailable = feedbackRecorded;
         return {
             taskId,
             success,
             duration,
             learningUpdates: {
-                patternsUpdated: feedbackResult?.updated || (success ? 2 : 1),
-                newPatterns: success ? 1 : 0,
-                trajectoryId: `traj-${Date.now()}`,
+                patternsUpdated: feedbackRecorded ? (feedbackResult?.updated ?? 0) : 0,
+                newPatterns: null,
+                trajectoryId: null,
                 controller: feedbackResult?.controller || 'none',
                 outcomePersisted,
+                available: learningAvailable,
+                ...(learningAvailable ? {} : {
+                    reason: feedbackResult
+                        ? `feedback controller '${feedbackResult.controller}' did not record the outcome`
+                        : 'feedback controller unavailable',
+                }),
             },
+            trajectory: { recorded: trajectoryRecorded },
             quality,
             pheromone,
             feedback: feedbackResult ? {

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

@@ -61,6 +61,26 @@ function validateMemoryInput(key, value, query, namespace) {
         throw new Error('Namespace contains disallowed characters');
     }
 }
+/**
+ * #3374 — presence check for a schema-`required` string parameter.
+ *
+ * `validateMemoryInput` above is a bounds-and-charset validator: every branch
+ * is truthiness-guarded, so an omitted parameter passes it silently. Nothing
+ * else enforces `inputSchema.required` for these tools, so without this an
+ * omitted `query` travelled down to `generateHashEmbedding`'s
+ * `text.toLowerCase()` and came back as an unrelated TypeError.
+ */
+const MISSING_REQUIRED_PARAM = 'MISSING_REQUIRED_PARAM';
+function missingRequiredString(input, param, tool) {
+    const v = input[param];
+    if (typeof v === 'string' && v.length > 0)
+        return null;
+    const got = v === undefined ? 'it was omitted' : v === '' ? 'it was an empty string' : `got ${v === null ? 'null' : typeof v}`;
+    return {
+        error: `${tool}: required parameter "${param}" must be a non-empty string (${got})`,
+        code: MISSING_REQUIRED_PARAM,
+    };
+}
 // #1884 — sanitize a key produced from arbitrary input (markdown headings,
 // frontmatter names, file names) so it survives validateMemoryInput on the
 // read/delete path. Replaces every dangerous char with `_`. Truncates to
@@ -360,6 +380,10 @@ export const memoryTools = [
             required: ['key', 'value'],
         },
         handler: async (input) => {
+            const missingKey = missingRequiredString(input, 'key', 'memory_store');
+            if (missingKey) {
+                return { success: false, key: input.key, stored: false, hasEmbedding: false, ...missingKey };
+            }
             await ensureInitialized();
             const { storeEntry } = await getMemoryFunctions();
             const key = input.key;
@@ -408,6 +432,8 @@ export const memoryTools = [
                     backend: await describeBackend(),
                     storeTime: `${duration.toFixed(2)}ms`,
                     error: result.error,
+                    // #3325: why hasEmbedding is false, when the bridge could not embed.
+                    ...(result.embeddingError ? { embeddingError: result.embeddingError } : {}),
                 };
             }
             catch (error) {
@@ -432,6 +458,10 @@ export const memoryTools = [
             required: ['key'],
         },
         handler: async (input) => {
+            const missingKey = missingRequiredString(input, 'key', 'memory_retrieve');
+            if (missingKey) {
+                return { key: input.key, namespace: input.namespace, value: null, found: false, ...missingKey };
+            }
             await ensureInitialized();
             const { getEntry } = await getMemoryFunctions();
             const key = input.key;
@@ -500,6 +530,10 @@ export const memoryTools = [
             required: ['query'],
         },
         handler: async (input) => {
+            const missingQuery = missingRequiredString(input, 'query', 'memory_search');
+            if (missingQuery) {
+                return { query: input.query, results: [], total: 0, ...missingQuery };
+            }
             await ensureInitialized();
             const { searchEntries } = await getMemoryFunctions();
             const query = input.query;
@@ -664,6 +698,10 @@ export const memoryTools = [
             required: ['key'],
         },
         handler: async (input) => {
+            const missingKey = missingRequiredString(input, 'key', 'memory_delete');
+            if (missingKey) {
+                return { success: false, key: input.key, namespace: input.namespace, deleted: false, ...missingKey };
+            }
             await ensureInitialized();
             const { deleteEntry } = await getMemoryFunctions();
             const key = input.key;
@@ -1145,6 +1183,10 @@ export const memoryTools = [
             required: ['query'],
         },
         handler: async (input) => {
+            const missingQuery = missingRequiredString(input, 'query', 'memory_search_unified');
+            if (missingQuery) {
+                return { success: false, query: input.query, results: [], total: 0, ...missingQuery };
+            }
             await ensureInitialized();
             const { searchEntries, listEntries } = await getMemoryFunctions();
             validateMemoryInput(undefined, undefined, input.query);

package/dist/src/memory/graph-edge-writer.d.ts

@@ -29,6 +29,16 @@
  *
  * @module v3/cli/memory/graph-edge-writer
  */
+/**
+ * Checkpoint and close the cached handle if it is open (optionally only if it
+ * is open on `dbPath`). Returns true if a handle was released. Never throws.
+ *
+ * busy_timeout is dropped to 0 first so the TRUNCATE checkpoint cannot stall
+ * the event loop behind another connection: if another native connection is
+ * attached the sidecars stay anyway (it owns them), so a busy checkpoint loses
+ * nothing; if this is the only connection, the checkpoint is never busy.
+ */
+export declare function releaseBridgeDb(dbPath?: string): boolean;
 /**
  * Return the better-sqlite3 Database instance for graph_edges writes.
  * Creates the graph_edges table if it is absent (idempotent).

package/dist/src/memory/graph-edge-writer.js

@@ -40,6 +40,72 @@ import { encodeEmbedding } from './embedding-quantization.js';
 let _db = null;
 let _dbPath = '';
 let _dbInitializing = false;
+// #3397 — the handle used to live for the whole MCP server process, keeping
+// the -wal/-shm sidecars on disk forever; the #2735 guard then refused every
+// later sql.js whole-image write (memory_store on Windows, where the native
+// bridge is off by default). The handle is now released after a short idle
+// window, and memory-initializer releases it on demand before its guard.
+//
+// Invariant this relies on: every caller of getBridgeDb() finishes using the
+// returned handle synchronously after the await (no await between it and the
+// last `db.` call), so a release can only land between operations. If a
+// caller ever breaks that, it gets "database connection is not open", which
+// every call site already catches.
+const DEFAULT_IDLE_RELEASE_MS = 1000;
+let _idleTimer = null;
+let _exitHookInstalled = false;
+function idleReleaseMs() {
+    const configured = Number(process.env.CLAUDE_FLOW_GRAPH_EDGE_IDLE_MS);
+    return Number.isFinite(configured) && configured >= 0 ? configured : DEFAULT_IDLE_RELEASE_MS;
+}
+function armIdleRelease() {
+    if (_idleTimer)
+        clearTimeout(_idleTimer);
+    _idleTimer = setTimeout(() => { _idleTimer = null; releaseBridgeDb(); }, idleReleaseMs());
+    _idleTimer.unref?.();
+    if (!_exitHookInstalled) {
+        _exitHookInstalled = true;
+        // 'exit' (not SIGINT/SIGTERM handlers, which would change Node's default
+        // termination) — sync-only work, so a clean shutdown checkpoints and
+        // removes the sidecars instead of leaving them for the next process.
+        process.once('exit', () => { releaseBridgeDb(); });
+    }
+}
+/**
+ * Checkpoint and close the cached handle if it is open (optionally only if it
+ * is open on `dbPath`). Returns true if a handle was released. Never throws.
+ *
+ * busy_timeout is dropped to 0 first so the TRUNCATE checkpoint cannot stall
+ * the event loop behind another connection: if another native connection is
+ * attached the sidecars stay anyway (it owns them), so a busy checkpoint loses
+ * nothing; if this is the only connection, the checkpoint is never busy.
+ */
+export function releaseBridgeDb(dbPath) {
+    if (!_db)
+        return false;
+    if (dbPath !== undefined && path.resolve(dbPath) !== path.resolve(_dbPath))
+        return false;
+    if (_idleTimer) {
+        clearTimeout(_idleTimer);
+        _idleTimer = null;
+    }
+    const db = _db;
+    _db = null;
+    _dbPath = '';
+    try {
+        db.pragma('busy_timeout = 0');
+    }
+    catch { /* best-effort */ }
+    try {
+        db.pragma('wal_checkpoint(TRUNCATE)');
+    }
+    catch { /* best-effort */ }
+    try {
+        db.close();
+    }
+    catch { /* best-effort */ }
+    return true;
+}
 /**
  * Return the better-sqlite3 Database instance for graph_edges writes.
  * Creates the graph_edges table if it is absent (idempotent).
@@ -56,8 +122,10 @@ let _dbInitializing = false;
 export async function getBridgeDb(customDbPath, opts) {
     const dbPath = customDbPath ?? path.join(getMemoryRoot(), 'memory.db');
     const createIfMissing = opts?.createIfMissing === true;
-    if (_db && _dbPath === dbPath)
+    if (_db && _dbPath === dbPath) {
+        armIdleRelease();
         return _db;
+    }
     if (_dbInitializing)
         return null;
     _dbInitializing = true;
@@ -120,8 +188,12 @@ export async function getBridgeDb(customDbPath, opts) {
       CREATE INDEX IF NOT EXISTS idx_graph_edges_relation ON graph_edges (relation);
       CREATE INDEX IF NOT EXISTS idx_graph_edges_reinforced ON graph_edges (last_reinforced);
     `);
+        // A handle cached for a different path would otherwise be orphaned
+        // (still open, sidecars still on disk) by the reassignment below.
+        releaseBridgeDb();
         _db = db;
         _dbPath = dbPath;
+        armIdleRelease();
         return db;
     }
     catch {
@@ -214,6 +286,10 @@ export async function countGraphEdges(dbPath) {
  * writes deterministically, regardless of platform/timing.
  */
 export function _resetBridgeDb() {
+    if (_idleTimer) {
+        clearTimeout(_idleTimer);
+        _idleTimer = null;
+    }
     if (_db) {
         try {
             _db.pragma('wal_checkpoint(TRUNCATE)');

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

@@ -86,6 +86,10 @@ export declare function bridgeStoreEntry(options: {
      *  still true — this is advisory, not a failure — but callers should
      *  surface it instead of only printing an unconditional success message. */
     persistWarning?: string;
+    /** #3325: set when an embedding was requested but none could be produced
+     *  (agentdb embedder absent/threw AND no real local model). The row was
+     *  written without a vector, so semantic search cannot find it. */
+    embeddingError?: string;
 } | null>;
 /**
  * Search entries via AgentDB v3.
@@ -337,6 +341,8 @@ export declare function bridgeStorePattern(options: {
     success: boolean;
     patternId: string;
     controller: string;
+    hasEmbedding?: boolean;
+    embeddingError?: string;
 } | null>;
 /**
  * Search patterns via ReasoningBank controller.