swarmdo 1.54.1 → 1.58.6

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

@@ -11,6 +11,94 @@ import { join } from 'node:path';
 import { bridgeSearchEntries } from '../memory/memory-bridge.js';
 import { selectInjectionMemories, mapSearchResultsToCandidates, extractPromptFromPayload, } from '../memory-inject/select.js';
 import { classifyCommand, extractBashCommand, denyOutput } from '../hooks-recipe/command-guard.js';
+// Read-only liveness probe (does not persist). Mirrors swarm-tools' isPidAlive
+// so the statusline never counts a swarm whose host process has exited.
+function statuslinePidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === 'EPERM';
+    }
+}
+/**
+ * Live swarm + agent counts for the statusline (`🐝 Swarms N   🤖 Agents M`).
+ * These are two distinct numbers, read from two canonical registries:
+ *   - agents: `.swarmdo/agents/store.json` + the hive `.swarmdo/agents.json`
+ *     (what `agent_spawn`, `swarm_init`, `agent bridge register`, and hive-mind
+ *     workers write) — every non-terminated agent is counted.
+ *   - swarms: `.swarmdo/swarm/swarm-state.json` — every `status: 'running'`
+ *     swarm whose host process is still alive; dead-pid / >24h-stale orphans are
+ *     skipped read-only (mirrors reconcileOrphanSwarms without persisting).
+ *
+ * The agent count replaces the old `ps aux | grep -c agentic-flow` heuristic,
+ * which (a) was blind to in-process agents — Claude Code Task-tool subagents and
+ * bridged agents never appear as a separate `agentic-flow` OS process — so the
+ * count never moved when a swarm spun up, and (b) false-positived on any process
+ * whose args merely mention "agentic-flow" (a grep, an open editor buffer, the
+ * ONNX embedder), showing phantom agents when none were running.
+ *
+ * No `maxAgents` denominator is reported: swarm size is never enforced at spawn
+ * time (the config value is an advisory hint feeding an internal [1,50]
+ * backstop), so a `[N/max]` gauge would imply a live cap that does not exist.
+ */
+export function computeSwarmStatus(cwd = process.cwd()) {
+    const agents = {};
+    // Both stores hold a { agents: { <id>: { status } } } map; merge them.
+    for (const rel of [['.swarmdo', 'agents', 'store.json'], ['.swarmdo', 'agents.json']]) {
+        try {
+            const p = join(cwd, ...rel);
+            if (existsSync(p)) {
+                const data = JSON.parse(readFileSync(p, 'utf-8'));
+                if (data && data.agents && typeof data.agents === 'object') {
+                    Object.assign(agents, data.agents);
+                }
+            }
+        }
+        catch {
+            // unreadable/corrupt store — skip it, count what we can
+        }
+    }
+    let activeAgents = 0;
+    for (const id of Object.keys(agents)) {
+        if (agents[id] && agents[id].status !== 'terminated')
+            activeAgents++;
+    }
+    // Active swarms — running, non-orphaned entries in swarm-state.json.
+    let activeSwarms = 0;
+    try {
+        const sp = join(cwd, '.swarmdo', 'swarm', 'swarm-state.json');
+        if (existsSync(sp)) {
+            const store = JSON.parse(readFileSync(sp, 'utf-8'));
+            const swarms = store && store.swarms && typeof store.swarms === 'object' ? store.swarms : {};
+            const ORPHAN_TTL_MS = 24 * 60 * 60 * 1000;
+            const nowMs = Date.now();
+            for (const s of Object.values(swarms)) {
+                if (!s || s.status !== 'running')
+                    continue;
+                if (typeof s.pid === 'number') {
+                    if (!statuslinePidAlive(s.pid))
+                        continue; // host process gone → orphan
+                }
+                else if (s.updatedAt) {
+                    const ageMs = nowMs - new Date(s.updatedAt).getTime();
+                    if (Number.isFinite(ageMs) && ageMs > ORPHAN_TTL_MS)
+                        continue; // heartbeat stale
+                }
+                activeSwarms++;
+            }
+        }
+    }
+    catch {
+        // unreadable/corrupt swarm store — count 0
+    }
+    return {
+        activeSwarms,
+        activeAgents,
+        coordinationActive: activeSwarms > 0 || activeAgents > 0,
+    };
+}
 /**
  * #1686 — `?? 0` only defaults null/undefined; NaN slips through and
  * surfaces as `"NaN"` (or earlier crashed `.toFixed`) in the metrics
@@ -3613,29 +3701,13 @@ const statuslineCommand = {
             // no scan has ever run — nothing is "pending", there is just no data
             return { status: 'NONE', critical: 0, high: 0, total: 0, scannedAt: null };
         }
-        // Get swarm status
+        // Get swarm status from the canonical agent registry (not `ps | grep agentic-flow`).
         function getSwarmStatus() {
-            let activeAgents = 0;
-            let coordinationActive = false;
-            const maxAgents = 15;
-            const isWindows = process.platform === 'win32';
-            try {
-                const psCmd = isWindows
-                    ? 'tasklist /FI "IMAGENAME eq node.exe" /NH 2>NUL | find /c /v "" 2>NUL || echo 0'
-                    : 'ps aux 2>/dev/null | grep -c agentic-flow || echo "0"';
-                const ps = execSync(psCmd, { encoding: 'utf-8', timeout: 3000 });
-                activeAgents = Math.max(0, parseInt(ps.trim()) - 1);
-                coordinationActive = activeAgents > 0;
-            }
-            catch {
-                // ps/tasklist unavailable or timed out — report zero
-            }
-            return { activeAgents, maxAgents, coordinationActive };
+            return computeSwarmStatus(process.cwd());
         }
         // Get system metrics
         function getSystemMetrics() {
             let memoryMB = 0;
-            let subAgents = 0;
             const learning = getLearningStats();
             try {
                 memoryMB = Math.floor(process.memoryUsage().heapUsed / 1024 / 1024);
@@ -3697,7 +3769,7 @@ const statuslineCommand = {
                 intelligencePct = Math.min(100, maturityScore);
             }
             const contextPct = Math.min(100, Math.floor(learning.sessions * 5));
-            return { memoryMB, contextPct, intelligencePct, subAgents };
+            return { memoryMB, contextPct, intelligencePct };
         }
         // Get user info
         function getUserInfo() {
@@ -3751,7 +3823,7 @@ const statuslineCommand = {
         const terminalCols = process.stdout.columns ?? 80;
         const autoCompact = !ctx.flags.full && terminalCols < COMPACT_WIDTH_THRESHOLD;
         if (ctx.flags.compact || autoCompact) {
-            const line = `DDD:${progress.domainsCompleted}/${progress.totalDomains} Sec:${security.status} Swarm:${swarm.activeAgents}/${swarm.maxAgents} Ctx:${system.contextPct}% Int:${system.intelligencePct}%`;
+            const line = `DDD:${progress.domainsCompleted}/${progress.totalDomains} Sec:${security.status} Swarms:${swarm.activeSwarms} Agents:${swarm.activeAgents} Ctx:${system.contextPct}% Int:${system.intelligencePct}%`;
             output.writeln(line);
             return { success: true, data: statusData };
         }
@@ -3923,13 +3995,13 @@ const statuslineCommand = {
         const line1 = `${c.brightCyan}🏗️  DDD Domains${c.reset}    ${progressBar(progress.domainsCompleted, progress.totalDomains)}  ` +
             `${domainsColor}${progress.domainsCompleted}${c.reset}/${c.brightWhite}${progress.totalDomains}${c.reset}    ` +
             perfIndicator;
-        const swarmIndicator = swarm.coordinationActive ? `${c.brightGreen}◉${c.reset}` : `${c.dim}○${c.reset}`;
-        const agentsColor = swarm.activeAgents > 0 ? c.brightGreen : c.red;
+        const swarmsColor = swarm.activeSwarms > 0 ? c.brightGreen : c.dim;
+        const agentsColor = swarm.activeAgents > 0 ? c.brightGreen : c.dim;
         const securityIcon = security.status === 'CLEAN' ? '🟢' : security.status === 'STALE' ? '🟡' : security.status === 'NONE' ? '⚪' : '🔴';
         const securityColor = security.status === 'CLEAN' ? c.brightGreen : security.status === 'STALE' ? c.brightYellow : security.status === 'NONE' ? c.dim : c.brightRed;
         const hooksColor = hooksStats.enabled > 0 ? c.brightGreen : c.dim;
-        const line2 = `${c.brightYellow}🤖 Swarm${c.reset}  ${swarmIndicator} [${agentsColor}${String(swarm.activeAgents).padStart(2)}${c.reset}/${c.brightWhite}${swarm.maxAgents}${c.reset}]  ` +
-            `${c.brightPurple}👥 ${system.subAgents}${c.reset}    ` +
+        const line2 = `${c.brightYellow}🐝 Swarms${c.reset} ${swarmsColor}${swarm.activeSwarms}${c.reset}    ` +
+            `${c.brightYellow}🤖 Agents${c.reset} ${agentsColor}${swarm.activeAgents}${c.reset}    ` +
             `${c.brightBlue}🪝 ${hooksColor}${hooksStats.enabled}${c.reset}/${c.brightWhite}${hooksStats.total}${c.reset}    ` +
             `${securityIcon} ${securityColor}sec ${security.status === 'VULN' ? (security.critical + security.high) + '!' : security.status === 'CLEAN' ? '✓' : security.status === 'STALE' ? 'stale' : '—'}${c.reset}    ` +
             `${c.brightCyan}💾 ${system.memoryMB}MB${c.reset}    ` +

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

@@ -64,6 +64,10 @@ const commandLoaders = {
     // — commits since your last working day, grouped by day with a diffstat.
     standup: () => import('./standup.js'),
     mine: () => import('./standup.js'), // alias via loader key
+    // Hot/cold/orphan USAGE report for authored .claude/ slash-commands + subagents
+    // — the "dead-code report" for the authoring surface (config lint validates it).
+    commands: () => import('./commands.js'),
+    slash: () => import('./commands.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'),
@@ -306,7 +310,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, ownershipCmd, hiddenCouplingCmd, testreportCmd, compactSnapshotCmd, standupCmd,] = 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, commandsUsageCmd,] = 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'),
@@ -314,7 +318,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('ownership'), loadCommand('hidden-coupling'), loadCommand('testreport'), loadCommand('compact-snapshot'), loadCommand('standup'),
+        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'), loadCommand('commands'),
     ]);
     return {
         primary: [
@@ -333,7 +337,7 @@ export async function getCommandsByCategory() {
             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, standupCmd,
+            analyzeCmd, routeCmd, progressCmd, usageCmd, hudCmd, codegraphCmd, standupCmd, commandsUsageCmd,
         ].filter(Boolean),
         management: [
             providersCmd, pluginsCmd, deploymentCmd, claimsCmd,

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

@@ -355,6 +355,9 @@ const initCommand = {
             const result = await callMCPTool('swarm_init', {
                 topology: topology,
                 maxAgents,
+                // A one-shot CLI process is not a lasting host — create a persistent
+                // (pid-less) swarm so it isn't reaped the instant `swarm init` exits.
+                persistent: true,
                 config: {
                     communicationProtocol: 'message-bus',
                     consensusMechanism: 'majority',
@@ -520,6 +523,7 @@ const startCommand = {
                 topology: 'hierarchical',
                 maxAgents: totalAgents,
                 strategy: strategy === 'development' ? 'specialized' : strategy,
+                persistent: true, // CLI process is ephemeral — pid-less swarm survives exit
             });
             spinner.succeed('Swarm initialized via MCP');
         }
@@ -818,6 +822,7 @@ const coordinateCommand = {
                 topology: 'hierarchical-mesh',
                 maxAgents: agentCount,
                 strategy: 'specialized',
+                persistent: true, // CLI process is ephemeral — pid-less swarm survives exit
             });
             output.printSuccess(`Swarm coordination initialized with ${agentCount} agent slots via MCP`);
         }

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

@@ -15,6 +15,7 @@
 import { output } from '../output.js';
 import { aggregateBlocks, aggregateUsage, collectUsage, totalUsage, localDateKey, } from '../usage/transcript-usage.js';
 import { collectToolErrors, delegationFromReport } from '../usage/transcript-errors.js';
+import { collectFriction } from '../usage/transcript-friction.js';
 import { computeCacheStats } from '../usage/cache-stats.js';
 import { evaluateGuard } from '../usage/spend-guard.js';
 import { resolvePeriodPair, parseRange, diffPeriods, modelMovers } from '../usage/diff.js';
@@ -201,6 +202,53 @@ function runErrorsView(ctx, report) {
     }
     return { success: true, exitCode: 0 };
 }
+/** Friction view — how often you interrupt Claude (ESC mid-turn), which tool was
+ * running when you did, and what KIND of errors dominate. The sniffly axes that
+ * `usage errors` (error rate) left on the table (#102). */
+function runFrictionView(ctx, report) {
+    if (ctx.flags.json === true) {
+        output.writeln(JSON.stringify(report, null, 2));
+        return { success: true, exitCode: 0 };
+    }
+    const pct = (v) => `${(v * 100).toFixed(1)}%`;
+    if (ctx.flags.csv === true) {
+        // Category table export (parity with `usage --csv`).
+        const headers = ['category', 'count', 'share'];
+        const rows = report.categories.map((c) => [c.category, c.count, c.share.toFixed(4)]);
+        output.writeln(toCsv(headers, rows));
+        return { success: true, exitCode: 0 };
+    }
+    output.writeln(output.bold('Claude Code usage — friction'));
+    if (report.interruptions === 0 && report.totalErrors === 0) {
+        output.writeln(output.info(`no friction detected in ${report.filesScanned} transcript files`));
+        return { success: true, exitCode: 0 };
+    }
+    output.writeln(output.dim(`${report.filesScanned} files · ${fmtInt(report.interruptions)} interruption${report.interruptions === 1 ? '' : 's'} across ${fmtInt(report.assistantTurns)} assistant turns (${pct(report.interruptionRate)})`));
+    if (report.byTool.length > 0) {
+        output.writeln('');
+        output.writeln(output.bold('Interrupted while running'));
+        output.printTable({
+            columns: [
+                { key: 'tool', header: 'Tool / context', width: 22 },
+                { key: 'count', header: 'Interrupts', width: 12, align: 'right' },
+            ],
+            data: report.byTool.slice(0, 15).map((t) => ({ tool: t.tool, count: fmtInt(t.interruptions) })),
+        });
+    }
+    if (report.categories.length > 0) {
+        output.writeln('');
+        output.writeln(output.bold('Error categories') + output.dim(`  (${fmtInt(report.totalErrors)} tool errors)`));
+        output.printTable({
+            columns: [
+                { key: 'category', header: 'Category', width: 14 },
+                { key: 'count', header: 'Count', width: 10, align: 'right' },
+                { key: 'share', header: 'Share', width: 8, align: 'right' },
+            ],
+            data: report.categories.map((c) => ({ category: c.category, count: fmtInt(c.count), share: pct(c.share) })),
+        });
+    }
+    return { success: true, exitCode: 0 };
+}
 /** Cache view — prompt-cache efficiency + $ saved by caching (the #1 cost lever). */
 function runCacheView(ctx, collection) {
     const stats = computeCacheStats(aggregateUsage(collection.events, 'model'));
@@ -547,6 +595,13 @@ async function run(ctx) {
         const dirs = typeof dirFlag === 'string' ? [dirFlag] : Array.isArray(dirFlag) ? dirFlag.map(String) : undefined;
         return runErrorsView(ctx, collectToolErrors({ dirs, since, until }));
     }
+    if (viewName === 'friction') {
+        const since = typeof ctx.flags.since === 'string' ? ctx.flags.since : undefined;
+        const until = typeof ctx.flags.until === 'string' ? ctx.flags.until : undefined;
+        const dirFlag = ctx.flags.dir;
+        const dirs = typeof dirFlag === 'string' ? [dirFlag] : Array.isArray(dirFlag) ? dirFlag.map(String) : undefined;
+        return runFrictionView(ctx, collectFriction({ dirs, since, until }));
+    }
     if (viewName === 'cache') {
         const since = typeof ctx.flags.since === 'string' ? ctx.flags.since : undefined;
         const until = typeof ctx.flags.until === 'string' ? ctx.flags.until : undefined;
@@ -574,7 +629,7 @@ async function run(ctx) {
     }
     const view = VIEWS[viewName];
     if (!view) {
-        output.writeln(output.error(`unknown view: ${viewName} (expected ${Object.keys(VIEWS).join('|')}|blocks|errors|cache|guard|diff|reflect|limits)`));
+        output.writeln(output.error(`unknown view: ${viewName} (expected ${Object.keys(VIEWS).join('|')}|blocks|errors|friction|cache|guard|diff|reflect|limits)`));
         return { success: false, exitCode: 1 };
     }
     const since = typeof ctx.flags.since === 'string' ? ctx.flags.since : undefined;
@@ -667,6 +722,7 @@ export const usageCommand = {
         { command: 'swarmdo usage projects --json', description: 'Per-project totals as JSON' },
         { command: 'swarmdo usage monthly --csv > usage.csv', description: 'Export monthly spend to CSV' },
         { command: 'swarmdo cost sessions --limit 10', description: 'Ten most expensive sessions (alias)' },
+        { command: 'swarmdo usage friction', description: 'How often you interrupt Claude + which error kinds dominate' },
     ],
     action: run,
 };

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

@@ -14,7 +14,17 @@ export declare const RETENTION: {
 export declare function storePath(cwd: string): string;
 export declare function loadMailbox(cwd: string): Mailbox;
 export declare function saveMailbox(cwd: string, box: Mailbox): void;
-/** This session's name: explicit override → SWARMDO_SESSION → hostname → "me". */
+/**
+ * This session's name, in precedence order:
+ *   explicit override (flag/param)
+ *   → $SWARMDO_SESSION   (set by Claude Code)
+ *   → $SWARMDO_AGENT     (harness-neutral — Codex/Copilot/pi agents export this)
+ *   → hostname → "me".
+ *
+ * The $SWARMDO_AGENT fallback lets a non-Claude agent declare a stable identity
+ * once (instead of passing `from`/`--self` on every call); without it, every
+ * agent on a host collapses to the shared hostname and direct addressing breaks.
+ */
 export declare function resolveSelf(flag?: unknown): string;
 /** Crypto-strong message id. */
 export declare function newMessageId(): string;

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

@@ -32,10 +32,24 @@ export function saveMailbox(cwd, box) {
     mkdirSync(dirname(p), { recursive: true });
     writeFileSync(p, JSON.stringify(box, null, 2) + '\n', 'utf-8');
 }
-/** This session's name: explicit override → SWARMDO_SESSION → hostname → "me". */
+/**
+ * This session's name, in precedence order:
+ *   explicit override (flag/param)
+ *   → $SWARMDO_SESSION   (set by Claude Code)
+ *   → $SWARMDO_AGENT     (harness-neutral — Codex/Copilot/pi agents export this)
+ *   → hostname → "me".
+ *
+ * The $SWARMDO_AGENT fallback lets a non-Claude agent declare a stable identity
+ * once (instead of passing `from`/`--self` on every call); without it, every
+ * agent on a host collapses to the shared hostname and direct addressing breaks.
+ */
 export function resolveSelf(flag) {
     const f = typeof flag === 'string' ? flag.trim() : '';
-    return f || (process.env.SWARMDO_SESSION || '').trim() || hostname() || 'me';
+    return (f ||
+        (process.env.SWARMDO_SESSION || '').trim() ||
+        (process.env.SWARMDO_AGENT || '').trim() ||
+        hostname() ||
+        'me');
 }
 /** Crypto-strong message id. */
 export function newMessageId() {

package/v3/@swarmdo/cli/dist/src/init/statusline-generator.d.ts

@@ -16,7 +16,7 @@ import type { InitOptions } from './types.js';
  * ▊ Swarmdo V3.6 ● user  │  ⎇ branch  │  Opus 4.7
  * ─────────────────────────────────────────────────────
  * 🏗️  DDD Domains    [●●○○○]  2/5    ⚡ HNSW 150x
- * 🤖 Swarm  ◉ [ 5/15]  👥 2    🪝 10/17    🟢 CVE 3/3    💾 4MB    🧠  63%
+ * 🐝 Swarms 1  🤖 Agents 5    🪝 10/17    🟢 CVE 3/3    💾 4MB    🧠  63%
  * 🔧 Architecture    ADRs ●71%  │  DDD ● 13%  │  Security ●CLEAN
  * 📊 AgentDB    Vectors ●3104⚡  │  Size 216KB  │  Tests ●6 (~24 cases)  │  MCP ●1/1
  */

package/v3/@swarmdo/cli/dist/src/init/statusline-generator.js

@@ -53,7 +53,7 @@ const BAKED_CLI_VERSION = readBakedCliVersion();
  * ▊ Swarmdo V3.6 ● user  │  ⎇ branch  │  Opus 4.7
  * ─────────────────────────────────────────────────────
  * 🏗️  DDD Domains    [●●○○○]  2/5    ⚡ HNSW 150x
- * 🤖 Swarm  ◉ [ 5/15]  👥 2    🪝 10/17    🟢 CVE 3/3    💾 4MB    🧠  63%
+ * 🐝 Swarms 1  🤖 Agents 5    🪝 10/17    🟢 CVE 3/3    💾 4MB    🧠  63%
  * 🔧 Architecture    ADRs ●71%  │  DDD ● 13%  │  Security ●CLEAN
  * 📊 AgentDB    Vectors ●3104⚡  │  Size 216KB  │  Tests ●6 (~24 cases)  │  MCP ●1/1
  */
@@ -166,7 +166,7 @@ function resolveCliBin() {
     ];
     try {
       const binDir = path.dirname(process.execPath);
-      const globalModuleDirs = [path.join(binDir, '..', 'lib', 'node_modules'), path.join(binDir, 'node_modules')];
+      const globalModuleDirs = [path.join(binDir, '..', 'lib', 'node_modules'), path.join(binDir, 'node_modules'), '/opt/homebrew/lib/node_modules', '/usr/local/lib/node_modules'];
       for (const prefix of [process.env.npm_config_prefix, process.env.PREFIX, path.join(home, '.npm-global')]) {
         if (prefix) globalModuleDirs.push(path.join(prefix, 'lib', 'node_modules'));
       }
@@ -209,6 +209,13 @@ function writeCache(data) {
  * and only counted ADRs in v3/implementation/adrs/ (missed v3/docs/adr/).
  */
 function getStatuslineData() {
+  // SWARMDO_STATUSLINE_NO_CLI: skip the CLI-delegation fork and render from local
+  // reads + stdin only. A cold render otherwise forks the hooks-statusline CLI
+  // (now more reachable via the global-node_modules probes below), and that fork
+  // can disturb the stdin cost payload; skipping it keeps renders fast, hermetic,
+  // and subprocess-free. Set by the statusline tests; usable by anyone who wants
+  // a no-fork statusline.
+  if (process.env.SWARMDO_STATUSLINE_NO_CLI) return buildLocalFallback();
   const cached = readCache();
   if (cached) return cached;
 
@@ -385,8 +392,8 @@ function buildLocalFallback() {
     user: { name: 'user', gitBranch: '', modelName: 'Claude Code' },
     v3Progress: { domainsCompleted: 0, totalDomains: 5, dddProgress: 0, patternsLearned: 0, sessionsCompleted: 0 },
     security: { status: 'NONE', critical: 0, high: 0, total: 0 },
-    swarm: { activeAgents: 0, maxAgents: CONFIG.maxAgents, coordinationActive: false },
-    system: { memoryMB: memMB, contextPct: 0, intelligencePct: 0, subAgents: 0 },
+    swarm: { activeSwarms: 0, activeAgents: 0, coordinationActive: false },
+    system: { memoryMB: memMB, contextPct: 0, intelligencePct: 0 },
     lastUpdated: new Date().toISOString(),
   });
 }
@@ -592,7 +599,7 @@ function getPkgVersion() {
     // (bin/node_modules) layouts.
     try {
       const binDir = path.dirname(process.execPath);
-      const globalModuleDirs = [path.join(binDir, '..', 'lib', 'node_modules'), path.join(binDir, 'node_modules')];
+      const globalModuleDirs = [path.join(binDir, '..', 'lib', 'node_modules'), path.join(binDir, 'node_modules'), '/opt/homebrew/lib/node_modules', '/usr/local/lib/node_modules'];
       // #2221 follow-up: a custom npm prefix (e.g. ~/.npm-global) is decoupled from
       // the node binary location, so the binDir-derived probes above all miss. Also
       // probe the npm prefix from the environment and the common ~/.npm-global default.
@@ -646,12 +653,11 @@ function generateStatusline() {
   const totalDomains = progress.totalDomains || 5;
   const dddProgress = progress.dddProgress || 0;
   const patternsLearned = progress.patternsLearned || 0;
+  const activeSwarms = swarm.activeSwarms || 0;
   const activeAgents = swarm.activeAgents || 0;
-  const maxAgents = swarm.maxAgents || CONFIG.maxAgents;
   const coordinationActive = swarm.coordinationActive || false;
   const intelligencePct = system.intelligencePct || 0;
   const memoryMB = system.memoryMB || 0;
-  const subAgents = system.subAgents || 0;
   const secCritHigh = (security.critical || 0) + (security.high || 0);
   const secStatus = security.status || 'NONE';
   const secLabel = secStatus === 'VULN' ? 'sec ' + secCritHigh + '!' : secStatus === 'CLEAN' ? 'sec ✓' : secStatus === 'STALE' ? 'sec stale' : 'sec —';
@@ -718,16 +724,16 @@ function generateStatusline() {
   );
 
   // Line 2: Swarm + Hooks + CVE + Memory + Intelligence
-  const swarmInd = coordinationActive ? c.brightGreen + '◉' + c.reset : c.dim + '○' + c.reset;
-  const agentsColor = activeAgents > 0 ? c.brightGreen : c.red;
+  const swarmsColor = activeSwarms > 0 ? c.brightGreen : c.dim;
+  const agentsColor = activeAgents > 0 ? c.brightGreen : c.dim;
   const secIcon = secStatus === 'CLEAN' ? '🟢' : secStatus === 'STALE' ? '🟡' : (secStatus === 'NONE' ? '⚪' : '🔴');
   const secColor = secStatus === 'CLEAN' ? c.brightGreen : secStatus === 'STALE' ? c.brightYellow : (secStatus === 'NONE' ? c.dim : c.brightRed);
   const hooksColor = hooksEnabled > 0 ? c.brightGreen : c.dim;
   const intellColor = intelligencePct >= 80 ? c.brightGreen : intelligencePct >= 40 ? c.brightYellow : c.dim;
 
   if (seg('swarm')) lines.push(
-    c.brightYellow + '🤖 Swarm' + c.reset + '  ' + swarmInd + ' [' + agentsColor + String(activeAgents).padStart(2) + c.reset + '/' + c.brightWhite + maxAgents + c.reset + ']  ' +
-    c.brightPurple + '👥 ' + subAgents + c.reset + '    ' +
+    c.brightYellow + '🐝 Swarms' + c.reset + ' ' + swarmsColor + activeSwarms + c.reset + '    ' +
+    c.brightYellow + '🤖 Agents' + c.reset + ' ' + agentsColor + activeAgents + c.reset + '    ' +
     c.brightBlue + '🪝 ' + hooksColor + hooksEnabled + c.reset + '/' + c.brightWhite + hooksTotal + c.reset + '    ' +
     secIcon + ' ' + secColor + secLabel + c.reset + '    ' +
     c.brightCyan + '💾 ' + memoryMB + 'MB' + c.reset + '    ' +

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

@@ -63,23 +63,34 @@ export function crossAgentAgentsMd() {
 ## What swarmdo gives you
 
 This project is wired to **swarmdo** — agent orchestration with persistent
-vector memory, swarm coordination, and 300+ MCP tools.
+vector memory, swarm coordination, cross-agent messaging, and 300+ MCP tools.
+Everything below works the same from Codex, Copilot, pi, or a plain shell —
+not just Claude Code.
 
-- **MCP server**: \`swarmdo mcp start\` (stdio). If your CLI supports MCP,
-  \`swarmdo integrations install <your-cli>\` wires it; key tools:
-  \`memory_search\`, \`memory_store\`, \`swarm_init\`, \`agent_spawn\`.
+- **MCP server**: \`swarmdo mcp start\` (stdio; serves every tool by default).
+  If your CLI supports MCP, \`swarmdo integrations install <your-cli>\` wires
+  it. Key tools: \`memory_search\`, \`memory_store\`, \`swarm_init\`,
+  \`agent_spawn\`, \`comms_send\` / \`comms_inbox\` (message other agents),
+  \`hotspots\` / \`coupling\` / \`ownership\` (git-history analysis).
 - **CLI**: \`npx swarmdo@latest <command>\` — \`memory search -q "topic"\`,
-  \`usage\`, \`task\`, \`hud\`, \`security scan\`, \`config lint\`.
+  \`comms send\` / \`comms inbox\`, \`standup\`, \`hotspots\`, \`coupling\`,
+  \`ownership\`, \`hidden-coupling\`, \`task\`, \`hud\`.
 
 ## Working agreement (any agent)
 
 1. **Search memory BEFORE starting**: \`memory_search(query="task keywords")\`
    — patterns with score > 0.7 are load-bearing precedent.
-2. **You are the executor** — swarmdo coordinates and remembers; it never
+2. **Coordinate through the cross-tool mailbox**: announce the files you're
+   about to change with \`comms_send(to="all", message="…")\` and check
+   \`comms_inbox\` before overlapping work. Non-Claude agents: set a stable
+   identity with \`export SWARMDO_AGENT=<your-name>\` (or pass \`from\` /
+   \`--self\`) so replies address you — without it every agent on this host
+   shares the hostname identity.
+3. **You are the executor** — swarmdo coordinates and remembers; it never
    writes your code for you.
-3. **Store what worked AFTER success**:
+4. **Store what worked AFTER success**:
    \`memory_store(key="pattern-…", value="what worked", namespace="patterns")\`.
-4. Claude Code users: the same surfaces are namespaced under \`/sDo:\`
+5. Claude Code users: the same surfaces are namespaced under \`/sDo:\`
    commands and \`/sdo-\` skills.
 
 ## Do not

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

@@ -12,7 +12,7 @@ import { loadMailbox, saveMailbox, resolveSelf, newMessageId, RETENTION } from '
 export const commsTools = [
     {
         name: 'comms_send',
-        description: 'Send a message to another Claude Code session working on the same repo (cross-session mailbox). Address "all" to broadcast to every session. Use for multi-session/"multiplayer" coordination; delivery is via a shared file, not the network.',
+        description: 'Send a message to another agent session — Claude Code, Codex, Copilot, pi, or any tool on the same repo (a cross-session/cross-tool mailbox). Address "all" to broadcast to every session. Use for multi-agent "multiplayer" coordination; delivery is via a shared file, not the network.',
         category: 'comms',
         inputSchema: {
             type: 'object',
@@ -20,7 +20,7 @@ export const commsTools = [
                 to: { type: 'string', description: 'Recipient session name, or "all" to broadcast' },
                 message: { type: 'string', description: 'Message body' },
                 subject: { type: 'string', description: 'Optional subject line' },
-                from: { type: 'string', description: 'Sender name (default: this session — $SWARMDO_SESSION or hostname)' },
+                from: { type: 'string', description: 'Sender name. Default: this session ($SWARMDO_SESSION, else $SWARMDO_AGENT, else hostname). Non-Claude agents should pass this (or export $SWARMDO_AGENT) so replies address them, not the shared hostname.' },
             },
             required: ['to', 'message'],
         },
@@ -49,12 +49,12 @@ export const commsTools = [
     },
     {
         name: 'comms_inbox',
-        description: 'List messages other sessions have sent to this session (cross-session mailbox), newest first. Includes "all" broadcasts. Set markRead to acknowledge them.',
+        description: 'List messages other agent sessions (Claude Code, Codex, Copilot, pi, …) have sent to this one — a cross-session/cross-tool mailbox — newest first. Includes "all" broadcasts. Set markRead to acknowledge them.',
         category: 'comms',
         inputSchema: {
             type: 'object',
             properties: {
-                to: { type: 'string', description: 'Whose inbox (default: this session)' },
+                to: { type: 'string', description: 'Whose inbox (default: this session — $SWARMDO_SESSION, else $SWARMDO_AGENT, else hostname)' },
                 unreadOnly: { type: 'boolean', description: 'Only unread messages' },
                 from: { type: 'string', description: 'Only messages from this sender' },
                 since: { type: 'string', description: 'Only messages after this ISO-8601 timestamp' },

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

@@ -179,6 +179,7 @@ export const swarmTools = [
                 maxAgents: { type: 'number', description: 'Maximum number of agents (1-50)' },
                 strategy: { type: 'string', description: 'Agent strategy (specialized, balanced, adaptive)' },
                 config: { type: 'object', description: 'Additional swarm configuration' },
+                persistent: { type: 'boolean', description: 'Create a persistent (pid-less) swarm that survives the creating process — set by the CLI, whose process is ephemeral. Reaped by the 24h idle-TTL instead of on-exit. Leave unset from a long-lived host (MCP server/daemon) so a dead host is reaped promptly.' },
             },
         },
         handler: async (input) => {
@@ -201,6 +202,7 @@ export const swarmTools = [
                     maxAgents: input.maxAgents,
                     strategy,
                     config: (input.config || {}),
+                    persistent: input.persistent,
                 });
             }
             catch (e) {