@claude-flow/cli 3.56.7 → 3.56.8

package/.claude/helpers/helpers.manifest.json

@@ -1,6 +1,6 @@
 {
   "manifest": {
-    "version": "3.56.7",
+    "version": "3.56.8",
     "files": {
       "auto-memory-hook.mjs": "631fac9d518835e2852a406888316bbbddddb49e7ed8e406d2e971f46833df9a",
       "hook-handler.cjs": "0f855c667b8d2d04cb4fe91b14b351d14c3dfb30516dcd9d7ae156acbe0a689d",
@@ -9,6 +9,6 @@
       "router.cjs": "16648b3c0d73b6681ac2d8d13def6a68286c57f5a11004de5b19a0fa088c833d"
     }
   },
-  "signature": "15NFpUZ8+naP4v/xuCBCl7IZ//YJPXQYotOg48V/Xw/uyCY1FXYeeL4a3Rwa+Bji0+CV4FRiZg61N6Zt+EStBg==",
+  "signature": "ld9RNoF9lnGKjlUpofQLwCZgtE9Y5QiNNkYZLGsSQhZGp51JhBnHymH9YWpFC3F1HBslxRnea6U2TVczJKK5Bg==",
   "algorithm": "ed25519"
 }

package/README.md

@@ -49,6 +49,10 @@ npx -y ruflo@latest mcp start
 
 MCP exposes Ruflo tools to your client. The console and mods above are Claude Code integrations; hook support depends on the client.
 
+<img src="docs/assets/readme/icons/terminal.svg" width="28" height="28" alt=""> **Prefer a plain terminal? Optional.** The console also runs on its own, with no Claude Code: `npx ruflo tui` (add `--plain` to print one frame for scripts). It shows Overview, Cost, Swarm, Events and Missions, plus an optional AI page. [Terminal UI guide](docs/USERGUIDE.md#terminal-ui-optional)
+
+<p align="center"><img src="docs/assets/ruflo-tui-compact.svg" width="640" alt="Looping recording of the optional ruflo terminal UI cycling through Overview, Cost, Swarm, Events and Missions in a sample project"></p>
+
 [Compare install paths](#quick-start) · [Open the console](#console-walkthrough) · [User guide](docs/USERGUIDE.md)
 
 <div align="center">
@@ -116,9 +120,11 @@ User → Ruflo (CLI/MCP) → Router → Swarm → Agents → Memory → LLM prov
 
 <p align="center"><img src="docs/assets/readme/console.svg" alt="Mission control: inspect agent work" width="100%"></p>
 
-<p align="center"><img src="docs/assets/ruflo-console-workflows.svg" width="952" height="964" alt="An animated recording of the ruflo console inside Claude Code: the boot (the neon sign and every area checked), then the Workflows page on a sample run: phases and agents with model, tokens and time; drilling from a run into one agent's activity, log and result; search; failure triage; cost; replay and compare; the control tab with a confirm card; and the mission autopilot panel"></p>
+<p align="center"><a href="https://raw.githubusercontent.com/ruvnet/ruflo/main/docs/assets/ruflo-console-theme-compact.svg"><img src="docs/assets/ruflo-console-theme-compact.svg" width="100%" alt="Ruflo Orbital theme: animated boot checks, block logo, menu icons, rotating globe, swarm routing, six color palettes and responsive Theme Studio"></a></p>
+
+[Open animated demo](https://raw.githubusercontent.com/ruvnet/ruflo/main/docs/assets/ruflo-console-theme-compact.svg) · [Theme Studio guide](plugins/ruflo-console/README.md) · [Workflow demo](docs/assets/ruflo-console-workflows.svg)
 
-<img src="docs/assets/readme/console-icon-workflows.svg" width="28" height="28" alt=""> **Your agent cockpit.** Track workflows, agents, models, tokens and cost beside Claude Code. The animation shows startup checks and a **sample workflow**, not a live session.
+<img src="docs/assets/readme/console-icon-workflows.svg" width="28" height="28" alt=""> **Your agent cockpit.** Track workflows, agents, models, tokens and cost beside Claude Code. The 38 second animation shows **Orbital and Theme Studio** through actual renderer frames, including boot checks, six palettes, customization, saved themes, JSON import and resizing. This compact 3.84 MB SVG retains all 456 frames. Native host and AI provider execution are not demonstrated.
 
 <img src="docs/assets/readme/console-icon-inspect.svg" width="28" height="28" alt=""> **Inspect any run.** Open agent logs and results, search, triage failures, replay and compare. Start with `npx ruflo init`, restart Claude Code, then `/ruflo`. [Full console tour](docs/assets/ruflo-console-walkthrough-wide.gif).
 
@@ -136,7 +142,7 @@ User → Ruflo (CLI/MCP) → Router → Swarm → Agents → Memory → LLM prov
 4. **Verify the result.** Check that Missions contains the goal and Overview records the action. Creating a mission does not mean the feature has been implemented.
 5. **Keep control.** **Take back control** pauses Claude's console tools. A later call should be refused until you restore control.
 
-**What the recording demonstrates:** a real Claude Haiku session with `write + auto`, mission creation, page navigation, a refused swarm stop, and control being taken back. The steps above use `ask` so you approve creation yourself. The separate workflow animation uses sample data; neither is evidence of completed swarm work or memory recall.
+**What the recording demonstrates:** a real Claude Haiku session with `write + auto`, mission creation, page navigation, a refused swarm stop, and control being taken back. The steps above use `ask` so you approve creation yourself. The linked workflow animation uses sample data, while the theme demo replays renderer frames. Neither is evidence of completed swarm work or memory recall.
 
 [Implementation and recorded test findings](v3/docs/adr/ADR-444-claude-controls-the-console.md) · [Reproduction script](plugins/ruflo-console/scripts/e2e-control.sh)
 

package/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 7,
-  "generatedAt": "2026-10-11T22:43:38.354Z",
-  "gitSha": "aac16fbd",
+  "generatedAt": "2026-10-12T17:29:00.623Z",
+  "gitSha": "4f1b3e96",
   "catalog": {
     "agents": 176,
     "tools": 423,

package/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/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/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/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)' },
     ],

package/dist/src/services/policy-ledger-anchor.js

@@ -14,10 +14,28 @@
 import { createHash } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, realpathSync } from 'node:fs';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
-import { homedir } from 'node:os';
+import { homedir, userInfo } from 'node:os';
 const LOG_FILE = 'ledger-anchors.json';
 const MIRROR_FILE = 'ledger-anchor-head.json';
 export const anchorLogPath = (projectRoot) => join(resolve(projectRoot), '.claude-flow', 'policy', LOG_FILE);
+/**
+ * The home directory trust material lives under: $HOME when it is an absolute path, else the account's home. An empty or relative
+ * $HOME (an unset variable in a wrapper script, `HOME=. cmd`) would make join() yield a path relative to the working directory and
+ * drop the HMAC key and anchor mirror into the project; that is never wanted, so it falls back to the account home or refuses.
+ */
+function trustHome() {
+    const home = homedir();
+    if (home && isAbsolute(home))
+        return home;
+    let account = '';
+    try {
+        account = userInfo().homedir;
+    }
+    catch { /* no account entry for this uid */ }
+    if (account && isAbsolute(account))
+        return account;
+    throw new Error('policy-trust-home-unresolved: $HOME is empty or relative and this account has no home directory; set HOME to an absolute path');
+}
 /**
  * Directory holding per-project trust material (anchor mirror, HMAC key).
  * Resolved from the environment at call time (#3919): $XDG_CONFIG_HOME when it
@@ -26,7 +44,7 @@ export const anchorLogPath = (projectRoot) => join(resolve(projectRoot), '.claud
  * user who already has trust state under the legacy ~/.config keeps using it.
  */
 export function policyTrustRoot() {
-    const legacy = join(homedir(), '.config', 'ruflo', 'policy-trust');
+    const legacy = join(trustHome(), '.config', 'ruflo', 'policy-trust');
     const xdg = process.env.XDG_CONFIG_HOME;
     if (!xdg || !isAbsolute(xdg))
         return legacy;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.56.7",
+  "version": "3.56.8",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",
@@ -104,7 +104,7 @@
     "@claude-flow/neural": "3.0.0",
     "@claude-flow/plugin-agent-federation": "1.0.1",
     "@claude-flow/security": "3.0.4",
-    "@claude-flow/shared": "3.0.3",
+    "@claude-flow/shared": "3.0.4",
     "@iarna/toml": "^2.2.5",
     "@noble/ed25519": "2.3.0",
     "@ruvector/rabitq-wasm": "0.1.0",