agentic-qe 3.8.10 → 3.8.12

package/dist/cli/handlers/heartbeat-handler.js

@@ -0,0 +1,382 @@
+/**
+ * Agentic QE v3 - Heartbeat Command Handler
+ * Imp-10: Token-Free Heartbeat Scheduler CLI Integration
+ *
+ * Handles the 'aqe heartbeat' command with subcommands:
+ *   status, run-now, history, log, pause, resume
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+import { formatDuration } from './interfaces.js';
+import { HeartbeatSchedulerWorker } from '../../workers/workers/heartbeat-scheduler.js';
+import { toErrorMessage } from '../../shared/error-utils.js';
+import { findProjectRoot } from '../../kernel/unified-memory.js';
+// ============================================================================
+// Heartbeat Handler
+// ============================================================================
+export class HeartbeatHandler {
+    name = 'heartbeat';
+    description = 'Manage the token-free heartbeat scheduler';
+    cleanupAndExit;
+    worker;
+    constructor(cleanupAndExit) {
+        this.cleanupAndExit = cleanupAndExit;
+        this.worker = new HeartbeatSchedulerWorker();
+    }
+    register(program, _context) {
+        const heartbeat = program
+            .command('heartbeat')
+            .description(this.description);
+        heartbeat
+            .command('status')
+            .description('Show heartbeat worker status, health, and schedule')
+            .action(async () => {
+            await this.executeStatus();
+        });
+        heartbeat
+            .command('run-now')
+            .description('Trigger an immediate heartbeat cycle')
+            .option('-t, --timeout <ms>', 'Timeout in milliseconds (default: worker built-in 60s)')
+            .action(async (options) => {
+            const timeout = options.timeout ? parseInt(options.timeout, 10) : undefined;
+            await this.executeRunNow(timeout);
+        });
+        heartbeat
+            .command('history')
+            .description('Show recent heartbeat results')
+            .option('-n, --count <count>', 'Number of entries to show', '10')
+            .action(async (options) => {
+            await this.executeHistory(parseInt(options.count, 10) || 10);
+        });
+        heartbeat
+            .command('log')
+            .description("Show today's daily log entries")
+            .option('-d, --date <date>', 'Show log for specific date (YYYY-MM-DD)')
+            .action(async (options) => {
+            await this.executeLog(options.date);
+        });
+        heartbeat
+            .command('pause')
+            .description('Pause the heartbeat worker')
+            .action(async () => {
+            await this.executePause();
+        });
+        heartbeat
+            .command('resume')
+            .description('Resume the heartbeat worker')
+            .action(async () => {
+            await this.executeResume();
+        });
+    }
+    // --------------------------------------------------------------------------
+    // Subcommand Implementations
+    // --------------------------------------------------------------------------
+    async executeStatus() {
+        try {
+            await this.worker.initialize();
+            const health = this.worker.getHealth();
+            const lastResult = this.worker.lastResult;
+            console.log(chalk.blue('\n  Heartbeat Scheduler Status'));
+            console.log(chalk.gray('  ' + '\u2500'.repeat(35)));
+            console.log(`  Status:         ${statusColor(health.status)}`);
+            console.log(`  Health Score:   ${scoreColor(health.healthScore)}${chalk.gray('/100')}`);
+            if (this.worker.lastRunAt) {
+                const ago = formatRelativeTime(this.worker.lastRunAt);
+                console.log(`  Last Run:       ${chalk.cyan(this.worker.lastRunAt.toISOString().replace('T', ' ').slice(0, 19))} ${chalk.gray(`(${ago})`)}`);
+            }
+            else {
+                console.log(`  Last Run:       ${chalk.gray('never')}`);
+            }
+            if (this.worker.nextRunAt) {
+                const until = formatRelativeTime(this.worker.nextRunAt, true);
+                console.log(`  Next Run:       ${chalk.cyan(this.worker.nextRunAt.toISOString().replace('T', ' ').slice(0, 19))} ${chalk.gray(`(${until})`)}`);
+            }
+            console.log(`  Total Runs:     ${chalk.cyan(String(health.totalExecutions))}`);
+            const successRate = health.totalExecutions > 0
+                ? ((health.successfulExecutions / health.totalExecutions) * 100).toFixed(1)
+                : '100.0';
+            console.log(`  Success Rate:   ${chalk.cyan(successRate + '%')}`);
+            if (lastResult?.metrics?.domainMetrics) {
+                const dm = lastResult.metrics.domainMetrics;
+                console.log('');
+                console.log(chalk.blue('  Last Result:'));
+                console.log(`    Promoted:     ${chalk.cyan(String(dm.promoted ?? 0))} patterns`);
+                console.log(`    Deprecated:   ${chalk.cyan(String(dm.deprecated ?? 0))} patterns`);
+                console.log(`    Decayed:      ${chalk.cyan(String(dm.decayed ?? 0))} patterns`);
+                console.log(`    Pending Exp:  ${chalk.cyan(String(dm.pendingExperiences ?? 0))}`);
+                console.log(`    Avg Conf:     ${chalk.cyan(String(dm.avgConfidence ?? 0))}`);
+            }
+            console.log('');
+            await this.cleanupAndExit(0);
+        }
+        catch (error) {
+            console.error(chalk.red('\n  Failed to get heartbeat status:'), toErrorMessage(error));
+            await this.cleanupAndExit(1);
+        }
+    }
+    async executeRunNow(timeoutMs) {
+        try {
+            console.log(chalk.blue('\n  Triggering heartbeat cycle...\n'));
+            await this.worker.initialize();
+            const abortController = new AbortController();
+            // Only add external timeout if the user explicitly requests one shorter
+            // than the worker's built-in 60s timeout.
+            const timeoutHandle = timeoutMs && timeoutMs > 0
+                ? setTimeout(() => abortController.abort(), timeoutMs)
+                : null;
+            // Use a real logger that outputs to the console, and a lightweight
+            // event bus / memory — the heartbeat worker only needs DB access
+            // (which it gets via getUnifiedMemory() internally).
+            const result = await this.worker.execute({
+                eventBus: { publish: async () => { } },
+                memory: {
+                    get: async () => undefined,
+                    set: async () => { },
+                    search: async () => [],
+                },
+                logger: {
+                    debug: () => { },
+                    info: (...args) => console.log(chalk.gray('  [heartbeat]'), ...args),
+                    warn: (...args) => console.warn(chalk.yellow('  [heartbeat]'), ...args),
+                    error: (...args) => console.error(chalk.red('  [heartbeat]'), ...args),
+                },
+                domains: {
+                    getDomainAPI: () => undefined,
+                    getDomainHealth: () => ({ status: 'healthy', errors: [] }),
+                },
+                signal: abortController.signal,
+            });
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+            if (result.success) {
+                const dm = result.metrics.domainMetrics;
+                console.log(chalk.green('  Heartbeat cycle complete.'));
+                console.log(`  Duration:       ${chalk.cyan(formatDuration(result.durationMs))}`);
+                console.log(`  Health Score:   ${scoreColor(result.metrics.healthScore)}${chalk.gray('/100')}`);
+                console.log(`  Trend:          ${trendColor(result.metrics.trend)}`);
+                console.log(`  Promoted:       ${chalk.cyan(String(dm.promoted ?? 0))}`);
+                console.log(`  Deprecated:     ${chalk.cyan(String(dm.deprecated ?? 0))}`);
+                console.log(`  Decayed:        ${chalk.cyan(String(dm.decayed ?? 0))}`);
+                console.log(`  Findings:       ${chalk.cyan(String(result.findings.length))}`);
+            }
+            else {
+                console.error(chalk.red('  Heartbeat cycle failed:'), result.error);
+            }
+            // Store history entry
+            storeHistoryEntry(result);
+            console.log('');
+            await this.cleanupAndExit(result.success ? 0 : 1);
+        }
+        catch (error) {
+            console.error(chalk.red('\n  Failed to run heartbeat:'), toErrorMessage(error));
+            await this.cleanupAndExit(1);
+        }
+    }
+    async executeHistory(count) {
+        try {
+            const entries = loadHistoryEntries(count);
+            if (entries.length === 0) {
+                console.log(chalk.yellow('\n  No heartbeat history found. Run `aqe heartbeat run-now` first.\n'));
+                await this.cleanupAndExit(0);
+                return;
+            }
+            console.log(chalk.blue(`\n  Heartbeat History (last ${entries.length})`));
+            console.log(chalk.gray('  ' + '\u2500'.repeat(60)));
+            for (const entry of entries) {
+                const status = entry.success ? chalk.green('OK') : chalk.red('FAIL');
+                const ts = entry.timestamp.slice(0, 19).replace('T', ' ');
+                const dm = entry.domainMetrics || {};
+                console.log(`  ${chalk.gray(ts)}  ${status}  ` +
+                    `score:${chalk.cyan(String(entry.healthScore))}  ` +
+                    `+${dm.promoted ?? 0}/-${dm.deprecated ?? 0}  ` +
+                    `${chalk.gray(formatDuration(entry.durationMs))}`);
+            }
+            console.log('');
+            await this.cleanupAndExit(0);
+        }
+        catch (error) {
+            console.error(chalk.red('\n  Failed to load history:'), toErrorMessage(error));
+            await this.cleanupAndExit(1);
+        }
+    }
+    async executeLog(date) {
+        try {
+            const targetDate = date || new Date().toISOString().split('T')[0];
+            // Validate date format to prevent path traversal (CLI-MCP parity with heartbeat-handlers.ts)
+            if (!/^\d{4}-\d{2}-\d{2}$/.test(targetDate)) {
+                console.error(chalk.red(`\n  Invalid date format: "${targetDate}". Use YYYY-MM-DD.\n`));
+                await this.cleanupAndExit(1);
+                return;
+            }
+            const logDir = path.join(findProjectRoot(), '.agentic-qe', 'logs');
+            const logPath = path.join(logDir, `${targetDate}.md`);
+            if (!fs.existsSync(logPath)) {
+                console.log(chalk.yellow(`\n  No daily log found for ${targetDate}.\n`));
+                await this.cleanupAndExit(0);
+                return;
+            }
+            const content = fs.readFileSync(logPath, 'utf-8');
+            console.log(chalk.blue(`\n  Daily Log \u2014 ${targetDate}`));
+            console.log(chalk.gray('  ' + '\u2500'.repeat(40)));
+            // Indent and display each line
+            for (const line of content.split('\n')) {
+                if (line.trim()) {
+                    console.log(`  ${line}`);
+                }
+            }
+            console.log('');
+            await this.cleanupAndExit(0);
+        }
+        catch (error) {
+            console.error(chalk.red('\n  Failed to read daily log:'), toErrorMessage(error));
+            await this.cleanupAndExit(1);
+        }
+    }
+    async executePause() {
+        try {
+            this.worker.pause();
+            console.log(chalk.yellow('\n  Heartbeat worker paused.\n'));
+            await this.cleanupAndExit(0);
+        }
+        catch (error) {
+            console.error(chalk.red('\n  Failed to pause heartbeat:'), toErrorMessage(error));
+            await this.cleanupAndExit(1);
+        }
+    }
+    async executeResume() {
+        try {
+            this.worker.resume();
+            console.log(chalk.green('\n  Heartbeat worker resumed.\n'));
+            await this.cleanupAndExit(0);
+        }
+        catch (error) {
+            console.error(chalk.red('\n  Failed to resume heartbeat:'), toErrorMessage(error));
+            await this.cleanupAndExit(1);
+        }
+    }
+    getHelp() {
+        return `
+Manage the token-free heartbeat scheduler (Imp-10).
+
+The heartbeat runs every 30 minutes performing SQL-only maintenance:
+  - Pattern promotion checks
+  - Stale pattern deprecation
+  - Confidence decay application
+  - Experience buffer monitoring
+  - Daily Markdown log entries
+
+Subcommands:
+  status    Show heartbeat worker status, health, and schedule
+  run-now   Trigger an immediate heartbeat cycle
+  history   Show recent heartbeat results (last 10)
+  log       Show today's daily log entries
+  pause     Pause the heartbeat worker
+  resume    Resume the heartbeat worker
+
+Examples:
+  aqe heartbeat status
+  aqe heartbeat run-now
+  aqe heartbeat history -n 5
+  aqe heartbeat log
+  aqe heartbeat log --date 2026-03-25
+  aqe heartbeat pause
+  aqe heartbeat resume
+`;
+    }
+}
+const MAX_HISTORY_ENTRIES = 100;
+function getHistoryPath() {
+    return path.join(findProjectRoot(), '.agentic-qe', 'heartbeat-history.json');
+}
+function storeHistoryEntry(result) {
+    try {
+        const historyPath = getHistoryPath();
+        const dir = path.dirname(historyPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        let entries = [];
+        if (fs.existsSync(historyPath)) {
+            try {
+                entries = JSON.parse(fs.readFileSync(historyPath, 'utf-8'));
+            }
+            catch {
+                entries = [];
+            }
+        }
+        entries.unshift({
+            timestamp: result.timestamp.toISOString(),
+            success: result.success,
+            durationMs: result.durationMs,
+            healthScore: result.metrics.healthScore,
+            domainMetrics: result.metrics.domainMetrics,
+        });
+        // Prune to max entries
+        if (entries.length > MAX_HISTORY_ENTRIES) {
+            entries = entries.slice(0, MAX_HISTORY_ENTRIES);
+        }
+        fs.writeFileSync(historyPath, JSON.stringify(entries, null, 2));
+    }
+    catch {
+        // Non-critical: don't fail the command if history persistence fails
+    }
+}
+function loadHistoryEntries(count) {
+    try {
+        const historyPath = getHistoryPath();
+        if (!fs.existsSync(historyPath)) {
+            return [];
+        }
+        const entries = JSON.parse(fs.readFileSync(historyPath, 'utf-8'));
+        return entries.slice(0, count);
+    }
+    catch {
+        return [];
+    }
+}
+// ============================================================================
+// Display Helpers
+// ============================================================================
+function statusColor(status) {
+    switch (status) {
+        case 'idle': return chalk.cyan(status);
+        case 'running': return chalk.yellow(status);
+        case 'paused': return chalk.yellow(status);
+        case 'stopped': return chalk.gray(status);
+        case 'error': return chalk.red(status);
+        default: return chalk.white(status);
+    }
+}
+function scoreColor(score) {
+    if (score >= 80)
+        return chalk.green(String(score));
+    if (score >= 50)
+        return chalk.yellow(String(score));
+    return chalk.red(String(score));
+}
+function trendColor(trend) {
+    switch (trend) {
+        case 'improving': return chalk.green(trend);
+        case 'stable': return chalk.cyan(trend);
+        case 'degrading': return chalk.red(trend);
+        default: return chalk.gray(trend);
+    }
+}
+function formatRelativeTime(date, future = false) {
+    const diffMs = future ? date.getTime() - Date.now() : Date.now() - date.getTime();
+    if (diffMs < 0)
+        return future ? 'now' : 'just now';
+    if (diffMs < 60_000)
+        return `${Math.floor(diffMs / 1000)}s ${future ? 'from now' : 'ago'}`;
+    if (diffMs < 3_600_000)
+        return `${Math.floor(diffMs / 60_000)}m ${future ? 'from now' : 'ago'}`;
+    return `${Math.floor(diffMs / 3_600_000)}h ${future ? 'from now' : 'ago'}`;
+}
+// ============================================================================
+// Factory
+// ============================================================================
+export function createHeartbeatHandler(cleanupAndExit) {
+    return new HeartbeatHandler(cleanupAndExit);
+}
+//# sourceMappingURL=heartbeat-handler.js.map

package/dist/cli/handlers/index.d.ts

@@ -12,4 +12,6 @@ export { DomainHandler, createDomainHandler } from './domain-handler.js';
 export { ProtocolHandler, createProtocolHandler } from './protocol-handler.js';
 export { BrainHandler, createBrainHandler } from './brain-handler.js';
 export { HypergraphHandler, createHypergraphHandler } from './hypergraph-handler.js';
+export { HeartbeatHandler, createHeartbeatHandler } from './heartbeat-handler.js';
+export { RoutingHandler, createRoutingHandler } from './routing-handler.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/cli/handlers/index.js

@@ -14,4 +14,6 @@ export { DomainHandler, createDomainHandler } from './domain-handler.js';
 export { ProtocolHandler, createProtocolHandler } from './protocol-handler.js';
 export { BrainHandler, createBrainHandler } from './brain-handler.js';
 export { HypergraphHandler, createHypergraphHandler } from './hypergraph-handler.js';
+export { HeartbeatHandler, createHeartbeatHandler } from './heartbeat-handler.js';
+export { RoutingHandler, createRoutingHandler } from './routing-handler.js';
 //# sourceMappingURL=index.js.map

package/dist/cli/handlers/routing-handler.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Agentic QE v3 - Routing Command Handler
+ * Imp-18: Economic Routing Model CLI Integration
+ *
+ * Handles the 'aqe routing' command with subcommands:
+ *   economics, accuracy, metrics
+ */
+import { Command } from 'commander';
+import { ICommandHandler, CLIContext } from './interfaces.js';
+export declare class RoutingHandler implements ICommandHandler {
+    readonly name = "routing";
+    readonly description = "View routing performance, economics, and accuracy";
+    private cleanupAndExit;
+    constructor(cleanupAndExit: (code: number) => Promise<never>);
+    getHelp(): string;
+    register(program: Command, _context: CLIContext): void;
+    private executeEconomics;
+    private executeAccuracy;
+    private executeMetrics;
+}
+export declare function createRoutingHandler(cleanupAndExit: (code: number) => Promise<never>): RoutingHandler;
+//# sourceMappingURL=routing-handler.d.ts.map

package/dist/cli/handlers/routing-handler.js

@@ -0,0 +1,227 @@
+/**
+ * Agentic QE v3 - Routing Command Handler
+ * Imp-18: Economic Routing Model CLI Integration
+ *
+ * Handles the 'aqe routing' command with subcommands:
+ *   economics, accuracy, metrics
+ */
+import chalk from 'chalk';
+import { toErrorMessage } from '../../shared/error-utils.js';
+import { createRoutingFeedbackCollector } from '../../routing/routing-feedback.js';
+import { getGlobalCostTracker } from '../../shared/llm/cost-tracker.js';
+// ============================================================================
+// Routing Handler
+// ============================================================================
+export class RoutingHandler {
+    name = 'routing';
+    description = 'View routing performance, economics, and accuracy';
+    cleanupAndExit;
+    constructor(cleanupAndExit) {
+        this.cleanupAndExit = cleanupAndExit;
+    }
+    getHelp() {
+        return [
+            'aqe routing economics [--complexity <0-1>] [--json]  Show tier efficiency & budget',
+            'aqe routing accuracy [--json]                        Show routing accuracy analysis',
+            'aqe routing metrics [--json]                         Show per-agent performance',
+        ].join('\n');
+    }
+    register(program, _context) {
+        const routing = program
+            .command('routing')
+            .description(this.description);
+        routing
+            .command('economics')
+            .description('Show economic routing report: tier efficiency, budget, savings')
+            .option('-c, --complexity <value>', 'Task complexity for scoring (0-1)', '0.5')
+            .option('--json', 'Output as JSON')
+            .action(async (options) => {
+            await this.executeEconomics(parseFloat(options.complexity) || 0.5, !!options.json);
+        });
+        routing
+            .command('accuracy')
+            .description('Show routing accuracy analysis')
+            .option('--json', 'Output as JSON')
+            .action(async (options) => {
+            await this.executeAccuracy(!!options.json);
+        });
+        routing
+            .command('metrics')
+            .description('Show per-agent performance metrics')
+            .option('--json', 'Output as JSON')
+            .action(async (options) => {
+            await this.executeMetrics(!!options.json);
+        });
+    }
+    // --------------------------------------------------------------------------
+    // Economics
+    // --------------------------------------------------------------------------
+    async executeEconomics(complexity, json) {
+        try {
+            const collector = createRoutingFeedbackCollector(100);
+            await collector.initialize();
+            collector.enableEconomicRouting({}, getGlobalCostTracker());
+            const report = collector.getEconomicReport();
+            if (!report) {
+                console.error(chalk.red('\n  Economic routing is not available.\n'));
+                await this.cleanupAndExit(1);
+                return;
+            }
+            if (json) {
+                console.log(JSON.stringify(report, (_k, v) => (v === Infinity ? 'Infinity' : v), 2));
+                await this.cleanupAndExit(0);
+                return;
+            }
+            console.log(chalk.blue('\n  Economic Routing Report'));
+            console.log(chalk.gray('  ' + '\u2500'.repeat(50)));
+            // Tier efficiency table
+            console.log(chalk.white('\n  Tier Efficiency (complexity=' + complexity.toFixed(1) + '):\n'));
+            console.log(chalk.gray('  Tier       Quality  Cost/Task    Q/$       Score'));
+            console.log(chalk.gray('  ' + '\u2500'.repeat(50)));
+            const scores = collector.getEconomicScore(complexity) ?? report.tierEfficiency;
+            for (const s of scores) {
+                const qpd = isFinite(s.qualityPerDollar) ? s.qualityPerDollar.toFixed(1) : '\u221E';
+                console.log(`  ${padRight(s.tier, 10)}` +
+                    `${chalk.cyan(s.qualityScore.toFixed(2))}    ` +
+                    `$${s.estimatedCostUsd.toFixed(4)}    ` +
+                    `${chalk.yellow(padLeft(qpd, 8))}  ` +
+                    `${scoreColor(s.economicScore)}`);
+            }
+            // Budget
+            console.log(chalk.white('\n  Budget:'));
+            console.log(`  Hourly cost:  $${report.currentHourlyCostUsd.toFixed(4)}`);
+            console.log(`  Daily cost:   $${report.currentDailyCostUsd.toFixed(4)}`);
+            if (report.budgetRemaining.hourly !== null) {
+                console.log(`  Hourly left:  $${report.budgetRemaining.hourly.toFixed(4)}`);
+            }
+            if (report.budgetRemaining.daily !== null) {
+                console.log(`  Daily left:   $${report.budgetRemaining.daily.toFixed(4)}`);
+            }
+            // Recommendation
+            console.log(chalk.white('\n  Recommendation:'));
+            console.log(`  ${chalk.green(report.recommendation)}`);
+            if (report.savingsOpportunity) {
+                console.log(chalk.white('\n  Savings Opportunity:'));
+                console.log(`  ${chalk.yellow(report.savingsOpportunity.description)}`);
+            }
+            console.log('');
+            await this.cleanupAndExit(0);
+        }
+        catch (error) {
+            console.error(chalk.red('\n  Failed to get economic report:'), toErrorMessage(error));
+            await this.cleanupAndExit(1);
+        }
+    }
+    // --------------------------------------------------------------------------
+    // Accuracy
+    // --------------------------------------------------------------------------
+    async executeAccuracy(json) {
+        try {
+            const collector = createRoutingFeedbackCollector(10000);
+            await collector.initialize();
+            const accuracy = collector.analyzeRoutingAccuracy();
+            if (json) {
+                console.log(JSON.stringify(accuracy, null, 2));
+                await this.cleanupAndExit(0);
+                return;
+            }
+            console.log(chalk.blue('\n  Routing Accuracy Analysis'));
+            console.log(chalk.gray('  ' + '\u2500'.repeat(40)));
+            console.log(`  Total outcomes:       ${chalk.cyan(String(accuracy.totalOutcomes))}`);
+            console.log(`  Followed recs:        ${chalk.cyan(String(accuracy.followedRecommendations))}`);
+            console.log(`  Override rate:         ${chalk.yellow((accuracy.overrideRate * 100).toFixed(1) + '%')}`);
+            console.log(`  Rec success rate:      ${scoreColor100(accuracy.recommendationSuccessRate * 100)}`);
+            console.log(`  Override success rate:  ${scoreColor100(accuracy.overrideSuccessRate * 100)}`);
+            console.log(`  Confidence correlation: ${chalk.cyan(accuracy.confidenceCorrelation.toFixed(3))}`);
+            // Recommendations
+            const recs = collector.getImprovementRecommendations();
+            if (recs.length > 0) {
+                console.log(chalk.white('\n  Recommendations:'));
+                for (const rec of recs) {
+                    console.log(`  ${chalk.gray('\u2022')} ${rec}`);
+                }
+            }
+            console.log('');
+            await this.cleanupAndExit(0);
+        }
+        catch (error) {
+            console.error(chalk.red('\n  Failed to analyze routing accuracy:'), toErrorMessage(error));
+            await this.cleanupAndExit(1);
+        }
+    }
+    // --------------------------------------------------------------------------
+    // Metrics
+    // --------------------------------------------------------------------------
+    async executeMetrics(json) {
+        try {
+            const collector = createRoutingFeedbackCollector(10000);
+            await collector.initialize();
+            const metrics = collector.getAllAgentMetrics();
+            if (json) {
+                console.log(JSON.stringify(metrics, null, 2));
+                await this.cleanupAndExit(0);
+                return;
+            }
+            if (metrics.length === 0) {
+                console.log(chalk.yellow('\n  No routing metrics available yet. Run some QE tasks first.\n'));
+                await this.cleanupAndExit(0);
+                return;
+            }
+            console.log(chalk.blue('\n  Agent Routing Metrics'));
+            console.log(chalk.gray('  ' + '\u2500'.repeat(60)));
+            console.log(chalk.gray('  Agent                  Tasks  Success  Quality  Trend'));
+            console.log(chalk.gray('  ' + '\u2500'.repeat(60)));
+            for (const m of metrics.slice(0, 20)) {
+                const trend = m.trend === 'improving' ? chalk.green('\u2191')
+                    : m.trend === 'declining' ? chalk.red('\u2193')
+                        : chalk.gray('\u2192');
+                console.log(`  ${padRight(m.agentId, 24)}` +
+                    `${padLeft(String(m.totalTasks), 5)}  ` +
+                    `${scoreColor100(m.successRate * 100)}  ` +
+                    `${chalk.cyan(m.avgQualityScore.toFixed(2))}     ` +
+                    `${trend} ${m.trend}`);
+            }
+            const stats = collector.getStats();
+            console.log(chalk.gray(`\n  ${stats.totalOutcomes} total outcomes, ${stats.uniqueAgentsUsed} agents`));
+            console.log('');
+            await this.cleanupAndExit(0);
+        }
+        catch (error) {
+            console.error(chalk.red('\n  Failed to get agent metrics:'), toErrorMessage(error));
+            await this.cleanupAndExit(1);
+        }
+    }
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+function padRight(str, len) {
+    return str.length >= len ? str : str + ' '.repeat(len - str.length);
+}
+function padLeft(str, len) {
+    return str.length >= len ? str : ' '.repeat(len - str.length) + str;
+}
+function scoreColor(score) {
+    const pct = score * 100;
+    const str = score.toFixed(3);
+    if (pct >= 70)
+        return chalk.green(str);
+    if (pct >= 40)
+        return chalk.yellow(str);
+    return chalk.red(str);
+}
+function scoreColor100(pct) {
+    const str = pct.toFixed(1) + '%';
+    if (pct >= 70)
+        return chalk.green(str);
+    if (pct >= 40)
+        return chalk.yellow(str);
+    return chalk.red(str);
+}
+// ============================================================================
+// Factory
+// ============================================================================
+export function createRoutingHandler(cleanupAndExit) {
+    return new RoutingHandler(cleanupAndExit);
+}
+//# sourceMappingURL=routing-handler.js.map

package/dist/cli/index.js

@@ -822,6 +822,7 @@ import { createPlatformCommand } from './commands/platform.js';
 import { createProveCommand } from './commands/prove.js';
 import { createRuVectorCommand } from './commands/ruvector-commands.js';
 import { createAuditCommand } from './commands/audit.js';
+import { createPipelineCommand } from './commands/pipeline.js';
 program.addCommand(createTokenUsageCommand());
 program.addCommand(createLLMRouterCommand());
 program.addCommand(createSyncCommands());
@@ -833,6 +834,7 @@ program.addCommand(createPlatformCommand());
 program.addCommand(createProveCommand(context, cleanupAndExit, ensureInitialized));
 program.addCommand(createRuVectorCommand());
 program.addCommand(createAuditCommand(context, cleanupAndExit, ensureInitialized));
+program.addCommand(createPipelineCommand(context, cleanupAndExit, ensureInitialized));
 // ============================================================================
 // Shutdown Handlers
 // ============================================================================