@girardmedia/bootspring 2.7.0 → 3.1.0

package/dist/cli/index.js

@@ -31,10 +31,11 @@ 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
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@1.21.7_postcss@8.5.14_tsx@4.21.0_typescript@5.9.3_yaml@2.8.3/node_modules/tsup/assets/cjs_shims.js
 var init_cjs_shims = __esm({
-  "../../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"() {
+  "../../node_modules/.pnpm/tsup@8.5.1_jiti@1.21.7_postcss@8.5.14_tsx@4.21.0_typescript@5.9.3_yaml@2.8.3/node_modules/tsup/assets/cjs_shims.js"() {
     "use strict";
   }
 });
@@ -3385,7 +3386,7 @@ var init_release = __esm({
   "../../packages/shared/src/release.ts"() {
     "use strict";
     init_cjs_shims();
-    BOOTSPRING_VERSION = "2.7.0";
+    BOOTSPRING_VERSION = "3.1.0";
     BOOTSPRING_PACKAGE_NAME = "@girardmedia/bootspring";
   }
 });
@@ -32898,13 +32899,16 @@ var require_data = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/utils.js
+// ../../node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/lib/utils.js
 var require_utils = __commonJS({
-  "../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/utils.js"(exports2, module2) {
+  "../../node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/lib/utils.js"(exports2, module2) {
     "use strict";
     init_cjs_shims();
     var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
     var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+    var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
+    var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
+    var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
     function stringArrayToHexStripped(input) {
       let acc = "";
       let code = 0;
@@ -33097,27 +33101,77 @@ var require_utils = __commonJS({
       }
       return output.join("");
     }
-    function normalizeComponentEncoding(component, esc4) {
-      const func = esc4 !== true ? escape : unescape;
-      if (component.scheme !== void 0) {
-        component.scheme = func(component.scheme);
-      }
-      if (component.userinfo !== void 0) {
-        component.userinfo = func(component.userinfo);
-      }
-      if (component.host !== void 0) {
-        component.host = func(component.host);
+    var HOST_DELIMS = { "@": "%40", "/": "%2F", "?": "%3F", "#": "%23", ":": "%3A" };
+    var HOST_DELIM_RE = /[@/?#:]/g;
+    var HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
+    function reescapeHostDelimiters(host, isIP) {
+      const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
+      re.lastIndex = 0;
+      return host.replace(re, (ch) => HOST_DELIMS[ch]);
+    }
+    function normalizePercentEncoding(input, decodeUnreserved = false) {
+      if (input.indexOf("%") === -1) {
+        return input;
       }
-      if (component.path !== void 0) {
-        component.path = func(component.path);
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            const normalizedHex = hex3.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (decodeUnreserved && isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i += 2;
+            continue;
+          }
+        }
+        output += input[i];
       }
-      if (component.query !== void 0) {
-        component.query = func(component.query);
+      return output;
+    }
+    function normalizePathEncoding(input) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            const normalizedHex = hex3.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (decoded !== "." && isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i += 2;
+            continue;
+          }
+        }
+        if (isPathCharacter(input[i])) {
+          output += input[i];
+        } else {
+          output += escape(input[i]);
+        }
       }
-      if (component.fragment !== void 0) {
-        component.fragment = func(component.fragment);
+      return output;
+    }
+    function escapePreservingEscapes(input) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            output += "%" + hex3.toUpperCase();
+            i += 2;
+            continue;
+          }
+        }
+        output += escape(input[i]);
       }
-      return component;
+      return output;
     }
     function recomposeAuthority(component) {
       const uriTokens = [];
@@ -33132,7 +33186,7 @@ var require_utils = __commonJS({
           if (ipV6res.isIPV6 === true) {
             host = `[${ipV6res.escapedHost}]`;
           } else {
-            host = component.host;
+            host = reescapeHostDelimiters(host, false);
           }
         }
         uriTokens.push(host);
@@ -33146,7 +33200,10 @@ var require_utils = __commonJS({
     module2.exports = {
       nonSimpleDomain,
       recomposeAuthority,
-      normalizeComponentEncoding,
+      reescapeHostDelimiters,
+      normalizePercentEncoding,
+      normalizePathEncoding,
+      escapePreservingEscapes,
       removeDotSegments,
       isIPv4,
       isUUID,
@@ -33156,9 +33213,9 @@ var require_utils = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/schemes.js
+// ../../node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/lib/schemes.js
 var require_schemes = __commonJS({
-  "../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/schemes.js"(exports2, module2) {
+  "../../node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/lib/schemes.js"(exports2, module2) {
     "use strict";
     init_cjs_shims();
     var { isUUID } = require_utils();
@@ -33367,17 +33424,17 @@ var require_schemes = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/index.js
+// ../../node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/index.js
 var require_fast_uri = __commonJS({
-  "../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/index.js"(exports2, module2) {
+  "../../node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/index.js"(exports2, module2) {
     "use strict";
     init_cjs_shims();
-    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
+    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
     function normalize2(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
-        serialize(parse7(uri, options), options);
+        normalizeString(uri, options);
       } else if (typeof uri === "object") {
         uri = /** @type {T} */
         parse7(serialize(uri, options), options);
@@ -33444,19 +33501,9 @@ var require_fast_uri = __commonJS({
       return target;
     }
     function equal(uriA, uriB, options) {
-      if (typeof uriA === "string") {
-        uriA = unescape(uriA);
-        uriA = serialize(normalizeComponentEncoding(parse7(uriA, options), true), { ...options, skipEscape: true });
-      } else if (typeof uriA === "object") {
-        uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true });
-      }
-      if (typeof uriB === "string") {
-        uriB = unescape(uriB);
-        uriB = serialize(normalizeComponentEncoding(parse7(uriB, options), true), { ...options, skipEscape: true });
-      } else if (typeof uriB === "object") {
-        uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true });
-      }
-      return uriA.toLowerCase() === uriB.toLowerCase();
+      const normalizedA = normalizeComparableURI(uriA, options);
+      const normalizedB = normalizeComparableURI(uriB, options);
+      return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
     }
     function serialize(cmpts, opts) {
       const component = {
@@ -33481,12 +33528,12 @@ var require_fast_uri = __commonJS({
       if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
       if (component.path !== void 0) {
         if (!options.skipEscape) {
-          component.path = escape(component.path);
+          component.path = escapePreservingEscapes(component.path);
           if (component.scheme !== void 0) {
             component.path = component.path.split("%3A").join(":");
           }
         } else {
-          component.path = unescape(component.path);
+          component.path = normalizePercentEncoding(component.path);
         }
       }
       if (options.reference !== "suffix" && component.scheme) {
@@ -33521,7 +33568,16 @@ var require_fast_uri = __commonJS({
       return uriTokens.join("");
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
-    function parse7(uri, opts) {
+    function getParseError(parsed, matches) {
+      if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
+        return 'URI path must start with "/" when authority is present.';
+      }
+      if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535)) {
+        return "URI port is malformed.";
+      }
+      return void 0;
+    }
+    function parseWithStatus(uri, opts) {
       const options = Object.assign({}, opts);
       const parsed = {
         scheme: void 0,
@@ -33532,6 +33588,7 @@ var require_fast_uri = __commonJS({
         query: void 0,
         fragment: void 0
       };
+      let malformedAuthorityOrPort = false;
       let isIP = false;
       if (options.reference === "suffix") {
         if (options.scheme) {
@@ -33552,6 +33609,11 @@ var require_fast_uri = __commonJS({
         if (isNaN(parsed.port)) {
           parsed.port = matches[5];
         }
+        const parseError = getParseError(parsed, matches);
+        if (parseError !== void 0) {
+          parsed.error = parsed.error || parseError;
+          malformedAuthorityOrPort = true;
+        }
         if (parsed.host) {
           const ipv4result = isIPv4(parsed.host);
           if (ipv4result === false) {
@@ -33590,14 +33652,18 @@ var require_fast_uri = __commonJS({
               parsed.scheme = unescape(parsed.scheme);
             }
             if (parsed.host !== void 0) {
-              parsed.host = unescape(parsed.host);
+              parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
             }
           }
           if (parsed.path) {
-            parsed.path = escape(unescape(parsed.path));
+            parsed.path = normalizePathEncoding(parsed.path);
           }
           if (parsed.fragment) {
-            parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+            try {
+              parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+            } catch {
+              parsed.error = parsed.error || "URI malformed";
+            }
           }
         }
         if (schemeHandler && schemeHandler.parse) {
@@ -33606,7 +33672,29 @@ var require_fast_uri = __commonJS({
       } else {
         parsed.error = parsed.error || "URI can not be parsed.";
       }
-      return parsed;
+      return { parsed, malformedAuthorityOrPort };
+    }
+    function parse7(uri, opts) {
+      return parseWithStatus(uri, opts).parsed;
+    }
+    function normalizeString(uri, opts) {
+      return normalizeStringWithStatus(uri, opts).normalized;
+    }
+    function normalizeStringWithStatus(uri, opts) {
+      const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+      return {
+        normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
+        malformedAuthorityOrPort
+      };
+    }
+    function normalizeComparableURI(uri, opts) {
+      if (typeof uri === "string") {
+        const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
+        return malformedAuthorityOrPort ? void 0 : normalized;
+      }
+      if (typeof uri === "object") {
+        return serialize(uri, opts);
+      }
     }
     var fastUri = {
       SCHEMES,
@@ -38412,7 +38500,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 +38517,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 +39298,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 +39314,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 +39332,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 +39347,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;
@@ -45895,6 +45983,317 @@ ${"=".repeat(50)}`);
   }
 });
 
+// ../../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, {
@@ -45912,6 +46311,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,
@@ -45953,6 +46353,7 @@ __export(src_exports3, {
   registerRbacTools: () => registerRbacTools,
   registerReleaseTools: () => registerReleaseTools,
   registerResource: () => registerResource,
+  registerSwarmTools: () => registerSwarmTools,
   registerSyncTools: () => registerSyncTools,
   registerTool: () => registerTool,
   resolveCompatibilityRegistry: () => resolveCompatibilityRegistry,
@@ -45988,6 +46389,7 @@ var init_src3 = __esm({
     init_observer_tools();
     init_autopilot_tools();
     init_brain_tools();
+    init_swarm_tools();
   }
 });
 
@@ -56629,7 +57031,7 @@ function registerBuildCommand(program3) {
     print.info(`Complexity: ${next.complexity ?? "Unknown"}`);
     if (current) print.info(`Status: ${next.status}`);
   });
-  build.command("done").alias("complete").description("Mark the current task as done (trusts caller \u2014 does not verify execution)").action(() => {
+  build.command("done").alias("complete").description("Mark the current task as done, auto-commit, and show next task").option("--no-commit", "Skip auto-commit").action((opts) => {
     const state = loadBuildStateWithAutoSync();
     if (!state) {
       print.error("No build state found");
@@ -56643,15 +57045,54 @@ function registerBuildCommand(program3) {
       return;
     }
     const currentId = queue[idx].id;
+    const currentTitle = queue[idx].title;
+    if (opts.commit !== false) {
+      try {
+        const { execSync: execSync15 } = require("child_process");
+        const cwd = process.cwd();
+        const status = execSync15("git status --porcelain", { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+        if (status) {
+          execSync15("git add -A", { cwd, stdio: ["ignore", "ignore", "ignore"] });
+          const msg = `feat(${currentId}): ${currentTitle}`;
+          execSync15(`git commit -m ${JSON.stringify(msg)}`, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+          print.success(`Committed: ${msg}`);
+        }
+      } catch {
+      }
+    }
     queue[idx].status = "completed";
     if (state.loopSession) {
       state.loopSession.currentIteration = (state.loopSession.currentIteration ?? 0) + 1;
     }
     saveBuildState(state);
-    const nextTask = queue.find((t) => t.status === "pending");
+    const nextTask = (() => {
+      for (const task of queue) {
+        if (task.status !== "pending") continue;
+        if (task.dependencies?.length) {
+          const allDone = task.dependencies.every((depId) => {
+            const dep = queue.find((t) => t.id === depId);
+            return dep && dep.status === "completed";
+          });
+          if (!allDone) continue;
+        }
+        return task;
+      }
+      return null;
+    })();
     print.success(`Task ${currentId} marked as done`);
     if (nextTask) {
-      print.info(`Next: ${nextTask.id} - ${nextTask.title}`);
+      console.log("");
+      print.header("Next Task");
+      print.info(`ID: ${nextTask.id}`);
+      print.info(`Title: ${nextTask.title}`);
+      if (nextTask.phase) print.info(`Phase: ${nextTask.phase}`);
+      if (nextTask.description) print.info(`Description: ${nextTask.description}`);
+      if (nextTask.acceptanceCriteria && nextTask.acceptanceCriteria.length > 0) {
+        print.info("Acceptance criteria:");
+        for (const ac of nextTask.acceptanceCriteria) {
+          console.log(`  [ ] ${ac}`);
+        }
+      }
     } else {
       print.success("No more pending tasks!");
     }
@@ -57537,6 +57978,71 @@ ${supplementaryContent}
       print.dim(`${snapshot.completedCount} completed, ${snapshot.pendingCount} pending`);
     }
   });
+  build.command("handoff").description("Save or load session handoff state for cross-session continuity").option("--save", "Save current session state").option("--notes <notes>", "Notes for the next session").option("--json", "Output as JSON").action((opts) => {
+    const handoffPath = path52.join(process.cwd(), "planning", ".handoff.json");
+    if (opts.save) {
+      const state = loadBuildStateWithAutoSync(true);
+      const queue = state?.implementationQueue ?? [];
+      const inProgress = queue.find((t) => t.status === "in_progress");
+      const lastCompleted = [...queue].reverse().find((t) => t.status === "completed");
+      let filesModified = [];
+      try {
+        const { execSync: execSync15 } = require("child_process");
+        const gitDiff = execSync15("git diff --name-only HEAD~1 2>/dev/null || true", { encoding: "utf8" }).trim();
+        if (gitDiff) filesModified = gitDiff.split("\n").filter(Boolean);
+      } catch {
+      }
+      const handoff = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        lastTaskId: lastCompleted?.id ?? null,
+        inProgressTask: inProgress?.id ?? null,
+        inProgressTitle: inProgress?.title ?? null,
+        filesModified,
+        notes: opts.notes ?? "",
+        blockers: [],
+        progress: {
+          completed: queue.filter((t) => t.status === "completed").length,
+          pending: queue.filter((t) => t.status === "pending").length,
+          total: queue.length
+        }
+      };
+      const dir = path52.dirname(handoffPath);
+      if (!fs51.existsSync(dir)) fs51.mkdirSync(dir, { recursive: true });
+      fs51.writeFileSync(handoffPath, JSON.stringify(handoff, null, 2));
+      if (opts.json) {
+        console.log(JSON.stringify({ saved: true, handoff }));
+      } else {
+        print.success("Session handoff saved");
+        if (inProgress) print.info(`In-progress: ${inProgress.id} \u2014 ${inProgress.title}`);
+        if (opts.notes) print.info(`Notes: ${opts.notes}`);
+      }
+      return;
+    }
+    if (!fs51.existsSync(handoffPath)) {
+      if (opts.json) {
+        console.log(JSON.stringify({ hasHandoff: false }));
+      } else {
+        print.info("No previous session handoff found.");
+      }
+      return;
+    }
+    try {
+      const handoff = JSON.parse(fs51.readFileSync(handoffPath, "utf-8"));
+      if (opts.json) {
+        console.log(JSON.stringify({ hasHandoff: true, handoff }));
+      } else {
+        print.header("Session Handoff");
+        print.info(`Saved: ${handoff.timestamp}`);
+        if (handoff.inProgressTask) print.info(`In-progress: ${handoff.inProgressTask} \u2014 ${handoff.inProgressTitle ?? ""}`);
+        if (handoff.lastTaskId) print.info(`Last completed: ${handoff.lastTaskId}`);
+        if (handoff.notes) print.info(`Notes: ${handoff.notes}`);
+        if (handoff.progress) print.info(`Progress: ${handoff.progress.completed}/${handoff.progress.total}`);
+        if (handoff.filesModified?.length) print.dim(`Files: ${handoff.filesModified.slice(0, 5).join(", ")}${handoff.filesModified.length > 5 ? ` +${handoff.filesModified.length - 5} more` : ""}`);
+      }
+    } catch {
+      print.error("Failed to read handoff file");
+    }
+  });
   build.action(() => {
     build.outputHelp();
   });
@@ -66356,7 +66862,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)) {
@@ -72858,10 +73364,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;
   }
@@ -72929,7 +73859,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 });
@@ -72941,7 +73871,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 });
@@ -72968,7 +73898,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 };
@@ -72982,7 +73912,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 });
@@ -72994,7 +73924,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) {
@@ -73030,7 +73960,7 @@ function registerGeoCommand(program3) {
 // src/commands/marketing.ts
 init_cjs_shims();
 init_src2();
-function requireAuth5() {
+function requireAuth6() {
   if (auth_exports.isAuthenticated()) {
     return true;
   }
@@ -73176,7 +74106,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];
@@ -73219,7 +74149,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");
@@ -73265,7 +74195,7 @@ function registerMarketingCommand(program3) {
 // src/commands/sales.ts
 init_cjs_shims();
 init_src2();
-function requireAuth6() {
+function requireAuth7() {
   if (auth_exports.isAuthenticated()) {
     return true;
   }
@@ -73386,7 +74316,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];
@@ -73424,7 +74354,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");
@@ -73469,7 +74399,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;
@@ -73478,7 +74408,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);
@@ -73505,7 +74435,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;
@@ -77931,6 +78861,7 @@ registerSetupCommand(program2);
 registerPipelineCommand(program2);
 registerWorkflowCommand(program2);
 registerHarnessCommand(program2);
+registerSwarmCommand(program2);
 registerGeoCommand(program2);
 registerMarketingCommand(program2);
 registerSalesCommand(program2);