bazilion 0.0.0 → 0.1.1

package/dist/cli.js

@@ -0,0 +1,2730 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { defineCommand as defineCommand19, runCommand, showUsage } from "citty";
+
+// package.json
+var package_default = {
+  name: "bazilion",
+  version: "0.1.1",
+  description: "Multi-agent runtime CLI \u2014 spawn LLM agents, manage profiles/groups/skills, and run the local daemon.",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/rullopat/bazilion.git",
+    directory: "apps/cli"
+  },
+  homepage: "https://bazilion.com",
+  bugs: {
+    url: "https://github.com/rullopat/bazilion/issues"
+  },
+  keywords: [
+    "agent",
+    "agents",
+    "ai",
+    "cli",
+    "daemon",
+    "llm",
+    "local-first",
+    "multi-agent",
+    "openclaw",
+    "skills"
+  ],
+  type: "module",
+  bin: {
+    bazilion: "./dist/cli.js"
+  },
+  files: [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  scripts: {
+    build: "tsup"
+  },
+  engines: {
+    node: ">=24.0.0"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  dependencies: {
+    "@earendil-works/pi-agent-core": "^0.75.4",
+    "@earendil-works/pi-ai": "^0.75.4",
+    "@earendil-works/pi-coding-agent": "^0.75.4",
+    "@hono/node-server": "^2.0.3",
+    "@mozilla/readability": "^0.6.0",
+    "@tobilu/qmd": "^2.5.2",
+    "adm-zip": "^0.5.17",
+    citty: "^0.2.2",
+    hono: "^4.12.22",
+    linkedom: "^0.18.12",
+    "qrcode-terminal": "^0.12.0",
+    typebox: "^1.1.38",
+    undici: "^8.3.0",
+    yaml: "^2.9.0"
+  },
+  devDependencies: {
+    "@bazilion/api-types": "workspace:*",
+    "@bazilion/client": "workspace:*",
+    "@types/adm-zip": "^0.5.8",
+    "@types/qrcode-terminal": "^0.12.2"
+  }
+};
+
+// ../../packages/client/src/index.ts
+var ApiClientError = class extends Error {
+  status;
+  body;
+  constructor(status, body) {
+    super(`${status}: ${body.error}`);
+    this.status = status;
+    this.body = body;
+  }
+};
+async function resolveToken(src) {
+  return typeof src === "function" ? await src() : src;
+}
+function createClient(cfg) {
+  async function authHeaders() {
+    const token = await resolveToken(cfg.token);
+    return {
+      authorization: `Bearer ${token}`,
+      // Astro 6 enabled `security.checkOrigin` by default for server mode:
+      // any state-changing request without an `Origin` matching the server
+      // host is rejected with 403. Browsers set this automatically; `fetch`
+      // in Node / React Native does not. Stamping the server's own URL is
+      // always valid for a legitimate client.
+      origin: cfg.serverUrl
+    };
+  }
+  async function request(method, path, body) {
+    const headers = { ...await authHeaders() };
+    if (body !== void 0) headers["content-type"] = "application/json";
+    const res = await fetch(`${cfg.serverUrl}${path}`, {
+      method,
+      headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({ error: res.statusText }));
+      throw new ApiClientError(res.status, err);
+    }
+    if (res.status === 204) return void 0;
+    return await res.json();
+  }
+  async function postMultipart(path, form) {
+    const res = await fetch(`${cfg.serverUrl}${path}`, {
+      method: "POST",
+      headers: { ...await authHeaders() },
+      body: form
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({ error: res.statusText }));
+      throw new ApiClientError(res.status, err);
+    }
+    if (res.status === 204) return void 0;
+    return await res.json();
+  }
+  async function* stream(method, path, body) {
+    const headers = { ...await authHeaders() };
+    if (body !== void 0) headers["content-type"] = "application/json";
+    const res = await fetch(`${cfg.serverUrl}${path}`, {
+      method,
+      headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok || !res.body) {
+      const err = await res.json().catch(() => ({ error: res.statusText }));
+      throw new ApiClientError(res.status, err);
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (line.trim()) yield JSON.parse(line);
+      }
+    }
+    if (buffer.trim()) yield JSON.parse(buffer);
+  }
+  return {
+    get: (p) => request("GET", p),
+    post: (p, b) => request("POST", p, b),
+    postMultipart,
+    put: (p, b) => request("PUT", p, b),
+    patch: (p, b) => request("PATCH", p, b),
+    del: (p) => request("DELETE", p),
+    stream
+  };
+}
+
+// src/auth-file.ts
+import { existsSync, readFileSync } from "fs";
+function readAuthFile(authFile) {
+  if (!existsSync(authFile)) {
+    throw new Error(`${authFile} not found. Start the daemon with \`bazilion serve\` first.`);
+  }
+  const raw = readFileSync(authFile, "utf8");
+  const parsed = JSON.parse(raw);
+  if (typeof parsed.token !== "string" || !parsed.token) {
+    throw new Error(`${authFile} is missing the "token" field`);
+  }
+  return { token: parsed.token, remote: parsed.remote ?? null };
+}
+
+// src/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+function resolveCliPaths(home) {
+  const root = home ?? process.env.BAZILION_HOME ?? join(homedir(), ".bazilion");
+  return { home: root, authFile: join(root, "auth.json") };
+}
+
+// src/client.ts
+function loadClientConfig() {
+  const envUrl = process.env.BAZILION_SERVER;
+  const envToken = process.env.BAZILION_TOKEN;
+  if (envUrl && envToken) return { serverUrl: envUrl, token: envToken };
+  const paths = resolveCliPaths();
+  const auth = readAuthFile(paths.authFile);
+  if (auth.remote?.server && auth.remote.token) {
+    return {
+      serverUrl: envUrl ?? auth.remote.server,
+      token: auth.remote.token
+    };
+  }
+  return {
+    serverUrl: envUrl ?? "http://127.0.0.1:4321",
+    token: auth.token
+  };
+}
+function createClient2(cfg = loadClientConfig()) {
+  return createClient({ serverUrl: cfg.serverUrl, token: cfg.token });
+}
+
+// src/commands/agent.ts
+import { stdin, stdout } from "process";
+import { createInterface } from "readline/promises";
+import { defineCommand } from "citty";
+
+// src/columnize.ts
+function columnize(rows, gap = "  ") {
+  if (rows.length === 0) return [];
+  const colCount = rows[0]?.length ?? 0;
+  const widths = new Array(colCount).fill(0);
+  for (const row of rows) {
+    for (let i = 0; i < colCount; i++) {
+      const cell = row[i] ?? "";
+      const prev = widths[i] ?? 0;
+      if (cell.length > prev) widths[i] = cell.length;
+    }
+  }
+  return rows.map(
+    (row) => row.map((cell, i) => {
+      if (i === colCount - 1) return cell;
+      return (cell ?? "").padEnd(widths[i] ?? 0);
+    }).join(gap)
+  );
+}
+
+// src/commands/agent.ts
+var spawnCmd = defineCommand({
+  meta: { name: "spawn", description: "Spawn an agent from a profile into a group" },
+  args: {
+    profile: { type: "string", required: true, description: "Profile id" },
+    name: { type: "string", description: "Agent name (defaults to profile name)" },
+    group: {
+      type: "string",
+      description: "Group to join (defaults to 'default')"
+    },
+    model: { type: "string", description: "Override profile default model" },
+    reasoning: {
+      type: "string",
+      description: "Reasoning level: off|minimal|low|medium|high|xhigh (default: medium)"
+    }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const body = {
+      profileId: args.profile,
+      name: args.name,
+      model: args.model,
+      reasoningLevel: args.reasoning,
+      groupId: args.group
+    };
+    const agent = await client.post("/api/agents", body);
+    console.log(`spawned agent ${agent.id} (${agent.name})`);
+    console.log(`dir: ${agent.dir}`);
+  }
+});
+var editCmd = defineCommand({
+  meta: {
+    name: "edit",
+    description: "Edit agent settings (name, model override, reasoning level)"
+  },
+  args: {
+    id: { type: "positional", required: true, description: "Agent id or prefix" },
+    name: { type: "string", description: "Rename the agent" },
+    model: { type: "string", description: 'Set model override (use --model "" to clear)' },
+    reasoning: {
+      type: "string",
+      description: "Reasoning level: off|minimal|low|medium|high|xhigh"
+    }
+  },
+  async run({ args }) {
+    if (args.name === void 0 && args.model === void 0 && args.reasoning === void 0) {
+      console.error("agent edit: specify at least one of --name, --model, or --reasoning");
+      process.exit(2);
+    }
+    const client = createClient2();
+    const body = {};
+    if (args.name !== void 0) body.name = args.name;
+    if (args.model !== void 0) {
+      body.modelOverride = args.model === "" ? null : args.model;
+    }
+    if (args.reasoning !== void 0) body.reasoningLevel = args.reasoning;
+    const agent = await client.patch(`/api/agents/${args.id}`, body);
+    console.log(`updated agent ${agent.id} (${agent.name})`);
+  }
+});
+var listCmd = defineCommand({
+  meta: { name: "list", description: "List agents" },
+  args: {
+    all: { type: "boolean", description: "Include archived agents" },
+    long: { type: "boolean", alias: "l", description: "Show profile + full UUID columns" }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const q = args.all ? "?includeArchived=true" : "";
+    const list = await client.get(`/api/agents${q}`);
+    if (list.length === 0) {
+      console.log("(no agents)");
+      return;
+    }
+    const rows = list.map(
+      (a) => args.long ? [a.id, a.status, a.name, a.profileId] : (
+        // Short UUID prefix — all CLI commands accept 4+ char prefixes now.
+        [a.id.slice(0, 8), a.status, a.name]
+      )
+    );
+    for (const line of columnize(rows)) console.log(line);
+  }
+});
+var showCmd = defineCommand({
+  meta: { name: "show", description: "Show agent details" },
+  args: {
+    id: { type: "positional", required: true }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const r = await client.get(`/api/agents/${args.id}`);
+    console.log(`# ${r.agent.id}`);
+    console.log(`name:    ${r.agent.name}`);
+    console.log(`status:  ${r.agent.status}`);
+    console.log(`profile: ${r.profile.id}`);
+    console.log(`model:   ${r.model}`);
+    console.log(`dir:     ${r.agent.dir}`);
+    console.log(`group:   ${r.group.id} ${r.group.path}`);
+    console.log("skills:");
+    if (r.skills.length === 0) {
+      console.log("  (none)");
+    } else {
+      for (const s of r.skills) console.log(`  ${s}`);
+    }
+  }
+});
+var archiveCmd = defineCommand({
+  meta: { name: "archive", description: "Archive an agent" },
+  args: {
+    id: { type: "positional", required: true }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    await client.post(`/api/agents/${args.id}/archive`);
+    console.log(`archived agent ${args.id}`);
+  }
+});
+var unarchiveCmd = defineCommand({
+  meta: { name: "unarchive", description: "Restore an archived agent to idle" },
+  args: {
+    id: { type: "positional", required: true }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    await client.post(`/api/agents/${args.id}/unarchive`);
+    console.log(`unarchived agent ${args.id}`);
+  }
+});
+var deleteCmd = defineCommand({
+  meta: { name: "delete", description: "Permanently delete an agent and its data" },
+  args: {
+    id: { type: "positional", required: true }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    await client.del(`/api/agents/${args.id}`);
+    console.log(`deleted agent ${args.id}`);
+  }
+});
+function printEvent(e, state) {
+  switch (e.type) {
+    case "assistant_delta":
+      process.stdout.write(e.delta);
+      state.inDeltaStream = true;
+      break;
+    case "assistant_message":
+      if (state.inDeltaStream) {
+        process.stdout.write("\n");
+        state.inDeltaStream = false;
+      } else {
+        console.log(e.text);
+      }
+      break;
+    case "tool_call":
+      if (state.inDeltaStream) {
+        process.stdout.write("\n");
+        state.inDeltaStream = false;
+      }
+      console.log(`  [tool: ${e.name} ${e.arguments}]`);
+      break;
+    case "tool_result":
+      console.log(`  [result: ${e.result.split("\n")[0]?.slice(0, 100)}]`);
+      break;
+    case "tool_error":
+      console.log(`  [tool error: ${e.name} \u2014 ${e.error}]`);
+      break;
+    case "error":
+      if (state.inDeltaStream) {
+        process.stdout.write("\n");
+        state.inDeltaStream = false;
+      }
+      console.log(`  [error: ${e.error}]`);
+      break;
+  }
+}
+async function streamTurn(client, agentId, message) {
+  const state = { inDeltaStream: false };
+  for await (const frame of client.stream("POST", `/api/agents/${agentId}/chat`, {
+    message
+  })) {
+    if (frame.kind === "event") {
+      if (frame.event.type !== "user_message") printEvent(frame.event, state);
+    } else if (frame.kind === "fatal") {
+      if (state.inDeltaStream) process.stdout.write("\n");
+      throw new Error(frame.error);
+    }
+  }
+}
+var chatCmd = defineCommand({
+  meta: { name: "chat", description: "Chat with an agent" },
+  args: {
+    id: { type: "positional", required: true },
+    message: {
+      type: "string",
+      description: "Send a single message and exit (one-shot mode)"
+    }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const resolved = await client.get(`/api/agents/${args.id}`);
+    if (args.message) {
+      await streamTurn(client, resolved.agent.id, args.message);
+      return;
+    }
+    console.log(`chatting with ${resolved.agent.name} (${resolved.model})`);
+    console.log("(type /exit to quit)");
+    const rl = createInterface({ input: stdin, output: stdout });
+    rl.setPrompt("> ");
+    rl.prompt();
+    for await (const line of rl) {
+      const trimmed = line.trim();
+      if (trimmed === "/exit" || trimmed === "/quit") break;
+      if (!trimmed) {
+        rl.prompt();
+        continue;
+      }
+      try {
+        await streamTurn(client, resolved.agent.id, trimmed);
+      } catch (err) {
+        console.error(`error: ${err.message}`);
+      }
+      rl.prompt();
+    }
+    rl.close();
+  }
+});
+var chatResetCmd = defineCommand({
+  meta: { name: "chat-reset", description: "Reset an agent's chat history to empty" },
+  args: {
+    id: { type: "positional", required: true },
+    force: { type: "boolean", description: "Skip the y/N prompt" }
+  },
+  async run({ args }) {
+    if (!args.force) {
+      process.stdout.write(`reset all chat history for ${args.id}? [y/N] `);
+      const answer = await new Promise((resolve3) => {
+        process.stdin.once("data", (d) => resolve3(String(d).trim().toLowerCase()));
+      });
+      if (answer !== "y" && answer !== "yes") {
+        console.log("aborted");
+        return;
+      }
+    }
+    const client = createClient2();
+    await client.post(`/api/agents/${args.id}/chat/reset`);
+    console.log(`reset chat history for ${args.id}`);
+  }
+});
+var chatTrimCmd = defineCommand({
+  meta: {
+    name: "chat-trim",
+    description: "Keep the first N messages of an agent's chat history; drop the rest"
+  },
+  args: {
+    id: { type: "positional", required: true },
+    keep: { type: "string", required: true, description: "Number of leading messages to keep" }
+  },
+  async run({ args }) {
+    const n = Number(args.keep);
+    if (!Number.isFinite(n) || n < 0 || !Number.isInteger(n)) {
+      throw new Error("--keep must be a non-negative integer");
+    }
+    const client = createClient2();
+    const body = { keepCount: n };
+    const res = await client.post(
+      `/api/agents/${args.id}/chat/truncate`,
+      body
+    );
+    console.log(
+      `trimmed: ${res.before} \u2192 ${res.after} messages (${res.before - res.after} dropped)`
+    );
+  }
+});
+function formatBytes(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KiB`;
+  return `${(n / (1024 * 1024)).toFixed(2)} MiB`;
+}
+var chatContextCmd = defineCommand({
+  meta: {
+    name: "chat-context",
+    description: "Break down what consumes the agent's context window"
+  },
+  args: {
+    id: { type: "positional", required: true },
+    detail: {
+      type: "boolean",
+      description: "Include every tool/skill entry instead of the top 30"
+    },
+    json: { type: "boolean", description: "Emit raw JSON instead of a human report" }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const query = args.detail || args.json ? "?detail=1" : "";
+    const ctx = await client.get(`/api/agents/${args.id}/chat/context${query}`);
+    if (args.json) {
+      console.log(JSON.stringify(ctx, null, 2));
+      return;
+    }
+    const fmt = (chars, tokens) => `${chars.toLocaleString()} chars (~${tokens.toLocaleString()} tok)`;
+    console.log(`\u{1F9E0} context for ${ctx.agentId}`);
+    console.log(`model: ${ctx.model}`);
+    console.log("");
+    console.log("## system prompt");
+    console.log(`  total: ${fmt(ctx.systemPrompt.chars, ctx.systemPrompt.tokens)}`);
+    if (ctx.systemPrompt.files.length > 0) {
+      console.log("  profile files:");
+      for (const f of ctx.systemPrompt.files) {
+        console.log(`    - ${f.name}: ${fmt(f.chars, f.tokens)}`);
+      }
+    }
+    if (ctx.systemPrompt.skillsListChars > 0) {
+      console.log(`  skills line: ${ctx.systemPrompt.skillsListChars.toLocaleString()} chars`);
+    }
+    if (ctx.systemPrompt.groupListChars > 0) {
+      console.log(`  group block: ${ctx.systemPrompt.groupListChars.toLocaleString()} chars`);
+    }
+    if (ctx.systemPrompt.userMdChars > 0) {
+      console.log(`  user_md block: ${ctx.systemPrompt.userMdChars.toLocaleString()} chars`);
+    }
+    console.log(`  memory hint: ${ctx.systemPrompt.memoryHintChars.toLocaleString()} chars`);
+    console.log("");
+    console.log("## tools");
+    console.log(`  count: ${ctx.tools.count}`);
+    console.log(
+      `  schemas (JSON): ${ctx.tools.schemaChars.toLocaleString()} chars (~${estimate(ctx.tools.schemaChars).toLocaleString()} tok)`
+    );
+    console.log(`  list text: ${ctx.tools.listChars.toLocaleString()} chars`);
+    if (ctx.tools.entries.length > 0) {
+      console.log("  top tools by schema size:");
+      for (const t of ctx.tools.entries) {
+        const params = t.paramCount != null ? ` (${t.paramCount} params)` : "";
+        console.log(`    - ${t.name}: ${t.schemaChars.toLocaleString()} chars${params}`);
+      }
+    }
+    console.log("");
+    if (ctx.skills.count > 0) {
+      console.log("## skills");
+      console.log(`  count: ${ctx.skills.count}`);
+      for (const s of ctx.skills.entries) {
+        console.log(`    - ${s.name}: ${s.blockChars.toLocaleString()} chars`);
+      }
+      console.log("");
+    }
+    console.log("## group");
+    console.log(`    - ${ctx.group.id} (${ctx.group.name}): ${ctx.group.path}`);
+    if (ctx.group.userMdChars > 0) {
+      console.log(`    user_md: ${ctx.group.userMdChars.toLocaleString()} chars`);
+    }
+    console.log("");
+    console.log("## history");
+    console.log(`  messages:    ${ctx.history.messageEntries}`);
+    console.log(`  compactions: ${ctx.history.compactionEntries}`);
+    console.log(`  total:       ${fmt(ctx.history.chars, ctx.history.tokensEstimate)}`);
+    console.log(`  bytes:       ${formatBytes(ctx.history.bytes)}`);
+    console.log("");
+    console.log(`TOTAL: ${fmt(ctx.totals.chars, ctx.totals.tokens)}`);
+  }
+});
+function estimate(chars) {
+  return Math.ceil(Math.max(0, chars) / 4);
+}
+var chatCompactCmd = defineCommand({
+  meta: {
+    name: "chat-compact",
+    description: "Summarize the head of an agent's chat log, preserving the tail verbatim"
+  },
+  args: {
+    id: { type: "positional", required: true },
+    "keep-tail": {
+      type: "string",
+      description: "Message entries to keep verbatim after the summary (default 10)"
+    },
+    instructions: {
+      type: "string",
+      description: "Optional extra guidance prepended to the summarizer prompt"
+    },
+    force: { type: "boolean", description: "Skip the y/N prompt" }
+  },
+  async run({ args }) {
+    if (!args.force) {
+      process.stdout.write(
+        `compact chat history for ${args.id}? head turns become a summary; tail is preserved. [y/N] `
+      );
+      const answer = await new Promise((resolve3) => {
+        process.stdin.once("data", (d) => resolve3(String(d).trim().toLowerCase()));
+      });
+      if (answer !== "y" && answer !== "yes") {
+        console.log("aborted");
+        return;
+      }
+    }
+    const keepTailNum = args["keep-tail"] ? Number(args["keep-tail"]) : void 0;
+    if (keepTailNum !== void 0 && (!Number.isFinite(keepTailNum) || keepTailNum < 0)) {
+      console.error("--keep-tail must be a non-negative integer");
+      process.exitCode = 1;
+      return;
+    }
+    const body = {};
+    if (keepTailNum !== void 0) body.keepTail = Math.floor(keepTailNum);
+    if (args.instructions) body.customInstructions = args.instructions;
+    const client = createClient2();
+    const res = await client.post(`/api/agents/${args.id}/chat/compact`, body);
+    console.log(
+      `compacted: ${res.before} \u2192 ${res.after} entries (${res.summarized} summarized, ${res.keptTail} tail kept verbatim)`
+    );
+    console.log(
+      `tokens: ~${res.tokensBefore.toLocaleString()} \u2192 ~${res.tokensAfter.toLocaleString()}`
+    );
+    console.log("");
+    console.log("summary:");
+    console.log(res.summary);
+  }
+});
+var skillAddCmd = defineCommand({
+  meta: { name: "add", description: "Attach a skill to an agent" },
+  args: {
+    agent: { type: "positional", required: true },
+    skill: { type: "positional", required: true }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const body = { skill: args.skill };
+    await client.post(`/api/agents/${args.agent}/skills`, body);
+    console.log(`attached skill ${args.skill} to ${args.agent}`);
+  }
+});
+var skillRmCmd = defineCommand({
+  meta: { name: "rm", description: "Detach a skill from an agent" },
+  args: {
+    agent: { type: "positional", required: true },
+    skill: { type: "positional", required: true }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    await client.del(`/api/agents/${args.agent}/skills/${encodeURIComponent(args.skill)}`);
+    console.log(`detached skill ${args.skill} from ${args.agent}`);
+  }
+});
+var skillCmd = defineCommand({
+  meta: { name: "skill", description: "Attach/detach skills on an agent" },
+  subCommands: {
+    add: skillAddCmd,
+    rm: skillRmCmd
+  }
+});
+var moveCmd = defineCommand({
+  meta: { name: "move", description: "Move an agent to a different group" },
+  args: {
+    agent: { type: "positional", required: true },
+    group: { type: "positional", required: true }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const body = { groupId: args.group };
+    await client.patch(`/api/agents/${args.agent}/group`, body);
+    console.log(`moved ${args.agent} to group ${args.group}`);
+  }
+});
+var sessionHeadCmd = defineCommand({
+  meta: {
+    name: "session-head",
+    description: "Print the agent's current session file head (for stale-tab checks)"
+  },
+  args: {
+    id: { type: "positional", required: true },
+    json: { type: "boolean", description: "Emit raw JSON instead of a human line" }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const head = await client.get(`/api/agents/${args.id}/sessions/head`);
+    if (args.json) {
+      console.log(JSON.stringify(head));
+      return;
+    }
+    console.log(head.file ? `${head.file} (${head.size} bytes)` : "(no session yet)");
+  }
+});
+var cancelCmd = defineCommand({
+  meta: { name: "cancel", description: "Abort the agent's currently-running turn" },
+  args: {
+    id: { type: "positional", required: true }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    await client.post(`/api/agents/${args.id}/cancel`);
+    console.log(`cancelled active turn for ${args.id}`);
+  }
+});
+var agentCommand = defineCommand({
+  meta: { name: "agent", description: "Manage agent instances" },
+  subCommands: {
+    spawn: spawnCmd,
+    list: listCmd,
+    show: showCmd,
+    edit: editCmd,
+    archive: archiveCmd,
+    unarchive: unarchiveCmd,
+    delete: deleteCmd,
+    chat: chatCmd,
+    "chat-reset": chatResetCmd,
+    "chat-trim": chatTrimCmd,
+    "chat-context": chatContextCmd,
+    "chat-compact": chatCompactCmd,
+    cancel: cancelCmd,
+    skill: skillCmd,
+    move: moveCmd,
+    "session-head": sessionHeadCmd
+  }
+});
+
+// src/commands/auth.ts
+import { loginOpenAICodex } from "@earendil-works/pi-ai/oauth";
+import { defineCommand as defineCommand2 } from "citty";
+function formatExpiry(ms) {
+  if (!ms) return "(unknown)";
+  const d = new Date(ms);
+  return d.toISOString().replace(/\.\d+Z$/, "Z");
+}
+var openaiLoginCmd = defineCommand2({
+  meta: {
+    name: "login",
+    description: "Connect your ChatGPT account via OAuth (browser sign-in)"
+  },
+  async run() {
+    const client = createClient2();
+    console.log("opening your browser for OpenAI sign-in...");
+    console.log("(if it doesn't open automatically, paste the URL shown below)");
+    const creds = await loginOpenAICodex({
+      onAuth: ({ url }) => {
+        console.log("");
+        console.log(`  \u2192 ${url}`);
+        console.log("");
+      },
+      onPrompt: async (prompt) => {
+        process.stdout.write(`${prompt.message}: `);
+        return new Promise((resolve3) => {
+          process.stdin.once("data", (d) => resolve3(String(d).trim()));
+        });
+      },
+      onProgress: (msg) => {
+        console.log(`  ${msg}`);
+      }
+    });
+    const status = await client.put("/api/auth/openai", {
+      refresh: creds.refresh,
+      access: creds.access,
+      expires: creds.expires
+    });
+    console.log("");
+    console.log("connected \u2713");
+    if (status.accountId) console.log(`account: ${status.accountId}`);
+    console.log(`access token expires: ${formatExpiry(status.expiresAt)}`);
+    console.log("");
+    console.log(`enable the 'openai-codex' provider on /config and add at least one model`);
+    console.log("(e.g. gpt-5.1-codex-max, gpt-5.2, gpt-5.3-codex) to start using it.");
+  }
+});
+var openaiLogoutCmd = defineCommand2({
+  meta: {
+    name: "logout",
+    description: "Forget the stored ChatGPT OAuth credentials"
+  },
+  async run() {
+    const client = createClient2();
+    await client.del("/api/auth/openai");
+    console.log("disconnected ChatGPT OAuth credentials");
+  }
+});
+var openaiStatusCmd = defineCommand2({
+  meta: {
+    name: "status",
+    description: "Show ChatGPT OAuth connection status"
+  },
+  async run() {
+    const client = createClient2();
+    const status = await client.get("/api/auth/openai");
+    if (!status.connected) {
+      console.log("not connected \u2014 run `bazilion auth openai login`");
+      return;
+    }
+    console.log("connected \u2713");
+    if (status.accountId) console.log(`account: ${status.accountId}`);
+    console.log(`access token expires: ${formatExpiry(status.expiresAt)}`);
+  }
+});
+var openaiCmd = defineCommand2({
+  meta: {
+    name: "openai",
+    description: "Manage ChatGPT (OAuth) authentication"
+  },
+  subCommands: {
+    login: openaiLoginCmd,
+    logout: openaiLogoutCmd,
+    status: openaiStatusCmd
+  }
+});
+var authCommand = defineCommand2({
+  meta: {
+    name: "auth",
+    description: "OAuth-based provider authentication (ChatGPT account, etc.)"
+  },
+  subCommands: {
+    openai: openaiCmd
+  }
+});
+
+// src/commands/backup.ts
+import { spawn } from "child_process";
+import { createWriteStream, existsSync as existsSync2, mkdirSync, readdirSync, rmSync } from "fs";
+import { resolve } from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+import { defineCommand as defineCommand3 } from "citty";
+var createCmd = defineCommand3({
+  meta: { name: "create", description: "Download a tar.gz backup of ~/.bazilion from the server" },
+  args: {
+    output: {
+      type: "positional",
+      required: false,
+      description: "Output file path (default: ./bazilion-backup-YYYY-MM-DD.tar.gz)"
+    }
+  },
+  async run({ args }) {
+    const cfg = loadClientConfig();
+    const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const outAbs = resolve(args.output ?? `bazilion-backup-${date}.tar.gz`);
+    console.log(`downloading backup \u2192 ${outAbs}`);
+    const res = await fetch(`${cfg.serverUrl}/api/backup`, {
+      headers: { authorization: `Bearer ${cfg.token}`, origin: cfg.serverUrl }
+    });
+    if (!res.ok || !res.body) {
+      let err = res.statusText;
+      try {
+        const body = await res.json();
+        err = body.error ?? err;
+      } catch {
+      }
+      throw new Error(`backup failed: ${err}`);
+    }
+    await pipeline(Readable.fromWeb(res.body), createWriteStream(outAbs));
+    console.log("done");
+  }
+});
+async function probeServerRunning(port) {
+  try {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), 500);
+    const res = await fetch(`http://127.0.0.1:${port}/login`, { signal: ctrl.signal });
+    clearTimeout(timer);
+    return res.status >= 200 && res.status < 600;
+  } catch {
+    return false;
+  }
+}
+var restoreCmd = defineCommand3({
+  meta: {
+    name: "restore",
+    description: "Extract a backup tar.gz into ~/.bazilion (offline; server must be stopped)"
+  },
+  args: {
+    file: {
+      type: "positional",
+      required: true,
+      description: "Path to tar.gz backup file"
+    },
+    home: { type: "string", description: "Override BAZILION_HOME" },
+    force: {
+      type: "boolean",
+      description: "Overwrite existing non-empty home (destroys existing data)"
+    }
+  },
+  async run({ args }) {
+    const file = resolve(args.file);
+    if (!existsSync2(file)) throw new Error(`backup file not found: ${file}`);
+    const paths = resolveCliPaths(args.home);
+    const targetHome = paths.home;
+    const defaultHome = !args.home && !process.env.BAZILION_HOME;
+    if (defaultHome && !args.force && await probeServerRunning(4321)) {
+      throw new Error(
+        "bazilion server appears to be running on :4321 \u2014 stop it first (DB corruption risk), or pass --force to override."
+      );
+    }
+    if (existsSync2(targetHome)) {
+      const entries = readdirSync(targetHome);
+      if (entries.length > 0) {
+        if (!args.force) {
+          throw new Error(
+            `${targetHome} is not empty. Pass --force to overwrite (destroys existing data).`
+          );
+        }
+        rmSync(targetHome, { recursive: true, force: true });
+      }
+    }
+    mkdirSync(targetHome, { recursive: true });
+    console.log(`extracting ${file} \u2192 ${targetHome}`);
+    await new Promise((res, rej) => {
+      const proc = spawn("tar", ["-xzf", file, "-C", targetHome], { stdio: "inherit" });
+      proc.on("error", rej);
+      proc.on("exit", (code) => {
+        if (code === 0) res();
+        else rej(new Error(`tar exited with code ${code}`));
+      });
+    });
+    console.log(`restored to ${targetHome}`);
+    console.log("start the server with: bazilion serve  (migrations apply automatically)");
+  }
+});
+var backupCommand = defineCommand3({
+  meta: { name: "backup", description: "Create or restore a ~/.bazilion tar.gz backup" },
+  subCommands: {
+    create: createCmd,
+    restore: restoreCmd
+  }
+  // `bazilion backup` with no positional falls through to citty's subcommand
+  // prompt ("No command specified"). The previous default (auto-download to
+  // cwd) double-fired when a subcommand was used because citty runs parent's
+  // `run` after the subcommand completes — explicit `create` / `restore` is
+  // the supported form now.
+});
+
+// src/commands/completion.ts
+import { defineCommand as defineCommand4 } from "citty";
+async function walk(cmd, path, out) {
+  const subsRaw = cmd.subCommands ?? {};
+  const subNames = Object.keys(subsRaw);
+  const flags = flagsOf(cmd.args ?? {});
+  out.push({ path, subs: subNames, flags });
+  for (const name of subNames) {
+    const v = subsRaw[name];
+    const sub = await Promise.resolve(v);
+    await walk(sub, [...path, name], out);
+  }
+}
+function flagsOf(args) {
+  const out = [];
+  for (const [name, def] of Object.entries(args)) {
+    if (def.type === "positional") continue;
+    out.push(`--${name}`);
+    const aliases = Array.isArray(def.alias) ? def.alias : def.alias ? [def.alias] : [];
+    for (const a of aliases) out.push(a.length === 1 ? `-${a}` : `--${a}`);
+  }
+  return out;
+}
+function bashScript(flat) {
+  const cases = flat.map((f) => {
+    const key = f.path.length === 0 ? '""' : JSON.stringify(f.path.join(" "));
+    const words = [...f.subs, ...f.flags].join(" ");
+    return `    ${key})
+      COMPREPLY=($(compgen -W ${JSON.stringify(words)} -- "$cur"))
+      ;;`;
+  }).join("\n");
+  return `# bazilion bash completion. Install with:
+#   source <(bazilion completion bash)
+# or append to ~/.bashrc / ~/.bash_profile.
+_bazilion_completion() {
+  local cur prev cword
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  cword=$COMP_CWORD
+  # Build the current subcommand path by walking words[1..cword-1], skipping
+  # flags and their values. We don't try to parse flag arity \u2014 treating every
+  # flag as standalone is a good-enough approximation for completion.
+  local cmd=""
+  local i
+  for ((i=1; i<cword; i++)); do
+    local w="\${COMP_WORDS[i]}"
+    [[ "$w" == -* ]] && continue
+    cmd+="\${cmd:+ }$w"
+  done
+  case "$cmd" in
+${cases}
+    *)
+      COMPREPLY=()
+      ;;
+  esac
+}
+complete -F _bazilion_completion bazilion
+`;
+}
+function zshScript(flat) {
+  const bash = bashScript(flat);
+  return `# bazilion zsh completion. Install with:
+#   source <(bazilion completion zsh)
+# If you don't already have bashcompinit loaded, this does it for you.
+autoload -U +X compinit && compinit
+autoload -U +X bashcompinit && bashcompinit
+${bash}`;
+}
+function fishScript(flat) {
+  const lines = [
+    "# bazilion fish completion. Install with:",
+    "#   bazilion completion fish | source",
+    "# or write it to ~/.config/fish/completions/bazilion.fish",
+    "",
+    "complete -c bazilion -f"
+  ];
+  for (const f of flat) {
+    if (f.path.length === 0) {
+      for (const s of f.subs) lines.push(`complete -c bazilion -n '__fish_use_subcommand' -a ${s}`);
+      for (const fl of f.flags) {
+        const long = fl.startsWith("--") ? fl.slice(2) : "";
+        const short = !fl.startsWith("--") ? fl.slice(1) : "";
+        const parts = ["complete -c bazilion -n '__fish_use_subcommand'"];
+        if (short) parts.push(`-s ${short}`);
+        if (long) parts.push(`-l ${long}`);
+        lines.push(parts.join(" "));
+      }
+    } else {
+      const guard = f.path.map((p) => `__fish_seen_subcommand_from ${p}`).join("; and ");
+      for (const s of f.subs) {
+        lines.push(`complete -c bazilion -n '${guard}' -a ${s}`);
+      }
+      for (const fl of f.flags) {
+        const long = fl.startsWith("--") ? fl.slice(2) : "";
+        const short = !fl.startsWith("--") ? fl.slice(1) : "";
+        const parts = [`complete -c bazilion -n '${guard}'`];
+        if (short) parts.push(`-s ${short}`);
+        if (long) parts.push(`-l ${long}`);
+        lines.push(parts.join(" "));
+      }
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+function completionCommand(main2) {
+  return defineCommand4({
+    meta: {
+      name: "completion",
+      description: "Print a shell completion script (bash, zsh, or fish)"
+    },
+    args: {
+      shell: {
+        type: "positional",
+        required: true,
+        description: "bash | zsh | fish"
+      }
+    },
+    async run({ args }) {
+      const flat = [];
+      await walk(main2, [], flat);
+      const shell = String(args.shell).toLowerCase();
+      if (shell === "bash") console.log(bashScript(flat));
+      else if (shell === "zsh") console.log(zshScript(flat));
+      else if (shell === "fish") console.log(fishScript(flat));
+      else throw new Error(`unsupported shell: ${args.shell} (want bash | zsh | fish)`);
+    }
+  });
+}
+
+// src/commands/config.ts
+import { defineCommand as defineCommand5 } from "citty";
+function displayValue(f) {
+  if (!f.set) return "(unset)";
+  if (f.kind === "secret") return f.preview ?? "(set)";
+  return f.value ?? "(set)";
+}
+var listCmd2 = defineCommand5({
+  meta: {
+    name: "list",
+    description: "List every configurable field (credentials + URLs) across all services"
+  },
+  async run() {
+    const client = createClient2();
+    const { providers } = await client.get("/api/config/providers");
+    const { services } = await client.get("/api/config/services");
+    const all = [...providers, ...services];
+    const rows = [];
+    for (const svc of all) {
+      for (const f of svc.fields) {
+        rows.push([svc.id, f.envVar, f.kind, displayValue(f)]);
+      }
+    }
+    if (rows.length === 0) {
+      console.log("(no fields registered)");
+      return;
+    }
+    for (const line of columnize(rows)) console.log(line);
+  }
+});
+var setCmd = defineCommand5({
+  meta: {
+    name: "set",
+    description: "Set a configurable field (auto-routes to secrets or plaintext store)"
+  },
+  args: {
+    envVar: {
+      type: "positional",
+      required: true,
+      description: "Env var name (e.g. ANTHROPIC_API_KEY, LMSTUDIO_URL)"
+    },
+    value: {
+      type: "positional",
+      required: true,
+      description: "New value (empty string clears the field)"
+    }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const body = { value: args.value };
+    const state = await client.put(
+      `/api/config/fields/${encodeURIComponent(args.envVar)}`,
+      body
+    );
+    console.log(`${state.envVar} (${state.kind}): ${displayValue(state)}`);
+  }
+});
+var rmCmd = defineCommand5({
+  meta: { name: "rm", description: "Remove a configurable field value" },
+  args: {
+    envVar: { type: "positional", required: true, description: "Env var name to clear" }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    await client.del(`/api/config/fields/${encodeURIComponent(args.envVar)}`);
+    console.log(`removed ${args.envVar}`);
+  }
+});
+var configCommand = defineCommand5({
+  meta: {
+    name: "config",
+    description: "Manage service configuration \u2014 credentials (encrypted) and URLs/IDs (plaintext), unified under one CLI"
+  },
+  subCommands: {
+    list: listCmd2,
+    set: setCmd,
+    rm: rmCmd
+  }
+});
+
+// src/commands/doctor.ts
+import { defineCommand as defineCommand6 } from "citty";
+var doctorCommand = defineCommand6({
+  meta: { name: "doctor", description: "Diagnose your bazilion install" },
+  async run() {
+    const client = createClient2();
+    const r = await client.get("/api/health");
+    function check(label, condition, hint) {
+      const mark = condition ? "\u2713" : "\u2717";
+      const tail = !condition && hint ? ` \u2014 ${hint}` : "";
+      console.log(`  ${mark} ${label}${tail}`);
+    }
+    console.log(`bazilion home: ${r.home}`);
+    console.log();
+    console.log("paths");
+    check("home dir exists", r.paths.home);
+    check("database exists", r.paths.db, "run: bazilion serve (auto-bootstraps on first run)");
+    check("auth.json exists", r.paths.auth, "run: bazilion serve (auto-bootstraps on first run)");
+    check("profiles dir exists", r.paths.profiles);
+    check("agents dir exists", r.paths.agents);
+    check("skills dir exists", r.paths.skills);
+    if (r.database) {
+      console.log();
+      console.log("database");
+      if (r.database.ok) {
+        console.log(`  ${r.database.profiles} profile(s)`);
+        console.log(
+          `  ${r.database.activeAgents} active agent(s) (${r.database.totalAgents} total)`
+        );
+        console.log(`  ${r.database.groups} group(s)`);
+      } else {
+        check("open database", false, r.database.error);
+      }
+    }
+    console.log();
+    console.log("skills library");
+    console.log(`  ${r.skills.installed} skill(s) installed`);
+    if (r.skills.parseErrors > 0) {
+      check("all skills parse", false, `${r.skills.parseErrors} skill(s) have errors`);
+    }
+    console.log();
+    console.log("providers (at least one needed for chat)");
+    if (r.providers.configured.length === 0) {
+      console.log("  - no cloud providers configured");
+      console.log("    (set e.g. ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY)");
+    } else {
+      for (const name of r.providers.configured) {
+        console.log(`  \u2713 ${name}`);
+      }
+    }
+    console.log(
+      `  \u2713 lmstudio: ${r.providers.lmstudio.baseURL}${r.providers.lmstudio.hasKey ? " (api key set)" : ""}`
+    );
+    console.log(`  \u2713 ollama:   ${r.providers.ollama.baseURL}`);
+    console.log();
+    console.log("web search (at least one needed for web_search tool)");
+    if (r.webSearch.bravePreview) {
+      console.log(`  \u2713 Brave Search (BRAVE_API_KEY set, ${r.webSearch.bravePreview})`);
+    } else {
+      console.log("  - Brave Search (set BRAVE_API_KEY \u2014 free at https://brave.com/search/api/)");
+    }
+    if (r.webSearch.searxngUrl) {
+      console.log(`  \u2713 SearXNG: ${r.webSearch.searxngUrl}`);
+    } else {
+      console.log("  - SearXNG (set SEARXNG_URL if you self-host one)");
+    }
+    if (!r.webSearch.bravePreview && !r.webSearch.searxngUrl) {
+      console.log("  \u26A0 no search backend \u2014 web_search will error until one is configured");
+    }
+    console.log();
+    console.log("openclaw integration");
+    if (r.openclaw.exists) {
+      console.log(`  \u2713 ${r.openclaw.path} found`);
+      console.log("    try: bazilion skill import --from openclaw");
+    } else {
+      console.log(`  - ${r.openclaw.path} not found (fine if you don't use OpenClaw)`);
+    }
+    console.log();
+    console.log("background jobs");
+    console.log(
+      `  ${r.scheduler.enabled ? "\u2713" : "-"} scheduler${r.scheduler.enabled ? ` (tick ${r.scheduler.tickMs}ms)` : " (BAZILION_SCHEDULER=off)"}`
+    );
+    console.log();
+    console.log("operational counts");
+    console.log(`  ${r.triggers.active} active trigger(s), ${r.triggers.disabled} disabled`);
+    console.log(`  ${r.tokens.active} active web token(s)`);
+    const anyCloudProvider = r.providers.configured.length > 0;
+    const hasProfiles = (r.database?.ok ? r.database.profiles : 0) > 0;
+    const hasAgents = (r.database?.ok ? r.database.totalAgents : 0) > 0;
+    console.log();
+    if (!r.ok) {
+      console.log("issues found \u2717");
+      process.exit(1);
+    }
+    if (!hasProfiles || !hasAgents) {
+      console.log("install is healthy, but not yet ready to run \u26A0");
+      const todo = [];
+      if (!anyCloudProvider) {
+        todo.push("  - set a cloud api key (ANTHROPIC_API_KEY / OPENAI_API_KEY / GEMINI_API_KEY)");
+        todo.push("    or make sure LMStudio / Ollama is running locally");
+      }
+      if (!hasProfiles) todo.push("  - create a profile: bazilion profile create <id> --model \u2026");
+      if (!hasAgents) todo.push("  - spawn an agent: bazilion agent spawn --profile <id>");
+      for (const line of todo) console.log(line);
+    } else {
+      console.log("all good \u2713");
+    }
+  }
+});
+
+// src/commands/group.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { stdin as stdin2 } from "process";
+import { defineCommand as defineCommand7 } from "citty";
+var addCmd = defineCommand7({
+  meta: {
+    name: "add",
+    description: "Register a group at ~/.bazilion/groups/<slug>/ (use --link to point at an existing tree)"
+  },
+  args: {
+    id: { type: "positional", required: true, description: "Group slug" },
+    name: { type: "string", description: "Display name (defaults to slug)" },
+    link: {
+      type: "string",
+      description: "Absolute path of an existing directory; the group slot becomes a symlink to it"
+    }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const body = {
+      id: args.id,
+      ...args.name ? { name: args.name } : {},
+      ...args.link ? { link: args.link } : {}
+    };
+    const g = await client.post("/api/groups", body);
+    console.log(`registered group ${g.id} at ${g.path}`);
+  }
+});
+var listCmd3 = defineCommand7({
+  meta: { name: "list", description: "List groups" },
+  async run() {
+    const client = createClient2();
+    const list = await client.get("/api/groups");
+    if (list.length === 0) {
+      console.log("(no groups)");
+      return;
+    }
+    const rows = list.map((g) => [g.id, g.path]);
+    for (const line of columnize(rows)) console.log(line);
+  }
+});
+var rmCmd2 = defineCommand7({
+  meta: { name: "rm", description: "Remove a group registration" },
+  args: {
+    id: { type: "positional", required: true }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    await client.del(`/api/groups/${args.id}`);
+    console.log(`removed group ${args.id}`);
+  }
+});
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of stdin2) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+var userMdShowCmd = defineCommand7({
+  meta: { name: "show", description: "Print the group's USER.md" },
+  args: { id: { type: "positional", required: true } },
+  async run({ args }) {
+    const client = createClient2();
+    const g = await client.get(`/api/groups/${args.id}`);
+    process.stdout.write(g.userMd);
+    if (g.userMd && !g.userMd.endsWith("\n")) process.stdout.write("\n");
+  }
+});
+var userMdSetCmd = defineCommand7({
+  meta: {
+    name: "set",
+    description: "Replace the group's USER.md (from --file, --from-stdin, or inline text)"
+  },
+  args: {
+    id: { type: "positional", required: true },
+    file: { type: "string", description: "Read content from a file path" },
+    "from-stdin": { type: "boolean", description: "Read content from stdin" },
+    text: { type: "string", description: "Inline content" }
+  },
+  async run({ args }) {
+    let content;
+    if (args["from-stdin"]) content = await readStdin();
+    else if (args.file) content = readFileSync2(args.file, "utf8");
+    else if (args.text !== void 0) content = args.text;
+    else {
+      console.error("group user-md set: provide --file, --from-stdin, or --text");
+      process.exit(2);
+    }
+    const client = createClient2();
+    const body = { userMd: content };
+    await client.put(`/api/groups/${args.id}/user-md`, body);
+    console.log(`updated USER.md for group ${args.id} (${content.length} bytes)`);
+  }
+});
+var userMdClearCmd = defineCommand7({
+  meta: { name: "clear", description: "Clear the group's USER.md to empty" },
+  args: { id: { type: "positional", required: true } },
+  async run({ args }) {
+    const client = createClient2();
+    const body = { userMd: "" };
+    await client.put(`/api/groups/${args.id}/user-md`, body);
+    console.log(`cleared USER.md for group ${args.id}`);
+  }
+});
+var userMdCmd = defineCommand7({
+  meta: { name: "user-md", description: "View or edit a group's USER.md" },
+  subCommands: {
+    show: userMdShowCmd,
+    set: userMdSetCmd,
+    clear: userMdClearCmd
+  }
+});
+var groupCommand = defineCommand7({
+  meta: { name: "group", description: "Manage groups (collaboration contexts)" },
+  subCommands: {
+    add: addCmd,
+    list: listCmd3,
+    rm: rmCmd2,
+    "user-md": userMdCmd
+  }
+});
+
+// src/commands/inbox.ts
+import { defineCommand as defineCommand8 } from "citty";
+function decodeText(payload) {
+  try {
+    const obj = JSON.parse(payload);
+    if (typeof obj.text === "string") return obj.text;
+  } catch {
+  }
+  return payload;
+}
+function messageRow(m) {
+  const when = new Date(m.createdAt).toISOString();
+  const state = m.readAt ? "read" : "NEW";
+  const text = decodeText(m.payload);
+  const preview = text.length > 60 ? `${text.slice(0, 60)}\u2026` : text;
+  return [m.id, state, when, `from:${m.fromAgentId.slice(0, 8)}`, `"${preview}"`];
+}
+var listCmd4 = defineCommand8({
+  meta: { name: "list", description: "List messages in an agent inbox" },
+  args: {
+    agent: { type: "positional", required: true, description: "Recipient agent id" },
+    unread: { type: "boolean", description: "Only show unread messages" }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const qs = args.unread ? "?unread=1" : "";
+    const { messages } = await client.get(
+      `/api/agents/${args.agent}/messages${qs}`
+    );
+    if (messages.length === 0) {
+      console.log(args.unread ? "(no unread messages)" : "(inbox empty)");
+      return;
+    }
+    for (const line of columnize(messages.map(messageRow))) console.log(line);
+  }
+});
+var showCmd2 = defineCommand8({
+  meta: { name: "show", description: "Show a single message in full" },
+  args: {
+    id: { type: "positional", required: true, description: "Message id" }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const m = await client.get(`/api/messages/${args.id}`);
+    const when = new Date(m.createdAt).toISOString();
+    const read = m.readAt ? new Date(m.readAt).toISOString() : "(unread)";
+    console.log(`id:        ${m.id}`);
+    console.log(`from:      ${m.fromAgentId}`);
+    console.log(`to:        ${m.toAgentId}`);
+    console.log(`created:   ${when}`);
+    console.log(`read:      ${read}`);
+    if (m.replyTo) console.log(`reply_to:  ${m.replyTo}`);
+    console.log("");
+    console.log(decodeText(m.payload));
+  }
+});
+var readCmd = defineCommand8({
+  meta: { name: "read", description: "Mark a message as read" },
+  args: {
+    id: { type: "positional", required: true, description: "Message id" }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    await client.patch(`/api/messages/${args.id}`, { read: true });
+    console.log(`marked read: ${args.id}`);
+  }
+});
+var inboxCommand = defineCommand8({
+  meta: { name: "inbox", description: "Inspect agent inboxes" },
+  subCommands: {
+    list: listCmd4,
+    show: showCmd2,
+    read: readCmd
+  }
+});
+
+// src/commands/login.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { defineCommand as defineCommand9 } from "citty";
+function normalizeServer(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new Error(`invalid --server URL: ${raw}`);
+  }
+  if (!/^https?:$/.test(url.protocol)) {
+    throw new Error(`--server must be http(s), got ${url.protocol}`);
+  }
+  return `${url.origin}${url.pathname.replace(/\/$/, "")}`;
+}
+async function verifyToken(server, token) {
+  const res = await fetch(`${server}/api/health`, {
+    headers: { authorization: `Bearer ${token}`, origin: server }
+  });
+  if (res.status === 401) throw new Error("server rejected token (401)");
+  if (!res.ok) throw new Error(`server returned ${res.status} from /api/health`);
+}
+var loginCommand = defineCommand9({
+  meta: {
+    name: "login",
+    description: "Save a remote bazilion server + token pair to auth.json"
+  },
+  args: {
+    server: { type: "string", description: "Remote server URL (http[s]://...)" },
+    token: { type: "string", description: "Token issued by `bazilion token create`" },
+    skipVerify: { type: "boolean", description: "Don't probe /api/health before saving" },
+    clear: { type: "boolean", description: "Remove the stored remote instead of setting one" }
+  },
+  async run({ args }) {
+    const paths = resolveCliPaths();
+    if (!existsSync3(paths.authFile)) {
+      throw new Error(
+        `${paths.authFile} not found. Start the daemon with "bazilion serve" first \u2014 login stores the remote there.`
+      );
+    }
+    const auth = JSON.parse(readFileSync3(paths.authFile, "utf8"));
+    if (args.clear) {
+      if (!auth.remote) {
+        console.log("no remote stored \u2014 nothing to clear");
+        return;
+      }
+      delete auth.remote;
+      writeFileSync(paths.authFile, `${JSON.stringify(auth, null, 2)}
+`, { mode: 384 });
+      console.log("cleared stored remote; CLI will fall back to the local daemon");
+      return;
+    }
+    if (!args.server || !args.token) {
+      throw new Error(
+        "--server and --token are required (or pass --clear to remove the stored remote)"
+      );
+    }
+    const server = normalizeServer(args.server);
+    if (!args.skipVerify) {
+      await verifyToken(server, args.token);
+    }
+    auth.remote = { server, token: args.token };
+    writeFileSync(paths.authFile, `${JSON.stringify(auth, null, 2)}
+`, { mode: 384 });
+    console.log(`saved remote: ${server}`);
+    console.log("CLI will now target this server unless BAZILION_SERVER is set in the env.");
+  }
+});
+
+// src/commands/memory.ts
+import { defineCommand as defineCommand10 } from "citty";
+function encodeKey(key) {
+  return key.split("/").map(encodeURIComponent).join("/");
+}
+var writeCmd = defineCommand10({
+  meta: { name: "write", description: "Write an entry into a group's shared memory" },
+  args: {
+    group: { type: "positional", required: true, description: "Group slug" },
+    key: { type: "positional", required: true, description: "Memory key (path under memory/)" },
+    content: { type: "positional", required: true, description: "Content to write" }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const entry2 = await client.put(
+      `/api/groups/${args.group}/memory/${encodeKey(args.key)}`,
+      { content: args.content }
+    );
+    console.log(`wrote ${entry2.key} (${entry2.content.length} bytes)`);
+  }
+});
+var readCmd2 = defineCommand10({
+  meta: { name: "read", description: "Read an entry from a group's shared memory" },
+  args: {
+    group: { type: "positional", required: true, description: "Group slug" },
+    key: { type: "positional", required: true }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const entry2 = await client.get(
+      `/api/groups/${args.group}/memory/${encodeKey(args.key)}`
+    );
+    console.log(entry2.content);
+  }
+});
+var searchCmd = defineCommand10({
+  meta: { name: "search", description: "Search a group's shared memory" },
+  args: {
+    group: { type: "positional", required: true, description: "Group slug" },
+    query: { type: "positional", required: true },
+    limit: { type: "string", description: "Max results (default 10)" }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const limit = args.limit ? Number.parseInt(args.limit, 10) : 10;
+    const params = new URLSearchParams({ q: args.query, limit: String(limit) });
+    const hits = await client.get(`/api/groups/${args.group}/memory/search?${params}`);
+    if (hits.length === 0) {
+      console.log("(no matches)");
+      return;
+    }
+    for (const h of hits) {
+      console.log(`${h.key}	${h.snippet.replaceAll("\n", " ")}`);
+    }
+  }
+});
+var listCmd5 = defineCommand10({
+  meta: { name: "list", description: "List all entries in a group's shared memory" },
+  args: {
+    group: { type: "positional", required: true, description: "Group slug" }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const all = await client.get(`/api/groups/${args.group}/memory`);
+    if (all.length === 0) {
+      console.log("(no memory entries)");
+      return;
+    }
+    for (const e of all) {
+      console.log(`${e.key}	${e.content.length}b`);
+    }
+  }
+});
+var rmCmd3 = defineCommand10({
+  meta: { name: "rm", description: "Remove an entry from a group's shared memory" },
+  args: {
+    group: { type: "positional", required: true, description: "Group slug" },
+    key: { type: "positional", required: true }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    await client.del(`/api/groups/${args.group}/memory/${encodeKey(args.key)}`);
+    console.log(`removed ${args.key}`);
+  }
+});
+var memoryCommand = defineCommand10({
+  meta: {
+    name: "memory",
+    description: "Manage a group's shared memory (BM25-indexed markdown notes)"
+  },
+  subCommands: {
+    write: writeCmd,
+    read: readCmd2,
+    search: searchCmd,
+    list: listCmd5,
+    rm: rmCmd3
+  }
+});
+
+// src/commands/profile.ts
+import { spawn as spawn2 } from "child_process";
+import { randomBytes } from "crypto";
+import { readFileSync as readFileSync4, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+
+// ../../packages/api-types/src/index.ts
+var PROFILE_FILES = [
+  "profile.json",
+  "SOUL.md",
+  "IDENTITY.md",
+  "BOOTSTRAP.md",
+  "AGENTS.md",
+  "TOOLS.md",
+  "HEARTBEAT.md"
+];
+
+// src/commands/profile.ts
+import { defineCommand as defineCommand11 } from "citty";
+function splitCsv(v) {
+  if (!v) return void 0;
+  const out = v.split(",").map((s) => s.trim()).filter(Boolean);
+  return out.length > 0 ? out : void 0;
+}
+function parseSkillsMode(v) {
+  if (v === void 0) return void 0;
+  if (v === "all" || v === "selected") return v;
+  throw new Error(`--skills-mode must be 'all' or 'selected', got '${v}'`);
+}
+var createCmd2 = defineCommand11({
+  meta: { name: "create", description: "Create a new profile" },
+  args: {
+    id: { type: "positional", required: true, description: "Profile slug" },
+    name: { type: "string", description: "Display name (defaults to slug)" },
+    model: {
+      type: "string",
+      required: true,
+      description: "Default model, e.g. anthropic:claude-opus-4-6"
+    },
+    "skills-mode": {
+      type: "string",
+      description: "'all' (attach every discovered skill) or 'selected' (default)"
+    },
+    skills: {
+      type: "string",
+      description: "Default skills, comma-separated (skills-mode=selected)"
+    },
+    "soul-file": {
+      type: "string",
+      description: "Path to custom SOUL.md content (defaults to the built-in template)"
+    },
+    "identity-file": {
+      type: "string",
+      description: "Path to custom IDENTITY.md content (defaults to the built-in template)"
+    },
+    "bootstrap-file": {
+      type: "string",
+      description: "Path to custom BOOTSTRAP.md content (defaults to the built-in template)"
+    },
+    "skip-bootstrap": {
+      type: "boolean",
+      description: "Skip the bootstrap file entirely (no first-run intro)"
+    },
+    "agents-file": {
+      type: "string",
+      description: "Path to AGENTS.md content (optional; omit to skip)"
+    },
+    "tools-file": {
+      type: "string",
+      description: "Path to TOOLS.md content (optional; omit to skip)"
+    },
+    "heartbeat-file": {
+      type: "string",
+      description: "Path to HEARTBEAT.md content (optional; omit to skip)"
+    }
+  },
+  async run({ args }) {
+    const skillsMode = parseSkillsMode(args["skills-mode"]);
+    const readTemplate = (path) => path ? readFileSync4(path, "utf8") : void 0;
+    const body = {
+      id: args.id,
+      name: args.name,
+      defaultModel: args.model,
+      skillsMode,
+      defaultSkills: splitCsv(args.skills),
+      soul: readTemplate(args["soul-file"]),
+      identity: readTemplate(args["identity-file"]),
+      bootstrap: args["skip-bootstrap"] ? null : readTemplate(args["bootstrap-file"]) ?? void 0,
+      agents: readTemplate(args["agents-file"]),
+      tools: readTemplate(args["tools-file"]),
+      heartbeat: readTemplate(args["heartbeat-file"])
+    };
+    const client = createClient2();
+    const profile = await client.post("/api/profiles", body);
+    console.log(`created profile ${profile.id} at ${profile.dir}`);
+  }
+});
+var listCmd6 = defineCommand11({
+  meta: { name: "list", description: "List profiles" },
+  async run() {
+    const client = createClient2();
+    const list = await client.get("/api/profiles");
+    if (list.length === 0) {
+      console.log("(no profiles)");
+      return;
+    }
+    const rows = list.map((p) => [p.id, p.defaultModel, p.name]);
+    for (const line of columnize(rows)) console.log(line);
+  }
+});
+var showCmd3 = defineCommand11({
+  meta: { name: "show", description: "Show profile details" },
+  args: {
+    id: { type: "positional", required: true }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const loaded = await client.get(`/api/profiles/${args.id}`);
+    console.log(`# ${loaded.profile.id}`);
+    console.log(`name:           ${loaded.profile.name}`);
+    console.log(`dir:            ${loaded.profile.dir}`);
+    console.log(`default model:  ${loaded.profile.defaultModel}`);
+    console.log(`skills mode:    ${loaded.profile.skillsMode}`);
+    console.log(
+      `default skills: ${loaded.defaultSkills.length === 0 ? "(none)" : loaded.defaultSkills.join(", ")}`
+    );
+    console.log(`bootstrap: ${loaded.files.bootstrap !== null ? "yes" : "no"}`);
+    console.log(`agents:    ${loaded.files.agents !== null ? "yes" : "no"}`);
+    console.log(`tools:     ${loaded.files.tools !== null ? "yes" : "no"}`);
+    console.log(`heartbeat: ${loaded.files.heartbeat !== null ? "yes" : "no"}`);
+    if (loaded.identity) {
+      const fields = Object.entries(loaded.identity).filter(([, v]) => typeof v === "string" && v.length > 0).map(([k, v]) => `${k}=${v}`).join(", ");
+      if (fields) console.log(`identity:  ${fields}`);
+    }
+  }
+});
+var editCmd2 = defineCommand11({
+  meta: { name: "edit", description: "Open a profile file in $EDITOR" },
+  args: {
+    id: { type: "positional", required: true },
+    file: {
+      type: "string",
+      default: "profile.json",
+      description: `File: ${PROFILE_FILES.join(", ")}`
+    }
+  },
+  async run({ args }) {
+    if (!PROFILE_FILES.includes(args.file)) {
+      throw new Error(`unsupported file: ${args.file}. Allowed: ${PROFILE_FILES.join(", ")}`);
+    }
+    const file = args.file;
+    const client = createClient2();
+    const { content } = await client.get(
+      `/api/profiles/${args.id}/files/${file}`
+    );
+    const tmpPath = join2(tmpdir(), `bazilion-${args.id}-${file}-${randomBytes(4).toString("hex")}`);
+    writeFileSync2(tmpPath, content);
+    try {
+      const editor = process.env.EDITOR ?? process.env.VISUAL ?? "vi";
+      const code = await new Promise((resolve3, reject) => {
+        const child = spawn2(editor, [tmpPath], { stdio: "inherit" });
+        child.on("error", reject);
+        child.on("close", (c) => resolve3(c ?? 0));
+      });
+      if (code !== 0) throw new Error(`editor exited with code ${code}`);
+      const updated = readFileSync4(tmpPath, "utf8");
+      if (updated === content) {
+        console.log("(no changes)");
+        return;
+      }
+      const body = { content: updated };
+      await client.put(`/api/profiles/${args.id}/files/${file}`, body);
+      console.log(`saved ${file}`);
+    } finally {
+      try {
+        rmSync2(tmpPath, { force: true });
+      } catch {
+      }
+    }
+  }
+});
+var updateCmd = defineCommand11({
+  meta: {
+    name: "update",
+    description: "Update profile settings (name, model, skills-mode, skills)"
+  },
+  args: {
+    id: { type: "positional", required: true },
+    name: { type: "string", description: "New display name" },
+    model: { type: "string", description: "New default model" },
+    "skills-mode": {
+      type: "string",
+      description: "Switch to 'all' or 'selected'"
+    },
+    skills: { type: "string", description: "Replacement default skills, comma-separated" }
+  },
+  async run({ args }) {
+    const body = {};
+    if (args.name !== void 0) body.name = args.name;
+    if (args.model !== void 0) body.defaultModel = args.model;
+    const mode = parseSkillsMode(args["skills-mode"]);
+    if (mode !== void 0) body.skillsMode = mode;
+    if (args.skills !== void 0) {
+      body.defaultSkills = args.skills.split(",").map((s) => s.trim()).filter(Boolean);
+    }
+    if (Object.keys(body).length === 0) {
+      throw new Error(
+        "nothing to update \u2014 pass at least one of --name/--model/--skills-mode/--skills"
+      );
+    }
+    const client = createClient2();
+    const profile = await client.patch(`/api/profiles/${args.id}`, body);
+    console.log(`updated profile ${profile.id}`);
+  }
+});
+var deleteCmd2 = defineCommand11({
+  meta: { name: "delete", description: "Permanently delete a profile and its files" },
+  args: {
+    id: { type: "positional", required: true }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    await client.del(`/api/profiles/${args.id}`);
+    console.log(`deleted profile ${args.id}`);
+  }
+});
+var profileCommand = defineCommand11({
+  meta: { name: "profile", description: "Manage profiles" },
+  subCommands: {
+    create: createCmd2,
+    list: listCmd6,
+    show: showCmd3,
+    edit: editCmd2,
+    update: updateCmd,
+    delete: deleteCmd2
+  }
+});
+
+// src/commands/provider.ts
+import { defineCommand as defineCommand12 } from "citty";
+var listCmd7 = defineCommand12({
+  meta: {
+    name: "list",
+    description: "List all providers with enabled/disabled state and curated model counts"
+  },
+  args: {
+    enabled: { type: "boolean", description: "Show only enabled providers" }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const { providers } = await client.get("/api/config/providers");
+    const filtered = args.enabled ? providers.filter((p) => p.enabled) : providers;
+    if (filtered.length === 0) {
+      console.log("(no providers to show)");
+      return;
+    }
+    const rows = filtered.map((p) => [
+      p.id,
+      p.enabled ? "enabled" : "disabled",
+      `${p.curated.length} curated`,
+      `${p.catalog.length} catalog`,
+      p.enabled ? "" : `(set ${p.envHint})`
+    ]);
+    for (const line of columnize(rows)) console.log(line);
+  }
+});
+var modelsCmd = defineCommand12({
+  meta: {
+    name: "models",
+    description: "Show curated + catalog + live models for one provider"
+  },
+  args: {
+    name: { type: "positional", required: true, description: "Provider name" }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const { providers } = await client.get("/api/config/providers");
+    const p = providers.find((x) => x.id === args.name);
+    if (!p) {
+      console.error(`unknown provider: ${args.name}`);
+      process.exit(1);
+    }
+    console.log(`# ${p.id} (${p.enabled ? "enabled" : "disabled"})`);
+    if (!p.enabled) console.log(`  (set ${p.envHint} to enable)`);
+    console.log("\n## curated");
+    if (p.curated.length === 0) console.log("  (none \u2014 use `provider models-set` to pin some)");
+    else for (const m of p.curated) console.log(`  ${m}`);
+    console.log("\n## catalog (from pi-ai)");
+    if (p.catalog.length === 0) console.log("  (empty)");
+    else for (const m of p.catalog) console.log(`  ${m}`);
+    if (p.live) {
+      console.log("\n## live (from upstream /v1/models)");
+      if (p.live.error) console.log(`  (error: ${p.live.error})`);
+      else if (p.live.models.length === 0) console.log("  (empty)");
+      else for (const m of p.live.models) console.log(`  ${m}`);
+    }
+  }
+});
+var modelsSetCmd = defineCommand12({
+  meta: {
+    name: "models-set",
+    description: "Replace the curated model list for a provider (comma-separated)"
+  },
+  args: {
+    name: { type: "positional", required: true, description: "Provider name" },
+    models: {
+      type: "positional",
+      required: true,
+      description: "Comma-separated model list (empty string clears the list)"
+    }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const models = args.models.split(",").map((s) => s.trim()).filter(Boolean);
+    const body = { models };
+    const saved = await client.put(
+      `/api/config/providers/${encodeURIComponent(args.name)}/models`,
+      body
+    );
+    console.log(`saved ${saved.models.length} curated model(s) for ${args.name}`);
+    for (const m of saved.models) console.log(`  ${m}`);
+  }
+});
+var enableCmd = defineCommand12({
+  meta: { name: "enable", description: "Toggle a provider on so agents can use it" },
+  args: {
+    name: { type: "positional", required: true, description: "Provider id (e.g. anthropic)" }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const res = await client.put(
+      `/api/config/providers/${encodeURIComponent(args.name)}/enabled`,
+      { enabled: true }
+    );
+    console.log(`${res.name}: enabled`);
+  }
+});
+var disableCmd = defineCommand12({
+  meta: {
+    name: "disable",
+    description: "Toggle a provider off \u2014 agents will refuse its model strings"
+  },
+  args: {
+    name: { type: "positional", required: true, description: "Provider id" }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const res = await client.put(
+      `/api/config/providers/${encodeURIComponent(args.name)}/enabled`,
+      { enabled: false }
+    );
+    console.log(`${res.name}: disabled`);
+  }
+});
+var testCmd = defineCommand12({
+  meta: { name: "test", description: "Send a single chat to a model and print the reply" },
+  args: {
+    model: {
+      type: "positional",
+      required: true,
+      description: "Model string, e.g. anthropic:claude-opus-4-6"
+    },
+    message: { type: "string", description: 'Message text (default "say hi briefly")' }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const body = { model: args.model, message: args.message };
+    console.log(`-> ${args.model}: ${args.message ?? "say hi briefly"}`);
+    const res = await client.post("/api/providers/test", body);
+    console.log(`<- ${res.content}`);
+    if (res.usage) {
+      console.log(`(${res.usage.promptTokens} in, ${res.usage.completionTokens} out)`);
+    }
+  }
+});
+var providerCommand = defineCommand12({
+  meta: { name: "provider", description: "Manage and test LLM providers" },
+  subCommands: {
+    list: listCmd7,
+    enable: enableCmd,
+    disable: disableCmd,
+    models: modelsCmd,
+    "models-set": modelsSetCmd,
+    test: testCmd
+  }
+});
+
+// src/commands/send.ts
+import { defineCommand as defineCommand13 } from "citty";
+var sendCommand = defineCommand13({
+  meta: {
+    name: "send",
+    description: "Send a message from one agent to another"
+  },
+  args: {
+    from: { type: "positional", required: true, description: "Sender agent id" },
+    to: { type: "positional", required: true, description: "Recipient agent id" },
+    message: { type: "positional", required: true, description: "Message text" }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const body = {
+      from: args.from,
+      payload: { text: args.message }
+    };
+    const msg = await client.post(`/api/agents/${args.to}/messages`, body);
+    console.log(`sent message ${msg.id}`);
+  }
+});
+
+// src/commands/serve.ts
+import { spawn as spawn3 } from "child_process";
+import { existsSync as existsSync4 } from "fs";
+import { join as join3 } from "path";
+import { defineCommand as defineCommand14 } from "citty";
+var bundledDaemonEntry = join3(import.meta.dirname, "daemon.js");
+var sourceDaemonEntry = join3(import.meta.dirname, "..", "..", "..", "daemon", "src", "index.ts");
+var daemonEntry = existsSync4(bundledDaemonEntry) ? bundledDaemonEntry : sourceDaemonEntry;
+var serveCommand = defineCommand14({
+  meta: {
+    name: "serve",
+    description: "Start the bazilion daemon (HTTP API)"
+  },
+  args: {
+    port: { type: "string", description: "Port (default 4321)" },
+    host: {
+      type: "string",
+      description: "Host (default 127.0.0.1). Put a TLS proxy in front before binding 0.0.0.0"
+    }
+  },
+  async run({ args }) {
+    if (!existsSync4(daemonEntry)) {
+      throw new Error(
+        `bazilion daemon not found at ${daemonEntry}. Are you running from a development checkout?`
+      );
+    }
+    const env = { ...process.env };
+    if (args.port) env.PORT = args.port;
+    if (args.host) env.HOST = args.host;
+    const host = args.host ?? "127.0.0.1";
+    const port = args.port ?? "4321";
+    if (host !== "127.0.0.1" && host !== "localhost" && host !== "::1") {
+      console.error("");
+      console.error(`\u26A0 binding to ${host} \u2014 the daemon is now reachable beyond loopback.`);
+      console.error("  anyone on this network who has a valid token can reach every API.");
+      console.error("  put a TLS proxy in front for untrusted networks.");
+      console.error("");
+    }
+    console.log(`starting bazilion daemon at http://${host}:${port}`);
+    console.log("(web UI runs separately: cd apps/web && pnpm dev)");
+    const nodeArgs = daemonEntry.endsWith(".ts") ? ["--import", "tsx/esm", daemonEntry] : [daemonEntry];
+    const proc = spawn3("node", nodeArgs, {
+      env,
+      stdio: "inherit"
+    });
+    let signalled = false;
+    const onSigterm = () => {
+      signalled = true;
+      try {
+        proc.kill("SIGTERM");
+      } catch {
+      }
+    };
+    process.on("SIGINT", () => {
+      signalled = true;
+    });
+    process.on("SIGTERM", onSigterm);
+    await new Promise((resolve3, reject) => {
+      proc.on("error", (err) => reject(err));
+      proc.on("close", (code) => {
+        if (signalled) {
+          process.exitCode = 0;
+          resolve3();
+        } else if (code === 0 || code === null) {
+          resolve3();
+        } else {
+          process.exitCode = code;
+          resolve3();
+        }
+      });
+    });
+  }
+});
+
+// src/commands/skill.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, statSync } from "fs";
+import { basename, resolve as resolve2 } from "path";
+import { defineCommand as defineCommand15 } from "citty";
+var listCmd8 = defineCommand15({
+  meta: { name: "list", description: "List installed skills (or those attached to an agent)" },
+  args: {
+    agent: { type: "string", description: "Filter to skills attached to this agent" }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    if (args.agent) {
+      const set = await client.get(`/api/agents/${args.agent}/skills`);
+      if (set.resolved.length === 0 && set.missing.length === 0) {
+        console.log("(no skills attached to this agent)");
+        return;
+      }
+      const rows2 = set.resolved.map((s) => [s.name, s.description]);
+      for (const line of columnize(rows2)) console.log(line);
+      for (const m of set.missing) {
+        console.log(`(missing: ${m.name} \u2014 ${m.reason})`);
+      }
+      return;
+    }
+    const skills = await client.get("/api/skills");
+    if (skills.length === 0) {
+      console.log('(no skills installed; use "bazilion skill import" to add some)');
+      return;
+    }
+    const rows = skills.map((s) => [
+      s.name,
+      s.parseError ? `(parse error: ${s.parseError})` : s.description
+    ]);
+    for (const line of columnize(rows)) console.log(line);
+  }
+});
+var importCmd = defineCommand15({
+  meta: {
+    name: "import",
+    description: "Import skills from openclaw, a directory, or a local .zip archive"
+  },
+  args: {
+    from: {
+      type: "string",
+      required: true,
+      description: 'Source: "openclaw", a filesystem path on the server, or a local .zip file to upload'
+    },
+    force: { type: "boolean", description: "Overwrite existing skills" }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const absFrom = resolve2(args.from);
+    const isLocalZip = args.from.toLowerCase().endsWith(".zip") && existsSync5(absFrom) && statSync(absFrom).isFile();
+    let result;
+    if (isLocalZip) {
+      const bytes = readFileSync5(absFrom);
+      const file = new File([bytes], basename(absFrom), { type: "application/zip" });
+      const fd = new FormData();
+      fd.set("file", file);
+      if (args.force) fd.set("force", "true");
+      result = await client.postMultipart("/api/skills/import", fd);
+    } else {
+      const body = {
+        source: args.from,
+        force: args.force
+      };
+      result = await client.post("/api/skills/import", body);
+    }
+    if (result.imported.length === 0 && result.skipped.length === 0) {
+      console.log("(nothing to import)");
+      return;
+    }
+    for (const name of result.imported) {
+      console.log(`imported ${name}`);
+    }
+    for (const s of result.skipped) {
+      console.log(`skipped ${s.name}: ${s.reason}`);
+    }
+  }
+});
+var rmCmd4 = defineCommand15({
+  meta: { name: "rm", description: "Remove an installed skill" },
+  args: {
+    name: { type: "positional", required: true }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    await client.del(`/api/skills/${encodeURIComponent(args.name)}`);
+    console.log(`removed skill ${args.name}`);
+  }
+});
+var skillCommand = defineCommand15({
+  meta: { name: "skill", description: "Manage the skill library" },
+  subCommands: {
+    list: listCmd8,
+    import: importCmd,
+    rm: rmCmd4
+  }
+});
+
+// src/commands/token.ts
+import { networkInterfaces } from "os";
+import { defineCommand as defineCommand16 } from "citty";
+import qrcode from "qrcode-terminal";
+function tokenRow(t) {
+  const last = t.lastUsedAt ? new Date(t.lastUsedAt).toISOString() : "(never)";
+  const state = t.revokedAt ? "revoked" : "active";
+  return [t.id, state, t.label, `last: ${last}`];
+}
+function detectLanOrigin(port) {
+  const candidates = [];
+  for (const ifs of Object.values(networkInterfaces())) {
+    for (const i of ifs ?? []) {
+      if (i.family === "IPv4" && !i.internal) candidates.push(i.address);
+    }
+  }
+  const [first, ...rest] = candidates;
+  if (!first) return null;
+  const origin = `http://${first}:${port}`;
+  return rest.length > 0 ? { origin, warning: `multiple LAN IPs found (${candidates.join(", ")}) \u2014 using ${first}` } : { origin };
+}
+function resolveQrServer(override) {
+  if (override) return override.replace(/\/$/, "");
+  const cfg = loadClientConfig();
+  const current = new URL(cfg.serverUrl);
+  const isLoopback = current.hostname === "127.0.0.1" || current.hostname === "localhost" || current.hostname === "::1";
+  if (!isLoopback) return cfg.serverUrl.replace(/\/$/, "");
+  const detected = detectLanOrigin(current.port || "4321");
+  if (!detected) {
+    throw new Error(
+      "server URL is loopback-only and no LAN interface was found. Pass --server http://<host>:<port> so the mobile client knows where to connect."
+    );
+  }
+  if (detected.warning) console.warn(`\u26A0 ${detected.warning}`);
+  return detected.origin;
+}
+var createCmd3 = defineCommand16({
+  meta: { name: "create", description: "Mint a new web token (shown once)" },
+  args: {
+    label: { type: "positional", required: true, description: "Human-readable label" },
+    qr: {
+      type: "boolean",
+      description: "Also render a pairing QR code for mobile clients (bazilion://pair?...)"
+    },
+    server: {
+      type: "string",
+      description: "Server URL to embed in the pairing QR (default: detect LAN IP; ignored without --qr)"
+    }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const body = { label: args.label };
+    const res = await client.post("/api/tokens", body);
+    console.log(`id:    ${res.meta.id}`);
+    console.log(`label: ${res.meta.label}`);
+    console.log(`token: ${res.token}`);
+    console.log("");
+    console.log("store the token now \u2014 it is not recoverable later.");
+    if (!args.qr) return;
+    const serverUrl = resolveQrServer(args.server);
+    const pairUrl = `bazilion://pair?server=${encodeURIComponent(serverUrl)}&token=${encodeURIComponent(res.token)}`;
+    console.log("");
+    console.log(`pairing URL: ${pairUrl}`);
+    console.log("");
+    qrcode.generate(pairUrl, { small: true }, (qr) => console.log(qr));
+  }
+});
+var listCmd9 = defineCommand16({
+  meta: { name: "list", description: "List web tokens" },
+  args: {
+    all: { type: "boolean", description: "Include revoked tokens" }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const qs = args.all ? "?includeRevoked=1" : "";
+    const { tokens } = await client.get(`/api/tokens${qs}`);
+    if (tokens.length === 0) {
+      console.log("(no tokens)");
+      return;
+    }
+    for (const line of columnize(tokens.map(tokenRow))) console.log(line);
+  }
+});
+var showLocalCmd = defineCommand16({
+  meta: {
+    name: "show-local",
+    description: "Print the bootstrap web token stored in ~/.bazilion/auth.json"
+  },
+  run() {
+    const paths = resolveCliPaths();
+    console.log(readAuthFile(paths.authFile).token);
+  }
+});
+var revokeCmd = defineCommand16({
+  meta: { name: "revoke", description: "Revoke a web token" },
+  args: {
+    id: { type: "positional", required: true }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    await client.del(`/api/tokens/${args.id}`);
+    console.log(`revoked token ${args.id}`);
+  }
+});
+var tokenCommand = defineCommand16({
+  meta: { name: "token", description: "Manage web tokens for API/CLI clients" },
+  subCommands: {
+    create: createCmd3,
+    list: listCmd9,
+    revoke: revokeCmd,
+    "show-local": showLocalCmd
+  }
+});
+
+// src/commands/trigger.ts
+import { defineCommand as defineCommand17 } from "citty";
+var addCmd2 = defineCommand17({
+  meta: { name: "add", description: "Add a heartbeat / cron trigger to an agent" },
+  args: {
+    agent: { type: "positional", required: true },
+    every: {
+      type: "string",
+      description: "Interval in seconds (e.g. --every 300 = every 5 minutes)"
+    },
+    cron: {
+      type: "string",
+      description: "Cron expression (5 fields: minute hour dom month dow)"
+    },
+    message: {
+      type: "string",
+      required: true,
+      description: "Message to inject when the trigger fires"
+    },
+    disabled: { type: "boolean", description: "Create in disabled state" }
+  },
+  async run({ args }) {
+    if (!args.every === !args.cron) {
+      throw new Error('specify exactly one of --every <seconds> or --cron "<expr>"');
+    }
+    const client = createClient2();
+    const body = args.every ? {
+      kind: "interval",
+      intervalSec: Number(args.every),
+      message: args.message,
+      enabled: !args.disabled
+    } : {
+      kind: "cron",
+      cronExpr: args.cron,
+      message: args.message,
+      enabled: !args.disabled
+    };
+    const res = await client.post(`/api/agents/${args.agent}/triggers`, body);
+    const t = res.trigger;
+    const spec = t.kind === "interval" ? `every ${t.intervalSec}s` : `cron "${t.cronExpr}"`;
+    console.log(`${t.id}	${spec}	${t.enabled ? "enabled" : "disabled"}`);
+  }
+});
+function triggerRow(t) {
+  const spec = t.kind === "interval" ? `every ${t.intervalSec}s` : `cron "${t.cronExpr}"`;
+  const last = t.lastFiredAt ? new Date(t.lastFiredAt).toISOString() : "(never)";
+  const state = t.enabled ? "enabled" : "disabled";
+  const msgPreview = t.message.length > 60 ? `${t.message.slice(0, 60)}\u2026` : t.message;
+  return [t.id, state, spec, `last: ${last}`, `"${msgPreview}"`];
+}
+var listCmd10 = defineCommand17({
+  meta: { name: "list", description: "List triggers for an agent" },
+  args: {
+    agent: { type: "positional", required: true }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const { triggers } = await client.get(
+      `/api/agents/${args.agent}/triggers`
+    );
+    if (triggers.length === 0) {
+      console.log("(no triggers)");
+      return;
+    }
+    for (const line of columnize(triggers.map(triggerRow))) console.log(line);
+  }
+});
+var rmCmd5 = defineCommand17({
+  meta: { name: "rm", description: "Delete a trigger" },
+  args: {
+    id: { type: "positional", required: true }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    await client.del(`/api/triggers/${args.id}`);
+    console.log(`removed trigger ${args.id}`);
+  }
+});
+var enableCmd2 = defineCommand17({
+  meta: { name: "enable", description: "Enable a trigger" },
+  args: {
+    id: { type: "positional", required: true }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const body = { enabled: true };
+    await client.patch(`/api/triggers/${args.id}`, body);
+    console.log(`enabled trigger ${args.id}`);
+  }
+});
+var disableCmd2 = defineCommand17({
+  meta: { name: "disable", description: "Disable a trigger" },
+  args: {
+    id: { type: "positional", required: true }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const body = { enabled: false };
+    await client.patch(`/api/triggers/${args.id}`, body);
+    console.log(`disabled trigger ${args.id}`);
+  }
+});
+var triggerCommand = defineCommand17({
+  meta: { name: "trigger", description: "Manage agent heartbeats / cron triggers" },
+  subCommands: {
+    add: addCmd2,
+    list: listCmd10,
+    rm: rmCmd5,
+    enable: enableCmd2,
+    disable: disableCmd2
+  }
+});
+
+// src/commands/uninstall.ts
+import { existsSync as existsSync6, readdirSync as readdirSync2, rmSync as rmSync3 } from "fs";
+import { join as join4 } from "path";
+import { defineCommand as defineCommand18 } from "citty";
+function makeLineReader() {
+  let buffer = "";
+  let ended = false;
+  const queue = [];
+  const tryDeliver = () => {
+    while (queue.length > 0) {
+      const nlIdx = buffer.indexOf("\n");
+      if (nlIdx === -1) {
+        if (ended) {
+          const resolve3 = queue.shift();
+          resolve3?.(buffer);
+          buffer = "";
+        } else {
+          return;
+        }
+      } else {
+        const line = buffer.slice(0, nlIdx);
+        buffer = buffer.slice(nlIdx + 1);
+        const resolve3 = queue.shift();
+        resolve3?.(line);
+      }
+    }
+  };
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", (chunk) => {
+    buffer += chunk;
+    tryDeliver();
+  });
+  process.stdin.on("end", () => {
+    ended = true;
+    tryDeliver();
+  });
+  return () => new Promise((resolve3) => {
+    queue.push(resolve3);
+    tryDeliver();
+  });
+}
+async function askYes(readLine, prompt) {
+  process.stdout.write(`${prompt} [y/N] `);
+  const answer = (await readLine()).trim().toLowerCase();
+  return answer === "y" || answer === "yes";
+}
+function removePath(p) {
+  if (!existsSync6(p)) return false;
+  rmSync3(p, { recursive: true, force: true });
+  return true;
+}
+var uninstallCommand = defineCommand18({
+  meta: {
+    name: "uninstall",
+    description: "Wipe bazilion state from ~/.bazilion (or BAZILION_HOME)"
+  },
+  args: {
+    home: { type: "string", description: "Override BAZILION_HOME" },
+    yes: {
+      type: "boolean",
+      description: "Skip confirmations (data tier only unless --all is set)"
+    },
+    all: {
+      type: "boolean",
+      description: "Also remove configs, logs, and skills (full wipe)"
+    }
+  },
+  async run({ args }) {
+    const paths = resolveCliPaths(args.home);
+    const dbFile = join4(paths.home, "bazilion.db");
+    const profilesDir = join4(paths.home, "profiles");
+    const agentsDir = join4(paths.home, "agents");
+    const groupsDir = join4(paths.home, "groups");
+    const skillsDir = join4(paths.home, "skills");
+    const logsDir = join4(paths.home, "logs");
+    if (!existsSync6(paths.home)) {
+      console.log(`nothing to remove: ${paths.home} does not exist`);
+      return;
+    }
+    console.log(`about to uninstall bazilion at ${paths.home}`);
+    console.log("");
+    const dataTargets = [
+      dbFile,
+      `${dbFile}-wal`,
+      `${dbFile}-shm`,
+      profilesDir,
+      agentsDir,
+      groupsDir
+    ];
+    const needsPrompt = !args.yes;
+    const readLine = needsPrompt ? makeLineReader() : null;
+    const wipeData = args.yes || await askYes(
+      readLine,
+      "remove DB + agent / profile / workspace data?"
+    );
+    if (!wipeData) {
+      console.log("aborted");
+      process.stdin.pause();
+      return;
+    }
+    const wipeAll = args.all || (args.yes ? false : await askYes(
+      readLine,
+      "also remove configs, logs, and skills? (full wipe of ~/.bazilion)"
+    ));
+    process.stdin.pause();
+    for (const p of dataTargets) {
+      if (removePath(p)) console.log(`removed ${p}`);
+    }
+    if (wipeAll) {
+      const configTargets = [paths.authFile, logsDir, skillsDir];
+      for (const p of configTargets) {
+        if (removePath(p)) console.log(`removed ${p}`);
+      }
+      if (readdirSync2(paths.home).length === 0) {
+        rmSync3(paths.home, { recursive: true, force: true });
+        console.log(`removed ${paths.home}`);
+      } else {
+        console.log(`${paths.home} still has unmanaged files; left in place`);
+      }
+    } else {
+      console.log("");
+      console.log("kept: auth.json, logs/, skills/");
+      console.log(`re-run 'bazilion serve' to recreate the DB when you're ready.`);
+    }
+  }
+});
+
+// src/index.ts
+var VERSION = package_default.version;
+var main = defineCommand19({
+  meta: {
+    name: "bazilion",
+    version: VERSION,
+    description: "Multi-agent runtime"
+  },
+  subCommands: {
+    login: loginCommand,
+    profile: profileCommand,
+    group: groupCommand,
+    agent: agentCommand,
+    skill: skillCommand,
+    memory: memoryCommand,
+    provider: providerCommand,
+    send: sendCommand,
+    inbox: inboxCommand,
+    config: configCommand,
+    serve: serveCommand,
+    doctor: doctorCommand,
+    backup: backupCommand,
+    trigger: triggerCommand,
+    token: tokenCommand,
+    auth: authCommand,
+    uninstall: uninstallCommand
+  }
+});
+main.subCommands.completion = completionCommand(main);
+async function resolveSubCommand(cmd, rawArgs, parent) {
+  const subs = cmd.subCommands;
+  if (subs && Object.keys(subs).length > 0) {
+    const idx = rawArgs.findIndex((a) => !a.startsWith("-"));
+    const name = idx >= 0 ? rawArgs[idx] : void 0;
+    if (name && subs[name]) {
+      return resolveSubCommand(subs[name], rawArgs.slice(idx + 1), cmd);
+    }
+  }
+  return [cmd, parent];
+}
+function printError(err) {
+  if (err instanceof ApiClientError) {
+    console.error(`error: ${err.body.error}`);
+    if (err.status === 401) {
+      console.error('  hint: token mismatch. Check ~/.bazilion/auth.json "token"');
+      console.error('        or re-run "bazilion login" for a remote server.');
+    } else if (err.status === 403) {
+      console.error("  hint: request was rejected by the server. If you hit this from a");
+      console.error("        fresh CLI build, check that BAZILION_SERVER matches the");
+      console.error("        server origin exactly (scheme + host + port).");
+    }
+    return;
+  }
+  const msg = err instanceof Error ? err.message : String(err);
+  console.error(`error: ${msg}`);
+  const cause = err instanceof Error ? err.cause : void 0;
+  const code = cause?.code;
+  if (code === "ECONNREFUSED" || /ECONNREFUSED/.test(msg)) {
+    console.error('  hint: the bazilion server is not running. Start it with "bazilion serve"');
+    console.error("        or point BAZILION_SERVER at a running instance.");
+  } else if (code === "ENOTFOUND" || /ENOTFOUND/.test(msg)) {
+    console.error("  hint: host not found. Check BAZILION_SERVER / ~/.bazilion/auth.json.");
+  }
+}
+function printTopLevelHelp() {
+  console.log(`Multi-agent runtime (bazilion v${VERSION})`);
+  console.log("");
+  console.log("USAGE bazilion <command> [args]");
+  console.log("");
+  const groups = [
+    {
+      title: "setup",
+      items: [
+        ["serve", "Start the bazilion daemon (auto-bootstraps ~/.bazilion on first run)"],
+        ["doctor", "Diagnose your bazilion install"],
+        ["uninstall", "Wipe bazilion state from ~/.bazilion (or BAZILION_HOME)"]
+      ]
+    },
+    {
+      title: "catalog",
+      items: [
+        ["profile", "Manage profiles (templates agents are spawned from)"],
+        ["group", "Manage groups (collaboration context \u2014 filesystem root + USER.md + roster)"],
+        ["skill", "Manage the skill library"],
+        ["provider", "Manage and test LLM providers"],
+        ["config", "Manage service config (credentials + URLs/IDs)"],
+        ["auth", "OAuth provider sign-in (ChatGPT account, \u2026)"]
+      ]
+    },
+    {
+      title: "agents",
+      items: [
+        ["agent", "Spawn, list, chat, archive agents"],
+        ["memory", "Read/write a group's shared memory"],
+        ["send", "Send a message from one agent to another"],
+        ["inbox", "Inspect agent inboxes"],
+        ["trigger", "Manage agent heartbeats / cron triggers"]
+      ]
+    },
+    {
+      title: "ops",
+      items: [["backup", "Download a tar.gz backup of ~/.bazilion"]]
+    },
+    {
+      title: "remote",
+      items: [
+        ["login", "Save a remote bazilion server + token pair to auth.json"],
+        ["token", "Manage web tokens for API/CLI clients"]
+      ]
+    },
+    {
+      title: "shell",
+      items: [["completion", "Print shell completion script (bash | zsh | fish)"]]
+    }
+  ];
+  const nameWidth = 12;
+  for (const g of groups) {
+    console.log(`  ${g.title}`);
+    for (const [name, desc] of g.items) {
+      console.log(`    ${name.padEnd(nameWidth)}${desc}`);
+    }
+    console.log("");
+  }
+  console.log("Use `bazilion <command> --help` for more information about a command.");
+}
+async function entry() {
+  const rawArgs = process.argv.slice(2);
+  try {
+    if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
+      const firstPositional = rawArgs.find((a) => !a.startsWith("-"));
+      if (!firstPositional) {
+        printTopLevelHelp();
+        process.exit(0);
+      }
+      const [target, parent] = await resolveSubCommand(main, rawArgs);
+      await showUsage(target, parent);
+      process.exit(0);
+    }
+    if (rawArgs.length === 1 && (rawArgs[0] === "--version" || rawArgs[0] === "-v")) {
+      console.log(VERSION);
+      return;
+    }
+    await runCommand(main, { rawArgs });
+  } catch (err) {
+    printError(err);
+    process.exit(1);
+  }
+}
+entry();
+//# sourceMappingURL=cli.js.map