@claude-flow/cli 3.10.46 → 3.12.0

package/dist/src/commands/neural.js

@@ -1516,11 +1516,2361 @@ const benchmarkCommand = {
         }
     },
 };
+// ============================================================================
+// ADR-148 — `neural router` subcommand tree: status / train / reload
+// ============================================================================
+const routerStatusCommand = {
+    name: 'status',
+    description: 'Show the cost-optimal neural router state (ADR-148) — gate, backend, artifact, counters',
+    options: [
+        { name: 'format', short: 'f', type: 'string', description: 'Output format: table, json', default: 'table' },
+    ],
+    examples: [
+        { command: 'claude-flow neural router status', description: 'Show router state' },
+        { command: 'CLAUDE_FLOW_ROUTER_NEURAL=1 claude-flow neural router status', description: 'Show status with gate open' },
+    ],
+    action: async (ctx) => {
+        const format = ctx.flags.format || 'table';
+        const { neuralRouterStatus } = await import('../ruvector/neural-router.js');
+        const { getModelRouterStats } = await import('../ruvector/model-router.js');
+        const status = await neuralRouterStatus();
+        const stats = getModelRouterStats();
+        const payload = { neuralRouter: status, modelRouter: stats };
+        if (format === 'json') {
+            output.writeln(JSON.stringify(payload, null, 2));
+            return { success: true, data: payload };
+        }
+        output.writeln();
+        output.writeln(output.bold('Cost-Optimal Neural Router (ADR-148)'));
+        output.writeln(output.dim('─'.repeat(60)));
+        output.writeln(`  Gate (CLAUDE_FLOW_ROUTER_NEURAL=1): ${status.enabled ? output.success('open') : output.warning('closed')}`);
+        output.writeln(`  Backend available:                  ${status.available ? output.success('yes') : output.warning('no')}`);
+        output.writeln(`  Active backend (routedBy):          ${status.routedBy ?? '—'}`);
+        output.writeln(`  Reason:                             ${status.reason}`);
+        output.writeln(`  Quality bar:                        ${status.config.qualityBar}`);
+        output.writeln(`  Seed corpus path:                   ${status.config.seedCorpusPath}`);
+        output.writeln(`  Bundled KRR artifact path:          ${status.config.bundledKrrPath}`);
+        output.writeln(`  User artifact (modelPath):          ${status.config.modelPath ?? '—'}`);
+        output.writeln();
+        output.writeln(output.bold('Counters (process-local since last reset)'));
+        output.writeln(output.dim('─'.repeat(60)));
+        output.writeln(`  Total decisions:    ${stats.totalDecisions}`);
+        output.writeln(`  routedBy:           heuristic=${stats.routedByCounts.heuristic}  hybrid=${stats.routedByCounts.hybrid}  bandit-fallback=${stats.routedByCounts['bandit-fallback']}`);
+        output.writeln(`  neuralBackend:      knn=${stats.neuralBackendCounts['metaharness-knn']}  krr=${stats.neuralBackendCounts['metaharness-krr']}  fastgrnn=${stats.neuralBackendCounts.fastgrnn}`);
+        output.writeln(`  A/B mode:           ${stats.ab.comparisons} comparisons, ${stats.ab.disagreements} disagreements (${(stats.ab.disagreementRate * 100).toFixed(1)}%)`);
+        output.writeln();
+        return { success: true, data: payload };
+    },
+};
+const routerTrainCommand = {
+    name: 'train',
+    description: 'Train a KRR router artifact from a DRACO-shaped JSON corpus (or the bundled seed) — pure TS, no native deps',
+    options: [
+        { name: 'corpus', short: 'c', type: 'string', description: 'Path to DRACO rows JSON ({embedding, scores}). Defaults to the bundled seed corpus.' },
+        { name: 'out', short: 'o', type: 'string', description: 'Output path for the trained KRR JSON.' },
+        { name: 'quality-bar', short: 'q', type: 'number', description: 'qualityBar for cost-optimal selection (default 0.8)', default: '0.8' },
+    ],
+    examples: [
+        { command: 'claude-flow neural router train', description: 'Train from the bundled seed and write to ./router.krr.json' },
+        { command: 'claude-flow neural router train -c ./my-corpus.json -o ./my-router.krr.json', description: 'Train from a custom corpus' },
+    ],
+    action: async (ctx) => {
+        const corpusPath = ctx.flags.corpus;
+        const outPath = ctx.flags.out || './router.krr.json';
+        const qualityBar = parseFloat(ctx.flags['quality-bar'] || '0.8') || 0.8;
+        let mh;
+        try {
+            mh = await import('@metaharness/router');
+        }
+        catch {
+            output.printError('@metaharness/router is not installed. `npm install @metaharness/router@^0.3.2` then re-run.');
+            return { success: false, exitCode: 1 };
+        }
+        const { neuralRouterStatus } = await import('../ruvector/neural-router.js');
+        const status = await neuralRouterStatus();
+        const fs = await import('node:fs');
+        const seedPath = corpusPath ?? status.config.seedCorpusPath;
+        if (!fs.existsSync(seedPath)) {
+            output.printError(`Corpus not found at ${seedPath}`);
+            return { success: false, exitCode: 1 };
+        }
+        const rows = JSON.parse(fs.readFileSync(seedPath, 'utf8'));
+        output.writeln();
+        output.writeln(output.bold('Training KRR router (ADR-148)'));
+        output.writeln(output.dim('─'.repeat(60)));
+        output.writeln(`  Corpus: ${seedPath}  (${rows.length} rows, dim=${rows[0]?.embedding?.length ?? '?'})`);
+        output.writeln(`  Output: ${outPath}`);
+        output.writeln(`  qualityBar: ${qualityBar}`);
+        output.writeln();
+        const spinner = output.createSpinner({ text: 'Fitting Beta-Bernoulli KRR with leave-one-out CV…', spinner: 'dots' });
+        spinner.start();
+        const t0 = performance.now();
+        const { router, lambda, looQuality } = mh.trainRouter(rows, { haiku: 1, sonnet: 3, opus: 15 }, {
+            qualityBar,
+            lambdas: [1e-4, 1e-3, 1e-2, 1e-1, 1e0],
+        });
+        const ms = performance.now() - t0;
+        spinner.succeed(`Trained in ${ms.toFixed(0)}ms (λ=${lambda.toExponential(3)}, looQuality=${looQuality.toFixed(4)})`);
+        fs.writeFileSync(outPath, JSON.stringify(router.toJSON()));
+        const bytes = fs.statSync(outPath).size;
+        output.writeln(`Wrote ${bytes} bytes → ${outPath}`);
+        output.writeln();
+        output.writeln(output.dim('Use: CLAUDE_FLOW_ROUTER_NEURAL=1 CLAUDE_FLOW_ROUTER_MODEL_PATH=' + outPath + ' …'));
+        output.writeln();
+        return { success: true, data: { lambda, looQuality, trainMs: ms, modelPath: outPath, modelBytes: bytes } };
+    },
+};
+// ADR-149 iter 19 — CLI surface for the iter 18 trajectory consumer. Pairs
+// decision+outcome rows from the JSONL recorder into seed-rows-compatible
+// training rows that `neural router train` (above) can consume.
+const routerTrainFromTrajectoriesCommand = {
+    name: 'train-from-trajectories',
+    description: 'Pair production decision+outcome JSONL rows into seed-corpus-shaped training rows (ADR-149 iter 18/19)',
+    options: [
+        { name: 'in', short: 'i', type: 'string', description: 'Trajectory JSONL path (default: $CLAUDE_FLOW_ROUTER_TRAJECTORY_PATH or .swarm/model-router-trajectories.jsonl)' },
+        { name: 'write', short: 'w', type: 'string', description: 'Write paired rows to this path (seed-rows.json-compatible JSON array)' },
+        { name: 'union', short: 'u', type: 'string', description: 'Union paired rows with an existing seed-rows.json — production rows win on task-text collision' },
+        { name: 'filter-source', type: 'string', description: 'Only keep outcomes whose source matches (e.g. llm-judge, agent-execute)' },
+        { name: 'min-quality', type: 'number', description: 'Drop pairs whose MAX outcome score is below this threshold (default 0 — keep failures, they are training signal)', default: '0' },
+        { name: 'format', short: 'f', type: 'string', description: 'Output format: table, json', default: 'table' },
+    ],
+    examples: [
+        { command: 'claude-flow neural router train-from-trajectories', description: 'Show pairing stats from default trajectory path' },
+        { command: 'claude-flow neural router train-from-trajectories -w production-rows.json', description: 'Emit a corpus to feed `router train`' },
+        { command: 'claude-flow neural router train-from-trajectories -u assets/model-router/seed-rows.json -w merged.json', description: 'Union production rows with the bundled seed corpus' },
+        { command: 'claude-flow neural router train-from-trajectories --filter-source llm-judge -w high-signal.json', description: 'Keep only judge-graded rows (drop coarse agent-execute baseline)' },
+    ],
+    action: async (ctx) => {
+        const fs = await import('node:fs');
+        const path = await import('node:path');
+        const { pairTrajectoryRows } = await import('../ruvector/router-trajectory.js');
+        const inPath = ctx.flags.in
+            ?? process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY_PATH
+            ?? path.resolve(process.cwd(), '.swarm', 'model-router-trajectories.jsonl');
+        const writePath = ctx.flags.write;
+        const unionPath = ctx.flags.union;
+        // Argv parser may camelCase hyphenated flags — accept both spellings.
+        const filterSource = (ctx.flags['filter-source'] ?? ctx.flags.filterSource);
+        const minQuality = parseFloat((ctx.flags['min-quality'] ?? ctx.flags.minQuality) || '0') || 0;
+        const fmt = ctx.flags.format || 'table';
+        if (!fs.existsSync(inPath)) {
+            const msg = `Trajectory file not found at ${inPath}`;
+            if (fmt === 'json') {
+                output.writeln(JSON.stringify({ error: msg, hint: 'Set CLAUDE_FLOW_ROUTER_TRAJECTORY=1 and run any agent_spawn → executeAgentTask flow to accumulate rows.' }, null, 2));
+            }
+            else {
+                output.printError(msg);
+                output.writeln(output.dim('  Set CLAUDE_FLOW_ROUTER_TRAJECTORY=1 to enable trajectory recording.'));
+            }
+            return { success: false, exitCode: 1 };
+        }
+        const text = fs.readFileSync(inPath, 'utf8');
+        const lines = text.split('\n').filter(l => l.trim().length > 0);
+        const allRows = [];
+        let malformed = 0;
+        for (const l of lines) {
+            try {
+                allRows.push(JSON.parse(l));
+            }
+            catch {
+                malformed++;
+            }
+        }
+        const { pairs: rawPairs, stats } = pairTrajectoryRows(allRows);
+        let pairs = rawPairs;
+        let filteredCount = pairs.length;
+        if (filterSource)
+            pairs = pairs.filter(p => p.source === filterSource);
+        if (minQuality > 0)
+            pairs = pairs.filter(p => Math.max(...Object.values(p.scores)) >= minQuality);
+        filteredCount = pairs.length;
+        const corpusRows = pairs.map(p => ({
+            task: p.task,
+            embedding: p.embedding,
+            scores: p.scores,
+            tier: p.tier,
+        }));
+        let unionRows = corpusRows;
+        let unioned = false;
+        let seedKept = 0;
+        if (unionPath) {
+            if (!fs.existsSync(unionPath)) {
+                output.printError(`--union path ${unionPath} not found`);
+                return { success: false, exitCode: 1 };
+            }
+            const seedRows = JSON.parse(fs.readFileSync(unionPath, 'utf8'));
+            const productionTasks = new Set(corpusRows.map(r => r.task));
+            const kept = seedRows.filter(r => !productionTasks.has(r.task));
+            seedKept = kept.length;
+            unionRows = [...kept, ...corpusRows];
+            unioned = true;
+        }
+        if (writePath) {
+            fs.writeFileSync(writePath, JSON.stringify(unionRows));
+        }
+        const data = {
+            input: inPath,
+            malformed,
+            stats,
+            afterFilters: filteredCount,
+            unioned,
+            seedKept: unioned ? seedKept : undefined,
+            finalRows: unionRows.length,
+            written: writePath,
+        };
+        if (fmt === 'json') {
+            output.writeln(JSON.stringify(data, null, 2));
+            return { success: true, data };
+        }
+        output.writeln();
+        output.writeln(output.bold('Trajectory → Training-row pairing (ADR-149 iter 18/19)'));
+        output.writeln(output.dim('─'.repeat(60)));
+        output.writeln(`  Input file:        ${inPath}`);
+        output.writeln(`  Total rows:        ${stats.totalRows} (${stats.decisions} decision, ${stats.outcomes} outcome${malformed > 0 ? `, ${malformed} malformed` : ''})`);
+        output.writeln(`  Paired:            ${stats.paired}`);
+        output.writeln(`  Dropped (no embed): ${stats.droppedNoEmbedding}`);
+        output.writeln(`  Dropped (no match): ${stats.droppedNoMatch}`);
+        if (Object.keys(stats.bySource).length > 0)
+            output.writeln(`  By source:         ${JSON.stringify(stats.bySource)}`);
+        if (Object.keys(stats.byTier).length > 0)
+            output.writeln(`  By tier:           ${JSON.stringify(stats.byTier)}`);
+        output.writeln(`  After filters:     ${filteredCount}`);
+        if (unioned)
+            output.writeln(`  Final (unioned):   ${unionRows.length}  (seed kept=${seedKept}, production=${corpusRows.length})`);
+        if (writePath)
+            output.writeln(`  Written:           ${writePath}`);
+        output.writeln();
+        if (stats.totalRows === 0) {
+            output.writeln(output.dim('  Empty trajectory file. Enable recording with `export CLAUDE_FLOW_ROUTER_TRAJECTORY=1` and run agent_spawn flows.'));
+        }
+        else if (pairs.length > 0 && writePath) {
+            output.writeln(output.dim(`  Next: claude-flow neural router train -c ${writePath} -o router.krr.json`));
+        }
+        output.writeln();
+        return { success: true, data };
+    },
+};
+const routerReloadCommand = {
+    name: 'reload',
+    description: 'Force-reload the neural router (clears in-process backend cache; next call re-reads artifact/corpus)',
+    options: [],
+    examples: [
+        { command: 'claude-flow neural router reload', description: 'Refresh backend caches after retraining an artifact' },
+    ],
+    action: async () => {
+        const { __resetNeuralRouterForTests, neuralRouterStatus } = await import('../ruvector/neural-router.js');
+        __resetNeuralRouterForTests();
+        output.writeln(output.success('Neural router backend cache cleared.'));
+        const status = await neuralRouterStatus();
+        output.writeln(output.dim(`  Active backend now: ${status.routedBy ?? '—'}  (${status.reason})`));
+        return { success: true, data: status };
+    },
+};
+/**
+ * ADR-149 iter 8 — `neural router models`: list the candidate registry
+ * with measured per-tier scores from the most recent seed-corpus bench,
+ * latency, and cost. Reads:
+ *   - assets/model-router/seed-rows.json (which model ids exist in the corpus)
+ *   - latest docs/benchmarks/runs/seed-corpus-*.json (per-candidate aggregates)
+ *   - assets/model-router/openrouter-alts.json (tier mapping + alt rankings)
+ * Falls back gracefully when files are missing.
+ */
+const routerModelsCommand = {
+    name: 'models',
+    description: 'List the cost-optimal router registry with measured per-tier scores, latency, and cost (ADR-149)',
+    options: [
+        { name: 'format', short: 'f', type: 'string', description: 'Output format: table, json', default: 'table' },
+    ],
+    examples: [
+        { command: 'claude-flow neural router models', description: 'Show candidate registry with measured stats' },
+        { command: 'claude-flow neural router models -f json', description: 'Machine-readable JSON' },
+    ],
+    action: async (ctx) => {
+        const fmt = ctx.flags.format || 'table';
+        const fs = await import('node:fs');
+        const path = await import('node:path');
+        const { neuralRouterStatus } = await import('../ruvector/neural-router.js');
+        const status = await neuralRouterStatus();
+        const seedPath = status.config.seedCorpusPath;
+        // Best-effort: the candidate set is the union of ids appearing in
+        // seed-rows.json scores keys. The latest measurement run's
+        // perCandidate array is the authoritative source for measured stats.
+        const candidates = new Map();
+        try {
+            if (fs.existsSync(seedPath)) {
+                const rows = JSON.parse(fs.readFileSync(seedPath, 'utf8'));
+                for (const r of rows) {
+                    for (const id of Object.keys(r.scores ?? {})) {
+                        if (!candidates.has(id))
+                            candidates.set(id, { id, tier: 'unknown' });
+                    }
+                }
+            }
+        }
+        catch { /* keep going */ }
+        // Pull latest FULL-CORPUS measurement for per-tier scores + latency.
+        // Prefer files with cheap+mid+strong all populated (40-row+ runs); fall
+        // back to the most-recent partial file if no full run is found.
+        try {
+            const benchDir = path.resolve(process.cwd(), 'docs', 'benchmarks', 'runs');
+            if (fs.existsSync(benchDir)) {
+                const files = fs.readdirSync(benchDir)
+                    .filter(f => f.startsWith('seed-corpus-') && f.endsWith('.json'))
+                    .sort()
+                    .reverse();
+                // Scan files newest-first; pick the first one that has all three
+                // tiers populated for the median model.
+                let chosen = null;
+                for (const f of files) {
+                    try {
+                        const data = JSON.parse(fs.readFileSync(path.join(benchDir, f), 'utf8'));
+                        const sample = data.perCandidate?.[0];
+                        if (sample && sample.cheap_avg_score != null && sample.mid_avg_score != null && sample.strong_avg_score != null) {
+                            chosen = data;
+                            break;
+                        }
+                        if (!chosen)
+                            chosen = data; // fallback to newest
+                    }
+                    catch { /* skip malformed */ }
+                }
+                if (chosen) {
+                    for (const raw of chosen.perCandidate ?? []) {
+                        const r = raw;
+                        const existing = candidates.get(r.id);
+                        const c = existing ?? { id: r.id, tier: 'unknown' };
+                        c.tier = (r.tier ?? c.tier) || 'unknown';
+                        c.cost_in = r.cost_per_m_tok_in;
+                        c.cost_out = r.cost_per_m_tok_out;
+                        c.cheap = r.cheap_avg_score ?? undefined;
+                        c.mid = r.mid_avg_score ?? undefined;
+                        c.strong = r.strong_avg_score ?? undefined;
+                        c.overall = r.overall_avg_score ?? undefined;
+                        c.latency_ms = r.latency_mean_ms ?? undefined;
+                        candidates.set(r.id, c);
+                    }
+                }
+            }
+        }
+        catch { /* keep going */ }
+        const rows = Array.from(candidates.values()).sort((a, b) => (b.overall ?? -1) - (a.overall ?? -1));
+        if (fmt === 'json') {
+            output.writeln(JSON.stringify({ count: rows.length, candidates: rows }, null, 2));
+            return { success: true, data: { count: rows.length, candidates: rows } };
+        }
+        output.writeln();
+        output.writeln(output.bold('Cost-Optimal Router Registry (ADR-149)'));
+        output.writeln(output.dim('─'.repeat(60)));
+        output.writeln(`  Source: ${seedPath}`);
+        output.writeln(`  Candidates: ${rows.length}`);
+        output.writeln();
+        if (rows.length === 0) {
+            output.writeln(output.warning('  No candidates — corpus not generated or measurement not run.'));
+            output.writeln(output.dim('  Run: node scripts/gen-seed-corpus-v2.mjs && OPENROUTER_API_KEY=... node scripts/benchmark-seed-corpus.mjs --live'));
+            return { success: true, data: { count: 0 } };
+        }
+        const fmtPct = (v) => v == null ? '—'.padStart(6) : `${(v * 100).toFixed(1)}%`.padStart(6);
+        const fmtCost = (v) => v == null ? '—' : `$${v.toFixed(2)}`;
+        const fmtLat = (v) => v == null ? '—' : `${v.toFixed(0)}ms`;
+        output.writeln('  | Candidate                                  | Tier   |  Cheap |   Mid  | Strong | Overall | $/Mtok in/out | Latency |');
+        output.writeln('  |--------------------------------------------|--------|--------|--------|--------|---------|---------------|---------|');
+        for (const c of rows) {
+            output.writeln(`  | ${c.id.padEnd(42)} | ${c.tier.padEnd(6)} | ${fmtPct(c.cheap)} | ${fmtPct(c.mid)} | ${fmtPct(c.strong)} | ${fmtPct(c.overall)} | ${fmtCost(c.cost_in).padStart(5)}/${fmtCost(c.cost_out).padEnd(6)} | ${fmtLat(c.latency_ms).padStart(7)} |`);
+        }
+        output.writeln();
+        output.writeln(output.dim('  Sorted by overall score desc. Empty cells = no measurement on that tier.'));
+        output.writeln(output.dim('  To re-measure: OPENROUTER_API_KEY=... node scripts/benchmark-seed-corpus.mjs --live'));
+        output.writeln();
+        return { success: true, data: { count: rows.length, candidates: rows } };
+    },
+};
+// ADR-149 iter 28 — observability into recorded routing decisions. The
+// trajectory JSONL (iter 17+) records every decision the router makes;
+// this subcommand exposes that data as filtered + aggregated views so
+// operators don't have to grep the file.
+const routerDecisionsCommand = {
+    name: 'decisions',
+    description: 'Query the routing-decision JSONL (iter 17+): filter, aggregate, paginate (ADR-149 iter 28)',
+    options: [
+        { name: 'in', short: 'i', type: 'string', description: 'Trajectory JSONL path (default: $CLAUDE_FLOW_ROUTER_TRAJECTORY_PATH or .swarm/model-router-trajectories.jsonl)' },
+        { name: 'since', short: 's', type: 'string', description: 'Time window suffix: 1h, 24h, 7d, 30d (default: all)' },
+        { name: 'routed-by', type: 'string', description: 'Filter by decision mechanism: hybrid | bandit-fallback | heuristic' },
+        { name: 'model', short: 'm', type: 'string', description: 'Filter by chosen model id (substring match, e.g. haiku, gpt-4)' },
+        { name: 'bucket', type: 'string', description: 'Filter by complexity bucket: cheap (< 0.34) | mid (< 0.67) | strong (≥ 0.67) — iter 58' },
+        { name: 'task-hash', type: 'string', description: 'Filter by exact task_hash (FNV-1a-32). Use for incident investigation — iter 59' },
+        { name: 'limit', short: 'l', type: 'number', description: 'Max recent decisions to list (default 20)', default: '20' },
+        { name: 'format', short: 'f', type: 'string', description: 'Output format: table, json', default: 'table' },
+    ],
+    examples: [
+        { command: 'claude-flow neural router decisions', description: 'Aggregate stats + 20 most-recent decisions' },
+        { command: 'claude-flow neural router decisions --since 24h', description: 'Last 24 hours only' },
+        { command: 'claude-flow neural router decisions --routed-by bandit-fallback', description: 'Find decisions where neural backend failed' },
+        { command: 'claude-flow neural router decisions --model haiku --format json', description: 'All haiku picks, JSON output' },
+    ],
+    action: async (ctx) => {
+        const fs = await import('node:fs');
+        const path = await import('node:path');
+        const inPath = ctx.flags.in
+            ?? process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY_PATH
+            ?? path.resolve(process.cwd(), '.swarm', 'model-router-trajectories.jsonl');
+        const since = ctx.flags.since;
+        const routedByFilter = (ctx.flags['routed-by'] ?? ctx.flags.routedBy);
+        const modelFilter = ctx.flags.model;
+        const bucketFilterRaw = ctx.flags.bucket?.toLowerCase();
+        const bucketFilter = bucketFilterRaw === 'cheap' || bucketFilterRaw === 'mid' || bucketFilterRaw === 'strong'
+            ? bucketFilterRaw : undefined;
+        if (bucketFilterRaw && !bucketFilter) {
+            output.printError(`--bucket must be one of: cheap | mid | strong (got "${bucketFilterRaw}")`);
+            return { success: false, exitCode: 1 };
+        }
+        // iter 59 — task_hash filter for incident investigation. Accepts the 8-char
+        // FNV-1a-32 hex format the trajectory recorder uses.
+        const taskHashFilter = (ctx.flags['task-hash'] ?? ctx.flags.taskHash)?.toLowerCase();
+        if (taskHashFilter && !/^[0-9a-f]{8}$/.test(taskHashFilter)) {
+            output.printError(`--task-hash must be an 8-char hex string (got "${taskHashFilter}")`);
+            return { success: false, exitCode: 1 };
+        }
+        const limit = parseInt(ctx.flags.limit || '20', 10) || 20;
+        const fmt = ctx.flags.format || 'table';
+        if (!fs.existsSync(inPath)) {
+            const msg = `Trajectory file not found at ${inPath}`;
+            if (fmt === 'json') {
+                output.writeln(JSON.stringify({ error: msg, hint: 'Set CLAUDE_FLOW_ROUTER_TRAJECTORY=1 to enable recording.' }, null, 2));
+            }
+            else {
+                output.printError(msg);
+                output.writeln(output.dim('  Set CLAUDE_FLOW_ROUTER_TRAJECTORY=1 to enable trajectory recording.'));
+            }
+            return { success: false, exitCode: 1 };
+        }
+        const text = fs.readFileSync(inPath, 'utf8');
+        const lines = text.split('\n').filter(l => l.trim().length > 0);
+        const decisions = [];
+        const outcomesByHash = new Map();
+        let malformed = 0;
+        for (const l of lines) {
+            try {
+                const row = JSON.parse(l);
+                if (row.type === 'decision') {
+                    decisions.push(row);
+                }
+                else if (row.type === 'outcome') {
+                    const arr = outcomesByHash.get(row.task_hash) ?? [];
+                    arr.push({
+                        task_hash: row.task_hash,
+                        ts: row.ts,
+                        quality: row.quality,
+                        cost_usd: row.cost_usd,
+                        tokens: row.tokens,
+                        model_id: row.model_id,
+                    });
+                    outcomesByHash.set(row.task_hash, arr);
+                }
+            }
+            catch {
+                malformed++;
+            }
+        }
+        // Time-window filter.
+        let cutoffMs = null;
+        if (since) {
+            const m = since.match(/^(\d+)([hdmw])$/);
+            if (m) {
+                const n = parseInt(m[1], 10);
+                const unitMs = { m: 60_000, h: 3_600_000, d: 86_400_000, w: 7 * 86_400_000 }[m[2]] ?? 0;
+                cutoffMs = Date.now() - n * unitMs;
+            }
+        }
+        let filtered = decisions;
+        if (cutoffMs !== null) {
+            filtered = filtered.filter(d => Date.parse(d.ts) >= cutoffMs);
+        }
+        if (routedByFilter) {
+            filtered = filtered.filter(d => d.routed_by === routedByFilter);
+        }
+        if (bucketFilter) {
+            filtered = filtered.filter(d => {
+                const bucket = d.complexity < 0.34 ? 'cheap' : d.complexity < 0.67 ? 'mid' : 'strong';
+                return bucket === bucketFilter;
+            });
+        }
+        if (taskHashFilter) {
+            filtered = filtered.filter(d => d.task_hash === taskHashFilter);
+        }
+        if (modelFilter) {
+            const needle = modelFilter.toLowerCase();
+            filtered = filtered.filter(d => {
+                const id = (d.openrouter_model ?? d.model).toLowerCase();
+                return id.includes(needle);
+            });
+        }
+        // Aggregate.
+        const byRoutedBy = {};
+        const byModel = {};
+        const byTier = { cheap: 0, mid: 0, strong: 0 };
+        // iter 31 — cost aggregation. Sum cost_usd from paired outcome rows.
+        let costTotalUsd = 0;
+        let costPairedCount = 0;
+        const costByModel = {};
+        const costByTier = { cheap: 0, mid: 0, strong: 0 };
+        // iter 65 — track per-hash decision-iteration so we can pair the N-th
+        // decision for a hash with the N-th outcome (instead of always pulling
+        // the latest outcome). Iter 17's recorder writes decision then outcome
+        // in chronological order, so this index-pairing matches what the agent
+        // actually dispatched.
+        const decisionIndexByHash = new Map();
+        for (const d of filtered) {
+            byRoutedBy[d.routed_by] = (byRoutedBy[d.routed_by] ?? 0) + 1;
+            const id = d.openrouter_model ?? d.model;
+            byModel[id] = (byModel[id] ?? 0) + 1;
+            const tier = d.complexity < 0.34 ? 'cheap' : d.complexity < 0.67 ? 'mid' : 'strong';
+            byTier[tier]++;
+            // iter 31 + iter 65 — JOIN to the i-th OUTCOME row for this task_hash
+            // (where i is the i-th DECISION for this hash). Avoids double-counting
+            // costs when a task ran multiple times.
+            const outcomeArr = outcomesByHash.get(d.task_hash);
+            if (outcomeArr && outcomeArr.length > 0) {
+                const seen = decisionIndexByHash.get(d.task_hash) ?? 0;
+                const out = outcomeArr[Math.min(seen, outcomeArr.length - 1)];
+                decisionIndexByHash.set(d.task_hash, seen + 1);
+                if (out?.cost_usd != null) {
+                    costTotalUsd += out.cost_usd;
+                    costPairedCount++;
+                    const modelKey = out.model_id ?? id;
+                    costByModel[modelKey] = (costByModel[modelKey] ?? 0) + out.cost_usd;
+                    costByTier[tier] += out.cost_usd;
+                }
+            }
+        }
+        const fallbackRate = filtered.length > 0
+            ? ((byRoutedBy['bandit-fallback'] ?? 0) / filtered.length) * 100
+            : 0;
+        // Sort by ts ascending so "most recent" is well-defined regardless of
+        // file order (rotation, concurrent writes can break monotonicity).
+        const sorted = [...filtered].sort((a, b) => a.ts.localeCompare(b.ts));
+        const recent = sorted.slice(-limit).reverse(); // newest first
+        const payload = {
+            input: inPath,
+            totalRows: lines.length,
+            decisionRows: decisions.length,
+            malformed,
+            filtered: filtered.length,
+            filters: { since, routedBy: routedByFilter, model: modelFilter, bucket: bucketFilter, taskHash: taskHashFilter },
+            aggregates: {
+                byRoutedBy, byModel, byTier,
+                fallbackRatePct: Math.round(fallbackRate * 100) / 100,
+                // iter 31 — cost aggregates. Only populated when outcome rows
+                // carry cost_usd (post-iter-31 trajectories).
+                ...(costPairedCount > 0 ? {
+                    costTotalUsd: Math.round(costTotalUsd * 1000000) / 1000000,
+                    costPairedCount,
+                    costByModel: Object.fromEntries(Object.entries(costByModel).map(([k, v]) => [k, Math.round(v * 1000000) / 1000000])),
+                    costByTier: Object.fromEntries(Object.entries(costByTier).map(([k, v]) => [k, Math.round(v * 1000000) / 1000000])),
+                    avgCostPerCall: Math.round((costTotalUsd / costPairedCount) * 1000000) / 1000000,
+                } : {}),
+            },
+            recent,
+        };
+        if (fmt === 'json') {
+            output.writeln(JSON.stringify(payload, null, 2));
+            return { success: true, data: payload };
+        }
+        output.writeln();
+        output.writeln(output.bold('Routing decisions (ADR-149 iter 17+, query iter 28)'));
+        output.writeln(output.dim('─'.repeat(72)));
+        output.writeln(`  Input:           ${inPath}`);
+        output.writeln(`  JSONL rows:      ${lines.length}  (${decisions.length} decision, ${malformed} malformed)`);
+        if (since || routedByFilter || modelFilter || bucketFilter || taskHashFilter) {
+            output.writeln(`  Filters:         ${[since && `since=${since}`, routedByFilter && `routed-by=${routedByFilter}`, modelFilter && `model~${modelFilter}`, bucketFilter && `bucket=${bucketFilter}`, taskHashFilter && `task_hash=${taskHashFilter}`].filter(Boolean).join(', ')}`);
+        }
+        output.writeln(`  After filters:   ${filtered.length}`);
+        output.writeln('');
+        if (filtered.length === 0) {
+            output.writeln(output.dim('  No decisions match the filters.'));
+            output.writeln('');
+            return { success: true, data: payload };
+        }
+        output.writeln(`  Fallback rate:   ${fallbackRate.toFixed(2)}%   (neural backend → bandit when prediction unusable)`);
+        output.writeln('');
+        output.writeln('  By routed_by:');
+        for (const [k, v] of Object.entries(byRoutedBy).sort((a, b) => b[1] - a[1])) {
+            const pct = ((v / filtered.length) * 100).toFixed(1).padStart(5);
+            output.writeln(`    ${k.padEnd(18)}  ${String(v).padStart(6)}  ${pct}%`);
+        }
+        output.writeln('');
+        output.writeln('  By model:');
+        for (const [k, v] of Object.entries(byModel).sort((a, b) => b[1] - a[1])) {
+            const pct = ((v / filtered.length) * 100).toFixed(1).padStart(5);
+            output.writeln(`    ${k.padEnd(42)}  ${String(v).padStart(6)}  ${pct}%`);
+        }
+        output.writeln('');
+        output.writeln('  By tier (complexity bucket):');
+        for (const [k, v] of Object.entries(byTier)) {
+            const pct = filtered.length > 0 ? ((v / filtered.length) * 100).toFixed(1).padStart(5) : '  0.0';
+            output.writeln(`    ${k.padEnd(8)}  ${String(v).padStart(6)}  ${pct}%`);
+        }
+        output.writeln('');
+        // iter 31 — cost block (only when outcome rows carry cost_usd).
+        if (costPairedCount > 0) {
+            output.writeln('  Cost (USD, from paired outcomes):');
+            output.writeln(`    Total:           $${costTotalUsd.toFixed(4)}  across ${costPairedCount} paired decisions`);
+            output.writeln(`    Avg per call:    $${(costTotalUsd / costPairedCount).toFixed(6)}`);
+            output.writeln('    By model:');
+            for (const [k, v] of Object.entries(costByModel).sort((a, b) => b[1] - a[1])) {
+                output.writeln(`      ${k.padEnd(40)}  $${v.toFixed(4)}`);
+            }
+            output.writeln('    By tier:');
+            for (const [k, v] of Object.entries(costByTier)) {
+                output.writeln(`      ${k.padEnd(8)}  $${v.toFixed(4)}`);
+            }
+            output.writeln('');
+        }
+        // iter 59 — incident detail mode. When --task-hash is set, render each
+        // matching decision with FULL task text, paired outcome, complexity,
+        // ab_pair, ensemble_disagreement. Operators investigating "why was
+        // THIS task routed to X?" want maximum context per decision.
+        if (taskHashFilter && filtered.length > 0) {
+            // iter 64 — sort occurrences newest-first by ts. JSONL insertion order
+            // may not match chronological order after rotation or out-of-order writes.
+            const incidentSorted = [...filtered].sort((a, b) => b.ts.localeCompare(a.ts));
+            output.writeln(output.bold(`  Incident detail for task_hash=${taskHashFilter} (${filtered.length} occurrence(s), newest first):`));
+            for (const d of incidentSorted) {
+                // iter 65 — outcomesByHash is now an array of all outcomes per hash.
+                // For the incident detail at this decision's timestamp, pick the
+                // outcome closest in time (typically the corresponding one written
+                // by iter 17's recorder immediately after the decision).
+                const allOutcomes = outcomesByHash.get(d.task_hash) ?? [];
+                const dts = Date.parse(d.ts);
+                let out;
+                let bestDelta = Infinity;
+                for (const o of allOutcomes) {
+                    const delta = Math.abs(Date.parse(o.ts) - dts);
+                    if (delta < bestDelta) {
+                        bestDelta = delta;
+                        out = o;
+                    }
+                }
+                const bucket = d.complexity < 0.34 ? 'cheap' : d.complexity < 0.67 ? 'mid' : 'strong';
+                output.writeln('');
+                output.writeln(`    ts:                  ${d.ts}`);
+                output.writeln(`    task:                "${d.task ?? '<task text not stored>'}"`);
+                output.writeln(`    complexity:          ${d.complexity.toFixed(3)} (bucket: ${bucket})`);
+                output.writeln(`    picked model:        ${d.openrouter_model ?? d.model}`);
+                output.writeln(`    routed_by:           ${d.routed_by}${d.neural_backend ? `  via ${d.neural_backend}` : ''}`);
+                output.writeln(`    confidence:          ${d.confidence.toFixed(3)}   uncertainty: ${d.uncertainty.toFixed(3)}`);
+                const apd = d.ab_pair;
+                if (apd) {
+                    output.writeln(`    ab_pair:             bandit=${apd.bandit_pick}  hybrid=${apd.hybrid_pick}  disagree=${apd.disagree}`);
+                }
+                const ed = d.ensemble_disagreement;
+                if (typeof ed === 'number') {
+                    output.writeln(`    ensemble disagree:   ${ed.toFixed(4)}`);
+                }
+                if (out) {
+                    output.writeln(`    outcome:             quality=${out.quality ?? '—'}  cost_usd=${out.cost_usd != null ? '$' + out.cost_usd.toFixed(6) : '—'}  source=${out.source ?? '—'}`);
+                }
+                else {
+                    output.writeln(`    outcome:             ${output.warning('(no paired outcome row)')}`);
+                }
+            }
+            output.writeln('');
+            return { success: true, data: payload };
+        }
+        output.writeln(`  ${Math.min(limit, recent.length)} most-recent decisions (newest first):`);
+        output.writeln('    ' + 'ts'.padEnd(20) + 'routed_by'.padEnd(18) + 'model'.padEnd(34) + 'conf');
+        for (const d of recent) {
+            const ts = d.ts.slice(0, 19);
+            const id = (d.openrouter_model ?? d.model).slice(0, 32);
+            output.writeln(`    ${ts.padEnd(20)}${d.routed_by.padEnd(18)}${id.padEnd(34)}${d.confidence.toFixed(2)}`);
+        }
+        output.writeln('');
+        return { success: true, data: payload };
+    },
+};
+// ADR-149 iter 30 — forward-direction observability. Pairs with iter 28's
+// backward-direction `decisions` query. Lets operators inspect what the
+// router would pick for a hypothetical task WITHOUT actually dispatching.
+const routerDecideCommand = {
+    name: 'decide',
+    description: 'Show what the router would pick for a given task — no dispatch, just inspection (ADR-149 iter 30)',
+    options: [
+        { name: 'task', short: 't', type: 'string', description: 'Task text (alternatively pass as positional arg)' },
+        { name: 'format', short: 'f', type: 'string', description: 'Output format: table, json', default: 'table' },
+    ],
+    examples: [
+        { command: 'claude-flow neural router decide "fix typo in cache.ts"', description: 'See the routing decision for a small task' },
+        { command: 'claude-flow neural router decide -t "design distributed consensus" -f json', description: 'JSON output for the routing decision' },
+        { command: 'CLAUDE_FLOW_ROUTER_COST_CEILING_USD_PER_MTOK=5 claude-flow neural router decide -t "..."', description: 'See iter 29 cost-ceiling mode in action' },
+    ],
+    action: async (ctx) => {
+        const task = ctx.flags.task ?? (ctx.args && ctx.args[0]) ?? null;
+        const fmt = ctx.flags.format || 'table';
+        if (!task || typeof task !== 'string' || task.trim().length === 0) {
+            output.printError('Provide a task: --task "..." or as a positional argument');
+            return { success: false, exitCode: 1 };
+        }
+        const { analyzeTaskComplexity, routeToModelFull } = await import('../ruvector/model-router.js');
+        const { embedTaskWithCache } = await import('../ruvector/task-embedder.js');
+        const { neuralRouterStatus, tryCostOptimalRoute } = await import('../ruvector/neural-router.js');
+        const t0 = performance.now();
+        const complexity = analyzeTaskComplexity(task);
+        let embedding;
+        try {
+            embedding = await embedTaskWithCache(task);
+        }
+        catch { /* embedder may be absent */ }
+        const result = await routeToModelFull(task, embedding);
+        const status = await neuralRouterStatus();
+        // iter 45 — also fetch the neural-layer result so we can surface the
+        // ensemble-disagreement diagnostic. Extra inference but `decide` is an
+        // operator inspection tool, not the hot path.
+        let neuralResult = null;
+        if (embedding) {
+            const bucket = complexity.score < 0.34 ? 'low' : complexity.score < 0.67 ? 'med' : 'high';
+            try {
+                neuralResult = await tryCostOptimalRoute(embedding, { complexityBucket: bucket });
+            }
+            catch { /* gated off or backend absent */ }
+        }
+        const ms = performance.now() - t0;
+        const payload = {
+            task: task.length > 200 ? task.slice(0, 200) + '…' : task,
+            taskLength: task.length,
+            hasEmbedding: !!embedding,
+            embeddingDim: embedding?.length ?? null,
+            complexity: {
+                score: complexity.score,
+                bucket: complexity.score < 0.34 ? 'low' : complexity.score < 0.67 ? 'med' : 'high',
+                features: complexity.features,
+                indicators: complexity.indicators,
+            },
+            decision: {
+                model: result.model,
+                modelId: result.modelId,
+                provider: result.provider,
+                openrouterModel: result.openrouterModel,
+                confidence: result.confidence,
+                uncertainty: result.uncertainty,
+                routedBy: result.routedBy,
+                neuralBackend: result.neuralBackend,
+                costMultiplier: result.costMultiplier,
+                reasoning: result.reasoning,
+                // iter 45 — ensemble disagreement diagnostic (always set when both
+                // unified KRR + bucket specialist are loaded; observable signal for
+                // tuning iter 44's threshold). null when not applicable.
+                ensembleDisagreement: neuralResult?.ensembleDisagreement ?? null,
+            },
+            alternatives: result.alternatives,
+            backend: {
+                enabled: status.enabled,
+                available: status.available,
+                routedBy: status.routedBy,
+                reason: status.reason,
+            },
+            activeEnv: {
+                CLAUDE_FLOW_ROUTER_NEURAL: process.env.CLAUDE_FLOW_ROUTER_NEURAL ?? null,
+                CLAUDE_FLOW_ROUTER_CALIBRATE: process.env.CLAUDE_FLOW_ROUTER_CALIBRATE ?? null,
+                CLAUDE_FLOW_ROUTER_COST_CEILING_USD_PER_MTOK: process.env.CLAUDE_FLOW_ROUTER_COST_CEILING_USD_PER_MTOK ?? null,
+                CLAUDE_FLOW_ROUTER_LATENCY_BUDGET_MS: process.env.CLAUDE_FLOW_ROUTER_LATENCY_BUDGET_MS ?? null,
+                CLAUDE_FLOW_ROUTER_QUALITY_BAR: process.env.CLAUDE_FLOW_ROUTER_QUALITY_BAR ?? null,
+                CLAUDE_FLOW_ROUTER_BANDIT_PER_MODEL: process.env.CLAUDE_FLOW_ROUTER_BANDIT_PER_MODEL ?? null,
+                CLAUDE_FLOW_ROUTER_ENSEMBLE_UNCERTAINTY_THRESHOLD: process.env.CLAUDE_FLOW_ROUTER_ENSEMBLE_UNCERTAINTY_THRESHOLD ?? null,
+            },
+            elapsedMs: Math.round(ms * 100) / 100,
+        };
+        if (fmt === 'json') {
+            output.writeln(JSON.stringify(payload, null, 2));
+            return { success: true, data: payload };
+        }
+        output.writeln();
+        output.writeln(output.bold('Routing decision preview (ADR-149 iter 30 — no dispatch)'));
+        output.writeln(output.dim('─'.repeat(72)));
+        output.writeln(`  Task:        "${payload.task}"`);
+        output.writeln(`  Length:      ${payload.taskLength} chars`);
+        output.writeln(`  Embedding:   ${payload.hasEmbedding ? `${payload.embeddingDim} dims` : output.warning('not available (embedder absent / disabled)')}`);
+        output.writeln('');
+        output.writeln(output.bold('  Complexity:'));
+        output.writeln(`    score:   ${complexity.score.toFixed(3)}`);
+        output.writeln(`    bucket:  ${payload.complexity.bucket}`);
+        output.writeln(`    features: ${Object.entries(complexity.features).map(([k, v]) => `${k}=${typeof v === 'number' ? v.toFixed(2) : v}`).join(', ')}`);
+        if (complexity.indicators.high.length + complexity.indicators.medium.length + complexity.indicators.low.length > 0) {
+            output.writeln(`    indicators: high=[${complexity.indicators.high.slice(0, 4).join(',')}] medium=[${complexity.indicators.medium.slice(0, 4).join(',')}] low=[${complexity.indicators.low.slice(0, 4).join(',')}]`);
+        }
+        output.writeln('');
+        output.writeln(output.bold('  Decision:'));
+        output.writeln(`    model:        ${output.success(result.model)}${result.modelId ? `  (id=${result.modelId})` : ''}`);
+        output.writeln(`    routed_by:    ${result.routedBy}${result.neuralBackend ? `  via ${result.neuralBackend}` : ''}`);
+        output.writeln(`    confidence:   ${result.confidence.toFixed(3)}    uncertainty: ${result.uncertainty.toFixed(3)}`);
+        output.writeln(`    cost mult:    ${result.costMultiplier.toFixed(2)}×`);
+        if (result.provider === 'openrouter' && result.openrouterModel) {
+            output.writeln(`    via:          openrouter → ${result.openrouterModel}`);
+        }
+        output.writeln(`    reasoning:    ${result.reasoning}`);
+        if (neuralResult?.ensembleDisagreement !== undefined) {
+            const d = neuralResult.ensembleDisagreement;
+            const annotation = d > 0.20 ? output.warning(' ⚠ high — consider tuning iter 44 threshold')
+                : d > 0.10 ? output.dim(' (moderate)')
+                    : output.dim(' (low — predictions agree)');
+            output.writeln(`    ensemble disagreement: ${d.toFixed(4)}${annotation}`);
+        }
+        output.writeln('');
+        if (result.alternatives.length > 0) {
+            output.writeln(output.bold('  Alternatives (model: score):'));
+            for (const a of result.alternatives) {
+                output.writeln(`    ${a.model.padEnd(8)}  ${a.score.toFixed(4)}`);
+            }
+            output.writeln('');
+        }
+        output.writeln(output.bold('  Backend state:'));
+        output.writeln(`    enabled:    ${status.enabled}`);
+        output.writeln(`    available:  ${status.available}`);
+        output.writeln(`    routedBy:   ${status.routedBy ?? '—'}`);
+        output.writeln(`    reason:     ${status.reason}`);
+        output.writeln('');
+        const activeEnvKeys = Object.entries(payload.activeEnv).filter(([, v]) => v !== null);
+        if (activeEnvKeys.length > 0) {
+            output.writeln(output.bold('  Active env overrides:'));
+            for (const [k, v] of activeEnvKeys)
+                output.writeln(`    ${k}=${v}`);
+            output.writeln('');
+        }
+        output.writeln(output.dim(`  Total decision time: ${ms.toFixed(1)}ms`));
+        output.writeln('');
+        return { success: true, data: payload };
+    },
+};
+// ADR-149 iter 32 — counterfactual cost-savings analysis. Iter 31 added
+// cost_usd to outcome rows; this subcommand consumes that and asks "what
+// would each decision have cost on the heuristic-only path?" — surfacing
+// the actual production savings the router delivers.
+const routerCostSavingsCommand = {
+    name: 'cost-savings',
+    description: 'Compute actual vs heuristic-counterfactual cost from paired decision+outcome rows (ADR-149 iter 32)',
+    options: [
+        { name: 'in', short: 'i', type: 'string', description: 'Trajectory JSONL path (default: $CLAUDE_FLOW_ROUTER_TRAJECTORY_PATH or .swarm/...)' },
+        { name: 'since', short: 's', type: 'string', description: 'Time window suffix: 1h, 24h, 7d, 30d' },
+        { name: 'format', short: 'f', type: 'string', description: 'Output format: table, json', default: 'table' },
+        { name: 'top-n', type: 'number', description: 'Show top-N largest individual savings (default 5)', default: '5' },
+        { name: 'baseline', short: 'b', type: 'string', description: 'Counterfactual baseline: heuristic | always-haiku | always-sonnet | always-opus | always-gpt-4.1 | all (default: all)', default: 'all' },
+        { name: 'window', short: 'w', type: 'string', description: 'Bin decisions into successive windows of this duration (e.g. 1h, 24h, 7d). Output adds a trend table — iter 34 drift detection.' },
+        { name: 'task-hash', type: 'string', description: 'Filter to specific task_hash (FNV-1a-32 hex). For per-task cost investigation — iter 61.' },
+        { name: 'alert-on-drop-pct', type: 'number', description: 'Exit 1 if the most recent window\'s savings% falls > N points below the mean of prior windows. Requires --window. Default off. (ADR-149 iter 50)' },
+    ],
+    examples: [
+        { command: 'claude-flow neural router cost-savings', description: 'All-time, all baselines (heuristic + Sonnet-always + Opus-always)' },
+        { command: 'claude-flow neural router cost-savings --baseline always-sonnet', description: 'Compare only against Sonnet-always' },
+        { command: 'claude-flow neural router cost-savings --window 24h', description: 'Daily savings trend — iter 34 drift detection' },
+        { command: 'claude-flow neural router cost-savings --since 7d --format json | jq .baselines.heuristic.savings.totalUsd', description: 'Pipe-friendly headline' },
+    ],
+    action: async (ctx) => {
+        const fs = await import('node:fs');
+        const path = await import('node:path');
+        const { MODEL_PRICES } = await import('../ruvector/model-prices.js');
+        const inPath = ctx.flags.in
+            ?? process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY_PATH
+            ?? path.resolve(process.cwd(), '.swarm', 'model-router-trajectories.jsonl');
+        const since = ctx.flags.since;
+        const fmt = ctx.flags.format || 'table';
+        const topN = parseInt((ctx.flags['top-n'] ?? ctx.flags.topN) || '5', 10) || 5;
+        if (!fs.existsSync(inPath)) {
+            const msg = `Trajectory file not found at ${inPath}`;
+            if (fmt === 'json') {
+                output.writeln(JSON.stringify({ error: msg }, null, 2));
+            }
+            else {
+                output.printError(msg);
+            }
+            return { success: false, exitCode: 1 };
+        }
+        // iter 62 — preserve ALL outcomes (don't dedup by task_hash). Decisions
+        // can still dedup because all occurrences of the same task have the
+        // same embedding/complexity (it's the same task!), but different runs
+        // produce different token counts and costs. The Array preserves those.
+        const decisions = new Map();
+        const outcomes = [];
+        let malformed = 0;
+        for (const l of fs.readFileSync(inPath, 'utf8').split('\n')) {
+            if (!l.trim())
+                continue;
+            try {
+                const r = JSON.parse(l);
+                if (r.type === 'decision')
+                    decisions.set(r.task_hash, r);
+                else if (r.type === 'outcome')
+                    outcomes.push(r);
+            }
+            catch {
+                malformed++;
+            }
+        }
+        // Time-window filter (on the OUTCOME ts, since that's when cost was incurred).
+        let cutoffMs = null;
+        if (since) {
+            const m = since.match(/^(\d+)([hdmw])$/);
+            if (m) {
+                const n = parseInt(m[1], 10);
+                const unitMs = { m: 60_000, h: 3_600_000, d: 86_400_000, w: 7 * 86_400_000 }[m[2]] ?? 0;
+                cutoffMs = Date.now() - n * unitMs;
+            }
+        }
+        // iter 33 — multi-baseline counterfactuals. Each per-call row carries
+        // the actual cost AND a map of counterfactual costs (one per baseline),
+        // so a single LOO over the trajectory data computes all baselines at once.
+        const baselineArg = ctx.flags.baseline ?? 'all';
+        const allBaselines = ['heuristic', 'always-haiku', 'always-sonnet', 'always-opus', 'always-gpt-4.1'];
+        const baselines = baselineArg === 'all' ? allBaselines : [baselineArg];
+        // Map each baseline label → the modelId used for pricing.
+        const baselineModelFor = (baseline, dec) => {
+            switch (baseline) {
+                case 'heuristic':
+                    return dec.ab_pair?.bandit_pick
+                        ?? (dec.complexity < 0.34 ? 'haiku' : dec.complexity < 0.67 ? 'sonnet' : 'opus');
+                case 'always-haiku': return 'haiku';
+                case 'always-sonnet': return 'sonnet';
+                case 'always-opus': return 'opus';
+                case 'always-gpt-4.1': return 'openai/gpt-4.1';
+                default: return baseline; // operator passes raw modelId
+            }
+        };
+        const perCall = [];
+        let droppedNoOutcomeCost = 0;
+        let droppedNoDecision = 0;
+        let droppedNoTokens = 0;
+        // iter 61 — task-hash filter for per-task cost investigation.
+        const taskHashFilter = (ctx.flags['task-hash'] ?? ctx.flags.taskHash)?.toLowerCase();
+        if (taskHashFilter && !/^[0-9a-f]{8}$/.test(taskHashFilter)) {
+            output.printError(`--task-hash must be an 8-char hex string (got "${taskHashFilter}")`);
+            return { success: false, exitCode: 1 };
+        }
+        // iter 62 — iterate ALL outcomes (Array), not just one per hash. Multiple
+        // occurrences of the same task contribute separately to the aggregate.
+        for (const out of outcomes) {
+            if (cutoffMs !== null && Date.parse(out.ts) < cutoffMs)
+                continue;
+            if (taskHashFilter && out.task_hash !== taskHashFilter)
+                continue;
+            if (out.cost_usd == null) {
+                droppedNoOutcomeCost++;
+                continue;
+            }
+            const dec = decisions.get(out.task_hash);
+            if (!dec) {
+                droppedNoDecision++;
+                continue;
+            }
+            if (!out.tokens) {
+                droppedNoTokens++;
+                continue;
+            }
+            const actualCost = out.cost_usd;
+            const actualModel = out.model_id ?? dec.openrouter_model ?? dec.model;
+            const tier = dec.complexity < 0.34 ? 'cheap' : dec.complexity < 0.67 ? 'mid' : 'strong';
+            // Compute every baseline at once. Cost = (input × $/Mtok_in + output ×
+            // $/Mtok_out) / 1e6 — same formula iter 31's costUsd() uses.
+            const counterfactuals = {};
+            for (const b of baselines) {
+                const m = baselineModelFor(b, dec);
+                const p = MODEL_PRICES[m] ?? { in: 1, out: 1 };
+                const cost = (out.tokens.input * p.in + out.tokens.output * p.out) / 1_000_000;
+                counterfactuals[b] = { model: m, cost, savings: cost - actualCost };
+            }
+            perCall.push({
+                task_hash: out.task_hash, ts: out.ts,
+                actualModel, actualCost,
+                counterfactuals,
+                tokens: out.tokens,
+                complexity: dec.complexity, tier,
+            });
+        }
+        const round6 = (x) => Math.round(x * 1_000_000) / 1_000_000;
+        const round2 = (x) => Math.round(x * 100) / 100;
+        const totalActual = perCall.reduce((s, p) => s + p.actualCost, 0);
+        const baselineAggs = {};
+        for (const b of baselines) {
+            let totalCf = 0;
+            const byTier = {
+                cheap: { actual: 0, counterfactual: 0, n: 0 },
+                mid: { actual: 0, counterfactual: 0, n: 0 },
+                strong: { actual: 0, counterfactual: 0, n: 0 },
+            };
+            for (const c of perCall) {
+                const cf = c.counterfactuals[b]?.cost ?? 0;
+                totalCf += cf;
+                byTier[c.tier].actual += c.actualCost;
+                byTier[c.tier].counterfactual += cf;
+                byTier[c.tier].n += 1;
+            }
+            const savings = totalCf - totalActual;
+            const pct = totalCf > 0 ? (savings / totalCf) * 100 : 0;
+            baselineAggs[b] = {
+                totalUsd: round6(savings),
+                savingsPct: round2(pct),
+                actualUsd: round6(totalActual),
+                counterfactualUsd: round6(totalCf),
+                byTier: Object.fromEntries(Object.entries(byTier).map(([k, v]) => [k, {
+                        n: v.n,
+                        actualUsd: round6(v.actual),
+                        counterfactualUsd: round6(v.counterfactual),
+                        savingsUsd: round6(v.counterfactual - v.actual),
+                        savingsPct: v.counterfactual > 0 ? round2(((v.counterfactual - v.actual) / v.counterfactual) * 100) : 0,
+                    }])),
+            };
+        }
+        // Top-N largest individual savings — use the first baseline's per-call savings.
+        const primaryBaseline = baselines[0];
+        const topSavings = [...perCall].sort((a, b) => (b.counterfactuals[primaryBaseline]?.savings ?? 0) - (a.counterfactuals[primaryBaseline]?.savings ?? 0)).slice(0, topN);
+        const payload = {
+            input: inPath,
+            filters: { since, taskHash: taskHashFilter },
+            pairs: perCall.length,
+            dropped: { noOutcomeCost: droppedNoOutcomeCost, noDecision: droppedNoDecision, noTokens: droppedNoTokens },
+            baselines: Object.fromEntries(Object.entries(baselineAggs).map(([k, v]) => [k, {
+                    savings: { totalUsd: v.totalUsd, savingsPct: v.savingsPct, actualUsd: v.actualUsd, counterfactualUsd: v.counterfactualUsd },
+                    byTier: v.byTier,
+                }])),
+            // Back-compat: top-level `savings` and `byTier` mirror the PRIMARY baseline
+            // (first in the requested list, which for --baseline all is "heuristic" — same
+            // as iter 32's output shape). Iter 32 callers parsing the old shape keep working.
+            savings: baselineAggs[primaryBaseline]
+                ? { totalUsd: baselineAggs[primaryBaseline].totalUsd, savingsPct: baselineAggs[primaryBaseline].savingsPct, actualUsd: baselineAggs[primaryBaseline].actualUsd, counterfactualUsd: baselineAggs[primaryBaseline].counterfactualUsd }
+                : { totalUsd: 0, savingsPct: 0, actualUsd: round6(totalActual), counterfactualUsd: 0 },
+            byTier: baselineAggs[primaryBaseline]?.byTier ?? {},
+            topSavings: topSavings.map(t => ({
+                ts: t.ts, actualModel: t.actualModel,
+                counterfactualModel: t.counterfactuals[primaryBaseline]?.model ?? '—',
+                actualUsd: round6(t.actualCost),
+                counterfactualUsd: round6(t.counterfactuals[primaryBaseline]?.cost ?? 0),
+                savingsUsd: round6(t.counterfactuals[primaryBaseline]?.savings ?? 0),
+            })),
+        };
+        // iter 34 — windowed drift detection. When --window is set, bin the
+        // paired calls into successive duration windows and emit a trend table
+        // (one row per window). Useful for "is the router degrading over time?"
+        // — a sudden drop in savings %% across windows surfaces calibration drift,
+        // workload shifts, or model deprecation.
+        const windowArg = ctx.flags.window;
+        let windowedTrend;
+        if (windowArg) {
+            const m = windowArg.match(/^(\d+)([hdmw])$/);
+            if (!m) {
+                output.printError(`--window must match Nh|Nd|Nm|Nw (got ${windowArg})`);
+                return { success: false, exitCode: 1 };
+            }
+            const n = parseInt(m[1], 10);
+            const unitMs = { m: 60_000, h: 3_600_000, d: 86_400_000, w: 7 * 86_400_000 }[m[2]] ?? 0;
+            const windowMs = n * unitMs;
+            if (windowMs <= 0) {
+                output.printError(`--window must be positive (got ${windowArg})`);
+                return { success: false, exitCode: 1 };
+            }
+            // Bin perCall by (outcome.ts - earliest.ts) / windowMs.
+            // Sort first so window indices are monotonic and gaps are visible.
+            const sorted = [...perCall].sort((a, b) => a.ts.localeCompare(b.ts));
+            if (sorted.length === 0) {
+                windowedTrend = [];
+            }
+            else {
+                const earliestMs = Date.parse(sorted[0].ts);
+                const bins = new Map();
+                for (const c of sorted) {
+                    const idx = Math.floor((Date.parse(c.ts) - earliestMs) / windowMs);
+                    if (!bins.has(idx))
+                        bins.set(idx, []);
+                    bins.get(idx).push(c);
+                }
+                const rows = [];
+                let priorPct = null;
+                for (const idx of [...bins.keys()].sort((a, b) => a - b)) {
+                    const items = bins.get(idx);
+                    let actual = 0, cf = 0;
+                    for (const c of items) {
+                        actual += c.actualCost;
+                        cf += c.counterfactuals[primaryBaseline]?.cost ?? 0;
+                    }
+                    const savings = cf - actual;
+                    const pct = cf > 0 ? (savings / cf) * 100 : 0;
+                    const windowStart = new Date(earliestMs + idx * windowMs).toISOString();
+                    const windowEnd = new Date(earliestMs + (idx + 1) * windowMs - 1).toISOString();
+                    const deltaVsPriorPct = priorPct === null ? null : round2(pct - priorPct);
+                    priorPct = pct;
+                    rows.push({
+                        windowStart, windowEnd, n: items.length,
+                        actualUsd: round6(actual),
+                        counterfactualUsd: round6(cf),
+                        savingsUsd: round6(savings),
+                        savingsPct: round2(pct),
+                        deltaVsPriorPct,
+                    });
+                }
+                windowedTrend = rows;
+            }
+            payload.windowedTrend = windowedTrend;
+            payload.windowConfig = { duration: windowArg, primaryBaseline };
+        }
+        // iter 50 — drift alert. When --alert-on-drop-pct is set AND --window
+        // produced ≥ 2 windows, compare the most-recent window's savings% to
+        // the mean of prior windows'. If it dropped by > threshold, fail
+        // (exit 1) so monitoring catches it. Independent of fmt — alert
+        // state goes into the payload AND drives the exit code.
+        const alertDropPctArg = (ctx.flags['alert-on-drop-pct'] ?? ctx.flags.alertOnDropPct);
+        let alertTriggered = false;
+        let alertReason = null;
+        if (alertDropPctArg !== undefined && alertDropPctArg !== null && alertDropPctArg !== '') {
+            const dropThreshold = typeof alertDropPctArg === 'string' ? parseFloat(alertDropPctArg) : alertDropPctArg;
+            if (!isFinite(dropThreshold) || dropThreshold <= 0) {
+                output.printError(`--alert-on-drop-pct must be a positive number (got ${alertDropPctArg})`);
+                return { success: false, exitCode: 1 };
+            }
+            if (!windowedTrend || windowedTrend.length < 2) {
+                alertReason = `not enough windows for drift detection (need ≥ 2, got ${windowedTrend?.length ?? 0}) — alert skipped`;
+            }
+            else {
+                const latest = windowedTrend[windowedTrend.length - 1];
+                const prior = windowedTrend.slice(0, -1);
+                const priorMean = prior.reduce((s, w) => s + w.savingsPct, 0) / prior.length;
+                const dropPct = priorMean - latest.savingsPct;
+                if (dropPct > dropThreshold) {
+                    alertTriggered = true;
+                    alertReason = `latest window savings ${latest.savingsPct.toFixed(2)}% is ${dropPct.toFixed(2)} points BELOW prior windows' mean ${priorMean.toFixed(2)}% (threshold ${dropThreshold})`;
+                }
+                else {
+                    alertReason = `latest window savings ${latest.savingsPct.toFixed(2)}% within ${dropThreshold} points of prior mean ${priorMean.toFixed(2)}% — OK`;
+                }
+            }
+            payload.alert = {
+                triggered: alertTriggered,
+                reason: alertReason,
+                dropThreshold,
+            };
+        }
+        if (fmt === 'json') {
+            output.writeln(JSON.stringify(payload, null, 2));
+            return alertTriggered
+                ? { success: false, exitCode: 1, data: payload }
+                : { success: true, data: payload };
+        }
+        output.writeln();
+        output.writeln(output.bold('Cost-savings analysis (ADR-149 iter 32)'));
+        output.writeln(output.dim('─'.repeat(72)));
+        output.writeln(`  Input:           ${inPath}`);
+        if (since)
+            output.writeln(`  Time window:     since ${since}`);
+        if (taskHashFilter)
+            output.writeln(`  Task hash:       ${taskHashFilter}  (filtered to this task)`);
+        output.writeln(`  Paired calls:    ${perCall.length}  (dropped: no-cost=${droppedNoOutcomeCost}, no-decision=${droppedNoDecision}, no-tokens=${droppedNoTokens})`);
+        output.writeln('');
+        if (perCall.length === 0) {
+            output.writeln(output.dim('  No cost-bearing paired rows. Enable trajectory recording AND make sure'));
+            output.writeln(output.dim('  outcome rows include `tokens` (iter 31 wired this through agent-execute-core).'));
+            output.writeln('');
+            return { success: true, data: payload };
+        }
+        output.writeln(output.bold('  Headline (actual = $' + totalActual.toFixed(6) + '):'));
+        output.writeln('    baseline            counterfactual   savings        %');
+        for (const [b, agg] of Object.entries(baselineAggs)) {
+            const savingsStr = agg.totalUsd >= 0 ? '$' + agg.totalUsd.toFixed(6) : '-$' + Math.abs(agg.totalUsd).toFixed(6);
+            const colored = agg.totalUsd >= 0 ? output.success(savingsStr) : output.warning(savingsStr);
+            output.writeln(`    ${b.padEnd(18)}  $${agg.counterfactualUsd.toFixed(6).padEnd(14)}  ${colored.padEnd(20)} ${agg.savingsPct.toString().padStart(6)}%`);
+        }
+        output.writeln('');
+        output.writeln(output.dim(`  Primary baseline for per-tier and top-savings views: "${primaryBaseline}"`));
+        output.writeln('');
+        const primaryAgg = baselineAggs[primaryBaseline];
+        output.writeln(output.bold('  By tier (' + primaryBaseline + '):'));
+        output.writeln('    tier      n   actual          counterfactual  savings         %');
+        for (const [k, v] of Object.entries(primaryAgg.byTier)) {
+            output.writeln(`    ${k.padEnd(8)}  ${String(v.n).padStart(3)}  $${v.actualUsd.toFixed(6).padEnd(14)} $${v.counterfactualUsd.toFixed(6).padEnd(14)} $${v.savingsUsd.toFixed(6).padEnd(14)} ${v.savingsPct.toString().padStart(6)}%`);
+        }
+        output.writeln('');
+        if (topSavings.length > 0) {
+            output.writeln(output.bold(`  Top ${topSavings.length} largest individual savings (${primaryBaseline}):`));
+            output.writeln('    ts                  actual                                    → counterfactual                           saved');
+            for (const t of topSavings) {
+                const cfModel = t.counterfactuals[primaryBaseline]?.model ?? '—';
+                const sv = t.counterfactuals[primaryBaseline]?.savings ?? 0;
+                output.writeln(`    ${t.ts.slice(0, 19)}  ${t.actualModel.padEnd(40)} → ${cfModel.padEnd(40)}  $${sv.toFixed(6)}`);
+            }
+            output.writeln('');
+        }
+        // iter 34 — windowed trend table for drift detection.
+        if (windowedTrend && windowedTrend.length > 0) {
+            output.writeln(output.bold(`  Windowed trend (${windowArg} bins, baseline=${primaryBaseline}):`));
+            output.writeln('    window start         n    actual       counterfactual  savings      %       Δ% vs prior');
+            for (const w of windowedTrend) {
+                const arrow = w.deltaVsPriorPct === null ? ''
+                    : w.deltaVsPriorPct > 0 ? output.success(`↑ +${w.deltaVsPriorPct.toFixed(2)}`)
+                        : w.deltaVsPriorPct < 0 ? output.warning(`↓ ${w.deltaVsPriorPct.toFixed(2)}`)
+                            : '·';
+                output.writeln(`    ${w.windowStart.slice(0, 19)}  ${String(w.n).padStart(3)}  $${w.actualUsd.toFixed(6).padEnd(11)} $${w.counterfactualUsd.toFixed(6).padEnd(14)} $${w.savingsUsd.toFixed(6).padEnd(11)} ${w.savingsPct.toString().padStart(6)}%  ${arrow}`);
+            }
+            output.writeln('');
+            output.writeln(output.dim('    Δ% vs prior: change in savings % from the prior window. Large negative'));
+            output.writeln(output.dim('    deltas suggest router degradation, workload shift, or calibration drift.'));
+            output.writeln('');
+        }
+        // iter 50 — alert footer when --alert-on-drop-pct was used.
+        if (alertReason !== null) {
+            if (alertTriggered) {
+                output.writeln(output.warning(`  ⚠ ALERT: ${alertReason}`));
+            }
+            else {
+                output.writeln(output.dim(`  ${alertReason}`));
+            }
+            output.writeln('');
+        }
+        return alertTriggered
+            ? { success: false, exitCode: 1, data: payload }
+            : { success: true, data: payload };
+    },
+};
+// ADR-149 iter 36 — operational observability for the trajectory JSONL itself.
+// Iter 17 added the recorder with rotation. Iter 28/30/32 consume the data.
+// Nothing previously surfaced "is logging healthy?" — size vs cap, rotation
+// count, parse success rate, pair-join rate, time range. SREs need this view.
+const routerTrajectoryHealthCommand = {
+    name: 'trajectory-health',
+    description: 'Show health of the routing-decision JSONL log: size, rotations, parse rate, pair-join rate (ADR-149 iter 36)',
+    options: [
+        { name: 'in', short: 'i', type: 'string', description: 'Trajectory JSONL path (default: $CLAUDE_FLOW_ROUTER_TRAJECTORY_PATH or .swarm/...)' },
+        { name: 'format', short: 'f', type: 'string', description: 'Output format: table, json', default: 'table' },
+    ],
+    examples: [
+        { command: 'claude-flow neural router trajectory-health', description: 'Snapshot of trajectory log health' },
+        { command: 'claude-flow neural router trajectory-health --format json | jq .pairJoinRatePct', description: 'Pipe-friendly pair-join rate for dashboards' },
+    ],
+    action: async (ctx) => {
+        const fs = await import('node:fs');
+        const path = await import('node:path');
+        const inPath = ctx.flags.in
+            ?? process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY_PATH
+            ?? path.resolve(process.cwd(), '.swarm', 'model-router-trajectories.jsonl');
+        const fmt = ctx.flags.format || 'table';
+        // Recorder config (mirrors router-trajectory.ts defaults).
+        const recorderEnabled = process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY === '1';
+        const maxSizeBytes = parseInt(process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY_MAXSIZE ?? `${10 * 1024 * 1024}`, 10) | 0;
+        const maxRotations = Math.max(0, parseInt(process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY_MAXROTATIONS ?? '3', 10) || 3);
+        if (!fs.existsSync(inPath)) {
+            const payload = {
+                recorderEnabled,
+                input: inPath,
+                exists: false,
+                message: 'No trajectory file at the configured path.',
+                hint: recorderEnabled
+                    ? 'Recorder is enabled — file should appear after the next routing decision.'
+                    : 'Recorder is OFF. Set CLAUDE_FLOW_ROUTER_TRAJECTORY=1 to enable.',
+            };
+            if (fmt === 'json')
+                output.writeln(JSON.stringify(payload, null, 2));
+            else {
+                output.writeln('');
+                output.writeln(output.bold('Trajectory health'));
+                output.writeln(output.dim('─'.repeat(60)));
+                output.writeln(`  Path:           ${inPath}`);
+                output.writeln(`  Recorder gate:  ${recorderEnabled ? output.success('ON') : output.warning('OFF (CLAUDE_FLOW_ROUTER_TRAJECTORY=1 to enable)')}`);
+                output.writeln(`  Status:         ${output.warning('file does not exist')}`);
+                output.writeln(`  Hint:           ${payload.hint}`);
+                output.writeln('');
+            }
+            return { success: true, data: payload };
+        }
+        const stat = fs.statSync(inPath);
+        const sizeBytes = stat.size;
+        const sizePct = maxSizeBytes > 0 ? Math.round((sizeBytes / maxSizeBytes) * 1000) / 10 : 0;
+        // Count .bak rotation files.
+        const rotationFiles = [];
+        for (let i = 1; i <= maxRotations; i++) {
+            const p = `${inPath}.${i}`;
+            if (fs.existsSync(p)) {
+                const s = fs.statSync(p);
+                rotationFiles.push({ index: i, path: p, bytes: s.size, mtime: s.mtime.toISOString() });
+            }
+        }
+        const lines = fs.readFileSync(inPath, 'utf8').split('\n').filter(l => l.trim().length > 0);
+        let decisions = 0, outcomes = 0, malformed = 0, otherType = 0;
+        let oldestTs = null;
+        let newestTs = null;
+        const decisionHashes = new Set();
+        const outcomeHashes = new Set();
+        for (const l of lines) {
+            try {
+                const r = JSON.parse(l);
+                if (r.type === 'decision') {
+                    decisions++;
+                    if (r.task_hash)
+                        decisionHashes.add(r.task_hash);
+                }
+                else if (r.type === 'outcome') {
+                    outcomes++;
+                    if (r.task_hash)
+                        outcomeHashes.add(r.task_hash);
+                }
+                else {
+                    otherType++;
+                }
+                if (r.ts) {
+                    if (oldestTs === null || r.ts < oldestTs)
+                        oldestTs = r.ts;
+                    if (newestTs === null || r.ts > newestTs)
+                        newestTs = r.ts;
+                }
+            }
+            catch {
+                malformed++;
+            }
+        }
+        // Pair-join rate: % of decisions that have a matching outcome.
+        let pairedHashes = 0;
+        for (const h of decisionHashes)
+            if (outcomeHashes.has(h))
+                pairedHashes++;
+        const pairJoinRatePct = decisionHashes.size > 0
+            ? Math.round((pairedHashes / decisionHashes.size) * 10000) / 100
+            : 0;
+        const parseSuccessPct = lines.length > 0
+            ? Math.round(((lines.length - malformed) / lines.length) * 10000) / 100
+            : 100;
+        const payload = {
+            recorderEnabled,
+            input: inPath,
+            exists: true,
+            file: {
+                sizeBytes,
+                sizePct,
+                maxSizeBytes,
+                maxRotations,
+                rotationsOnDisk: rotationFiles.length,
+                rotations: rotationFiles,
+                mtime: stat.mtime.toISOString(),
+            },
+            rows: {
+                total: lines.length,
+                decisions, outcomes, otherType, malformed,
+            },
+            pairing: {
+                uniqueDecisionHashes: decisionHashes.size,
+                uniqueOutcomeHashes: outcomeHashes.size,
+                pairedHashes,
+                pairJoinRatePct,
+                parseSuccessPct,
+            },
+            timeRange: {
+                oldestTs, newestTs,
+                spanHours: oldestTs && newestTs ? Math.round(((Date.parse(newestTs) - Date.parse(oldestTs)) / 3600_000) * 10) / 10 : 0,
+            },
+        };
+        if (fmt === 'json') {
+            output.writeln(JSON.stringify(payload, null, 2));
+            return { success: true, data: payload };
+        }
+        output.writeln();
+        output.writeln(output.bold('Trajectory health (ADR-149 iter 36)'));
+        output.writeln(output.dim('─'.repeat(60)));
+        output.writeln(`  Path:           ${inPath}`);
+        output.writeln(`  Recorder gate:  ${recorderEnabled ? output.success('ON') : output.warning('OFF')}`);
+        output.writeln('');
+        output.writeln(output.bold('  File:'));
+        const sizeMb = (sizeBytes / 1_048_576).toFixed(3);
+        const capMb = (maxSizeBytes / 1_048_576).toFixed(1);
+        const sizeWarn = sizePct >= 80 ? output.warning(`(${sizePct}% of cap)`) : output.dim(`(${sizePct}% of cap)`);
+        output.writeln(`    size:         ${sizeBytes} bytes (${sizeMb} MB) of ${capMb} MB max  ${sizeWarn}`);
+        output.writeln(`    last write:   ${stat.mtime.toISOString()}`);
+        output.writeln(`    rotations:    ${rotationFiles.length} of ${maxRotations} max .bak files on disk`);
+        for (const r of rotationFiles) {
+            output.writeln(`      .${r.index}:  ${r.bytes} bytes  ${r.mtime}`);
+        }
+        output.writeln('');
+        output.writeln(output.bold('  Rows:'));
+        output.writeln(`    total:        ${lines.length}`);
+        output.writeln(`    decisions:    ${decisions}`);
+        output.writeln(`    outcomes:     ${outcomes}`);
+        if (otherType > 0)
+            output.writeln(`    other type:   ${otherType}`);
+        output.writeln(`    malformed:    ${malformed}  (parse success ${parseSuccessPct}%)`);
+        output.writeln('');
+        output.writeln(output.bold('  Pairing (decision ↔ outcome join by task_hash):'));
+        output.writeln(`    unique decision hashes:  ${decisionHashes.size}`);
+        output.writeln(`    unique outcome hashes:   ${outcomeHashes.size}`);
+        output.writeln(`    paired:                  ${pairedHashes} (${pairJoinRatePct}%)`);
+        if (pairJoinRatePct < 50 && decisionHashes.size > 5) {
+            output.writeln(output.warning(`    ⚠ pair-join rate < 50% — outcome rows may not be wired through (iter 17/31).`));
+        }
+        output.writeln('');
+        if (oldestTs && newestTs) {
+            output.writeln(output.bold('  Time range:'));
+            output.writeln(`    oldest:       ${oldestTs}`);
+            output.writeln(`    newest:       ${newestTs}`);
+            output.writeln(`    span:         ${payload.timeRange.spanHours} hours`);
+            output.writeln('');
+        }
+        return { success: true, data: payload };
+    },
+};
+// ADR-149 iter 54 — consolidated env-var inspection. The router has ~15
+// CLAUDE_FLOW_ROUTER_* env vars accumulated across iters 12-53. Operators
+// need a single command that lists each with its current value (or default),
+// effect, and which iter introduced it. Color-coded: green = override set,
+// dim = default.
+const routerConfigCommand = {
+    name: 'config',
+    description: 'List all CLAUDE_FLOW_ROUTER_* env vars with current values + effects (ADR-149 iter 54)',
+    options: [
+        { name: 'format', short: 'f', type: 'string', description: 'Output format: table, json', default: 'table' },
+        { name: 'only-overrides', type: 'boolean', description: 'Only show env vars that are explicitly set (hide defaults)', default: false },
+    ],
+    examples: [
+        { command: 'claude-flow neural router config', description: 'All router env vars with current values' },
+        { command: 'claude-flow neural router config --only-overrides', description: 'Just what the operator has set' },
+        { command: 'claude-flow neural router config --format json | jq', description: 'Audit / diff against another deployment' },
+    ],
+    action: async (ctx) => {
+        const fmt = ctx.flags.format || 'table';
+        const onlyOverrides = Boolean(ctx.flags['only-overrides'] ?? ctx.flags.onlyOverrides);
+        const rows = [
+            // Core gate (iter 0)
+            { name: 'CLAUDE_FLOW_ROUTER_NEURAL', iter: 0, defaultValue: 'unset (0)', currentValue: process.env.CLAUDE_FLOW_ROUTER_NEURAL ?? '', isOverride: !!process.env.CLAUDE_FLOW_ROUTER_NEURAL, effect: 'Gate. =1 enables neural router; otherwise pure-bandit heuristic.' },
+            { name: 'CLAUDE_FLOW_ROUTER_MODEL_PATH', iter: 0, defaultValue: 'unset', currentValue: process.env.CLAUDE_FLOW_ROUTER_MODEL_PATH ?? '', isOverride: !!process.env.CLAUDE_FLOW_ROUTER_MODEL_PATH, effect: 'Override the KRR artifact path. Defaults to bundled.' },
+            { name: 'CLAUDE_FLOW_ROUTER_QUALITY_BAR', iter: 0, defaultValue: '0.50', currentValue: process.env.CLAUDE_FLOW_ROUTER_QUALITY_BAR ?? '', isOverride: !!process.env.CLAUDE_FLOW_ROUTER_QUALITY_BAR, effect: 'Cost-optimal mode: minimum predicted quality to pick a candidate.' },
+            // Trajectory (iter 17)
+            { name: 'CLAUDE_FLOW_ROUTER_TRAJECTORY', iter: 17, defaultValue: 'unset (0)', currentValue: process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY ?? '', isOverride: !!process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY, effect: 'Gate. =1 writes decision+outcome rows to .swarm/model-router-trajectories.jsonl.' },
+            { name: 'CLAUDE_FLOW_ROUTER_TRAJECTORY_PATH', iter: 17, defaultValue: '.swarm/model-router-trajectories.jsonl', currentValue: process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY_PATH ?? '', isOverride: !!process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY_PATH, effect: 'Override the trajectory JSONL path.' },
+            { name: 'CLAUDE_FLOW_ROUTER_TRAJECTORY_MAXSIZE', iter: 17, defaultValue: '10485760 (10MB)', currentValue: process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY_MAXSIZE ?? '', isOverride: !!process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY_MAXSIZE, effect: 'Bytes before rotation. Set 0 to disable rotation.' },
+            { name: 'CLAUDE_FLOW_ROUTER_TRAJECTORY_MAXROTATIONS', iter: 17, defaultValue: '3', currentValue: process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY_MAXROTATIONS ?? '', isOverride: !!process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY_MAXROTATIONS, effect: 'Max .bak files to keep when rotating.' },
+            { name: 'CLAUDE_FLOW_ROUTER_TRAJECTORY_TASKLEN', iter: 17, defaultValue: '500', currentValue: process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY_TASKLEN ?? '', isOverride: !!process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY_TASKLEN, effect: 'Max chars of task text to persist per row (truncated above this).' },
+            // Latency budget (iter 12)
+            { name: 'CLAUDE_FLOW_ROUTER_LATENCY_BUDGET_MS', iter: 12, defaultValue: '0 (unbounded)', currentValue: process.env.CLAUDE_FLOW_ROUTER_LATENCY_BUDGET_MS ?? '', isOverride: !!process.env.CLAUDE_FLOW_ROUTER_LATENCY_BUDGET_MS, effect: 'Drop candidates whose measured p50 latency > this many ms before selection.' },
+            // Per-modelId bandit (iter 14)
+            { name: 'CLAUDE_FLOW_ROUTER_BANDIT_PER_MODEL', iter: 14, defaultValue: 'unset (0)', currentValue: process.env.CLAUDE_FLOW_ROUTER_BANDIT_PER_MODEL ?? '', isOverride: !!process.env.CLAUDE_FLOW_ROUTER_BANDIT_PER_MODEL, effect: 'Gate. =1 enables per-modelId Thompson sampling perturbation of neural prediction.' },
+            // k-NN backend (iter 0)
+            { name: 'CLAUDE_FLOW_ROUTER_KNN_K', iter: 0, defaultValue: '5', currentValue: process.env.CLAUDE_FLOW_ROUTER_KNN_K ?? '', isOverride: !!process.env.CLAUDE_FLOW_ROUTER_KNN_K, effect: 'k for the k-NN backend when KRR is not loadable.' },
+            { name: 'CLAUDE_FLOW_ROUTER_SEED_CORPUS', iter: 0, defaultValue: 'bundled seed-rows.json', currentValue: process.env.CLAUDE_FLOW_ROUTER_SEED_CORPUS ?? '', isOverride: !!process.env.CLAUDE_FLOW_ROUTER_SEED_CORPUS, effect: 'Override the DRACO seed corpus path.' },
+            // Calibration (iter 22-25)
+            { name: 'CLAUDE_FLOW_ROUTER_CALIBRATE', iter: 24, defaultValue: 'unset (default ON)', currentValue: process.env.CLAUDE_FLOW_ROUTER_CALIBRATE ?? '', isOverride: !!process.env.CLAUDE_FLOW_ROUTER_CALIBRATE, effect: 'Isotonic calibration of KRR predictions. =0 opts out (recovers raw KRR). Default-on since iter 24 (OOS validated).' },
+            { name: 'CLAUDE_FLOW_ROUTER_CALIBRATOR_PATH', iter: 22, defaultValue: 'bundled seed-router.calibrator.json', currentValue: process.env.CLAUDE_FLOW_ROUTER_CALIBRATOR_PATH ?? '', isOverride: !!process.env.CLAUDE_FLOW_ROUTER_CALIBRATOR_PATH, effect: 'Override the unified calibrator path. Per-tier files (low/med/high) load from the same dir.' },
+            // Cost ceiling (iter 29)
+            { name: 'CLAUDE_FLOW_ROUTER_COST_CEILING_USD_PER_MTOK', iter: 29, defaultValue: '0 (disabled)', currentValue: process.env.CLAUDE_FLOW_ROUTER_COST_CEILING_USD_PER_MTOK ?? '', isOverride: !!process.env.CLAUDE_FLOW_ROUTER_COST_CEILING_USD_PER_MTOK, effect: 'Orthogonal selector mode: pick BEST quality among candidates ≤ ceiling $/Mtok blended.' },
+            // A/B mode (iter 5/37)
+            { name: 'CLAUDE_FLOW_ROUTER_AB', iter: 5, defaultValue: 'unset (0)', currentValue: process.env.CLAUDE_FLOW_ROUTER_AB ?? '', isOverride: !!process.env.CLAUDE_FLOW_ROUTER_AB, effect: 'Legacy all-on A/B mode. Records bandit_pick + hybrid_pick on every decision.' },
+            { name: 'CLAUDE_FLOW_ROUTER_AB_SAMPLE_RATE', iter: 37, defaultValue: '0 (disabled)', currentValue: process.env.CLAUDE_FLOW_ROUTER_AB_SAMPLE_RATE ?? '', isOverride: !!process.env.CLAUDE_FLOW_ROUTER_AB_SAMPLE_RATE, effect: 'Sampled A/B mode. 0..1 fraction of decisions to A/B (deterministic by task_hash). Overrides legacy AB=1.' },
+            // Ensemble uncertainty (iter 44)
+            { name: 'CLAUDE_FLOW_ROUTER_ENSEMBLE_UNCERTAINTY_THRESHOLD', iter: 44, defaultValue: '0 (disabled)', currentValue: process.env.CLAUDE_FLOW_ROUTER_ENSEMBLE_UNCERTAINTY_THRESHOLD ?? '', isOverride: !!process.env.CLAUDE_FLOW_ROUTER_ENSEMBLE_UNCERTAINTY_THRESHOLD, effect: 'When > 0: if |unified_q - specialist_q| > threshold for picked model, fall back to bandit.' },
+            // Bandit warmup (iter 52/53)
+            { name: 'CLAUDE_FLOW_ROUTER_BANDIT_WARMUP_RANGE', iter: 52, defaultValue: '8', currentValue: process.env.CLAUDE_FLOW_ROUTER_BANDIT_WARMUP_RANGE ?? '', isOverride: !!process.env.CLAUDE_FLOW_ROUTER_BANDIT_WARMUP_RANGE, effect: 'Continuous warmup denominator. Smaller = bandit ramps faster; larger = more conservative.' },
+            { name: 'CLAUDE_FLOW_ROUTER_BANDIT_FULL_INFLUENCE', iter: 53, defaultValue: 'unset (0)', currentValue: process.env.CLAUDE_FLOW_ROUTER_BANDIT_FULL_INFLUENCE ?? '', isOverride: !!process.env.CLAUDE_FLOW_ROUTER_BANDIT_FULL_INFLUENCE, effect: 'Gate. =1 uses asymptotic curve (samples-2)/(samples+WARMUP) — bandit dominates at scale.' },
+            { name: 'CLAUDE_FLOW_ROUTER_BANDIT_SHRINKAGE_LAMBDA', iter: 57, defaultValue: '4', currentValue: process.env.CLAUDE_FLOW_ROUTER_BANDIT_SHRINKAGE_LAMBDA ?? '', isOverride: !!process.env.CLAUDE_FLOW_ROUTER_BANDIT_SHRINKAGE_LAMBDA, effect: 'Cross-bucket shrinkage strength. λ=0 disables; higher λ = more bias toward marginal anchor for cold cells.' },
+        ];
+        const visible = onlyOverrides ? rows.filter(r => r.isOverride) : rows;
+        if (fmt === 'json') {
+            output.writeln(JSON.stringify(visible, null, 2));
+            return { success: true, data: visible };
+        }
+        output.writeln();
+        output.writeln(output.bold('Router config — ADR-149 iter 54 (env-var inventory)'));
+        output.writeln(output.dim('─'.repeat(72)));
+        output.writeln(`  ${visible.length} of ${rows.length} entries  (${rows.filter(r => r.isOverride).length} overridden, ${rows.length - rows.filter(r => r.isOverride).length} default)`);
+        output.writeln('');
+        for (const r of visible) {
+            const value = r.isOverride ? output.success(r.currentValue) : output.dim(`(default: ${r.defaultValue})`);
+            output.writeln(`  ${r.name} = ${value}`);
+            output.writeln(`    ${output.dim(`iter ${r.iter}`)} ${r.effect}`);
+            output.writeln('');
+        }
+        if (visible.length === 0 && onlyOverrides) {
+            output.writeln(output.dim('  No overrides — all router behavior is at defaults.'));
+            output.writeln('');
+        }
+        return { success: true, data: visible };
+    },
+};
+// ADR-149 iter 55 — side-by-side comparison of the two selector modes.
+// Iter 29 added quality-best-under-budget; iter 30 added `decide` for the
+// default cost-optimal mode. This subcommand runs BOTH on the same task
+// so operators can see which mode is right for their workload BEFORE
+// flipping CLAUDE_FLOW_ROUTER_COST_CEILING_USD_PER_MTOK on for production.
+const routerCompareModesCommand = {
+    name: 'compare-modes',
+    description: 'Compare selector modes side-by-side for a hypothetical task (cost-optimal vs cost-ceiling) — ADR-149 iter 55',
+    options: [
+        { name: 'task', short: 't', type: 'string', description: 'Task text (or positional arg)' },
+        { name: 'ceiling', type: 'number', description: 'Cost-ceiling $/Mtok for iter 29 mode (default 20)', default: '20' },
+        { name: 'format', short: 'f', type: 'string', description: 'Output format: table, json', default: 'table' },
+    ],
+    examples: [
+        { command: 'claude-flow neural router compare-modes "refactor strategy pattern"', description: 'Compare both modes for a task' },
+        { command: 'claude-flow neural router compare-modes -t "..." --ceiling 5', description: 'Cost-ceiling at $5 blended' },
+    ],
+    action: async (ctx) => {
+        const task = ctx.flags.task ?? (ctx.args && ctx.args[0]) ?? null;
+        if (!task) {
+            output.printError('Provide a task: --task "..." or as positional arg');
+            return { success: false, exitCode: 1 };
+        }
+        const ceiling = parseFloat(ctx.flags.ceiling || '20') || 20;
+        const fmt = ctx.flags.format || 'table';
+        const { embedTaskWithCache } = await import('../ruvector/task-embedder.js');
+        const { tryCostOptimalRoute, __resetNeuralRouterForTests } = await import('../ruvector/neural-router.js');
+        const { analyzeTaskComplexity } = await import('../ruvector/model-router.js');
+        const complexity = analyzeTaskComplexity(task);
+        const bucket = complexity.score < 0.34 ? 'low' : complexity.score < 0.67 ? 'med' : 'high';
+        let embedding;
+        try {
+            embedding = await embedTaskWithCache(task);
+        }
+        catch { /* */ }
+        if (!embedding) {
+            output.printError('Embedder unavailable — cannot run neural routing for comparison');
+            return { success: false, exitCode: 1 };
+        }
+        // Mode 1: cost-optimal (default — no ceiling)
+        process.env.CLAUDE_FLOW_ROUTER_NEURAL = '1';
+        delete process.env.CLAUDE_FLOW_ROUTER_COST_CEILING_USD_PER_MTOK;
+        __resetNeuralRouterForTests();
+        const costOptimal = await tryCostOptimalRoute(embedding, { complexityBucket: bucket });
+        // Mode 2: cost-ceiling
+        process.env.CLAUDE_FLOW_ROUTER_COST_CEILING_USD_PER_MTOK = String(ceiling);
+        __resetNeuralRouterForTests();
+        const costCeiling = await tryCostOptimalRoute(embedding, { complexityBucket: bucket });
+        // Clean up
+        delete process.env.CLAUDE_FLOW_ROUTER_COST_CEILING_USD_PER_MTOK;
+        __resetNeuralRouterForTests();
+        const payload = {
+            task: task.length > 200 ? task.slice(0, 200) + '…' : task,
+            complexity: complexity.score,
+            bucket,
+            modes: {
+                costOptimal: costOptimal ? {
+                    modelId: costOptimal.modelId,
+                    predictedQuality: costOptimal.predictedQuality,
+                    costPerMTok: costOptimal.alternatives.find(a => a.modelId === costOptimal.modelId)?.costPerMTok ?? null,
+                    metBar: costOptimal.metBar,
+                } : null,
+                costCeiling: costCeiling ? {
+                    ceilingUsd: ceiling,
+                    modelId: costCeiling.modelId,
+                    predictedQuality: costCeiling.predictedQuality,
+                    costPerMTok: costCeiling.alternatives.find(a => a.modelId === costCeiling.modelId)?.costPerMTok ?? null,
+                    metBar: costCeiling.metBar,
+                } : null,
+            },
+            sameModel: costOptimal?.modelId === costCeiling?.modelId,
+            deltaQuality: (costCeiling && costOptimal) ? costCeiling.predictedQuality - costOptimal.predictedQuality : null,
+            deltaCost: (costCeiling && costOptimal)
+                ? ((costCeiling.alternatives.find(a => a.modelId === costCeiling.modelId)?.costPerMTok ?? 0) - (costOptimal.alternatives.find(a => a.modelId === costOptimal.modelId)?.costPerMTok ?? 0))
+                : null,
+        };
+        if (fmt === 'json') {
+            output.writeln(JSON.stringify(payload, null, 2));
+            return { success: true, data: payload };
+        }
+        output.writeln();
+        output.writeln(output.bold('Selector mode comparison (ADR-149 iter 55)'));
+        output.writeln(output.dim('─'.repeat(72)));
+        output.writeln(`  Task:        "${payload.task}"`);
+        output.writeln(`  Complexity:  ${complexity.score.toFixed(3)} (bucket: ${bucket})`);
+        output.writeln('');
+        output.writeln(output.bold('  Cost-optimal mode (default — cheapest above qualityBar):'));
+        if (costOptimal) {
+            const co = payload.modes.costOptimal;
+            output.writeln(`    picked:           ${output.success(co.modelId)}`);
+            output.writeln(`    predicted Q:      ${co.predictedQuality.toFixed(4)}`);
+            output.writeln(`    cost ($/Mtok):    $${co.costPerMTok?.toFixed(2)}`);
+            output.writeln(`    met quality bar:  ${co.metBar ? '✓' : '✗'}`);
+        }
+        else {
+            output.writeln(`    ${output.warning('null (neural backend declined — would fall back to bandit)')}`);
+        }
+        output.writeln('');
+        output.writeln(output.bold(`  Cost-ceiling mode (iter 29 — best quality ≤ $${ceiling}/Mtok):`));
+        if (costCeiling) {
+            const cc = payload.modes.costCeiling;
+            output.writeln(`    picked:           ${output.success(cc.modelId)}`);
+            output.writeln(`    predicted Q:      ${cc.predictedQuality.toFixed(4)}`);
+            output.writeln(`    cost ($/Mtok):    $${cc.costPerMTok?.toFixed(2)}`);
+            output.writeln(`    met quality bar:  ${cc.metBar ? '✓' : '✗'}`);
+        }
+        else {
+            output.writeln(`    ${output.warning('null')}`);
+        }
+        output.writeln('');
+        if (costOptimal && costCeiling) {
+            if (payload.sameModel) {
+                output.writeln(output.dim('  Both modes picked the same model — selector choice irrelevant for this task.'));
+            }
+            else {
+                const dq = payload.deltaQuality;
+                const dc = payload.deltaCost;
+                const qSign = dq > 0 ? '+' : '';
+                const cSign = dc > 0 ? '+' : '';
+                const qColor = dq > 0 ? output.success(`${qSign}${dq.toFixed(4)}`) : output.warning(`${dq.toFixed(4)}`);
+                const cColor = dc > 0 ? output.warning(`${cSign}$${dc.toFixed(2)}`) : output.success(`$${dc.toFixed(2)}`);
+                output.writeln(`  Δ (ceiling − optimal):  predicted Q: ${qColor}    cost: ${cColor}`);
+                output.writeln('');
+                output.writeln(output.dim(`    Cost-ceiling pays extra cost for higher quality (or is forced cheap if ceiling is tight).`));
+                output.writeln(output.dim(`    Cost-optimal accepts qualityBar threshold but minimizes spend.`));
+            }
+        }
+        output.writeln('');
+        return { success: true, data: payload };
+    },
+};
+// ADR-149 iter 49 — single-command SRE dashboard. The router has 13 subcommands
+// (iter 48); ops want ONE that says "is everything working AND saving money?".
+// Aggregates the most-asked signals into one terse screen.
+const routerStatsSummaryCommand = {
+    name: 'stats-summary',
+    description: 'One-screen SRE dashboard: gate, recent activity, savings, bandit warmest cell (ADR-149 iter 49)',
+    options: [
+        { name: 'format', short: 'f', type: 'string', description: 'Output format: table, json', default: 'table' },
+    ],
+    examples: [
+        { command: 'claude-flow neural router stats-summary', description: 'One-screen health check' },
+        { command: 'claude-flow neural router stats-summary --format json | jq .', description: 'Pipe to dashboards / alerting' },
+    ],
+    action: async (ctx) => {
+        const fs = await import('node:fs');
+        const path = await import('node:path');
+        const fmt = ctx.flags.format || 'table';
+        // 1. Backend gate / status
+        const { neuralRouterStatus } = await import('../ruvector/neural-router.js');
+        const { getModelRouterStats } = await import('../ruvector/model-router.js');
+        const backend = await neuralRouterStatus();
+        const stats = getModelRouterStats();
+        // 2. Trajectory existence + basic counts
+        const trajectoryPath = process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY_PATH
+            ?? path.resolve(process.cwd(), '.swarm', 'model-router-trajectories.jsonl');
+        let trajectory = { exists: false, rows: 0, decisions: 0, outcomes: 0, pairedWithCost: 0, oldestTs: null, newestTs: null };
+        let recent24h = null;
+        let cost7d = null;
+        if (fs.existsSync(trajectoryPath)) {
+            trajectory.exists = true;
+            const { MODEL_PRICES } = await import('../ruvector/model-prices.js');
+            const lines = fs.readFileSync(trajectoryPath, 'utf8').split('\n').filter(l => l.trim().length > 0);
+            trajectory.rows = lines.length;
+            const cutoff24h = Date.now() - 24 * 3600_000;
+            const cutoff7d = Date.now() - 7 * 86400_000;
+            let recDec = 0, recFallback = 0;
+            const decs7d = new Map();
+            const outs7d = new Map();
+            for (const l of lines) {
+                try {
+                    const r = JSON.parse(l);
+                    const tsMs = Date.parse(r.ts);
+                    if (r.type === 'decision') {
+                        trajectory.decisions++;
+                        if (tsMs >= cutoff24h) {
+                            recDec++;
+                            if (r.routed_by === 'bandit-fallback')
+                                recFallback++;
+                        }
+                        if (tsMs >= cutoff7d)
+                            decs7d.set(r.task_hash, r);
+                    }
+                    else if (r.type === 'outcome') {
+                        trajectory.outcomes++;
+                        if (r.cost_usd != null)
+                            trajectory.pairedWithCost++;
+                        if (tsMs >= cutoff7d)
+                            outs7d.set(r.task_hash, r);
+                    }
+                    if (r.ts) {
+                        if (!trajectory.oldestTs || r.ts < trajectory.oldestTs)
+                            trajectory.oldestTs = r.ts;
+                        if (!trajectory.newestTs || r.ts > trajectory.newestTs)
+                            trajectory.newestTs = r.ts;
+                    }
+                }
+                catch { /* malformed */ }
+            }
+            recent24h = {
+                decisions: recDec, fallbacks: recFallback,
+                fallbackRatePct: recDec > 0 ? Math.round((recFallback / recDec) * 10000) / 100 : 0,
+            };
+            // 7-day cost via heuristic counterfactual
+            let pairs = 0, actual = 0, cf = 0;
+            for (const [hash, dec] of decs7d) {
+                const out = outs7d.get(hash);
+                if (!out?.cost_usd || !out.tokens)
+                    continue;
+                pairs++;
+                actual += out.cost_usd;
+                const tierModel = dec.complexity < 0.34 ? 'haiku' : dec.complexity < 0.67 ? 'sonnet' : 'opus';
+                const cfModel = dec.ab_pair?.bandit_pick ?? tierModel;
+                const p = MODEL_PRICES[cfModel] ?? { in: 1, out: 1 };
+                cf += (out.tokens.input * p.in + out.tokens.output * p.out) / 1_000_000;
+            }
+            if (pairs > 0) {
+                cost7d = {
+                    pairs,
+                    actualUsd: Math.round(actual * 1_000_000) / 1_000_000,
+                    counterfactualUsd: Math.round(cf * 1_000_000) / 1_000_000,
+                    savingsUsd: Math.round((cf - actual) * 1_000_000) / 1_000_000,
+                    savingsPct: cf > 0 ? Math.round(((cf - actual) / cf) * 10000) / 100 : 0,
+                };
+            }
+        }
+        let warmestCell = null;
+        const statePath = path.resolve(process.cwd(), '.swarm', 'model-router-state.json');
+        if (fs.existsSync(statePath)) {
+            try {
+                const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+                const priors = state.priorsById ?? state.priors ?? {};
+                let bestSamples = 0;
+                for (const bucket of ['low', 'med', 'high']) {
+                    const b = priors[bucket];
+                    if (!b)
+                        continue;
+                    for (const [k, p] of Object.entries(b)) {
+                        const samples = p.alpha + p.beta - 2;
+                        if (samples > bestSamples) {
+                            bestSamples = samples;
+                            warmestCell = { bucket, key: k, samples, meanQuality: p.alpha / (p.alpha + p.beta) };
+                        }
+                    }
+                }
+            }
+            catch { /* malformed */ }
+        }
+        const payload = {
+            backend: {
+                enabled: backend.enabled,
+                available: backend.available,
+                routedBy: backend.routedBy,
+                reason: backend.reason,
+            },
+            processLocal: {
+                totalDecisions: stats.totalDecisions,
+                modelDistribution: stats.modelDistribution,
+                routedByCounts: stats.routedByCounts,
+                abDisagreementRate: stats.ab.comparisons > 0 ? Math.round(stats.ab.disagreementRate * 10000) / 100 : 0,
+            },
+            trajectory,
+            recent24h,
+            cost7d,
+            warmestBanditCell: warmestCell,
+        };
+        if (fmt === 'json') {
+            output.writeln(JSON.stringify(payload, null, 2));
+            return { success: true, data: payload };
+        }
+        output.writeln();
+        output.writeln(output.bold('Router stats summary — ADR-149 iter 49 (one-screen SRE view)'));
+        output.writeln(output.dim('─'.repeat(72)));
+        output.writeln('');
+        output.writeln(output.bold('  Backend:'));
+        output.writeln(`    gate:           ${backend.enabled ? output.success('open (NEURAL=1)') : output.warning('closed')}`);
+        output.writeln(`    available:      ${backend.available ? output.success('yes') : output.warning('no')}`);
+        output.writeln(`    active backend: ${backend.routedBy ?? '—'}`);
+        output.writeln(`    reason:         ${backend.reason}`);
+        output.writeln('');
+        output.writeln(output.bold('  Process-local (since this server started):'));
+        output.writeln(`    decisions:      ${stats.totalDecisions}`);
+        output.writeln(`    routed_by:      heuristic=${stats.routedByCounts.heuristic}  hybrid=${stats.routedByCounts.hybrid}  bandit-fallback=${stats.routedByCounts['bandit-fallback']}`);
+        if (stats.ab.comparisons > 0) {
+            output.writeln(`    A/B:            ${stats.ab.comparisons} comparisons, ${stats.ab.disagreements} disagreements (${(stats.ab.disagreementRate * 100).toFixed(1)}%)`);
+        }
+        output.writeln('');
+        output.writeln(output.bold('  Trajectory log:'));
+        if (!trajectory.exists) {
+            output.writeln(`    ${output.warning('file does not exist — recorder OFF or no decisions made')}`);
+        }
+        else {
+            output.writeln(`    rows:           ${trajectory.rows}  (${trajectory.decisions} decisions / ${trajectory.outcomes} outcomes / ${trajectory.pairedWithCost} cost-bearing)`);
+            if (trajectory.oldestTs && trajectory.newestTs) {
+                output.writeln(`    span:           ${trajectory.oldestTs.slice(0, 19)} → ${trajectory.newestTs.slice(0, 19)}`);
+            }
+        }
+        output.writeln('');
+        if (recent24h) {
+            const rateStr = recent24h.fallbackRatePct > 30 ? output.warning(recent24h.fallbackRatePct + '% ⚠')
+                : recent24h.fallbackRatePct > 10 ? recent24h.fallbackRatePct + '%'
+                    : output.success(recent24h.fallbackRatePct + '%');
+            output.writeln(output.bold(`  Last 24h:`));
+            output.writeln(`    decisions:      ${recent24h.decisions}`);
+            output.writeln(`    fallback rate:  ${rateStr}  (neural backend → bandit when prediction unusable)`);
+            output.writeln('');
+        }
+        if (cost7d) {
+            const savingsStr = cost7d.savingsUsd >= 0
+                ? output.success(`$${cost7d.savingsUsd.toFixed(4)}`)
+                : output.warning(`-$${Math.abs(cost7d.savingsUsd).toFixed(4)}`);
+            output.writeln(output.bold('  Last 7d cost-savings (vs heuristic baseline):'));
+            output.writeln(`    paired calls:    ${cost7d.pairs}`);
+            output.writeln(`    actual:          $${cost7d.actualUsd.toFixed(4)}`);
+            output.writeln(`    counterfactual:  $${cost7d.counterfactualUsd.toFixed(4)}`);
+            output.writeln(`    savings:         ${savingsStr}  (${cost7d.savingsPct}%)`);
+            output.writeln('');
+        }
+        if (warmestCell) {
+            output.writeln(output.bold('  Bandit warmest cell:'));
+            output.writeln(`    ${warmestCell.bucket} × ${warmestCell.key}  →  ${warmestCell.samples} samples, meanQ=${warmestCell.meanQuality.toFixed(3)}`);
+            output.writeln('');
+        }
+        output.writeln(output.dim('  For drill-down: `router decisions`, `router cost-savings`, `router bandit-state`'));
+        output.writeln('');
+        return { success: true, data: payload };
+    },
+};
+// ADR-149 iter 48 — bandit-state inspection. The persisted bandit posteriors
+// (`.swarm/model-router-state.json`) accumulate across restarts but are
+// otherwise invisible. Surfacing the (bucket × model) prior matrix lets
+// operators see where bandit learning is thin (cold cells) and where it's
+// confident (large α+β).
+const routerBanditStateCommand = {
+    name: 'bandit-state',
+    description: 'Inspect persisted bandit Beta priors per bucket × model (ADR-149 iter 48)',
+    options: [
+        { name: 'path', type: 'string', description: 'Path to model-router-state.json (default: .swarm/model-router-state.json)' },
+        { name: 'format', short: 'f', type: 'string', description: 'Output format: table, json', default: 'table' },
+        { name: 'cold-threshold', type: 'number', description: 'Highlight cells with sample count below this (default 4 — matches iter 14 density guard)', default: '4' },
+    ],
+    examples: [
+        { command: 'claude-flow neural router bandit-state', description: 'Show all Beta priors per bucket × tier + per bucket × modelId' },
+        { command: 'claude-flow neural router bandit-state --format json | jq .priorsById', description: 'Just the per-modelId matrix' },
+    ],
+    action: async (ctx) => {
+        const fs = await import('node:fs');
+        const path = await import('node:path');
+        const statePath = ctx.flags.path
+            ?? path.resolve(process.cwd(), '.swarm', 'model-router-state.json');
+        const fmt = ctx.flags.format || 'table';
+        const coldThreshold = parseInt(ctx.flags['cold-threshold'] || '4', 10) || 4;
+        if (!fs.existsSync(statePath)) {
+            const msg = `Bandit state file not found at ${statePath}`;
+            if (fmt === 'json')
+                output.writeln(JSON.stringify({ error: msg, hint: 'State is created on first routing decision. Run any agent_spawn flow with CLAUDE_FLOW_ROUTER_NEURAL=1.' }, null, 2));
+            else {
+                output.printError(msg);
+                output.writeln(output.dim('  State is created on first routing decision. Run any agent_spawn flow.'));
+            }
+            return { success: false, exitCode: 1 };
+        }
+        let state;
+        try {
+            state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+        }
+        catch (err) {
+            const msg = `Failed to parse bandit state: ${err instanceof Error ? err.message : String(err)}`;
+            if (fmt === 'json')
+                output.writeln(JSON.stringify({ error: msg }, null, 2));
+            else
+                output.printError(msg);
+            return { success: false, exitCode: 1 };
+        }
+        // Helper: enumerate all cells from a BucketedPriors with derived stats.
+        const cells = (priors) => {
+            const out = [];
+            if (!priors)
+                return out;
+            for (const bucket of ['low', 'med', 'high']) {
+                const b = priors[bucket];
+                if (!b)
+                    continue;
+                for (const [k, p] of Object.entries(b)) {
+                    const samples = p.alpha + p.beta - 2; // -2 because Beta(1,1) is the uniform prior
+                    const meanQuality = p.alpha / (p.alpha + p.beta);
+                    out.push({ bucket, key: k, alpha: p.alpha, beta: p.beta, samples, meanQuality, cold: samples < coldThreshold });
+                }
+            }
+            return out;
+        };
+        const tierCells = cells(state.priors);
+        const idCells = cells(state.priorsById);
+        const coldTierCells = tierCells.filter(c => c.cold);
+        const coldIdCells = idCells.filter(c => c.cold);
+        const payload = {
+            input: statePath,
+            stateVersion: state.version ?? 2,
+            totalDecisions: state.totalDecisions ?? 0,
+            lastUpdated: state.lastUpdated ?? null,
+            coldThreshold,
+            priors: tierCells,
+            priorsById: idCells,
+            summary: {
+                tierCells: tierCells.length,
+                coldTierCells: coldTierCells.length,
+                idCells: idCells.length,
+                coldIdCells: coldIdCells.length,
+                warmestIdCell: idCells.length > 0 ? [...idCells].sort((a, b) => b.samples - a.samples)[0] : null,
+            },
+        };
+        if (fmt === 'json') {
+            output.writeln(JSON.stringify(payload, null, 2));
+            return { success: true, data: payload };
+        }
+        output.writeln();
+        output.writeln(output.bold('Bandit state inspection (ADR-149 iter 48)'));
+        output.writeln(output.dim('─'.repeat(72)));
+        output.writeln(`  Path:               ${statePath}`);
+        output.writeln(`  Schema version:     v${state.version ?? 2}  (v2=tier priors only; v3=adds priorsById)`);
+        output.writeln(`  Total decisions:    ${state.totalDecisions ?? 0}`);
+        if (state.lastUpdated)
+            output.writeln(`  Last update:        ${state.lastUpdated}`);
+        output.writeln(`  Cold threshold:     samples < ${coldThreshold}  (iter 14 density-guard cutoff)`);
+        output.writeln('');
+        const renderTable = (label, rows) => {
+            if (rows.length === 0) {
+                output.writeln(`  ${label}:  (empty — no outcomes recorded yet for this layer)`);
+                output.writeln('');
+                return;
+            }
+            output.writeln(output.bold(`  ${label}:`));
+            output.writeln('    bucket  key                                       α        β     samples  meanQ');
+            for (const c of rows.sort((a, b) => (a.bucket.localeCompare(b.bucket)) || (b.samples - a.samples))) {
+                const coldMark = c.cold ? output.warning(' ❄ cold') : '';
+                output.writeln(`    ${c.bucket.padEnd(6)}  ${c.key.padEnd(38)}  ${c.alpha.toFixed(1).padStart(5)}  ${c.beta.toFixed(1).padStart(5)}  ${String(c.samples).padStart(7)}  ${c.meanQuality.toFixed(3)}${coldMark}`);
+            }
+            output.writeln('');
+        };
+        renderTable('Tier priors (bucket × tier label)', tierCells);
+        renderTable('Per-modelId priors (bucket × concrete modelId, iter 14)', idCells);
+        output.writeln(output.bold('  Summary:'));
+        output.writeln(`    tier cells:        ${tierCells.length}  (cold: ${coldTierCells.length})`);
+        output.writeln(`    per-modelId cells: ${idCells.length}  (cold: ${coldIdCells.length})`);
+        if (payload.summary.warmestIdCell) {
+            const w = payload.summary.warmestIdCell;
+            output.writeln(`    warmest cell:      ${w.bucket} × ${w.key}  (${w.samples} samples, meanQ=${w.meanQuality.toFixed(3)})`);
+        }
+        output.writeln('');
+        if (coldIdCells.length > 0 && idCells.length > 0) {
+            output.writeln(output.dim(`  Cold cells suppress iter 14 per-modelId Thompson perturbation. Until α+β ≥ ${coldThreshold + 2},`));
+            output.writeln(output.dim('  the neural prediction dominates that (bucket, modelId) pair without bandit correction.'));
+            output.writeln('');
+        }
+        return { success: true, data: payload };
+    },
+};
+// ADR-149 iter 38 — consumer for iter 37's sampled A/B mode. Aggregates
+// ab_pair from decision rows into a (bandit_pick × hybrid_pick) confusion
+// matrix plus disagreement rate. Operators see WHERE the neural prior
+// moves the bandit's decisions.
+const routerAbStatsCommand = {
+    name: 'ab-stats',
+    description: 'Aggregate A/B (bandit-vs-hybrid) disagreement from trajectory ab_pair rows (ADR-149 iter 38)',
+    options: [
+        { name: 'in', short: 'i', type: 'string', description: 'Trajectory JSONL path (default: $CLAUDE_FLOW_ROUTER_TRAJECTORY_PATH or .swarm/...)' },
+        { name: 'since', short: 's', type: 'string', description: 'Time window suffix: 1h, 24h, 7d, 30d' },
+        { name: 'format', short: 'f', type: 'string', description: 'Output format: table, json', default: 'table' },
+    ],
+    examples: [
+        { command: 'claude-flow neural router ab-stats', description: 'All A/B comparisons recorded so far' },
+        { command: 'claude-flow neural router ab-stats --since 7d --format json', description: 'Last 7 days, pipe-friendly' },
+        { command: 'CLAUDE_FLOW_ROUTER_AB_SAMPLE_RATE=0.05 ... && claude-flow neural router ab-stats', description: 'After running with iter 37 sampling on' },
+    ],
+    action: async (ctx) => {
+        const fs = await import('node:fs');
+        const path = await import('node:path');
+        const inPath = ctx.flags.in
+            ?? process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY_PATH
+            ?? path.resolve(process.cwd(), '.swarm', 'model-router-trajectories.jsonl');
+        const since = ctx.flags.since;
+        const fmt = ctx.flags.format || 'table';
+        if (!fs.existsSync(inPath)) {
+            const msg = `Trajectory file not found at ${inPath}`;
+            if (fmt === 'json')
+                output.writeln(JSON.stringify({ error: msg }, null, 2));
+            else {
+                output.printError(msg);
+                output.writeln(output.dim('  Set CLAUDE_FLOW_ROUTER_TRAJECTORY=1 + CLAUDE_FLOW_ROUTER_AB_SAMPLE_RATE=0.05 to start collecting ab_pair data.'));
+            }
+            return { success: false, exitCode: 1 };
+        }
+        // Parse + filter to decision rows that carry ab_pair.
+        let cutoffMs = null;
+        if (since) {
+            const m = since.match(/^(\d+)([hdmw])$/);
+            if (m) {
+                const n = parseInt(m[1], 10);
+                const unitMs = { m: 60_000, h: 3_600_000, d: 86_400_000, w: 7 * 86_400_000 }[m[2]] ?? 0;
+                cutoffMs = Date.now() - n * unitMs;
+            }
+        }
+        const rows = fs.readFileSync(inPath, 'utf8').split('\n').filter(l => l.trim().length > 0);
+        let totalDecisions = 0;
+        let malformed = 0;
+        const abRows = [];
+        for (const l of rows) {
+            try {
+                const r = JSON.parse(l);
+                if (r.type !== 'decision')
+                    continue;
+                totalDecisions++;
+                if (!r.ab_pair)
+                    continue;
+                if (cutoffMs !== null && Date.parse(r.ts) < cutoffMs)
+                    continue;
+                abRows.push(r);
+            }
+            catch {
+                malformed++;
+            }
+        }
+        const cells = new Map();
+        let disagree = 0;
+        const banditTotals = {};
+        const hybridTotals = {};
+        for (const r of abRows) {
+            const ap = r.ab_pair;
+            const key = `${ap.bandit_pick}→${ap.hybrid_pick}`;
+            const cell = cells.get(key) ?? { bandit: ap.bandit_pick, hybrid: ap.hybrid_pick, count: 0 };
+            cell.count++;
+            cells.set(key, cell);
+            banditTotals[ap.bandit_pick] = (banditTotals[ap.bandit_pick] ?? 0) + 1;
+            hybridTotals[ap.hybrid_pick] = (hybridTotals[ap.hybrid_pick] ?? 0) + 1;
+            if (ap.disagree)
+                disagree++;
+        }
+        const disagreeRatePct = abRows.length > 0 ? Math.round((disagree / abRows.length) * 10000) / 100 : 0;
+        // Models actually seen, in stable iteration order.
+        const allModels = Array.from(new Set([...Object.keys(banditTotals), ...Object.keys(hybridTotals)])).sort();
+        const matrix = {};
+        for (const b of allModels) {
+            matrix[b] = {};
+            for (const h of allModels) {
+                matrix[b][h] = cells.get(`${b}→${h}`)?.count ?? 0;
+            }
+        }
+        // Disagreement breakdown — off-diagonal cells sorted by count desc.
+        const offDiag = [];
+        for (const c of cells.values()) {
+            if (c.bandit !== c.hybrid) {
+                offDiag.push({ ...c, pctOfDisagrees: disagree > 0 ? Math.round((c.count / disagree) * 10000) / 100 : 0 });
+            }
+        }
+        offDiag.sort((a, b) => b.count - a.count);
+        const payload = {
+            input: inPath,
+            filters: { since },
+            totalDecisions, malformed,
+            abComparisons: abRows.length,
+            disagreements: disagree,
+            disagreementRatePct: disagreeRatePct,
+            models: allModels,
+            banditTotals, hybridTotals,
+            confusionMatrix: matrix,
+            disagreementBreakdown: offDiag,
+            coveragePct: totalDecisions > 0 ? Math.round((abRows.length / totalDecisions) * 10000) / 100 : 0,
+        };
+        if (fmt === 'json') {
+            output.writeln(JSON.stringify(payload, null, 2));
+            return { success: true, data: payload };
+        }
+        output.writeln();
+        output.writeln(output.bold('A/B (bandit vs hybrid) stats — ADR-149 iter 37/38'));
+        output.writeln(output.dim('─'.repeat(72)));
+        output.writeln(`  Input:              ${inPath}`);
+        if (since)
+            output.writeln(`  Time window:        since ${since}`);
+        output.writeln(`  Total decisions:    ${totalDecisions}  (${malformed} malformed)`);
+        output.writeln(`  A/B comparisons:    ${abRows.length}  (${payload.coveragePct}% of decisions had ab_pair)`);
+        output.writeln('');
+        if (abRows.length === 0) {
+            output.writeln(output.dim('  No ab_pair rows found. Enable iter 37 sampling:'));
+            output.writeln(output.dim('    export CLAUDE_FLOW_ROUTER_TRAJECTORY=1'));
+            output.writeln(output.dim('    export CLAUDE_FLOW_ROUTER_AB_SAMPLE_RATE=0.05  # 5% sampling'));
+            output.writeln('');
+            return { success: true, data: payload };
+        }
+        output.writeln(`  Disagreements:      ${disagree}  (${disagreeRatePct}% of A/B comparisons)`);
+        output.writeln('');
+        output.writeln(output.bold(`  Confusion matrix (rows = bandit pick, cols = hybrid pick, ${allModels.length} models):`));
+        const headerPad = Math.max(8, ...allModels.map(m => m.length));
+        output.writeln('    ' + 'bandit \\ hybrid'.padEnd(headerPad) + '  ' + allModels.map(m => m.padStart(8)).join(''));
+        for (const b of allModels) {
+            const cells = allModels.map(h => String(matrix[b][h] ?? 0).padStart(8));
+            output.writeln(`    ${b.padEnd(headerPad)}  ${cells.join('')}`);
+        }
+        output.writeln(output.dim('    (Diagonal cells = agreement, off-diagonal = disagreement.)'));
+        output.writeln('');
+        if (offDiag.length > 0) {
+            output.writeln(output.bold('  Disagreement breakdown (bandit → hybrid):'));
+            output.writeln('    transition'.padEnd(40) + '  count  % of disagrees');
+            for (const c of offDiag) {
+                output.writeln(`    ${(c.bandit + ' → ' + c.hybrid).padEnd(38)}  ${String(c.count).padStart(5)}  ${c.pctOfDisagrees.toString().padStart(6)}%`);
+            }
+            output.writeln('');
+        }
+        return { success: true, data: payload };
+    },
+};
+// ADR-149 iter 43 — show the canonical price table that drives cost
+// computations, blended-price routing, and counterfactual baselines.
+// Operators ask "what does the router think gpt-4.1 costs?" frequently;
+// previously the answer required reading src/ruvector/model-prices.ts.
+const routerPricesCommand = {
+    name: 'prices',
+    description: 'Show the per-model price table that drives blended cost + counterfactual computations (ADR-149 iter 43)',
+    options: [
+        { name: 'format', short: 'f', type: 'string', description: 'Output format: table, json', default: 'table' },
+        { name: 'sort', type: 'string', description: 'Sort by: blended (default), input, output, name', default: 'blended' },
+    ],
+    examples: [
+        { command: 'claude-flow neural router prices', description: 'Show all models sorted by blended price' },
+        { command: 'claude-flow neural router prices --sort name', description: 'Sort alphabetically' },
+        { command: 'claude-flow neural router prices --format json | jq \'.[] | select(.id | contains("opus"))\'', description: 'Filter via jq' },
+    ],
+    action: async (ctx) => {
+        const { MODEL_PRICES, blendedPrice } = await import('../ruvector/model-prices.js');
+        const fmt = ctx.flags.format || 'table';
+        const sortKey = (ctx.flags.sort || 'blended').toLowerCase();
+        const rows = Object.entries(MODEL_PRICES).map(([id, p]) => ({
+            id,
+            inPerMtok: p.in,
+            outPerMtok: p.out,
+            blendedPerMtok: blendedPrice(id),
+        }));
+        switch (sortKey) {
+            case 'input':
+                rows.sort((a, b) => a.inPerMtok - b.inPerMtok);
+                break;
+            case 'output':
+                rows.sort((a, b) => a.outPerMtok - b.outPerMtok);
+                break;
+            case 'name':
+                rows.sort((a, b) => a.id.localeCompare(b.id));
+                break;
+            case 'blended':
+            default: rows.sort((a, b) => a.blendedPerMtok - b.blendedPerMtok);
+        }
+        if (fmt === 'json') {
+            output.writeln(JSON.stringify(rows, null, 2));
+            return { success: true, data: rows };
+        }
+        output.writeln();
+        output.writeln(output.bold('Model price table (ADR-149 iter 31/43 — single source of truth)'));
+        output.writeln(output.dim('─'.repeat(72)));
+        output.writeln(`  ${rows.length} entries, sorted by ${sortKey}`);
+        output.writeln('');
+        output.writeln('    model id                                      $/Mtok in   $/Mtok out   blended ($/Mtok)');
+        for (const r of rows) {
+            output.writeln(`    ${r.id.padEnd(44)}  ${('$' + r.inPerMtok.toFixed(2)).padStart(9)}  ${('$' + r.outPerMtok.toFixed(2)).padStart(11)}  ${('$' + r.blendedPerMtok.toFixed(2)).padStart(15)}`);
+        }
+        output.writeln('');
+        output.writeln(output.dim('  Blended = $/Mtok_in + 3 × $/Mtok_out (1 input : 3 output ratio for code tasks).'));
+        output.writeln(output.dim('  Unknown model ids fall back to $1/Mtok blended (1×in + 1×out).'));
+        output.writeln('');
+        return { success: true, data: rows };
+    },
+};
+// ADR-149 iter 41 — forward-looking budget projection. Iter 32-34 measure
+// past cost (actual vs counterfactual, per-window drift). This subcommand
+// extrapolates: given the measured rate and average cost per decision over
+// a recent window, what will routing cost over the next 7d / 30d / 90d /
+// 365d? Also projects the heuristic baseline so operators see the savings
+// trajectory across a quarter or year.
+const routerCostProjectionCommand = {
+    name: 'cost-projection',
+    description: 'Project monthly/quarterly cost from measured rate (ADR-149 iter 41)',
+    options: [
+        { name: 'in', short: 'i', type: 'string', description: 'Trajectory JSONL path (default: $CLAUDE_FLOW_ROUTER_TRAJECTORY_PATH or .swarm/...)' },
+        { name: 'window', short: 'w', type: 'string', description: 'Measurement window to extrapolate FROM (default 7d). Format: 1h, 24h, 7d, 30d' },
+        { name: 'horizons', type: 'string', description: 'Projection horizons (CSV of duration suffixes). Default: 7d,30d,90d,365d' },
+        { name: 'format', short: 'f', type: 'string', description: 'Output format: table, json', default: 'table' },
+    ],
+    examples: [
+        { command: 'claude-flow neural router cost-projection', description: 'Project from last 7d of data → 7d/30d/90d/365d horizons' },
+        { command: 'claude-flow neural router cost-projection --window 24h --horizons 7d,30d', description: 'Project from last day only' },
+        { command: 'claude-flow neural router cost-projection --format json | jq .horizons[1].projectedSavingsUsd', description: '30-day savings projection for dashboards' },
+    ],
+    action: async (ctx) => {
+        const fs = await import('node:fs');
+        const path = await import('node:path');
+        const { MODEL_PRICES } = await import('../ruvector/model-prices.js');
+        const inPath = ctx.flags.in
+            ?? process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY_PATH
+            ?? path.resolve(process.cwd(), '.swarm', 'model-router-trajectories.jsonl');
+        const windowSpec = ctx.flags.window ?? '7d';
+        const horizonSpecs = (ctx.flags.horizons ?? '7d,30d,90d,365d').split(',').map(s => s.trim());
+        const fmt = ctx.flags.format || 'table';
+        const parseDuration = (s) => {
+            const m = s.match(/^(\d+)([hdmw])$/);
+            if (!m)
+                return null;
+            const n = parseInt(m[1], 10);
+            const unitMs = { m: 60_000, h: 3_600_000, d: 86_400_000, w: 7 * 86_400_000 }[m[2]] ?? 0;
+            return n * unitMs;
+        };
+        const windowMs = parseDuration(windowSpec);
+        if (!windowMs || windowMs <= 0) {
+            output.printError(`--window must be Nh/Nd/Nm/Nw (got ${windowSpec})`);
+            return { success: false, exitCode: 1 };
+        }
+        if (!fs.existsSync(inPath)) {
+            const msg = `Trajectory file not found at ${inPath}`;
+            if (fmt === 'json')
+                output.writeln(JSON.stringify({ error: msg }, null, 2));
+            else
+                output.printError(msg);
+            return { success: false, exitCode: 1 };
+        }
+        // iter 66 — outcomes now ARRAY (was Map). Same fix as iter 62/63/65:
+        // a Map keyed by task_hash collapses multiple runs of the same task to
+        // the LATEST outcome only, biasing the rate downward (pairCount =
+        // unique-tasks, not unique-calls). Production projections were
+        // systematically too small for any workload with recurring tasks.
+        const decisions = new Map();
+        const outcomes = [];
+        let malformed = 0;
+        const cutoffMs = Date.now() - windowMs;
+        for (const l of fs.readFileSync(inPath, 'utf8').split('\n')) {
+            if (!l.trim())
+                continue;
+            try {
+                const r = JSON.parse(l);
+                if (Date.parse(r.ts) < cutoffMs)
+                    continue;
+                if (r.type === 'decision')
+                    decisions.set(r.task_hash, r);
+                else if (r.type === 'outcome')
+                    outcomes.push(r);
+            }
+            catch {
+                malformed++;
+            }
+        }
+        // Pair + compute window totals. Iterate OUTCOMES (not deduped decisions);
+        // each outcome row contributes its own cost + tokens to the rate.
+        let pairCount = 0;
+        let actualUsd = 0;
+        let counterfactualUsd = 0; // heuristic = tier-by-complexity baseline (iter 32 default)
+        let totalInputTokens = 0;
+        let totalOutputTokens = 0;
+        for (const out of outcomes) {
+            if (!out?.cost_usd || !out.tokens)
+                continue;
+            const dec = decisions.get(out.task_hash);
+            if (!dec)
+                continue;
+            pairCount++;
+            actualUsd += out.cost_usd;
+            totalInputTokens += out.tokens.input;
+            totalOutputTokens += out.tokens.output;
+            // Heuristic counterfactual: tier-by-complexity (matches iter 32 default).
+            const tierModel = dec.complexity < 0.34 ? 'haiku'
+                : dec.complexity < 0.67 ? 'sonnet' : 'opus';
+            const cfModel = dec.ab_pair?.bandit_pick ?? tierModel;
+            const p = MODEL_PRICES[cfModel] ?? { in: 1, out: 1 };
+            counterfactualUsd += (out.tokens.input * p.in + out.tokens.output * p.out) / 1_000_000;
+        }
+        if (pairCount === 0) {
+            const msg = `No paired cost-bearing rows in the last ${windowSpec}. Cannot project.`;
+            const payload = { error: msg, windowSpec, hint: 'Enable CLAUDE_FLOW_ROUTER_TRAJECTORY=1 and run some routed agent calls first.' };
+            if (fmt === 'json')
+                output.writeln(JSON.stringify(payload, null, 2));
+            else {
+                output.printError(msg);
+                output.writeln(output.dim(`  ${payload.hint}`));
+            }
+            return { success: true, data: payload };
+        }
+        // Per-second rate from this window's pair count.
+        const callsPerSecond = pairCount / (windowMs / 1000);
+        const avgActualPerCall = actualUsd / pairCount;
+        const avgCounterfactualPerCall = counterfactualUsd / pairCount;
+        // Extrapolate to horizons. Costs scale linearly with calls; calls scale
+        // linearly with elapsed time at the measured rate.
+        const horizons = horizonSpecs.map(spec => {
+            const ms = parseDuration(spec);
+            if (!ms)
+                return { spec, error: 'invalid duration' };
+            const projectedCalls = Math.round(callsPerSecond * (ms / 1000));
+            const projectedActualUsd = avgActualPerCall * projectedCalls;
+            const projectedCounterfactualUsd = avgCounterfactualPerCall * projectedCalls;
+            const projectedSavingsUsd = projectedCounterfactualUsd - projectedActualUsd;
+            const projectedSavingsPct = projectedCounterfactualUsd > 0
+                ? (projectedSavingsUsd / projectedCounterfactualUsd) * 100 : 0;
+            return {
+                spec, durationMs: ms,
+                projectedCalls,
+                projectedActualUsd: Math.round(projectedActualUsd * 1_000_000) / 1_000_000,
+                projectedCounterfactualUsd: Math.round(projectedCounterfactualUsd * 1_000_000) / 1_000_000,
+                projectedSavingsUsd: Math.round(projectedSavingsUsd * 1_000_000) / 1_000_000,
+                projectedSavingsPct: Math.round(projectedSavingsPct * 100) / 100,
+            };
+        });
+        const payload = {
+            input: inPath,
+            window: windowSpec,
+            malformed,
+            measurement: {
+                pairs: pairCount,
+                actualUsd: Math.round(actualUsd * 1_000_000) / 1_000_000,
+                counterfactualUsd: Math.round(counterfactualUsd * 1_000_000) / 1_000_000,
+                savingsUsd: Math.round((counterfactualUsd - actualUsd) * 1_000_000) / 1_000_000,
+                callsPerSecond: Math.round(callsPerSecond * 1_000_000) / 1_000_000,
+                callsPerDay: Math.round(callsPerSecond * 86400 * 100) / 100,
+                avgActualPerCall: Math.round(avgActualPerCall * 1_000_000) / 1_000_000,
+                avgCounterfactualPerCall: Math.round(avgCounterfactualPerCall * 1_000_000) / 1_000_000,
+                avgInputTokensPerCall: Math.round(totalInputTokens / pairCount),
+                avgOutputTokensPerCall: Math.round(totalOutputTokens / pairCount),
+            },
+            horizons,
+        };
+        if (fmt === 'json') {
+            output.writeln(JSON.stringify(payload, null, 2));
+            return { success: true, data: payload };
+        }
+        output.writeln();
+        output.writeln(output.bold('Cost projection (ADR-149 iter 41)'));
+        output.writeln(output.dim('─'.repeat(72)));
+        output.writeln(`  Input:             ${inPath}`);
+        output.writeln(`  Measurement window: last ${windowSpec}  (${pairCount} paired calls)`);
+        output.writeln('');
+        output.writeln(output.bold('  Measured rate:'));
+        output.writeln(`    Calls/day:                  ${payload.measurement.callsPerDay}`);
+        output.writeln(`    Avg actual cost/call:       $${payload.measurement.avgActualPerCall.toFixed(6)}`);
+        output.writeln(`    Avg counterfactual/call:    $${payload.measurement.avgCounterfactualPerCall.toFixed(6)}  (heuristic: cheap→haiku, mid→sonnet, strong→opus)`);
+        output.writeln(`    Avg tokens/call:            ${payload.measurement.avgInputTokensPerCall} in / ${payload.measurement.avgOutputTokensPerCall} out`);
+        output.writeln('');
+        output.writeln(output.bold('  Projections (linear extrapolation from measured rate):'));
+        output.writeln('    horizon  projected calls   actual $        counterfactual $  savings $      %');
+        for (const h of horizons) {
+            if ('error' in h) {
+                output.writeln(`    ${h.spec.padEnd(7)}  invalid duration`);
+                continue;
+            }
+            const savingsStr = h.projectedSavingsUsd >= 0
+                ? output.success(`$${h.projectedSavingsUsd.toFixed(2)}`)
+                : output.warning(`-$${Math.abs(h.projectedSavingsUsd).toFixed(2)}`);
+            output.writeln(`    ${h.spec.padEnd(7)}  ${String(h.projectedCalls).padStart(15)}   $${h.projectedActualUsd.toFixed(2).padStart(12)}   $${h.projectedCounterfactualUsd.toFixed(2).padStart(14)}   ${savingsStr.padEnd(14)} ${h.projectedSavingsPct.toFixed(2).padStart(6)}%`);
+        }
+        output.writeln('');
+        output.writeln(output.dim('  Assumes the next horizon\'s workload mix and rate matches the measurement window.'));
+        output.writeln(output.dim('  Use iter 34 (--window) to check if recent windows are drifting before trusting these.'));
+        output.writeln('');
+        return { success: true, data: payload };
+    },
+};
+const routerCommand = {
+    name: 'router',
+    description: 'Cost-optimal neural router lifecycle (ADR-148/149): status, models, prices, config, train, train-from-trajectories, decide, compare-modes, decisions, cost-savings, cost-projection, trajectory-health, ab-stats, bandit-state, stats-summary, reload',
+    subcommands: [routerStatusCommand, routerModelsCommand, routerPricesCommand, routerConfigCommand, routerTrainCommand, routerTrainFromTrajectoriesCommand, routerDecideCommand, routerCompareModesCommand, routerDecisionsCommand, routerCostSavingsCommand, routerCostProjectionCommand, routerTrajectoryHealthCommand, routerAbStatsCommand, routerBanditStateCommand, routerStatsSummaryCommand, routerReloadCommand],
+    examples: [
+        { command: 'claude-flow neural router status', description: 'Show router state, gate, counters' },
+        { command: 'claude-flow neural router models', description: 'List candidate registry with measured stats (ADR-149)' },
+        { command: 'claude-flow neural router prices', description: 'Show the canonical $/Mtok price table (iter 43)' },
+        { command: 'claude-flow neural router config', description: 'Inventory all CLAUDE_FLOW_ROUTER_* env vars (iter 54)' },
+        { command: 'claude-flow neural router train -o ./router.krr.json', description: 'Train a KRR artifact' },
+        { command: 'claude-flow neural router train-from-trajectories -w production-rows.json', description: 'Pair production JSONL into a training corpus (iter 18)' },
+        { command: 'claude-flow neural router decide "fix typo in cache.ts"', description: 'Inspect decision for a hypothetical task (iter 30)' },
+        { command: 'claude-flow neural router compare-modes "task" --ceiling 5', description: 'Compare cost-optimal vs cost-ceiling side-by-side (iter 55)' },
+        { command: 'claude-flow neural router decisions --since 24h', description: 'Query recorded decisions (iter 28)' },
+        { command: 'claude-flow neural router cost-savings --since 7d', description: 'Actual vs heuristic-counterfactual spend (iter 32)' },
+        { command: 'claude-flow neural router trajectory-health', description: 'JSONL log health: size, rotations, parse + pair-join rate (iter 36)' },
+        { command: 'claude-flow neural router ab-stats', description: 'A/B disagreement matrix from sampled ab_pair (iter 37/38)' },
+        { command: 'claude-flow neural router bandit-state', description: 'Persisted Beta priors per (bucket × model) (iter 48)' },
+        { command: 'claude-flow neural router stats-summary', description: 'One-screen SRE dashboard (iter 49)' },
+        { command: 'claude-flow neural router cost-projection', description: 'Project monthly/quarterly spend from measured rate (iter 41)' },
+        { command: 'claude-flow neural router reload', description: 'Clear in-process backend cache' },
+    ],
+    action: async () => {
+        output.writeln('Use a subcommand: status | models | prices | config | train | train-from-trajectories | decide | compare-modes | decisions | cost-savings | cost-projection | trajectory-health | ab-stats | bandit-state | stats-summary | reload');
+        return { success: true };
+    },
+};
 // Main neural command
 export const neuralCommand = {
     name: 'neural',
     description: 'Neural pattern training, MoE, Flash Attention, pattern learning',
-    subcommands: [trainCommand, statusCommand, patternsCommand, predictCommand, optimizeCommand, benchmarkCommand, listCommand, exportCommand, importCommand],
+    subcommands: [trainCommand, statusCommand, patternsCommand, predictCommand, optimizeCommand, benchmarkCommand, listCommand, exportCommand, importCommand, routerCommand],
     examples: [
         { command: 'claude-flow neural status', description: 'Check neural system status' },
         { command: 'claude-flow neural train -p coordination', description: 'Train coordination patterns' },