swarmdo 1.18.0 → 1.19.0

package/.claude/helpers/statusline.cjs

@@ -515,7 +515,7 @@ function getCostFromStdin() {
 // misses, the displayed version is meaningful (matches what the user
 // installed), not a stale hard-coded string.
 function getPkgVersion() {
-  let ver = '1.18.0';
+  let ver = '1.19.0';
   try {
     const home = os.homedir();
     const pkgPaths = [

package/README.md

@@ -2,7 +2,7 @@
 
 [![swarmdo](swarmdo/assets/brand/logo-full.svg)](https://swarmdo.com)
 
-[![npm version (swarmdo)](https://img.shields.io/badge/npx%20swarmdo-v1.18.0-cb3837?style=for-the-badge&logo=npm&logoColor=white)](https://github.com/SwarmDo/swarmdo/releases)
+[![npm version (swarmdo)](https://img.shields.io/badge/npx%20swarmdo-v1.19.0-cb3837?style=for-the-badge&logo=npm&logoColor=white)](https://github.com/SwarmDo/swarmdo/releases)
 [![MIT License](https://img.shields.io/badge/License-MIT-yellow?style=for-the-badge)](https://github.com/SwarmDo/swarmdo/blob/main/LICENSE)
 [![Website](https://img.shields.io/badge/swarmdo.com-e2a33c?style=for-the-badge&logoColor=black)](https://swarmdo.com)
 [![Star on GitHub](https://img.shields.io/github/stars/SwarmDo/swarmdo?style=for-the-badge&logo=github&color=gold)](https://github.com/SwarmDo/swarmdo)
@@ -287,6 +287,7 @@ The recent release train added a full day-to-day operations layer around the swa
 | `swarmdo hotspots` | **Change-risk hotspots from git history** — rank files by churn × recency × author-spread to surface the technical debt worth refactoring or testing, answered from data instead of a guess. `--since 90d`, `--by risk\|churn\|commits\|authors`, `--top N`, `--format json`. Pairs with `codegraph`; also an MCP tool (`hotspots`). Deterministic |
 | `swarmdo affected` | **Run only the tests your change touches** — from a git diff, walk `codegraph`'s import graph to list every file (and test file) a change could break (reverse-dependency closure, nx/turbo/`jest --findRelatedTests` style). `--base main`, `--tests` (pipeable list), `--format json`. Also an MCP tool (`affected`). Deterministic |
 | `swarmdo cycles` | **Find circular import dependencies** — an SCC scan over `codegraph`'s import graph surfaces the mutually-importing file groups (and self-imports) that cause temporal-dead-zone and `undefined`-export bugs, `madge --circular` style. `--ci` exits 1 on any cycle to gate a build; `--format json`. Also an MCP tool (`cycles`). Deterministic |
+| `swarmdo testreport` | **JUnit/TAP → failure digest** — turn raw test-result files into the exact failing test names + `file:line` + assertion messages, instead of scanning hundreds of log lines. The front-half of the test→fix loop: feed the failures straight into `repair`. Reads a file, a directory, or stdin; `--ci` exits 1 on any failure, `--format json`. Also an MCP tool (`testreport`). Deterministic |
 | `swarmdo integrations` (alias `integrate`) | **Use swarmdo from Codex CLI, GitHub Copilot CLI, and pi** — one command wires AGENTS.md + each CLI's MCP config (idempotent, dry-run first, never touches your Claude Code setup) |
 | OpenRouter model pool | **Let swarms pick from any models you configure** — declare tier-mapped OpenRouter models in `swarmdo.config.json`; the router Thompson-samples among them per task and the execution layer dispatches the winner |
 | `swarmdo changelog` (alias `notes`) | **Release notes from conventional commits** — `--out NOTES.md` feeds `gh release create --notes-file` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swarmdo",
-  "version": "1.18.0",
+  "version": "1.19.0",
   "description": "Swarmdo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/v3/@swarmdo/cli/dist/src/commands/index.js

@@ -50,6 +50,9 @@ const commandLoaders = {
     // Circular-import detector (madge --circular demand) — SCC scan over
     // codegraph's import graph; catches TDZ/undefined-export bugs.
     cycles: () => import('./cycles.js'),
+    // JUnit/TAP test-result parser (dorny/test-reporter demand) — raw results →
+    // failing test + file:line + message; the front-half of the test→fix loop.
+    testreport: () => import('./testreport.js'),
     // Queryable exported-symbol index (codegraph demand) — where things are
     // defined without grep+read round-trips.
     codegraph: () => import('./codegraph.js'),
@@ -283,7 +286,7 @@ export async function getCommandsByCategory() {
     // three slots from 'statusline' onward (completionsCmd received the
     // statusline module, analyzeCmd received completions, …), scrambling the
     // categorized help. Every load now has a named slot.
-    const [daemonCmd, doctorCmd, embeddingsCmd, neuralCmd, performanceCmd, securityCmd, swarmvectorCmd, hiveMindCmd, configCmd, statuslineCmd, compressCmd, efficiencyCmd, completionsCmd, migrateCmd, workflowCmd, analyzeCmd, routeCmd, progressCmd, providersCmd, pluginsCmd, deploymentCmd, claimsCmd, issuesCmd, updateCmd, processCmd, guidanceCmd, applianceCmd, cleanupCmd, autopilotCmd, demoCmd, usageCmd, repairCmd, hudCmd, compactCmd, codegraphCmd, redactCmd, packCmd, envCmd, licenseCmd, sbomCmd, applyCmd, hotspotsCmd, affectedCmd, cyclesCmd,] = await Promise.all([
+    const [daemonCmd, doctorCmd, embeddingsCmd, neuralCmd, performanceCmd, securityCmd, swarmvectorCmd, hiveMindCmd, configCmd, statuslineCmd, compressCmd, efficiencyCmd, completionsCmd, migrateCmd, workflowCmd, analyzeCmd, routeCmd, progressCmd, providersCmd, pluginsCmd, deploymentCmd, claimsCmd, issuesCmd, updateCmd, processCmd, guidanceCmd, applianceCmd, cleanupCmd, autopilotCmd, demoCmd, usageCmd, repairCmd, hudCmd, compactCmd, codegraphCmd, redactCmd, packCmd, envCmd, licenseCmd, sbomCmd, applyCmd, hotspotsCmd, affectedCmd, cyclesCmd, testreportCmd,] = await Promise.all([
         loadCommand('daemon'), loadCommand('doctor'), loadCommand('embeddings'), loadCommand('neural'),
         loadCommand('performance'), loadCommand('security'), loadCommand('swarmvector'), loadCommand('hive-mind'),
         loadCommand('config'), loadCommand('statusline'), loadCommand('compress'), loadCommand('efficiency'),
@@ -291,7 +294,7 @@ export async function getCommandsByCategory() {
         loadCommand('analyze'), loadCommand('route'), loadCommand('progress'), loadCommand('providers'),
         loadCommand('plugins'), loadCommand('deployment'), loadCommand('claims'), loadCommand('issues'),
         loadCommand('update'), loadCommand('process'), loadCommand('guidance'), loadCommand('appliance'),
-        loadCommand('cleanup'), loadCommand('autopilot'), loadCommand('demo'), loadCommand('usage'), loadCommand('repair'), loadCommand('hud'), loadCommand('compact'), loadCommand('codegraph'), loadCommand('redact'), loadCommand('pack'), loadCommand('env'), loadCommand('license'), loadCommand('sbom'), loadCommand('apply'), loadCommand('hotspots'), loadCommand('affected'), loadCommand('cycles'),
+        loadCommand('cleanup'), loadCommand('autopilot'), loadCommand('demo'), loadCommand('usage'), loadCommand('repair'), loadCommand('hud'), loadCommand('compact'), loadCommand('codegraph'), loadCommand('redact'), loadCommand('pack'), loadCommand('env'), loadCommand('license'), loadCommand('sbom'), loadCommand('apply'), loadCommand('hotspots'), loadCommand('affected'), loadCommand('cycles'), loadCommand('testreport'),
     ]);
     return {
         primary: [
@@ -307,7 +310,7 @@ export async function getCommandsByCategory() {
         utility: [
             configCmd, doctorCmd, daemonCmd, completionsCmd,
             migrateCmd, workflowCmd, demoCmd,
-            statuslineCmd, compressCmd, compactCmd, redactCmd, packCmd, envCmd, licenseCmd, sbomCmd, applyCmd, hotspotsCmd, affectedCmd, cyclesCmd, efficiencyCmd,
+            statuslineCmd, compressCmd, compactCmd, redactCmd, packCmd, envCmd, licenseCmd, sbomCmd, applyCmd, hotspotsCmd, affectedCmd, cyclesCmd, testreportCmd, efficiencyCmd,
         ].filter(Boolean),
         analysis: [
             analyzeCmd, routeCmd, progressCmd, usageCmd, hudCmd, codegraphCmd,

package/v3/@swarmdo/cli/dist/src/commands/testreport.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `swarmdo testreport` — parse JUnit-XML / TAP results into a failure digest.
+ *
+ *   swarmdo testreport junit.xml           # human digest
+ *   swarmdo testreport ./reports           # scan a dir for *.xml/*.tap
+ *   vitest --reporter=junit | swarmdo testreport   # from stdin
+ *   swarmdo testreport junit.xml --format json     # machine output
+ *   swarmdo testreport junit.xml --ci              # exit 1 if any failed
+ *
+ * The front-half of the test→fix loop: turn raw results into exact failing
+ * test + file:line + message, then hand it to `repair`. Engine
+ * (../testreport/testreport.ts) is pure + tested; this reads files.
+ */
+import type { Command } from '../types.js';
+export declare const testreportCommand: Command;
+export default testreportCommand;
+//# sourceMappingURL=testreport.d.ts.map

package/v3/@swarmdo/cli/dist/src/commands/testreport.js

@@ -0,0 +1,119 @@
+/**
+ * `swarmdo testreport` — parse JUnit-XML / TAP results into a failure digest.
+ *
+ *   swarmdo testreport junit.xml           # human digest
+ *   swarmdo testreport ./reports           # scan a dir for *.xml/*.tap
+ *   vitest --reporter=junit | swarmdo testreport   # from stdin
+ *   swarmdo testreport junit.xml --format json     # machine output
+ *   swarmdo testreport junit.xml --ci              # exit 1 if any failed
+ *
+ * The front-half of the test→fix loop: turn raw results into exact failing
+ * test + file:line + message, then hand it to `repair`. Engine
+ * (../testreport/testreport.ts) is pure + tested; this reads files.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { output } from '../output.js';
+import { parseTestReport, detectFormat, mergeSummaries, formatSummary, } from '../testreport/testreport.js';
+function readStdin() {
+    return new Promise((resolve) => {
+        const chunks = [];
+        process.stdin.on('data', (c) => chunks.push(Buffer.from(c)));
+        process.stdin.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        process.stdin.on('error', () => resolve(Buffer.concat(chunks).toString('utf8')));
+    });
+}
+/** Expand path args into a list of result files (dirs → their *.xml/*.tap). */
+function collectFiles(root, args) {
+    const files = [];
+    for (const a of args) {
+        const abs = path.resolve(root, a);
+        let st;
+        try {
+            st = fs.statSync(abs);
+        }
+        catch {
+            continue;
+        }
+        if (st.isDirectory()) {
+            for (const entry of fs.readdirSync(abs)) {
+                if (/\.(xml|tap)$/i.test(entry))
+                    files.push(path.join(abs, entry));
+            }
+        }
+        else {
+            files.push(abs);
+        }
+    }
+    return files;
+}
+function numFlag(v, def) {
+    const n = typeof v === 'number' ? v : typeof v === 'string' ? parseInt(v, 10) : NaN;
+    return Number.isFinite(n) ? n : def;
+}
+async function run(ctx) {
+    const root = ctx.cwd || process.cwd();
+    const asJson = ctx.flags.format === 'json';
+    const ci = ctx.flags.ci === true;
+    const top = numFlag(ctx.flags.top, 0);
+    // NB: --type, not --format (global --format is choices-validated to text|json|table).
+    const typeOverride = typeof ctx.flags.type === 'string' ? ctx.flags.type : undefined;
+    if (typeOverride && typeOverride !== 'junit' && typeOverride !== 'tap') {
+        output.printError(`unknown --type '${typeOverride}' (use junit|tap)`);
+        return { success: false, exitCode: 1 };
+    }
+    let summary;
+    if (ctx.args.length === 0) {
+        if (process.stdin.isTTY) {
+            output.writeln(output.error('Usage: swarmdo testreport <file|dir>   OR   <runner> | swarmdo testreport'));
+            return { success: false, exitCode: 1 };
+        }
+        const content = await readStdin();
+        const fmt = typeOverride ?? detectFormat(content);
+        summary = parseTestReport(content, fmt);
+    }
+    else {
+        const files = collectFiles(root, ctx.args);
+        if (files.length === 0) {
+            output.printError('no test-result files found (looked for *.xml / *.tap)');
+            return { success: false, exitCode: 1 };
+        }
+        const summaries = [];
+        for (const f of files) {
+            let content;
+            try {
+                content = fs.readFileSync(f, 'utf8');
+            }
+            catch {
+                continue;
+            }
+            const fmt = typeOverride ?? detectFormat(content, f);
+            summaries.push(parseTestReport(content, fmt));
+        }
+        summary = mergeSummaries(summaries);
+    }
+    if (asJson) {
+        process.stdout.write(JSON.stringify(summary, null, 2) + '\n');
+    }
+    else {
+        output.writeln(formatSummary(summary, { top: top > 0 ? top : undefined }));
+    }
+    const code = ci && summary.failed > 0 ? 1 : 0;
+    return { success: code === 0, exitCode: code };
+}
+export const testreportCommand = {
+    name: 'testreport',
+    description: 'Parse JUnit-XML / TAP test results into a compact failure digest (test name + file:line + message) — the front-half of the test→fix loop',
+    options: [
+        { name: 'type', description: 'force input format: junit|tap (default: auto-detect)', type: 'string' },
+        { name: 'top', description: 'show only the first N failures', type: 'string' },
+        { name: 'ci', description: 'exit 1 if any test failed', type: 'boolean' },
+    ],
+    examples: [
+        { command: 'swarmdo testreport junit.xml', description: 'Digest a JUnit report' },
+        { command: 'vitest --reporter=junit | swarmdo testreport --ci', description: 'Parse from stdin, fail on any failure' },
+    ],
+    action: run,
+};
+export default testreportCommand;
+//# sourceMappingURL=testreport.js.map

package/v3/@swarmdo/cli/dist/src/mcp-client.js

@@ -27,6 +27,7 @@ import { applyTools } from './mcp-tools/apply-tools.js';
 import { hotspotsTools } from './mcp-tools/hotspots-tools.js';
 import { affectedTools } from './mcp-tools/affected-tools.js';
 import { cyclesTools } from './mcp-tools/cycles-tools.js';
+import { testreportTools } from './mcp-tools/testreport-tools.js';
 import { progressTools } from './mcp-tools/progress-tools.js';
 import { embeddingsTools } from './mcp-tools/embeddings-tools.js';
 import { claimsTools } from './mcp-tools/claims-tools.js';
@@ -118,6 +119,7 @@ const TOOL_GROUPS = {
     hotspots: () => hotspotsTools,
     affected: () => affectedTools,
     cycles: () => cyclesTools,
+    testreport: () => testreportTools,
     progress: () => progressTools,
     embeddings: () => embeddingsTools,
     claims: () => claimsTools,

package/v3/@swarmdo/cli/dist/src/mcp-tools/index.d.ts

@@ -23,6 +23,7 @@ export { applyTools } from './apply-tools.js';
 export { hotspotsTools } from './hotspots-tools.js';
 export { affectedTools } from './affected-tools.js';
 export { cyclesTools } from './cycles-tools.js';
+export { testreportTools } from './testreport-tools.js';
 export { progressTools } from './progress-tools.js';
 export { transferTools } from './transfer-tools.js';
 export { securityTools } from './security-tools.js';

package/v3/@swarmdo/cli/dist/src/mcp-tools/index.js

@@ -22,6 +22,7 @@ export { applyTools } from './apply-tools.js';
 export { hotspotsTools } from './hotspots-tools.js';
 export { affectedTools } from './affected-tools.js';
 export { cyclesTools } from './cycles-tools.js';
+export { testreportTools } from './testreport-tools.js';
 export { progressTools } from './progress-tools.js';
 export { transferTools } from './transfer-tools.js';
 export { securityTools } from './security-tools.js';

package/v3/@swarmdo/cli/dist/src/mcp-tools/profiles.js

@@ -29,6 +29,7 @@ const LEAN_GROUPS = [
     'hotspots', // hotspots — git-history change-risk ranking ("where's the debt?")
     'affected', // affected — impacted files/tests from a change via the import graph
     'cycles', // cycles — circular-import detection via the import graph
+    'testreport', // testreport — JUnit/TAP → structured failure digest (pairs w/ repair)
 ];
 /** Balanced = lean + orchestration/session/system the average user reaches for. */
 const BALANCED_EXTRA = [

package/v3/@swarmdo/cli/dist/src/mcp-tools/testreport-tools.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Testreport MCP Tool
+ *
+ * Let an agent turn raw JUnit/TAP test output into a structured failure digest —
+ * exact failing test + file:line + message — instead of re-reading hundreds of
+ * log lines. The front-half of the test→fix loop: pair with `repair`. Shares the
+ * pure parser in ../testreport/testreport.ts with the CLI; string-in/JSON-out.
+ */
+import type { MCPTool } from './types.js';
+export declare const testreportTools: MCPTool[];
+//# sourceMappingURL=testreport-tools.d.ts.map

package/v3/@swarmdo/cli/dist/src/mcp-tools/testreport-tools.js

@@ -0,0 +1,33 @@
+/**
+ * Testreport MCP Tool
+ *
+ * Let an agent turn raw JUnit/TAP test output into a structured failure digest —
+ * exact failing test + file:line + message — instead of re-reading hundreds of
+ * log lines. The front-half of the test→fix loop: pair with `repair`. Shares the
+ * pure parser in ../testreport/testreport.ts with the CLI; string-in/JSON-out.
+ */
+import { parseTestReport, detectFormat } from '../testreport/testreport.js';
+const testreportTool = {
+    name: 'testreport',
+    description: 'Parse JUnit-XML or TAP test output into a structured summary: {passed, failed, skipped, total, durationMs, failures:[{suite,name,file,line,message}]}. Call this on a results file/string to get the exact failing tests + file:line instead of scanning logs; feed the failures into `repair`. Deterministic; auto-detects the format.',
+    category: 'testreport',
+    tags: ['tests', 'junit', 'tap', 'ci', 'failures'],
+    inputSchema: {
+        type: 'object',
+        properties: {
+            content: { type: 'string', description: 'the raw JUnit XML or TAP text' },
+            format: { type: 'string', enum: ['junit', 'tap'], description: 'force the input format (default: auto-detect)' },
+        },
+        required: ['content'],
+    },
+    handler: async (params) => {
+        if (typeof params.content !== 'string')
+            return { error: true, message: 'content (string) is required' };
+        const fmt = params.format === 'junit' || params.format === 'tap'
+            ? params.format
+            : detectFormat(params.content);
+        return { format: fmt, ...parseTestReport(params.content, fmt) };
+    },
+};
+export const testreportTools = [testreportTool];
+//# sourceMappingURL=testreport-tools.js.map

package/v3/@swarmdo/cli/dist/src/testreport/testreport.d.ts

@@ -0,0 +1,51 @@
+/**
+ * testreport.ts — parse JUnit-XML / TAP test results into a compact failure
+ * digest. The missing front-half of the test→fix loop: an agent runs the suite,
+ * points this at the results, and gets exactly the failing test names + file:line
+ * + assertion message — instead of re-reading hundreds of log lines — then feeds
+ * that into `repair`. Inspired by dorny/test-reporter, action-junit-report,
+ * gotestsum.
+ *
+ * Pure + deterministic: a results string in, a normalized summary out. The file
+ * read / glob lives in ../commands/testreport.ts, so this is fixture-testable.
+ * No XML dependency — well-formed JUnit escapes <>& in attribute values, so a
+ * focused tokenizer over <testcase>/<failure> is safe.
+ */
+export type TestStatus = 'passed' | 'failed' | 'skipped';
+export type TestFormat = 'junit' | 'tap';
+export interface TestFailure {
+    suite: string;
+    name: string;
+    file?: string;
+    line?: number;
+    message?: string;
+    type?: string;
+}
+export interface TestSummary {
+    passed: number;
+    failed: number;
+    skipped: number;
+    total: number;
+    durationMs: number;
+    failures: TestFailure[];
+}
+/** Pull a `file:line` out of a stack-trace / assertion message. Pure. */
+export declare function extractFileLine(text: string): {
+    file?: string;
+    line?: number;
+};
+/** Parse JUnit XML (testsuites/testsuite/testcase). Pure. */
+export declare function parseJUnit(xml: string): TestSummary;
+/** Parse TAP (Test Anything Protocol) output. Pure. */
+export declare function parseTAP(text: string): TestSummary;
+/** Sniff the format from a path extension, then content. Pure. */
+export declare function detectFormat(content: string, path?: string): TestFormat;
+/** Parse by explicit or detected format. Pure. */
+export declare function parseTestReport(content: string, format: TestFormat): TestSummary;
+/** Merge several summaries (multi-file globs). Pure. */
+export declare function mergeSummaries(list: TestSummary[]): TestSummary;
+/** Human-readable digest. Pure. */
+export declare function formatSummary(s: TestSummary, opts?: {
+    top?: number;
+}): string;
+//# sourceMappingURL=testreport.d.ts.map

package/v3/@swarmdo/cli/dist/src/testreport/testreport.js

@@ -0,0 +1,182 @@
+/**
+ * testreport.ts — parse JUnit-XML / TAP test results into a compact failure
+ * digest. The missing front-half of the test→fix loop: an agent runs the suite,
+ * points this at the results, and gets exactly the failing test names + file:line
+ * + assertion message — instead of re-reading hundreds of log lines — then feeds
+ * that into `repair`. Inspired by dorny/test-reporter, action-junit-report,
+ * gotestsum.
+ *
+ * Pure + deterministic: a results string in, a normalized summary out. The file
+ * read / glob lives in ../commands/testreport.ts, so this is fixture-testable.
+ * No XML dependency — well-formed JUnit escapes <>& in attribute values, so a
+ * focused tokenizer over <testcase>/<failure> is safe.
+ */
+/** Decode the five predefined XML entities. Pure. */
+function decodeXml(s) {
+    return s
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'")
+        .replace(/&#(\d+);/g, (_, d) => String.fromCharCode(parseInt(d, 10)))
+        .replace(/&amp;/g, '&'); // last, so &amp;lt; → &lt; not <
+}
+/** Extract key="value" / key='value' attributes from a tag's attribute text. Pure. */
+function parseAttrs(attrText) {
+    const out = {};
+    const re = /([\w:.-]+)\s*=\s*("([^"]*)"|'([^']*)')/g;
+    let m;
+    while ((m = re.exec(attrText)) !== null) {
+        out[m[1]] = decodeXml(m[3] ?? m[4] ?? '');
+    }
+    return out;
+}
+/** Pull a `file:line` out of a stack-trace / assertion message. Pure. */
+export function extractFileLine(text) {
+    if (!text)
+        return {};
+    // Prefer a parenthesised frame `(path:line:col)`, else a bare `path:line`.
+    const paren = text.match(/\(([^()\s]+?):(\d+):(?:\d+)\)/);
+    if (paren)
+        return { file: paren[1], line: parseInt(paren[2], 10) };
+    const bare = text.match(/([\w./\\-]+\.[a-zA-Z]{1,5}):(\d+)(?::\d+)?/);
+    if (bare)
+        return { file: bare[1], line: parseInt(bare[2], 10) };
+    return {};
+}
+/** Parse JUnit XML (testsuites/testsuite/testcase). Pure. */
+export function parseJUnit(xml) {
+    const failures = [];
+    let passed = 0, failed = 0, skipped = 0, durationMs = 0;
+    const caseRe = /<testcase\b([^>]*?)(?:\/>|>([\s\S]*?)<\/testcase>)/g;
+    let c;
+    while ((c = caseRe.exec(xml)) !== null) {
+        const attrs = parseAttrs(c[1]);
+        const body = c[2] ?? '';
+        const name = attrs.name ?? '(unnamed)';
+        const suite = attrs.classname ?? attrs.suite ?? '';
+        if (attrs.time)
+            durationMs += Math.round(parseFloat(attrs.time) * 1000) || 0;
+        const fail = body.match(/<(failure|error)\b([^>]*?)(?:\/>|>([\s\S]*?)<\/\1>)/);
+        const isSkipped = /<skipped\b[^>]*\/?>/.test(body);
+        if (fail) {
+            failed++;
+            const fAttrs = parseAttrs(fail[2]);
+            const inner = decodeXml((fail[3] ?? '').trim());
+            const message = fAttrs.message || inner.split('\n')[0] || undefined;
+            // Prefer explicit file/line attrs (pytest, some emitters), else sniff the trace.
+            const loc = attrs.file
+                ? { file: attrs.file, line: attrs.line ? parseInt(attrs.line, 10) : undefined }
+                : extractFileLine(inner || fAttrs.message || '');
+            failures.push({ suite, name, message, type: fAttrs.type, ...loc });
+        }
+        else if (isSkipped) {
+            skipped++;
+        }
+        else {
+            passed++;
+        }
+    }
+    return { passed, failed, skipped, total: passed + failed + skipped, durationMs, failures };
+}
+/** Parse TAP (Test Anything Protocol) output. Pure. */
+export function parseTAP(text) {
+    const failures = [];
+    let passed = 0, failed = 0, skipped = 0;
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const m = line.match(/^(ok|not ok)\b\s*(\d+)?\s*-?\s*(.*)$/);
+        if (!m)
+            continue;
+        const ok = m[1] === 'ok';
+        let desc = m[3].trim();
+        const directive = desc.match(/#\s*(SKIP|TODO)\b(.*)$/i);
+        if (directive)
+            desc = desc.slice(0, directive.index).trim();
+        if (directive && /skip/i.test(directive[1])) {
+            skipped++;
+            continue;
+        }
+        if (ok) {
+            passed++;
+        }
+        else {
+            failed++;
+            // Look ahead for an indented YAML diagnostic block for message/file/line.
+            let message;
+            let file;
+            let lineNo;
+            for (let j = i + 1; j < lines.length; j++) {
+                const d = lines[j];
+                if (!/^\s/.test(d) && d.trim() !== '')
+                    break; // dedented → block ended
+                const mm = d.match(/^\s*message:\s*(.+)$/);
+                if (mm)
+                    message = mm[1].replace(/^["']|["']$/g, '').trim();
+                const fm = d.match(/^\s*(?:file|at):\s*(.+)$/);
+                if (fm) {
+                    const fl = extractFileLine(fm[1]);
+                    if (fl.file) {
+                        file = fl.file;
+                        lineNo = fl.line;
+                    }
+                }
+                const lm = d.match(/^\s*line:\s*(\d+)/);
+                if (lm)
+                    lineNo = parseInt(lm[1], 10);
+                if (/^\s*\.\.\.\s*$/.test(d))
+                    break; // end of YAML block
+            }
+            failures.push({ suite: '', name: desc || '(unnamed)', message, file, line: lineNo });
+        }
+    }
+    return { passed, failed, skipped, total: passed + failed + skipped, durationMs: 0, failures };
+}
+/** Sniff the format from a path extension, then content. Pure. */
+export function detectFormat(content, path) {
+    if (path) {
+        if (/\.tap$/i.test(path))
+            return 'tap';
+        if (/\.xml$/i.test(path))
+            return 'junit';
+    }
+    if (/<testsuite|<testcase/i.test(content))
+        return 'junit';
+    if (/^\s*(TAP version|1\.\.\d|ok\b|not ok\b)/m.test(content))
+        return 'tap';
+    return 'junit';
+}
+/** Parse by explicit or detected format. Pure. */
+export function parseTestReport(content, format) {
+    return format === 'tap' ? parseTAP(content) : parseJUnit(content);
+}
+/** Merge several summaries (multi-file globs). Pure. */
+export function mergeSummaries(list) {
+    return list.reduce((acc, s) => ({
+        passed: acc.passed + s.passed,
+        failed: acc.failed + s.failed,
+        skipped: acc.skipped + s.skipped,
+        total: acc.total + s.total,
+        durationMs: acc.durationMs + s.durationMs,
+        failures: acc.failures.concat(s.failures),
+    }), { passed: 0, failed: 0, skipped: 0, total: 0, durationMs: 0, failures: [] });
+}
+/** Human-readable digest. Pure. */
+export function formatSummary(s, opts = {}) {
+    const head = `${s.passed} passed · ${s.failed} failed · ${s.skipped} skipped (${s.total} total, ${s.durationMs}ms)`;
+    if (s.failures.length === 0)
+        return head + (s.failed === 0 ? ' ✓' : '');
+    const shown = opts.top && opts.top > 0 ? s.failures.slice(0, opts.top) : s.failures;
+    const lines = [head, ''];
+    for (const f of shown) {
+        const where = f.file ? `${f.file}${f.line ? `:${f.line}` : ''}` : '';
+        lines.push(`✗ ${f.suite ? f.suite + ' › ' : ''}${f.name}${where ? `  (${where})` : ''}`);
+        if (f.message)
+            lines.push(`    ${f.message.split('\n')[0]}`);
+    }
+    if (shown.length < s.failures.length)
+        lines.push(`… and ${s.failures.length - shown.length} more`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=testreport.js.map

package/v3/@swarmdo/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmdo/cli",
-  "version": "1.18.0",
+  "version": "1.19.0",
   "type": "module",
   "description": "Swarmdo 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",