@claude-flow/cli 3.42.5 → 3.44.0

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

@@ -9,6 +9,8 @@ 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';
+import { DEFAULT_ROUTER_EMBEDDER, embedForRouter, resolveRouterEmbedder, } from '../ruvector/router-embedder.js';
 // Real vector search functions - lazy loaded to avoid circular imports
 let searchEntriesFn = null;
 /**
@@ -107,46 +109,16 @@ async function getMoERouter() {
 // Tries native VectorDb first (16k+ routes/s HNSW), falls back to pure JS (47k routes/s cosine)
 let semanticRouter = null;
 let nativeVectorDb = null;
-let semanticRouterInitialized = false;
 let routerBackend = 'none';
 // Pre-computed embeddings for common task patterns (cached)
 const TASK_PATTERN_EMBEDDINGS = new Map();
-function generateSimpleEmbedding(text, dimension = 384) {
-    // Simple deterministic embedding based on character codes
-    // This is for routing purposes where we need consistent, fast embeddings
-    const embedding = new Float32Array(dimension);
-    const normalized = text.toLowerCase().replace(/[^a-z0-9\s]/g, '');
-    const words = normalized.split(/\s+/).filter(w => w.length > 0);
-    // Combine word-level and character-level features
-    for (let i = 0; i < dimension; i++) {
-        let value = 0;
-        // Word-level features
-        for (let w = 0; w < words.length; w++) {
-            const word = words[w];
-            for (let c = 0; c < word.length; c++) {
-                const charCode = word.charCodeAt(c);
-                value += Math.sin((charCode * (i + 1) + w * 17 + c * 23) * 0.0137);
-            }
-        }
-        // Character-level features
-        for (let c = 0; c < text.length; c++) {
-            value += Math.cos((text.charCodeAt(c) * (i + 1) + c * 7) * 0.0073);
-        }
-        embedding[i] = value / Math.max(1, text.length);
-    }
-    // Normalize
-    let norm = 0;
-    for (let i = 0; i < dimension; i++) {
-        norm += embedding[i] * embedding[i];
-    }
-    norm = Math.sqrt(norm);
-    if (norm > 0) {
-        for (let i = 0; i < dimension; i++) {
-            embedding[i] /= norm;
-        }
-    }
-    return embedding;
-}
+// ADR-390: the router's embedder (MiniLM or the historical hash). Pattern and
+// query vectors always come from the SAME embedder; `routerEmbedder` records the
+// one that actually built the current index (after any degradation to hash).
+let routerEmbedder = DEFAULT_ROUTER_EMBEDDER;
+let routerEmbedderReason;
+let routerRequestedEmbedder = null;
+let routerInitPromise = null;
 // ── Runtime routing outcome persistence ──────────────────────────────
 // Closes the learning loop: post-task records outcomes → route loads them.
 const ROUTING_OUTCOMES_PATH = join(resolve('.'), '.claude-flow/routing-outcomes.json');
@@ -190,7 +162,8 @@ function saveRoutingOutcomes(outcomes) {
         // The prior singleton cache made the learned store inert until restart.
         semanticRouter = null;
         nativeVectorDb = null;
-        semanticRouterInitialized = false;
+        routerInitPromise = null;
+        routerRequestedEmbedder = null;
         routerBackend = 'none';
         TASK_PATTERN_EMBEDDINGS.clear();
     }
@@ -269,15 +242,65 @@ 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).
+ *
+ * ADR-390: `requested` (else CLAUDE_FLOW_ROUTER_EMBEDDER, else the default)
+ * picks the embedder. The index is rebuilt when the requested embedder changes.
+ * Concurrent callers share one in-flight build.
  */
-async function getSemanticRouter() {
-    if (semanticRouterInitialized) {
-        return { router: semanticRouter, backend: routerBackend, native: nativeVectorDb };
+async function getSemanticRouter(requested) {
+    const selection = resolveRouterEmbedder(requested);
+    if (routerInitPromise && routerRequestedEmbedder === selection.kind) {
+        return routerInitPromise;
+    }
+    semanticRouter = null;
+    nativeVectorDb = null;
+    routerBackend = 'none';
+    TASK_PATTERN_EMBEDDINGS.clear();
+    routerRequestedEmbedder = selection.kind;
+    routerInitPromise = buildSemanticRouter(selection.kind, selection.reason);
+    return routerInitPromise;
+}
+/** Test hook: drop the cached semantic index so the next route rebuilds it. */
+export function resetSemanticRouterForTests() {
+    semanticRouter = null;
+    nativeVectorDb = null;
+    routerBackend = 'none';
+    routerInitPromise = null;
+    routerRequestedEmbedder = null;
+    TASK_PATTERN_EMBEDDINGS.clear();
+}
+/** Embed every pattern keyword with ONE embedder (ADR-390: never mix spaces). */
+async function embedPatternKeywords(patterns, kind) {
+    const entries = Object.entries(patterns);
+    const flat = entries.flatMap(([, p]) => p.keywords);
+    const res = await embedForRouter(flat, kind);
+    const vectors = new Map();
+    let i = 0;
+    for (const [name, p] of entries) {
+        vectors.set(name, res.vectors.slice(i, i + p.keywords.length));
+        i += p.keywords.length;
     }
-    semanticRouterInitialized = true;
+    return { vectors, embedder: res.embedder, reason: res.reason };
+}
+async function buildSemanticRouter(kind, selectionReason) {
+    const patterns = getMergedTaskPatterns();
+    const embedded = await embedPatternKeywords(patterns, kind);
+    routerEmbedder = embedded.embedder;
+    routerEmbedderReason = embedded.reason ?? selectionReason;
+    const handle = () => ({
+        router: semanticRouter,
+        backend: routerBackend,
+        native: nativeVectorDb,
+        embedder: routerEmbedder,
+        ...(routerEmbedderReason ? { embedderReason: routerEmbedderReason } : {}),
+    });
     // STEP 1: Try native VectorDb from @ruvector/router (HNSW-backed)
     // Note: Native VectorDb uses a persistent database file which can have lock issues
     // in concurrent environments. We try it first but fall back gracefully to pure JS.
@@ -299,17 +322,17 @@ async function getSemanticRouter() {
                     hnswEfSearch: 100,
                 });
                 // Initialize with static + runtime-learned task patterns
-                for (const [patternName, { keywords }] of Object.entries(getMergedTaskPatterns())) {
-                    for (const keyword of keywords) {
-                        const embedding = generateSimpleEmbedding(keyword);
-                        db.insert(`${patternName}:${keyword}`, embedding);
-                        TASK_PATTERN_EMBEDDINGS.set(`${patternName}:${keyword}`, embedding);
-                    }
+                for (const [patternName, { keywords }] of Object.entries(patterns)) {
+                    const embeddings = embedded.vectors.get(patternName) ?? [];
+                    keywords.forEach((keyword, i) => {
+                        db.insert(`${patternName}:${keyword}`, embeddings[i]);
+                        TASK_PATTERN_EMBEDDINGS.set(`${patternName}:${keyword}`, embeddings[i]);
+                    });
                 }
                 nativeVectorDb = db;
                 routerBackend = 'native';
-                console.log('[hooks] Semantic router initialized: native VectorDb (HNSW, 16k+ routes/s)');
-                return { router: null, backend: routerBackend, native: nativeVectorDb };
+                console.log(`[hooks] Semantic router initialized: native VectorDb (HNSW, 16k+ routes/s), embedder=${routerEmbedder}`);
+                return handle();
             }
         }
         catch (err) {
@@ -321,8 +344,8 @@ async function getSemanticRouter() {
     try {
         const { SemanticRouter } = await import('../ruvector/semantic-router.js');
         semanticRouter = new SemanticRouter({ dimension: 384 });
-        for (const [patternName, { keywords, agents, source, support, reliability }] of Object.entries(getMergedTaskPatterns())) {
-            const embeddings = keywords.map(kw => generateSimpleEmbedding(kw));
+        for (const [patternName, { keywords, agents, source, support, reliability }] of Object.entries(patterns)) {
+            const embeddings = embedded.vectors.get(patternName) ?? [];
             semanticRouter.addIntentWithEmbeddings(patternName, embeddings, {
                 agents,
                 keywords,
@@ -336,14 +359,14 @@ async function getSemanticRouter() {
             });
         }
         routerBackend = 'pure-js';
-        console.log('[hooks] Semantic router initialized: pure JS (cosine, 47k routes/s)');
+        console.log(`[hooks] Semantic router initialized: pure JS (cosine, 47k routes/s), embedder=${routerEmbedder}`);
     }
     catch {
         semanticRouter = null;
         routerBackend = 'none';
         console.log('[hooks] Semantic router initialized: none (no backend available)');
     }
-    return { router: semanticRouter, backend: routerBackend, native: nativeVectorDb };
+    return handle();
 }
 /**
  * Get router backend info for status display.
@@ -621,11 +644,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 +983,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;
@@ -1005,134 +1039,185 @@ export const hooksRoute = {
                 // AgentDB router not available — fall through to local routing
             }
         }
-        // Get router (tries native VectorDb first, falls back to pure JS)
-        const { router, backend, native } = useSemanticRouter
-            ? await getSemanticRouter()
-            : { router: null, backend: 'none', native: null };
-        let semanticResult = [];
-        let routingMethod = 'keyword';
-        let routingLatencyMs = 0;
-        let backendInfo = '';
-        const queryText = context ? `${task} ${context}` : task;
-        const queryEmbedding = generateSimpleEmbedding(queryText);
-        // Try native VectorDb (HNSW-backed)
-        if (native && backend === 'native') {
-            const routeStart = performance.now();
-            try {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const results = native.search(queryEmbedding, 5);
-                routingLatencyMs = performance.now() - routeStart;
-                routingMethod = 'semantic-native';
-                backendInfo = 'native VectorDb (HNSW)';
-                // Convert results to semantic format
-                const mergedPatterns = getMergedTaskPatterns();
-                semanticResult = results.map((r) => {
-                    const [patternName] = r.id.split(':');
-                    const pattern = mergedPatterns[patternName];
-                    return {
-                        intent: patternName,
-                        score: 1 - r.score, // Native uses distance (lower is better), convert to similarity
-                        metadata: {
-                            agents: pattern?.agents || (patternName.startsWith('learned-') ? [patternName.slice(8)] : ['coder']),
-                            source: pattern?.source ?? (patternName.startsWith('learned-') ? 'learned' : 'static'),
-                            support: pattern?.support,
-                            reliability: pattern?.reliability,
-                        },
-                    };
-                });
-            }
-            catch {
-                // Native failed, try pure JS fallback
-            }
-        }
-        // Try pure JS SemanticRouter fallback
-        if (router && backend === 'pure-js' && semanticResult.length === 0) {
-            const routeStart = performance.now();
-            semanticResult = router.routeWithEmbedding(queryEmbedding, 3);
+        return routeTaskLocal(task, context, useSemanticRouter);
+    }),
+};
+/**
+ * hooks_route's local routing (semantic index + keyword fallback), run after the
+ * AgentDB pre-route. Shared with {@link routeTaskForBench} so the benchmark
+ * measures exactly the path hooks_route takes. (Body kept at its original
+ * indentation to keep this refactor's diff small.)
+ */
+async function routeTaskLocal(task, context, useSemanticRouter, embedderOverride) {
+    // Get router (tries native VectorDb first, falls back to pure JS)
+    let handle = useSemanticRouter
+        ? await getSemanticRouter(embedderOverride)
+        : {
+            router: null, backend: 'none', native: null,
+            embedder: resolveRouterEmbedder(embedderOverride).kind,
+            embedderReason: 'semantic router disabled (useSemanticRouter=false)',
+        };
+    let semanticResult = [];
+    let routingMethod = 'keyword';
+    let routingLatencyMs = 0;
+    let backendInfo = '';
+    const queryText = context ? `${task} ${context}` : task;
+    // ADR-390: the query is embedded with the embedder that built the index.
+    let queryEmbedding = null;
+    if (handle.router || handle.native) {
+        const q = await embedForRouter([queryText], handle.embedder);
+        if (q.embedder !== handle.embedder) {
+            // MiniLM failed on the query after building a MiniLM index: rebuild the
+            // index with the hash so patterns and query share one space again.
+            routerInitPromise = buildSemanticRouter('hash', q.reason);
+            handle = await routerInitPromise;
+        }
+        queryEmbedding = q.vectors[0];
+    }
+    const { router, backend, native } = handle;
+    // Try native VectorDb (HNSW-backed)
+    if (native && backend === 'native' && queryEmbedding) {
+        const routeStart = performance.now();
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const results = native.search(queryEmbedding, 5);
             routingLatencyMs = performance.now() - routeStart;
-            routingMethod = 'semantic-pure-js';
-            backendInfo = 'pure JS (cosine similarity)';
-        }
-        // Get agents from semantic routing or fall back to keyword
-        let agents;
-        let confidence;
-        let matchedPattern = '';
-        // Both static and learned patterns are gated on the same similarity
-        // score. Learned patterns additionally require support/reliability as a
-        // quality guard, but do NOT need a higher score bar — a learned pattern
-        // that outscores every static candidate must not lose to one anyway
-        // (#2864: a 25pp higher threshold made a top-scoring learned-researcher
-        // match at 0.57 lose to a static match at 0.52, discarding the learned
-        // store's output on the majority of routes).
-        const eligibleSemantic = semanticResult.find((match) => {
-            if (match.score <= 0.4)
-                return false;
-            const learned = match.intent.startsWith('learned-') || match.metadata.source === 'learned';
-            if (!learned)
-                return true;
-            return Number(match.metadata.support ?? 0) >= 2
-                && Number(match.metadata.reliability ?? 0) >= 0.75;
-        });
-        if (eligibleSemantic) {
-            const topMatch = eligibleSemantic;
-            agents = topMatch.metadata.agents || ['coder', 'researcher'];
-            confidence = topMatch.score;
-            matchedPattern = topMatch.intent;
+            routingMethod = 'semantic-native';
+            backendInfo = 'native VectorDb (HNSW)';
+            // Convert results to semantic format
+            const mergedPatterns = getMergedTaskPatterns();
+            semanticResult = results.map((r) => {
+                const [patternName] = r.id.split(':');
+                const pattern = mergedPatterns[patternName];
+                return {
+                    intent: patternName,
+                    score: 1 - r.score, // Native uses distance (lower is better), convert to similarity
+                    metadata: {
+                        agents: pattern?.agents || (patternName.startsWith('learned-') ? [patternName.slice(8)] : ['coder']),
+                        source: pattern?.source ?? (patternName.startsWith('learned-') ? 'learned' : 'static'),
+                        support: pattern?.support,
+                        reliability: pattern?.reliability,
+                    },
+                };
+            });
         }
-        else {
-            // Fall back to keyword matching
-            const suggestion = suggestAgentsForTask(task);
-            agents = suggestion.agents;
-            confidence = suggestion.confidence;
-            matchedPattern = 'keyword-fallback';
-            routingMethod = 'keyword';
-            backendInfo = 'keyword matching';
+        catch {
+            // Native failed, try pure JS fallback
         }
-        // Determine complexity
-        const taskLower = task.toLowerCase();
-        const complexity = taskLower.includes('complex') || taskLower.includes('architecture') || task.length > 200
-            ? 'high'
-            : taskLower.includes('simple') || taskLower.includes('fix') || task.length < 50
-                ? 'low'
-                : 'medium';
-        return {
-            task,
-            routing: {
-                method: routingMethod,
-                backend: backendInfo,
-                latencyMs: routingLatencyMs,
-                throughput: routingLatencyMs > 0 ? `${Math.round(1000 / routingLatencyMs)} routes/s` : 'N/A',
-            },
-            matchedPattern,
-            semanticMatches: semanticResult.slice(0, 3).map(r => ({
-                pattern: r.intent,
-                score: Math.round(r.score * 100) / 100,
-            })),
-            primaryAgent: {
-                type: agents[0],
-                confidence: Math.round(confidence * 100) / 100,
-                reason: routingMethod.startsWith('semantic')
-                    ? `Semantic similarity to "${matchedPattern}" pattern (${Math.round(confidence * 100)}%)`
-                    : `Task contains keywords matching ${agents[0]} specialization`,
-            },
-            alternativeAgents: agents.slice(1).map((agent, i) => ({
-                type: agent,
-                confidence: Math.round((confidence - (0.1 * (i + 1))) * 100) / 100,
-                reason: `Alternative agent for ${agent} capabilities`,
-            })),
-            estimatedMetrics: {
-                successProbability: Math.round(confidence * 100) / 100,
-                estimatedDuration: complexity === 'high' ? '2-4 hours' : complexity === 'medium' ? '30-60 min' : '10-30 min',
-                complexity,
-            },
-            swarmRecommendation: agents.length > 2 ? {
-                topology: 'hierarchical',
-                agents,
-                coordination: 'queen-led',
-            } : null,
-        };
-    },
-};
+    }
+    // Try pure JS SemanticRouter fallback
+    if (router && backend === 'pure-js' && queryEmbedding && semanticResult.length === 0) {
+        const routeStart = performance.now();
+        semanticResult = router.routeWithEmbedding(queryEmbedding, 3);
+        routingLatencyMs = performance.now() - routeStart;
+        routingMethod = 'semantic-pure-js';
+        backendInfo = 'pure JS (cosine similarity)';
+    }
+    // Get agents from semantic routing or fall back to keyword
+    let agents;
+    let confidence;
+    let matchedPattern = '';
+    // Both static and learned patterns are gated on the same similarity
+    // score. Learned patterns additionally require support/reliability as a
+    // quality guard, but do NOT need a higher score bar — a learned pattern
+    // that outscores every static candidate must not lose to one anyway
+    // (#2864: a 25pp higher threshold made a top-scoring learned-researcher
+    // match at 0.57 lose to a static match at 0.52, discarding the learned
+    // store's output on the majority of routes).
+    const eligibleSemantic = semanticResult.find((match) => {
+        if (match.score <= 0.4)
+            return false;
+        const learned = match.intent.startsWith('learned-') || match.metadata.source === 'learned';
+        if (!learned)
+            return true;
+        return Number(match.metadata.support ?? 0) >= 2
+            && Number(match.metadata.reliability ?? 0) >= 0.75;
+    });
+    if (eligibleSemantic) {
+        const topMatch = eligibleSemantic;
+        agents = topMatch.metadata.agents || ['coder', 'researcher'];
+        confidence = topMatch.score;
+        matchedPattern = topMatch.intent;
+    }
+    else {
+        // Fall back to keyword matching
+        const suggestion = suggestAgentsForTask(task);
+        agents = suggestion.agents;
+        confidence = suggestion.confidence;
+        matchedPattern = 'keyword-fallback';
+        routingMethod = 'keyword';
+        backendInfo = 'keyword matching';
+    }
+    // Determine complexity
+    const taskLower = task.toLowerCase();
+    const complexity = taskLower.includes('complex') || taskLower.includes('architecture') || task.length > 200
+        ? 'high'
+        : taskLower.includes('simple') || taskLower.includes('fix') || task.length < 50
+            ? 'low'
+            : 'medium';
+    return {
+        task,
+        routing: {
+            method: routingMethod,
+            backend: backendInfo,
+            latencyMs: routingLatencyMs,
+            throughput: routingLatencyMs > 0 ? `${Math.round(1000 / routingLatencyMs)} routes/s` : 'N/A',
+        },
+        matchedPattern,
+        semanticMatches: semanticResult.slice(0, 3).map(r => ({
+            pattern: r.intent,
+            score: Math.round(r.score * 100) / 100,
+        })),
+        primaryAgent: {
+            type: agents[0],
+            confidence: Math.round(confidence * 100) / 100,
+            reason: routingMethod.startsWith('semantic')
+                ? `Semantic similarity to "${matchedPattern}" pattern (${Math.round(confidence * 100)}%)`
+                : `Task contains keywords matching ${agents[0]} specialization`,
+        },
+        alternativeAgents: agents.slice(1).map((agent, i) => ({
+            type: agent,
+            confidence: Math.round((confidence - (0.1 * (i + 1))) * 100) / 100,
+            reason: `Alternative agent for ${agent} capabilities`,
+        })),
+        estimatedMetrics: {
+            successProbability: Math.round(confidence * 100) / 100,
+            estimatedDuration: complexity === 'high' ? '2-4 hours' : complexity === 'medium' ? '30-60 min' : '10-30 min',
+            complexity,
+        },
+        swarmRecommendation: agents.length > 2 ? {
+            topology: 'hierarchical',
+            agents,
+            coordination: 'queen-led',
+        } : null,
+        // ADR-390: which embedder the semantic index + query used ('hash' when degraded).
+        embedder: handle.embedder,
+        ...(handle.embedderReason ? { embedderReason: handle.embedderReason } : {}),
+    };
+}
+/**
+ * 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 async function routeTaskForBench(task, opts) {
+    const r = await routeTaskLocal(task, opts.context, true, opts.embedder);
+    return {
+        primaryAgent: r.primaryAgent.type,
+        confidence: r.primaryAgent.confidence,
+        pattern: r.matchedPattern,
+        embedder: r.embedder,
+        ...(r.embedderReason ? { embedderReason: r.embedderReason } : {}),
+        method: String(r.routing?.method ?? ''),
+    };
+}
 export const hooksMetrics = {
     name: 'hooks_metrics',
     description: 'View learning metrics dashboard Use when native Bash hooks (via Claude Code\'s settings.json) are wrong because you need Ruflo-side state — pattern persistence, neural training signals, model-routing learning, cost tracking, audit chain. For one-off shell commands, plain Bash hooks are fine.',
@@ -1439,10 +1524,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 +1669,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 ? {