claude-flow 3.10.41 → 3.10.42

package/.claude/scheduled_tasks.lock

@@ -0,0 +1 @@
+{"sessionId":"d0b433ab-a217-4dde-9ea4-b2c996ac456a","pid":35460,"acquiredAt":1781120150954}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.10.41",
+  "version": "3.10.42",
   "description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

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

@@ -399,9 +399,20 @@ const postEditCommand = {
                 metrics,
                 timestamp: Date.now(),
             });
+            // #2352: the MCP handler returns `{success: false, error: "..."}` on
+            // validation failure (e.g. unsupported path shape) without throwing.
+            // Surface that explicitly instead of always printing the success line —
+            // Windows users were seeing `[OK]` while nothing reached the learning
+            // pipeline because absolute paths were rejected upstream.
+            const mcpFailed = result && result.success === false;
+            const mcpError = result?.error;
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
-                return { success: true, data: result };
+                return { success: !mcpFailed, exitCode: mcpFailed ? 1 : 0, data: result };
+            }
+            if (mcpFailed) {
+                output.printError(`Post-edit hook failed: ${mcpError || 'unknown error'}`);
+                return { success: false, exitCode: 1 };
             }
             output.writeln();
             output.printSuccess(`Outcome recorded for ${filePath}`);

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

@@ -773,7 +773,13 @@ const hooksCommand = {
                 skills: false,
                 commands: false,
                 agents: false,
-                helpers: false,
+                // #2350: helpers MUST ship with the hooks subcommand. The hook entries
+                // in settings.json point at `.claude/helpers/hook-handler.cjs`; if
+                // that file doesn't exist, settings-generator (#1744 fix) drops the
+                // hooks block entirely — so the one subcommand whose stated purpose
+                // is "Initialize only hooks configuration" produced settings.json
+                // with no `hooks` key while reporting "N hooks enabled".
+                helpers: true,
                 statusline: false,
                 mcp: false,
                 runtime: false,

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

@@ -2665,7 +2665,81 @@ export const hooksTrajectoryEnd = {
             }
             catch { /* intelligence module not loadable — keep sona-only behaviour */ }
         }
+        // #2351: when an agent calls trajectory-end with no recorded steps but a
+        // non-empty `feedback` string, the feedback was previously dropped on the
+        // floor — `patternsExtracted` reported 0 and `pattern-search` never
+        // surfaced it. Step-less trajectories are the common case for LLM agents
+        // (nothing forces step logging mid-task), and feedback is often the most
+        // distilled lesson available. Route it through the same store + embed
+        // path that pattern-store uses so it becomes searchable. Best-effort:
+        // failures here must not turn the trajectory-end call itself into a
+        // failure — the trajectory record was already persisted above.
+        let feedbackDistilled = { stored: false };
+        const hasSteps = !!trajectory && trajectory.steps.length > 0;
+        const trimmedFeedback = typeof feedback === 'string' ? feedback.trim() : '';
+        if (trajectory && !hasSteps && trimmedFeedback.length > 0) {
+            const distilledPatternId = `pattern-feedback-${trajectoryId}-${Date.now()}`;
+            const patternMetadata = {
+                sourceTrajectoryId: trajectoryId,
+                task: trajectory.task,
+                agent: trajectory.agent,
+                outcome: success ? 'success' : 'failure',
+                distilledFrom: 'trajectory-end-feedback',
+            };
+            // Modest default confidence — step-less feedback hasn't been validated
+            // by execution evidence the way a multi-step trajectory has.
+            const feedbackConfidence = success ? 0.6 : 0.4;
+            try {
+                const bridge = await import('../memory/memory-bridge.js');
+                const rb = await bridge.bridgeStorePattern({
+                    pattern: trimmedFeedback,
+                    type: 'trajectory-feedback',
+                    confidence: feedbackConfidence,
+                    metadata: patternMetadata,
+                });
+                if (rb?.success) {
+                    feedbackDistilled = { stored: true, patternId: rb.patternId, controller: rb.controller };
+                }
+            }
+            catch {
+                // Bridge unavailable — fall through to direct store
+            }
+            if (!feedbackDistilled.stored) {
+                try {
+                    const storeFn = await getRealStoreFunction();
+                    if (storeFn) {
+                        const r = await storeFn({
+                            key: distilledPatternId,
+                            value: JSON.stringify({
+                                pattern: trimmedFeedback,
+                                type: 'trajectory-feedback',
+                                confidence: feedbackConfidence,
+                                metadata: patternMetadata,
+                                timestamp: endedAt,
+                            }),
+                            namespace: 'pattern',
+                            generateEmbeddingFlag: true,
+                            tags: [
+                                'trajectory-feedback',
+                                success ? 'success' : 'failure',
+                                `confidence-${Math.round(feedbackConfidence * 100)}`,
+                            ],
+                        });
+                        if (r?.success) {
+                            feedbackDistilled = { stored: true, patternId: r.id || distilledPatternId, controller: 'store-fallback' };
+                        }
+                    }
+                }
+                catch {
+                    // Both paths failed — leave feedbackDistilled.stored = false.
+                }
+            }
+        }
         const learningTimeMs = Date.now() - startTime;
+        // patternsExtracted now reflects either recorded steps (the original
+        // semantics) OR a distilled feedback pattern (#2351), so step-less
+        // trajectories with useful feedback no longer report 0.
+        const patternsExtracted = (trajectory?.steps.length || 0) + (feedbackDistilled.stored ? 1 : 0);
         return {
             trajectoryId,
             success,
@@ -2678,7 +2752,11 @@ export const hooksTrajectoryEnd = {
                 sonaConfidence: sonaResult.confidence || undefined,
                 ewcConsolidation: ewcResult.consolidated,
                 ewcPenalty: ewcResult.penalty || undefined,
-                patternsExtracted: trajectory?.steps.length || 0,
+                patternsExtracted,
+                feedbackDistilled: feedbackDistilled.stored ? {
+                    patternId: feedbackDistilled.patternId,
+                    controller: feedbackDistilled.controller,
+                } : undefined,
                 learningTimeMs,
                 globalStatsTrajectoriesDelta: globalStatsDelta, // Round B: was 0, now reflects
             },

package/v3/@claude-flow/cli/dist/src/ruvector/neural-router.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Neural routing scaffold — `@ruvector/tiny-dancer` FastGRNN seam (#2334 Phase 1)
+ *
+ * Wires the optional neural path that ADR-026 originally described, behind a
+ * double gate that is OFF by default:
+ *
+ *   CLAUDE_FLOW_ROUTER_NEURAL=1                      — opt in to the neural path
+ *   CLAUDE_FLOW_ROUTER_MODEL_PATH=<x.safetensors>    — trained FastGRNN artifact
+ *
+ * Both must be set; otherwise `tryNeuralRoute` returns `null` immediately and
+ * the caller stays on the shipped heuristic + Thompson-bandit path. When the
+ * gate is open but anything fails (package not installed — it is an
+ * optionalDependency per ADR-124 — artifact missing/incompatible, runtime
+ * error), this module degrades gracefully: it returns `null`, never throws,
+ * and the caller reports `routedBy: 'bandit-fallback'` so the active path is
+ * observable rather than inferred from import success (ADR-086/074).
+ *
+ * Candidate modeling (#2334 Q3, provisional): the 3 model tiers are encoded as
+ * fixed candidates with deterministic placeholder embeddings (orthogonal-ish
+ * one-hot-block vectors). This is explicitly provisional — the trained Phase 2
+ * artifact defines what candidate embeddings mean, and this encoding is the
+ * scaffolding default until the maintainers answer #2334's candidate-modeling
+ * question. Until a real artifact exists the gate stays closed in practice, so
+ * the placeholder never influences routing.
+ *
+ * @module neural-router
+ */
+/** The three routable tiers — 'inherit' is never a neural candidate. */
+export type NeuralRoutableModel = 'haiku' | 'sonnet' | 'opus';
+export interface NeuralRouteDecision {
+    model: NeuralRoutableModel;
+    confidence: number;
+    uncertainty: number;
+    inferenceTimeUs: number;
+}
+/** True when the user has opted in AND pointed at a model artifact. */
+export declare function neuralRoutingEnabled(): boolean;
+/** Reset cached state — for tests. */
+export declare function resetNeuralRouter(): void;
+/**
+ * Attempt a neural routing decision for the given task embedding.
+ *
+ * Returns `null` (never throws) when the gate is closed, the package or
+ * artifact is unavailable, or inference fails — callers fall back to the
+ * bandit and report `routedBy: 'bandit-fallback'` (when the gate was open)
+ * or `'heuristic'` (when it never was).
+ */
+export declare function tryNeuralRoute(embedding: number[]): Promise<NeuralRouteDecision | null>;
+//# sourceMappingURL=neural-router.d.ts.map

package/v3/@claude-flow/cli/dist/src/ruvector/neural-router.js

@@ -0,0 +1,132 @@
+/**
+ * Neural routing scaffold — `@ruvector/tiny-dancer` FastGRNN seam (#2334 Phase 1)
+ *
+ * Wires the optional neural path that ADR-026 originally described, behind a
+ * double gate that is OFF by default:
+ *
+ *   CLAUDE_FLOW_ROUTER_NEURAL=1                      — opt in to the neural path
+ *   CLAUDE_FLOW_ROUTER_MODEL_PATH=<x.safetensors>    — trained FastGRNN artifact
+ *
+ * Both must be set; otherwise `tryNeuralRoute` returns `null` immediately and
+ * the caller stays on the shipped heuristic + Thompson-bandit path. When the
+ * gate is open but anything fails (package not installed — it is an
+ * optionalDependency per ADR-124 — artifact missing/incompatible, runtime
+ * error), this module degrades gracefully: it returns `null`, never throws,
+ * and the caller reports `routedBy: 'bandit-fallback'` so the active path is
+ * observable rather than inferred from import success (ADR-086/074).
+ *
+ * Candidate modeling (#2334 Q3, provisional): the 3 model tiers are encoded as
+ * fixed candidates with deterministic placeholder embeddings (orthogonal-ish
+ * one-hot-block vectors). This is explicitly provisional — the trained Phase 2
+ * artifact defines what candidate embeddings mean, and this encoding is the
+ * scaffolding default until the maintainers answer #2334's candidate-modeling
+ * question. Until a real artifact exists the gate stays closed in practice, so
+ * the placeholder never influences routing.
+ *
+ * @module neural-router
+ */
+import { existsSync } from 'fs';
+// ============================================================================
+// Gate & lifecycle
+// ============================================================================
+/** True when the user has opted in AND pointed at a model artifact. */
+export function neuralRoutingEnabled() {
+    return process.env.CLAUDE_FLOW_ROUTER_NEURAL === '1'
+        && !!process.env.CLAUDE_FLOW_ROUTER_MODEL_PATH;
+}
+// Cached router instance + a sticky failure latch so a broken install/artifact
+// costs one failed load, not one per routing call.
+let routerInstance = null;
+let loadFailed = false;
+/** Reset cached state — for tests. */
+export function resetNeuralRouter() {
+    routerInstance = null;
+    loadFailed = false;
+}
+async function loadRouter() {
+    if (routerInstance)
+        return routerInstance;
+    if (loadFailed)
+        return null;
+    const modelPath = process.env.CLAUDE_FLOW_ROUTER_MODEL_PATH;
+    if (!modelPath || !existsSync(modelPath)) {
+        loadFailed = true;
+        return null;
+    }
+    try {
+        // Dynamic import of an optionalDependency (ADR-124): absent on installs
+        // where the native binding failed or was skipped — degrade, don't throw.
+        const mod = await import('@ruvector/tiny-dancer');
+        const RouterCtor = mod.Router;
+        if (!RouterCtor) {
+            loadFailed = true;
+            return null;
+        }
+        routerInstance = new RouterCtor({ modelPath });
+        return routerInstance;
+    }
+    catch {
+        loadFailed = true;
+        return null;
+    }
+}
+// ============================================================================
+// Candidate encoding (provisional — see header + #2334 Q3)
+// ============================================================================
+const TIER_ORDER = ['haiku', 'sonnet', 'opus'];
+/**
+ * Deterministic placeholder embedding for a tier candidate: a block one-hot
+ * over the embedding dimensionality. Replaced by whatever the Phase 2 trained
+ * artifact defines as candidate space.
+ */
+function tierCandidateEmbedding(tierIndex, dim) {
+    const v = new Array(dim).fill(0);
+    const block = Math.max(1, Math.floor(dim / TIER_ORDER.length));
+    const start = tierIndex * block;
+    for (let i = start; i < Math.min(start + block, dim); i++)
+        v[i] = 1 / Math.sqrt(block);
+    return v;
+}
+// ============================================================================
+// Routing
+// ============================================================================
+/**
+ * Attempt a neural routing decision for the given task embedding.
+ *
+ * Returns `null` (never throws) when the gate is closed, the package or
+ * artifact is unavailable, or inference fails — callers fall back to the
+ * bandit and report `routedBy: 'bandit-fallback'` (when the gate was open)
+ * or `'heuristic'` (when it never was).
+ */
+export async function tryNeuralRoute(embedding) {
+    if (!neuralRoutingEnabled())
+        return null;
+    if (!embedding || embedding.length === 0)
+        return null;
+    const router = await loadRouter();
+    if (!router)
+        return null;
+    try {
+        const response = await router.route({
+            queryEmbedding: embedding,
+            candidates: TIER_ORDER.map((tier, i) => ({
+                id: tier,
+                embedding: tierCandidateEmbedding(i, embedding.length),
+                metadata: JSON.stringify({ tier }),
+            })),
+        });
+        const best = response.decisions?.[0];
+        if (!best || !TIER_ORDER.includes(best.candidateId))
+            return null;
+        return {
+            model: best.candidateId,
+            confidence: best.confidence,
+            uncertainty: best.uncertainty,
+            inferenceTimeUs: response.inferenceTimeUs,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=neural-router.js.map

package/v3/@claude-flow/cli/dist/src/ruvector/router-trajectory.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Router trajectory collection (#2334 Phase 1)
+ *
+ * Opt-in per-decision dataset collection for the model router. The persisted
+ * bandit state (`.swarm/model-router-state.json`) keeps only aggregates —
+ * 9 Beta(α,β) cells and a capped/truncated history — which is not trainable
+ * material for the Phase 2 FastGRNN tier-classifier. This sidecar captures
+ * the per-example rows that training needs:
+ *
+ *   decision rows: { taskHash, task, embedding?, complexity, features,
+ *                    model, confidence, uncertainty, routedBy, ts }
+ *   outcome rows:  { taskHash, model, outcome, ts }
+ *
+ * joined offline on `taskHash` (sha256-16 of the task text).
+ *
+ * OFF by default. Enable with CLAUDE_FLOW_ROUTER_TRAJECTORY=1. Rows append to
+ * `.swarm/model-router-trajectories.jsonl` — local-only, same trust domain as
+ * the existing state file, but unlike it the rows contain full task text (up
+ * to 500 chars) and raw embeddings, which is why this is opt-in rather than
+ * always-on.
+ *
+ * Writes are best-effort: any fs error is swallowed (collection must never
+ * break routing), matching the state-file behavior in model-router.ts.
+ *
+ * @module router-trajectory
+ */
+export declare const TRAJECTORY_FILE = ".swarm/model-router-trajectories.jsonl";
+export declare function trajectoryCollectionEnabled(): boolean;
+/** Join key: first 16 hex chars of sha256(task). */
+export declare function taskHash(task: string): string;
+export interface TrajectoryDecisionRow {
+    v: number;
+    type: 'decision';
+    ts: string;
+    taskHash: string;
+    /** Task text, capped at 500 chars (cf. learningHistory's 100). */
+    task: string;
+    /** Raw embedding when one was threaded through route(); else omitted. */
+    embedding?: number[];
+    complexity: number;
+    features: {
+        lexicalComplexity: number;
+        semanticDepth: number;
+        taskScope: number;
+        uncertaintyLevel: number;
+    };
+    model: string;
+    confidence: number;
+    uncertainty: number;
+    routedBy: string;
+}
+export interface TrajectoryOutcomeRow {
+    v: number;
+    type: 'outcome';
+    ts: string;
+    taskHash: string;
+    model: string;
+    outcome: 'success' | 'failure' | 'escalated';
+}
+export declare function recordTrajectoryDecision(task: string, embedding: number[] | undefined, complexity: TrajectoryDecisionRow['features'] & {
+    score: number;
+}, decision: {
+    model: string;
+    confidence: number;
+    uncertainty: number;
+    routedBy: string;
+}): void;
+export declare function recordTrajectoryOutcome(task: string, model: string, outcome: 'success' | 'failure' | 'escalated'): void;
+//# sourceMappingURL=router-trajectory.d.ts.map

package/v3/@claude-flow/cli/dist/src/ruvector/router-trajectory.js

@@ -0,0 +1,87 @@
+/**
+ * Router trajectory collection (#2334 Phase 1)
+ *
+ * Opt-in per-decision dataset collection for the model router. The persisted
+ * bandit state (`.swarm/model-router-state.json`) keeps only aggregates —
+ * 9 Beta(α,β) cells and a capped/truncated history — which is not trainable
+ * material for the Phase 2 FastGRNN tier-classifier. This sidecar captures
+ * the per-example rows that training needs:
+ *
+ *   decision rows: { taskHash, task, embedding?, complexity, features,
+ *                    model, confidence, uncertainty, routedBy, ts }
+ *   outcome rows:  { taskHash, model, outcome, ts }
+ *
+ * joined offline on `taskHash` (sha256-16 of the task text).
+ *
+ * OFF by default. Enable with CLAUDE_FLOW_ROUTER_TRAJECTORY=1. Rows append to
+ * `.swarm/model-router-trajectories.jsonl` — local-only, same trust domain as
+ * the existing state file, but unlike it the rows contain full task text (up
+ * to 500 chars) and raw embeddings, which is why this is opt-in rather than
+ * always-on.
+ *
+ * Writes are best-effort: any fs error is swallowed (collection must never
+ * break routing), matching the state-file behavior in model-router.ts.
+ *
+ * @module router-trajectory
+ */
+import { createHash } from 'crypto';
+import { appendFileSync, existsSync, mkdirSync } from 'fs';
+import { dirname, join } from 'path';
+export const TRAJECTORY_FILE = '.swarm/model-router-trajectories.jsonl';
+/** Schema version stamped on every row so offline training can dispatch. */
+const ROW_VERSION = 1;
+export function trajectoryCollectionEnabled() {
+    return process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY === '1';
+}
+/** Join key: first 16 hex chars of sha256(task). */
+export function taskHash(task) {
+    return createHash('sha256').update(task).digest('hex').slice(0, 16);
+}
+function appendRow(row) {
+    try {
+        const fullPath = join(process.cwd(), TRAJECTORY_FILE);
+        const dir = dirname(fullPath);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        appendFileSync(fullPath, JSON.stringify(row) + '\n');
+    }
+    catch {
+        // Best-effort: collection must never break routing.
+    }
+}
+export function recordTrajectoryDecision(task, embedding, complexity, decision) {
+    if (!trajectoryCollectionEnabled())
+        return;
+    appendRow({
+        v: ROW_VERSION,
+        type: 'decision',
+        ts: new Date().toISOString(),
+        taskHash: taskHash(task),
+        task: task.slice(0, 500),
+        ...(embedding && embedding.length > 0 ? { embedding } : {}),
+        complexity: complexity.score,
+        features: {
+            lexicalComplexity: complexity.lexicalComplexity,
+            semanticDepth: complexity.semanticDepth,
+            taskScope: complexity.taskScope,
+            uncertaintyLevel: complexity.uncertaintyLevel,
+        },
+        model: decision.model,
+        confidence: decision.confidence,
+        uncertainty: decision.uncertainty,
+        routedBy: decision.routedBy,
+    });
+}
+export function recordTrajectoryOutcome(task, model, outcome) {
+    if (!trajectoryCollectionEnabled())
+        return;
+    appendRow({
+        v: ROW_VERSION,
+        type: 'outcome',
+        ts: new Date().toISOString(),
+        taskHash: taskHash(task),
+        model,
+        outcome,
+    });
+}
+//# sourceMappingURL=router-trajectory.js.map

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.10.41",
+  "version": "3.10.42",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",