claude-flow 3.32.35 → 3.32.36

package/v3/@claude-flow/cli/dist/src/commands/swarm.js

@@ -50,6 +50,34 @@ function getSwarmStatus(swarmId) {
             // Ignore
         }
     }
+    // The canonical agent registry is the same source used by `agent list`.
+    // Prefer it over the swarm-level coordination boolean so idle agents are
+    // not reported as active (#2808). Hive agents are merged additively.
+    if (totalAgents === 0) {
+        try {
+            const canonicalPath = path.join(process.cwd(), '.claude-flow', 'agents', 'store.json');
+            const hivePath = path.join(process.cwd(), '.claude-flow', 'agents.json');
+            const merged = {};
+            for (const storePath of [hivePath, canonicalPath]) {
+                if (!fs.existsSync(storePath))
+                    continue;
+                const parsed = JSON.parse(fs.readFileSync(storePath, 'utf-8'));
+                if (parsed?.agents && typeof parsed.agents === 'object') {
+                    Object.assign(merged, parsed.agents);
+                }
+            }
+            const agents = Object.values(merged).filter(agent => agent.status !== 'terminated');
+            if (agents.length > 0) {
+                totalAgents = agents.length;
+                activeAgents = agents.filter(agent => agent.status === 'active' ||
+                    agent.status === 'running' ||
+                    agent.status === 'busy').length;
+            }
+        }
+        catch {
+            // Ignore — the count-only activity file remains the final fallback.
+        }
+    }
     // #2799 — `agent spawn` never writes `.swarm/agents/*.json`; it records
     // the count in `.claude-flow/metrics/swarm-activity.json` (via
     // updateSwarmActivityMetrics in commands/agent.ts). So when the agents

package/v3/@claude-flow/cli/dist/src/init/executor.js

@@ -370,18 +370,19 @@ function mergeSettingsForUpgrade(existing) {
     // js/redos): a crafted settings.json command string with dozens of
     // dash-token repetitions can hang this check for minutes.
     const BROKEN_STATUSLINE_RE = /(?:npx\s+(?:--?\S+\s+){0,10})?@?claude-flow(?:\/cli)?(?:@\S+)?\s+hooks\s+statusline/;
+    const BROKEN_NPX_LATEST_RE = /npx\s+(?:--?\S+\s+){0,10}@?claude-flow\/cli@latest\s+\S+/;
     const existingStatusLine = existing.statusLine;
     if (existingStatusLine) {
         const existingCmd = typeof existingStatusLine.command === 'string' ? existingStatusLine.command : '';
-        const isBroken = BROKEN_STATUSLINE_RE.test(existingCmd);
+        const isBroken = BROKEN_STATUSLINE_RE.test(existingCmd) || BROKEN_NPX_LATEST_RE.test(existingCmd);
         merged.statusLine = {
             type: 'command',
             command: isBroken || !existingCmd ? NEW_STATUSLINE_CMD : existingCmd,
             // Remove invalid fields: refreshMs, enabled (not supported by Claude Code)
         };
     }
-    // #2448 — Detect and REGENERATE per-action hook commands that still use
-    // the runaway `npx @claude-flow/cli@latest hooks <sub>` form. These fire
+    // #2448 / #2677 — Detect and REGENERATE per-action hook commands that still
+    // use the runaway `npx @claude-flow/cli@latest hooks <sub>` form. These fire
     // on every PreToolUse/PostToolUse/UserPromptSubmit, each spawning ~130 MB
     // of cold Node + npm registry resolution; the storm is what kernel-paniced
     // the reporter's machine in #2448.
@@ -409,15 +410,20 @@ function mergeSettingsForUpgrade(existing) {
             for (const group of groups) {
                 if (!Array.isArray(group.hooks))
                     continue;
-                for (const h of group.hooks) {
+                group.hooks = group.hooks.filter((h) => {
                     if (typeof h?.command !== 'string')
-                        continue;
+                        return true;
                     const m = BROKEN_HOOK_RE.exec(h.command);
-                    if (!m)
-                        continue;
-                    // Subcommand captured (e.g. "pre-bash", "post-edit", "route") — keep it.
-                    h.command = localHookCmd(m[1]);
-                }
+                    if (m) {
+                        // Subcommand captured (e.g. "pre-bash", "post-edit", "route") — keep it.
+                        h.command = localHookCmd(m[1]);
+                        return true;
+                    }
+                    // Sibling CLI invocations (memory/daemon/swarm/...) have no
+                    // hook-handler equivalent. Drop the stale extra; the merge above
+                    // has already installed current local-helper hooks for this event.
+                    return !BROKEN_NPX_LATEST_RE.test(h.command);
+                });
             }
         }
     }

package/v3/@claude-flow/cli/dist/src/init/helpers-generator.js

@@ -775,11 +775,22 @@ export function generateIntelligenceStub() {
         "const path = require('path');",
         "const os = require('os');",
         '',
-        "const DATA_DIR = path.join(process.cwd(), '.claude-flow', 'data');",
+        'function resolveProjectRoot(startDir) {',
+        '  if (process.env.CLAUDE_PROJECT_DIR) return path.resolve(process.env.CLAUDE_PROJECT_DIR);',
+        '  var dir = path.resolve(startDir || process.cwd());',
+        '  while (true) {',
+        '    if (fs.existsSync(path.join(dir, ".git")) || fs.existsSync(path.join(dir, ".claude-flow"))) return dir;',
+        '    var parent = path.dirname(dir);',
+        '    if (parent === dir) return path.resolve(startDir || process.cwd());',
+        '    dir = parent;',
+        '  }',
+        '}',
+        "const PROJECT_ROOT = resolveProjectRoot(process.cwd());",
+        "const DATA_DIR = path.join(PROJECT_ROOT, '.claude-flow', 'data');",
         "const STORE_PATH = path.join(DATA_DIR, 'auto-memory-store.json');",
         "const RANKED_PATH = path.join(DATA_DIR, 'ranked-context.json');",
         "const PENDING_PATH = path.join(DATA_DIR, 'pending-insights.jsonl');",
-        "const SESSION_DIR = path.join(process.cwd(), '.claude-flow', 'sessions');",
+        "const SESSION_DIR = path.join(PROJECT_ROOT, '.claude-flow', 'sessions');",
         "const SESSION_FILE = path.join(SESSION_DIR, 'current.json');",
         '',
         'function ensureDir(dir) {',
@@ -823,8 +834,8 @@ export function generateIntelligenceStub() {
         '  var entries = [];',
         '  var candidates = [',
         '    path.join(os.homedir(), ".claude", "projects"),',
-        '    path.join(process.cwd(), ".claude-flow", "memory"),',
-        '    path.join(process.cwd(), ".claude", "memory"),',
+        '    path.join(PROJECT_ROOT, ".claude-flow", "memory"),',
+        '    path.join(PROJECT_ROOT, ".claude", "memory"),',
         '  ];',
         '  for (var i = 0; i < candidates.length; i++) {',
         '    try {',

package/v3/@claude-flow/cli/dist/src/init/statusline-generator.js

@@ -53,6 +53,16 @@ function getInstalledCliVersionLocal() {
         return '0.0.0';
     }
 }
+function compareVersionsLocal(a, b) {
+    const pa = a.split(/[.-]/).map(part => Number.parseInt(part, 10) || 0);
+    const pb = b.split(/[.-]/).map(part => Number.parseInt(part, 10) || 0);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const delta = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (delta !== 0)
+            return delta;
+    }
+    return 0;
+}
 /**
  * Generate optimized statusline script
  * Output format:
@@ -91,10 +101,12 @@ export function generateStatuslineScript(options) {
     // getInstalledCliVersionLocal() above — reuse the pattern for the
     // same reason it exists there.
     let helperContent = null;
+    let helperPackageRoot = '';
     try {
         const esmRequire = createRequire(import.meta.url);
         const pkgJsonPath = esmRequire.resolve('@claude-flow/cli/package.json');
-        const helperPath = path.join(path.dirname(pkgJsonPath), '.claude', 'helpers', 'statusline.cjs');
+        helperPackageRoot = path.dirname(pkgJsonPath);
+        const helperPath = path.join(helperPackageRoot, '.claude', 'helpers', 'statusline.cjs');
         helperContent = fs.readFileSync(helperPath, 'utf-8');
     }
     catch {
@@ -105,6 +117,7 @@ export function generateStatuslineScript(options) {
                 if (pkg && pkg.name === '@claude-flow/cli') {
                     const candidate = path.join(dir, '.claude', 'helpers', 'statusline.cjs');
                     if (fs.existsSync(candidate)) {
+                        helperPackageRoot = dir;
                         helperContent = fs.readFileSync(candidate, 'utf-8');
                         break;
                     }
@@ -128,15 +141,15 @@ export function generateStatuslineScript(options) {
     // whatever the helper hard-codes) ships. Add a paired test in
     // statusline-cost-display.test.ts before changing either token.
     helperContent = helperContent.replace(/maxAgents: \d+,/, `maxAgents: ${maxAgents},`);
+    helperContent = helperContent.replace(/const BAKED_INSTALL_ROOT = "[^"]*";/, `const BAKED_INSTALL_ROOT = ${JSON.stringify(helperPackageRoot)};`);
     // Only overwrite the helper's baked version if OURS resolves higher.
     // Otherwise the substitution could DOWNGRADE (test environments where
     // esmRequire.resolve happens to hit an older node_modules install would
-    // clobber a fresh committed helper). Naive lexicographic compare — works
-    // for canonical semver strings with same-width digit parts, which is
-    // reliable at this stage of the version space.
+    // clobber a fresh committed helper). Compare numeric components:
+    // lexicographic comparison freezes 3.32.24 below 3.32.8 (#2811).
     const helperVerMatch = helperContent.match(/let ver = "([^"]+)";/);
     const helperVer = helperVerMatch ? helperVerMatch[1] : '';
-    if (!helperVer || bakedVersion > helperVer) {
+    if (!helperVer || compareVersionsLocal(bakedVersion, helperVer) > 0) {
         helperContent = helperContent.replace(/let ver = "[^"]+";/, `let ver = ${JSON.stringify(bakedVersion)};`);
     }
     return helperContent;

package/v3/@claude-flow/cli/dist/src/mcp-server.d.ts

@@ -48,6 +48,31 @@ export interface MCPServerStatus {
         metrics?: Record<string, number>;
     };
 }
+export declare function parseMcpToolSelection(value: string | undefined): string[] | 'all';
+/**
+ * Apply the existing `--tools` contract to advertised schemas. A selector can
+ * be an exact tool name, a category, or a namespace prefix (`memory` matches
+ * `memory_store`). Execution remains registered internally; only the fixed
+ * per-request schema catalogue is reduced.
+ */
+export declare function filterAdvertisedMcpTools<T extends {
+    name: string;
+    category?: string;
+}>(tools: T[], selection: string[] | 'all'): T[];
+export interface McpSchemaOverhead {
+    toolCount: number;
+    bytes: number;
+    estimatedTokens: number;
+    contextWindowTokens?: number;
+    ratio?: number;
+    risk: 'normal' | 'high';
+}
+/** Conservative JSON-size estimate for the fixed tools/list catalogue. */
+export declare function assessMcpSchemaOverhead(tools: Array<{
+    name: string;
+    description?: string;
+    inputSchema?: unknown;
+}>, contextWindowTokens?: number): McpSchemaOverhead;
 /**
  * MCP Server Manager
  *

package/v3/@claude-flow/cli/dist/src/mcp-server.js

@@ -42,6 +42,54 @@ const DEFAULT_OPTIONS = {
     daemonize: false,
     timeout: 30000,
 };
+export function parseMcpToolSelection(value) {
+    if (!value || value.trim().toLowerCase() === 'all')
+        return 'all';
+    const selectors = value.split(',').map((item) => item.trim()).filter(Boolean);
+    return selectors.length > 0 ? selectors : 'all';
+}
+/**
+ * Apply the existing `--tools` contract to advertised schemas. A selector can
+ * be an exact tool name, a category, or a namespace prefix (`memory` matches
+ * `memory_store`). Execution remains registered internally; only the fixed
+ * per-request schema catalogue is reduced.
+ */
+export function filterAdvertisedMcpTools(tools, selection) {
+    if (selection === 'all')
+        return tools;
+    const selectors = new Set(selection.map((item) => item.toLowerCase()));
+    return tools.filter((tool) => {
+        const name = tool.name.toLowerCase();
+        const category = tool.category?.toLowerCase();
+        return selectors.has(name)
+            || (category !== undefined && selectors.has(category))
+            || Array.from(selectors).some((selector) => name.startsWith(`${selector}_`));
+    });
+}
+/** Conservative JSON-size estimate for the fixed tools/list catalogue. */
+export function assessMcpSchemaOverhead(tools, contextWindowTokens) {
+    const catalogue = tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+    }));
+    const bytes = Buffer.byteLength(JSON.stringify(catalogue), 'utf8');
+    const estimatedTokens = Math.ceil(bytes / 4);
+    const validWindow = Number.isFinite(contextWindowTokens) && Number(contextWindowTokens) > 0
+        ? Number(contextWindowTokens)
+        : undefined;
+    const ratio = validWindow ? estimatedTokens / validWindow : undefined;
+    return {
+        toolCount: tools.length,
+        bytes,
+        estimatedTokens,
+        ...(validWindow === undefined ? {} : { contextWindowTokens: validWindow }),
+        ...(ratio === undefined ? {} : { ratio }),
+        risk: (ratio !== undefined ? ratio >= 0.2 : estimatedTokens >= 8_000)
+            ? 'high'
+            : 'normal',
+    };
+}
 /**
  * MCP Server Manager
  *
@@ -55,7 +103,14 @@ export class MCPServerManager extends EventEmitter {
     healthCheckInterval;
     constructor(options = {}) {
         super();
-        this.options = { ...DEFAULT_OPTIONS, ...options };
+        // `options.tools`, populated by the `mcp start --tools` CLI flag, is
+        // spread last below and therefore takes precedence over this env fallback.
+        const environmentTools = parseMcpToolSelection(process.env.CLAUDE_FLOW_MCP_TOOLS);
+        this.options = {
+            ...DEFAULT_OPTIONS,
+            ...(environmentTools === 'all' ? {} : { tools: environmentTools }),
+            ...options,
+        };
     }
     /**
      * Start the MCP server
@@ -420,7 +475,7 @@ export class MCPServerManager extends EventEmitter {
                         },
                     };
                 case 'tools/list':
-                    const tools = listMCPTools();
+                    const tools = filterAdvertisedMcpTools(listMCPTools(), this.options.tools);
                     return {
                         jsonrpc: '2.0',
                         id: message.id,

package/v3/@claude-flow/cli/dist/src/mcp-tools/embeddings-tools.js

@@ -50,13 +50,16 @@ async function getRealEmbeddingFunction() {
     }
     return realEmbeddingFn;
 }
-// Generate real ONNX embedding (falls back to deterministic hash if ONNX unavailable)
 async function generateRealEmbedding(text, dimension) {
     const realFn = await getRealEmbeddingFunction();
     if (realFn) {
         try {
             const result = await realFn(text);
-            return result.embedding;
+            return {
+                embedding: result.embedding,
+                backend: result.backend ?? 'onnx',
+                model: result.model,
+            };
         }
         catch {
             // Fall through to fallback
@@ -75,7 +78,11 @@ async function generateRealEmbedding(text, dimension) {
     }
     // L2 normalize
     const norm = Math.sqrt(embedding.reduce((sum, x) => sum + x * x, 0));
-    return embedding.map(x => x / norm);
+    return {
+        embedding: embedding.map(x => x / norm),
+        backend: 'mock',
+        model: 'hash-fallback',
+    };
 }
 // Convert Euclidean embedding to Poincaré ball
 function toPoincare(euclidean, curvature) {
@@ -238,7 +245,8 @@ export const embeddingsTools = [
             }
             const useHyperbolic = input.hyperbolic === true && config.hyperbolic.enabled;
             // Generate real ONNX embedding
-            const embedding = await generateRealEmbedding(text, config.dimension);
+            const generated = await generateRealEmbedding(text, config.dimension);
+            const embedding = generated.embedding;
             let result;
             let geometry;
             if (useHyperbolic) {
@@ -254,6 +262,8 @@ export const embeddingsTools = [
                 embedding: result,
                 metadata: {
                     model: config.model,
+                    embeddingBackend: generated.backend,
+                    semanticGrounded: generated.backend === 'onnx',
                     dimension: config.dimension,
                     geometry,
                     curvature: useHyperbolic ? config.hyperbolic.curvature : null,
@@ -309,10 +319,13 @@ export const embeddingsTools = [
                     return { success: false, error: v.error };
             }
             // Generate real ONNX embeddings for both texts
-            const [emb1, emb2] = await Promise.all([
+            const [generated1, generated2] = await Promise.all([
                 generateRealEmbedding(text1, config.dimension),
                 generateRealEmbedding(text2, config.dimension)
             ]);
+            const emb1 = generated1.embedding;
+            const emb2 = generated2.embedding;
+            const embeddingBackend = generated1.backend === 'onnx' && generated2.backend === 'onnx' ? 'onnx' : 'mock';
             let similarity;
             let distance;
             switch (metric) {
@@ -341,14 +354,21 @@ export const embeddingsTools = [
                 similarity,
                 distance,
                 metric,
+                embeddingBackend,
+                semanticGrounded: embeddingBackend === 'onnx',
                 texts: {
                     text1: { length: text1.length, preview: text1.slice(0, 50) },
                     text2: { length: text2.length, preview: text2.slice(0, 50) },
                 },
-                interpretation: similarity > 0.8 ? 'very similar' :
-                    similarity > 0.6 ? 'similar' :
-                        similarity > 0.4 ? 'somewhat similar' :
-                            similarity > 0.2 ? 'different' : 'very different',
+                interpretation: embeddingBackend === 'onnx'
+                    ? similarity > 0.8 ? 'very similar'
+                        : similarity > 0.6 ? 'similar'
+                            : similarity > 0.4 ? 'somewhat similar'
+                                : similarity > 0.2 ? 'different' : 'very different'
+                    : null,
+                warning: embeddingBackend === 'mock'
+                    ? 'Hash fallback scores are deterministic but not semantically meaningful.'
+                    : undefined,
             };
         },
     },
@@ -426,6 +446,8 @@ export const embeddingsTools = [
                     })),
                     metadata: {
                         model: config.model,
+                        embeddingBackend: queryEmbedding.backend,
+                        semanticGrounded: queryEmbedding.backend === 'onnx',
                         topK,
                         threshold,
                         namespace: namespace || 'all',
@@ -433,6 +455,9 @@ export const embeddingsTools = [
                         indexType: config.hyperbolic.enabled ? 'HNSW (hyperbolic)' : 'HNSW (euclidean)',
                         resultCount: searchResult.results.length
                     },
+                    warning: queryEmbedding.backend === 'mock'
+                        ? 'Results use a hash fallback and are not semantically ranked.'
+                        : undefined,
                 };
             }
             catch {
@@ -444,12 +469,17 @@ export const embeddingsTools = [
                     results: [],
                     metadata: {
                         model: config.model,
+                        embeddingBackend: queryEmbedding.backend,
+                        semanticGrounded: queryEmbedding.backend === 'onnx',
                         topK,
                         threshold,
                         namespace: namespace || 'all',
                         searchTime: `${searchTime}ms`,
                         indexType: config.hyperbolic.enabled ? 'HNSW (hyperbolic)' : 'HNSW (euclidean)',
                     },
+                    warning: queryEmbedding.backend === 'mock'
+                        ? 'Hash fallback is active; semantic search is unavailable.'
+                        : undefined,
                     message: 'No embeddings indexed yet. Use memory store to add documents.',
                 };
             }
@@ -795,6 +825,8 @@ export const embeddingsTools = [
             }
             catch { /* not installed */ }
             const ruvectorEnabled = config.neural.ruvector?.enabled ?? false;
+            const backendProbe = await generateRealEmbedding('ruflo embedding backend probe', config.dimension);
+            const semanticGrounded = backendProbe.backend === 'onnx';
             return {
                 success: true,
                 initialized: true,
@@ -822,11 +854,20 @@ export const embeddingsTools = [
                     models: config.modelPath,
                 },
                 initializedAt: config.initialized,
+                embeddingBackend: backendProbe.backend,
+                semanticGrounded,
+                warning: semanticGrounded
+                    ? undefined
+                    : 'Hash fallback is active. Similarity scores are deterministic but not semantically meaningful.',
                 capabilities: {
                     onnxModels: ['Xenova/all-MiniLM-L6-v2', 'Xenova/all-mpnet-base-v2'],
                     geometries: ['euclidean', 'poincare'],
                     normalizations: ['L2', 'L1', 'minmax', 'zscore'],
-                    features: ['semantic search', 'hyperbolic projection', 'neural substrate'],
+                    features: [
+                        ...(semanticGrounded ? ['semantic search'] : []),
+                        'hyperbolic projection',
+                        'neural substrate',
+                    ],
                 },
             };
         },

package/v3/@claude-flow/cli/dist/src/mcp-tools/hooks-tools.js

@@ -439,6 +439,20 @@ function getIntelligenceStatsFromMemory() {
         const category = e.metadata?.category || 'general';
         categories[category] = (categories[category] || 0) + 1;
     });
+    const successfulPatterns = patternEntries.filter(e => e.metadata?.success === true).length;
+    const failedPatterns = patternEntries.filter(e => e.metadata?.success === false).length;
+    const describedPatterns = patternEntries.filter(e => {
+        if (typeof e.metadata?.task === 'string' && e.metadata.task.trim())
+            return true;
+        try {
+            const value = typeof e.value === 'string' ? JSON.parse(e.value) : e.value;
+            return typeof value?.task === 'string' &&
+                Boolean(String(value.task).trim());
+        }
+        catch {
+            return false;
+        }
+    }).length;
     // Count routing decisions
     const routingEntries = entries.filter(e => e.key.includes('routing') ||
         e.metadata?.type === 'routing-decision');
@@ -472,6 +486,10 @@ function getIntelligenceStatsFromMemory() {
         },
         patterns: {
             learned: patternEntries.length,
+            successful: successfulPatterns,
+            failed: failedPatterns,
+            unknown: Math.max(0, patternEntries.length - successfulPatterns - failedPatterns),
+            described: describedPatterns,
             categories,
         },
         memory: {
@@ -1074,21 +1092,28 @@ export const hooksMetrics = {
                 agentCounts[o.agent] = (agentCounts[o.agent] || 0) + 1;
         }
         const topAgent = Object.entries(agentCounts).sort((a, b) => b[1] - a[1])[0]?.[0] ?? null;
-        const successful = stats.trajectories.successful;
-        const total = stats.trajectories.total;
-        const failed = Math.max(0, total - successful);
         return {
             _real: true,
             _dataSource: 'intelligence-stats + routing-outcomes',
             period,
             patterns: {
                 total: stats.patterns.learned,
-                successful,
-                failed,
+                successful: stats.patterns.successful,
+                failed: stats.patterns.failed,
+                unknown: stats.patterns.unknown,
+                described: stats.patterns.described,
+                descriptionCoverage: stats.patterns.learned > 0
+                    ? stats.patterns.described / stats.patterns.learned
+                    : null,
                 avgConfidence: stats.routing.avgConfidence || null,
             },
             agents: {
-                routingAccuracy: stats.routing.avgConfidence || null,
+                // Confidence is a model self-score, not observed routing accuracy
+                // (#2809). Keep the old key as an explicit null for compatibility
+                // while exposing the truthful additive field.
+                routingAccuracy: null,
+                averageConfidence: stats.routing.avgConfidence || null,
+                outcomeSuccessRate: successRate,
                 totalRoutes: stats.routing.decisions,
                 topAgent,
             },
@@ -1097,7 +1122,7 @@ export const hooksMetrics = {
                 successRate,
                 avgRiskScore: null,
             },
-            _note: total === 0 && totalCommands === 0
+            _note: stats.patterns.learned === 0 && totalCommands === 0
                 ? 'No metrics data collected yet. Run hooks_post-task / hooks_intelligence_trajectory-end / hooks_route to populate.'
                 : undefined,
             lastUpdated: new Date().toISOString(),
@@ -1311,6 +1336,7 @@ export const hooksPostTask = {
             const bridge = await import('../memory/memory-bridge.js');
             feedbackResult = await bridge.bridgeRecordFeedback({
                 taskId,
+                task: params.task || undefined,
                 success,
                 quality,
                 agent,
@@ -3136,7 +3162,7 @@ export const hooksIntelligenceStats = {
         catch {
             memoryStats = {
                 trajectories: { total: 0, successful: 0 },
-                patterns: { learned: 0, categories: {} },
+                patterns: { learned: 0, successful: 0, failed: 0, unknown: 0, described: 0, categories: {} },
                 memory: { indexSize: 0, totalAccessCount: 0, memorySizeBytes: 0 },
                 routing: { decisions: 0, avgConfidence: 0 },
             };

package/v3/@claude-flow/cli/dist/src/memory/memory-bridge.d.ts

@@ -322,6 +322,8 @@ export declare function bridgeSearchPatterns(options: {
  */
 export declare function bridgeRecordFeedback(options: {
     taskId: string;
+    /** Human-readable task text used as the semantic learning signal. */
+    task?: string;
     success: boolean;
     quality: number;
     agent?: string;

package/v3/@claude-flow/cli/dist/src/memory/memory-bridge.js

@@ -1840,11 +1840,15 @@ export async function bridgeRecordFeedback(options) {
         try {
             const intelligence = await import('./intelligence.js');
             const verdict = options.success ? 'success' : 'failure';
+            const taskContext = options.task?.trim();
             const recorded = await intelligence.recordTrajectory([{
                     type: 'action',
-                    content: `Task ${options.taskId} completed by ${options.agent || 'unknown'} — success=${options.success}, quality=${options.quality.toFixed(3)}`,
+                    // Put the task description first so the embedding represents the
+                    // work, not just the bookkeeping suffix (#2812).
+                    content: `${taskContext ? `${taskContext} — ` : ''}Task ${options.taskId} completed by ${options.agent || 'unknown'} — success=${options.success}, quality=${options.quality.toFixed(3)}`,
                     metadata: {
                         taskId: options.taskId,
+                        task: taskContext,
                         agent: options.agent,
                         quality: options.quality,
                         duration: options.duration,

package/v3/@claude-flow/cli/dist/src/services/memory-distillation.d.ts

@@ -20,6 +20,7 @@ export interface DistillOptions {
 export interface DistillReport {
     processed: number;
     episodes: number;
+    episodeEmbeddings: number;
     patterns: number;
     patternEmbeddings: number;
     causalEdges: number;