swarmdo 1.50.0 → 1.58.1

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

@@ -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;
 
@@ -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.

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/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/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.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,
             };

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

@@ -0,0 +1,83 @@
+/**
+ * standup.ts — "what did I do?" recall from git history, weekend-aware.
+ *
+ * Ports the signature behavior of git-standup: list the commits since your last
+ * WORKING day, so on Monday you reach back to Friday (not merely yesterday).
+ * Power users juggling many repos + AI-agent sessions use it to re-orient at the
+ * start of a session and to answer the standup question in one command.
+ *
+ * Pure + deterministic: the grouping core takes the raw `git log --numstat`
+ * dump (control-char delimited, subject included) and a reference Date, and
+ * folds it into per-day buckets. No LLM, no network — the git subprocess lives
+ * in ../commands/standup.ts, so this module is fully fixture-testable.
+ * `resolveRenamePath` is reused from hotspots so renamed files fold correctly.
+ *
+ * Expected log format (control-char delimited):
+ *   <SOH>%H<US>%aN<US>%aI<US>%s     ← one header line per commit (subject last)
+ *   <added>\t<deleted>\t<path>      ← one numstat line per file ('-' = binary)
+ */
+export interface StandupCommit {
+    hash: string;
+    author: string;
+    /** epoch milliseconds, parsed from the ISO author date */
+    date: number;
+    subject: string;
+    /** insertions summed across the commit's files (binary counts as 0) */
+    added: number;
+    /** deletions summed across the commit's files */
+    deleted: number;
+    /** count of files touched by the commit */
+    files: number;
+}
+export interface DayBucket {
+    /** local calendar day, `YYYY-MM-DD` */
+    day: string;
+    /** commits on this day, newest first */
+    commits: StandupCommit[];
+    /** day totals */
+    added: number;
+    deleted: number;
+    files: number;
+}
+/**
+ * How many days back to the last WORKING day (Mon–Fri), given a day-of-week
+ * (0=Sun..6=Sat). Weekend-aware, matching git-standup's signature behavior:
+ *   Monday (1)  → 3  (reach back to Friday)
+ *   Sunday (0)  → 2  (reach back to Friday)
+ *   any other   → 1  (yesterday)
+ * Pure integer core — no Date, no timezone. Out-of-range inputs are normalized
+ * into 0..6 so callers can pass raw arithmetic safely.
+ */
+export declare function daysToLastWorkingDay(dayOfWeek: number): number;
+/**
+ * The default weekend-aware window for a reference date. Reads the LOCAL
+ * day-of-week — a user's "last working day" is local to them. Pure w.r.t. the
+ * injected Date.
+ */
+export declare function sinceLastWorkingDay(refDate: Date): {
+    sinceDays: number;
+};
+/** Parse the control-char-delimited standup log dump into commits. Pure. */
+export declare function parseStandupLog(raw: string): StandupCommit[];
+/**
+ * Local `YYYY-MM-DD` for an epoch-ms instant. Uses LOCAL calendar components so
+ * the day matches the user's wall clock; round-trips with local-constructed
+ * dates regardless of the runner timezone. Pure.
+ */
+export declare function dayKey(ms: number): string;
+/**
+ * Fold commits into per-day buckets — newest day first, and newest commit first
+ * within a day. Day boundaries are LOCAL. Pure (Array.sort is stable, so
+ * same-timestamp commits keep git-log order).
+ */
+export declare function groupByDay(commits: StandupCommit[]): DayBucket[];
+/** Weekday name for a `YYYY-MM-DD` day key (local). '' if unparseable. Pure. */
+export declare function weekdayOf(day: string): string;
+/**
+ * Human-readable standup: a heading per day (weekday + date + counts) followed
+ * by each commit's abbreviated hash and subject, then a totals footer. Pure.
+ */
+export declare function formatStandup(buckets: DayBucket[], opts?: {
+    abbrev?: number;
+}): string;
+//# sourceMappingURL=standup.d.ts.map