swarmdo 1.45.0 → 1.50.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.45.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.50.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)
@@ -290,12 +290,14 @@ The recent release train added a full day-to-day operations layer around the swa
 | `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 coupling` | **Files that change together** — the empirical complement to `affected`'s static import graph: mine git history for file pairs that keep landing in the same commit (a schema and its type, a serializer split across modules) so you catch the co-edit you'd otherwise forget. `--file <path>` answers "what changes with X?", `--since`, `--min-shared`, `--csv`. Modeled on code-maat / CodeScene. Also an MCP tool (`coupling`). Deterministic |
+| `swarmdo ownership` | **Who owns each file, and what breaks if they leave** — a per-file knowledge map + bus factor from git history: the dominant author, ownership concentration, and the fewest authors whose churn clears 50% (a lone owner is flagged ⚠ key-person), plus a repo-wide truck factor. `--since`, `--min-churn`, `--top`, `--csv`, `--format json`. code-maat main-dev / CodeScene "Knowledge Map"; also an MCP tool (`ownership`). Deterministic |
+| `swarmdo hidden-coupling` | **Co-change with no import edge** — join the two graphs swarmdo already owns (temporal `coupling` from git + `codegraph`'s import graph) and emit the set difference: file pairs that keep changing together yet nothing in the code links them ("logical minus structural coupling" — a config and its consumers, a schema and its mirror type). The co-edit `affected` can't see. `--since`, `--min-shared`, `--csv`, `--format json`. Grounded in Gall et al. (ICSM 1998). 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`; `--contributors` appends a credited contributor roll |
 | `swarmdo mcp doctor` | **MCP config diagnosis** — missing binaries, bad URLs, malformed entries across `.mcp.json` + `~/.claude.json` |
-| `swarmdo config lint` | **Static config validation** — the pure shape layer for `swarmdo.config.json`, the `.claude/settings*.json` hooks block, `.mcp.json`, and **`.claude/agents/*.md` subagents** (missing `name`/`description`, a `name` duplicated across files — CC silently loads only one — a bad `model`, malformed frontmatter). `--strict` gates CI |
+| `swarmdo config lint` | **Static config validation** — the pure shape layer for `swarmdo.config.json`, the `.claude/settings*.json` hooks block, `.mcp.json`, **`.claude/agents/*.md` subagents** (missing `name`/`description`, a `name` duplicated across files — CC silently loads only one — a bad `model`, malformed frontmatter), and **custom slash commands + skills** (malformed YAML that makes CC load empty metadata, a bad `effort`, an inline `` !`cmd` `` bash-injection that's inert or not covered by `allowed-tools`). `--strict` gates CI |
 | `swarmdo permissions` (alias `perms`) | **Audit your Claude Code permission rules** — static analysis of `permissions.allow`/`deny`/`ask` in `.claude/settings*.json`: flags allow↔deny conflicts (dead rules), over-broad `Bash(*)` grants, shadowed/redundant rules, duplicates, and malformed entries. `--strict` gates CI. Read-only; the static-safety sibling of `config lint` / `mcp doctor` |
 | `swarmdo comms` (alias `mailbox`) | **Cross-session agent mailbox** — one Claude Code session messages another by name (`send -t <session>`, `-t all` broadcasts, `inbox`, `read`, `watch`); sessions on the same repo share `.swarmdo/comms/`. `inbox --hook` surfaces new mail as prompt context without polling. Also MCP tools (`comms_send`/`comms_inbox`) |
 | `swarmdo hooks memory-inject` | **Prompt-time semantic memory injection** — embeds each prompt, vector-searches your stored memories, and injects the most relevant under a token budget (recall at the moment of need); wire it with `hooks recipe memory-inject` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swarmdo",
-  "version": "1.45.0",
+  "version": "1.50.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/config.js

@@ -400,7 +400,7 @@ const importCommand = {
 const lintCommand = {
     name: 'lint',
     aliases: ['validate'],
-    description: 'Statically validate swarmdo.config.json, .claude/settings*.json hooks, .mcp.json, .claude/agents/*.md subagents, and the post-1.4 sDo layout',
+    description: 'Statically validate swarmdo.config.json, .claude/settings*.json hooks, .mcp.json, .claude/agents/*.md subagents, .claude/commands + skills slash-command frontmatter/body, and the post-1.4 sDo layout',
     options: [
         { name: 'json', type: 'boolean', description: 'machine-readable findings', default: false },
         { name: 'strict', type: 'boolean', description: 'exit 1 on warnings too (default: errors only)', default: false },
@@ -437,6 +437,35 @@ const lintCommand = {
             .filter((n) => n.endsWith('.md'))
             .map((n) => read(`.claude/agents/${n}`))
             .filter((x) => x.raw !== null);
+        // Custom slash commands nest (e.g. `.claude/commands/sDo/*.md`), so walk the
+        // tree; skills live one dir deep as `.claude/skills/<name>/SKILL.md`.
+        const walkMd = (rel) => {
+            const acc = [];
+            let entries;
+            try {
+                entries = fs.readdirSync(path.join(cwd, rel), { withFileTypes: true });
+            }
+            catch {
+                return acc;
+            }
+            for (const e of entries) {
+                if (e.name.startsWith('.'))
+                    continue;
+                const childRel = `${rel}/${e.name}`;
+                if (e.isDirectory())
+                    acc.push(...walkMd(childRel));
+                else if (e.isFile() && e.name.endsWith('.md')) {
+                    const r = read(childRel);
+                    if (r.raw !== null)
+                        acc.push({ file: childRel, raw: r.raw });
+                }
+            }
+            return acc;
+        };
+        const commandFiles = walkMd('.claude/commands');
+        const skillFiles = list('.claude/skills')
+            .map((dir) => read(`.claude/skills/${dir}/SKILL.md`))
+            .filter((x) => x.raw !== null);
         const report = lintAll({
             swarmdoConfig: read(configRel),
             settingsFiles: [read('.claude/settings.json'), read('.claude/settings.local.json')],
@@ -445,6 +474,8 @@ const lintCommand = {
             sdoCommands: list('.claude/commands/sDo'),
             skills: list('.claude/skills'),
             agentFiles,
+            commandFiles,
+            skillFiles,
         });
         const failed = report.errors > 0 || (ctx.flags.strict === true && report.warnings > 0);
         if (ctx.flags.json === true) {

package/v3/@swarmdo/cli/dist/src/commands/hidden-coupling.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `swarmdo hidden-coupling` — files that CHANGE TOGETHER but have no import edge.
+ *
+ *   swarmdo hidden-coupling                       # co-change pairs the code doesn't explain
+ *   swarmdo hidden-coupling --since 6mo --min-shared 3
+ *   swarmdo hidden-coupling --format json | --csv
+ *
+ * "Logical coupling minus structural coupling": pairs with a high co-change
+ * `degree` (from `coupling`) yet NO import edge connecting them (from
+ * `codegraph`). A dependency real enough to move two files in lockstep but
+ * invisible in the code — the co-edit an agent following imports would miss, or
+ * a missing abstraction a reviewer should question. Composes the two capture
+ * paths verbatim: git-log + `computeCoupling`, and the codegraph index load.
+ * Engine (../coupling/hidden.ts) is pure + tested.
+ */
+import type { Command } from '../types.js';
+export declare const hiddenCouplingCommand: Command;
+export default hiddenCouplingCommand;
+//# sourceMappingURL=hidden-coupling.d.ts.map

package/v3/@swarmdo/cli/dist/src/commands/hidden-coupling.js

@@ -0,0 +1,92 @@
+/**
+ * `swarmdo hidden-coupling` — files that CHANGE TOGETHER but have no import edge.
+ *
+ *   swarmdo hidden-coupling                       # co-change pairs the code doesn't explain
+ *   swarmdo hidden-coupling --since 6mo --min-shared 3
+ *   swarmdo hidden-coupling --format json | --csv
+ *
+ * "Logical coupling minus structural coupling": pairs with a high co-change
+ * `degree` (from `coupling`) yet NO import edge connecting them (from
+ * `codegraph`). A dependency real enough to move two files in lockstep but
+ * invisible in the code — the co-edit an agent following imports would miss, or
+ * a missing abstraction a reviewer should question. Composes the two capture
+ * paths verbatim: git-log + `computeCoupling`, and the codegraph index load.
+ * Engine (../coupling/hidden.ts) is pure + tested.
+ */
+import { execFileSync } from 'node:child_process';
+import { output } from '../output.js';
+import { parseGitLog } from '../hotspots/hotspots.js';
+import { computeCoupling } from '../coupling/coupling.js';
+import { computeHiddenCoupling, formatHiddenCoupling, hiddenCouplingToCsv } from '../coupling/hidden.js';
+import { loadIndex, scanRepo, saveIndex } from '../codegraph/store.js';
+import { normalizeSince } from '../util/since.js';
+/** Read a numeric flag that the parser may deliver as a number OR a string. */
+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 since = typeof ctx.flags.since === 'string' ? ctx.flags.since : '1 year ago';
+    const top = numFlag(ctx.flags.top, 30);
+    const minShared = numFlag(ctx.flags['min-shared'], 2);
+    const maxFiles = numFlag(ctx.flags['max-files'], 30);
+    const asJson = ctx.flags.format === 'json';
+    const asCsv = ctx.flags.csv === true;
+    // Capture 1: the full co-change history (same `--numstat` dump `coupling` uses;
+    // NO pathspec filter — that would strip co-changed files from each commit).
+    const args = ['log', '--no-merges', '--numstat', `--since=${normalizeSince(since)}`, '--format=format:%x01%H%x1f%aN%x1f%aI'];
+    let raw;
+    try {
+        raw = execFileSync('git', args, { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 128 * 1024 * 1024 });
+    }
+    catch {
+        output.printError('git log failed — is this a git repository?');
+        return { success: false, exitCode: 1 };
+    }
+    // Rank ALL coupling pairs (no top yet — we cap the HIDDEN set after filtering).
+    const pairs = computeCoupling(parseGitLog(raw), { minShared, maxFiles });
+    // Capture 2: the static import graph (prefer a saved index; build one if absent).
+    let index = loadIndex(root);
+    if (!index) {
+        index = scanRepo(root);
+        try {
+            saveIndex(root, index);
+        }
+        catch { /* read-only fs — in-memory is fine */ }
+    }
+    const hidden = computeHiddenCoupling(pairs, index.imports, { top: top > 0 ? top : undefined });
+    if (asCsv) {
+        process.stdout.write(hiddenCouplingToCsv(hidden) + '\n');
+    }
+    else if (asJson) {
+        process.stdout.write(JSON.stringify({ generated: new Date().toISOString(), since, minShared, coupled: pairs.length, count: hidden.length, hidden }, null, 2) + '\n');
+    }
+    else if (hidden.length === 0) {
+        output.writeln(output.dim(`no hidden coupling found — every co-change pair has an import edge (or none met --min-shared ${minShared} / --since ${since})`));
+    }
+    else {
+        output.writeln(output.bold(`Hidden coupling (co-change with NO import edge, since ${since}, min-shared ${minShared})`));
+        output.writeln(formatHiddenCoupling(hidden));
+        output.writeln(output.dim(`${hidden.length} hidden of ${pairs.length} coupled pair(s) — these move together but nothing in the code links them`));
+    }
+    return { success: true, exitCode: 0 };
+}
+export const hiddenCouplingCommand = {
+    name: 'hidden-coupling',
+    description: 'Rank file pairs that change together in git history but have NO import edge (logical minus structural coupling) — the co-edit `affected` can\'t see',
+    options: [
+        { name: 'since', description: 'history window, e.g. 90d or "3 months ago" (default 1 year)', type: 'string' },
+        { name: 'min-shared', description: 'drop pairs sharing fewer than N commits (default 2)', type: 'string' },
+        { name: 'max-files', description: 'skip commits touching more than N files (default 30; 0 = no cap)', type: 'string' },
+        { name: 'top', description: 'keep only the top N hidden pairs (default 30; 0 = all)', type: 'string' },
+        { name: 'csv', description: 'export the ranking as CSV (for spreadsheets)', type: 'boolean' },
+    ],
+    examples: [
+        { command: 'swarmdo hidden-coupling --since 6mo --min-shared 3', description: 'Strong co-change pairs with no code link, last 6 months' },
+        { command: 'swarmdo hidden-coupling --format json', description: 'Machine-readable hidden-coupling report' },
+    ],
+    action: run,
+};
+export default hiddenCouplingCommand;
+//# sourceMappingURL=hidden-coupling.js.map

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

@@ -54,6 +54,12 @@ const commandLoaders = {
     // Temporal (co-change) coupling from git history (code-maat demand) — file
     // pairs that change together; the empirical complement to `affected`.
     coupling: () => import('./coupling.js'),
+    // Per-file knowledge map + bus factor from git history (code-maat main-dev
+    // demand) — who owns each file, and what breaks if they leave.
+    ownership: () => import('./ownership.js'),
+    // Hidden coupling — co-change pairs with NO import edge (logical minus
+    // structural coupling); joins `coupling`'s git capture with codegraph's graph.
+    'hidden-coupling': () => import('./hidden-coupling.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'),
@@ -296,7 +302,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, couplingCmd, testreportCmd, compactSnapshotCmd,] = 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, couplingCmd, ownershipCmd, hiddenCouplingCmd, testreportCmd, compactSnapshotCmd,] = 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'),
@@ -304,7 +310,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('coupling'), loadCommand('testreport'), loadCommand('compact-snapshot'),
+        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('coupling'), loadCommand('ownership'), loadCommand('hidden-coupling'), loadCommand('testreport'), loadCommand('compact-snapshot'),
     ]);
     return {
         primary: [
@@ -320,7 +326,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, couplingCmd, testreportCmd, compactSnapshotCmd, efficiencyCmd,
+            statuslineCmd, compressCmd, compactCmd, redactCmd, packCmd, envCmd, licenseCmd, sbomCmd, applyCmd, hotspotsCmd, affectedCmd, cyclesCmd, couplingCmd, ownershipCmd, hiddenCouplingCmd, testreportCmd, compactSnapshotCmd, efficiencyCmd,
         ].filter(Boolean),
         analysis: [
             analyzeCmd, routeCmd, progressCmd, usageCmd, hudCmd, codegraphCmd,

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

@@ -0,0 +1,18 @@
+/**
+ * `swarmdo ownership` — per-file knowledge map + BUS FACTOR mined from git history.
+ *
+ *   swarmdo ownership                      # knowledge map, most fragile files first
+ *   swarmdo ownership src --since 90d       # scope to a path + window
+ *   swarmdo ownership --top 10 --format json
+ *   swarmdo ownership --csv > ownership.csv
+ *
+ * "Who owns each file, and what breaks if they leave?" — the code-maat
+ * main-dev / bus-factor analysis. Files where one author owns nearly all the
+ * churn (bus factor 1) are key-person risks. Pairs with `hotspots` (change-risk)
+ * and `coupling` (co-change). Engine (../ownership/ownership.ts) is pure +
+ * tested; this captures the git log (the same `--numstat` dump those use).
+ */
+import type { Command } from '../types.js';
+export declare const ownershipCommand: Command;
+export default ownershipCommand;
+//# sourceMappingURL=ownership.d.ts.map

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

@@ -0,0 +1,88 @@
+/**
+ * `swarmdo ownership` — per-file knowledge map + BUS FACTOR mined from git history.
+ *
+ *   swarmdo ownership                      # knowledge map, most fragile files first
+ *   swarmdo ownership src --since 90d       # scope to a path + window
+ *   swarmdo ownership --top 10 --format json
+ *   swarmdo ownership --csv > ownership.csv
+ *
+ * "Who owns each file, and what breaks if they leave?" — the code-maat
+ * main-dev / bus-factor analysis. Files where one author owns nearly all the
+ * churn (bus factor 1) are key-person risks. Pairs with `hotspots` (change-risk)
+ * and `coupling` (co-change). Engine (../ownership/ownership.ts) is pure +
+ * tested; this captures the git log (the same `--numstat` dump those use).
+ */
+import { execFileSync } from 'node:child_process';
+import { output } from '../output.js';
+import { parseGitLog } from '../hotspots/hotspots.js';
+import { computeOwnership, repoBusFactor, formatOwnership, ownershipToCsv } from '../ownership/ownership.js';
+import { normalizeSince } from '../util/since.js';
+/** Read a numeric flag that the parser may deliver as a number OR a string. */
+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 pathArg = ctx.args[0];
+    const since = typeof ctx.flags.since === 'string' ? ctx.flags.since : '1 year ago';
+    const top = numFlag(ctx.flags.top, 40);
+    const minChurn = numFlag(ctx.flags['min-churn'], 1);
+    const asJson = ctx.flags.format === 'json';
+    const asCsv = ctx.flags.csv === true;
+    // Same SOH-delimited numstat capture `hotspots` uses. `%aN` folds author
+    // name/email variants through `.mailmap` so one person is one owner. A
+    // positional pathspec scopes BOTH the file rows and the truck factor to that
+    // subtree (unlike `coupling`, per-file ownership survives a pathspec fine).
+    const args = ['log', '--no-merges', '--numstat', `--since=${normalizeSince(since)}`, '--format=format:%x01%H%x1f%aN%x1f%aI'];
+    if (pathArg)
+        args.push('--', pathArg);
+    let raw;
+    try {
+        raw = execFileSync('git', args, { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 128 * 1024 * 1024 });
+    }
+    catch {
+        output.printError('git log failed — is this a git repository?');
+        return { success: false, exitCode: 1 };
+    }
+    const commits = parseGitLog(raw);
+    const files = computeOwnership(commits, { minChurn, top: top > 0 ? top : undefined });
+    const repo = repoBusFactor(commits);
+    if (asCsv) {
+        process.stdout.write(ownershipToCsv(files) + '\n');
+    }
+    else if (asJson) {
+        process.stdout.write(JSON.stringify({ generated: new Date().toISOString(), since, minChurn, repoBusFactor: repo, count: files.length, ownership: files }, null, 2) + '\n');
+    }
+    else if (files.length === 0) {
+        output.writeln(output.dim('no ownership data found — no matching git history in the window'));
+    }
+    else {
+        output.writeln(output.bold(`File ownership & bus factor (since ${since})`));
+        if (repo.factor > 0) {
+            const who = repo.authors.length <= 3 ? repo.authors.join(', ') : `${repo.authors.slice(0, 3).join(', ')} +${repo.authors.length - 3}`;
+            const flag = repo.factor === 1 ? '  ⚠ single point of knowledge' : '';
+            output.writeln(output.dim(`Repo truck factor: ${repo.factor} (${who} own >50% of churn)${flag}`));
+        }
+        output.writeln(formatOwnership(files));
+    }
+    return { success: true, exitCode: 0 };
+}
+export const ownershipCommand = {
+    name: 'ownership',
+    description: 'Map per-file authorship concentration + bus factor from git history — find the key-person risks (code-maat main-dev / knowledge map)',
+    options: [
+        { name: 'since', description: 'history window, e.g. 90d or "3 months ago" (default 1 year)', type: 'string' },
+        { name: 'top', description: 'keep only the top N files (default 40; 0 = all)', type: 'string' },
+        { name: 'min-churn', description: 'drop files with total churn below N (default 1)', type: 'string' },
+        { name: 'csv', description: 'export the knowledge map as CSV (for spreadsheets)', type: 'boolean' },
+    ],
+    examples: [
+        { command: 'swarmdo ownership src --since 6mo', description: 'Knowledge map under src/ in the last 6 months' },
+        { command: 'swarmdo ownership --top 10 --format json', description: 'Ten most fragile files as JSON, with repo truck factor' },
+        { command: 'swarmdo ownership --csv > ownership.csv', description: 'Export the ownership map to CSV' },
+    ],
+    action: run,
+};
+export default ownershipCommand;
+//# sourceMappingURL=ownership.js.map

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

@@ -78,13 +78,13 @@ function walk(o) {
             if (e.isDirectory()) {
                 if (SKIP_DIRS.has(e.name))
                     continue;
-                if (o.gitignore?.(rel + '/'))
-                    continue;
+                if (o.gitignore?.(rel, true))
+                    continue; // isDir=true → dir-only patterns (build/) prune the dir + its contents
                 stack.push(full);
             }
             else if (e.isFile()) {
-                if (o.gitignore?.(rel))
-                    continue;
+                if (o.gitignore?.(rel, false))
+                    continue; // isDir=false → a dir-only pattern (build/) must NOT drop a file named `build`
                 if (o.exclude?.(rel))
                     continue;
                 if (o.include && !o.include(rel))

package/v3/@swarmdo/cli/dist/src/config-lint/commands-lint.d.ts

@@ -0,0 +1,31 @@
+/**
+ * commands-lint.ts — static validation of Claude Code custom slash commands
+ * (the `.claude/commands` tree) and skills (`.claude/skills/<name>/SKILL.md`).
+ *
+ * Slash commands / skills are the most-copied Claude Code power-user artifact,
+ * and CC swallows their footguns silently: malformed YAML frontmatter makes CC
+ * load the body with EMPTY metadata (so `/cmd` "works" typed but Claude can
+ * never auto-match it), and two body rules bite in ways manual review misses —
+ * an inline `` !`cmd` `` that isn't at a line start / after whitespace is left as
+ * literal text and NEVER runs, and one whose command no `allowed-tools` Bash
+ * rule covers prompts/blocks instead of running pre-approved. This catches those
+ * before CC does. Sibling of agents-lint; same `Finding` shape.
+ *
+ * Pure: parsed text in, findings out. Reuses the permission-rule matcher
+ * (parseRule/covers) so allowed-tools coverage matches Claude Code's own glob
+ * semantics. Only truly-bounded fields are enum-checked (NOT `model`, which
+ * accepts aliases and full IDs) to stay false-positive-safe.
+ */
+import type { Finding } from './lint.js';
+/** Reasoning-effort levels a command/skill `effort:` field may name. */
+export declare const EFFORT_LEVELS: string[];
+/** Lint ONE command/skill file's raw text. `kind` toggles the skill-only rule
+ * that frontmatter (with name + description) is REQUIRED. Pure. */
+export declare function lintCommandFile(file: string, raw: string, kind?: 'command' | 'skill'): Finding[];
+export interface CommandFile {
+    file: string;
+    raw: string;
+}
+/** Lint a set of command files and skill files. Pure. */
+export declare function lintCommandFiles(commands: CommandFile[], skills?: CommandFile[]): Finding[];
+//# sourceMappingURL=commands-lint.d.ts.map

package/v3/@swarmdo/cli/dist/src/config-lint/commands-lint.js

@@ -0,0 +1,127 @@
+/**
+ * commands-lint.ts — static validation of Claude Code custom slash commands
+ * (the `.claude/commands` tree) and skills (`.claude/skills/<name>/SKILL.md`).
+ *
+ * Slash commands / skills are the most-copied Claude Code power-user artifact,
+ * and CC swallows their footguns silently: malformed YAML frontmatter makes CC
+ * load the body with EMPTY metadata (so `/cmd` "works" typed but Claude can
+ * never auto-match it), and two body rules bite in ways manual review misses —
+ * an inline `` !`cmd` `` that isn't at a line start / after whitespace is left as
+ * literal text and NEVER runs, and one whose command no `allowed-tools` Bash
+ * rule covers prompts/blocks instead of running pre-approved. This catches those
+ * before CC does. Sibling of agents-lint; same `Finding` shape.
+ *
+ * Pure: parsed text in, findings out. Reuses the permission-rule matcher
+ * (parseRule/covers) so allowed-tools coverage matches Claude Code's own glob
+ * semantics. Only truly-bounded fields are enum-checked (NOT `model`, which
+ * accepts aliases and full IDs) to stay false-positive-safe.
+ */
+import { parse as parseYaml } from 'yaml';
+import { parseRule, covers } from '../permissions/audit.js';
+const f = (file, severity, rule, message) => ({ file, severity, rule, message });
+/** Reasoning-effort levels a command/skill `effort:` field may name. */
+export const EFFORT_LEVELS = ['low', 'medium', 'high', 'xhigh', 'max'];
+const FRONTMATTER_RE = /^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n([\s\S]*))?$/;
+function parseFile(raw) {
+    const text = raw.replace(/^\uFEFF/, '');
+    const m = text.match(FRONTMATTER_RE);
+    if (!m) {
+        // An opening `---` with no closing fence is malformed; anything else is a
+        // plain-markdown command (no frontmatter — perfectly valid).
+        if (/^---[ \t]*\r?\n/.test(text))
+            return { meta: null, body: text, malformed: 'has an opening `---` but no closing `---` fence' };
+        return { meta: null, body: text };
+    }
+    const body = m[2] ?? '';
+    let fm;
+    try {
+        fm = parseYaml(m[1]);
+    }
+    catch (e) {
+        return { meta: null, body, malformed: `frontmatter is not valid YAML: ${e.message}` };
+    }
+    if (fm === null || typeof fm !== 'object' || Array.isArray(fm)) {
+        return { meta: null, body, malformed: 'frontmatter must be a YAML mapping of key: value' };
+    }
+    return { meta: fm, body };
+}
+/**
+ * Inline bash-injection placeholders `` !`cmd` `` in the body. Claude Code only
+ * RUNS one whose `!` is at a line start or immediately after whitespace; if `!`
+ * follows another character (e.g. `` KEY=!`cmd` ``) it is left as literal text.
+ */
+function bashInjections(body) {
+    const out = [];
+    const re = /!`([^`\n]+)`/g;
+    let m;
+    while ((m = re.exec(body)) !== null) {
+        const at = m.index;
+        const active = at === 0 || /\s/.test(body[at - 1]);
+        out.push({ cmd: m[1].trim(), active });
+    }
+    return out;
+}
+/** Parse the `allowed-tools` frontmatter (string list or YAML array) into rules;
+ * null = the key is absent (no pre-approval declared, so coverage isn't checked). */
+function allowedToolRules(meta) {
+    const at = meta['allowed-tools'] ?? meta['allowedTools'];
+    if (at === undefined)
+        return null;
+    const parts = Array.isArray(at) ? at.map(String) : typeof at === 'string' ? at.split(',') : [];
+    const rules = [];
+    for (const p of parts) {
+        const r = parseRule(p.trim());
+        if (r.tool !== undefined)
+            rules.push(r);
+    }
+    return rules;
+}
+/** Lint ONE command/skill file's raw text. `kind` toggles the skill-only rule
+ * that frontmatter (with name + description) is REQUIRED. Pure. */
+export function lintCommandFile(file, raw, kind = 'command') {
+    const p = parseFile(raw);
+    const out = [];
+    if (p.malformed) {
+        out.push(f(file, 'error', 'command-malformed-frontmatter', p.malformed));
+    }
+    else if (kind === 'skill' && !p.meta) {
+        out.push(f(file, 'error', 'skill-missing-frontmatter', 'a SKILL.md must start with a `---` … `---` frontmatter block declaring `name` and `description`'));
+    }
+    const meta = p.meta;
+    if (meta) {
+        if (kind === 'skill' && (typeof meta.name !== 'string' || meta.name.trim() === '')) {
+            out.push(f(file, 'error', 'skill-missing-name', 'frontmatter is missing a non-empty `name`'));
+        }
+        if (typeof meta.description !== 'string' || meta.description.trim() === '') {
+            const how = kind === 'skill' ? 'decide when to invoke the skill' : 'list the command and model-invoke it';
+            out.push(f(file, kind === 'skill' ? 'error' : 'warn', 'command-missing-description', `frontmatter has no non-empty \`description\` (Claude Code uses it to ${how})`));
+        }
+        if (meta.effort !== undefined && !EFFORT_LEVELS.includes(String(meta.effort))) {
+            out.push(f(file, 'error', 'command-bad-effort', `effort "${String(meta.effort)}" is not one of: ${EFFORT_LEVELS.join(', ')}`));
+        }
+    }
+    // Body cross-checks (both kinds). Coverage is only checked when allowed-tools
+    // is declared — otherwise the author never opted into pre-approval.
+    const rules = meta ? allowedToolRules(meta) : null;
+    for (const inj of bashInjections(p.body)) {
+        const tok = '!`' + inj.cmd + '`';
+        if (!inj.active) {
+            out.push(f(file, 'warn', 'command-inert-bash-injection', `inline bash ${tok} follows a non-whitespace character — Claude Code leaves it as literal text and never runs it (put \`!\` at a line start or after whitespace)`));
+            continue;
+        }
+        if (rules && rules.length > 0 && !rules.some((r) => covers(r, { tool: 'Bash', specifier: inj.cmd }))) {
+            out.push(f(file, 'warn', 'command-uncovered-bash-injection', `inline bash ${tok} is not covered by any \`allowed-tools\` Bash rule — it will prompt/block instead of running pre-approved`));
+        }
+    }
+    return out;
+}
+/** Lint a set of command files and skill files. Pure. */
+export function lintCommandFiles(commands, skills = []) {
+    const out = [];
+    for (const c of commands)
+        out.push(...lintCommandFile(c.file, c.raw, 'command'));
+    for (const s of skills)
+        out.push(...lintCommandFile(s.file, s.raw, 'skill'));
+    return out;
+}
+//# sourceMappingURL=commands-lint.js.map

package/v3/@swarmdo/cli/dist/src/config-lint/lint.d.ts

@@ -18,6 +18,7 @@ export interface Finding {
 export declare const TOPOLOGIES: string[];
 export declare const MEMORY_BACKENDS: string[];
 import { type AgentFile } from './agents-lint.js';
+import { type CommandFile } from './commands-lint.js';
 export declare const KNOWN_CONFIG_KEYS: string[];
 export declare const HOOK_EVENTS: string[];
 /** Parse a JSON file's raw text; a null raw means "file absent" (fine). */
@@ -52,6 +53,10 @@ export interface LintInput {
     skills?: string[];
     /** `.claude/agents/*.md` subagent definitions (raw text per file) */
     agentFiles?: AgentFile[];
+    /** custom slash commands under the `.claude/commands` tree (raw text per file) */
+    commandFiles?: CommandFile[];
+    /** skill definitions at `.claude/skills/<name>/SKILL.md` (raw text per file) */
+    skillFiles?: CommandFile[];
 }
 export interface LintReport {
     findings: Finding[];

package/v3/@swarmdo/cli/dist/src/config-lint/lint.js

@@ -13,6 +13,7 @@ export const TOPOLOGIES = ['hierarchical', 'mesh', 'hierarchical-mesh', 'ring',
 export const MEMORY_BACKENDS = ['agentdb', 'sqlite', 'hybrid', 'memory'];
 import { parseOpenRouterConfig } from '../providers/openrouter-config.js';
 import { lintAgents } from './agents-lint.js';
+import { lintCommandFiles } from './commands-lint.js';
 export const KNOWN_CONFIG_KEYS = ['topology', 'maxAgents', 'strategy', 'consensus', 'memory', 'memoryBackend', 'hnsw', 'neural', 'embeddings', 'providers', 'mcp', 'logging', 'daemon', 'hooks', 'version', 'openrouter', '$schema'];
 // Current Claude Code hook events (source: code.claude.com/docs/en/hooks).
 // Kept in sync with the runtime; a stale list here false-warns on valid hooks.
@@ -197,6 +198,9 @@ export function lintAll(input) {
     findings.push(...lintLegacyLayout(input.commandsRoot ?? [], input.skills ?? [], input.sdoCommands ?? []));
     if (input.agentFiles?.length)
         findings.push(...lintAgents(input.agentFiles));
+    if (input.commandFiles?.length || input.skillFiles?.length) {
+        findings.push(...lintCommandFiles(input.commandFiles ?? [], input.skillFiles ?? []));
+    }
     return {
         findings,
         errors: findings.filter((x) => x.severity === 'error').length,

package/v3/@swarmdo/cli/dist/src/coupling/hidden.d.ts

@@ -0,0 +1,45 @@
+/**
+ * hidden.ts — HIDDEN coupling: files that change together but have no import
+ * edge to explain it. "Logical coupling minus structural coupling."
+ *
+ * `coupling` mines temporal (co-change) coupling from git; `codegraph` builds
+ * the static import graph. Join them and emit the SET DIFFERENCE: pairs with a
+ * high co-change degree yet NO import edge connecting them in either direction.
+ * That's a dependency real enough to move two files in lockstep but invisible in
+ * the code — a JSON schema and the type that mirrors it, a serializer/parser
+ * split across modules, a config file and its consumers, a doc that must track
+ * an API. An agent editing A won't reach B by following imports, so it forgets
+ * the co-edit; a reviewer sees a missing abstraction / architectural smell.
+ *
+ * This is the divergence between evolutionary coupling (Gall et al., "Detection
+ * of Logical Coupling," ICSM 1998) and structural coupling — CodeScene flags
+ * change-coupling that crosses architectural boundaries as "surprising." swarmdo
+ * is uniquely positioned to compute it because it already owns BOTH captures.
+ *
+ * Pure + deterministic: a set-difference over two already-built inputs (the
+ * ranked CouplingPair[] from computeCoupling + the ImportEdge[] from the index).
+ * No git, no fs — fully fixture-testable.
+ */
+import type { CouplingPair } from './coupling.js';
+import type { ImportEdge } from '../codegraph/codegraph.js';
+export interface AnnotatedPair extends CouplingPair {
+    /** true iff an import edge connects a↔b in EITHER direction (a structural link
+     * that explains the co-change); the returned pairs are all `false`. */
+    importLinked: boolean;
+}
+export interface HiddenCouplingOptions {
+    /** keep only the top N hidden pairs after ranking (default: all) */
+    top?: number;
+}
+/**
+ * Return the co-change pairs that NO import edge explains, ranked as they came
+ * from `computeCoupling` (degree desc, shared desc, path order). A type-only
+ * import still counts as a structural link — it's a real code reference that
+ * explains the co-change — so those pairs are excluded too. Pure.
+ */
+export declare function computeHiddenCoupling(pairs: CouplingPair[], imports: ImportEdge[], opts?: HiddenCouplingOptions): AnnotatedPair[];
+/** Export the hidden-coupling ranking as CSV for review. Pure. */
+export declare function hiddenCouplingToCsv(pairs: AnnotatedPair[]): string;
+/** Human-readable table. Pure. */
+export declare function formatHiddenCoupling(pairs: AnnotatedPair[]): string;
+//# sourceMappingURL=hidden.d.ts.map

package/v3/@swarmdo/cli/dist/src/coupling/hidden.js

@@ -0,0 +1,66 @@
+/**
+ * hidden.ts — HIDDEN coupling: files that change together but have no import
+ * edge to explain it. "Logical coupling minus structural coupling."
+ *
+ * `coupling` mines temporal (co-change) coupling from git; `codegraph` builds
+ * the static import graph. Join them and emit the SET DIFFERENCE: pairs with a
+ * high co-change degree yet NO import edge connecting them in either direction.
+ * That's a dependency real enough to move two files in lockstep but invisible in
+ * the code — a JSON schema and the type that mirrors it, a serializer/parser
+ * split across modules, a config file and its consumers, a doc that must track
+ * an API. An agent editing A won't reach B by following imports, so it forgets
+ * the co-edit; a reviewer sees a missing abstraction / architectural smell.
+ *
+ * This is the divergence between evolutionary coupling (Gall et al., "Detection
+ * of Logical Coupling," ICSM 1998) and structural coupling — CodeScene flags
+ * change-coupling that crosses architectural boundaries as "surprising." swarmdo
+ * is uniquely positioned to compute it because it already owns BOTH captures.
+ *
+ * Pure + deterministic: a set-difference over two already-built inputs (the
+ * ranked CouplingPair[] from computeCoupling + the ImportEdge[] from the index).
+ * No git, no fs — fully fixture-testable.
+ */
+import { toCsv } from '../util/csv.js';
+const US = '\x1f'; // pair-key separator (never appears in a file path)
+/** Canonical undirected pair key so direction doesn't matter. */
+const pairKey = (a, b) => (a < b ? a + US + b : b + US + a);
+/**
+ * Return the co-change pairs that NO import edge explains, ranked as they came
+ * from `computeCoupling` (degree desc, shared desc, path order). A type-only
+ * import still counts as a structural link — it's a real code reference that
+ * explains the co-change — so those pairs are excluded too. Pure.
+ */
+export function computeHiddenCoupling(pairs, imports, opts = {}) {
+    // Every file pair connected by a resolved import edge, either direction.
+    const linked = new Set();
+    for (const e of imports) {
+        if (e.resolved)
+            linked.add(pairKey(e.from, e.resolved));
+    }
+    const hidden = pairs
+        .map((p) => ({ ...p, importLinked: linked.has(pairKey(p.a, p.b)) }))
+        .filter((p) => !p.importLinked);
+    return opts.top && opts.top > 0 ? hidden.slice(0, opts.top) : hidden;
+}
+/** Export the hidden-coupling ranking as CSV for review. Pure. */
+export function hiddenCouplingToCsv(pairs) {
+    const headers = ['fileA', 'fileB', 'degree', 'shared', 'commitsA', 'commitsB'];
+    const rows = pairs.map((p) => [p.a, p.b, p.degree, p.shared, p.aCommits, p.bCommits]);
+    return toCsv(headers, rows);
+}
+/** Human-readable table. Pure. */
+export function formatHiddenCoupling(pairs) {
+    if (pairs.length === 0)
+        return 'no hidden coupling found (every co-change pair has an import edge, or none met the threshold)';
+    const lines = [];
+    lines.push('rank  degree  shared  commits(A/B)  files (co-change, no import edge)');
+    pairs.forEach((p, i) => {
+        const rank = String(i + 1).padStart(4);
+        const degree = `${Math.round(p.degree * 100)}%`.padStart(6);
+        const shared = String(p.shared).padStart(6);
+        const ab = `${p.aCommits}/${p.bCommits}`.padStart(11);
+        lines.push(`${rank}  ${degree}  ${shared}  ${ab}  ${p.a}  ⇢  ${p.b}`);
+    });
+    return lines.join('\n');
+}
+//# sourceMappingURL=hidden.js.map

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

@@ -27,6 +27,7 @@ import { licenseTools } from './mcp-tools/license-tools.js';
 import { applyTools } from './mcp-tools/apply-tools.js';
 import { hotspotsTools } from './mcp-tools/hotspots-tools.js';
 import { couplingTools } from './mcp-tools/coupling-tools.js';
+import { ownershipTools } from './mcp-tools/ownership-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';
@@ -121,6 +122,7 @@ const TOOL_GROUPS = {
     apply: () => applyTools,
     hotspots: () => hotspotsTools,
     coupling: () => couplingTools,
+    ownership: () => ownershipTools,
     affected: () => affectedTools,
     cycles: () => cyclesTools,
     testreport: () => testreportTools,

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

@@ -23,6 +23,7 @@ export { licenseTools } from './license-tools.js';
 export { applyTools } from './apply-tools.js';
 export { hotspotsTools } from './hotspots-tools.js';
 export { couplingTools } from './coupling-tools.js';
+export { ownershipTools } from './ownership-tools.js';
 export { affectedTools } from './affected-tools.js';
 export { cyclesTools } from './cycles-tools.js';
 export { testreportTools } from './testreport-tools.js';

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

@@ -22,6 +22,7 @@ export { licenseTools } from './license-tools.js';
 export { applyTools } from './apply-tools.js';
 export { hotspotsTools } from './hotspots-tools.js';
 export { couplingTools } from './coupling-tools.js';
+export { ownershipTools } from './ownership-tools.js';
 export { affectedTools } from './affected-tools.js';
 export { cyclesTools } from './cycles-tools.js';
 export { testreportTools } from './testreport-tools.js';

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

@@ -0,0 +1,14 @@
+/**
+ * Ownership MCP Tool
+ *
+ * Let an agent ask "who owns this file, and is it a bus-factor-1 key-person
+ * file?" and get ranked JSON — the risk/reviewer dimension it is otherwise
+ * blind to. An agent about to refactor a fragile single-owner file gets the
+ * signal that the change needs extra care, and "who should review this" gets a
+ * data-backed answer (the file's main-dev). Completes the git-mining trio's
+ * agent-callable set (hotspots + coupling + ownership). Shares the pure engine
+ * in ../ownership/ownership.ts with the CLI; captures git history via subprocess.
+ */
+import type { MCPTool } from './types.js';
+export declare const ownershipTools: MCPTool[];
+//# sourceMappingURL=ownership-tools.d.ts.map

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

@@ -0,0 +1,51 @@
+/**
+ * Ownership MCP Tool
+ *
+ * Let an agent ask "who owns this file, and is it a bus-factor-1 key-person
+ * file?" and get ranked JSON — the risk/reviewer dimension it is otherwise
+ * blind to. An agent about to refactor a fragile single-owner file gets the
+ * signal that the change needs extra care, and "who should review this" gets a
+ * data-backed answer (the file's main-dev). Completes the git-mining trio's
+ * agent-callable set (hotspots + coupling + ownership). Shares the pure engine
+ * in ../ownership/ownership.ts with the CLI; captures git history via subprocess.
+ */
+import { execFileSync } from 'node:child_process';
+import { parseGitLog } from '../hotspots/hotspots.js';
+import { computeOwnership, repoBusFactor } from '../ownership/ownership.js';
+import { normalizeSince } from '../util/since.js';
+const ownershipTool = {
+    name: 'ownership',
+    description: 'Map per-file authorship concentration + bus factor from git history — "who owns each file, and what breaks if they leave?" (code-maat main-dev / knowledge map). Returns ranked JSON, most-fragile-first, so an agent editing a file knows if it is a single-owner (bus factor 1) key-person risk that needs extra care, and who its main-dev reviewer is. Includes a repo-level truck factor. Runs in a git repository.',
+    category: 'ownership',
+    tags: ['git', 'ownership', 'bus-factor', 'knowledge-map', 'risk', 'review'],
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'repo path to run in (default cwd)' },
+            since: { type: 'string', description: 'history window, e.g. 90d or "3 months ago" (default 1 year)' },
+            top: { type: 'number', description: 'keep only the top N files (default 40; 0 = all)' },
+            minChurn: { type: 'number', description: 'drop files with total churn below N (default 1)' },
+        },
+    },
+    handler: async (params) => {
+        const cwd = typeof params.path === 'string' ? params.path : process.cwd();
+        const since = typeof params.since === 'string' ? params.since : '1 year ago';
+        const top = typeof params.top === 'number' ? params.top : 40;
+        const minChurn = typeof params.minChurn === 'number' ? params.minChurn : 1;
+        // Same `--numstat` dump `hotspots`/`coupling` parse; `%aN` folds author
+        // name/email variants through .mailmap so one person is one owner.
+        const args = ['log', '--no-merges', '--numstat', `--since=${normalizeSince(since)}`, '--format=format:%x01%H%x1f%aN%x1f%aI'];
+        let raw;
+        try {
+            raw = execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 128 * 1024 * 1024 });
+        }
+        catch {
+            return { error: true, message: 'git log failed — not a git repository?' };
+        }
+        const commits = parseGitLog(raw);
+        const ownership = computeOwnership(commits, { minChurn, top: top > 0 ? top : undefined });
+        return { since, minChurn, repoBusFactor: repoBusFactor(commits), count: ownership.length, ownership };
+    },
+};
+export const ownershipTools = [ownershipTool];
+//# sourceMappingURL=ownership-tools.js.map

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

@@ -28,6 +28,7 @@ const LEAN_GROUPS = [
     'apply', // apply_patch — fuzzy unified-diff applier for agent edits
     'hotspots', // hotspots — git-history change-risk ranking ("where's the debt?")
     'coupling', // coupling — files that change together (temporal co-change), complements affected
+    'ownership', // ownership — per-file bus factor / knowledge map (who owns it, key-person risk)
     '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)

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

@@ -0,0 +1,61 @@
+/**
+ * ownership.ts — per-file authorship concentration + BUS FACTOR from git history.
+ *
+ * "Who owns this file, and what breaks if they leave?" answered from data. For
+ * every file we compute the dominant author (main-dev), how concentrated the
+ * churn is in that one person (ownership share), how many hands have touched it,
+ * and its bus factor — the smallest set of top authors whose combined churn
+ * clears half the file. A bus factor of 1 is a key-person risk: one departure
+ * orphans the file. A repo-level "truck factor" answers the same question for
+ * the whole codebase.
+ *
+ * This is the code-maat `main-dev` / `entity-ownership` analysis (Tornhill,
+ * *Your Code as a Crime Scene*), surfaced as CodeScene's "Knowledge Map" and
+ * "Bus Factor". The scoring core is a pure fold over the SAME `git log --numstat`
+ * dump `hotspots`/`coupling` already parse — it reuses that Commit type +
+ * parseGitLog and is unit-tested without a repo. `%aN` (mailmap-folded author)
+ * means name/email variants of one person count as one owner.
+ */
+import type { Commit } from '../hotspots/hotspots.js';
+export interface FileOwnership {
+    path: string;
+    /** dominant author: most churn, tie → most commits, tie → name ascending */
+    owner: string;
+    /** owner churn / total file churn ∈ (0,1]; 1.0 = a single hand */
+    ownership: number;
+    /** distinct authors who touched the file */
+    authors: number;
+    /** total added+deleted across all commits */
+    churn: number;
+    /** commits touching the file */
+    commits: number;
+    /** smallest # of top-churn authors whose cumulative churn EXCEEDS 50% */
+    busFactor: number;
+    /** busFactor === 1 — a single point of knowledge (one departure orphans it) */
+    keyPersonRisk: boolean;
+}
+export interface RepoBusFactor {
+    /** the covering set: fewest top authors whose cumulative churn exceeds 50% */
+    authors: string[];
+    /** authors.length — the repo "truck factor" */
+    factor: number;
+}
+export interface OwnershipOptions {
+    /** drop files with total churn below this (default 1 → skips pure-binary edits) */
+    minChurn?: number;
+    /** keep only the top N files after ranking (default: all) */
+    top?: number;
+}
+/** Aggregate commits into per-file ownership, scored and ranked. Pure. */
+export declare function computeOwnership(commits: Commit[], opts?: OwnershipOptions): FileOwnership[];
+/**
+ * Repo-level truck factor: the fewest top authors whose combined churn across
+ * the WHOLE history exceeds half the total. If that set is one person, a single
+ * departure takes the majority of the codebase's institutional knowledge. Pure.
+ */
+export declare function repoBusFactor(commits: Commit[]): RepoBusFactor;
+/** Export the knowledge map as CSV for spreadsheets / staffing review. Pure. */
+export declare function ownershipToCsv(files: FileOwnership[]): string;
+/** Human-readable knowledge map. Pure. */
+export declare function formatOwnership(files: FileOwnership[]): string;
+//# sourceMappingURL=ownership.d.ts.map

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

@@ -0,0 +1,151 @@
+/**
+ * ownership.ts — per-file authorship concentration + BUS FACTOR from git history.
+ *
+ * "Who owns this file, and what breaks if they leave?" answered from data. For
+ * every file we compute the dominant author (main-dev), how concentrated the
+ * churn is in that one person (ownership share), how many hands have touched it,
+ * and its bus factor — the smallest set of top authors whose combined churn
+ * clears half the file. A bus factor of 1 is a key-person risk: one departure
+ * orphans the file. A repo-level "truck factor" answers the same question for
+ * the whole codebase.
+ *
+ * This is the code-maat `main-dev` / `entity-ownership` analysis (Tornhill,
+ * *Your Code as a Crime Scene*), surfaced as CodeScene's "Knowledge Map" and
+ * "Bus Factor". The scoring core is a pure fold over the SAME `git log --numstat`
+ * dump `hotspots`/`coupling` already parse — it reuses that Commit type +
+ * parseGitLog and is unit-tested without a repo. `%aN` (mailmap-folded author)
+ * means name/email variants of one person count as one owner.
+ */
+import { toCsv } from '../util/csv.js';
+/**
+ * Bus factor of a churn distribution: the smallest number of top-churn authors
+ * whose cumulative churn STRICTLY exceeds half the total. An author sitting at
+ * exactly 50% is not enough on their own (you'd need one more), which is what
+ * makes an even two-way split a bus factor of 2. Pure.
+ */
+function busFactorOf(authors, total) {
+    const byChurn = authors.slice().sort((x, y) => y.churn - x.churn || (x.name < y.name ? -1 : x.name > y.name ? 1 : 0));
+    const threshold = total / 2;
+    let cum = 0;
+    let k = 0;
+    for (const a of byChurn) {
+        cum += a.churn;
+        k++;
+        if (cum > threshold)
+            break;
+    }
+    return Math.max(1, k);
+}
+/** Aggregate commits into per-file ownership, scored and ranked. Pure. */
+export function computeOwnership(commits, opts = {}) {
+    const minChurn = opts.minChurn ?? 1;
+    const acc = new Map();
+    for (const c of commits) {
+        // Fold this commit's numstat lines into per-path churn first, so a path that
+        // appears twice in one commit (rename collisions) counts as ONE commit.
+        const perPath = new Map();
+        for (const f of c.files) {
+            if (!f.path)
+                continue;
+            perPath.set(f.path, (perPath.get(f.path) ?? 0) + f.added + f.deleted);
+        }
+        for (const [path, churn] of perPath) {
+            let fa = acc.get(path);
+            if (!fa) {
+                fa = { churn: 0, commits: 0, byAuthor: new Map() };
+                acc.set(path, fa);
+            }
+            fa.churn += churn;
+            fa.commits += 1;
+            let a = fa.byAuthor.get(c.author);
+            if (!a) {
+                a = { name: c.author, churn: 0, commits: 0 };
+                fa.byAuthor.set(c.author, a);
+            }
+            a.churn += churn;
+            a.commits += 1;
+        }
+    }
+    const out = [];
+    for (const [path, fa] of acc) {
+        if (fa.churn < minChurn)
+            continue;
+        const authors = [...fa.byAuthor.values()];
+        // owner: most churn, tie → most commits (sustained involvement), tie → name asc
+        const owner = authors
+            .slice()
+            .sort((x, y) => y.churn - x.churn || y.commits - x.commits || (x.name < y.name ? -1 : x.name > y.name ? 1 : 0))[0];
+        const ownership = fa.churn > 0 ? Math.round((owner.churn / fa.churn) * 100) / 100 : 0;
+        const busFactor = busFactorOf(authors, fa.churn);
+        out.push({
+            path,
+            owner: owner.name,
+            ownership,
+            authors: authors.length,
+            churn: fa.churn,
+            commits: fa.commits,
+            busFactor,
+            keyPersonRisk: busFactor === 1,
+        });
+    }
+    // Deterministic ranking: most fragile first — lowest bus factor, then most
+    // concentrated (ownership desc), then most churn, then path asc for stable ties.
+    out.sort((x, y) => x.busFactor - y.busFactor ||
+        y.ownership - x.ownership ||
+        y.churn - x.churn ||
+        (x.path < y.path ? -1 : x.path > y.path ? 1 : 0));
+    return opts.top && opts.top > 0 ? out.slice(0, opts.top) : out;
+}
+/**
+ * Repo-level truck factor: the fewest top authors whose combined churn across
+ * the WHOLE history exceeds half the total. If that set is one person, a single
+ * departure takes the majority of the codebase's institutional knowledge. Pure.
+ */
+export function repoBusFactor(commits) {
+    const byAuthor = new Map();
+    let total = 0;
+    for (const c of commits) {
+        for (const f of c.files) {
+            const ch = f.added + f.deleted;
+            byAuthor.set(c.author, (byAuthor.get(c.author) ?? 0) + ch);
+            total += ch;
+        }
+    }
+    const sorted = [...byAuthor.entries()].sort((x, y) => y[1] - x[1] || (x[0] < y[0] ? -1 : x[0] > y[0] ? 1 : 0));
+    const threshold = total / 2;
+    const authors = [];
+    let cum = 0;
+    for (const [name, ch] of sorted) {
+        authors.push(name);
+        cum += ch;
+        if (cum > threshold)
+            break;
+    }
+    return { authors, factor: authors.length };
+}
+/** Export the knowledge map as CSV for spreadsheets / staffing review. Pure. */
+export function ownershipToCsv(files) {
+    const headers = ['path', 'owner', 'ownership', 'busFactor', 'authors', 'churn', 'commits', 'keyPersonRisk'];
+    const rows = files.map((f) => [f.path, f.owner, f.ownership, f.busFactor, f.authors, f.churn, f.commits, f.keyPersonRisk]);
+    return toCsv(headers, rows);
+}
+/** Human-readable knowledge map. Pure. */
+export function formatOwnership(files) {
+    if (files.length === 0)
+        return 'no ownership data found (no matching history)';
+    const lines = [];
+    lines.push('rank  bus  own%   authors  churn   commits  owner                 file');
+    files.forEach((f, i) => {
+        const rank = String(i + 1).padStart(4);
+        const bus = String(f.busFactor).padStart(3);
+        const own = `${Math.round(f.ownership * 100)}%`.padStart(5);
+        const authors = String(f.authors).padStart(7);
+        const churn = String(f.churn).padStart(6);
+        const commits = String(f.commits).padStart(7);
+        const owner = (f.owner.length > 20 ? f.owner.slice(0, 19) + '…' : f.owner).padEnd(20);
+        const risk = f.keyPersonRisk ? '  ⚠ key-person' : '';
+        lines.push(`${rank}  ${bus}  ${own}  ${authors}  ${churn}  ${commits}  ${owner}  ${f.path}${risk}`);
+    });
+    return lines.join('\n');
+}
+//# sourceMappingURL=ownership.js.map

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

@@ -54,5 +54,5 @@ export declare function packFiles(input: PackFile[], opts?: PackOptions): PackRe
  * `dir/`, `*.ext` globs, `**` depth globs (gitignore(5) semantics), leading `/`
  * anchors, and `!` negation. Not the full spec (no nested ignore files).
  */
-export declare function makeIgnoreMatcher(patterns: string[]): (relPath: string) => boolean;
+export declare function makeIgnoreMatcher(patterns: string[]): (relPath: string, isDir?: boolean) => boolean;
 //# sourceMappingURL=pack.d.ts.map

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

@@ -201,19 +201,24 @@ export function makeIgnoreMatcher(patterns) {
         // Only a slash-free pattern (`dir`, `*.ext`) matches at any depth.
         const anchored = leadingSlash || body.includes('/');
         const re = new RegExp('^' + globToRegExp(body) + (dirOnly ? '(/|$)' : '($|/)'));
-        return { negate, anchored, re };
+        return { negate, anchored, dirOnly, re };
     });
     // Ignored status of a single path (last-match-wins over the ordered rules).
-    const ruleVerdict = (path) => {
+    // `isDirComponent` is whether the entry named by the path's LAST segment is a
+    // directory: a trailing-slash (dir-only) pattern matches directories ONLY per
+    // gitignore(5), so `build/` must NOT fire on a regular file named `build`.
+    const ruleVerdict = (path, isDirComponent) => {
         let ignored = false;
         for (const r of rules) {
+            if (r.dirOnly && !isDirComponent)
+                continue; // dir-only pattern can't match a file
             const candidates = r.anchored ? [path] : [path, ...path.split('/').map((_, i, a) => a.slice(i).join('/'))];
             if (candidates.some((c) => r.re.test(c)))
                 ignored = !r.negate;
         }
         return ignored;
     };
-    return (relPath) => {
+    return (relPath, isDir = false) => {
         // Walk ancestor dirs top-down: once a parent directory is excluded, the file
         // stays excluded — a negation cannot re-include under an excluded parent
         // (gitignore(5): "not possible to re-include a file if a parent directory of
@@ -227,7 +232,10 @@ export function makeIgnoreMatcher(patterns) {
                     return true;
                 continue; // excluded ancestor carries down
             }
-            const verdict = ruleVerdict(parts.slice(0, i + 1).join('/'));
+            // Ancestor prefixes are directories by construction; only the final entry's
+            // type comes from the caller (a filesystem walker knows dir vs file).
+            const componentIsDir = isLast ? isDir : true;
+            const verdict = ruleVerdict(parts.slice(0, i + 1).join('/'), componentIsDir);
             if (isLast)
                 return verdict;
             parentIgnored = verdict; // this directory prefix carries forward

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

@@ -53,9 +53,11 @@ export const RULES = [
  * values (paths, short flags) out. The value class also stops at the URL/query
  * delimiters `&`, `?`, `#` (absent from base64/base64url/hex token alphabets):
  * otherwise a query-string secret like `client_secret=…&api_key=…` over-captures
- * past the `&` into the next secret, and that inflated span — overlapping a range
- * the high-confidence RULES pass already claimed — gets dropped entirely, leaving
- * the first secret unredacted.
+ * past the `&` into the next secret. It CANNOT stop at `/ : . = + ~`, though —
+ * base64/base64url/connection-string secrets contain those — so a recognized
+ * token glued on by one of them still over-captures; the entropy pass in
+ * `collectHits` handles that by CLIPPING the span at the claimed range rather
+ * than dropping the finding (which would leak the leading secret, #100).
  */
 const ASSIGNMENT_RE = /(?<![A-Za-z])(?:pass(?:word|phrase|wd)?|pwd|secret|token|api[_-]?key|apikey|access[_-]?key|auth[_-]?token|client[_-]?secret|credential|creds|key)["']?\s*[:=]\s*["']?([^\s"'`,;&?#]{8,})/gi;
 /** Shannon entropy in bits/char. Pure; used by the assignment fallback. */
@@ -121,15 +123,32 @@ function collectHits(text, opts) {
         while ((m = ASSIGNMENT_RE.exec(text)) !== null) {
             const value = m[1];
             const start = m.index + m[0].indexOf(value);
-            const end = start + value.length;
-            if (overlaps(start, end))
-                continue;
-            if (isAllowlisted(value, opts.allowlist))
+            let end = start + value.length;
+            let match = value;
+            // The value class must include `/ : . = + ~` for base64/base64url/conn-string
+            // secrets, so a recognized RULES token (GitHub PAT, AWS key, …) glued on by
+            // one of those separators gets over-captured into this span. When that
+            // happens, DON'T drop the finding on overlap — the leading high-entropy
+            // secret would leak in cleartext (only the trailing token got masked, #100).
+            // Instead clip the span to end at the earliest claimed range within it and
+            // re-gate the leading fragment; the trailing token keeps its RULES redaction.
+            const overlapping = claimed.filter(([s, e]) => start < e && end > s);
+            if (overlapping.length > 0) {
+                // value's own start already sits inside a claimed secret → fully covered
+                if (overlapping.some(([s, e]) => s <= start && start < e))
+                    continue;
+                const clipTo = Math.min(...overlapping.map(([s]) => s));
+                match = text.slice(start, clipTo).replace(/[^A-Za-z0-9]+$/, ''); // drop the trailing separator
+                end = start + match.length;
+                if (match.length < 8)
+                    continue; // clipped leading fragment too short to be a secret
+            }
+            if (isAllowlisted(match, opts.allowlist))
                 continue;
-            if (shannonEntropy(value) < threshold)
+            if (shannonEntropy(match) < threshold)
                 continue;
             claimed.push([start, end]);
-            hits.push({ ruleId: 'high-entropy-assignment', description: 'High-entropy secret assignment', index: start, match: value });
+            hits.push({ ruleId: 'high-entropy-assignment', description: 'High-entropy secret assignment', index: start, match });
         }
     }
     return hits.sort((a, b) => a.index - b.index);

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

@@ -1,6 +1,6 @@
 {
   "name": "@swarmdo/cli",
-  "version": "1.45.0",
+  "version": "1.50.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",