claude-flow 3.42.4 → 3.43.0

package/.claude/.proven-config-version

@@ -0,0 +1 @@
+sha256:6141a8ea990c5063b77e090ae8f37f9c539d8aa8f58dcceb30f3a82f97e57319

package/.claude/helpers/router.cjs

@@ -1,7 +1,16 @@
 #!/usr/bin/env node
 /**
  * Claude Flow Agent Router
- * Routes tasks to optimal agents based on learned patterns
+ *
+ * Static keyword router that suggests an agent for a task description.
+ * NOTE: This is *not* a learned model. It is a heuristic table; "confidence"
+ * is reported as a heuristic prior, not a calibrated probability.
+ *
+ * #2257 fix: patterns are now word-boundary-anchored so short tokens like
+ * `cd`, `ci`, `ui`, `add`, `structure` no longer match inside unrelated
+ * words (`decision`, `infrastructure`, `address`, `addendum`). Default
+ * confidence dropped from 0.8 to 0.6 to better reflect that this is a
+ * static heuristic, not a learned classifier.
  */
 
 const AGENT_CAPABILITIES = {
@@ -15,41 +24,73 @@ const AGENT_CAPABILITIES = {
   devops: ['ci-cd', 'docker', 'deployment', 'infrastructure'],
 };
 
-const TASK_PATTERNS = {
-  'implement|create|build|add|write code': 'coder',
-  'test|spec|coverage|unit test|integration': 'tester',
-  'review|audit|check|validate|security': 'reviewer',
-  'research|find|search|documentation|explore': 'researcher',
-  'design|architect|structure|plan': 'architect',
-  'api|endpoint|server|backend|database': 'backend-dev',
-  'ui|frontend|component|react|css|style': 'frontend-dev',
-  'deploy|docker|ci|cd|pipeline|infrastructure': 'devops',
-};
+// Each entry is an array of tokens. Tokens are alternation-friendly:
+//   - multi-word phrases ("unit test") match as phrases
+//   - single tokens are wrapped with \b … \b word boundaries at match time
+const TASK_PATTERNS = [
+  // Code patterns
+  { tokens: ['implement', 'create', 'build', 'add', 'write code', 'refactor', 'debug'], agent: 'coder' },
+  { 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' },
+
+  // Domain patterns
+  { tokens: ['api', 'endpoint', 'server', 'backend', 'database'], agent: 'backend-dev' },
+  { tokens: ['ui', 'frontend', 'component', 'react', 'css', 'style'], agent: 'frontend-dev' },
+  // 'cd' / 'ci' are kept but require word boundaries via \b — they will not
+  // match inside "decision" or "specific". 'cd' as a literal command in a
+  // task description ("set up cd pipeline") still matches.
+  { tokens: ['deploy', 'docker', 'ci', 'cd', 'ci/cd', 'pipeline', 'infrastructure', 'devops'], agent: 'devops' },
+];
+
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+// Build an anchored alternation regex from a token list.
+//   - multi-word phrases (containing whitespace or '/') match literally
+//   - single tokens are wrapped with \b boundaries so 'cd' won't match "decide"
+function buildPattern(tokens) {
+  const alternatives = tokens.map((tok) => {
+    const escaped = escapeRegex(tok.toLowerCase());
+    if (/\s|\//.test(tok)) {
+      // Phrase: whitespace/'/' on each side acts as a natural boundary
+      return escaped;
+    }
+    return `\\b${escaped}\\b`;
+  });
+  return new RegExp(`(?:${alternatives.join('|')})`, 'i');
+}
+
+const COMPILED_PATTERNS = TASK_PATTERNS.map((entry) => ({
+  agent: entry.agent,
+  tokens: entry.tokens,
+  regex: buildPattern(entry.tokens),
+}));
 
 function routeTask(task) {
-  const taskLower = task.toLowerCase();
+  const taskLower = String(task ?? '').toLowerCase();
 
-  for (const [pattern, agent] of Object.entries(TASK_PATTERNS)) {
-    const regex = new RegExp(pattern, 'i');
-    if (regex.test(taskLower)) {
+  for (const entry of COMPILED_PATTERNS) {
+    if (entry.regex.test(taskLower)) {
       return {
-        agent,
-        confidence: 0.8,
-        reason: `Matched pattern: ${pattern}`,
+        agent: entry.agent,
+        // Heuristic prior, not a learned probability — see file header.
+        confidence: 0.6,
+        reason: `Matched keyword(s) from: ${entry.tokens.join('|')}`,
       };
     }
   }
 
   return {
     agent: 'coder',
-    confidence: 0.5,
-    reason: 'Default routing - no specific pattern matched',
+    confidence: 0.3,
+    reason: 'Default routing - no specific keyword matched',
   };
 }
 
-module.exports = { routeTask, AGENT_CAPABILITIES, TASK_PATTERNS };
-
-// CLI - only run when executed directly
+// CLI
 if (require.main === module) {
   const task = process.argv.slice(2).join(' ');
   if (task) {
@@ -60,3 +101,5 @@ if (require.main === module) {
     console.log('\nAvailable agents:', Object.keys(AGENT_CAPABILITIES).join(', '));
   }
 }
+
+module.exports = { routeTask, AGENT_CAPABILITIES, TASK_PATTERNS, buildPattern };

package/.claude/proven-config.json

@@ -0,0 +1,42 @@
+{
+  "adoptedAt": 1790175486477,
+  "championId": "sha256:6141a8ea990c5063b77e090ae8f37f9c539d8aa8f58dcceb30f3a82f97e57319",
+  "manifest": {
+    "schema": "ruflo.proven-config/v1",
+    "policy": {
+      "ref": "sha256:6141a8ea990c5063b77e090ae8f37f9c539d8aa8f58dcceb30f3a82f97e57319",
+      "value": {
+        "alpha": 0.3,
+        "subjectWeight": 1,
+        "mmrLambda": 0.5,
+        "bodyWeight": 1.5,
+        "typePenaltyFactor": 0.5
+      }
+    },
+    "layer": "framework/node-cli",
+    "compatibility": {
+      "ruflo": ">=3.24.0"
+    },
+    "benchmark": {
+      "corpus": "ADR-081-labelled-v1",
+      "corpusHash": "sha256:2f700b5c363e20a3bd88ce2bc9b87bbbbaa61732c6177894c6ec37890f888982"
+    },
+    "receipt": {
+      "heldOutDelta": 0.07381404928570845,
+      "redblue": "PASS",
+      "drift": 0,
+      "canary": {
+        "rollbackRate": 0,
+        "latencyP95": 244.612458000076,
+        "costPerTask": 0
+      },
+      "receiptCoverage": 1
+    },
+    "platform": [
+      "linux",
+      "macOS",
+      "windows"
+    ]
+  },
+  "previous": ""
+}

package/node_modules/@claude-flow/security/dist/input-validator.d.ts

@@ -159,14 +159,14 @@ export declare const SpawnAgentSchema: z.ZodObject<{
     timeout: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     type: "coder" | "reviewer" | "tester" | "planner" | "researcher" | "security-architect" | "security-auditor" | "memory-specialist" | "swarm-specialist" | "integration-architect" | "performance-engineer" | "core-architect" | "test-architect" | "queen-coordinator" | "project-coordinator";
+    id?: string | undefined;
     config?: Record<string, unknown> | undefined;
     timeout?: number | undefined;
-    id?: string | undefined;
 }, {
     type: "coder" | "reviewer" | "tester" | "planner" | "researcher" | "security-architect" | "security-auditor" | "memory-specialist" | "swarm-specialist" | "integration-architect" | "performance-engineer" | "core-architect" | "test-architect" | "queen-coordinator" | "project-coordinator";
+    id?: string | undefined;
     config?: Record<string, unknown> | undefined;
     timeout?: number | undefined;
-    id?: string | undefined;
 }>;
 /**
  * Task input schema
@@ -181,13 +181,13 @@ export declare const TaskInputSchema: z.ZodObject<{
     taskId: string;
     content: string;
     agentType: "coder" | "reviewer" | "tester" | "planner" | "researcher" | "security-architect" | "security-auditor" | "memory-specialist" | "swarm-specialist" | "integration-architect" | "performance-engineer" | "core-architect" | "test-architect" | "queen-coordinator" | "project-coordinator";
-    priority?: "critical" | "high" | "medium" | "low" | undefined;
+    priority?: "low" | "medium" | "high" | "critical" | undefined;
     metadata?: Record<string, unknown> | undefined;
 }, {
     taskId: string;
     content: string;
     agentType: "coder" | "reviewer" | "tester" | "planner" | "researcher" | "security-architect" | "security-auditor" | "memory-specialist" | "swarm-specialist" | "integration-architect" | "performance-engineer" | "core-architect" | "test-architect" | "queen-coordinator" | "project-coordinator";
-    priority?: "critical" | "high" | "medium" | "low" | undefined;
+    priority?: "low" | "medium" | "high" | "critical" | undefined;
     metadata?: Record<string, unknown> | undefined;
 }>;
 /**
@@ -234,16 +234,16 @@ export declare const ExecutorConfigSchema: z.ZodObject<{
     cwd: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
     allowSudo: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
-    allowedCommands: string[];
     timeout: number;
+    allowedCommands: string[];
     maxBuffer: number;
     allowSudo: boolean;
     blockedPatterns?: string[] | undefined;
     cwd?: string | undefined;
 }, {
     allowedCommands: string[];
-    blockedPatterns?: string[] | undefined;
     timeout?: number | undefined;
+    blockedPatterns?: string[] | undefined;
     maxBuffer?: number | undefined;
     cwd?: string | undefined;
     allowSudo?: boolean | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.42.4",
+  "version": "3.43.0",
   "workspaces": [
     "v3/@claude-flow/codex",
     "v3/@claude-flow/mcp",
@@ -98,8 +98,8 @@
     "@claude-flow/plugin-gastown-bridge": "^0.1.3",
     "@ruvector/attention": "^0.1.3",
     "@ruvector/core": "^0.1.30",
-    "@ruvector/router": "^0.1.30",
-    "@ruvector/router-linux-x64-gnu": "^0.1.30",
+    "@ruvector/router": "^0.1.31",
+    "@ruvector/router-linux-x64-gnu": "^0.1.31",
     "@ruvector/sona": "^0.1.5",
     "agentdb": "^3.0.0-alpha.17",
     "agentic-flow": "^2.0.14",

package/v3/@claude-flow/cli/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/v3/@claude-flow/cli/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/v3/@claude-flow/cli/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/v3/@claude-flow/cli/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/v3/@claude-flow/cli/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/v3/@claude-flow/cli/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/v3/@claude-flow/cli/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/v3/@claude-flow/cli/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/v3/@claude-flow/cli/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).