@girardmedia/bootspring 2.6.0 → 3.0.0

package/dist/cli/index.js

@@ -31,6 +31,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // ../../node_modules/.pnpm/tsup@8.5.1_jiti@1.21.7_postcss@8.5.8_tsx@4.21.0_typescript@5.9.3_yaml@2.8.3/node_modules/tsup/assets/cjs_shims.js
 var init_cjs_shims = __esm({
@@ -3385,7 +3386,7 @@ var init_release = __esm({
   "../../packages/shared/src/release.ts"() {
     "use strict";
     init_cjs_shims();
-    BOOTSPRING_VERSION = "2.6.0";
+    BOOTSPRING_VERSION = "3.0.0";
     BOOTSPRING_PACKAGE_NAME = "@girardmedia/bootspring";
   }
 });
@@ -38412,7 +38413,7 @@ var require_main = __commonJS({
       }
       return to;
     };
-    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
     var node_exports = {};
     __export2(node_exports, {
       analyzeMetafile: () => analyzeMetafile,
@@ -38429,7 +38430,7 @@ var require_main = __commonJS({
       transformSync: () => transformSync,
       version: () => version3
     });
-    module2.exports = __toCommonJS(node_exports);
+    module2.exports = __toCommonJS2(node_exports);
     function encodePacket(packet) {
       let visit = (value) => {
         if (value === null) {
@@ -39210,7 +39211,7 @@ is not a problem with esbuild. You need to fix your environment instead.
     function buildOrContextImpl(callName, buildKey, sendRequest, sendResponse, refs, streamIn, requestCallbacks, options, isTTY2, defaultWD2, callback) {
       const details = createObjectStash();
       const isContext = callName === "context";
-      const handleError = (e, pluginName) => {
+      const handleError2 = (e, pluginName) => {
         const flags = [];
         try {
           pushLogFlags(flags, options, {}, isTTY2, buildLogLevelDefault);
@@ -39226,12 +39227,12 @@ is not a problem with esbuild. You need to fix your environment instead.
       if (typeof options === "object") {
         const value = options.plugins;
         if (value !== void 0) {
-          if (!Array.isArray(value)) return handleError(new Error(`"plugins" must be an array`), "");
+          if (!Array.isArray(value)) return handleError2(new Error(`"plugins" must be an array`), "");
           plugins = value;
         }
       }
       if (plugins && plugins.length > 0) {
-        if (streamIn.isSync) return handleError(new Error("Cannot use plugins in synchronous API calls"), "");
+        if (streamIn.isSync) return handleError2(new Error("Cannot use plugins in synchronous API calls"), "");
         handlePlugins(
           buildKey,
           sendRequest,
@@ -39244,14 +39245,14 @@ is not a problem with esbuild. You need to fix your environment instead.
           details
         ).then(
           (result) => {
-            if (!result.ok) return handleError(result.error, result.pluginName);
+            if (!result.ok) return handleError2(result.error, result.pluginName);
             try {
               buildOrContextContinue(result.requestPlugins, result.runOnEndCallbacks, result.scheduleOnDisposeCallbacks);
             } catch (e) {
-              handleError(e, "");
+              handleError2(e, "");
             }
           },
-          (e) => handleError(e, "")
+          (e) => handleError2(e, "")
         );
         return;
       }
@@ -39259,7 +39260,7 @@ is not a problem with esbuild. You need to fix your environment instead.
         buildOrContextContinue(null, (result, done) => done([], []), () => {
         });
       } catch (e) {
-        handleError(e, "");
+        handleError2(e, "");
       }
       function buildOrContextContinue(requestPlugins, runOnEndCallbacks, scheduleOnDisposeCallbacks) {
         const writeDefault = streamIn.hasFS;
@@ -45805,12 +45806,414 @@ var init_autopilot_tools = __esm({
   }
 });
 
+// ../../packages/mcp/src/brain-tools.ts
+function getRouter() {
+  if (!routerInstance) {
+    try {
+      const { brain } = require("@bootspring/session-intelligence");
+      routerInstance = new brain.UnifiedBrainRouter();
+    } catch {
+      throw new Error("Brain router requires @bootspring/session-intelligence");
+    }
+  }
+  return routerInstance;
+}
+function registerBrainTools() {
+  registerTool(brainDefinition, brainHandler);
+}
+var routerInstance, brainDefinition, brainHandler, BRAIN_TOOLS;
+var init_brain_tools = __esm({
+  "../../packages/mcp/src/brain-tools.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_registry();
+    routerInstance = null;
+    brainDefinition = {
+      name: "bootspring_brain",
+      description: "Intelligent natural language router \u2014 analyzes input and dispatches to the right Bootspring skill, workflow, agent, or pipeline. Use this to find the best action for any request.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          prompt: {
+            type: "string",
+            description: "Natural language input to route"
+          },
+          autoDispatch: {
+            type: "boolean",
+            description: "If true and confidence > 0.85, include a dispatch instruction"
+          }
+        },
+        required: ["prompt"]
+      }
+    };
+    brainHandler = async (args) => {
+      const prompt2 = String(args.prompt || "");
+      const autoDispatch = Boolean(args.autoDispatch);
+      if (!prompt2.trim()) {
+        return {
+          content: [{ type: "text", text: "Error: prompt is required" }],
+          isError: true
+        };
+      }
+      const router = getRouter();
+      const result = router.route(prompt2);
+      const lines = [];
+      lines.push(`Brain Router Result`);
+      lines.push(`${"=".repeat(50)}`);
+      lines.push(`Target:     ${result.target.name}`);
+      lines.push(`Type:       ${result.target.type}`);
+      lines.push(`Confidence: ${result.confidence}`);
+      lines.push(`Method:     ${result.method}`);
+      if (result.target.command) {
+        lines.push(`Command:    ${result.target.command}`);
+      }
+      lines.push(`
+Description: ${result.target.description}`);
+      lines.push(`
+Explanation: ${result.explanation}`);
+      if (result.alternatives.length > 0) {
+        lines.push(`
+Alternatives:`);
+        for (const alt of result.alternatives) {
+          const cmd = alt.target.command ? ` (${alt.target.command})` : "";
+          lines.push(`  - ${alt.target.name} [${alt.target.type}] confidence=${alt.confidence}${cmd}`);
+        }
+      }
+      if (autoDispatch && result.confidence >= 0.85 && result.target.command) {
+        lines.push(`
+${"=".repeat(50)}`);
+        lines.push(`AUTO-DISPATCH: Confidence ${result.confidence} >= 0.85`);
+        lines.push(`Execute: ${result.target.command}`);
+        lines.push(
+          `Use the MCP tool or CLI command above to fulfill the user's request.`
+        );
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    };
+    BRAIN_TOOLS = [brainDefinition];
+  }
+});
+
+// ../../packages/mcp/src/swarm-tools.ts
+function errorResult(message) {
+  return {
+    content: [{ type: "text", text: `Error: ${message}` }],
+    isError: true
+  };
+}
+function registerSwarmTools() {
+  registerTool(swarmDefinition, swarmHandler);
+  registerTool(memoryDefinition, memoryHandler);
+  registerTool(planDefinition, planHandler);
+}
+var swarmDefinition, swarmHandler, memoryDefinition, memoryHandler, planDefinition, planHandler, SWARM_TOOLS;
+var init_swarm_tools = __esm({
+  "../../packages/mcp/src/swarm-tools.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_registry();
+    swarmDefinition = {
+      name: "bootspring_swarm",
+      description: "Multi-agent swarm orchestration \u2014 start swarms, spawn agents, submit tasks, run consensus votes, and change topologies (hierarchical, mesh, ring, star, adaptive). Agents collaborate through shared state and self-organize based on workload.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["start", "stop", "status", "spawn", "agents", "submit", "batch", "consensus", "topology"],
+            description: "Swarm action to perform"
+          },
+          topology: {
+            type: "string",
+            enum: ["hierarchical", "mesh", "ring", "star", "adaptive"],
+            description: "Swarm topology (for start/topology actions)"
+          },
+          role: {
+            type: "string",
+            enum: ["queen", "worker", "specialist", "reviewer", "monitor"],
+            description: "Agent role (for spawn action)"
+          },
+          capabilities: {
+            type: "array",
+            items: { type: "string" },
+            description: "Agent capabilities (for spawn action)"
+          },
+          taskType: {
+            type: "string",
+            description: "Task type (for submit action)"
+          },
+          taskDescription: {
+            type: "string",
+            description: "Task description (for submit action)"
+          },
+          priority: {
+            type: "string",
+            enum: ["critical", "high", "normal", "low"],
+            description: "Task priority (for submit action)"
+          },
+          question: {
+            type: "string",
+            description: "Question for consensus vote"
+          },
+          options: {
+            type: "array",
+            items: { type: "string" },
+            description: "Vote options for consensus"
+          }
+        },
+        required: ["action"]
+      }
+    };
+    swarmHandler = async (args) => {
+      const action = String(args.action || "");
+      try {
+        const { api } = (init_src2(), __toCommonJS(src_exports2));
+        let result;
+        switch (action) {
+          case "start":
+            result = await api.request("POST", "/swarm/start", {
+              topology: args.topology || "hierarchical"
+            });
+            break;
+          case "stop":
+            result = await api.request("POST", "/swarm/stop");
+            break;
+          case "status":
+            result = await api.request("GET", "/swarm/status");
+            break;
+          case "spawn":
+            if (!args.role) return errorResult("role is required for spawn");
+            result = await api.request("POST", "/swarm/agents", {
+              role: args.role,
+              capabilities: args.capabilities || ["general"]
+            });
+            break;
+          case "agents":
+            result = await api.request("GET", "/swarm/agents");
+            break;
+          case "submit":
+            if (!args.taskType || !args.taskDescription) {
+              return errorResult("taskType and taskDescription are required for submit");
+            }
+            result = await api.request("POST", "/swarm/tasks", {
+              type: args.taskType,
+              description: args.taskDescription,
+              input: {},
+              priority: args.priority || "normal"
+            });
+            break;
+          case "consensus":
+            if (!args.question || !args.options) {
+              return errorResult("question and options are required for consensus");
+            }
+            result = await api.request("POST", "/swarm/consensus", {
+              question: args.question,
+              options: args.options
+            });
+            break;
+          case "topology":
+            if (args.topology) {
+              result = await api.request("POST", "/swarm/topology", { topology: args.topology });
+            } else {
+              result = await api.request("GET", "/swarm/topology");
+            }
+            break;
+          default:
+            return errorResult(`Unknown action: ${action}`);
+        }
+        return {
+          content: [{
+            type: "text",
+            text: `Swarm ${action} result:
+${JSON.stringify(result, null, 2)}`
+          }]
+        };
+      } catch (err) {
+        return errorResult(err instanceof Error ? err.message : String(err));
+      }
+    };
+    memoryDefinition = {
+      name: "bootspring_memory",
+      description: "Vector memory for AI agents \u2014 store decisions, patterns, and trajectories. Search by semantic similarity using HNSW index. Agents learn from past successes.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["search", "store", "trajectory", "stats", "forget"],
+            description: "Memory action to perform"
+          },
+          query: {
+            type: "string",
+            description: "Search query (for search action)"
+          },
+          content: {
+            type: "string",
+            description: "Content to store (for store action)"
+          },
+          type: {
+            type: "string",
+            enum: ["decision", "pattern", "error", "solution", "context", "preference", "trajectory"],
+            description: "Memory entry type"
+          },
+          goal: {
+            type: "string",
+            description: "Goal (for trajectory action)"
+          },
+          steps: {
+            type: "array",
+            items: { type: "string" },
+            description: "Steps taken (for trajectory action)"
+          },
+          outcome: {
+            type: "string",
+            enum: ["success", "partial", "failure"],
+            description: "Trajectory outcome"
+          },
+          id: {
+            type: "string",
+            description: "Entry ID (for forget action)"
+          },
+          limit: {
+            type: "number",
+            description: "Max results for search (default 10)"
+          }
+        },
+        required: ["action"]
+      }
+    };
+    memoryHandler = async (args) => {
+      const action = String(args.action || "");
+      try {
+        const { api } = (init_src2(), __toCommonJS(src_exports2));
+        let result;
+        switch (action) {
+          case "search":
+            if (!args.query) return errorResult("query is required for search");
+            result = await api.request("POST", "/swarm/memory/search", {
+              query: args.query,
+              limit: args.limit || 10,
+              type: args.type
+            });
+            break;
+          case "store":
+            if (!args.content || !args.type) return errorResult("content and type are required for store");
+            result = await api.request("POST", "/swarm/memory", {
+              content: args.content,
+              type: args.type,
+              sessionId: `mcp-${Date.now()}`
+            });
+            break;
+          case "trajectory":
+            if (!args.goal || !args.steps || !args.outcome) {
+              return errorResult("goal, steps, and outcome are required for trajectory");
+            }
+            result = await api.request("POST", "/swarm/memory/trajectory", {
+              goal: args.goal,
+              steps: args.steps,
+              sessionId: `mcp-${Date.now()}`,
+              outcome: args.outcome
+            });
+            break;
+          case "stats":
+            result = await api.request("GET", "/swarm/memory/stats");
+            break;
+          case "forget":
+            if (!args.id) return errorResult("id is required for forget");
+            result = await api.request("DELETE", `/swarm/memory/${args.id}`);
+            break;
+          default:
+            return errorResult(`Unknown action: ${action}`);
+        }
+        return {
+          content: [{
+            type: "text",
+            text: `Memory ${action} result:
+${JSON.stringify(result, null, 2)}`
+          }]
+        };
+      } catch (err) {
+        return errorResult(err instanceof Error ? err.message : String(err));
+      }
+    };
+    planDefinition = {
+      name: "bootspring_plan",
+      description: "Goal-oriented action planning (GOAP) \u2014 decompose high-level goals into executable task DAGs with A* search. Finds optimal sequences and parallelizable groups.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["plan", "actions", "register"],
+            description: "Planner action"
+          },
+          goal: {
+            type: "string",
+            description: "Goal to plan for (for plan action)"
+          },
+          parallel: {
+            type: "boolean",
+            description: "Enable parallel task groups"
+          },
+          currentState: {
+            type: "object",
+            description: "Current world state (key-value pairs)"
+          },
+          goalConditions: {
+            type: "array",
+            description: "Goal conditions [{key, operator, value}]"
+          }
+        },
+        required: ["action"]
+      }
+    };
+    planHandler = async (args) => {
+      const action = String(args.action || "");
+      try {
+        const { api } = (init_src2(), __toCommonJS(src_exports2));
+        let result;
+        switch (action) {
+          case "plan":
+            if (!args.goal) return errorResult("goal is required for plan");
+            result = await api.request("POST", "/swarm/plan", {
+              goal: args.goal,
+              currentState: args.currentState || {},
+              goalConditions: args.goalConditions || [{ key: "deployed", operator: "==", value: true }],
+              parallel: args.parallel ?? true
+            });
+            break;
+          case "actions":
+            result = await api.request("GET", "/swarm/plan/actions");
+            break;
+          case "register":
+            return errorResult("Register custom actions via the API: POST /swarm/plan/actions");
+          default:
+            return errorResult(`Unknown action: ${action}`);
+        }
+        return {
+          content: [{
+            type: "text",
+            text: `Plan ${action} result:
+${JSON.stringify(result, null, 2)}`
+          }]
+        };
+      } catch (err) {
+        return errorResult(err instanceof Error ? err.message : String(err));
+      }
+    };
+    SWARM_TOOLS = [swarmDefinition, memoryDefinition, planDefinition];
+  }
+});
+
 // ../../packages/mcp/src/index.ts
 var src_exports3 = {};
 __export(src_exports3, {
   ASSISTANT_PARITY_TOOLS: () => ASSISTANT_PARITY_TOOLS,
   AUDIT_TOOLS: () => AUDIT_TOOLS,
   AUTOPILOT_TOOLS: () => AUTOPILOT_TOOLS,
+  BRAIN_TOOLS: () => BRAIN_TOOLS,
   COMPLIANCE_TOOLS: () => COMPLIANCE_TOOLS,
   DOCS_INTELLIGENCE_TOOLS: () => DOCS_INTELLIGENCE_TOOLS,
   MARKETPLACE_TOOLS: () => MARKETPLACE_TOOLS,
@@ -45821,6 +46224,7 @@ __export(src_exports3, {
   QUALITY_INTELLIGENCE_TOOLS: () => QUALITY_INTELLIGENCE_TOOLS,
   RBAC_TOOLS: () => RBAC_TOOLS,
   RELEASE_TOOLS: () => RELEASE_TOOLS,
+  SWARM_TOOLS: () => SWARM_TOOLS,
   SYNC_TOOLS: () => SYNC_TOOLS,
   agentDetails: () => agentDetails,
   assistResponse: () => assistResponse,
@@ -45850,6 +46254,7 @@ __export(src_exports3, {
   registerAssistantParityTools: () => registerAssistantParityTools,
   registerAuditTools: () => registerAuditTools,
   registerAutopilotTools: () => registerAutopilotTools,
+  registerBrainTools: () => registerBrainTools,
   registerComplianceTools: () => registerComplianceTools,
   registerDocsIntelligenceTools: () => registerDocsIntelligenceTools,
   registerMarketplaceTools: () => registerMarketplaceTools,
@@ -45861,6 +46266,7 @@ __export(src_exports3, {
   registerRbacTools: () => registerRbacTools,
   registerReleaseTools: () => registerReleaseTools,
   registerResource: () => registerResource,
+  registerSwarmTools: () => registerSwarmTools,
   registerSyncTools: () => registerSyncTools,
   registerTool: () => registerTool,
   resolveCompatibilityRegistry: () => resolveCompatibilityRegistry,
@@ -45895,6 +46301,8 @@ var init_src3 = __esm({
     init_notification_tools();
     init_observer_tools();
     init_autopilot_tools();
+    init_brain_tools();
+    init_swarm_tools();
   }
 });
 
@@ -66263,7 +66671,7 @@ function drawProgressBar(progress, width = 20) {
 }
 function getWorkflowStates(projectRoot) {
   const workflows = {};
-  const names = ["onboard", "analyze", "audit", "seed", "context", "deploy", "loop", "preseed"];
+  const names = ["onboard", "analyze", "audit", "seed", "context", "deploy", "loop"];
   for (const name of names) {
     const stateFile = path78.join(projectRoot, ".bootspring", name, "workflow-state.json");
     if (fs77.existsSync(stateFile)) {
@@ -72765,10 +73173,434 @@ function registerHarnessCommand(program3) {
   });
 }
 
-// src/commands/geo.ts
+// src/commands/swarm.ts
 init_cjs_shims();
 init_src2();
 function requireAuth4() {
+  if (auth_exports.isAuthenticated()) return true;
+  print(`${COLORS.red}Not authenticated.${COLORS.reset} Run ${COLORS.bold}bootspring auth login${COLORS.reset} first.`);
+  process.exitCode = 1;
+  return false;
+}
+function handleError(error50) {
+  if (error50 && typeof error50 === "object" && "response" in error50) {
+    const resp = error50.response;
+    if (resp?.status === 403) {
+      print(`
+${COLORS.yellow}Swarm Intelligence requires Pro tier or higher.${COLORS.reset}`);
+      print(`Upgrade at: ${COLORS.cyan}https://bootspring.com/pricing${COLORS.reset}
+`);
+      return;
+    }
+    print(`${COLORS.red}Error:${COLORS.reset} ${resp?.data?.error || resp?.data?.message || "Unknown API error"}`);
+    return;
+  }
+  print(`${COLORS.red}Error:${COLORS.reset} ${error50 instanceof Error ? error50.message : String(error50)}`);
+}
+var TOPOLOGY_SYMBOLS = {
+  hierarchical: "\u25B3",
+  // △
+  mesh: "\u25C6",
+  // ◆
+  ring: "\u25CB",
+  // ○
+  star: "\u2605",
+  // ★
+  adaptive: "\u21C4"
+  // ⇄
+};
+var STATUS_COLORS = {
+  idle: COLORS.green,
+  busy: COLORS.cyan,
+  waiting: COLORS.yellow,
+  failed: COLORS.red,
+  offline: COLORS.dim
+};
+function registerSwarmCommand(program3) {
+  const cmd = program3.command("swarm").description("Multi-agent swarm orchestration \u2014 topology, consensus, planning");
+  cmd.command("start").description("Start a new swarm").option("-t, --topology <type>", "Topology: hierarchical, mesh, ring, star, adaptive", "hierarchical").option("--max-agents <n>", "Maximum agents", "50").option("--json", "Output as JSON").action(async (opts) => {
+    if (!requireAuth4()) return;
+    try {
+      const res = await api_client_exports.request("POST", "/swarm/start", {
+        topology: opts.topology,
+        maxAgents: parseInt(opts.maxAgents, 10)
+      });
+      if (opts.json) {
+        print(JSON.stringify(res, null, 2));
+        return;
+      }
+      const topo = opts.topology;
+      const sym = TOPOLOGY_SYMBOLS[topo] || "";
+      print(`
+${COLORS.bold}${COLORS.cyan}${sym} Swarm Started${COLORS.reset}`);
+      print(`  Topology:    ${COLORS.green}${topo}${COLORS.reset}`);
+      print(`  Max Agents:  ${opts.maxAgents}`);
+      print(`  Phase:       ${res.config?.phase || "running"}
+`);
+    } catch (error50) {
+      handleError(error50);
+    }
+  });
+  cmd.command("stop").description("Stop the current swarm").option("--json", "Output as JSON").action(async (opts) => {
+    if (!requireAuth4()) return;
+    try {
+      const res = await api_client_exports.request("POST", "/swarm/stop");
+      if (opts.json) {
+        print(JSON.stringify(res, null, 2));
+        return;
+      }
+      print(`
+${COLORS.bold}Swarm Stopped${COLORS.reset}`);
+      if (res.metrics) {
+        print(`  Tasks Completed: ${COLORS.green}${res.metrics.completedTasks}${COLORS.reset}`);
+        print(`  Tasks Failed:    ${COLORS.red}${res.metrics.failedTasks}${COLORS.reset}`);
+        print(`  Total Agents:    ${res.metrics.totalAgents}`);
+      }
+      print("");
+    } catch (error50) {
+      handleError(error50);
+    }
+  });
+  cmd.command("status").description("Show swarm metrics and topology").option("--json", "Output as JSON").action(async (opts) => {
+    if (!requireAuth4()) return;
+    try {
+      const res = await api_client_exports.request("GET", "/swarm/status");
+      if (opts.json) {
+        print(JSON.stringify(res, null, 2));
+        return;
+      }
+      const m = res.metrics;
+      const sym = TOPOLOGY_SYMBOLS[m.topology] || "";
+      print(`
+${COLORS.bold}${COLORS.cyan}${sym} Swarm Status${COLORS.reset}`);
+      print(`${"\u2500".repeat(50)}`);
+      print(`  Phase:       ${m.phase}`);
+      print(`  Topology:    ${COLORS.green}${m.topology}${COLORS.reset}`);
+      print(`  Uptime:      ${Math.round(m.uptime / 1e3)}s`);
+      print("");
+      print(`  ${COLORS.bold}Agents${COLORS.reset}`);
+      print(`    Total:     ${m.totalAgents}`);
+      print(`    Active:    ${COLORS.cyan}${m.activeAgents}${COLORS.reset}`);
+      print(`    Idle:      ${COLORS.green}${m.idleAgents}${COLORS.reset}`);
+      print(`    Failed:    ${COLORS.red}${m.failedAgents}${COLORS.reset}`);
+      print("");
+      print(`  ${COLORS.bold}Tasks${COLORS.reset}`);
+      print(`    Total:     ${m.totalTasks}`);
+      print(`    Running:   ${COLORS.cyan}${m.runningTasks}${COLORS.reset}`);
+      print(`    Pending:   ${COLORS.yellow}${m.pendingTasks}${COLORS.reset}`);
+      print(`    Completed: ${COLORS.green}${m.completedTasks}${COLORS.reset}`);
+      print(`    Failed:    ${COLORS.red}${m.failedTasks}${COLORS.reset}`);
+      print("");
+      print(`  Throughput:  ${m.throughputTasksPerMin} tasks/min`);
+      print(`  Avg Time:    ${m.avgTaskDurationMs}ms`);
+      if (res.topology) {
+        print(`
+  ${COLORS.bold}Topology Graph${COLORS.reset}`);
+        print(`    Nodes: ${res.topology.nodes.length}  Edges: ${res.topology.edges.length}`);
+      }
+      print("");
+    } catch (error50) {
+      handleError(error50);
+    }
+  });
+  cmd.command("spawn <role>").description("Spawn a new agent (queen, worker, specialist, reviewer, monitor)").option("-c, --capabilities <caps>", "Comma-separated capabilities", "general").option("--json", "Output as JSON").action(async (role, opts) => {
+    if (!requireAuth4()) return;
+    const validRoles = ["queen", "worker", "specialist", "reviewer", "monitor"];
+    if (!validRoles.includes(role)) {
+      print(`${COLORS.red}Invalid role:${COLORS.reset} ${role}. Must be one of: ${validRoles.join(", ")}`);
+      return;
+    }
+    try {
+      const capabilities = opts.capabilities.split(",").map((c) => c.trim());
+      const res = await api_client_exports.request("POST", "/swarm/agents", { role, capabilities });
+      if (opts.json) {
+        print(JSON.stringify(res, null, 2));
+        return;
+      }
+      print(`
+${COLORS.green}Agent spawned:${COLORS.reset} ${res.id}`);
+      print(`  Role:         ${res.role}`);
+      print(`  Capabilities: ${res.capabilities.join(", ")}`);
+      print(`  Status:       ${STATUS_COLORS[res.status] || ""}${res.status}${COLORS.reset}
+`);
+    } catch (error50) {
+      handleError(error50);
+    }
+  });
+  cmd.command("agents").description("List swarm agents").option("--role <role>", "Filter by role").option("--json", "Output as JSON").action(async (opts) => {
+    if (!requireAuth4()) return;
+    try {
+      const query = opts.role ? `?role=${opts.role}` : "";
+      const res = await api_client_exports.request("GET", `/swarm/agents${query}`);
+      if (opts.json) {
+        print(JSON.stringify(res, null, 2));
+        return;
+      }
+      print(`
+${COLORS.bold}${COLORS.cyan}Swarm Agents${COLORS.reset} (${res.count})
+`);
+      print(`${"ID".padEnd(24)} ${"Role".padEnd(12)} ${"Status".padEnd(10)} ${"Done".padEnd(6)} ${"Fail".padEnd(6)} Capabilities`);
+      print(`${"\u2500".repeat(24)} ${"\u2500".repeat(12)} ${"\u2500".repeat(10)} ${"\u2500".repeat(6)} ${"\u2500".repeat(6)} ${"\u2500".repeat(20)}`);
+      for (const a of res.agents) {
+        const color = STATUS_COLORS[a.status] || "";
+        print(
+          `${a.id.padEnd(24)} ${a.role.padEnd(12)} ${color}${a.status.padEnd(10)}${COLORS.reset} ${String(a.completedTasks).padEnd(6)} ${String(a.failedTasks).padEnd(6)} ${a.capabilities.join(", ")}`
+        );
+      }
+      print("");
+    } catch (error50) {
+      handleError(error50);
+    }
+  });
+  cmd.command("submit <type>").description("Submit a task to the swarm").argument("<description>", "Task description").option("-p, --priority <level>", "Priority: critical, high, normal, low", "normal").option("--json", "Output as JSON").action(async (type, description, opts) => {
+    if (!requireAuth4()) return;
+    try {
+      const res = await api_client_exports.request("POST", "/swarm/tasks", {
+        type,
+        description,
+        input: {},
+        priority: opts.priority
+      });
+      if (opts.json) {
+        print(JSON.stringify(res, null, 2));
+        return;
+      }
+      print(`
+${COLORS.green}Task submitted:${COLORS.reset} ${res.id}`);
+      print(`  Type:     ${res.type}`);
+      print(`  Priority: ${res.priority}`);
+      print(`  Status:   ${res.status}`);
+      if (res.assignedAgentId) {
+        print(`  Assigned: ${res.assignedAgentId}`);
+      }
+      print("");
+    } catch (error50) {
+      handleError(error50);
+    }
+  });
+  cmd.command("plan <goal>").description("Generate a GOAP execution plan from a goal").option("--parallel", "Enable parallel task groups").option("--json", "Output as JSON").action(async (goal, opts) => {
+    if (!requireAuth4()) return;
+    try {
+      const res = await api_client_exports.request("POST", "/swarm/plan", {
+        goal,
+        currentState: {},
+        goalConditions: [{ key: "deployed", operator: "==", value: true }],
+        parallel: !!opts.parallel
+      });
+      if (opts.json) {
+        print(JSON.stringify(res, null, 2));
+        return;
+      }
+      const feasibleStr = res.feasible ? `${COLORS.green}FEASIBLE${COLORS.reset}` : `${COLORS.red}INFEASIBLE${COLORS.reset}`;
+      print(`
+${COLORS.bold}${COLORS.cyan}Goal Planner${COLORS.reset}
+`);
+      print(`  Goal:        ${goal}`);
+      print(`  Feasible:    ${feasibleStr}`);
+      print(`  Explanation: ${res.explanation}`);
+      if (res.feasible && res.steps.length > 0) {
+        print(`  Total Cost:  ${res.totalCost}`);
+        print(`  Est. Time:   ${Math.round(res.estimatedDurationMs / 1e3)}s`);
+        print(`  Par. Groups: ${res.parallelGroups}`);
+        print(`
+  ${COLORS.bold}Execution Steps:${COLORS.reset}
+`);
+        print(`  ${"#".padEnd(4)} ${"Action".padEnd(24)} ${"Agent".padEnd(14)} ${"Group".padEnd(8)} Duration`);
+        print(`  ${"\u2500".repeat(4)} ${"\u2500".repeat(24)} ${"\u2500".repeat(14)} ${"\u2500".repeat(8)} ${"\u2500".repeat(10)}`);
+        for (const step of res.steps) {
+          const group = `G${step.parallelGroup}`;
+          const dur = `${Math.round(step.action.estimatedDurationMs / 1e3)}s`;
+          print(
+            `  ${String(step.order + 1).padEnd(4)} ${step.action.name.padEnd(24)} ${step.action.agentCapability.padEnd(14)} ${group.padEnd(8)} ${dur}`
+          );
+        }
+        if (res.steps.some((s) => s.dependencies.length > 0)) {
+          print(`
+  ${COLORS.bold}Dependencies:${COLORS.reset}`);
+          for (const step of res.steps) {
+            if (step.dependencies.length > 0) {
+              print(`  ${step.action.name} ${COLORS.dim}<- ${step.dependencies.join(", ")}${COLORS.reset}`);
+            }
+          }
+        }
+      }
+      print("");
+    } catch (error50) {
+      handleError(error50);
+    }
+  });
+  cmd.command("consensus <question>").description("Run a consensus vote across agents").requiredOption("-o, --options <opts>", "Comma-separated vote options").option("--json", "Output as JSON").action(async (question, opts) => {
+    if (!requireAuth4()) return;
+    try {
+      const options = opts.options.split(",").map((o) => o.trim());
+      const res = await api_client_exports.request("POST", "/swarm/consensus", { question, options });
+      if (opts.json) {
+        print(JSON.stringify(res, null, 2));
+        return;
+      }
+      const quorum = res.quorumReached ? `${COLORS.green}QUORUM REACHED${COLORS.reset}` : `${COLORS.yellow}NO QUORUM${COLORS.reset}`;
+      print(`
+${COLORS.bold}${COLORS.cyan}Consensus Vote${COLORS.reset}
+`);
+      print(`  Question:  ${question}`);
+      print(`  Decision:  ${COLORS.bold}${res.decision}${COLORS.reset}`);
+      print(`  Agreement: ${Math.round(res.agreement * 100)}%`);
+      print(`  Status:    ${quorum}`);
+      print(`  Votes:     ${res.votes.length}
+`);
+    } catch (error50) {
+      handleError(error50);
+    }
+  });
+  cmd.command("memory <action>").description("Vector memory: search, store, stats").argument("[query]", "Search query or content to store").option("--type <type>", "Memory type filter").option("--limit <n>", "Max results", "10").option("--json", "Output as JSON").action(async (action, query, opts) => {
+    if (!requireAuth4()) return;
+    try {
+      if (action === "search" && query) {
+        const res = await api_client_exports.request("POST", "/swarm/memory/search", {
+          query,
+          limit: parseInt(opts.limit, 10),
+          type: opts.type
+        });
+        if (opts.json) {
+          print(JSON.stringify(res, null, 2));
+          return;
+        }
+        print(`
+${COLORS.bold}${COLORS.cyan}Memory Search${COLORS.reset} (${res.results.length} results, ${res.searchTimeMs}ms, ${res.method})
+`);
+        for (const r of res.results) {
+          const truncated = r.entry.content.length > 80 ? r.entry.content.slice(0, 80) + "..." : r.entry.content;
+          print(`  ${COLORS.green}#${r.rank}${COLORS.reset} [${r.score.toFixed(3)}] ${COLORS.dim}(${r.entry.type})${COLORS.reset} ${truncated}`);
+        }
+        print("");
+      } else if (action === "stats") {
+        const res = await api_client_exports.request("GET", "/swarm/memory/stats");
+        if (opts.json) {
+          print(JSON.stringify(res, null, 2));
+          return;
+        }
+        print(`
+${COLORS.bold}${COLORS.cyan}Vector Memory Stats${COLORS.reset}
+`);
+        print(`  Entries:    ${res.totalEntries}`);
+        print(`  Dimensions: ${res.dimensions}`);
+        print(`  Layers:     ${res.layers}`);
+        print(`  Avg Import: ${res.avgImportance}`);
+        print(`  Memory:     ${Math.round(res.memoryBytes / 1024)}KB`);
+        if (res.byType && Object.keys(res.byType).length > 0) {
+          print(`
+  By Type:`);
+          for (const [type, count] of Object.entries(res.byType)) {
+            print(`    ${type.padEnd(16)} ${count}`);
+          }
+        }
+        print("");
+      } else {
+        print(`
+Usage: bootspring swarm memory <search|stats> [query]`);
+        print(`  ${COLORS.dim}bootspring swarm memory search "how to fix tests"${COLORS.reset}`);
+        print(`  ${COLORS.dim}bootspring swarm memory stats${COLORS.reset}
+`);
+      }
+    } catch (error50) {
+      handleError(error50);
+    }
+  });
+  cmd.command("topology").description("Show or change swarm topology").option("-s, --set <type>", "Change topology: hierarchical, mesh, ring, star, adaptive").option("--json", "Output as JSON").action(async (opts) => {
+    if (!requireAuth4()) return;
+    try {
+      if (opts.set) {
+        const res = await api_client_exports.request("POST", "/swarm/topology", { topology: opts.set });
+        if (opts.json) {
+          print(JSON.stringify(res, null, 2));
+          return;
+        }
+        print(`
+${COLORS.green}Topology changed to:${COLORS.reset} ${opts.set}
+`);
+      } else {
+        const res = await api_client_exports.request("GET", "/swarm/topology");
+        if (opts.json) {
+          print(JSON.stringify(res, null, 2));
+          return;
+        }
+        print(`
+${COLORS.bold}${COLORS.cyan}Topology Graph${COLORS.reset}
+`);
+        print(`  Nodes: ${res.nodes.length}  Edges: ${res.edges.length}
+`);
+        for (const node of res.nodes) {
+          const color = STATUS_COLORS[node.status] || "";
+          print(`  ${color}\u25CF${COLORS.reset} ${node.id} (${node.role})`);
+        }
+        if (res.edges.length > 0) {
+          print(`
+  Edges:`);
+          for (const edge of res.edges.slice(0, 20)) {
+            const arrow = edge.type === "parent" ? "\u2192" : "\u2194";
+            print(`    ${edge.from} ${arrow} ${edge.to} ${COLORS.dim}(${edge.type})${COLORS.reset}`);
+          }
+          if (res.edges.length > 20) {
+            print(`    ${COLORS.dim}... and ${res.edges.length - 20} more edges${COLORS.reset}`);
+          }
+        }
+        print("");
+      }
+    } catch (error50) {
+      handleError(error50);
+    }
+  });
+  cmd.command("visualize").description("Visualize swarm topology as ASCII art").option("--json", "Output as JSON").action(async (opts) => {
+    if (!requireAuth4()) return;
+    try {
+      const res = await api_client_exports.request("GET", "/swarm/snapshot");
+      if (opts.json) {
+        print(JSON.stringify(res, null, 2));
+        return;
+      }
+      const m = res.metrics;
+      const sym = TOPOLOGY_SYMBOLS[m.topology] || "";
+      print(`
+${COLORS.bold}${COLORS.cyan}${sym} Swarm Visualization \u2014 ${m.topology}${COLORS.reset}
+`);
+      const agents = res.agents || [];
+      const queen = agents.find((a) => a.role === "queen");
+      if (m.topology === "hierarchical" || m.topology === "star") {
+        if (queen) {
+          print(`  ${COLORS.yellow}\u265B ${queen.id}${COLORS.reset} (queen)`);
+          const children = agents.filter((a) => a.parentId === queen.id);
+          for (let i = 0; i < children.length; i++) {
+            const isLast = i === children.length - 1;
+            const prefix = isLast ? "  \u2514\u2500\u2500 " : "  \u251C\u2500\u2500 ";
+            const color = STATUS_COLORS[children[i].status] || "";
+            print(`${prefix}${color}\u25CF ${children[i].id}${COLORS.reset} (${children[i].role})`);
+          }
+        }
+      } else if (m.topology === "ring") {
+        for (let i = 0; i < agents.length; i++) {
+          const color = STATUS_COLORS[agents[i].status] || "";
+          const arrow = i < agents.length - 1 ? " \u2192" : ` \u2192 ${agents[0]?.id || ""}`;
+          print(`  ${color}\u25CF ${agents[i].id}${COLORS.reset}${arrow}`);
+        }
+      } else {
+        for (const a of agents) {
+          const color = STATUS_COLORS[a.status] || "";
+          print(`  ${color}\u25CF${COLORS.reset} ${a.id} (${a.role}) [${a.capabilities.join(", ")}]`);
+        }
+      }
+      print(`
+  ${COLORS.dim}Agents: ${m.totalAgents} | Tasks: ${m.totalTasks} | Completed: ${m.completedTasks} | Phase: ${m.phase}${COLORS.reset}
+`);
+    } catch (error50) {
+      handleError(error50);
+    }
+  });
+}
+
+// src/commands/geo.ts
+init_cjs_shims();
+init_src2();
+function requireAuth5() {
   if (auth_exports.isAuthenticated()) {
     return true;
   }
@@ -72836,7 +73668,7 @@ function printGeoResult(result) {
 function registerGeoCommand(program3) {
   const geo = program3.command("geo").description("GEO-SEO analysis \u2014 optimize for AI search engines");
   geo.command("audit <url>").description("Full GEO + SEO audit with parallel subagents").option("--format <format>", "Output format: markdown | json", "markdown").action(async (url2, opts) => {
-    if (!requireAuth4()) return;
+    if (!requireAuth5()) return;
     const spinner = createSpinner("Running GEO audit...").start();
     try {
       const result = await api_client_exports.request("POST", "/geo/audit", { url: url2, options: opts });
@@ -72848,7 +73680,7 @@ function registerGeoCommand(program3) {
     }
   });
   geo.command("quick <url>").description("60-second GEO visibility snapshot").action(async (url2) => {
-    if (!requireAuth4()) return;
+    if (!requireAuth5()) return;
     const spinner = createSpinner("Quick GEO scan...").start();
     try {
       const result = await api_client_exports.request("POST", "/geo/quick", { url: url2 });
@@ -72875,7 +73707,7 @@ function registerGeoCommand(program3) {
   ];
   for (const sub of subcommands) {
     geo.command(`${sub.name} ${sub.arg}`).description(sub.desc).action(async (urlOrDomain) => {
-      if (!requireAuth4()) return;
+      if (!requireAuth5()) return;
       const spinner = createSpinner(`Running ${sub.name}...`).start();
       try {
         const body = sub.arg === "<domain>" ? { domain: urlOrDomain } : { url: urlOrDomain };
@@ -72889,7 +73721,7 @@ function registerGeoCommand(program3) {
     });
   }
   geo.command("prospect <action>").description("CRM: manage prospects (new, list, show, audit, note, status, pipeline)").argument("[args...]", "Action-specific arguments").action(async (action, args) => {
-    if (!requireAuth4()) return;
+    if (!requireAuth5()) return;
     const spinner = createSpinner(`Prospect ${action}...`).start();
     try {
       const result = await api_client_exports.request("POST", "/geo/prospect", { action, data: args });
@@ -72901,7 +73733,7 @@ function registerGeoCommand(program3) {
     }
   });
   geo.command("schemas [name]").description("List JSON-LD schema templates or view a specific one").action(async (name) => {
-    if (!requireAuth4()) return;
+    if (!requireAuth5()) return;
     const spinner = createSpinner(name ? `Fetching ${name} schema...` : "Listing schemas...").start();
     try {
       if (name) {
@@ -72937,7 +73769,7 @@ function registerGeoCommand(program3) {
 // src/commands/marketing.ts
 init_cjs_shims();
 init_src2();
-function requireAuth5() {
+function requireAuth6() {
   if (auth_exports.isAuthenticated()) {
     return true;
   }
@@ -73083,7 +73915,7 @@ function registerMarketingCommand(program3) {
       }
     }
     sub.action(async (...actionArgs) => {
-      if (!requireAuth5()) return;
+      if (!requireAuth6()) return;
       const body = {};
       for (let i = 0; i < cmd.args.length; i++) {
         body[cmd.args[i].name] = actionArgs[i];
@@ -73126,7 +73958,7 @@ function registerMarketingCommand(program3) {
     });
   }
   marketing.command("commands").description("List all available marketing commands").action(async () => {
-    if (!requireAuth5()) return;
+    if (!requireAuth6()) return;
     const spinner = createSpinner("Fetching marketing commands...").start();
     try {
       const result = await api_client_exports.request("GET", "/marketing/commands");
@@ -73172,7 +74004,7 @@ function registerMarketingCommand(program3) {
 // src/commands/sales.ts
 init_cjs_shims();
 init_src2();
-function requireAuth6() {
+function requireAuth7() {
   if (auth_exports.isAuthenticated()) {
     return true;
   }
@@ -73293,7 +74125,7 @@ function registerSalesCommand(program3) {
       }
     }
     sub.action(async (...actionArgs) => {
-      if (!requireAuth6()) return;
+      if (!requireAuth7()) return;
       const body = {};
       for (let i = 0; i < cmd.args.length; i++) {
         body[cmd.args[i].name] = actionArgs[i];
@@ -73331,7 +74163,7 @@ function registerSalesCommand(program3) {
     });
   }
   sales.command("commands").description("List all available sales commands").action(async () => {
-    if (!requireAuth6()) return;
+    if (!requireAuth7()) return;
     const spinner = createSpinner("Fetching sales commands...").start();
     try {
       const result = await api_client_exports.request("GET", "/sales/commands");
@@ -73376,7 +74208,7 @@ function registerSalesCommand(program3) {
 // src/commands/jobs.ts
 init_cjs_shims();
 init_src2();
-function requireAuth7() {
+function requireAuth8() {
   if (auth_exports.isAuthenticated()) return true;
   print.error('Not logged in. Run "bootspring auth login" first.');
   process.exitCode = 1;
@@ -73385,7 +74217,7 @@ function requireAuth7() {
 function registerJobsCommand(program3) {
   const jobs = program3.command("jobs").description("List and poll async job results");
   jobs.command("list").alias("ls").description("List recent jobs").option("--type <type>", "Filter by type (geo, marketing, sales)").option("--limit <n>", "Number of jobs to show", "20").action(async (opts) => {
-    if (!requireAuth7()) return;
+    if (!requireAuth8()) return;
     try {
       const params = new URLSearchParams();
       if (opts.type) params.set("type", opts.type);
@@ -73412,7 +74244,7 @@ ${COLORS.bold}Recent Jobs${COLORS.reset}
     }
   });
   jobs.command("status <jobId>").alias("get").description("Get job status and results").action(async (jobId) => {
-    if (!requireAuth7()) return;
+    if (!requireAuth8()) return;
     try {
       const response = await api_client_exports.request("GET", `/jobs/${encodeURIComponent(jobId)}`);
       const job = response.job;
@@ -77615,6 +78447,164 @@ ${COLORS.bold}Shell Completion${COLORS.reset}
   });
 }
 
+// src/commands/brain.ts
+init_cjs_shims();
+var _router = null;
+function getRouter2() {
+  if (!_router) {
+    try {
+      const { brain } = require("@bootspring/session-intelligence");
+      _router = new brain.UnifiedBrainRouter();
+    } catch {
+      return null;
+    }
+  }
+  return _router;
+}
+function registerBrainCommand(program3) {
+  const brain = program3.command("brain").description("NLU brain \u2014 natural language routing to skills, workflows, agents, and pipelines");
+  brain.command("route <prompt...>").description("Route a natural language query and show the result").option("--json", "Output as JSON").option("--auto-dispatch", "Include dispatch instruction if confidence > 0.85").action(async (promptParts, opts) => {
+    const router = getRouter2();
+    if (!router) {
+      console.error("Brain router not available. Ensure @bootspring/session-intelligence is installed.");
+      process.exitCode = 1;
+      return;
+    }
+    const prompt2 = promptParts.join(" ");
+    const result = router.route(prompt2);
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(`
+  \x1B[1mBrain Router Result\x1B[0m`);
+    console.log(`  ${"\u2500".repeat(46)}`);
+    console.log(`  Target:     ${result.target.name}`);
+    console.log(`  Type:       ${result.target.type}`);
+    console.log(`  Confidence: ${result.confidence}`);
+    console.log(`  Method:     ${result.method}`);
+    if (result.target.command) {
+      console.log(`  Command:    \x1B[36m${result.target.command}\x1B[0m`);
+    }
+    console.log(`  Description: ${result.target.description}`);
+    console.log(`  Explanation: ${result.explanation}`);
+    if (result.alternatives.length > 0) {
+      console.log(`
+  Alternatives:`);
+      for (const alt of result.alternatives) {
+        const cmd = alt.target.command ? ` \u2192 ${alt.target.command}` : "";
+        console.log(`    - ${alt.target.name} [${alt.target.type}] (${alt.confidence})${cmd}`);
+      }
+    }
+    if (opts.autoDispatch && result.confidence >= 0.85 && result.target.command) {
+      console.log(`
+  \x1B[32mAUTO-DISPATCH\x1B[0m: Run \x1B[36m${result.target.command}\x1B[0m`);
+    }
+    console.log();
+  });
+  brain.command("status", { isDefault: true }).description("Show brain status \u2014 loaded targets, corpus size, config").option("--json", "Output as JSON").action(async (opts) => {
+    const router = getRouter2();
+    if (!router) {
+      console.error("Brain router not available.");
+      process.exitCode = 1;
+      return;
+    }
+    let corpusSize = 0;
+    let targetTypes = {};
+    try {
+      const { brain: brainMod } = require("@bootspring/session-intelligence");
+      const corpus = brainMod.BRAIN_CORPUS;
+      corpusSize = corpus.length;
+      for (const t of corpus) {
+        targetTypes[t.type] = (targetTypes[t.type] || 0) + 1;
+      }
+    } catch {
+    }
+    const analytics = router.getAnalytics();
+    const status = {
+      active: true,
+      corpusSize,
+      targetTypes,
+      totalInvocations: analytics.totalInvocations,
+      accuracyRate: analytics.accuracyRate,
+      methodBreakdown: analytics.methodBreakdown
+    };
+    if (opts.json) {
+      console.log(JSON.stringify(status, null, 2));
+      return;
+    }
+    console.log(`
+  \x1B[1mBrain Status\x1B[0m`);
+    console.log(`  ${"\u2500".repeat(46)}`);
+    console.log(`  Active:       \x1B[32myes\x1B[0m`);
+    console.log(`  Corpus size:  ${corpusSize} targets`);
+    if (Object.keys(targetTypes).length > 0) {
+      console.log(`  Target types:`);
+      for (const [type, count] of Object.entries(targetTypes)) {
+        console.log(`    ${type}: ${count}`);
+      }
+    }
+    console.log(`  Invocations:  ${analytics.totalInvocations}`);
+    console.log(`  Accuracy:     ${(analytics.accuracyRate * 100).toFixed(1)}%`);
+    if (Object.keys(analytics.methodBreakdown).length > 0) {
+      console.log(`  Methods:`);
+      for (const [method, count] of Object.entries(analytics.methodBreakdown)) {
+        console.log(`    ${method}: ${count}`);
+      }
+    }
+    console.log();
+  });
+  brain.command("analytics").description("Show routing analytics \u2014 invocations, accuracy, top targets").option("--json", "Output as JSON").action(async (opts) => {
+    const router = getRouter2();
+    if (!router) {
+      console.error("Brain router not available.");
+      process.exitCode = 1;
+      return;
+    }
+    const analytics = router.getAnalytics();
+    if (opts.json) {
+      console.log(JSON.stringify(analytics, null, 2));
+      return;
+    }
+    console.log(`
+  \x1B[1mBrain Analytics\x1B[0m`);
+    console.log(`  ${"\u2500".repeat(46)}`);
+    console.log(`  Total invocations: ${analytics.totalInvocations}`);
+    console.log(`  Correct routes:    ${analytics.correctRoutes}`);
+    console.log(`  User overrides:    ${analytics.userOverrides}`);
+    console.log(`  Accuracy rate:     ${(analytics.accuracyRate * 100).toFixed(1)}%`);
+    if (Object.keys(analytics.methodBreakdown).length > 0) {
+      console.log(`
+  Method breakdown:`);
+      for (const [method, count] of Object.entries(analytics.methodBreakdown)) {
+        console.log(`    ${method}: ${count}`);
+      }
+    }
+    if (analytics.topTargets.length > 0) {
+      console.log(`
+  Top targets:`);
+      for (const t of analytics.topTargets) {
+        console.log(`    ${t.name}: ${t.count} hits`);
+      }
+    }
+    console.log();
+  });
+  brain.command("reset").description("Reset brain analytics").option("--json", "Output as JSON").action(async (opts) => {
+    const router = getRouter2();
+    if (!router) {
+      console.error("Brain router not available.");
+      process.exitCode = 1;
+      return;
+    }
+    router.resetAnalytics();
+    if (opts.json) {
+      console.log(JSON.stringify({ reset: true }));
+      return;
+    }
+    console.log("Brain analytics reset.");
+  });
+}
+
 // src/index.ts
 var program2 = new Command();
 program2.name("bootspring").description("Thin CLI for Bootspring cloud MCP, hosted agents, and AI-assisted workflows").version(BOOTSPRING_VERSION);
@@ -77680,6 +78670,7 @@ registerSetupCommand(program2);
 registerPipelineCommand(program2);
 registerWorkflowCommand(program2);
 registerHarnessCommand(program2);
+registerSwarmCommand(program2);
 registerGeoCommand(program2);
 registerMarketingCommand(program2);
 registerSalesCommand(program2);
@@ -77702,6 +78693,7 @@ registerExperimental(registerSpecCommand);
 registerSyncCommand(program2);
 registerHookCommand(program2);
 registerCompletionCommand(program2);
+registerBrainCommand(program2);
 var HERO_COMMANDS = /* @__PURE__ */ new Set([
   "auth",
   "build",
@@ -77721,7 +78713,7 @@ var COMMAND_GROUPS = {
   "Project": ["project", "workspace", "org", "switch", "checkpoint"],
   "Dev Tools": ["doctor", "health", "setup", "validate", "watch", "dashboard", "update", "hook", "completion"],
   "Analysis": ["analyze", "audit", "quality", "security", "diff", "report"],
-  "AI & Agents": ["agent", "skill", "context", "prompt", "flow"],
+  "AI & Agents": ["agent", "skill", "brain", "context", "prompt", "flow"],
   "Observe": ["observe", "autopilot", "monitor", "session", "metrics", "telemetry"],
   "Docs": ["docs", "generate", "prd", "content", "plan", "suggest"],
   "Deploy & Ops": ["deploy", "sync", "cloud-sync", "github", "undo", "history", "changes", "log"],