@claude-flow/cli 3.42.5 → 3.44.0

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

@@ -1,13 +1,14 @@
 {
   "manifest": {
-    "version": "3.42.5",
+    "version": "3.44.0",
     "files": {
       "auto-memory-hook.mjs": "85fe05c757421c52137c0bc8545a0896bab6b4714538c2a11d1d0835bfcc8c1c",
       "hook-handler.cjs": "209d9fafe10e17d1be0866727f6f9cf9ac66f9a0793f1c793a4f58319e8e4583",
       "intelligence.cjs": "30e42ed7ec4ca5a94ac54fdb1330d2d47ac5f3fdeeef207753574723a9e77b5c",
-      "statusline.cjs": "4a48353b4f1566fa4379b00fd0321b6676a22b6cc91fbbd8380ac5183d619468"
+      "statusline.cjs": "4a48353b4f1566fa4379b00fd0321b6676a22b6cc91fbbd8380ac5183d619468",
+      "router.js": "b6998397e7883191b62229ccdc66fb87f1ccca1d5b2039ecb8c1e686d1ad81f8"
     }
   },
-  "signature": "vKGy5o0MCknsugr2YSBRJojeNK1T+3et2Aqtj8MMFdgX6XeKHZglXkBjfNC6Jh74afqiXGBQlUs7VQgMf7daDQ==",
+  "signature": "vl9y84CRx7XaIXMi3iD1q3UVqeUvGsvpwjXkhMuA42myuVhCbgtnSNM9W8M3Pv9Odqy5qucwwDsz7MB7mUqDBg==",
   "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-21T19:42:33.000Z",
-  "gitSha": "9c61c86f",
+  "generatedAt": "2026-09-23T18:40:54.000Z",
+  "gitSha": "0a96fb88",
   "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/executor.js

@@ -499,7 +499,7 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
         const sourceHelpersForUpgrade = findSourceHelpersDir();
         if (sourceHelpersForUpgrade) {
             // Keep in sync with helper-refresh.ts:CRITICAL_HELPERS.
-            const criticalHelpers = ['auto-memory-hook.mjs', 'hook-handler.cjs', 'intelligence.cjs', 'statusline.cjs'];
+            const criticalHelpers = ['auto-memory-hook.mjs', 'hook-handler.cjs', 'intelligence.cjs', 'statusline.cjs', 'router.js'];
             for (const helperName of criticalHelpers) {
                 const targetPath = path.join(targetDir, '.claude', 'helpers', helperName);
                 const sourcePath = path.join(sourceHelpersForUpgrade, helperName);
@@ -524,6 +524,7 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 'hook-handler.cjs': generateHookHandler(),
                 'intelligence.cjs': generateIntelligenceStub(),
                 'auto-memory-hook.mjs': generateAutoMemoryHook(),
+                'router.js': generateAgentRouter(), // ADR-389
             };
             for (const [helperName, content] of Object.entries(generatedCritical)) {
                 const targetPath = path.join(targetDir, '.claude', 'helpers', helperName);

package/dist/src/init/helper-refresh.js

@@ -71,6 +71,10 @@ export const CRITICAL_HELPERS = [
     // statusline.cjs is here so the funnel disclosure row (ADR-301) reaches
     // existing installs on the next `ruflo` command, not only fresh `ruflo init`.
     'statusline.cjs',
+    // router.js is loaded by hook-handler.cjs to label each prompt with an agent.
+    // Without it here, installs kept the pre-#2257 substring router forever
+    // ("latest" -> tester). ADR-389 / #3401.
+    'router.js',
 ];
 function errorCode(error) {
     return typeof error === 'object' && error !== null && 'code' in error
@@ -309,6 +313,7 @@ async function writeCriticalHelpers(helpersDir, version, opts = {}) {
         'hook-handler.cjs': gen.generateHookHandler(),
         'intelligence.cjs': gen.generateIntelligenceStub(),
         'auto-memory-hook.mjs': gen.generateAutoMemoryHook(),
+        'router.js': gen.generateAgentRouter(), // ADR-389
         // Fallback needs the same generator inputs `ruflo init` uses. We match the
         // hardcoded default (maxAgents 15) because the fallback fires when the
         // installed package is unresolvable — no way to read the user's project

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

@@ -3,6 +3,7 @@
  * Provides intelligent hooks functionality via MCP protocol
  */
 import { type MCPTool } from './types.js';
+import { type RouterEmbedderKind } from '../ruvector/router-embedder.js';
 /**
  * Strip extended-thinking blocks from text before it enters a learning
  * trajectory (hermes-agent think_scrubber pattern). Claude models with extended
@@ -13,11 +14,46 @@ import { type MCPTool } from './types.js';
  * the tag names untouched.
  */
 export declare function scrubReasoningBlocks(text: string): string;
+/** Test hook: drop the cached semantic index so the next route rebuilds it. */
+export declare function resetSemanticRouterForTests(): void;
+/** 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;
 export declare const hooksPostCommand: MCPTool;
 export declare const hooksRoute: MCPTool;
+/** Result of {@link routeTaskForBench}. */
+export interface BenchRouteResult {
+    primaryAgent: string;
+    confidence: number;
+    /** Matched pattern name, or 'keyword-fallback'. */
+    pattern: string;
+    /** Embedder actually used ('hash' if MiniLM was requested but unavailable). */
+    embedder: RouterEmbedderKind;
+    embedderReason?: string;
+    /** routing.method of the underlying route ('semantic-native' | 'semantic-pure-js' | 'keyword'). */
+    method: string;
+}
+/**
+ * INTERNAL / BENCH-ONLY (ADR-391). Not a public API; may change without notice.
+ *
+ * Routes `task` through the same local path `hooks_route` uses (semantic index +
+ * keyword fallback) with an explicit embedder, without the MCP layer. It skips
+ * the two steps that are neither ADR-391 candidate A nor B: the AgentDB
+ * pre-route (`bridgeRouteTask`, which answers first when its confidence > 0.5)
+ * and the opt-in typesafe wrapper (CLAUDE_FLOW_ROUTER_TYPESAFE). With those
+ * inactive, `primaryAgent` equals `hooks_route`'s `primaryAgent.type`.
+ *
+ * Switching `embedder` between calls rebuilds the index; benchmark in blocks.
+ */
+export declare function routeTaskForBench(task: string, opts: {
+    embedder: RouterEmbedderKind;
+    context?: string;
+}): Promise<BenchRouteResult>;
 export declare const hooksMetrics: MCPTool;
 export declare const hooksList: MCPTool;
 export declare const hooksPreTask: MCPTool;