@honeybee-ai/waggle-cli 1.0.0 → 1.0.2

package/dist/cli.js

@@ -188,14 +188,14 @@ var init_hooks = __esm({
   }
 });
 
-// node_modules/.pnpm/@agentcoordinationprotocol+sdk@file+..+acp+packages+sdk/node_modules/@agentcoordinationprotocol/sdk/dist/client.js
+// node_modules/.pnpm/@agentcoordinationprotocol+sdk@0.1.0/node_modules/@agentcoordinationprotocol/sdk/dist/client.js
 import { request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
 function createAcpClient(config) {
   const base = config.server.replace(/\/$/, "");
   const ns = (config.namespace ?? "default") === "default" ? "" : `/${config.namespace}`;
   function fetch(method, path, body) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve3, reject) => {
       const url = new URL(`${base}/api${ns}${path}`);
       const isHttps = url.protocol === "https:";
       const reqFn = isHttps ? httpsRequest : httpRequest;
@@ -214,9 +214,9 @@ function createAcpClient(config) {
         res.on("end", () => {
           try {
             const parsed = data ? JSON.parse(data) : {};
-            resolve({ ok: res.statusCode >= 200 && res.statusCode < 300, status: res.statusCode, data: parsed });
+            resolve3({ ok: res.statusCode >= 200 && res.statusCode < 300, status: res.statusCode, data: parsed });
           } catch {
-            resolve({ ok: false, status: res.statusCode, data: {} });
+            resolve3({ ok: false, status: res.statusCode, data: {} });
           }
         });
       });
@@ -341,14 +341,14 @@ function createAcpClient(config) {
 }
 var TIMEOUT;
 var init_client = __esm({
-  "node_modules/.pnpm/@agentcoordinationprotocol+sdk@file+..+acp+packages+sdk/node_modules/@agentcoordinationprotocol/sdk/dist/client.js"() {
+  "node_modules/.pnpm/@agentcoordinationprotocol+sdk@0.1.0/node_modules/@agentcoordinationprotocol/sdk/dist/client.js"() {
     TIMEOUT = 3e3;
   }
 });
 
-// node_modules/.pnpm/@agentcoordinationprotocol+sdk@file+..+acp+packages+sdk/node_modules/@agentcoordinationprotocol/sdk/dist/index.js
+// node_modules/.pnpm/@agentcoordinationprotocol+sdk@0.1.0/node_modules/@agentcoordinationprotocol/sdk/dist/index.js
 var init_dist = __esm({
-  "node_modules/.pnpm/@agentcoordinationprotocol+sdk@file+..+acp+packages+sdk/node_modules/@agentcoordinationprotocol/sdk/dist/index.js"() {
+  "node_modules/.pnpm/@agentcoordinationprotocol+sdk@0.1.0/node_modules/@agentcoordinationprotocol/sdk/dist/index.js"() {
     init_client();
   }
 });
@@ -361,9 +361,9 @@ __export(init_exports, {
 import { createInterface } from "node:readline";
 function prompt(rl, question, defaultVal) {
   const suffix = defaultVal ? ` ${c("dim", `[${defaultVal}]`)}` : "";
-  return new Promise((resolve) => {
+  return new Promise((resolve3) => {
     rl.question(`  ${question}${suffix}: `, (answer) => {
-      resolve(answer.trim() || defaultVal || "");
+      resolve3(answer.trim() || defaultVal || "");
     });
   });
 }
@@ -691,8 +691,8 @@ async function tryParseSpec(content) {
 }
 async function tryParseYaml(content) {
   try {
-    const yaml = await import(JS_YAML);
-    const loadYaml = yaml.load || yaml.default?.load;
+    const yaml3 = await import(JS_YAML);
+    const loadYaml = yaml3.load || yaml3.default?.load;
     if (loadYaml) return loadYaml(content);
   } catch {
   }
@@ -1865,6 +1865,745 @@ var init_hooks_cmd = __esm({
   }
 });
 
+// src/brood.ts
+import { readFileSync as readFileSync5, existsSync as existsSync5 } from "node:fs";
+import { join as join5, resolve } from "node:path";
+import yaml from "js-yaml";
+function normalizeStartOn(raw) {
+  if (typeof raw === "string") {
+    return {
+      conditions: [{ event: raw, count: 1 }],
+      timeout: DEFAULT_START_ON_TIMEOUT
+    };
+  }
+  const timeout = typeof raw.timeout === "number" ? raw.timeout : DEFAULT_START_ON_TIMEOUT;
+  if (raw.all) {
+    const conditions = raw.all.map((item) => {
+      if (typeof item === "string") return { event: item, count: 1 };
+      return { event: item.event, count: item.count ?? 1 };
+    });
+    return { conditions, timeout };
+  }
+  if (raw.event) {
+    return {
+      conditions: [{ event: raw.event, count: raw.count ?? 1 }],
+      timeout
+    };
+  }
+  throw new Error("startOn must be a string, { event, count? }, or { all: [...] }");
+}
+function findBroodFile(fileArg) {
+  if (fileArg) {
+    const p = resolve(fileArg);
+    return existsSync5(p) ? p : null;
+  }
+  for (const name of BROOD_FILES) {
+    const p = join5(process.cwd(), name);
+    if (existsSync5(p)) return p;
+  }
+  return null;
+}
+async function parseBroodFile(filePath) {
+  const content = readFileSync5(filePath, "utf8");
+  const raw = filePath.endsWith(".json") ? JSON.parse(content) : parseYaml(content);
+  return validate2(raw);
+}
+function parseYaml(content) {
+  return yaml.load(content);
+}
+function validate2(raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new Error("brood file must be a YAML/JSON object");
+  }
+  const obj = raw;
+  if (typeof obj.name !== "string" || !obj.name) {
+    throw new Error('brood file requires a "name" field');
+  }
+  if (!obj.hives || typeof obj.hives !== "object") {
+    throw new Error('brood file requires a "hives" map');
+  }
+  const hives = {};
+  const hivesObj = obj.hives;
+  for (const [name, value] of Object.entries(hivesObj)) {
+    if (!value || typeof value !== "object") {
+      throw new Error(`hive "${name}" must be an object`);
+    }
+    const hive = value;
+    const config = {};
+    if (hive.worktree !== void 0) {
+      if (typeof hive.worktree !== "string") throw new Error(`hive "${name}".worktree must be a string`);
+      config.worktree = hive.worktree;
+    }
+    const acpRaw = hive.acp ?? hive.spec ?? hive.protocol;
+    if (acpRaw !== void 0) {
+      if (typeof acpRaw === "string") {
+        config.acp = acpRaw;
+      } else if (typeof acpRaw === "object" && acpRaw !== null && !Array.isArray(acpRaw)) {
+        config.acp = acpRaw;
+      } else {
+        throw new Error(`hive "${name}".acp must be a string (file/URL) or inline spec object`);
+      }
+    }
+    if (hive.port !== void 0) {
+      if (typeof hive.port !== "number") throw new Error(`hive "${name}".port must be a number`);
+      config.port = hive.port;
+    }
+    const agentsRaw = hive.workers ?? hive.agents;
+    if (agentsRaw !== void 0) {
+      if (!Array.isArray(agentsRaw)) throw new Error(`hive "${name}".agents must be an array`);
+      config.agents = agentsRaw.map((a, i) => {
+        if (!a || typeof a !== "object") throw new Error(`hive "${name}".agents[${i}] must be an object`);
+        const agent = a;
+        if (typeof agent.role !== "string") throw new Error(`hive "${name}".agents[${i}].role must be a string`);
+        let tools;
+        if (agent.tools !== void 0) {
+          if (agent.tools === "all") {
+            tools = "all";
+          } else if (Array.isArray(agent.tools) && agent.tools.every((t) => typeof t === "string")) {
+            tools = agent.tools;
+          } else {
+            throw new Error(`hive "${name}".agents[${i}].tools must be 'all' or an array of strings`);
+          }
+        }
+        let coordination;
+        if (agent.coordination !== void 0) {
+          if (typeof agent.coordination === "string" && ["lite", "full", "none"].includes(agent.coordination)) {
+            coordination = agent.coordination;
+          } else if (Array.isArray(agent.coordination) && agent.coordination.every((t) => typeof t === "string")) {
+            coordination = agent.coordination;
+          } else {
+            throw new Error(`hive "${name}".agents[${i}].coordination must be 'lite', 'full', 'none', or an array of strings`);
+          }
+        }
+        let agentType;
+        if (agent.type !== void 0) {
+          if (agent.type !== "worker" && agent.type !== "drone" && agent.type !== "claude") {
+            throw new Error(`hive "${name}".agents[${i}].type must be 'worker', 'drone', or 'claude'`);
+          }
+          agentType = agent.type;
+        }
+        const startOn = agent.startOn !== void 0 ? agent.startOn : void 0;
+        let wakeOn;
+        if (agent.wake_on !== void 0) {
+          if (!agent.wake_on || typeof agent.wake_on !== "object") {
+            throw new Error(`hive "${name}".agents[${i}].wake_on must be an object`);
+          }
+          const wo = agent.wake_on;
+          wakeOn = {
+            types: Array.isArray(wo.types) ? wo.types.filter((t) => typeof t === "string") : void 0,
+            timeout: typeof wo.timeout === "number" ? wo.timeout : void 0,
+            max_wakes: typeof wo.max_wakes === "number" ? wo.max_wakes : void 0
+          };
+        }
+        return {
+          role: agent.role,
+          count: typeof agent.count === "number" ? agent.count : void 0,
+          type: agentType,
+          model_hint: typeof agent.model_hint === "string" ? agent.model_hint : void 0,
+          prompt: typeof agent.prompt === "string" ? agent.prompt : void 0,
+          pluginDir: typeof agent.plugin_dir === "string" ? agent.plugin_dir : void 0,
+          tools,
+          coordination,
+          startOn,
+          wake_on: wakeOn
+        };
+      });
+    }
+    const honeycombRaw = hive.honeycomb ?? hive.comb;
+    if (honeycombRaw !== void 0) {
+      if (!honeycombRaw || typeof honeycombRaw !== "object") {
+        throw new Error(`hive "${name}".honeycomb must be an object`);
+      }
+      const hc = honeycombRaw;
+      config.honeycomb = {
+        publishes: Array.isArray(hc.publishes) ? hc.publishes.filter((x) => typeof x === "string") : void 0,
+        subscribes: Array.isArray(hc.subscribes) ? hc.subscribes.filter((x) => typeof x === "string") : void 0
+      };
+    }
+    const dancesRaw = hive.dances ?? hive.logic;
+    if (dancesRaw !== void 0) {
+      if (typeof dancesRaw !== "string") throw new Error(`hive "${name}".dances must be a string (file path)`);
+      config.dances = dancesRaw;
+    }
+    hives[name] = config;
+  }
+  let provider;
+  if (obj.provider !== void 0) {
+    if (typeof obj.provider !== "string") throw new Error('"provider" must be a string (e.g. "ollama/qwen3:8b")');
+    provider = obj.provider;
+  }
+  let models;
+  if (obj.models !== void 0) {
+    if (!obj.models || typeof obj.models !== "object" || Array.isArray(obj.models)) {
+      throw new Error('"models" must be an object mapping role names to provider strings');
+    }
+    models = {};
+    for (const [role, val] of Object.entries(obj.models)) {
+      if (typeof val !== "string") throw new Error(`models.${role} must be a string`);
+      models[role] = val;
+    }
+  }
+  let env;
+  if (obj.env !== void 0) {
+    if (!obj.env || typeof obj.env !== "object" || Array.isArray(obj.env)) {
+      throw new Error('"env" must be an object mapping variable names to string values');
+    }
+    env = {};
+    for (const [key, val] of Object.entries(obj.env)) {
+      env[key] = String(val);
+    }
+  }
+  let stagger;
+  if (obj.stagger !== void 0) {
+    if (typeof obj.stagger !== "number" || obj.stagger < 0) {
+      throw new Error('"stagger" must be a non-negative number (seconds between agent spawns)');
+    }
+    stagger = obj.stagger;
+  }
+  let dances;
+  const dancesTopRaw = obj.dances ?? obj.logic;
+  if (dancesTopRaw !== void 0) {
+    if (typeof dancesTopRaw !== "string") throw new Error('"dances" must be a string (file path)');
+    dances = dancesTopRaw;
+  }
+  return {
+    name: obj.name,
+    version: typeof obj.version === "string" ? obj.version : void 0,
+    provider,
+    models,
+    env,
+    stagger,
+    dances,
+    hives
+  };
+}
+var DEFAULT_START_ON_TIMEOUT, BROOD_FILES;
+var init_brood = __esm({
+  "src/brood.ts"() {
+    "use strict";
+    DEFAULT_START_ON_TIMEOUT = 0;
+    BROOD_FILES = ["brood.yaml", "brood.yml", "brood.json"];
+  }
+});
+
+// src/lib/ipc-broker.ts
+import { createServer } from "node:net";
+var IPCBroker;
+var init_ipc_broker = __esm({
+  "src/lib/ipc-broker.ts"() {
+    "use strict";
+    IPCBroker = class {
+      server = null;
+      hives = /* @__PURE__ */ new Map();
+      socketMap = /* @__PURE__ */ new Map();
+      onHiveConnect;
+      onHiveDisconnect;
+      constructor(opts) {
+        this.onHiveConnect = opts?.onHiveConnect;
+        this.onHiveDisconnect = opts?.onHiveDisconnect;
+      }
+      async listen(socketPath) {
+        return new Promise((resolve3, reject) => {
+          const srv = createServer((socket) => this.onConnection(socket));
+          srv.on("error", reject);
+          srv.listen(socketPath, () => {
+            this.server = srv;
+            resolve3();
+          });
+        });
+      }
+      async close() {
+        for (const conn of this.hives.values()) {
+          conn.socket.end();
+        }
+        this.hives.clear();
+        this.socketMap.clear();
+        if (this.server) {
+          return new Promise((resolve3) => {
+            this.server.close(() => resolve3());
+          });
+        }
+      }
+      getConnectedHives() {
+        return [...this.hives.keys()];
+      }
+      onConnection(socket) {
+        let buffer = "";
+        socket.setEncoding("utf8");
+        socket.on("data", (chunk) => {
+          buffer += chunk;
+          const lines = buffer.split("\n");
+          buffer = lines.pop();
+          for (const line of lines) {
+            if (!line) continue;
+            try {
+              this.handleMessage(socket, JSON.parse(line));
+            } catch {
+            }
+          }
+        });
+        socket.on("close", () => {
+          const conn = this.socketMap.get(socket);
+          if (conn) {
+            this.hives.delete(conn.name);
+            this.socketMap.delete(socket);
+            this.onHiveDisconnect?.(conn.name);
+          }
+        });
+        socket.on("error", () => {
+        });
+      }
+      handleMessage(socket, msg2) {
+        if (msg2.type === "register" && msg2.hive) {
+          const conn = {
+            name: msg2.hive,
+            socket,
+            subscribes: new Set(msg2.subscribes ?? [])
+          };
+          this.hives.set(msg2.hive, conn);
+          this.socketMap.set(socket, conn);
+          this.onHiveConnect?.(msg2.hive);
+        } else if (msg2.type === "event" && msg2.hive && msg2.topic) {
+          this.routeEvent(msg2.hive, msg2.topic, msg2.event);
+        }
+      }
+      routeEvent(sourceHive, topic, event) {
+        for (const [name, conn] of this.hives) {
+          if (name === sourceHive) continue;
+          if (!conn.subscribes.has(topic)) continue;
+          const forward = JSON.stringify({ type: "forward", topic, event }) + "\n";
+          conn.socket.write(forward);
+        }
+      }
+    };
+  }
+});
+
+// src/commands/up.ts
+var up_exports = {};
+__export(up_exports, {
+  up: () => up
+});
+import { spawn } from "node:child_process";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync4, existsSync as existsSync6, unlinkSync as unlinkSync2, readFileSync as readFileSync6 } from "node:fs";
+import { join as join6, dirname as dirname2, resolve as resolve2 } from "node:path";
+import { tmpdir } from "node:os";
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { createRequire } from "node:module";
+import yaml2 from "js-yaml";
+function resolvePackage(pkg, cwd) {
+  const bases = [
+    join6(cwd, "__placeholder.js"),
+    import.meta.url
+  ];
+  for (const base of bases) {
+    try {
+      const req = createRequire(base);
+      return req.resolve(pkg);
+    } catch {
+    }
+  }
+  return null;
+}
+function stateDir() {
+  return join6(process.cwd(), ".honeybee");
+}
+function stateFile() {
+  return join6(stateDir(), "brood.state.json");
+}
+async function up(args2) {
+  if (args2[0] === "--help" || args2[0] === "-h") {
+    console.log(`
+${c("bold", "wgl up")} \u2014 start a local brood (multi-hive incubator cluster)
+
+${c("cyan", "USAGE:")}
+  wgl up [options]
+
+${c("cyan", "OPTIONS:")}
+  --file <path>        Path to brood.yaml (default: auto-detect in cwd)
+  -f <path>            Alias for --file
+  --base-port <N>      Starting port for hives (default: 3100)
+  --provider <str>     LLM provider (e.g. cerebras/qwen-3-32b)
+  --spec <path>        ACP spec file path (no brood.yaml needed)
+  --dances <path>      Dance file path
+  --no-acp             Benchmark mode: LLM sees all coordination tools directly
+
+${c("cyan", "DESCRIPTION:")}
+  Reads brood.yaml, starts an IPC broker, spawns incubator processes
+  per hive, and wires Honeycomb cross-hive event routing between them.
+
+  When hives define agents, incubator spawns Propolis (environment MCP
+  server) and Drone (ReAct agent runtime) child processes within its hive.
+
+  Same brood.yaml works locally (IPC) and managed (Colony).
+
+${c("cyan", "EXAMPLES:")}
+  wgl up
+  wgl up --file ./my-project/brood.yaml
+  wgl up --base-port 4000
+`);
+    return;
+  }
+  if (existsSync6(stateFile())) {
+    console.log(error("A brood is already running"));
+    console.log(c("dim", "  Run `wgl down` to stop it first"));
+    process.exit(1);
+  }
+  const fileIdx = args2.indexOf("--file");
+  const fileArg = fileIdx !== -1 ? args2[fileIdx + 1] : void 0;
+  const fIdx = args2.indexOf("-f");
+  const fArg = fIdx !== -1 ? args2[fIdx + 1] : void 0;
+  const basePortIdx = args2.indexOf("--base-port");
+  const basePort = basePortIdx !== -1 ? parseInt(args2[basePortIdx + 1], 10) : 3100;
+  const noAcp = args2.includes("--no-acp");
+  const providerIdx = args2.indexOf("--provider");
+  const providerArg = providerIdx !== -1 ? args2[providerIdx + 1] : void 0;
+  const specIdx = args2.indexOf("--spec");
+  const specArg = specIdx !== -1 ? args2[specIdx + 1] : void 0;
+  const dancesIdx = args2.indexOf("--dances");
+  const dancesArg = dancesIdx !== -1 ? args2[dancesIdx + 1] : void 0;
+  const provider = providerArg ?? process.env.WAGGLE_PROVIDER ?? void 0;
+  const specPath = specArg ?? process.env.WAGGLE_SPEC ?? void 0;
+  const dancesPath = dancesArg ?? process.env.WAGGLE_DANCES ?? void 0;
+  let broodPath = findBroodFile(fArg ?? fileArg);
+  let config;
+  if (broodPath) {
+    try {
+      config = await parseBroodFile(broodPath);
+    } catch (err) {
+      console.log(error(`Invalid brood file: ${err.message}`));
+      process.exit(1);
+      return;
+    }
+  } else if (specPath) {
+    const specName = specPath.replace(/\.(acp|yaml|yml|json)$/i, "").split("/").pop() ?? "default";
+    config = {
+      name: specName,
+      provider: provider ?? "ollama/qwen3:8b",
+      dances: dancesPath,
+      hives: {
+        [specName]: {
+          acp: specPath,
+          dances: dancesPath
+        }
+      }
+    };
+    broodPath = join6(process.cwd(), "brood.yaml");
+  } else {
+    console.log(error("No brood.yaml found and no --spec provided"));
+    console.log(c("dim", "  Create a brood.yaml or pass --spec <path>"));
+    process.exit(1);
+    return;
+  }
+  const hiveNames = Object.keys(config.hives);
+  if (hiveNames.length === 0) {
+    console.log(error("brood.yaml has no hives defined"));
+    process.exit(1);
+    return;
+  }
+  const hivesWithAgents = hiveNames.filter((n) => (config.hives[n].agents?.length ?? 0) > 0);
+  const needsHivePackage = hivesWithAgents.some(
+    (n) => config.hives[n].agents?.some((a) => !a.type || a.type === "worker" || a.type === "drone")
+  );
+  const cwd = process.cwd();
+  const incubatorEntry = resolvePackage(INCUBATOR_PKG, cwd);
+  if (!incubatorEntry) {
+    console.log(error("Incubator not installed"));
+    console.log(`
+  Install it with:
+    ${c("cyan", "npm install @honeybee-ai/incubator")}
+`);
+    process.exit(1);
+    return;
+  }
+  let hiveEntry = null;
+  if (needsHivePackage) {
+    hiveEntry = resolvePackage(HIVE_PKG, cwd);
+    if (!hiveEntry) {
+      console.log(error("Hive not installed (required for worker/drone agents)"));
+      console.log(`
+  Install it with:
+    ${c("cyan", "npm install @honeybee-ai/hive")}
+`);
+      process.exit(1);
+      return;
+    }
+  }
+  const baseEnv = {
+    ...process.env,
+    ...config.env
+  };
+  console.log(heading(`Starting brood: ${config.name}`));
+  console.log(label("File", broodPath));
+  console.log(label("Hives", hiveNames.join(", ")));
+  if (provider && broodPath) {
+    config.provider = provider;
+  }
+  if (config.provider) console.log(label("Provider", config.provider));
+  if (config.env) console.log(label("Env", Object.keys(config.env).join(", ")));
+  if (hivesWithAgents.length > 0) console.log(label("Agent hives", hivesWithAgents.join(", ")));
+  if (noAcp) console.log(label("Mode", "no-acp (benchmark \u2014 LLM sees coordination tools)"));
+  console.log();
+  const broodId = randomBytes2(4).toString("hex");
+  const socketDir = join6(tmpdir(), `honeybee-brood-${broodId}`);
+  mkdirSync2(socketDir, { recursive: true });
+  const socketPath = join6(socketDir, "broker.sock");
+  const broker = new IPCBroker({
+    onHiveConnect: (name) => console.log(success(`Hive "${name}" connected to broker`)),
+    onHiveDisconnect: (name) => console.log(warn(`Hive "${name}" disconnected`))
+  });
+  await broker.listen(socketPath);
+  console.log(success("IPC broker started"));
+  const children = /* @__PURE__ */ new Map();
+  const hiveState = {};
+  let port = basePort;
+  let propolisPort = basePort + 100;
+  for (const [name, hive] of Object.entries(config.hives)) {
+    const hivePort = hive.port ?? port++;
+    const hiveCwd = hive.worktree ? resolve2(dirname2(broodPath), hive.worktree) : dirname2(broodPath);
+    const protocolPath = resolveProtocol(hive, broodPath, name);
+    const incubatorArgs = ["--http", `--port=${hivePort}`];
+    if (protocolPath) {
+      incubatorArgs.push(`--protocol=${protocolPath}`);
+    }
+    const dancesField = dancesPath ?? hive.dances ?? config.dances;
+    if (dancesField) {
+      const resolvedDances = resolve2(dirname2(broodPath), dancesField);
+      incubatorArgs.push(`--dances=${resolvedDances}`);
+    }
+    const hiveAgents = hive.agents?.length ? hive.agents : deriveAgentsFromSpec(protocolPath);
+    if (hiveAgents.length) {
+      const pPort = propolisPort++;
+      const worktreePath = hive.worktree ? resolve2(dirname2(broodPath), hive.worktree) : resolve2(dirname2(broodPath));
+      const agentsConfig = {
+        provider: config.provider ?? "ollama/qwen3:8b",
+        stagger: config.stagger ?? 2,
+        noAcp,
+        propolisPort: pPort,
+        worktree: worktreePath,
+        hiveEntry: hiveEntry ?? "",
+        ...protocolPath ? { protocolPath } : {},
+        agents: hiveAgents.map((a) => ({
+          role: a.role,
+          count: a.count,
+          type: a.type,
+          tools: a.tools,
+          coordination: a.coordination,
+          modelHint: a.model_hint ?? null,
+          prompt: a.prompt ?? null,
+          startOn: a.startOn ? normalizeStartOn(a.startOn) : null,
+          wakeOn: a.wake_on ? {
+            types: a.wake_on.types ?? null,
+            timeout: a.wake_on.timeout ?? 0,
+            maxWakes: a.wake_on.max_wakes ?? 0
+          } : null
+        })),
+        models: config.models,
+        env: config.env
+      };
+      incubatorArgs.push(`--agents=${JSON.stringify(agentsConfig)}`);
+      incubatorArgs.push("--verbose");
+      const workerCount = hiveAgents.filter((a) => !a.type || a.type === "worker").reduce((sum, a) => sum + (a.count ?? 1), 0);
+      const droneCount = hiveAgents.filter((a) => a.type === "drone").reduce((sum, a) => sum + (a.count ?? 1), 0);
+      const claudeCount = hiveAgents.filter((a) => a.type === "claude").reduce((sum, a) => sum + (a.count ?? 1), 0);
+      const parts = [];
+      if (workerCount > 0) parts.push(`${workerCount} worker${workerCount !== 1 ? "s" : ""}`);
+      if (droneCount > 0) parts.push(`${droneCount} drone${droneCount !== 1 ? "s" : ""}`);
+      if (claudeCount > 0) parts.push(`${claudeCount} claude${claudeCount !== 1 ? "s" : ""}`);
+      console.log(label(`${name}/agents`, `${parts.join(" + ")} (delegated to incubator)`));
+    }
+    const env = {
+      ...baseEnv,
+      HONEYCOMB_BROKER_SOCKET: socketPath,
+      HONEYCOMB_HIVE_NAME: name
+    };
+    if (hive.honeycomb?.publishes?.length) {
+      env["HONEYCOMB_PUBLISHES"] = hive.honeycomb.publishes.join(",");
+    }
+    if (hive.honeycomb?.subscribes?.length) {
+      env["HONEYCOMB_SUBSCRIBES"] = hive.honeycomb.subscribes.join(",");
+    }
+    const incChild = spawn(process.execPath, [incubatorEntry, ...incubatorArgs], {
+      env,
+      cwd: hiveCwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    incChild.stderr?.on("data", (data) => {
+      const line = data.toString().trim();
+      if (line) console.log(c("dim", `[${name}] ${line}`));
+    });
+    incChild.on("exit", (code) => {
+      children.delete(`incubator:${name}`);
+      if (code !== null && code !== 0) {
+        console.log(warn(`Hive "${name}" incubator exited with code ${code}`));
+      }
+    });
+    if (incChild.pid) {
+      children.set(`incubator:${name}`, incChild);
+      hiveState[name] = { pid: incChild.pid, port: hivePort };
+      console.log(label(name, `incubator port ${hivePort} (pid ${incChild.pid})`));
+    }
+  }
+  mkdirSync2(stateDir(), { recursive: true });
+  const state2 = {
+    name: config.name,
+    socketPath,
+    hives: hiveState,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync4(stateFile(), JSON.stringify(state2, null, 2));
+  console.log();
+  console.log(success(`Brood "${config.name}" running (${hiveNames.length} hive${hiveNames.length !== 1 ? "s" : ""})`));
+  console.log(c("dim", "  Press Ctrl+C or run `wgl down` to stop"));
+  const shutdown = async () => {
+    console.log("\n" + c("dim", "Shutting down..."));
+    for (const [key, child] of children) {
+      child.kill("SIGTERM");
+      console.log(c("dim", `  Stopped ${key}`));
+    }
+    await broker.close();
+    try {
+      unlinkSync2(socketPath);
+    } catch {
+    }
+    try {
+      unlinkSync2(stateFile());
+    } catch {
+    }
+    console.log(success("Brood stopped"));
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await new Promise(() => {
+  });
+}
+function deriveAgentsFromSpec(protocolPath) {
+  if (!protocolPath || protocolPath.startsWith("http://") || protocolPath.startsWith("https://")) return [];
+  try {
+    const raw = readFileSync6(protocolPath, "utf-8");
+    const spec = protocolPath.endsWith(".json") ? JSON.parse(raw) : yaml2.load(raw);
+    const roles = spec.roles;
+    if (!roles) return [];
+    const agents = [];
+    for (const [roleName, roleDef] of Object.entries(roles)) {
+      const count = typeof roleDef.agents === "number" ? roleDef.agents : 1;
+      for (let i = 0; i < count; i++) {
+        agents.push({ role: roleName });
+      }
+    }
+    return agents;
+  } catch {
+    return [];
+  }
+}
+function resolveProtocol(hive, broodPath, hiveName) {
+  const acpField = hive.acp ?? hive.protocol;
+  if (!acpField) return void 0;
+  if (typeof acpField === "string") {
+    if (acpField.startsWith("http://") || acpField.startsWith("https://")) {
+      return acpField;
+    }
+    return resolve2(dirname2(broodPath), acpField);
+  }
+  const tempDir = join6(tmpdir(), `honeybee-protocol-${randomBytes2(4).toString("hex")}`);
+  mkdirSync2(tempDir, { recursive: true });
+  const tempPath = join6(tempDir, `${hiveName}.acp.json`);
+  writeFileSync4(tempPath, JSON.stringify(acpField, null, 2));
+  return tempPath;
+}
+var INCUBATOR_PKG, HIVE_PKG;
+var init_up = __esm({
+  "src/commands/up.ts"() {
+    "use strict";
+    init_format();
+    init_brood();
+    init_ipc_broker();
+    INCUBATOR_PKG = "@honeybee-ai/incubator";
+    HIVE_PKG = "@honeybee-ai/hive";
+  }
+});
+
+// src/commands/down.ts
+var down_exports = {};
+__export(down_exports, {
+  down: () => down
+});
+import { readFileSync as readFileSync7, existsSync as existsSync7, unlinkSync as unlinkSync3, rmSync } from "node:fs";
+import { join as join7 } from "node:path";
+function stateFile2() {
+  return join7(process.cwd(), ".honeybee", "brood.state.json");
+}
+async function down(args2) {
+  if (args2[0] === "--help" || args2[0] === "-h") {
+    console.log(`
+${c("bold", "wgl down")} \u2014 stop a running brood
+
+${c("cyan", "USAGE:")}
+  wgl down
+
+${c("cyan", "DESCRIPTION:")}
+  Reads .honeybee/brood.state.json, sends SIGTERM to all incubator
+  processes (which clean up their own propolis + drone children),
+  removes the broker socket, and deletes the state file.
+
+${c("cyan", "EXAMPLES:")}
+  wgl down
+`);
+    return;
+  }
+  const path = stateFile2();
+  if (!existsSync7(path)) {
+    console.log(error("No running brood found"));
+    console.log(c("dim", "  No .honeybee/brood.state.json in current directory"));
+    process.exit(1);
+    return;
+  }
+  let state2;
+  try {
+    state2 = JSON.parse(readFileSync7(path, "utf8"));
+  } catch {
+    console.log(error("Corrupt state file"));
+    process.exit(1);
+    return;
+  }
+  console.log(heading(`Stopping brood: ${state2.name}`));
+  let stopped = 0;
+  for (const [name, info4] of Object.entries(state2.hives)) {
+    try {
+      process.kill(info4.pid, "SIGTERM");
+      console.log(label(name, `incubator stopped (pid ${info4.pid})`));
+      stopped++;
+    } catch {
+      console.log(label(name, c("dim", `not running (pid ${info4.pid})`)));
+    }
+  }
+  if (state2.socketPath) {
+    try {
+      unlinkSync3(state2.socketPath);
+    } catch {
+    }
+    const { dirname: dirname4 } = await import("node:path");
+    try {
+      rmSync(dirname4(state2.socketPath), { recursive: true, force: true });
+    } catch {
+    }
+  }
+  try {
+    unlinkSync3(path);
+  } catch {
+  }
+  const hiveCount = Object.keys(state2.hives).length;
+  console.log();
+  console.log(success(`Brood stopped (${hiveCount} hive${hiveCount !== 1 ? "s" : ""} terminated)`));
+}
+var init_down = __esm({
+  "src/commands/down.ts"() {
+    "use strict";
+    init_format();
+  }
+});
+
 // src/commands/serve.ts
 var serve_exports = {};
 __export(serve_exports, {
@@ -1944,18 +2683,18 @@ var init_serve = __esm({
 });
 
 // src/lib/global-config.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync5, mkdirSync as mkdirSync2 } from "node:fs";
-import { join as join5 } from "node:path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync5, existsSync as existsSync8, mkdirSync as mkdirSync3 } from "node:fs";
+import { join as join8 } from "node:path";
 import { homedir } from "node:os";
 function ensureDir() {
-  if (!existsSync5(WGL_DIR)) {
-    mkdirSync2(WGL_DIR, { recursive: true });
+  if (!existsSync8(WGL_DIR)) {
+    mkdirSync3(WGL_DIR, { recursive: true });
   }
 }
 function loadGlobalConfig() {
-  if (!existsSync5(CONFIG_PATH)) return { ...DEFAULTS };
+  if (!existsSync8(CONFIG_PATH)) return { ...DEFAULTS };
   try {
-    const raw = JSON.parse(readFileSync5(CONFIG_PATH, "utf8"));
+    const raw = JSON.parse(readFileSync8(CONFIG_PATH, "utf8"));
     return { ...DEFAULTS, ...raw };
   } catch {
     return { ...DEFAULTS };
@@ -1963,7 +2702,7 @@ function loadGlobalConfig() {
 }
 function saveGlobalConfig(config) {
   ensureDir();
-  writeFileSync4(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
+  writeFileSync5(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
 }
 function setGlobalConfigValue(key, value) {
   const config = loadGlobalConfig();
@@ -1974,8 +2713,8 @@ var WGL_DIR, CONFIG_PATH, DEFAULTS;
 var init_global_config = __esm({
   "src/lib/global-config.ts"() {
     "use strict";
-    WGL_DIR = join5(homedir(), ".wgl");
-    CONFIG_PATH = join5(WGL_DIR, "config.json");
+    WGL_DIR = join8(homedir(), ".wgl");
+    CONFIG_PATH = join8(WGL_DIR, "config.json");
     DEFAULTS = {
       defaultPlatform: "https://hivemind.honeyb.dev",
       defaultRole: "developer",
@@ -1985,11 +2724,11 @@ var init_global_config = __esm({
   }
 });
 
-// node_modules/.pnpm/@honeybee-ai+sdk@file+..+sdk+packages+sdk/node_modules/@honeybee-ai/sdk/dist/http.js
+// ../sdk/dist/http.js
 import { request as httpRequest2 } from "node:http";
 import { request as httpsRequest2 } from "node:https";
 function httpReq(method, url, body, headers = {}) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     const parsed = new URL(url);
     const isHttps = parsed.protocol === "https:";
     const reqFn = isHttps ? httpsRequest2 : httpRequest2;
@@ -2006,13 +2745,13 @@ function httpReq(method, url, body, headers = {}) {
       res.on("end", () => {
         try {
           const parsed2 = data ? JSON.parse(data) : {};
-          resolve({
+          resolve3({
             ok: res.statusCode >= 200 && res.statusCode < 300,
             status: res.statusCode,
             data: parsed2
           });
         } catch {
-          resolve({ ok: false, status: res.statusCode, data: {} });
+          resolve3({ ok: false, status: res.statusCode, data: {} });
         }
       });
     });
@@ -2028,28 +2767,30 @@ function httpReq(method, url, body, headers = {}) {
 }
 var TIMEOUT2;
 var init_http = __esm({
-  "node_modules/.pnpm/@honeybee-ai+sdk@file+..+sdk+packages+sdk/node_modules/@honeybee-ai/sdk/dist/http.js"() {
+  "../sdk/dist/http.js"() {
+    "use strict";
     TIMEOUT2 = 1e4;
   }
 });
 
-// node_modules/.pnpm/@honeybee-ai+sdk@file+..+sdk+packages+sdk/node_modules/@honeybee-ai/sdk/dist/auth.js
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync6, mkdirSync as mkdirSync3 } from "node:fs";
-import { join as join6 } from "node:path";
+// ../sdk/dist/auth.js
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, existsSync as existsSync9, mkdirSync as mkdirSync4, chmodSync } from "node:fs";
+import { join as join9 } from "node:path";
 import { homedir as homedir2 } from "node:os";
 function loadAuthStore() {
-  if (!existsSync6(AUTH_PATH))
+  if (!existsSync9(AUTH_PATH))
     return { profiles: {} };
   try {
-    return JSON.parse(readFileSync6(AUTH_PATH, "utf8"));
+    return JSON.parse(readFileSync9(AUTH_PATH, "utf8"));
   } catch {
     return { profiles: {} };
   }
 }
 function saveAuthStore(store) {
-  if (!existsSync6(WGL_DIR2))
-    mkdirSync3(WGL_DIR2, { recursive: true });
-  writeFileSync5(AUTH_PATH, JSON.stringify(store, null, 2) + "\n", { mode: 384 });
+  if (!existsSync9(WGL_DIR2))
+    mkdirSync4(WGL_DIR2, { recursive: true });
+  writeFileSync6(AUTH_PATH, JSON.stringify(store, null, 2) + "\n", { mode: 384 });
+  chmodSync(AUTH_PATH, 384);
 }
 function getActiveProfile(profileName) {
   const store = loadAuthStore();
@@ -2134,15 +2875,16 @@ async function refreshToken(platform, refreshTokenValue) {
 }
 var WGL_DIR2, AUTH_PATH, GITHUB_CLIENT_ID;
 var init_auth = __esm({
-  "node_modules/.pnpm/@honeybee-ai+sdk@file+..+sdk+packages+sdk/node_modules/@honeybee-ai/sdk/dist/auth.js"() {
+  "../sdk/dist/auth.js"() {
+    "use strict";
     init_http();
-    WGL_DIR2 = join6(homedir2(), ".wgl");
-    AUTH_PATH = join6(WGL_DIR2, "auth.json");
+    WGL_DIR2 = join9(homedir2(), ".wgl");
+    AUTH_PATH = join9(WGL_DIR2, "auth.json");
     GITHUB_CLIENT_ID = "Ov23liy8H1qGZdVAk1Vr";
   }
 });
 
-// node_modules/.pnpm/@honeybee-ai+sdk@file+..+sdk+packages+sdk/node_modules/@honeybee-ai/sdk/dist/platform.js
+// ../sdk/dist/platform.js
 function createPlatformClient(options) {
   const profileName = options?.profileName || "personal";
   const maybeProfile = getActiveProfile(profileName);
@@ -2154,9 +2896,8 @@ function createPlatformClient(options) {
   const platformUrl = new URL(platform);
   const apiBase = `${platformUrl.protocol}//api.${platformUrl.host}/rest/v1`;
   let accessToken = profile.accessToken;
-  async function ensureValidToken() {
-    if (!isTokenExpired(profile))
-      return;
+  let refreshPromise = null;
+  async function doRefresh() {
     try {
       const tokens = await refreshToken(profile.platform, profile.refreshToken);
       accessToken = tokens.access_token;
@@ -2170,7 +2911,17 @@ function createPlatformClient(options) {
       });
     } catch {
       throw new Error("Session expired. Run `wgl auth login` to re-authenticate.");
+    } finally {
+      refreshPromise = null;
+    }
+  }
+  async function ensureValidToken() {
+    if (!isTokenExpired(profile))
+      return;
+    if (!refreshPromise) {
+      refreshPromise = doRefresh();
     }
+    return refreshPromise;
   }
   function fetch(method, path, body, skipAuth = false) {
     const url = `${apiBase}${path}`;
@@ -2184,21 +2935,11 @@ function createPlatformClient(options) {
     await ensureValidToken();
     const res = await fetch(method, path, body);
     if (res.status === 401) {
-      try {
-        const tokens = await refreshToken(profile.platform, profile.refreshToken);
-        accessToken = tokens.access_token;
-        setProfile(profileName, {
-          platform: profile.platform,
-          email: profile.email,
-          org: profile.org,
-          accessToken: tokens.access_token,
-          refreshToken: tokens.refresh_token,
-          expiresAt: Math.floor(Date.now() / 1e3) + tokens.expires_in
-        });
-        return fetch(method, path, body);
-      } catch {
-        throw new Error("Session expired. Run `wgl auth login` to re-authenticate.");
+      if (!refreshPromise) {
+        refreshPromise = doRefresh();
       }
+      await refreshPromise;
+      return fetch(method, path, body);
     }
     return res;
   }
@@ -2284,20 +3025,34 @@ function createPlatformClient(options) {
     listCarapaceKeys: () => authedFetch("GET", "/carapace/dashboard/keys"),
     createCarapaceKey: (name, mode) => authedFetch("POST", "/carapace/dashboard/keys", { name, mode }),
     deleteCarapaceKey: (id) => authedFetch("DELETE", `/carapace/dashboard/keys/${encodeURIComponent(id)}`),
+    // --- Telemetry ---
+    telemetryOverview: (days) => authedFetch("GET", `/carapace/api/telemetry/overview${days ? "?days=" + days : ""}`),
+    telemetryTimeline: (days) => authedFetch("GET", `/carapace/api/telemetry/timeline${days ? "?days=" + days : ""}`),
+    telemetryEvents: (opts) => {
+      const params = new URLSearchParams();
+      if (opts?.limit)
+        params.set("limit", String(opts.limit));
+      if (opts?.offset)
+        params.set("offset", String(opts.offset));
+      const qs = params.toString();
+      return authedFetch("GET", `/carapace/api/telemetry/events${qs ? "?" + qs : ""}`);
+    },
     // --- Auth ---
     getMe: () => authedFetch("GET", "/auth/me")
   };
 }
 var init_platform = __esm({
-  "node_modules/.pnpm/@honeybee-ai+sdk@file+..+sdk+packages+sdk/node_modules/@honeybee-ai/sdk/dist/platform.js"() {
+  "../sdk/dist/platform.js"() {
+    "use strict";
     init_http();
     init_auth();
   }
 });
 
-// node_modules/.pnpm/@honeybee-ai+sdk@file+..+sdk+packages+sdk/node_modules/@honeybee-ai/sdk/dist/index.js
+// ../sdk/dist/index.js
 var init_dist2 = __esm({
-  "node_modules/.pnpm/@honeybee-ai+sdk@file+..+sdk+packages+sdk/node_modules/@honeybee-ai/sdk/dist/index.js"() {
+  "../sdk/dist/index.js"() {
+    "use strict";
     init_platform();
     init_auth();
   }
@@ -2545,7 +3300,7 @@ var marketplace_exports = {};
 __export(marketplace_exports, {
   marketplace: () => marketplace
 });
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "node:fs";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "node:fs";
 import { basename as basename2 } from "node:path";
 async function marketplace(args2) {
   const sub = args2[0];
@@ -2720,7 +3475,7 @@ async function install(args2) {
     }
     const safeName = basename2(name).replace(/[/\\]/g, "_");
     const filename = `${safeName}.acp.json`;
-    writeFileSync6(filename, JSON.stringify(specContent, null, 2) + "\n");
+    writeFileSync7(filename, JSON.stringify(specContent, null, 2) + "\n");
     console.log(success(`Downloaded: ${filename}`));
     console.log(c("dim", "  No local server \u2014 saved to file. Load with: wgl protocol load " + filename));
   } catch (err) {
@@ -2748,7 +3503,7 @@ async function publish(args2) {
   }
   let content;
   try {
-    content = readFileSync7(file, "utf8");
+    content = readFileSync10(file, "utf8");
   } catch {
     console.log(error(`Cannot read file: ${file}`));
     process.exit(1);
@@ -2830,30 +3585,30 @@ var integrations_exports = {};
 __export(integrations_exports, {
   integrations: () => integrations
 });
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync7, mkdirSync as mkdirSync4, existsSync as existsSync7 } from "node:fs";
-import { join as join7 } from "node:path";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync8, mkdirSync as mkdirSync5, existsSync as existsSync10 } from "node:fs";
+import { join as join10 } from "node:path";
 import { homedir as homedir3 } from "node:os";
 function configDir() {
-  return join7(homedir3(), ".config", "honeybee");
+  return join10(homedir3(), ".config", "honeybee");
 }
 function configPath() {
-  return join7(configDir(), "integrations.json");
+  return join10(configDir(), "integrations.json");
 }
 function loadLocalConfig() {
   const path = configPath();
-  if (!existsSync7(path)) return {};
+  if (!existsSync10(path)) return {};
   try {
-    return JSON.parse(readFileSync8(path, "utf8"));
+    return JSON.parse(readFileSync11(path, "utf8"));
   } catch {
     return {};
   }
 }
 function saveLocalConfig(config) {
   const dir = configDir();
-  if (!existsSync7(dir)) {
-    mkdirSync4(dir, { recursive: true });
+  if (!existsSync10(dir)) {
+    mkdirSync5(dir, { recursive: true });
   }
-  writeFileSync7(configPath(), JSON.stringify(config, null, 2) + "\n");
+  writeFileSync8(configPath(), JSON.stringify(config, null, 2) + "\n", { mode: 384 });
 }
 async function integrations(args2) {
   const sub = args2[0];
@@ -3026,9 +3781,13 @@ async function install2(args2) {
     }
     const manifest = res.data;
     const npmPackage = manifest.npm_package || name;
-    const { execSync: execSync2 } = await import("node:child_process");
+    if (!/^(@[a-z0-9-~][a-z0-9._-~]*\/)?[a-z0-9-~][a-z0-9._-~]*(@[^;|&`$\s]+)?$/.test(npmPackage)) {
+      console.log(error(`Invalid npm package name: ${npmPackage}`));
+      process.exit(1);
+    }
+    const { execFileSync } = await import("node:child_process");
     console.log(c("dim", `  Installing ${npmPackage}...`));
-    execSync2(`npm install -g ${npmPackage}`, { stdio: "inherit" });
+    execFileSync("npm", ["install", "-g", npmPackage], { stdio: "inherit" });
     const config = loadLocalConfig();
     config[name] = {
       package: npmPackage,
@@ -3125,10 +3884,10 @@ async function publish2(args2) {
   }
   let content;
   try {
-    content = readFileSync8(manifestPath, "utf8");
+    content = readFileSync11(manifestPath, "utf8");
   } catch {
     try {
-      content = readFileSync8(join7(manifestPath, "manifest.json"), "utf8");
+      content = readFileSync11(join10(manifestPath, "manifest.json"), "utf8");
     } catch {
       console.log(error(`Cannot read manifest: ${manifestPath}`));
       process.exit(1);
@@ -3196,7 +3955,7 @@ var swarm_exports = {};
 __export(swarm_exports, {
   swarm: () => swarm
 });
-import { readFileSync as readFileSync9 } from "node:fs";
+import { readFileSync as readFileSync12 } from "node:fs";
 async function swarm(args2) {
   const sub = args2[0];
   if (!sub || sub === "--help" || sub === "-h") {
@@ -3280,7 +4039,7 @@ async function create(args2) {
   if (protoIdx !== -1) {
     const protoFile = args2[protoIdx + 1];
     try {
-      const content = readFileSync9(protoFile, "utf8");
+      const content = readFileSync12(protoFile, "utf8");
       const parsed = JSON.parse(content);
       opts.protocol_name = parsed.name || protoFile;
       opts.protocol_content = content;
@@ -3587,7 +4346,7 @@ var scan_exports = {};
 __export(scan_exports, {
   scan: () => scan
 });
-import { readFileSync as readFileSync10 } from "node:fs";
+import { readFileSync as readFileSync13 } from "node:fs";
 async function scan(args2) {
   if (args2[0] === "--help" || args2[0] === "-h") {
     console.log(`
@@ -3635,7 +4394,7 @@ ${c("cyan", "EXAMPLES:")}
       return;
     }
     try {
-      text = readFileSync10(filePath, "utf8");
+      text = readFileSync13(filePath, "utf8");
     } catch {
       console.log(error(`Cannot read file: ${filePath}`));
       process.exit(1);
@@ -3735,6 +4494,157 @@ var init_scan = __esm({
   }
 });
 
+// src/commands/telemetry.ts
+var telemetry_exports = {};
+__export(telemetry_exports, {
+  telemetry: () => telemetry
+});
+async function telemetry(args2) {
+  const sub = args2[0];
+  if (sub === "--help" || sub === "-h" || !sub) {
+    console.log(`
+${c("bold", "wgl telemetry")} \u2014 view telemetry data from Carapace
+
+${c("cyan", "USAGE:")}
+  wgl telemetry overview              Aggregate counters (scans, threats, latency)
+  wgl telemetry events                Recent telemetry events
+  wgl telemetry timeline              Daily breakdown by event type
+
+${c("cyan", "OPTIONS:")}
+  --days N          Time window in days (default: 30, max: 90)
+  --limit N         Number of events to show (default: 20, max: 100)
+  --json            JSON output (pipe-friendly)
+
+${c("cyan", "EXAMPLES:")}
+  wgl telemetry overview
+  wgl telemetry overview --days 7
+  wgl telemetry events --limit 10
+  wgl telemetry timeline --json
+`);
+    return;
+  }
+  let client;
+  try {
+    client = createPlatformClient();
+  } catch {
+    console.log(error("Not logged in. Run `wgl auth login` first."));
+    process.exit(1);
+    return;
+  }
+  const jsonOutput = args2.includes("--json");
+  const daysIdx = args2.indexOf("--days");
+  const days = daysIdx !== -1 ? parseInt(args2[daysIdx + 1], 10) || 30 : void 0;
+  const limitIdx = args2.indexOf("--limit");
+  const limit = limitIdx !== -1 ? parseInt(args2[limitIdx + 1], 10) || 20 : void 0;
+  switch (sub) {
+    case "overview":
+      await showOverview(client, days, jsonOutput);
+      break;
+    case "events":
+      await showEvents(client, limit, jsonOutput);
+      break;
+    case "timeline":
+      await showTimeline(client, days, jsonOutput);
+      break;
+    default:
+      console.log(error(`Unknown subcommand: ${sub}`));
+      console.log("Run `wgl telemetry --help` for usage");
+      process.exit(2);
+  }
+}
+async function showOverview(client, days, json) {
+  const res = await client.telemetryOverview(days);
+  if (!res.ok) {
+    console.log(error(`Failed to fetch overview (${res.status})`));
+    process.exit(1);
+    return;
+  }
+  const data = res.data;
+  if (json) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  console.log(heading(`Telemetry Overview (${data.days} days)`));
+  console.log(table([
+    ["Scans", String(data.totalScans)],
+    ["Threats Blocked", data.threatsBlocked > 0 ? c("red", String(data.threatsBlocked)) : "0"],
+    ["MCP Proxy Requests", String(data.totalMcpRequests)],
+    ["LLM Proxy Requests", String(data.totalProxyRequests)],
+    ["Avg Latency", `${data.avgLatencyMs}ms`]
+  ]));
+  console.log();
+}
+async function showEvents(client, limit, json) {
+  const res = await client.telemetryEvents({ limit: limit ?? 20 });
+  if (!res.ok) {
+    console.log(error(`Failed to fetch events (${res.status})`));
+    process.exit(1);
+    return;
+  }
+  const page = res.data;
+  if (json) {
+    console.log(JSON.stringify(page, null, 2));
+    return;
+  }
+  console.log(heading(`Recent Events (${page.events.length} of ${page.total})`));
+  if (page.events.length === 0) {
+    console.log(`  ${c("dim", "No telemetry events yet.")}`);
+    console.log();
+    return;
+  }
+  for (const event of page.events) {
+    const typeColor = event.eventType === "threat_detected" ? "red" : event.eventType.startsWith("agent_") ? "cyan" : event.eventType.startsWith("llm_") ? "yellow" : "dim";
+    const ts = new Date(event.createdAt).toLocaleString();
+    console.log(`  ${c("dim", ts)}  ${c(typeColor, event.eventType.padEnd(18))}`);
+    if (event.metadata) {
+      const meta = Object.entries(event.metadata).slice(0, 4).map(([k, v]) => `${k}=${typeof v === "object" ? JSON.stringify(v) : v}`).join(" ");
+      if (meta) console.log(`    ${c("dim", meta)}`);
+    }
+  }
+  console.log();
+}
+async function showTimeline(client, days, json) {
+  const res = await client.telemetryTimeline(days);
+  if (!res.ok) {
+    console.log(error(`Failed to fetch timeline (${res.status})`));
+    process.exit(1);
+    return;
+  }
+  const data = res.data;
+  if (json) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  console.log(heading(`Telemetry Timeline (${data.days} days)`));
+  if (data.timeline.length === 0) {
+    console.log(`  ${c("dim", "No data for this period.")}`);
+    console.log();
+    return;
+  }
+  const byDate = /* @__PURE__ */ new Map();
+  for (const entry of data.timeline) {
+    const key = entry.date;
+    if (!byDate.has(key)) byDate.set(key, []);
+    byDate.get(key).push({ type: entry.event_type, count: entry.count });
+  }
+  for (const [date, entries] of byDate) {
+    const total = entries.reduce((s, e) => s + e.count, 0);
+    console.log(`  ${c("bold", date)}  ${c("dim", `(${total} events)`)}`);
+    for (const e of entries) {
+      const bar = "|".repeat(Math.min(e.count, 40));
+      console.log(`    ${e.type.padEnd(18)} ${c("cyan", bar)} ${e.count}`);
+    }
+  }
+  console.log();
+}
+var init_telemetry = __esm({
+  "src/commands/telemetry.ts"() {
+    "use strict";
+    init_dist2();
+    init_format();
+  }
+});
+
 // src/commands/completion.ts
 var completion_exports = {};
 __export(completion_exports, {
@@ -3931,28 +4841,28 @@ var upgrade_exports = {};
 __export(upgrade_exports, {
   upgrade: () => upgrade
 });
-import { readFileSync as readFileSync11 } from "node:fs";
-import { join as join8, dirname as dirname2 } from "node:path";
+import { readFileSync as readFileSync14 } from "node:fs";
+import { join as join11, dirname as dirname3 } from "node:path";
 import { request as httpsRequest3 } from "node:https";
 import { execSync } from "node:child_process";
 function getCurrentVersion() {
-  if (true) return "1.0.0";
+  if (true) return "1.0.2";
   try {
-    const pkgPath = join8(dirname2(new URL(import.meta.url).pathname), "..", "package.json");
-    return JSON.parse(readFileSync11(pkgPath, "utf8")).version;
+    const pkgPath = join11(dirname3(new URL(import.meta.url).pathname), "..", "package.json");
+    return JSON.parse(readFileSync14(pkgPath, "utf8")).version;
   } catch {
     return "0.0.0-dev";
   }
 }
 function fetchLatestVersion() {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     const req = httpsRequest3(REGISTRY_URL, { timeout: 1e4 }, (res) => {
       let data = "";
       res.on("data", (chunk) => data += chunk);
       res.on("end", () => {
         try {
           const parsed = JSON.parse(data);
-          resolve(parsed.version);
+          resolve3(parsed.version);
         } catch {
           reject(new Error("Failed to parse registry response"));
         }
@@ -4082,6 +4992,10 @@ ${c("cyan", "CONTROL:")}
   pause [reason]        Pause coordination
   resume                Resume coordination
 
+${c("cyan", "BROOD:")}
+  up                    Start local brood (multi-hive cluster)
+  down                  Stop a running brood
+
 ${c("cyan", "SERVER & HOOKS:")}
   serve                 Start local incubator server
   hooks install         Install Claude Code hooks
@@ -4122,6 +5036,11 @@ ${c("cyan", "CLOUD:")}
   swarm keys            Manage API keys
   swarm logs            Tail swarm events
 
+${c("cyan", "TELEMETRY:")}
+  telemetry overview    Aggregate counters (scans, threats, latency)
+  telemetry events      Recent telemetry events
+  telemetry timeline    Daily breakdown by event type
+
 ${c("cyan", "TOOLS:")}
   scan <text>           Scan text for prompt injection
   completion <shell>    Generate shell completion script
@@ -4153,12 +5072,12 @@ async function main() {
   }
   if (command === "--version" || command === "-v") {
     if (true) {
-      console.log("1.0.0");
+      console.log("1.0.2");
     } else {
-      const { readFileSync: readFileSync12 } = await null;
-      const { join: join9, dirname: dirname3 } = await null;
-      const pkgPath = join9(dirname3(new URL(import.meta.url).pathname), "..", "package.json");
-      const pkg = JSON.parse(readFileSync12(pkgPath, "utf8"));
+      const { readFileSync: readFileSync15 } = await null;
+      const { join: join12, dirname: dirname4 } = await null;
+      const pkgPath = join12(dirname4(new URL(import.meta.url).pathname), "..", "package.json");
+      const pkg = JSON.parse(readFileSync15(pkgPath, "utf8"));
       console.log(pkg.version);
     }
     return;
@@ -4170,8 +5089,8 @@ async function main() {
       break;
     }
     case "join": {
-      const { join: join9 } = await Promise.resolve().then(() => (init_join(), join_exports));
-      await join9(commandArgs);
+      const { join: join12 } = await Promise.resolve().then(() => (init_join(), join_exports));
+      await join12(commandArgs);
       break;
     }
     case "status": {
@@ -4249,6 +5168,16 @@ async function main() {
       await hooksCmd2(commandArgs);
       break;
     }
+    case "up": {
+      const { up: up2 } = await Promise.resolve().then(() => (init_up(), up_exports));
+      await up2(commandArgs);
+      break;
+    }
+    case "down": {
+      const { down: down2 } = await Promise.resolve().then(() => (init_down(), down_exports));
+      await down2(commandArgs);
+      break;
+    }
     case "serve": {
       const { serve: serve2 } = await Promise.resolve().then(() => (init_serve(), serve_exports));
       await serve2(commandArgs);
@@ -4284,6 +5213,11 @@ async function main() {
       await scan2(commandArgs);
       break;
     }
+    case "telemetry": {
+      const { telemetry: telemetry2 } = await Promise.resolve().then(() => (init_telemetry(), telemetry_exports));
+      await telemetry2(commandArgs);
+      break;
+    }
     case "completion": {
       const { completion: completion2 } = await Promise.resolve().then(() => (init_completion(), completion_exports));
       await completion2(commandArgs);