claude-flow 3.10.40 → 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.40",
+  "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/hive-mind.js

@@ -306,7 +306,20 @@ async function spawnClaudeCodeInstance(swarmId, swarmName, objective, workers, f
             output.printSuccess('Claude Code launched with Hive Mind coordination');
             output.printInfo('The Queen coordinator will orchestrate all worker agents');
             output.writeln(output.dim(`Prompt file saved at: ${promptFile}`));
-            return { success: true, promptFile };
+            // #2297: await child exit before returning. Without this, the CLI
+            // process resolves immediately, finishes, and the still-initializing
+            // `claude` child loses its controlling terminal and is killed mid-launch
+            // — visible as a stray XTVERSION reply leaking onto the next shell
+            // prompt (the terminal queried for capabilities, but the child died
+            // before reading the answer). Awaiting also makes the existing
+            // claudeProcess.on('exit', ...) log lines actually print, and lets the
+            // non-interactive (-p / --non-interactive) path complete only after
+            // Claude Code finishes.
+            const claudeExitCode = await new Promise((resolve) => {
+                claudeProcess.on('exit', (c) => resolve(c ?? 0));
+                claudeProcess.on('error', () => resolve(1));
+            });
+            return { success: claudeExitCode === 0, promptFile };
         }
         else if (dryRun) {
             output.writeln();

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}`);
@@ -1560,6 +1571,19 @@ const postTaskCommand = {
             short: 'a',
             description: 'Agent that executed the task',
             type: 'string'
+        },
+        {
+            // ADR-147 P2: nested-subagent spawn-tree capture
+            name: 'parent-agent-id',
+            description: 'ID of the parent agent (from Claude Code\'s parent_agent_id OTel span tag). Omit for top-level work.',
+            type: 'string',
+            required: false
+        },
+        {
+            name: 'depth',
+            description: 'Chain depth from root lead session (0 = lead, 1+ = subagent). Used by ADR-147 P3 depth-aware guardrail.',
+            type: 'number',
+            required: false
         }
     ],
     examples: [
@@ -1579,6 +1603,9 @@ const postTaskCommand = {
                 quality: ctx.flags.quality,
                 agent: ctx.flags.agent,
                 timestamp: Date.now(),
+                // ADR-147 P2: forward spawn-tree lineage if caller supplied it
+                parentAgentId: ctx.flags.parentAgentId,
+                depth: ctx.flags.depth,
             });
             if (ctx.flags.format === 'json') {
                 output.printJson(result);

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/init/statusline-generator.js

@@ -65,10 +65,51 @@ const CONFIG = {
 const CWD = process.cwd();
 
 // ─── Delegation cache ───────────────────────────────────────────
-// Cache the CLI JSON result for 10s so rapid prompt re-renders
-// (e.g. every keypress in some shells) don't re-invoke npx each time.
+// Cache the CLI JSON result for 60s so rapid prompt re-renders
+// (Claude Code refreshes the statusline several times a second while
+// streaming) don't re-invoke the CLI each time. #2337: bumped 10s→60s
+// because 10s was far too short for how often Claude Code re-renders.
 const CACHE_FILE = path.join(os.tmpdir(), 'ruflo-statusline-cache-' + require('crypto').createHash('md5').update(CWD).digest('hex').slice(0, 8) + '.json');
-const CACHE_TTL_MS = 10000;
+const CACHE_TTL_MS = 60000;
+
+// #2337: resolve an already-installed @claude-flow/cli (or ruflo) bin so we
+// can invoke it directly via \`node\`. The previous version called
+// \`npx --yes @claude-flow/cli@latest\` on every uncached render, which forces
+// a registry resolution + cold-start of the entire CLI per render. With
+// multiple concurrent Claude Code sessions this storms the host (reporter
+// saw load average 40-65 on a 12-core box).
+//
+// Returns the absolute path to bin/cli.js or null. Mirrors getPkgVersion()'s
+// path probing (project, monorepo, plugin marketplace, global node_modules
+// including custom-prefix layouts like ~/.npm-global).
+function resolveCliBin() {
+  try {
+    const home = os.homedir();
+    const candidates = [
+      path.join(home, '.claude', 'plugins', 'marketplaces', 'ruflo', 'bin', 'cli.js'),
+      path.join(CWD, 'node_modules', '@claude-flow', 'cli', 'bin', 'cli.js'),
+      path.join(CWD, 'node_modules', 'ruflo', 'bin', 'cli.js'),
+      path.join(CWD, 'v3', '@claude-flow', 'cli', 'bin', 'cli.js'),
+    ];
+    try {
+      const binDir = path.dirname(process.execPath);
+      const globalModuleDirs = [path.join(binDir, '..', 'lib', 'node_modules'), path.join(binDir, 'node_modules')];
+      for (const prefix of [process.env.npm_config_prefix, process.env.PREFIX, path.join(home, '.npm-global')]) {
+        if (prefix) globalModuleDirs.push(path.join(prefix, 'lib', 'node_modules'));
+      }
+      for (const gm of globalModuleDirs) {
+        candidates.push(
+          path.join(gm, 'ruflo', 'bin', 'cli.js'),
+          path.join(gm, '@claude-flow', 'cli', 'bin', 'cli.js'),
+        );
+      }
+    } catch { /* ignore */ }
+    for (const p of candidates) {
+      if (fs.existsSync(p)) return p;
+    }
+  } catch { /* ignore */ }
+  return null;
+}
 
 function readCache() {
   try {
@@ -99,8 +140,16 @@ function getStatuslineData() {
   if (cached) return cached;
 
   try {
+    // #2337: prefer an already-installed CLI bin via direct \`node\` invocation
+    // — no npx, no registry round-trip, no @latest re-resolve per render.
+    // Fall back to \`npx --prefer-offline @claude-flow/cli\` (no @latest) only
+    // when nothing is installed locally, so a cold environment still works.
+    const cliBin = resolveCliBin();
+    const cmd = cliBin
+      ? '"' + process.execPath + '" "' + cliBin + '" hooks statusline --json 2>/dev/null'
+      : 'npx --prefer-offline @claude-flow/cli hooks statusline --json 2>/dev/null';
     const raw = execSync(
-      'npx --yes @claude-flow/cli@latest hooks statusline --json 2>/dev/null',
+      cmd,
       { encoding: 'utf-8', timeout: 8000, stdio: ['pipe', 'pipe', 'pipe'], cwd: CWD }
     ).trim();
     // The CLI may emit preamble lines before the JSON — find the first '{'.

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

@@ -1239,6 +1239,9 @@ export const hooksPostTask = {
             quality: { type: 'number', description: 'Quality score (0-1)' },
             task: { type: 'string', description: 'Task description text (used for learning keyword extraction)' },
             storeDecisions: { type: 'boolean', description: 'Also store routing decision in memory DB' },
+            // ADR-147 P2: nested-subagent spawn-tree capture
+            parentAgentId: { type: 'string', description: 'ID of the parent agent (from Claude Code\'s parent_agent_id OTel span tag / x-claude-code-parent-agent-id header). Omit for top-level work.' },
+            depth: { type: 'number', description: 'Chain depth from root lead session (0 = lead, 1+ = subagent). Used by ADR-147 P3 depth-aware guardrail.' },
         },
         required: ['taskId'],
     },
@@ -1258,6 +1261,22 @@ export const hooksPostTask = {
             if (!v.valid)
                 return { success: false, error: v.error };
         }
+        // ADR-147 P2: validate spawn-tree lineage if provided
+        const parentAgentId = params.parentAgentId;
+        if (parentAgentId !== undefined) {
+            const v = validateIdentifier(parentAgentId, 'parentAgentId');
+            if (!v.valid)
+                return { success: false, error: v.error };
+        }
+        const depthRaw = params.depth;
+        let depth;
+        if (depthRaw !== undefined && depthRaw !== null) {
+            const n = Number(depthRaw);
+            if (!Number.isInteger(n) || n < 0 || n > 32) {
+                return { success: false, error: 'depth must be a non-negative integer ≤ 32' };
+            }
+            depth = n;
+        }
         // Phase 3: Wire recordFeedback through bridge → LearningSystem + ReasoningBank
         let feedbackResult = null;
         try {
@@ -1269,6 +1288,9 @@ export const hooksPostTask = {
                 agent,
                 duration: params.duration || undefined,
                 patterns: params.patterns || undefined,
+                // ADR-147 P2: forward spawn-tree lineage so it lands in feedback + memory
+                parentAgentId,
+                depth,
             });
         }
         catch {
@@ -2643,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,
@@ -2656,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/memory/memory-bridge.d.ts

@@ -265,6 +265,8 @@ export declare function bridgeRecordFeedback(options: {
     duration?: number;
     patterns?: string[];
     dbPath?: string;
+    parentAgentId?: string;
+    depth?: number;
 }): Promise<{
     success: boolean;
     controller: string;

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

@@ -1422,6 +1422,8 @@ export async function bridgeRecordFeedback(options) {
                     await learningSystem.recordFeedback({
                         taskId: options.taskId, success: options.success, quality: options.quality,
                         agent: options.agent, duration: options.duration, timestamp: Date.now(),
+                        // ADR-147 P2: forward spawn-tree lineage if present
+                        parentAgentId: options.parentAgentId, depth: options.depth,
                     });
                     controller = 'learningSystem';
                     updated++;

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