swarmdo 1.19.0 → 1.27.0

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.19.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.27.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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swarmdo",
-  "version": "1.19.0",
+  "version": "1.27.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/apply/apply.d.ts

@@ -15,6 +15,8 @@ export interface HunkLine {
     /** ' ' context, '-' removal, '+' addition */
     type: ' ' | '-' | '+';
     content: string;
+    /** true if a `` marker immediately followed this line */
+    noEol?: boolean;
 }
 export interface Hunk {
     oldStart: number;

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

@@ -54,7 +54,10 @@ export function parsePatch(text) {
                 hunk.lines.push({ type: ' ', content: '' }); // blank context line written without the leading space
             }
             else if (line.startsWith('\\')) {
-                // "" — ignore
+                // "" — attaches to the preceding hunk line,
+                // recording that that side of the diff has no trailing newline.
+                if (hunk.lines.length)
+                    hunk.lines[hunk.lines.length - 1].noEol = true;
             }
             else {
                 hunk = null; // end of hunk block
@@ -119,6 +122,9 @@ export function applyPatch(source, patch, opts = {}) {
         lines.pop(); // drop the empty element from a trailing \n
     let offset = 0;
     const results = [];
+    // If a hunk that reaches EOF carries an explicit no-newline marker, it — not
+    // the source — decides the output's trailing newline. undefined = no marker.
+    let eofNoEol;
     for (const hunk of patch.hunks) {
         const { oldBlock, newBlock } = hunkBlocks(hunk);
         const expected = hunk.oldStart - 1 + offset;
@@ -157,12 +163,33 @@ export function applyPatch(source, patch, opts = {}) {
         lines.splice(placed, oldBlock.length, ...newBlock);
         offset += newBlock.length - oldBlock.length;
         results.push({ hunk, applied: true, at: placed, fuzzUsed: usedFuzz });
+        // If this hunk's new content is now the tail of the file, its markers
+        // determine whether the file ends with a newline.
+        if (placed + newBlock.length === lines.length)
+            eofNoEol = newSideEndsNoEol(hunk);
     }
     let result = lines.join('\n');
-    if (trailingNewline)
+    // The patch's explicit EOF marker wins; absent one, keep the source's state.
+    const endWithNewline = eofNoEol === undefined ? trailingNewline : !eofNoEol;
+    if (endWithNewline)
         result += '\n';
     return { ok: results.every((r) => r.applied), result, hunks: results };
 }
+/**
+ * Whether the NEW side of `hunk` ends without a trailing newline — read from the
+ * last context/addition line's marker. Returns undefined if the hunk carries no
+ * `\ No newline` marker at all (so the source's state should be kept). Pure.
+ */
+function newSideEndsNoEol(hunk) {
+    if (!hunk.lines.some((l) => l.noEol))
+        return undefined;
+    for (let i = hunk.lines.length - 1; i >= 0; i--) {
+        const l = hunk.lines[i];
+        if (l.type === ' ' || l.type === '+')
+            return !!l.noEol;
+    }
+    return undefined;
+}
 function countLeadingContext(hunk) {
     let n = 0;
     for (const l of hunk.lines) {

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

@@ -24,18 +24,41 @@ export const SECTIONS = [
     { type: 'chore', label: 'Chores', hidden: true },
 ];
 const SUBJECT_RE = /^(\w+)(?:\(([^)]+)\))?(!)?:\s+(.+)$/;
+// git's default revert subject: `Revert "<original subject>"` (git-revert(1)).
+// The conventional `revert:` type is handled by SUBJECT_RE; this catches the
+// bare git form, which otherwise falls into the hidden `other` bucket.
+const REVERT_RE = /^Revert\s+"(.+)"$/;
+// Conventional Commits: a breaking-change footer MUST be the uppercase token
+// `BREAKING CHANGE` (or `BREAKING-CHANGE`) at the start of a footer line,
+// followed by `: `. Anchoring to a line start avoids a false positive when the
+// phrase merely appears in prose ("this is not a BREAKING CHANGE, just …").
+const BREAKING_RE = /^BREAKING[ -]CHANGE:\s/m;
 /** Parse one conventional-commit subject (+ optional body for BREAKING CHANGE). */
 export function parseCommit(hash, subject, body = '') {
-    const m = SUBJECT_RE.exec(subject.trim());
+    const trimmed = subject.trim();
+    const rev = REVERT_RE.exec(trimmed);
+    if (rev) {
+        // Recurse into the quoted original subject to lift its scope/description.
+        const inner = SUBJECT_RE.exec(rev[1].trim());
+        return {
+            hash,
+            type: 'revert',
+            scope: inner ? inner[2] ?? null : null,
+            breaking: BREAKING_RE.test(body),
+            subject: inner ? inner[4].trim() : rev[1].trim(),
+            raw: trimmed,
+        };
+    }
+    const m = SUBJECT_RE.exec(trimmed);
     if (!m) {
-        return { hash, type: null, scope: null, breaking: /BREAKING[ -]CHANGE/.test(body), subject: subject.trim(), raw: subject.trim() };
+        return { hash, type: null, scope: null, breaking: BREAKING_RE.test(body), subject: subject.trim(), raw: subject.trim() };
     }
     const [, type, scope, bang, desc] = m;
     return {
         hash,
         type: type.toLowerCase(),
         scope: scope ?? null,
-        breaking: bang === '!' || /BREAKING[ -]CHANGE/.test(body),
+        breaking: bang === '!' || BREAKING_RE.test(body),
         subject: desc.trim(),
         raw: subject.trim(),
     };

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

@@ -31,6 +31,13 @@ export interface ImportEdge {
     resolved: string | null;
     /** 1-based line of the import */
     line: number;
+    /**
+     * True for a TypeScript type-only import/export (`import type …`,
+     * `export type … from …`). These are erased at compile time (with
+     * isolatedModules/verbatimModuleSyntax) so they create NO runtime dependency
+     * — relevant to cycle detection, where a type-only "cycle" is benign.
+     */
+    isTypeOnly?: boolean;
 }
 export interface CodeIndex {
     /** Repo-relative file → symbols declared in it. */
@@ -46,19 +53,31 @@ export declare function extractImports(source: string, file: string): Array<{
     from: string;
     spec: string;
     line: number;
+    isTypeOnly: boolean;
 }>;
 /**
- * Resolve a spec to a repo-relative file in `fileSet`, or null. Only relative
- * specs (`.`/`..`) resolve; bare specifiers (packages, aliases, `node:`) are
- * external → null. Tries the path as-is, common extensions, and `/index.*`,
- * and rewrites a `.js` spec to its `.ts` sibling (TS ESM convention).
+ * A tsconfig `paths` / workspace alias: a bare-specifier pattern mapped to a
+ * repo-relative target (baseUrl already applied), each optionally containing a
+ * single star wildcard — e.g. pattern `@swarmdo/[star]` → target
+ * `v3/@swarmdo/[star]/src`, where `[star]` captures the remaining spec.
  */
-export declare function resolveImport(fromFile: string, spec: string, fileSet: Set<string>): string | null;
-/** Build an index from already-read files. Pure. */
+export interface ImportAlias {
+    pattern: string;
+    target: string;
+}
+/**
+ * Resolve a spec to a repo-relative file in `fileSet`, or null. Relative specs
+ * (`.`/`..`) resolve against the importing file's dir. Bare specifiers resolve
+ * only if they match a tsconfig-`paths`/workspace `alias` — otherwise they're
+ * external (packages, `node:`) → null. Tries common extensions and `/index.*`,
+ * and rewrites a `.js` spec to its `.ts` sibling (TS ESM convention). Pure.
+ */
+export declare function resolveImport(fromFile: string, spec: string, fileSet: Set<string>, aliases?: ImportAlias[]): string | null;
+/** Build an index from already-read files. `aliases` resolve bare-specifier internal imports. Pure. */
 export declare function buildIndex(files: Array<{
     file: string;
     source: string;
-}>): CodeIndex;
+}>, aliases?: ImportAlias[]): CodeIndex;
 export interface QueryOptions {
     /** Substring/case-insensitive match instead of exact. */
     fuzzy?: boolean;

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

@@ -28,6 +28,43 @@ const MATCHERS = [
     { kind: 'enum', re: /^export\s+(?:const\s+)?enum\s+([A-Za-z_$][\w$]*)/ },
     { kind: 'const', re: /^export\s+(?:const|let|var)\s+([A-Za-z_$][\w$]*)/ },
 ];
+/**
+ * Top-level (comma-separated) simple-identifier declarator names in a
+ * const/let/var declaration list, e.g. `a = 1, b = fn(1, 2), c = 3` → [a,b,c].
+ * Commas inside parens/brackets/braces/strings don't split. Destructuring
+ * patterns (a segment starting with `{`/`[`) yield no name — kept as-is. Pure.
+ */
+function declaratorNames(decl) {
+    const names = [];
+    let depth = 0;
+    let start = 0;
+    let str = null;
+    const take = (seg) => {
+        const m = seg.trim().match(/^([A-Za-z_$][\w$]*)/);
+        if (m)
+            names.push(m[1]);
+    };
+    for (let i = 0; i < decl.length; i++) {
+        const ch = decl[i];
+        if (str) {
+            if (ch === str && decl[i - 1] !== '\\')
+                str = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === '`')
+            str = ch;
+        else if (ch === '(' || ch === '[' || ch === '{')
+            depth++;
+        else if (ch === ')' || ch === ']' || ch === '}')
+            depth--;
+        else if (ch === ',' && depth === 0) {
+            take(decl.slice(start, i));
+            start = i + 1;
+        }
+    }
+    take(decl.slice(start));
+    return names;
+}
 /** Extract exported symbols from one source file. Pure. */
 export function extractSymbols(source, file) {
     const out = [];
@@ -37,9 +74,29 @@ export function extractSymbols(source, file) {
         const trimmed = raw.trimStart();
         if (!trimmed.startsWith('export'))
             continue;
+        // `export * as ns from '…'` (ES2020) creates a real named export `ns` — a
+        // namespace binding — unlike bare `export * from '…'` which adds no local
+        // name. Index it (kind 'const', the closest value-binding kind) before the
+        // blanket `export *` skip below.
+        const nsRe = /^export\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\b/;
+        const nsm = trimmed.match(nsRe);
+        if (nsm) {
+            out.push({ name: nsm[1], kind: 'const', file, line: i + 1, signature: trimmed.slice(0, SIG_MAX).replace(/\s+$/, '') });
+            continue;
+        }
         // Skip re-export / bare forms handled elsewhere: `export {` and `export *`.
         if (/^export\s*[*{]/.test(trimmed))
             continue;
+        // const/let/var can declare MULTIPLE comma-separated bindings — index each
+        // (`export const a = 1, b = 2` → a AND b). Exclude `const enum` (handled by
+        // the enum matcher) and leave destructuring exports unindexed as before.
+        const declM = trimmed.match(/^export\s+(?:const|let|var)\s+(?!enum\b)(.*)$/);
+        if (declM) {
+            const sig = trimmed.slice(0, SIG_MAX).replace(/\s+$/, '');
+            for (const name of declaratorNames(declM[1]))
+                out.push({ name, kind: 'const', file, line: i + 1, signature: sig });
+            continue;
+        }
         for (const { kind, re } of MATCHERS) {
             const m = trimmed.match(re);
             if (!m)
@@ -77,6 +134,9 @@ export function extractImports(source, file) {
         const line = lines[i];
         if (!/\b(?:from|import|require)\b/.test(line))
             continue;
+        // A whole-import type-only form: `import type …` / `export type …`. NOT
+        // inline `import { type X }` (mixed with value imports → still a runtime edge).
+        const isTypeOnly = /^\s*(?:import|export)\s+type\b/.test(line);
         const seen = new Set();
         for (const re of IMPORT_RES) {
             re.lastIndex = 0;
@@ -86,7 +146,7 @@ export function extractImports(source, file) {
                 if (seen.has(spec))
                     continue; // same spec caught by two patterns on one line
                 seen.add(spec);
-                out.push({ from: file, spec, line: i + 1 });
+                out.push({ from: file, spec, line: i + 1, isTypeOnly });
             }
         }
     }
@@ -106,16 +166,20 @@ function joinRelative(fromFile, spec) {
     return parts.join('/');
 }
 const RESOLVE_EXTS = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.mts', '.cts'];
-/**
- * Resolve a spec to a repo-relative file in `fileSet`, or null. Only relative
- * specs (`.`/`..`) resolve; bare specifiers (packages, aliases, `node:`) are
- * external → null. Tries the path as-is, common extensions, and `/index.*`,
- * and rewrites a `.js` spec to its `.ts` sibling (TS ESM convention).
- */
-export function resolveImport(fromFile, spec, fileSet) {
-    if (!spec.startsWith('.'))
+/** Substitute a spec through one alias (with `*` wildcard), or null if no match. Pure. */
+function applyAlias(pattern, target, spec) {
+    const star = pattern.indexOf('*');
+    if (star < 0)
+        return spec === pattern ? target : null;
+    const prefix = pattern.slice(0, star);
+    const suffix = pattern.slice(star + 1);
+    if (spec.length < prefix.length + suffix.length || !spec.startsWith(prefix) || !spec.endsWith(suffix))
         return null;
-    const base = joinRelative(fromFile, spec);
+    const mid = spec.slice(prefix.length, spec.length - suffix.length);
+    return target.includes('*') ? target.replace('*', mid) : target;
+}
+/** Resolve a bare repo-relative base path to a file in `fileSet` (exts + /index + .js→.ts). Pure. */
+function resolveInFileSet(base, fileSet) {
     const bases = [base];
     const jsExt = base.match(/\.(js|jsx|mjs|cjs)$/);
     if (jsExt)
@@ -132,15 +196,35 @@ export function resolveImport(fromFile, spec, fileSet) {
     }
     return null;
 }
-/** Build an index from already-read files. Pure. */
-export function buildIndex(files) {
+/**
+ * Resolve a spec to a repo-relative file in `fileSet`, or null. Relative specs
+ * (`.`/`..`) resolve against the importing file's dir. Bare specifiers resolve
+ * only if they match a tsconfig-`paths`/workspace `alias` — otherwise they're
+ * external (packages, `node:`) → null. Tries common extensions and `/index.*`,
+ * and rewrites a `.js` spec to its `.ts` sibling (TS ESM convention). Pure.
+ */
+export function resolveImport(fromFile, spec, fileSet, aliases = []) {
+    if (spec.startsWith('.'))
+        return resolveInFileSet(joinRelative(fromFile, spec), fileSet);
+    for (const a of aliases) {
+        const cand = applyAlias(a.pattern, a.target, spec);
+        if (cand == null)
+            continue;
+        const r = resolveInFileSet(cand, fileSet);
+        if (r)
+            return r;
+    }
+    return null;
+}
+/** Build an index from already-read files. `aliases` resolve bare-specifier internal imports. Pure. */
+export function buildIndex(files, aliases = []) {
     const symbols = [];
     const fileSet = new Set(files.map((f) => f.file));
     const imports = [];
     for (const { file, source } of files) {
         symbols.push(...extractSymbols(source, file));
         for (const imp of extractImports(source, file)) {
-            imports.push({ ...imp, resolved: resolveImport(imp.from, imp.spec, fileSet) });
+            imports.push({ ...imp, resolved: resolveImport(imp.from, imp.spec, fileSet, aliases) });
         }
     }
     // Stable order: file, then line.

package/v3/@swarmdo/cli/dist/src/codegraph/store.d.ts

@@ -4,11 +4,18 @@
  * Shared by the `codegraph` CLI command and the codegraph MCP tools so the
  * scan/persist behaviour can't drift between them.
  */
-import { type CodeIndex } from './codegraph.js';
+import { type CodeIndex, type ImportAlias } from './codegraph.js';
 export declare const INDEX_REL: string;
 /** Recursively collect source files under `root`, skipping vendor/build dirs and .d.ts. */
 export declare function walkSourceFiles(root: string): string[];
 export declare function indexPath(root: string): string;
+/**
+ * Read `<root>/tsconfig.json` and derive repo-relative import aliases from
+ * `compilerOptions.paths` (+ `baseUrl`). Tolerant of JSONC comments/trailing
+ * commas; returns [] on any problem (so bare-specifier imports stay external,
+ * as before). Only the first target of each path pattern is used. Pure-ish (fs read).
+ */
+export declare function parseTsconfigAliases(root: string): ImportAlias[];
 /** Scan a repo (or a subpath of it) and build the index. `root` is the repo
  * root used for relative paths; `scanRoot` (default = root) is where to walk. */
 export declare function scanRepo(root: string, scanRoot?: string): CodeIndex;

package/v3/@swarmdo/cli/dist/src/codegraph/store.js

@@ -53,6 +53,83 @@ function safeRead(abs) {
 export function indexPath(root) {
     return path.join(root, INDEX_REL);
 }
+/**
+ * Strip JSONC `//` and block comments + trailing commas, STRING-AWARE so a `/*`
+ * inside a path pattern (e.g. `"@app/*"`, ubiquitous in tsconfig paths) isn't
+ * mistaken for a comment start. Pure.
+ */
+function stripJsonc(s) {
+    let out = '';
+    let inStr = false, esc = false;
+    for (let i = 0; i < s.length; i++) {
+        const ch = s[i];
+        if (inStr) {
+            out += ch;
+            if (esc)
+                esc = false;
+            else if (ch === '\\')
+                esc = true;
+            else if (ch === '"')
+                inStr = false;
+            continue;
+        }
+        if (ch === '"') {
+            inStr = true;
+            out += ch;
+            continue;
+        }
+        if (ch === '/' && s[i + 1] === '/') {
+            while (i < s.length && s[i] !== '\n')
+                i++;
+            out += '\n';
+            continue;
+        }
+        if (ch === '/' && s[i + 1] === '*') {
+            i += 2;
+            while (i < s.length && !(s[i] === '*' && s[i + 1] === '/'))
+                i++;
+            i++;
+            continue;
+        }
+        out += ch;
+    }
+    return out.replace(/,(\s*[}\]])/g, '$1');
+}
+/**
+ * Read `<root>/tsconfig.json` and derive repo-relative import aliases from
+ * `compilerOptions.paths` (+ `baseUrl`). Tolerant of JSONC comments/trailing
+ * commas; returns [] on any problem (so bare-specifier imports stay external,
+ * as before). Only the first target of each path pattern is used. Pure-ish (fs read).
+ */
+export function parseTsconfigAliases(root) {
+    let raw;
+    try {
+        raw = fs.readFileSync(path.join(root, 'tsconfig.json'), 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const json = stripJsonc(raw);
+    let cfg;
+    try {
+        cfg = JSON.parse(json);
+    }
+    catch {
+        return [];
+    }
+    const co = cfg.compilerOptions ?? {};
+    if (!co.paths || typeof co.paths !== 'object')
+        return [];
+    const baseUrl = typeof co.baseUrl === 'string' ? co.baseUrl : '.';
+    const aliases = [];
+    for (const [pattern, targets] of Object.entries(co.paths)) {
+        const first = Array.isArray(targets) ? targets[0] : undefined;
+        if (typeof first !== 'string')
+            continue;
+        aliases.push({ pattern, target: path.join(baseUrl, first).split(path.sep).join('/') });
+    }
+    return aliases;
+}
 /** Scan a repo (or a subpath of it) and build the index. `root` is the repo
  * root used for relative paths; `scanRoot` (default = root) is where to walk. */
 export function scanRepo(root, scanRoot = root) {
@@ -60,7 +137,7 @@ export function scanRepo(root, scanRoot = root) {
     const read = files
         .map((abs) => ({ file: path.relative(root, abs), source: safeRead(abs) }))
         .filter((f) => f.source !== null);
-    return buildIndex(read);
+    return buildIndex(read, parseTsconfigAliases(root));
 }
 /** Persist the index to .swarm/codegraph.json under `root`. */
 export function saveIndex(root, index) {

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

@@ -15,6 +15,7 @@ async function run(ctx) {
     const root = ctx.cwd || process.cwd();
     const asJson = ctx.flags.format === 'json';
     const ci = ctx.flags.ci === true;
+    const includeTypeOnly = ctx.flags['include-type-only'] === true;
     let index = loadIndex(root);
     if (!index) {
         index = scanRepo(root);
@@ -23,7 +24,7 @@ async function run(ctx) {
         }
         catch { /* read-only fs — index is in memory */ }
     }
-    const res = findCycles(index);
+    const res = findCycles(index, { includeTypeOnly });
     const count = res.cycles.length + res.selfLoops.length;
     if (asJson) {
         process.stdout.write(JSON.stringify({ count, ...res }, null, 2) + '\n');
@@ -40,10 +41,12 @@ export const cyclesCommand = {
     description: 'Find circular import dependencies via the import graph (madge --circular style) — catch the TDZ/undefined-export bugs they cause',
     options: [
         { name: 'ci', description: 'exit 1 if any circular dependency exists (gate a build)', type: 'boolean' },
+        { name: 'include-type-only', description: 'also count TypeScript `import type` edges (excluded by default — they erase at compile time and cause no runtime cycle)', type: 'boolean' },
     ],
     examples: [
         { command: 'swarmdo cycles', description: 'List circular imports in the repo' },
         { command: 'swarmdo cycles --ci', description: 'Fail CI when a cycle is introduced' },
+        { command: 'swarmdo cycles --include-type-only', description: 'Strict view: count type-only imports too' },
     ],
     action: run,
 };

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

@@ -33,8 +33,11 @@ async function run(ctx) {
     }
     // Global --format (text|json|table); text and table both render the table.
     const asJson = ctx.flags.format === 'json';
-    // Capture history: SOH-delimited header + numstat, no merges.
-    const args = ['log', '--no-merges', '--numstat', `--since=${since}`, '--format=format:%x01%H%x1f%an%x1f%aI'];
+    // Capture history: SOH-delimited header + numstat, no merges. `%aN` (not
+    // `%an`) resolves author names through `.mailmap`, so name/email variants of
+    // the same person fold into one identity — otherwise the author-spread factor
+    // in the risk score is silently inflated. Identical to `%an` when no .mailmap.
+    const args = ['log', '--no-merges', '--numstat', `--since=${since}`, '--format=format:%x01%H%x1f%aN%x1f%aI'];
     if (pathArg)
         args.push('--', pathArg);
     let raw;

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

@@ -15,6 +15,10 @@ import * as os from 'node:os';
 import { execFileSync } from 'node:child_process';
 import { output } from '../output.js';
 import { planRelease, renderStep } from '../release/release.js';
+/** Escape every regex metacharacter (incl. backslash) so a value is a literal in `new RegExp`. */
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 function repoRootFrom(cwd) {
     try {
         return execFileSync('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
@@ -47,7 +51,7 @@ function syncDocs(root, files, current, next) {
         let after = before;
         // exact patterns used by every release since 1.4.x
         after = after.replaceAll(`**Swarmdo v${current}** (`, `**Swarmdo v${next}** (`);
-        after = after.replace(new RegExp(`\\*\\*Swarmdo v${next.replace(/\./g, '\\.')}\\*\\* \\(\\d{4}-\\d{2}-\\d{2}\\)`), `**Swarmdo v${next}** (${today})`);
+        after = after.replace(new RegExp(`\\*\\*Swarmdo v${escapeRegExp(next)}\\*\\* \\(\\d{4}-\\d{2}-\\d{2}\\)`), `**Swarmdo v${next}** (${today})`);
         after = after.replaceAll(`swarmdo@${current}\` (umbrella), \`@swarmdo/cli@${current}\`, \`swarmdo-bridge@${current}\``, `swarmdo@${next}\` (umbrella), \`@swarmdo/cli@${next}\`, \`swarmdo-bridge@${next}\``);
         // README badge + website carry the last PUBLISHED version, which lags
         // the repo version (`current`) between releases — match any semver in

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

@@ -98,7 +98,8 @@ async function run(ctx) {
     else {
         output.writeln(formatSummary(summary, { top: top > 0 ? top : undefined }));
     }
-    const code = ci && summary.failed > 0 ? 1 : 0;
+    // A bail-out aborts the suite → results are incomplete → treat as failure in CI.
+    const code = ci && (summary.failed > 0 || summary.bailedOut) ? 1 : 0;
     return { success: code === 0, exitCode: code };
 }
 export const testreportCommand = {

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

@@ -12,8 +12,18 @@
  * The index load lives in ../commands/cycles.ts, so this is fixture-testable.
  */
 import type { CodeIndex } from '../codegraph/codegraph.js';
+export interface CycleOptions {
+    /**
+     * Include TypeScript `import type`/`export type` edges. They erase at compile
+     * time so a type-only "cycle" causes none of the runtime bugs this detector
+     * exists to catch — excluded by DEFAULT to avoid false positives. Set true for
+     * a strict structural view. An edge counts as a runtime edge if ANY import
+     * between the two files is a value import (mixed imports keep the edge).
+     */
+    includeTypeOnly?: boolean;
+}
 /** Build file → sorted list of internal (resolved) imports. Pure. */
-export declare function buildAdjacency(index: CodeIndex): Map<string, string[]>;
+export declare function buildAdjacency(index: CodeIndex, opts?: CycleOptions): Map<string, string[]>;
 /**
  * Tarjan's SCC. Returns every strongly-connected component as a member list.
  * Iterative (no recursion) so deep graphs don't overflow the stack. Deterministic:
@@ -31,7 +41,7 @@ export interface CycleResult {
  * it has ≥2 files (mutual reachability) or a single file with a self-edge.
  * Deterministic: groups sorted by size desc then first member.
  */
-export declare function findCycles(index: CodeIndex): CycleResult;
+export declare function findCycles(index: CodeIndex, opts?: CycleOptions): CycleResult;
 /** Human-readable summary. Pure. */
 export declare function formatCycles(res: CycleResult): string;
 //# sourceMappingURL=cycles.d.ts.map

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

@@ -12,7 +12,7 @@
  * The index load lives in ../commands/cycles.ts, so this is fixture-testable.
  */
 /** Build file → sorted list of internal (resolved) imports. Pure. */
-export function buildAdjacency(index) {
+export function buildAdjacency(index, opts = {}) {
     const adj = new Map();
     const ensure = (f) => {
         let l = adj.get(f);
@@ -25,6 +25,8 @@ export function buildAdjacency(index) {
     for (const e of index.imports) {
         if (!e.resolved)
             continue; // external — not part of internal cycles
+        if (e.isTypeOnly && !opts.includeTypeOnly)
+            continue; // type-only → no runtime edge
         const l = ensure(e.from);
         if (!l.includes(e.resolved))
             l.push(e.resolved);
@@ -101,8 +103,8 @@ export function stronglyConnectedComponents(adj) {
  * it has ≥2 files (mutual reachability) or a single file with a self-edge.
  * Deterministic: groups sorted by size desc then first member.
  */
-export function findCycles(index) {
-    const adj = buildAdjacency(index);
+export function findCycles(index, opts = {}) {
+    const adj = buildAdjacency(index, opts);
     const selfLoops = [];
     for (const [from, tos] of adj)
         if (tos.includes(from))

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

@@ -29,8 +29,11 @@ export interface EnvReport {
 export declare function extractEnvRefs(source: string, file: string): EnvRef[];
 /**
  * Parse a `.env` file into an ordered list of declared keys. Handles `KEY=val`,
- * `export KEY=val`, quoted values, `# comments`, and blank lines. Values are
- * ignored — we only reconcile key presence. Pure.
+ * `export KEY=val`, quoted values, `# comments`, and blank lines. The key
+ * charset + `:` separator mirror the reference `dotenv` package's grammar
+ * (`[\w.-]+` with `=` or `: ` as separator), so dotted/hyphenated keys like
+ * `APP.NAME` aren't silently dropped. Values are ignored — we only reconcile
+ * key presence. Pure.
  */
 export declare function parseDotenv(text: string): string[];
 export interface ReconcileInput {