claude-flow 3.56.7 → 3.56.9

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

@@ -97,11 +97,19 @@ const diffCommand = {
         output.printInfo(`Analyzing diff: ${output.highlight(ref)}`);
         try {
             // Call MCP tool for diff analysis
+            // Shape returned by the analyze_diff MCP tool (ruvector/diff-classifier.ts).
+            // Typed from the classifier itself so the renderer cannot drift from it again.
             const result = await callMCPTool('analyze_diff', {
                 ref,
-                includeFileRisks: verbose,
+                // Always request file risks: the handler computes them anyway, and the
+                // high-risk file list below is derived from them.
+                includeFileRisks: true,
                 includeReviewers: showReviewers || showAll,
             });
+            if (result.error) {
+                output.printError(`Diff analysis failed: ${result.message ?? 'unknown error'}`);
+                return { success: false, exitCode: 1 };
+            }
             // JSON output
             if (formatType === 'json') {
                 output.printJson(result);
@@ -110,13 +118,18 @@ const diffCommand = {
             output.writeln();
             // Summary box
             const files = result.files || [];
-            const risk = result.risk || { overall: 'unknown', score: 0, breakdown: { fileCount: 0, totalChanges: 0, highRiskFiles: [], securityConcerns: [], breakingChanges: [], testCoverage: 'unknown' } };
-            const classification = result.classification || { category: 'unknown', confidence: 0, reasoning: '' };
+            const fileRisks = result.fileRisks || [];
+            const risk = result.risk || { overall: 'low', score: 0, breakdown: { low: 0, medium: 0, high: 0, critical: 0 } };
+            const classification = result.classification;
+            const category = classification?.primary ?? 'unknown';
+            const secondary = classification?.secondary?.length ? classification.secondary.join(', ') : '';
+            const totalChanges = files.reduce((sum, f) => sum + f.additions + f.deletions, 0);
+            const highRiskFiles = fileRisks.filter((r) => r.risk === 'high' || r.risk === 'critical').map((r) => r.file);
             output.printBox([
                 `Ref: ${result.ref || 'HEAD'}`,
                 `Files: ${files.length}`,
                 `Risk: ${getRiskDisplay(risk.overall)} (${risk.score}/100)`,
-                `Type: ${classification.category}${classification.subcategory ? ` (${classification.subcategory})` : ''}`,
+                `Type: ${category}${secondary ? ` (${secondary})` : ''}`,
                 ``,
                 result.summary || 'No summary available',
             ].join('\n'), 'Diff Analysis');
@@ -128,33 +141,28 @@ const diffCommand = {
                 output.printTable({
                     columns: [
                         { key: 'metric', header: 'Metric', width: 25 },
-                        { key: 'value', header: 'Value', width: 30 },
+                        { key: 'value', header: 'Value', width: 42 },
                     ],
                     data: [
                         { metric: 'Overall Risk', value: getRiskDisplay(risk.overall) },
                         { metric: 'Risk Score', value: `${risk.score}/100` },
-                        { metric: 'Files Changed', value: risk.breakdown.fileCount },
-                        { metric: 'Total Lines Changed', value: risk.breakdown.totalChanges },
-                        { metric: 'Test Coverage', value: risk.breakdown.testCoverage },
+                        { metric: 'Files Changed', value: files.length },
+                        { metric: 'Total Lines Changed', value: totalChanges },
+                        { metric: 'Files by Risk', value: `low ${risk.breakdown.low} / medium ${risk.breakdown.medium} / high ${risk.breakdown.high} / critical ${risk.breakdown.critical}` },
                     ],
                 });
-                // Security concerns
-                if (risk.breakdown.securityConcerns.length > 0) {
-                    output.writeln();
-                    output.writeln(output.bold(output.warning('Security Concerns')));
-                    output.printList(risk.breakdown.securityConcerns.map(c => output.warning(c)));
-                }
-                // Breaking changes
-                if (risk.breakdown.breakingChanges.length > 0) {
+                // Risk factors reported by the classifier
+                const riskFactors = classification?.riskFactors ?? [];
+                if (riskFactors.length > 0) {
                     output.writeln();
-                    output.writeln(output.bold(output.error('Potential Breaking Changes')));
-                    output.printList(risk.breakdown.breakingChanges.map(c => output.error(c)));
+                    output.writeln(output.bold(output.warning('Risk Factors')));
+                    output.printList(riskFactors.map(c => output.warning(c)));
                 }
                 // High risk files
-                if (risk.breakdown.highRiskFiles.length > 0) {
+                if (highRiskFiles.length > 0) {
                     output.writeln();
                     output.writeln(output.bold('High Risk Files'));
-                    output.printList(risk.breakdown.highRiskFiles.map(f => output.warning(f)));
+                    output.printList(highRiskFiles.map(f => output.warning(f)));
                 }
             }
             // Classification
@@ -168,13 +176,16 @@ const diffCommand = {
                         { key: 'value', header: 'Value', width: 40 },
                     ],
                     data: [
-                        { field: 'Category', value: classification.category },
-                        { field: 'Subcategory', value: classification.subcategory || '-' },
-                        { field: 'Confidence', value: `${(classification.confidence * 100).toFixed(0)}%` },
+                        { field: 'Category', value: category },
+                        { field: 'Secondary', value: secondary || '-' },
+                        { field: 'Confidence', value: `${((classification?.confidence ?? 0) * 100).toFixed(0)}%` },
+                        { field: 'Impact', value: classification?.impactLevel ?? '-' },
                     ],
                 });
-                output.writeln();
-                output.writeln(output.dim(`Reasoning: ${classification.reasoning}`));
+                if (classification?.testingStrategy?.length) {
+                    output.writeln();
+                    output.writeln(output.dim(`Testing strategy: ${classification.testingStrategy.join(', ')}`));
+                }
             }
             // Reviewers
             if (showReviewers || showAll) {
@@ -190,13 +201,13 @@ const diffCommand = {
                 }
             }
             // Verbose file-level details
-            if (verbose && result.fileRisks) {
+            if (verbose && fileRisks.length > 0) {
                 output.writeln();
                 output.writeln(output.bold('File-Level Analysis'));
                 output.writeln(output.dim('-'.repeat(50)));
                 output.printTable({
                     columns: [
-                        { key: 'path', header: 'File', width: 40 },
+                        { key: 'file', header: 'File', width: 40 },
                         { key: 'risk', header: 'Risk', width: 12, format: (v) => getRiskDisplay(String(v)) },
                         { key: 'score', header: 'Score', width: 8, align: 'right' },
                         { key: 'reasons', header: 'Reasons', width: 30, format: (v) => {
@@ -204,7 +215,7 @@ const diffCommand = {
                                 return reasons.slice(0, 2).join('; ');
                             } },
                     ],
-                    data: result.fileRisks,
+                    data: fileRisks.map((r) => ({ ...r })),
                 });
             }
             // Files changed table
@@ -219,7 +230,7 @@ const diffCommand = {
                         { key: 'additions', header: '+', width: 8, align: 'right', format: (v) => output.success(`+${v}`) },
                         { key: 'deletions', header: '-', width: 8, align: 'right', format: (v) => output.error(`-${v}`) },
                     ],
-                    data: files.slice(0, 20),
+                    data: files.slice(0, 20).map((f) => ({ ...f })),
                 });
                 if (files.length > 20) {
                     output.writeln(output.dim(`  ... and ${files.length - 20} more files`));

package/v3/@claude-flow/cli/dist/src/commands/coverage-reader.d.ts

@@ -0,0 +1,29 @@
+interface CoverageFileEntry {
+    filePath: string;
+    lines: number;
+    branches: number;
+    functions: number;
+    statements: number;
+}
+interface CoverageData {
+    found: boolean;
+    source: string;
+    entries: CoverageFileEntry[];
+    summary: {
+        totalFiles: number;
+        overallLineCoverage: number;
+        overallBranchCoverage: number;
+        overallFunctionCoverage: number;
+        overallStatementCoverage: number;
+    };
+}
+/**
+ * Read coverage data from disk. Checks these locations in order:
+ * 1. coverage/coverage-summary.json (Jest/Istanbul)
+ * 2. coverage/lcov.info (lcov format)
+ * 3. coverage/coverage-final.json (Istanbul counters)
+ * 4. .nyc_output/out.json (nyc counters or legacy summary)
+ */
+export declare function readCoverageFromDisk(): CoverageData;
+export {};
+//# sourceMappingURL=coverage-reader.d.ts.map

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

@@ -0,0 +1,247 @@
+import { readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+/** Coverage reports are build output the project controls: refuse anything large enough to stall or exhaust the process. */
+const MAX_REPORT_BYTES = 64 * 1024 * 1024;
+/** The file's text, or undefined when it is missing, not a regular file, unreadable, or over the size cap. */
+function readReport(path) {
+    try {
+        const stat = statSync(path);
+        if (!stat.isFile() || stat.size > MAX_REPORT_BYTES)
+            return undefined;
+        return readFileSync(path, 'utf-8');
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Read coverage data from disk. Checks these locations in order:
+ * 1. coverage/coverage-summary.json (Jest/Istanbul)
+ * 2. coverage/lcov.info (lcov format)
+ * 3. coverage/coverage-final.json (Istanbul counters)
+ * 4. .nyc_output/out.json (nyc counters or legacy summary)
+ */
+export function readCoverageFromDisk() {
+    const cwd = process.cwd();
+    const noData = {
+        found: false,
+        source: 'none',
+        entries: [],
+        summary: { totalFiles: 0, overallLineCoverage: 0, overallBranchCoverage: 0, overallFunctionCoverage: 0, overallStatementCoverage: 0 },
+    };
+    // 1. Try coverage-summary.json (Jest/Istanbul)
+    for (const relPath of ['coverage/coverage-summary.json', 'coverage-summary.json']) {
+        const text = readReport(join(cwd, relPath));
+        if (text !== undefined) {
+            try {
+                const raw = JSON.parse(text);
+                const report = parseCoverageSummaryJson(raw, relPath);
+                if (report.found)
+                    return report;
+            }
+            catch {
+                // malformed, try next
+            }
+        }
+    }
+    // 2. Try lcov.info
+    for (const relPath of ['coverage/lcov.info', 'lcov.info']) {
+        const raw = readReport(join(cwd, relPath));
+        if (raw !== undefined) {
+            try {
+                const report = parseLcovInfo(raw, relPath);
+                if (report.found)
+                    return report;
+            }
+            catch {
+                // malformed, try next
+            }
+        }
+    }
+    // Istanbul's raw counter map (Jest, Vitest, nyc).
+    for (const relPath of ['coverage/coverage-final.json', 'coverage-final.json', '.nyc_output/out.json']) {
+        const text = readReport(join(cwd, relPath));
+        if (text === undefined)
+            continue;
+        try {
+            const raw = JSON.parse(text);
+            const report = parseIstanbulCoverage(raw, relPath);
+            if (report.found)
+                return report;
+            const legacy = parseCoverageSummaryJson(raw, relPath);
+            if (legacy.found)
+                return legacy;
+        }
+        catch {
+            // Missing or malformed, try the next supported report.
+        }
+    }
+    return noData;
+}
+function parseCoverageSummaryJson(data, source) {
+    const entries = [];
+    const metricsByFile = [];
+    for (const [filePath, metrics] of Object.entries(data)) {
+        if (filePath === 'total')
+            continue;
+        const m = metrics;
+        if (!m || typeof m !== 'object')
+            continue;
+        if (!['lines', 'branches', 'functions', 'statements'].some(key => m[key]))
+            continue;
+        metricsByFile.push(m);
+        const linePct = percentage(m.lines) ?? 0;
+        const branchPct = (percentage(m.branches) ?? 0);
+        const funcPct = (percentage(m.functions) ?? 0);
+        const stmtPct = (percentage(m.statements) ?? 0);
+        entries.push({ filePath, lines: linePct, branches: branchPct, functions: funcPct, statements: stmtPct });
+    }
+    // Only aggregate complete counts. A missing denominator is unknown, not empty.
+    const total = data['total'];
+    const aggregate = (key) => {
+        const supplied = percentage(total?.[key]);
+        if (supplied !== undefined)
+            return supplied;
+        const metrics = metricsByFile.map(file => file[key]);
+        if (metrics.length === 0 || !metrics.every(hasCounts))
+            return 0;
+        return ratio(metrics.reduce((sum, m) => sum + m.covered, 0), metrics.reduce((sum, m) => sum + m.total, 0));
+    };
+    // Sort by lowest line coverage
+    entries.sort((a, b) => a.lines - b.lines);
+    return {
+        found: entries.length > 0,
+        source,
+        entries,
+        summary: {
+            totalFiles: entries.length,
+            overallLineCoverage: aggregate('lines'),
+            overallBranchCoverage: aggregate('branches'),
+            overallFunctionCoverage: aggregate('functions'),
+            overallStatementCoverage: aggregate('statements'),
+        },
+    };
+}
+function parseLcovInfo(raw, source) {
+    const entries = [];
+    let currentFile = '';
+    let linesHit = 0, linesFound = 0;
+    let branchesHit = 0, branchesFound = 0;
+    let functionsHit = 0, functionsFound = 0;
+    let totalLH = 0, totalLF = 0, totalBH = 0, totalBF = 0, totalFH = 0, totalFF = 0;
+    const flushRecord = () => {
+        if (currentFile) {
+            // A corrupt record cannot report more hits than lines, or a negative count.
+            linesHit = Math.min(linesHit, linesFound);
+            branchesHit = Math.min(branchesHit, branchesFound);
+            functionsHit = Math.min(functionsHit, functionsFound);
+            totalLH += linesHit;
+            totalLF += linesFound;
+            totalBH += branchesHit;
+            totalBF += branchesFound;
+            totalFH += functionsHit;
+            totalFF += functionsFound;
+            entries.push({
+                filePath: currentFile,
+                lines: linesFound > 0 ? (linesHit / linesFound) * 100 : 100,
+                branches: branchesFound > 0 ? (branchesHit / branchesFound) * 100 : 100,
+                functions: functionsFound > 0 ? (functionsHit / functionsFound) * 100 : 100,
+                statements: linesFound > 0 ? (linesHit / linesFound) * 100 : 100,
+            });
+        }
+    };
+    for (const line of raw.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('SF:')) {
+            flushRecord();
+            currentFile = trimmed.slice(3);
+            linesHit = 0;
+            linesFound = 0;
+            branchesHit = 0;
+            branchesFound = 0;
+            functionsHit = 0;
+            functionsFound = 0;
+        }
+        else if (trimmed.startsWith('LH:')) {
+            linesHit = count(trimmed.slice(3));
+        }
+        else if (trimmed.startsWith('LF:')) {
+            linesFound = count(trimmed.slice(3));
+        }
+        else if (trimmed.startsWith('BRH:')) {
+            branchesHit = count(trimmed.slice(4));
+        }
+        else if (trimmed.startsWith('BRF:')) {
+            branchesFound = count(trimmed.slice(4));
+        }
+        else if (trimmed.startsWith('FNH:')) {
+            functionsHit = count(trimmed.slice(4));
+        }
+        else if (trimmed.startsWith('FNF:')) {
+            functionsFound = count(trimmed.slice(4));
+        }
+        else if (trimmed === 'end_of_record') {
+            flushRecord();
+            currentFile = '';
+        }
+    }
+    flushRecord();
+    entries.sort((a, b) => a.lines - b.lines);
+    return {
+        found: entries.length > 0,
+        source,
+        entries,
+        summary: {
+            totalFiles: entries.length,
+            overallLineCoverage: ratio(totalLH, totalLF),
+            overallBranchCoverage: ratio(totalBH, totalBF),
+            overallFunctionCoverage: ratio(totalFH, totalFF),
+            overallStatementCoverage: ratio(totalLH, totalLF),
+        },
+    };
+}
+/** A non-negative integer count; anything else in a report line is treated as 0. */
+function count(text) {
+    const n = parseInt(text, 10);
+    return Number.isFinite(n) && n > 0 ? n : 0;
+}
+function ratio(covered, total) {
+    return total > 0 ? covered / total * 100 : 100;
+}
+function hasCounts(metric) {
+    return typeof metric?.total === 'number' && Number.isFinite(metric.total) && metric.total >= 0
+        && typeof metric.covered === 'number' && Number.isFinite(metric.covered)
+        && metric.covered >= 0 && metric.covered <= metric.total;
+}
+function percentage(metric) {
+    if (typeof metric?.pct === 'number' && Number.isFinite(metric.pct)
+        && metric.pct >= 0 && metric.pct <= 100)
+        return metric.pct;
+    return hasCounts(metric) ? ratio(metric.covered, metric.total) : undefined;
+}
+/** Istanbul line coverage uses the maximum statement hit count on each start line. */
+function parseIstanbulCoverage(data, source) {
+    const summary = {};
+    for (const [filePath, value] of Object.entries(data)) {
+        const cov = value;
+        if (!cov || !cov.s || !cov.f || !cov.b || !cov.statementMap)
+            continue;
+        const lines = new Map();
+        for (const [id, hits] of Object.entries(cov.s)) {
+            const line = cov.statementMap[id]?.start?.line;
+            if (!Number.isInteger(line) || line < 1)
+                throw new Error('Invalid Istanbul statement location');
+            lines.set(line, Math.max(lines.get(line) ?? 0, hits));
+        }
+        const metric = (hits) => {
+            if (hits.some(n => !Number.isFinite(n) || n < 0))
+                throw new Error('Invalid Istanbul counter');
+            const covered = hits.filter(n => n > 0).length;
+            return { total: hits.length, covered, pct: ratio(covered, hits.length) };
+        };
+        summary[filePath] = { lines: metric([...lines.values()]), statements: metric(Object.values(cov.s)),
+            functions: metric(Object.values(cov.f)), branches: metric(Object.values(cov.b).flat()) };
+    }
+    return parseCoverageSummaryJson(summary, source);
+}
+//# sourceMappingURL=coverage-reader.js.map

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

@@ -1,10 +1,14 @@
+/**
+ * V3 CLI Hooks Command
+ * Self-learning hooks system for intelligent workflow automation
+ */
 import { validateFeedbackPatterns } from '../memory/feedback-patterns.js';
+import { readCoverageFromDisk } from './coverage-reader.js';
 import { output } from '../output.js';
 import { confirm } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import { storeCommand } from './transfer-store.js';
-import { existsSync, readFileSync, statSync } from 'node:fs';
-import { join } from 'node:path';
+import { readFileSync, statSync } from 'node:fs';
 import { getSecurityStatus as sharedGetSecurityStatus, getSwarmStatus as sharedGetSwarmStatus, getGitUncommittedCount as sharedGetGitUncommittedCount, } from '../funnel/local-signals.js';
 /**
  * #1686 — `?? 0` only defaults null/undefined; NaN slips through and
@@ -16,181 +20,6 @@ function safeNum(value, fallback = 0) {
     const n = typeof value === 'number' ? value : Number(value);
     return Number.isFinite(n) ? n : fallback;
 }
-/**
- * Read coverage data from disk. Checks these locations in order:
- * 1. coverage/coverage-summary.json (Jest/Istanbul)
- * 2. coverage/lcov.info (lcov format)
- * 3. .nyc_output/out.json (nyc)
- */
-function readCoverageFromDisk() {
-    const cwd = process.cwd();
-    const noData = {
-        found: false,
-        source: 'none',
-        entries: [],
-        summary: { totalFiles: 0, overallLineCoverage: 0, overallBranchCoverage: 0, overallFunctionCoverage: 0, overallStatementCoverage: 0 },
-    };
-    // 1. Try coverage-summary.json (Jest/Istanbul)
-    for (const relPath of ['coverage/coverage-summary.json', 'coverage-summary.json']) {
-        const summaryPath = join(cwd, relPath);
-        if (existsSync(summaryPath)) {
-            try {
-                const raw = JSON.parse(readFileSync(summaryPath, 'utf-8'));
-                return parseCoverageSummaryJson(raw, relPath);
-            }
-            catch {
-                // malformed, try next
-            }
-        }
-    }
-    // 2. Try lcov.info
-    for (const relPath of ['coverage/lcov.info', 'lcov.info']) {
-        const lcovPath = join(cwd, relPath);
-        if (existsSync(lcovPath)) {
-            try {
-                const raw = readFileSync(lcovPath, 'utf-8');
-                return parseLcovInfo(raw, relPath);
-            }
-            catch {
-                // malformed, try next
-            }
-        }
-    }
-    // 3. Try .nyc_output/out.json
-    const nycPath = join(cwd, '.nyc_output', 'out.json');
-    if (existsSync(nycPath)) {
-        try {
-            const raw = JSON.parse(readFileSync(nycPath, 'utf-8'));
-            return parseCoverageSummaryJson(raw, '.nyc_output/out.json');
-        }
-        catch {
-            // malformed
-        }
-    }
-    return noData;
-}
-function parseCoverageSummaryJson(data, source) {
-    const entries = [];
-    let totalLines = 0, coveredLines = 0;
-    let totalBranches = 0, coveredBranches = 0;
-    let totalFunctions = 0, coveredFunctions = 0;
-    let totalStatements = 0, coveredStatements = 0;
-    for (const [filePath, metrics] of Object.entries(data)) {
-        if (filePath === 'total')
-            continue;
-        const m = metrics;
-        if (!m || typeof m !== 'object')
-            continue;
-        const linePct = m.lines?.pct ?? m.lines?.covered != null ? ((m.lines?.covered ?? 0) / Math.max(m.lines?.total ?? 1, 1)) * 100 : 0;
-        const branchPct = m.branches?.pct ?? (m.branches?.total ? ((m.branches?.covered ?? 0) / m.branches.total) * 100 : 100);
-        const funcPct = m.functions?.pct ?? (m.functions?.total ? ((m.functions?.covered ?? 0) / m.functions.total) * 100 : 100);
-        const stmtPct = m.statements?.pct ?? (m.statements?.total ? ((m.statements?.covered ?? 0) / m.statements.total) * 100 : 100);
-        entries.push({ filePath, lines: linePct, branches: branchPct, functions: funcPct, statements: stmtPct });
-        totalLines += m.lines?.total ?? 0;
-        coveredLines += m.lines?.covered ?? 0;
-        totalBranches += m.branches?.total ?? 0;
-        coveredBranches += m.branches?.covered ?? 0;
-        totalFunctions += m.functions?.total ?? 0;
-        coveredFunctions += m.functions?.covered ?? 0;
-        totalStatements += m.statements?.total ?? 0;
-        coveredStatements += m.statements?.covered ?? 0;
-    }
-    // Also read the total key if present
-    const total = data['total'];
-    const overallLine = total?.lines?.pct ?? (totalLines > 0 ? (coveredLines / totalLines) * 100 : 0);
-    const overallBranch = total?.branches?.pct ?? (totalBranches > 0 ? (coveredBranches / totalBranches) * 100 : 0);
-    const overallFunction = total?.functions?.pct ?? (totalFunctions > 0 ? (coveredFunctions / totalFunctions) * 100 : 0);
-    const overallStatement = total?.statements?.pct ?? (totalStatements > 0 ? (coveredStatements / totalStatements) * 100 : 0);
-    // Sort by lowest line coverage
-    entries.sort((a, b) => a.lines - b.lines);
-    return {
-        found: true,
-        source,
-        entries,
-        summary: {
-            totalFiles: entries.length,
-            overallLineCoverage: overallLine,
-            overallBranchCoverage: overallBranch,
-            overallFunctionCoverage: overallFunction,
-            overallStatementCoverage: overallStatement,
-        },
-    };
-}
-function parseLcovInfo(raw, source) {
-    const entries = [];
-    let currentFile = '';
-    let linesHit = 0, linesFound = 0;
-    let branchesHit = 0, branchesFound = 0;
-    let functionsHit = 0, functionsFound = 0;
-    const flushRecord = () => {
-        if (currentFile) {
-            entries.push({
-                filePath: currentFile,
-                lines: linesFound > 0 ? (linesHit / linesFound) * 100 : 0,
-                branches: branchesFound > 0 ? (branchesHit / branchesFound) * 100 : 100,
-                functions: functionsFound > 0 ? (functionsHit / functionsFound) * 100 : 100,
-                statements: linesFound > 0 ? (linesHit / linesFound) * 100 : 0,
-            });
-        }
-    };
-    for (const line of raw.split('\n')) {
-        const trimmed = line.trim();
-        if (trimmed.startsWith('SF:')) {
-            currentFile = trimmed.slice(3);
-            linesHit = 0;
-            linesFound = 0;
-            branchesHit = 0;
-            branchesFound = 0;
-            functionsHit = 0;
-            functionsFound = 0;
-        }
-        else if (trimmed.startsWith('LH:')) {
-            linesHit = parseInt(trimmed.slice(3), 10) || 0;
-        }
-        else if (trimmed.startsWith('LF:')) {
-            linesFound = parseInt(trimmed.slice(3), 10) || 0;
-        }
-        else if (trimmed.startsWith('BRH:')) {
-            branchesHit = parseInt(trimmed.slice(4), 10) || 0;
-        }
-        else if (trimmed.startsWith('BRF:')) {
-            branchesFound = parseInt(trimmed.slice(4), 10) || 0;
-        }
-        else if (trimmed.startsWith('FNH:')) {
-            functionsHit = parseInt(trimmed.slice(4), 10) || 0;
-        }
-        else if (trimmed.startsWith('FNF:')) {
-            functionsFound = parseInt(trimmed.slice(4), 10) || 0;
-        }
-        else if (trimmed === 'end_of_record') {
-            flushRecord();
-            currentFile = '';
-        }
-    }
-    flushRecord();
-    entries.sort((a, b) => a.lines - b.lines);
-    let totalLH = 0, totalLF = 0, totalBH = 0, totalBF = 0;
-    for (const e of entries) {
-        // Approximate from percentages (we lost exact counts after flush, but summaries are okay)
-        totalLH += e.lines;
-        totalLF += 100;
-        totalBH += e.branches;
-        totalBF += 100;
-    }
-    const n = entries.length || 1;
-    return {
-        found: true,
-        source,
-        entries,
-        summary: {
-            totalFiles: entries.length,
-            overallLineCoverage: totalLH / n,
-            overallBranchCoverage: totalBH / n,
-            overallFunctionCoverage: 0,
-            overallStatementCoverage: totalLH / n,
-        },
-    };
-}
 /**
  * Classify a coverage gap by priority type based on coverage percentage and threshold
  */
@@ -2996,7 +2825,7 @@ const coverageRouteCommand = {
                 'c8:       npx c8 npm test',
             ]);
             output.writeln();
-            output.writeln(output.dim('Expected files: coverage/coverage-summary.json, coverage/lcov.info, or .nyc_output/out.json'));
+            output.writeln(output.dim('Expected files: coverage/coverage-summary.json, coverage/lcov.info, coverage/coverage-final.json, or .nyc_output/out.json'));
             return { success: false, exitCode: 1 };
         }
     }
@@ -3187,7 +3016,7 @@ const coverageSuggestCommand = {
                 'c8:       npx c8 npm test',
             ]);
             output.writeln();
-            output.writeln(output.dim('Expected files: coverage/coverage-summary.json, coverage/lcov.info, or .nyc_output/out.json'));
+            output.writeln(output.dim('Expected files: coverage/coverage-summary.json, coverage/lcov.info, coverage/coverage-final.json, or .nyc_output/out.json'));
             return { success: false, exitCode: 1 };
         }
     }
@@ -3407,7 +3236,7 @@ const coverageGapsCommand = {
                 'c8:       npx c8 npm test',
             ]);
             output.writeln();
-            output.writeln(output.dim('Expected files: coverage/coverage-summary.json, coverage/lcov.info, or .nyc_output/out.json'));
+            output.writeln(output.dim('Expected files: coverage/coverage-summary.json, coverage/lcov.info, coverage/coverage-final.json, or .nyc_output/out.json'));
             return { success: false, exitCode: 1 };
         }
     }

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

@@ -9,7 +9,7 @@
  * a one-line hint and exit 2, unless --plain asks for one frame as plain text and exit 0 (ADR-489 decision E).
  *
  *   npx ruflo tui                 # interactive, in a terminal
- *   npx ruflo tui --view swarm    # start on the Swarm page (keys 1-5 or o c s e m switch pages)
+ *   npx ruflo tui --view swarm    # start on the Swarm page (keys 1-6 or o c s e m a switch pages)
  *   npx ruflo tui --plain | head  # one plain frame, exit 0 (scripts, CI)
  *   npx ruflo tui | cat           # not a terminal and no --plain: a hint on stderr, exit 2
  */
@@ -55,7 +55,7 @@ export const tuiCommand = {
     ],
     examples: [
         { command: 'npx ruflo tui', description: 'Open the console in this terminal' },
-        { command: 'npx ruflo tui --view swarm', description: 'Start on the Swarm page (keys 1-5 switch pages, tab cycles, q quits)' },
+        { command: 'npx ruflo tui --view swarm', description: 'Start on the Swarm page (keys 1-6 switch pages, tab cycles, q quits)' },
         { command: 'npx ruflo tui --view ai --model openai/gpt-4o-mini --max-spend-usd 0.1', description: 'The AI page on a cheap OpenRouter model, stopping at $0.10 reported (key in $OPENROUTER_API_KEY, never shown)' },
         { command: 'npx ruflo tui --plain | head -40', description: 'One plain frame, exit 0: for scripts and CI (no terminal needed)' },
     ],