swarmdo 1.45.0 → 1.54.1

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,16 @@ 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'),
+    // Weekend-aware "what did I do?" recall from git history (git-standup demand)
+    // — commits since your last working day, grouped by day with a diffstat.
+    standup: () => import('./standup.js'),
+    mine: () => import('./standup.js'), // alias via loader key
     // 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 +306,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, standupCmd,] = 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 +314,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'), loadCommand('standup'),
     ]);
     return {
         primary: [
@@ -320,10 +330,10 @@ 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,
+            analyzeCmd, routeCmd, progressCmd, usageCmd, hudCmd, codegraphCmd, standupCmd,
         ].filter(Boolean),
         management: [
             providersCmd, pluginsCmd, deploymentCmd, claimsCmd,

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/commands/standup.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `swarmdo standup` — recall what you committed since your last working day.
+ *
+ *   swarmdo standup                   # your commits since the last working day
+ *   swarmdo standup --all             # everyone's commits
+ *   swarmdo standup --author "Ada"    # a specific author (or: swarmdo standup Ada)
+ *   swarmdo standup --days 7          # explicit N-day window
+ *   swarmdo standup --since 2w        # explicit window (git approxidate)
+ *   swarmdo standup --format json     # machine-readable
+ *
+ * Weekend-aware (git-standup parity): on Monday it reaches back to Friday, on
+ * Sunday to Friday, otherwise to yesterday. Engine (../standup/standup.ts) is
+ * pure + tested; this thin layer captures the git log and renders.
+ */
+import type { Command } from '../types.js';
+export declare const standupCommand: Command;
+export default standupCommand;
+//# sourceMappingURL=standup.d.ts.map

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

@@ -0,0 +1,116 @@
+/**
+ * `swarmdo standup` — recall what you committed since your last working day.
+ *
+ *   swarmdo standup                   # your commits since the last working day
+ *   swarmdo standup --all             # everyone's commits
+ *   swarmdo standup --author "Ada"    # a specific author (or: swarmdo standup Ada)
+ *   swarmdo standup --days 7          # explicit N-day window
+ *   swarmdo standup --since 2w        # explicit window (git approxidate)
+ *   swarmdo standup --format json     # machine-readable
+ *
+ * Weekend-aware (git-standup parity): on Monday it reaches back to Friday, on
+ * Sunday to Friday, otherwise to yesterday. Engine (../standup/standup.ts) is
+ * pure + tested; this thin layer captures the git log and renders.
+ */
+import { execFileSync } from 'node:child_process';
+import { output } from '../output.js';
+import { parseStandupLog, groupByDay, sinceLastWorkingDay, formatStandup } from '../standup/standup.js';
+import { normalizeSince } from '../util/since.js';
+/** Read a non-negative numeric flag the parser may deliver as number OR string. */
+function numFlag(v) {
+    const n = typeof v === 'number' ? v : typeof v === 'string' ? parseInt(v, 10) : NaN;
+    return Number.isFinite(n) && n >= 0 ? n : undefined;
+}
+/** Resolve the default author (git config user.name); '' if unset/unavailable. */
+function gitUserName(root) {
+    try {
+        return execFileSync('git', ['config', 'user.name'], {
+            cwd: root,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+async function run(ctx) {
+    const root = ctx.cwd || process.cwd();
+    const asJson = ctx.flags.format === 'json';
+    const all = ctx.flags.all === true;
+    // Author: explicit --author, else positional arg, else current git user
+    // (unless --all, which clears the filter to show everyone).
+    const authorFlag = typeof ctx.flags.author === 'string' ? ctx.flags.author : ctx.args[0];
+    let author = '';
+    if (!all)
+        author = ((authorFlag && authorFlag.trim()) || gitUserName(root)).trim();
+    // Window resolution (priority): --since (approxidate passthrough) >
+    // --days N > the weekend-aware default.
+    const now = new Date();
+    const sinceExpr = typeof ctx.flags.since === 'string' ? ctx.flags.since.trim() : '';
+    const daysFlag = numFlag(ctx.flags.days);
+    let sinceArg;
+    let windowLabel;
+    if (sinceExpr) {
+        sinceArg = normalizeSince(sinceExpr);
+        windowLabel = sinceExpr;
+    }
+    else {
+        const days = daysFlag ?? sinceLastWorkingDay(now).sinceDays;
+        // Cutoff = LOCAL midnight `days` ago, so the WHOLE last working day is
+        // included (a plain "3 days ago" would start mid-morning and miss commits).
+        const cutoff = new Date(now.getFullYear(), now.getMonth(), now.getDate() - days);
+        sinceArg = cutoff.toISOString();
+        windowLabel = days === 1 ? 'since yesterday' : `since ${days} days ago`;
+    }
+    const args = ['log', '--numstat', `--since=${sinceArg}`, '--format=format:%x01%H%x1f%aN%x1f%aI%x1f%s'];
+    if (author)
+        args.push(`--author=${author}`);
+    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 buckets = groupByDay(parseStandupLog(raw));
+    if (asJson) {
+        const count = buckets.reduce((n, b) => n + b.commits.length, 0);
+        process.stdout.write(JSON.stringify({ generated: now.toISOString(), author: all ? null : author || null, since: sinceArg, count, buckets }, null, 2) + '\n');
+    }
+    else {
+        const who = all ? 'everyone' : author || 'you';
+        if (buckets.length === 0) {
+            output.writeln(output.dim(`no commits for ${who} ${windowLabel} — nothing to report`));
+        }
+        else {
+            output.writeln(output.bold(`Standup for ${who} (${windowLabel})`));
+            output.writeln(formatStandup(buckets));
+        }
+    }
+    return { success: true, exitCode: 0 };
+}
+export const standupCommand = {
+    name: 'standup',
+    description: 'Recall what you committed since your last working day (weekend-aware: Monday reaches back to Friday) — git-standup parity',
+    options: [
+        { name: 'all', description: 'show commits from all authors (not just you)', type: 'boolean' },
+        { name: 'author', description: 'filter to a specific author (default: git config user.name)', type: 'string' },
+        { name: 'days', description: 'explicit N-day window (overrides the weekend-aware default)', type: 'string' },
+        { name: 'since', description: 'explicit window, e.g. 2w or "last monday" (git approxidate)', type: 'string' },
+    ],
+    examples: [
+        { command: 'swarmdo standup', description: 'Your commits since the last working day' },
+        { command: 'swarmdo standup --all --since 1w', description: "Everyone's commits in the last week" },
+        { command: 'swarmdo standup --format json', description: 'Machine-readable per-day buckets' },
+    ],
+    action: run,
+};
+export default standupCommand;
+//# sourceMappingURL=standup.js.map

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

@@ -103,6 +103,35 @@ function getSwarmStatus(swarmId) {
             // Ignore
         }
     }
+    // Canonical-store fallback: the `.swarm/*` paths above are the pre-#2085
+    // layout. The real swarm store written by swarm_init / agent_spawn / the
+    // agent bridge lives at `.swarmdo/swarm/swarm-state.json`. When the legacy
+    // paths are empty, read the canonical store so `swarm status` reflects a
+    // bridge-created (or MCP-created) swarm instead of falsely reporting "none".
+    if (!swarmState) {
+        try {
+            const swFile = path.join(process.cwd(), '.swarmdo', 'swarm', 'swarm-state.json');
+            if (fs.existsSync(swFile)) {
+                const swStore = JSON.parse(fs.readFileSync(swFile, 'utf-8'));
+                const running = Object.values(swStore.swarms || {})
+                    .filter((s) => s.status === 'running')
+                    .sort((a, b) => new Date(String(b.createdAt)).getTime() - new Date(String(a.createdAt)).getTime())[0];
+                if (running) {
+                    const cfg = running.config || {};
+                    swarmState = {
+                        id: running.swarmId,
+                        topology: running.topology,
+                        strategy: cfg.strategy || 'specialized',
+                    };
+                    const enrolled = Array.isArray(running.agents) ? running.agents.length : 0;
+                    totalAgents = Math.max(totalAgents, enrolled);
+                }
+            }
+        }
+        catch {
+            // Canonical store unavailable — keep the legacy view.
+        }
+    }
     // Calculate dynamic progress based on actual state
     // If no swarm state, show 0%. Otherwise calculate from completed tasks
     const totalTasks = completedTasks + inProgressTasks + pendingTasks;

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,