swarmdo 1.50.0 → 1.54.1

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

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

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

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

package/v3/@swarmdo/cli/dist/src/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-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/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