swarmdo 1.45.0 → 1.54.1

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/init/helpers-generator.js

@@ -277,6 +277,31 @@ function routeTask(task) {
   };
 }
 
+// Mirror of src/agent-bridge/bridge.ts classifyPrompt — decides whether a
+// prompt warrants spinning up a bound-agent swarm (and which roles), so the
+// UserPromptSubmit hook can tell the main agent to spawn + bridge agents
+// (making Swarmdo used by default instead of sitting idle).
+const AGENTIC_RE = /\\b(implement|build|create|add(?:ing)?|develop|refactor\\w*|migrat\\w*|redesign|re-?architect\\w*|architect\\w*|feature|integrat\\w*|overhaul|rewrite|port|scaffold|end-to-end|multi-file|test suite|coverage|audit|harden\\w*|vulnerab\\w*|cve|fix\\w*|debug\\w*|optimi[sz]e|performance)\\b/i;
+const TRIVIAL_RE = /\\b(what|why|how|explain|describe|show|list|find|search|where|which|typo|readme|comment|one-?liner|quick question|rename|bump (?:the )?version|status|help)\\b/i;
+const ROLE_SIGNALS = [
+  { re: /\\b(security|vulnerab\\w*|cve|auth\\w*|inject\\w*|xss|ssrf)\\b/i, roles: ['security-auditor', 'coder', 'reviewer'] },
+  { re: /\\b(refactor\\w*|migrat\\w*|redesign|re-?architect\\w*|overhaul|rewrite)\\b/i, roles: ['system-architect', 'coder', 'reviewer'] },
+  { re: /\\b(perf\\w*|optimi[sz]e|benchmark|latency|throughput)\\b/i, roles: ['perf-analyzer', 'coder', 'tester'] },
+  { re: /\\b(test|coverage|tdd|spec)\\b/i, roles: ['tester', 'coder', 'reviewer'] },
+  { re: /\\b(feature|implement|build|integrat\\w*|end-to-end|api)\\b/i, roles: ['researcher', 'system-architect', 'coder', 'tester', 'reviewer'] },
+];
+function classifyAgentic(task) {
+  const p = String(task == null ? '' : task).trim();
+  if (!p) return { requiresAgents: false, roles: [] };
+  if (!AGENTIC_RE.test(p)) return { requiresAgents: false, roles: [] };
+  if (TRIVIAL_RE.test(p) && p.length < 40) return { requiresAgents: false, roles: [] };
+  let roles = ['coder'];
+  for (const s of ROLE_SIGNALS) {
+    if (s.re.test(p)) { roles = s.roles; break; }
+  }
+  return { requiresAgents: true, roles };
+}
+
 // CLI
 const task = process.argv.slice(2).join(' ');
 
@@ -288,7 +313,7 @@ if (task) {
   console.log('\\nAvailable agents:', Object.keys(AGENT_CAPABILITIES).join(', '));
 }
 
-module.exports = { routeTask, AGENT_CAPABILITIES, TASK_PATTERNS, buildPattern };
+module.exports = { routeTask, classifyAgentic, AGENT_CAPABILITIES, TASK_PATTERNS, buildPattern };
 `;
 }
 /**
@@ -482,6 +507,21 @@ export function generateHookHandler() {
         '    } else {',
         "      console.log('[INFO] Router not available, using default routing');",
         '    }',
+        '    // Agentic prompts → remind the main agent to actually USE Swarmdo:',
+        '    // spawn Claude Code agents AND bridge them (auto-forms a swarm).',
+        '    // Advisory + fully guarded — never breaks the prompt.',
+        '    try {',
+        '      if (router && router.classifyAgentic) {',
+        '        var intent = router.classifyAgentic(prompt);',
+        '        if (intent.requiresAgents) {',
+        "          console.log('');",
+        "          console.log('[SWARMDO] Agentic task — use the swarm: after you spawn Claude Code agents,');",
+        "          console.log('  register each so Swarmdo tracks them and auto-forms a swarm from your config:');",
+        "          console.log('    swarmdo agent bridge register -n <agent-name> -t <role> -s <session>');",
+        "          console.log('  suggested roles: ' + intent.roles.join(', ') + '   then: swarmdo agent bridge list / swarm status');",
+        '        }',
+        '      }',
+        '    } catch (e) { /* advisory only — never break the prompt */ }',
         '  },',
         '',
         "  'pre-bash': () => {",

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/agent-tools.js

@@ -9,6 +9,7 @@ import { join } from 'node:path';
 import { getProjectCwd } from './types.js';
 import { validateIdentifier, validateText, validateAgentSpawn } from './validate-input.js';
 import { executeAgentTask } from './agent-execute-core.js';
+import { buildSpawnInput, reconcile, isBound, orphanedAgentIds } from '../agent-bridge/bridge.js';
 // Storage paths
 const STORAGE_DIR = '.swarmdo';
 const AGENT_DIR = 'agents';
@@ -74,6 +75,27 @@ function loadHiveAgents() {
 function loadAllAgents() {
     return { ...loadHiveAgents(), ...loadAgentStore().agents };
 }
+/**
+ * Read the project's swarm topology defaults from swarmdo.config.json for the
+ * agent bridge's auto-swarm. Defensive — returns {} on any error so the bridge
+ * falls back to the anti-drift defaults (hierarchical / 8 / specialized).
+ * Accepts either a top-level `swarm` block or the root object.
+ */
+function readSwarmConfigDefaults() {
+    try {
+        const p = join(getProjectCwd(), 'swarmdo.config.json');
+        if (!existsSync(p))
+            return {};
+        const j = JSON.parse(readFileSync(p, 'utf-8'));
+        const sw = (j.swarm || j) ?? {};
+        const str = (v) => (typeof v === 'string' ? v : undefined);
+        const num = (v) => (typeof v === 'number' ? v : undefined);
+        return { topology: str(sw.topology), maxAgents: num(sw.maxAgents), strategy: str(sw.strategy) };
+    }
+    catch {
+        return {};
+    }
+}
 // Default model mappings for agent types (can be overridden)
 const AGENT_TYPE_MODEL_DEFAULTS = {
     // Complex agents → opus
@@ -323,6 +345,150 @@ export const agentTools = [
             return response;
         },
     },
+    {
+        name: 'agent_bridge_register',
+        description: "Register a REAL Claude Code Agent-tool agent into Swarmdo's registry so `swarmdo agent list` and `swarm_status` reflect it. Call this right AFTER you spawn a Claude Code subagent (Task/Agent tool): pass its name, session id, subagent type, and a one-line task. Idempotent — re-registering the same name+session UPDATES the bound record instead of duplicating. This is the bridge that stops Swarmdo sitting empty while real agents run: unlike agent_spawn (which only registers coordination metadata), this binds the record to a worker that actually exists.",
+        category: 'agent',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'The Claude Code agent name (e.g. "research-ccgap")' },
+                sessionId: { type: 'string', description: 'The Claude Code session id (from name@session-…)' },
+                agentType: { type: 'string', description: 'The subagent_type (e.g. general-purpose, coder). Default general-purpose.' },
+                task: { type: 'string', description: 'One-line task/prompt summary' },
+            },
+            required: ['name'],
+        },
+        handler: async (input) => {
+            const src = input;
+            const name = String(src.name || '').trim();
+            if (!name)
+                return { success: false, error: 'name is required (the Claude Code agent name)' };
+            const descriptor = {
+                name,
+                sessionId: src.sessionId ? String(src.sessionId) : undefined,
+                agentType: String(src.agentType || 'general-purpose'),
+                task: src.task ? String(src.task) : undefined,
+            };
+            const spawnInput = buildSpawnInput(descriptor, new Date().toISOString());
+            // Auto-swarm: registering a Claude Code agent spins up a swarm from the
+            // project config (anti-drift defaults if absent) when none is running, and
+            // enrolls this agent into it — so bridged agents coordinate instead of
+            // floating unattached. registerAgent honors spawnInput.swarmId to join.
+            let swarm;
+            try {
+                const { ensureActiveSwarm } = await import('./swarm-tools.js');
+                const cfg = readSwarmConfigDefaults();
+                swarm = ensureActiveSwarm({
+                    topology: cfg.topology || 'hierarchical',
+                    maxAgents: cfg.maxAgents || 8,
+                    strategy: cfg.strategy || 'specialized',
+                });
+                spawnInput.swarmId = swarm.swarmId;
+            }
+            catch {
+                /* swarm optional — the agent still registers in the global store */
+            }
+            const res = await registerAgent(spawnInput);
+            if (!res.success)
+                return res;
+            return {
+                ...res,
+                bound: true,
+                origin: 'claude-code',
+                claudeName: descriptor.name,
+                status: 'registered',
+                ...(swarm ? { swarm } : {}),
+            };
+        },
+    },
+    {
+        name: 'agent_bridge_list',
+        description: 'List Swarmdo agent records split into Claude-Code-BOUND (each mirrors a real Task/Agent-tool agent) vs NATIVE, with binding detail. Pass `live` (array of current Claude Code agent names) to also get a reconciliation: which live agents are unmirrored (need agent_bridge_register), and which bound records are orphaned (their Claude agent is gone).',
+        category: 'agent',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                live: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Current live Claude Code agent names, for reconciliation',
+                },
+            },
+        },
+        handler: async (input) => {
+            const all = Object.values(loadAllAgents());
+            const summarize = (a) => ({
+                agentId: a.agentId,
+                agentType: a.agentType,
+                status: a.status,
+                ...(isBound(a) ? { binding: a.config.binding } : {}),
+            });
+            const bound = all.filter(isBound).map(summarize);
+            const native = all.filter((a) => !isBound(a)).map(summarize);
+            const liveRaw = input.live;
+            const live = Array.isArray(liveRaw) ? liveRaw.map(String) : undefined;
+            const reconciliation = live ? reconcile(all, live) : undefined;
+            return {
+                total: all.length,
+                boundCount: bound.length,
+                nativeCount: native.length,
+                bound,
+                native,
+                ...(reconciliation ? { reconciliation } : {}),
+            };
+        },
+    },
+    {
+        name: 'agent_bridge_prune',
+        description: "Reap orphaned Claude-Code-bound records — bound agents whose Claude Code agent is no longer live. Pass the CURRENT live Claude Code agent names as `live`; any bound record NOT in that list is removed from the agent store and from every swarm roster. Native (unbound) Swarmdo agents are never touched. Idempotent — use it to stop stale bindings accumulating across sessions.",
+        category: 'agent',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                live: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Current live Claude Code agent names; bound records not in this list are pruned',
+                },
+            },
+            required: ['live'],
+        },
+        handler: async (input) => {
+            const liveRaw = input.live;
+            const live = Array.isArray(liveRaw) ? liveRaw.map(String) : [];
+            const all = Object.values(loadAllAgents());
+            const toPrune = orphanedAgentIds(all, live);
+            if (toPrune.length === 0)
+                return { pruned: [], count: 0 };
+            // Remove from the canonical agent store (bound records always live here).
+            const store = loadAgentStore();
+            for (const id of toPrune)
+                delete store.agents[id];
+            saveAgentStore(store);
+            // Remove from any swarm roster so swarm_status doesn't report ghosts.
+            try {
+                const { loadSwarmStore: _loadSwarmStore, saveSwarmStore: _saveSwarmStore } = await import('./swarm-tools.js');
+                const swarmStore = _loadSwarmStore();
+                const pruneSet = new Set(toPrune);
+                let changed = false;
+                for (const swarm of Object.values(swarmStore.swarms)) {
+                    if (Array.isArray(swarm.agents)) {
+                        const before = swarm.agents.length;
+                        swarm.agents = swarm.agents.filter((a) => !pruneSet.has(a));
+                        if (swarm.agents.length !== before)
+                            changed = true;
+                    }
+                }
+                if (changed)
+                    _saveSwarmStore(swarmStore);
+            }
+            catch {
+                /* swarm store optional — records already removed from the agent store */
+            }
+            return { pruned: toPrune, count: toPrune.length };
+        },
+    },
     {
         // ADR-095 G3 — spawn + execute fused. Closes the #1 UX trap from the
         // 2026-04 audit (@roman-rr): `agent_spawn` looks like it spawns a worker

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/mcp-tools/swarm-tools.d.ts

@@ -32,6 +32,39 @@ interface SwarmStore {
 }
 export declare function loadSwarmStore(): SwarmStore;
 export declare function saveSwarmStore(store: SwarmStore): void;
+export interface CreateSwarmOptions {
+    topology?: string;
+    maxAgents?: number;
+    strategy?: string;
+    config?: Record<string, unknown>;
+    /**
+     * When true, do NOT stamp the host `pid` — the swarm is a persistent logical
+     * coordination record, not tied to one process's lifetime, so it survives
+     * ephemeral CLI invocations (the agent bridge) instead of being reaped by the
+     * #1799 PID-orphan check the instant the creating process exits. Such swarms
+     * still expire via the 24h idle-TTL fallback. Daemon-hosted swarms
+     * (`swarm_init`) leave this false so a dead host IS reaped promptly.
+     */
+    persistent?: boolean;
+}
+/**
+ * Create + persist a swarm. Extracted from the `swarm_init` handler so other
+ * subsystems (the Claude-Code agent bridge) can spin up a swarm from config
+ * WITHOUT duplicating the store-write. Throws on an invalid topology. Shared
+ * single source of truth — no parallel swarm creation.
+ */
+export declare function createSwarm(opts: CreateSwarmOptions): SwarmState;
+/**
+ * Return the most-recent RUNNING swarm, or create one from `defaults` if none
+ * exists. Used by the agent bridge so registering a Claude Code agent
+ * auto-spins-up a swarm (from the project's anti-drift config) and enrolls it,
+ * instead of leaving the agent unattached.
+ */
+export declare function ensureActiveSwarm(defaults: CreateSwarmOptions): {
+    swarmId: string;
+    topology: string;
+    created: boolean;
+};
 export declare const swarmTools: MCPTool[];
 export {};
 //# sourceMappingURL=swarm-tools.d.ts.map

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

@@ -109,6 +109,64 @@ export function saveSwarmStore(store) {
 const VALID_TOPOLOGIES = new Set([
     'hierarchical', 'mesh', 'hierarchical-mesh', 'ring', 'star', 'hybrid', 'adaptive',
 ]);
+/**
+ * Create + persist a swarm. Extracted from the `swarm_init` handler so other
+ * subsystems (the Claude-Code agent bridge) can spin up a swarm from config
+ * WITHOUT duplicating the store-write. Throws on an invalid topology. Shared
+ * single source of truth — no parallel swarm creation.
+ */
+export function createSwarm(opts) {
+    const topology = opts.topology || 'hierarchical-mesh';
+    const maxAgents = Math.min(Math.max(opts.maxAgents || 15, 1), 50);
+    const strategy = opts.strategy || 'specialized';
+    const config = opts.config || {};
+    if (!VALID_TOPOLOGIES.has(topology)) {
+        throw new Error(`Invalid topology: ${topology}. Valid: ${[...VALID_TOPOLOGIES].join(', ')}`);
+    }
+    const swarmId = `swarm-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const now = new Date().toISOString();
+    const swarmState = {
+        swarmId,
+        topology,
+        maxAgents,
+        status: 'running',
+        agents: [],
+        tasks: [],
+        config: {
+            topology,
+            maxAgents,
+            strategy,
+            communicationProtocol: config.communicationProtocol || 'message-bus',
+            autoScaling: config.autoScaling ?? true,
+            consensusMechanism: config.consensusMechanism || 'majority',
+        },
+        createdAt: now,
+        updatedAt: now,
+        // Persistent (bridge) swarms omit the pid so they aren't reaped on process
+        // exit; daemon-hosted swarms record it for prompt orphan reconciliation.
+        ...(opts.persistent ? {} : { pid: process.pid }),
+    };
+    const store = loadSwarmStore();
+    store.swarms[swarmId] = swarmState;
+    saveSwarmStore(store);
+    return swarmState;
+}
+/**
+ * Return the most-recent RUNNING swarm, or create one from `defaults` if none
+ * exists. Used by the agent bridge so registering a Claude Code agent
+ * auto-spins-up a swarm (from the project's anti-drift config) and enrolls it,
+ * instead of leaving the agent unattached.
+ */
+export function ensureActiveSwarm(defaults) {
+    const store = loadSwarmStore();
+    const running = Object.values(store.swarms)
+        .filter((s) => s.status === 'running')
+        .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())[0];
+    if (running)
+        return { swarmId: running.swarmId, topology: running.topology, created: false };
+    const s = createSwarm({ ...defaults, persistent: true });
+    return { swarmId: s.swarmId, topology: s.topology, created: true };
+}
 export const swarmTools = [
     {
         name: 'swarm_init',
@@ -135,49 +193,26 @@ export const swarmTools = [
                 if (!v.valid)
                     return { success: false, error: v.error };
             }
-            const topology = input.topology || 'hierarchical-mesh';
-            const maxAgents = Math.min(Math.max(input.maxAgents || 15, 1), 50);
             const strategy = input.strategy || 'specialized';
-            const config = (input.config || {});
-            if (!VALID_TOPOLOGIES.has(topology)) {
-                return {
-                    success: false,
-                    error: `Invalid topology: ${topology}. Valid: ${[...VALID_TOPOLOGIES].join(', ')}`,
-                };
-            }
-            const swarmId = `swarm-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-            const now = new Date().toISOString();
-            const swarmState = {
-                swarmId,
-                topology,
-                maxAgents,
-                status: 'running',
-                agents: [],
-                tasks: [],
-                config: {
-                    topology,
-                    maxAgents,
+            let swarmState;
+            try {
+                swarmState = createSwarm({
+                    topology: input.topology,
+                    maxAgents: input.maxAgents,
                     strategy,
-                    communicationProtocol: config.communicationProtocol || 'message-bus',
-                    autoScaling: config.autoScaling ?? true,
-                    consensusMechanism: config.consensusMechanism || 'majority',
-                },
-                createdAt: now,
-                updatedAt: now,
-                // #1799 — record host PID so subsequent loads can detect orphans
-                // when this process exits without a graceful swarm_shutdown.
-                pid: process.pid,
-            };
-            const store = loadSwarmStore();
-            store.swarms[swarmId] = swarmState;
-            saveSwarmStore(store);
+                    config: (input.config || {}),
+                });
+            }
+            catch (e) {
+                return { success: false, error: e.message };
+            }
             return {
                 success: true,
-                swarmId,
-                topology,
+                swarmId: swarmState.swarmId,
+                topology: swarmState.topology,
                 strategy,
-                maxAgents,
-                initializedAt: now,
+                maxAgents: swarmState.maxAgents,
+                initializedAt: swarmState.createdAt,
                 config: swarmState.config,
                 persisted: true,
             };