swarm-orchestrator 7.0.0-alpha.0

package/dist/src/cli/share-handlers.js

@@ -0,0 +1,163 @@
+"use strict";
+/**
+ * Share-related CLI command handlers extracted from cli-handlers.ts.
+ * Handles /share transcript import and prior-context display.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleShareCommand = handleShareCommand;
+const session_manager_1 = require("../session-manager");
+const usage_1 = require("./usage");
+const logger_1 = require("../logger");
+const logger = (0, logger_1.getLogger)('cli:share');
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function importShare(runId, stepNumber, agentName, transcriptPath) {
+    logger.info('Swarm Orchestrator - Import /share Transcript\n');
+    const step = parseInt(stepNumber, 10);
+    if (isNaN(step)) {
+        logger.error('Error: Step number must be a number');
+        return 1;
+    }
+    const manager = new session_manager_1.SessionManager();
+    try {
+        const stepShare = manager.importShare(runId, step, agentName, transcriptPath);
+        logger.info(`✓ Imported /share transcript for step ${step}`);
+        logger.info(`  Agent: ${agentName}`);
+        logger.info(`  Run: ${runId}`);
+        logger.info(`  Saved to: ${stepShare.transcriptPath}\n`);
+        logger.info('Extracted Index:');
+        logger.info('===============');
+        if (stepShare.index.changedFiles.length > 0) {
+            logger.info(`\nChanged Files (${stepShare.index.changedFiles.length}):`);
+            stepShare.index.changedFiles.forEach(file => logger.info(`  - ${file}`));
+        }
+        if (stepShare.index.commandsExecuted.length > 0) {
+            logger.info(`\nCommands Executed (${stepShare.index.commandsExecuted.length}):`);
+            stepShare.index.commandsExecuted.forEach(cmd => logger.info(`  $ ${cmd}`));
+        }
+        if (stepShare.index.testsRun.length > 0) {
+            logger.info(`\nTests Run:`);
+            stepShare.index.testsRun.forEach(test => {
+                const status = test.verified ? '✓' : '✗';
+                logger.info(`  ${status} ${test.command}`);
+                if (!test.verified && test.reason) {
+                    logger.info(`    reason: ${test.reason}`);
+                }
+            });
+        }
+        if (stepShare.index.prLinks.length > 0) {
+            logger.info(`\nPR Links:`);
+            stepShare.index.prLinks.forEach(link => logger.info(`  - ${link}`));
+        }
+        if (stepShare.index.claims.length > 0) {
+            logger.info(`\nClaims Verification:`);
+            stepShare.index.claims.forEach(claim => {
+                const status = claim.verified ? '✓' : '⚠';
+                logger.info(`  ${status} ${claim.claim.substring(0, 80)}`);
+                if (claim.evidence) {
+                    logger.info(`    evidence: ${claim.evidence}`);
+                }
+            });
+        }
+        const unverified = stepShare.index.claims.filter(c => !c.verified);
+        if (unverified.length > 0) {
+            logger.warn(`\n⚠ WARNING: ${unverified.length} unverified claims detected`);
+            logger.warn('this step may require manual review before proceeding\n');
+        }
+        else {
+            logger.info('\n✓ All claims verified\n');
+        }
+        return 0;
+    }
+    catch (error) {
+        logger.error('Error importing share:', error instanceof Error ? error.message : error);
+        return 1;
+    }
+}
+function showShareContext(runId, stepNumber) {
+    logger.info('Swarm Orchestrator - Prior Context\n');
+    const step = parseInt(stepNumber, 10);
+    if (isNaN(step)) {
+        logger.error('Error: Step number must be a number');
+        return 1;
+    }
+    const manager = new session_manager_1.SessionManager();
+    try {
+        const summary = manager.generateContextSummary(runId, step);
+        logger.info(`Prior context for step ${step} in run ${runId}:\n`);
+        logger.info(summary);
+        logger.info('');
+        const allUnverified = manager.getUnverifiedClaims(runId);
+        if (allUnverified.length > 0) {
+            logger.warn('⚠ UNVERIFIED CLAIMS IN PRIOR STEPS:');
+            allUnverified.forEach(item => {
+                logger.warn(`  Step ${item.step} (${item.agent}): ${item.claims.length} unverified claims`);
+            });
+            logger.info('');
+        }
+        return 0;
+    }
+    catch (error) {
+        logger.error('Error loading context:', error instanceof Error ? error.message : error);
+        return 1;
+    }
+}
+// ---------------------------------------------------------------------------
+// Exported command handler
+// ---------------------------------------------------------------------------
+async function handleShareCommand(args) {
+    const subcommand = args[1];
+    if (!subcommand) {
+        logger.error('Error: share subcommand required (import or context)\n');
+        (0, usage_1.showUsage)();
+        return 1;
+    }
+    if (subcommand === 'import') {
+        if (args.length < 6) {
+            logger.error('Error: share import requires: <runid> <step> <agent> <path>\n');
+            (0, usage_1.showUsage)();
+            return 1;
+        }
+        const runId = args[2];
+        const stepNumber = args[3];
+        const agentName = args[4];
+        const transcriptPath = args[5];
+        if (!runId || !stepNumber || !agentName || !transcriptPath) {
+            logger.error('Error: all arguments required\n');
+            (0, usage_1.showUsage)();
+            return 1;
+        }
+        try {
+            return importShare(runId, stepNumber, agentName, transcriptPath);
+        }
+        catch (error) {
+            logger.error('Error:', error instanceof Error ? error.message : error);
+            return 1;
+        }
+    }
+    if (subcommand === 'context') {
+        if (args.length < 4) {
+            logger.error('Error: share context requires: <runid> <step>\n');
+            (0, usage_1.showUsage)();
+            return 1;
+        }
+        const runId = args[2];
+        const stepNumber = args[3];
+        if (!runId || !stepNumber) {
+            logger.error('Error: all arguments required\n');
+            (0, usage_1.showUsage)();
+            return 1;
+        }
+        try {
+            return showShareContext(runId, stepNumber);
+        }
+        catch (error) {
+            logger.error('Error:', error instanceof Error ? error.message : error);
+            return 1;
+        }
+    }
+    logger.error(`Unknown share subcommand: ${subcommand}\n`);
+    (0, usage_1.showUsage)();
+    return 1;
+}

package/dist/src/cli/status-handlers.js

@@ -0,0 +1,457 @@
+"use strict";
+/**
+ * Status / reporting CLI command handlers extracted from cli-handlers.ts.
+ * Each handler validates its arguments, performs the work, and returns an
+ * exit code (0 = success, 1 = failure). No handler calls process.exit.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showStatus = showStatus;
+exports.handleStatusCommand = handleStatusCommand;
+exports.handleGatesCommand = handleGatesCommand;
+exports.handleAuditCommand = handleAuditCommand;
+exports.handleMetricsCommand = handleMetricsCommand;
+exports.handleReportCommand = handleReportCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const step_runner_1 = require("../step-runner");
+const sarif_formatter_1 = require("../sarif-formatter");
+const flags_1 = require("./flags");
+const usage_1 = require("./usage");
+const logger_1 = require("../logger");
+const logger = (0, logger_1.getLogger)('cli:status');
+// ---------------------------------------------------------------------------
+// Internal helpers (not exported; called by the handle* functions)
+// ---------------------------------------------------------------------------
+function showStatus(executionId, outputFormat = 'text') {
+    if (outputFormat !== 'json') {
+        logger.info('Swarm Orchestrator - Execution Status\n');
+    }
+    const runner = new step_runner_1.StepRunner();
+    try {
+        const context = runner.loadExecutionContext(executionId);
+        if (outputFormat === 'json') {
+            const nextStep = context.stepResults.find(r => r.status === 'pending') || null;
+            (0, logger_1.writeStructuredOutput)({
+                mode: 'sequential',
+                executionId,
+                status: context.stepResults.every(r => r.status === 'completed')
+                    ? 'completed'
+                    : context.stepResults.some(r => r.status === 'failed')
+                        ? 'failed'
+                        : 'in_progress',
+                nextStep,
+                context,
+            });
+        }
+        else {
+            const summary = runner.generateSummary(context);
+            logger.info(summary);
+            const nextStep = context.stepResults.find(r => r.status === 'pending');
+            if (nextStep) {
+                logger.info(`\nNext step: ${nextStep.stepNumber} (${nextStep.agentName})`);
+                logger.info('Run execution command again to see instructions for this step.');
+            }
+            else {
+                const allCompleted = context.stepResults.every(r => r.status === 'completed');
+                if (allCompleted) {
+                    logger.info('\n✓ All steps completed!');
+                }
+                else {
+                    logger.info('\n⚠ Some steps failed or were skipped');
+                }
+            }
+        }
+        return 0;
+    }
+    catch {
+        // Not a sequential execution context; fall through to swarm session state
+    }
+    const MetricsCollectorClass = require('../metrics-collector').default;
+    const collector = new MetricsCollectorClass(executionId, '');
+    const state = collector.loadSession(executionId);
+    if (state) {
+        const completed = state.lastCompletedStep;
+        const total = state.graph.steps.length;
+        if (outputFormat === 'json') {
+            (0, logger_1.writeStructuredOutput)({
+                mode: 'swarm',
+                executionId,
+                sessionId: state.sessionId,
+                status: state.status,
+                completed,
+                total,
+                branches: Object.keys(state.branchMap).length,
+                transcripts: Object.keys(state.transcripts).length,
+                gateResults: state.gateResults,
+                metrics: state.metrics,
+            });
+        }
+        else {
+            logger.info(`  Session:    ${state.sessionId}`);
+            logger.info(`  Status:     ${state.status}`);
+            logger.info(`  Progress:   ${completed}/${total} steps completed`);
+            logger.info(`  Branches:   ${Object.keys(state.branchMap).length}`);
+            logger.info(`  Transcripts:${Object.keys(state.transcripts).length}`);
+            if (state.status === 'completed') {
+                logger.info('\n✓ All steps completed!');
+            }
+            else if (state.status === 'failed') {
+                logger.info('\n⚠ Execution failed. Use --resume to retry.');
+            }
+            else {
+                logger.info(`\n⏳ ${state.status} at step ${completed + 1}`);
+            }
+        }
+        return 0;
+    }
+    logger.error(`Execution not found: ${executionId}`);
+    logger.error('Checked both proof/ (sequential) and runs/ (swarm) directories.');
+    return 1;
+}
+// ---------------------------------------------------------------------------
+// Command handlers (exported for testing and called by main dispatch)
+// ---------------------------------------------------------------------------
+async function handleStatusCommand(args) {
+    const executionId = (0, flags_1.extractPositionalArgs)(args.slice(1), {
+        booleanFlags: ['--verbose', '--json'],
+        valueFlags: ['--output'],
+    })[0];
+    if (!executionId) {
+        logger.error('Error: Execution ID required\n');
+        (0, usage_1.showUsage)();
+        return 1;
+    }
+    try {
+        return showStatus(executionId, (0, flags_1.parseOutputFormat)(args));
+    }
+    catch (error) {
+        logger.error('Error showing status:', error instanceof Error ? error.message : error);
+        return 1;
+    }
+}
+async function handleGatesCommand(args) {
+    const { load_quality_gates_config, run_quality_gates } = require('../quality-gates');
+    const outputFormat = (0, flags_1.parseOutputFormat)(args);
+    const positional = (0, flags_1.extractPositionalArgs)(args, {
+        booleanFlags: ['--verbose', '--json'],
+        valueFlags: ['--output', '--quality-gates-config', '--quality-gates-out', '--base-commit', '--sarif'],
+    })[0];
+    const projectRoot = positional ? path.resolve(process.cwd(), positional) : process.cwd();
+    const configIndex = args.indexOf('--quality-gates-config');
+    const configPath = configIndex !== -1 && args[configIndex + 1] ? args[configIndex + 1] : undefined;
+    const outIndex = args.indexOf('--quality-gates-out');
+    const outDir = outIndex !== -1 && args[outIndex + 1]
+        ? path.resolve(process.cwd(), args[outIndex + 1])
+        : undefined;
+    // When a base commit is provided, compute baseline files so gates only flag
+    // agent-created or agent-modified files, not pre-existing project code.
+    const baseCommitIdx = args.indexOf('--base-commit');
+    const baseCommitSha = baseCommitIdx !== -1 && args[baseCommitIdx + 1] ? args[baseCommitIdx + 1] : undefined;
+    let baselineFiles;
+    if (baseCommitSha) {
+        try {
+            const { execSync } = require('child_process');
+            const fileList = execSync(`git ls-tree -r --name-only ${baseCommitSha}`, {
+                cwd: projectRoot,
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            baselineFiles = new Set(fileList.trim().split('\n').filter(Boolean));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.error(`Failed to read baseline files from commit ${baseCommitSha}: ${msg}`);
+            return 1;
+        }
+    }
+    const sarifIndex = args.indexOf('--sarif');
+    const sarifPath = sarifIndex !== -1 && args[sarifIndex + 1] ? args[sarifIndex + 1] : undefined;
+    if (outputFormat === 'json' && sarifPath === '-') {
+        logger.error('Cannot combine --output json with --sarif -');
+        return 1;
+    }
+    const config = load_quality_gates_config(projectRoot, configPath);
+    const result = await run_quality_gates(projectRoot, config, outDir, baselineFiles, baseCommitSha);
+    if (outputFormat === 'json') {
+        (0, logger_1.writeStructuredOutput)({
+            projectRoot,
+            configPath: configPath || null,
+            outDir: outDir || null,
+            baseCommitSha: baseCommitSha || null,
+            ...result,
+        });
+    }
+    else {
+        // When SARIF goes to stdout, route status text to stderr to keep stdout clean
+        const log = sarifPath === '-' ? logger.error : logger.info;
+        const icon = result.passed ? '✅' : '❌';
+        log(`${icon} quality gates ${result.passed ? 'passed' : 'failed'} (${result.totalDurationMs}ms)`);
+        for (const gate of result.results) {
+            const g = gate.status === 'pass' ? '✅' : gate.status === 'skip' ? '⏭️' : '❌';
+            log(`  ${g} ${gate.id}: ${gate.issues.length} issue(s)`);
+            if (gate.issues.length > 0) {
+                for (const issue of gate.issues) {
+                    const loc = issue.filePath ? ` (${issue.filePath}${issue.line ? ':' + issue.line : ''})` : '';
+                    log(`     ${issue.message}${loc}`);
+                    if (issue.excerpt) {
+                        const trimmed = issue.excerpt.split('\n').slice(0, 5).join('\n');
+                        log(`     ${trimmed}`);
+                    }
+                }
+            }
+        }
+    }
+    if (sarifPath) {
+        const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', 'package.json'), 'utf8'));
+        const sarifOutput = (0, sarif_formatter_1.formatSarif)(result, pkg.version);
+        if (sarifPath === '-') {
+            process.stdout.write(sarifOutput + '\n');
+        }
+        else {
+            const resolved = path.resolve(process.cwd(), sarifPath);
+            const dir = path.dirname(resolved);
+            if (!fs.existsSync(dir)) {
+                logger.error(`SARIF output directory does not exist: ${dir}`);
+                return 1;
+            }
+            fs.writeFileSync(resolved, sarifOutput, 'utf8');
+            logger.info(`SARIF report written to ${resolved}`);
+        }
+    }
+    return result.passed ? 0 : 1;
+}
+async function handleAuditCommand(args) {
+    const sessionId = (0, flags_1.extractPositionalArgs)(args.slice(1), {
+        booleanFlags: ['--verbose', '--json'],
+        valueFlags: ['--output'],
+    })[0];
+    if (!sessionId) {
+        logger.error('Error: session ID required\nUsage: swarm audit <session-id>');
+        return 1;
+    }
+    const MetricsCollectorClass = require('../metrics-collector').default;
+    const collector = new MetricsCollectorClass(sessionId, '');
+    const state = collector.loadSession(sessionId);
+    if (!state) {
+        logger.error(`Session not found: ${sessionId}`);
+        return 1;
+    }
+    logger.info(collector.generateAuditReport(state));
+    return 0;
+}
+async function handleMetricsCommand(args) {
+    const sessionId = (0, flags_1.extractPositionalArgs)(args.slice(1), {
+        booleanFlags: ['--verbose', '--json'],
+        valueFlags: ['--output'],
+    })[0];
+    if (!sessionId) {
+        logger.error('Error: session ID required\nUsage: swarm metrics <session-id>');
+        return 1;
+    }
+    const MetricsCollectorClass = require('../metrics-collector').default;
+    const collector = new MetricsCollectorClass(sessionId, '');
+    const state = collector.loadSession(sessionId);
+    if (!state) {
+        logger.error(`Session not found: ${sessionId}`);
+        return 1;
+    }
+    const steps = state.graph.steps.length;
+    const completed = state.lastCompletedStep;
+    const branches = Object.keys(state.branchMap).length;
+    const transcripts = Object.keys(state.transcripts).length;
+    const gatesPassed = state.gateResults.filter(g => g.status === 'pass').length;
+    const gatesFailed = state.gateResults.filter(g => g.status === 'fail').length;
+    const gatesSkipped = state.gateResults.filter(g => g.status === 'skip').length;
+    const premiumReqs = readActualPremiumRequests(sessionId, state);
+    const totalMs = Number(state.metrics['totalTimeMs'] ?? 0);
+    if ((0, flags_1.parseOutputFormat)(args) === 'json') {
+        (0, logger_1.writeStructuredOutput)({
+            sessionId: state.sessionId,
+            status: state.status,
+            steps, completed, branches, transcripts,
+            gatesPassed, gatesFailed, gatesSkipped, premiumReqs,
+            totalTimeMs: totalMs
+        });
+    }
+    else {
+        logger.info(`\n  Session Metrics: ${state.sessionId}\n  ${'─'.repeat(50)}`);
+        logger.info(`  Status:          ${state.status}`);
+        logger.info(`  Steps:           ${completed}/${steps} completed`);
+        logger.info(`  Branches:        ${branches}`);
+        logger.info(`  Transcripts:     ${transcripts}`);
+        const gateLine = gatesSkipped > 0
+            ? `${gatesPassed} passed, ${gatesFailed} failed, ${gatesSkipped} skipped`
+            : `${gatesPassed} passed, ${gatesFailed} failed`;
+        logger.info(`  Gates:           ${gateLine}`);
+        logger.info(`  Premium requests:${premiumReqs}`);
+        if (totalMs > 0) {
+            const sec = Math.round(totalMs / 1000);
+            logger.info(`  Wall time:       ${sec}s`);
+        }
+        logger.info(`  ${'─'.repeat(50)}\n`);
+    }
+    return 0;
+}
+/**
+ * Pull the actual premium-request count for a session from
+ * `cost-attribution.json`, which the post-run reporter writes from
+ * `CostAttributor`. Falls back to `state.metrics.premiumRequests` and then 0.
+ *
+ * The session-state metrics map is populated incrementally during the run and
+ * has historically been missing this field; cost-attribution is the
+ * authoritative post-run record.
+ */
+function readActualPremiumRequests(sessionId, state) {
+    const fs = require('fs');
+    const path = require('path');
+    const candidate = path.join(process.cwd(), 'runs', sessionId, 'cost-attribution.json');
+    if (fs.existsSync(candidate)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(candidate, 'utf8'));
+            if (typeof parsed.totalActualPremiumRequests === 'number') {
+                return parsed.totalActualPremiumRequests;
+            }
+        }
+        catch {
+            // fall through to metrics-map fallback
+        }
+    }
+    return Number(state.metrics['premiumRequests'] ?? 0);
+}
+async function handleReportCommand(args) {
+    if (args.includes('--help') || args.includes('-h')) {
+        logger.info(`
+Usage: swarm report <run-id> [flags]
+
+Generate a structured run report from existing run artifacts.
+
+Arguments:
+  <run-id>   The run directory name (e.g., swarm-2026-04-08T05-23-52-947Z)
+
+Flags:
+  --format <md|json>   Output format (default: both)
+  --stdout             Print to terminal instead of writing files
+  --latest             Use the most recent run directory
+
+Examples:
+  swarm report swarm-2026-04-08T05-23-52-947Z
+  swarm report --latest --format md --stdout
+  swarm report --latest
+`);
+        return 0;
+    }
+    const useLatest = args.includes('--latest');
+    const toStdout = args.includes('--stdout');
+    const formatIdx = args.indexOf('--format');
+    let format = 'both';
+    if (formatIdx !== -1 && args[formatIdx + 1]) {
+        const val = args[formatIdx + 1];
+        if (val !== 'md' && val !== 'json') {
+            logger.error(`--format requires "md" or "json", got "${val}"`);
+            return 1;
+        }
+        format = val;
+    }
+    let runDir;
+    if (useLatest) {
+        const runsRoot = path.join(process.cwd(), 'runs');
+        if (!fs.existsSync(runsRoot)) {
+            logger.error(`No runs/ directory found in ${process.cwd()}`);
+            return 1;
+        }
+        const entries = fs.readdirSync(runsRoot, { withFileTypes: true })
+            .filter(e => e.isDirectory())
+            .map(e => e.name)
+            .sort()
+            .reverse();
+        if (entries.length === 0) {
+            logger.error('No run directories found in runs/');
+            return 1;
+        }
+        runDir = path.join(runsRoot, entries[0]);
+    }
+    else {
+        const runId = args.find(a => !a.startsWith('--') && a !== 'report');
+        if (!runId) {
+            logger.error('Error: run-id required (or use --latest)');
+            logger.error('Usage: swarm report <run-id>');
+            return 1;
+        }
+        runDir = path.join(process.cwd(), 'runs', runId);
+        if (!fs.existsSync(runDir)) {
+            // Try as absolute path
+            runDir = runId;
+        }
+    }
+    if (!fs.existsSync(runDir)) {
+        logger.error(`Run directory not found: ${runDir}`);
+        return 1;
+    }
+    const { ReportGenerator } = await Promise.resolve().then(() => __importStar(require('../report-generator')));
+    const { ReportRenderer } = await Promise.resolve().then(() => __importStar(require('../report-renderer')));
+    let report;
+    try {
+        const generator = new ReportGenerator();
+        report = generator.generate(runDir);
+    }
+    catch (err) {
+        logger.error(`Failed to generate report: ${err instanceof Error ? err.message : err}`);
+        return 1;
+    }
+    const md = ReportRenderer.toMarkdown(report);
+    const json = ReportRenderer.toJson(report);
+    if (toStdout) {
+        if (format === 'md' || format === 'both')
+            logger.info(md);
+        if (format === 'json' || format === 'both')
+            logger.info(json);
+    }
+    else {
+        if (format === 'md' || format === 'both') {
+            const mdPath = path.join(runDir, 'report.md');
+            fs.writeFileSync(mdPath, md);
+            logger.info(`Report written: ${mdPath}`);
+        }
+        if (format === 'json' || format === 'both') {
+            const jsonPath = path.join(runDir, 'report.json');
+            fs.writeFileSync(jsonPath, json);
+            logger.info(`Report written: ${jsonPath}`);
+        }
+    }
+    const summary = ReportRenderer.toSummaryLine(report);
+    logger.info(summary);
+    return 0;
+}