botapp-cli 0.2.4 → 0.2.7

package/dist/index.js

@@ -1,6 +1,13 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/index.ts
-import { Command as Command20 } from "commander";
-import pc21 from "picocolors";
+import { Command as Command25 } from "commander";
+import pc26 from "picocolors";
 
 // src/commands/server.ts
 import { Command } from "commander";
@@ -151,11 +158,11 @@ function findServerEntry() {
 }
 
 // src/commands/daemon.ts
-import { spawn as spawn2 } from "child_process";
-import { randomUUID } from "crypto";
-import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync3, statSync } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join3, resolve as resolve3 } from "path";
+import { spawn as spawn3 } from "child_process";
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync3, statSync as statSync3 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join5, resolve as resolve4 } from "path";
 import { createInterface as createInterface2 } from "readline";
 import { Command as Command3 } from "commander";
 import { WebSocket } from "ws";
@@ -187,7 +194,8 @@ function writeYaml(profiles) {
       server: p.server,
       daemonId: p.daemonId,
       daemonName: p.daemonName,
-      token: p.token
+      token: p.token,
+      ...p.userEmail ? { userEmail: p.userEmail } : {}
     };
   }
   writeFileSync2(DAEMON_FILE, stringify2({ profiles: map }), "utf-8");
@@ -227,7 +235,8 @@ function loadDaemonProfiles() {
         server: normalizeServer(value.server),
         daemonId: value.daemonId,
         daemonName: value.daemonName ?? value.daemonId,
-        token: value.token
+        token: value.token,
+        userEmail: value.userEmail
       });
     }
   }
@@ -266,7 +275,8 @@ function saveDaemonProfile(input2) {
     server,
     daemonId: input2.daemonId,
     daemonName: input2.daemonName ?? input2.daemonId,
-    token: input2.token
+    token: input2.token,
+    userEmail: input2.userEmail
   };
   writeYaml([...remaining, next]);
   return next;
@@ -483,7 +493,557 @@ async function daemonSelfRequest(server, token, path, opts) {
   return data;
 }
 
+// src/rpc/registry.ts
+var RpcRegistry = class {
+  handlers = /* @__PURE__ */ new Map();
+  register(op, handler) {
+    if (this.handlers.has(op)) {
+      throw new Error(`RPC op already registered: ${op}`);
+    }
+    this.handlers.set(op, handler);
+  }
+  get(op) {
+    return this.handlers.get(op);
+  }
+  has(op) {
+    return this.handlers.has(op);
+  }
+};
+var InternalRpcContext = class {
+  constructor(appName, rpcId, ws) {
+    this.appName = appName;
+    this.rpcId = rpcId;
+    this.ws = ws;
+  }
+  appName;
+  rpcId;
+  ws;
+  cancelled = false;
+  inputCallback = null;
+  cancelCallback = null;
+  pushChunk(payload) {
+    sendJson(this.ws, {
+      type: "daemon_rpc_stream",
+      rpcId: this.rpcId,
+      payload
+    });
+  }
+  isCancelled() {
+    return this.cancelled;
+  }
+  onInput(callback) {
+    this.inputCallback = callback;
+  }
+  onCancel(callback) {
+    this.cancelCallback = callback;
+  }
+  cancel() {
+    if (this.cancelled) return;
+    this.cancelled = true;
+    const cb = this.cancelCallback;
+    this.cancelCallback = null;
+    if (cb) {
+      try {
+        cb();
+      } catch {
+      }
+    }
+  }
+  receiveInput(payload) {
+    this.inputCallback?.(payload);
+  }
+};
+var RpcDispatcher = class {
+  constructor(registry, ws) {
+    this.registry = registry;
+    this.ws = ws;
+  }
+  registry;
+  ws;
+  inflight = /* @__PURE__ */ new Map();
+  /** Handle a `daemon_rpc_request` frame. */
+  async dispatchRequest(frame) {
+    const handler = this.registry.get(frame.op);
+    if (!handler) {
+      this.sendResponse(frame.rpcId, {
+        ok: false,
+        error: `unknown daemon RPC op: ${frame.op}`
+      });
+      return;
+    }
+    const ctx = new InternalRpcContext(
+      frame.appName ?? "unknown",
+      frame.rpcId,
+      this.ws
+    );
+    this.inflight.set(frame.rpcId, { ctx });
+    try {
+      const result = await handler(frame.params ?? {}, ctx);
+      if (this.inflight.has(frame.rpcId)) {
+        this.sendResponse(frame.rpcId, { ok: true, result });
+      }
+    } catch (e) {
+      if (this.inflight.has(frame.rpcId)) {
+        this.sendResponse(frame.rpcId, {
+          ok: false,
+          error: e?.message ?? String(e)
+        });
+      }
+    } finally {
+      this.inflight.delete(frame.rpcId);
+    }
+  }
+  /** Handle a `daemon_rpc_input` frame. */
+  dispatchInput(frame) {
+    const call = this.inflight.get(frame.rpcId);
+    if (!call) return;
+    call.ctx.receiveInput(frame.payload);
+  }
+  /** Handle a `daemon_rpc_cancel` frame. */
+  dispatchCancel(frame) {
+    const call = this.inflight.get(frame.rpcId);
+    if (!call) return;
+    call.ctx.cancel();
+  }
+  /** Cancel everything (called on socket close). */
+  shutdown() {
+    for (const [, call] of this.inflight) {
+      call.ctx.cancel();
+    }
+    this.inflight.clear();
+  }
+  sendResponse(rpcId, body) {
+    sendJson(this.ws, { type: "daemon_rpc_response", rpcId, ...body });
+  }
+};
+function sendJson(ws, frame) {
+  if (ws.readyState !== ws.OPEN) return;
+  ws.send(JSON.stringify(frame));
+}
+
+// src/rpc/file-handlers.ts
+import { Buffer as Buffer2 } from "buffer";
+import {
+  promises as fsp,
+  realpathSync,
+  statSync
+} from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname, isAbsolute, join as join3, relative, resolve as resolve3, sep } from "path";
+function registerFileHandlers(registry) {
+  registry.register("file.tree", fileTree);
+  registry.register("file.read", fileRead);
+  registry.register("file.write", fileWrite);
+  registry.register("file.stat", fileStat);
+  registry.register("file.mkdir", fileMkdir);
+  registry.register("file.delete", fileDelete);
+  registry.register("file.rename", fileRename);
+  registry.register("fs.browse", fsBrowse);
+  registry.register("fs.home", fsHome);
+  registry.register("fs.mkdir", fsMkdir);
+}
+function expandHome(p) {
+  if (p === "~") return homedir3();
+  if (p.startsWith("~/")) return join3(homedir3(), p.slice(2));
+  return p;
+}
+function resolveRoot(root) {
+  if (typeof root !== "string" || !root.trim()) {
+    throw new Error("file.*: `root` is required");
+  }
+  const expanded = expandHome(root);
+  if (!isAbsolute(expanded)) {
+    throw new Error(`file.*: \`root\` must be absolute (got "${root}")`);
+  }
+  try {
+    return realpathSync(expanded);
+  } catch {
+    return resolve3(expanded);
+  }
+}
+function jailedPath(root, sub) {
+  const canonicalRoot = resolveRoot(root);
+  const candidate = sub == null || sub === "" ? canonicalRoot : isAbsolute(sub) ? sub : resolve3(canonicalRoot, sub);
+  let realBase = candidate;
+  let tail = "";
+  while (true) {
+    try {
+      realBase = realpathSync(realBase);
+      break;
+    } catch {
+      const parent = dirname(realBase);
+      if (parent === realBase) {
+        realBase = candidate;
+        tail = "";
+        break;
+      }
+      tail = tail ? join3(realBase.slice(parent.length + 1), tail) : realBase.slice(parent.length + 1);
+      realBase = parent;
+    }
+  }
+  const final = tail ? join3(realBase, tail) : realBase;
+  const rel = relative(canonicalRoot, final);
+  if (rel.startsWith("..") || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
+    throw new Error(`file.*: path "${sub ?? ""}" escapes workspace root "${root}"`);
+  }
+  return final;
+}
+var DEFAULT_IGNORE = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  ".turbo",
+  "dist",
+  "build",
+  ".venv",
+  "__pycache__",
+  ".DS_Store"
+]);
+async function fileTree(params) {
+  const root = resolveRoot(params.root);
+  const start = jailedPath(params.root, params.path);
+  const depth = Math.max(0, params.depth ?? 1);
+  const ignore = /* @__PURE__ */ new Set([...DEFAULT_IGNORE, ...params.ignore ?? []]);
+  const out = [];
+  async function walk2(absDir, level) {
+    let entries;
+    try {
+      entries = await fsp.readdir(absDir, {
+        withFileTypes: true,
+        encoding: "utf8"
+      });
+    } catch (e) {
+      if (e?.code === "ENOENT" || e?.code === "ENOTDIR") return;
+      throw e;
+    }
+    entries.sort((a, b) => {
+      if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+    for (const entry of entries) {
+      if (ignore.has(entry.name)) continue;
+      const abs = join3(absDir, entry.name);
+      const rel = relative(root, abs);
+      let stat = null;
+      try {
+        stat = await fsp.stat(abs);
+      } catch {
+        continue;
+      }
+      const node = {
+        name: entry.name,
+        path: rel,
+        isDir: entry.isDirectory(),
+        size: entry.isFile() ? stat.size : void 0,
+        mtimeMs: stat.mtimeMs
+      };
+      out.push(node);
+      if (entry.isDirectory() && level < depth) {
+        await walk2(abs, level + 1);
+      }
+    }
+  }
+  await walk2(start, 1);
+  return out;
+}
+async function fileRead(params) {
+  const abs = jailedPath(params.root, params.path);
+  const maxBytes = params.maxBytes ?? 5 * 1024 * 1024;
+  const stat = await fsp.stat(abs);
+  if (!stat.isFile()) {
+    throw new Error(`file.read: not a file: ${params.path}`);
+  }
+  if (stat.size > maxBytes) {
+    throw new Error(
+      `file.read: file too large (${stat.size} bytes > ${maxBytes}). Pass maxBytes to override or chunk the read.`
+    );
+  }
+  const buf = await fsp.readFile(abs);
+  const encoding = params.encoding ?? "utf8";
+  return {
+    path: params.path,
+    content: encoding === "base64" ? buf.toString("base64") : buf.toString("utf8"),
+    encoding,
+    size: stat.size,
+    mtimeMs: stat.mtimeMs
+  };
+}
+async function fileWrite(params) {
+  const abs = jailedPath(params.root, params.path);
+  if (params.createDirs !== false) {
+    await fsp.mkdir(dirname(abs), { recursive: true });
+  }
+  const buf = (params.encoding ?? "utf8") === "base64" ? Buffer2.from(params.content, "base64") : Buffer2.from(params.content, "utf8");
+  await fsp.writeFile(abs, buf);
+  const stat = await fsp.stat(abs);
+  return { path: params.path, size: stat.size, mtimeMs: stat.mtimeMs };
+}
+async function fileStat(params) {
+  let abs;
+  try {
+    abs = params.path == null || params.path === "" ? expandHome(params.root) : jailedPath(params.root, params.path);
+  } catch (e) {
+    if (/escapes workspace root/.test(e?.message ?? "")) throw e;
+    return { exists: false, isFile: false, isDir: false, size: 0, mtimeMs: 0 };
+  }
+  try {
+    const stat = statSync(abs);
+    return {
+      exists: true,
+      isFile: stat.isFile(),
+      isDir: stat.isDirectory(),
+      size: stat.size,
+      mtimeMs: stat.mtimeMs
+    };
+  } catch {
+    return { exists: false, isFile: false, isDir: false, size: 0, mtimeMs: 0 };
+  }
+}
+async function fileMkdir(params) {
+  const abs = jailedPath(params.root, params.path);
+  await fsp.mkdir(abs, { recursive: true });
+  return { path: params.path };
+}
+async function fileDelete(params) {
+  const abs = jailedPath(params.root, params.path);
+  await fsp.rm(abs, { recursive: !!params.recursive, force: false });
+  return { path: params.path };
+}
+async function fileRename(params) {
+  const fromAbs = jailedPath(params.root, params.from);
+  const toAbs = jailedPath(params.root, params.to);
+  await fsp.rename(fromAbs, toAbs);
+  return { from: params.from, to: params.to };
+}
+async function fsBrowse(params) {
+  const expanded = expandHome(params.path ?? "~");
+  if (!isAbsolute(expanded)) {
+    throw new Error(`fs.browse: path must be absolute (got "${params.path}")`);
+  }
+  let resolved;
+  try {
+    resolved = realpathSync(expanded);
+  } catch {
+    resolved = resolve3(expanded);
+  }
+  let raw;
+  try {
+    raw = await fsp.readdir(resolved, {
+      withFileTypes: true,
+      encoding: "utf8"
+    });
+  } catch (e) {
+    throw new Error(`fs.browse: cannot read ${resolved}: ${e?.code ?? e?.message ?? e}`);
+  }
+  const entries = [];
+  for (const entry of raw) {
+    if (!params.showHidden && entry.name.startsWith(".")) continue;
+    const isDir = entry.isDirectory();
+    if (!isDir && !params.includeFiles) continue;
+    entries.push({
+      name: entry.name,
+      path: join3(resolved, entry.name),
+      isDir
+    });
+  }
+  entries.sort((a, b) => {
+    if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+  const parent = dirname(resolved);
+  return {
+    path: resolved,
+    parent: parent === resolved ? null : parent,
+    entries
+  };
+}
+async function fsHome() {
+  return { home: homedir3(), cwd: process.cwd() };
+}
+async function fsMkdir(params) {
+  const expanded = expandHome(params.path ?? "");
+  if (!expanded || !isAbsolute(expanded)) {
+    throw new Error(`fs.mkdir: path must be absolute (got "${params.path}")`);
+  }
+  await fsp.mkdir(expanded, { recursive: true });
+  return { path: expanded };
+}
+
+// src/rpc/pty-handlers.ts
+import { spawn as spawn2 } from "child_process";
+import { randomUUID } from "crypto";
+import { existsSync as existsSync4, statSync as statSync2 } from "fs";
+import { homedir as homedir4, platform } from "os";
+import { join as join4 } from "path";
+import { isAbsolute as isAbsolute2 } from "path";
+var handles = /* @__PURE__ */ new Map();
+function registerPtyHandlers(registry) {
+  registry.register("pty.spawn", ptySpawn);
+  registry.register("pty.write", ptyWrite);
+  registry.register("pty.resize", ptyResize);
+  registry.register("pty.kill", ptyKill);
+}
+async function ptySpawn(params, ctx) {
+  if (!params.cwd || typeof params.cwd !== "string" || !isAbsolute2(params.cwd)) {
+    throw new Error("pty.spawn: `cwd` is required and must be absolute");
+  }
+  let cwdStat;
+  try {
+    cwdStat = statSync2(params.cwd);
+  } catch {
+    throw new Error(`pty.spawn: cwd does not exist: ${params.cwd}`);
+  }
+  if (!cwdStat.isDirectory()) {
+    throw new Error(`pty.spawn: cwd is not a directory: ${params.cwd}`);
+  }
+  const command = params.command || defaultShell();
+  if (!existsSync4(command)) {
+    throw new Error(
+      `pty.spawn: shell binary not found: ${command} (set $SHELL in the daemon's environment, or pass an explicit \`command\`)`
+    );
+  }
+  const args = params.args ?? defaultShellArgs();
+  const env = { TERM: "xterm-256color" };
+  for (const [k, v] of Object.entries(process.env)) {
+    if (typeof v === "string") env[k] = v;
+  }
+  for (const [k, v] of Object.entries(params.env ?? {})) {
+    env[k] = v;
+  }
+  const cols = params.cols ?? 80;
+  const rows = params.rows ?? 24;
+  const handle = await openPty({ command, args, cwd: params.cwd, env, cols, rows, ctx });
+  handles.set(handle.handle.ptyId, handle.handle);
+  ctx.onInput((payload) => {
+    if (typeof payload === "string") handle.handle.write(payload);
+    else if (payload && typeof payload.data === "string") {
+      handle.handle.write(payload.data);
+    }
+  });
+  ctx.onCancel(() => {
+    handle.handle.kill("SIGTERM");
+    setTimeout(() => {
+      try {
+        handle.handle.kill("SIGKILL");
+      } catch {
+      }
+    }, 5e3).unref();
+  });
+  ctx.pushChunk({ kind: "mode", mode: handle.mode, ptyId: handle.handle.ptyId });
+  const exitCode = await handle.exited;
+  handles.delete(handle.handle.ptyId);
+  return { ptyId: handle.handle.ptyId, exitCode, mode: handle.mode };
+}
+async function ptyWrite(params) {
+  const handle = handles.get(params.ptyId);
+  if (!handle) throw new Error(`pty.write: unknown ptyId ${params.ptyId}`);
+  handle.write(params.data);
+  return { ok: true };
+}
+async function ptyResize(params) {
+  const handle = handles.get(params.ptyId);
+  if (!handle) throw new Error(`pty.resize: unknown ptyId ${params.ptyId}`);
+  handle.resize(params.cols, params.rows);
+  return { ok: true };
+}
+async function ptyKill(params) {
+  const handle = handles.get(params.ptyId);
+  if (!handle) throw new Error(`pty.kill: unknown ptyId ${params.ptyId}`);
+  handle.kill(params.signal ?? "SIGTERM");
+  return { ok: true };
+}
+async function openPty(opts) {
+  const nodePty = await loadNodePty();
+  if (nodePty) {
+    const proc2 = nodePty.spawn(opts.command, opts.args, {
+      name: "xterm-256color",
+      cols: opts.cols,
+      rows: opts.rows,
+      cwd: opts.cwd,
+      env: opts.env
+    });
+    const ptyId2 = randomUUID();
+    proc2.onData((data) => {
+      opts.ctx.pushChunk({ kind: "data", data });
+    });
+    const exited2 = new Promise((resolve11) => {
+      proc2.onExit(({ exitCode }) => {
+        resolve11(exitCode);
+      });
+    });
+    return {
+      mode: "pty",
+      exited: exited2,
+      handle: {
+        ptyId: ptyId2,
+        resize: (cols, rows) => proc2.resize(cols, rows),
+        write: (data) => proc2.write(data),
+        kill: (signal) => proc2.kill(signal)
+      }
+    };
+  }
+  const proc = spawn2(
+    opts.command,
+    opts.args,
+    {
+      cwd: opts.cwd,
+      env: opts.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    }
+  );
+  const ptyId = randomUUID();
+  proc.stdout.on("data", (chunk) => {
+    opts.ctx.pushChunk({ kind: "data", data: chunk.toString("utf8") });
+  });
+  proc.stderr.on("data", (chunk) => {
+    opts.ctx.pushChunk({ kind: "data", data: chunk.toString("utf8") });
+  });
+  const exited = new Promise((resolve11) => {
+    proc.on("close", (code) => resolve11(code));
+  });
+  return {
+    mode: "pipe",
+    exited,
+    handle: {
+      ptyId,
+      resize: () => {
+      },
+      write: (data) => {
+        proc.stdin.write(data);
+      },
+      kill: (signal) => {
+        proc.kill(signal ?? "SIGTERM");
+      }
+    }
+  };
+}
+var nodePtyCache = void 0;
+async function loadNodePty() {
+  if (nodePtyCache !== void 0) return nodePtyCache;
+  try {
+    const moduleName = "node-pty";
+    nodePtyCache = await import(moduleName);
+    return nodePtyCache;
+  } catch {
+    nodePtyCache = null;
+    return null;
+  }
+}
+function defaultShell() {
+  if (platform() === "win32") {
+    return process.env.COMSPEC || "cmd.exe";
+  }
+  return process.env.SHELL || "/bin/bash";
+}
+function defaultShellArgs() {
+  if (platform() === "win32") return [];
+  return ["-l", "-i"];
+}
+
 // src/commands/daemon.ts
+var rpcRegistry = new RpcRegistry();
+registerFileHandlers(rpcRegistry);
+registerPtyHandlers(rpcRegistry);
 var daemonCommand = new Command3("daemon").description("Manage and run the local botapp daemon");
 daemonCommand.command("run").description(
   "Run paired daemons and wait for server jobs. With no flags, runs every paired profile concurrently \u2014 so a single `bot daemon run` covers both local and remote pairings."
@@ -527,9 +1087,31 @@ function pickProfilesToRun(alias, server) {
   }
   return loadDaemonProfiles();
 }
+daemonCommand.command("unpair").description("Remove a paired profile from ~/.botapp/daemon.yaml (does not touch the server)").argument("<aliasOrServer>", "Profile alias (e.g. local) or server URL").action((aliasOrServer) => {
+  const removed = removeDaemonProfile(aliasOrServer);
+  if (!removed) {
+    console.error(pc3.red(`No paired profile matching "${aliasOrServer}".`));
+    process.exitCode = 1;
+    return;
+  }
+  console.log(pc3.green(`Removed daemon profile: ${aliasOrServer}`));
+});
+daemonCommand.command("list").alias("ls").description("List paired daemon profiles from ~/.botapp/daemon.yaml").action(() => {
+  const profiles = loadDaemonProfiles();
+  if (profiles.length === 0) {
+    console.log(pc3.dim("No paired daemons. Run `bot pair` to add one."));
+    return;
+  }
+  for (const p of profiles) {
+    console.log(pc3.bold(p.alias ?? p.server));
+    console.log(`  Server: ${p.server}`);
+    console.log(`  Daemon: ${p.daemonName} ${pc3.dim(`(${p.daemonId})`)}`);
+    console.log(`  User:   ${p.userEmail ?? pc3.dim("unknown \u2014 re-pair to capture")}`);
+  }
+});
 daemonCommand.command("stop").description("Stop the background daemon started by `bot launch`").action(async () => {
-  const pidFile = join3(homedir3(), ".botapp", "daemon.pid");
-  if (!existsSync4(pidFile)) {
+  const pidFile = join5(homedir5(), ".botapp", "daemon.pid");
+  if (!existsSync5(pidFile)) {
     console.log(pc3.yellow("No background daemon PID file found."));
     return;
   }
@@ -555,16 +1137,17 @@ daemonCommand.command("agent").description("Manage agents hosted by this daemon"
     for (const agent of data.agents ?? []) {
       console.log(`${pc3.bold(agent.name)} ${pc3.dim(`(${agent.id})`)}`);
       console.log(`  Kind:    ${agent.kind}`);
+      if (agent.model) console.log(`  Model:   ${agent.model}`);
       console.log(`  Command: ${agent.command} ${(agent.args ?? []).join(" ")}`);
       if (agent.cwd) console.log(`  CWD:     ${agent.cwd}`);
     }
   })
 ).addCommand(createDaemonAgentConfigCommand()).addCommand(
-  new Command3("add").description("Register a local agent command").argument("<name>", "Name, e.g. codex, claude-code, openclaw, hermes, or hermes-agent").requiredOption("--command <command>", "Executable command").option(
+  new Command3("add").description("Register a local agent command").argument("<name>", "Name, e.g. codex, claude-code, kimi, openclaw, hermes, or hermes-agent").requiredOption("--command <command>", "Executable command").option(
     "--kind <kind>",
-    "Agent adapter kind: acp, codex, claude-code, openclaw, hermes, hermes-agent, or shell",
+    "Agent adapter kind: acp, codex, claude-code, kimi, openclaw, hermes, hermes-agent, or shell",
     "acp"
-  ).option("--arg <arg...>", "Argument passed to the executable").option("--cwd <cwd>", "Working directory for the agent process").option("--env <entry...>", "Environment entries in KEY=VALUE form").option("--profile <alias>", "Daemon profile alias to register against").option("--server <url>", "Daemon profile by server URL").action(async (name, opts) => {
+  ).option("--arg <arg...>", "Argument passed to the executable").option("--cwd <cwd>", "Working directory for the agent process").option("--env <entry...>", "Environment entries in KEY=VALUE form").option("--model <model>", "Provider model to pass to the agent runtime").option("--profile <alias>", "Daemon profile alias to register against").option("--server <url>", "Daemon profile by server URL").action(async (name, opts) => {
     const profile = requireSelectedProfile(opts);
     if (!profile) return;
     const env = parseEnv(opts.env ?? []);
@@ -580,12 +1163,14 @@ daemonCommand.command("agent").description("Manage agents hosted by this daemon"
           command: opts.command,
           args: opts.arg ?? [],
           cwd: opts.cwd,
-          env
+          env,
+          model: opts.model
         }
       }
     );
     console.log(pc3.green(`Registered daemon agent: ${pc3.bold(data.agent.name)}`));
     console.log(`  ID:      ${data.agent.id}`);
+    if (data.agent.model) console.log(`  Model:   ${data.agent.model}`);
     console.log(`  Command: ${data.agent.command} ${(data.agent.args ?? []).join(" ")}`);
   })
 ).addCommand(
@@ -657,6 +1242,7 @@ function runDaemonSocket(wsUrl, setActiveWs) {
   return new Promise((resolveRun) => {
     const ws = new WebSocket(wsUrl);
     setActiveWs(ws);
+    const rpcDispatcher = new RpcDispatcher(rpcRegistry, ws);
     let opened = false;
     let superseded = false;
     let settled = false;
@@ -665,6 +1251,7 @@ function runDaemonSocket(wsUrl, setActiveWs) {
       if (settled) return;
       settled = true;
       if (ping) clearInterval(ping);
+      rpcDispatcher.shutdown();
       resolveRun({ opened, superseded });
     }
     ws.on("open", () => {
@@ -676,7 +1263,7 @@ function runDaemonSocket(wsUrl, setActiveWs) {
       }, 3e4);
     });
     ws.on("message", (raw) => {
-      void handleFrame(ws, raw.toString());
+      void handleFrame(ws, raw.toString(), rpcDispatcher);
     });
     ws.on("close", (code, reason) => {
       if (code === 4e3) superseded = true;
@@ -692,8 +1279,20 @@ function runDaemonSocket(wsUrl, setActiveWs) {
     });
   });
 }
-async function handleFrame(ws, raw) {
+async function handleFrame(ws, raw, rpcDispatcher) {
   const frame = JSON.parse(raw);
+  if (frame.type === "daemon_rpc_request") {
+    void rpcDispatcher.dispatchRequest(frame);
+    return;
+  }
+  if (frame.type === "daemon_rpc_input") {
+    rpcDispatcher.dispatchInput(frame);
+    return;
+  }
+  if (frame.type === "daemon_rpc_cancel") {
+    rpcDispatcher.dispatchCancel(frame);
+    return;
+  }
   if (frame.type === "daemon_job") {
     const job = frame.job;
     console.log(pc3.blue(`Running ${job.agent.name} job ${job.id}`));
@@ -737,7 +1336,10 @@ async function runAgentJob(job, update) {
   if (job.agent.kind === "claude-code" || job.agent.kind === "claude_code") {
     return runClaudeCodeAgent(job, update);
   }
-  if (job.agent.kind === "openclaw" || job.agent.kind === "kimiclaw") {
+  if (job.agent.kind === "kimi") {
+    return runKimiCodeAgent(job, update);
+  }
+  if (job.agent.kind === "openclaw") {
     return runOpenClawAgent(job, update);
   }
   if (job.agent.kind === "hermes" || job.agent.kind === "hermes-agent") {
@@ -749,7 +1351,7 @@ async function runAgentJob(job, update) {
   return runAcpAgent(job);
 }
 async function runShellAgent(job) {
-  const child = spawn2(job.agent.command, [...job.agent.args, job.query], {
+  const child = spawn3(job.agent.command, [...job.agent.args, job.query], {
     cwd: job.agent.cwd ?? process.cwd(),
     env: { ...process.env, ...job.agent.env ?? {} }
   });
@@ -761,7 +1363,7 @@ async function runShellAgent(job) {
   child.stderr.on("data", (chunk) => {
     stderr += chunk.toString();
   });
-  const code = await new Promise((resolve7) => child.on("close", resolve7));
+  const code = await new Promise((resolve11) => child.on("close", resolve11));
   if (code !== 0) {
     throw new Error(stderr.trim() || `Agent exited with code ${code}`);
   }
@@ -778,6 +1380,9 @@ async function runCodexAgent(job, update) {
   if (!args.includes("--skip-git-repo-check")) {
     args.push("--skip-git-repo-check");
   }
+  if (job.agent.model && !hasAnyFlag(args, ["--model", "-m"])) {
+    args.push("--model", job.agent.model);
+  }
   if (!hasAnyFlag(args, [
     "--sandbox",
     "-s",
@@ -789,7 +1394,7 @@ async function runCodexAgent(job, update) {
     args.push("--dangerously-bypass-approvals-and-sandbox");
   }
   args.push(job.query);
-  const child = spawn2(job.agent.command, args, {
+  const child = spawn3(job.agent.command, args, {
     cwd: job.agent.cwd ?? process.cwd(),
     env: { ...process.env, ...job.agent.env ?? {} },
     stdio: ["ignore", "pipe", "pipe"]
@@ -806,12 +1411,19 @@ async function runCodexAgent(job, update) {
     rawEvents: []
   };
   const toolCalls = /* @__PURE__ */ new Map();
+  const errors = [];
   function processLine(line) {
     if (!line.trim()) return;
     try {
       const event = JSON.parse(line);
       result.rawEvents.push(event);
       update({ kind: "codex_event", event });
+      if (event?.type === "error" && typeof event.message === "string") {
+        errors.push(event.message);
+      }
+      if (event?.type === "turn.failed" && typeof event.error?.message === "string") {
+        errors.push(event.error.message);
+      }
       if (event?.type === "item.completed" && event.item?.type === "agent_message") {
         if (typeof event.item.text === "string") {
           result.messages.push(event.item.text);
@@ -839,9 +1451,9 @@ async function runCodexAgent(job, update) {
   }
   const rl = createInterface2({ input: child.stdout });
   rl.on("line", processLine);
-  const code = await new Promise((resolve7) => child.on("close", resolve7));
+  const code = await new Promise((resolve11) => child.on("close", resolve11));
   if (code !== 0) {
-    throw new Error(stderr.trim() || `Codex exited with code ${code}`);
+    throw new Error(errors.at(-1) ?? (stderr.trim() || `Codex exited with code ${code}`));
   }
   result.text = result.messages.at(-1)?.trim() || "";
   result.toolCalls = [...toolCalls.values()];
@@ -858,6 +1470,9 @@ async function runClaudeCodeAgent(job, update) {
   if (!args.includes("--verbose")) {
     args.push("--verbose");
   }
+  if (job.agent.model && !hasAnyFlag(args, ["--model"])) {
+    args.push("--model", job.agent.model);
+  }
   if (!hasAnyFlag(args, [
     "--permission-mode",
     "--dangerously-skip-permissions",
@@ -869,7 +1484,7 @@ async function runClaudeCodeAgent(job, update) {
   if (resume && !args.includes("--resume")) {
     args.push("--resume", resume);
   }
-  const child = spawn2(job.agent.command, args, {
+  const child = spawn3(job.agent.command, args, {
     cwd: job.agent.cwd ?? process.cwd(),
     env: { ...process.env, ...job.agent.env ?? {} },
     stdio: ["pipe", "pipe", "pipe"]
@@ -880,6 +1495,9 @@ async function runClaudeCodeAgent(job, update) {
   child.stderr.on("data", (chunk) => {
     stderr += chunk.toString();
   });
+  const noiseLines = [];
+  const errorEvents = [];
+  const NOISE_TAIL = 6;
   const result = {
     kind: "claude-code",
     text: "",
@@ -937,11 +1555,19 @@ async function runClaudeCodeAgent(job, update) {
     try {
       event = JSON.parse(line);
     } catch {
+      noiseLines.push(line);
+      if (noiseLines.length > NOISE_TAIL) noiseLines.shift();
       return;
     }
     result.rawEvents.push(event);
     update({ kind: "claude_code_event", event });
     captureSessionId(event);
+    if (event && (event.is_error === true || event.subtype === "error" || event.type === "result" && event.is_error)) {
+      try {
+        errorEvents.push(JSON.stringify(event).slice(0, 1e3));
+      } catch {
+      }
+    }
     if (event.type === "assistant" && event.message?.content) {
       ingestAssistantContent(
         Array.isArray(event.message.content) ? event.message.content : []
@@ -960,9 +1586,148 @@ async function runClaudeCodeAgent(job, update) {
   }
   const rl = createInterface2({ input: child.stdout });
   rl.on("line", processLine);
-  const code = await new Promise((resolve7) => child.on("close", resolve7));
+  const code = await new Promise((resolve11) => child.on("close", resolve11));
   if (code !== 0) {
-    throw new Error(stderr.trim() || `Claude Code exited with code ${code}`);
+    const parts = [];
+    if (stderr.trim()) parts.push(stderr.trim());
+    if (errorEvents.length > 0) {
+      parts.push(`Error events: ${errorEvents.join(" | ")}`);
+    }
+    if (noiseLines.length > 0 && parts.length === 0) {
+      parts.push(`Last stdout lines: ${noiseLines.join(" | ").slice(-1500)}`);
+    }
+    if (parts.length === 0) {
+      parts.push(`Claude Code exited with code ${code} (no stderr or stdout output)`);
+    }
+    throw new Error(parts.join(" \u2014 "));
+  }
+  if (!result.text) {
+    result.text = result.messages.at(-1)?.trim() ?? "";
+  }
+  result.toolCalls = [...toolCalls.values()];
+  return JSON.stringify(result);
+}
+async function runKimiCodeAgent(job, update) {
+  const args = [...job.agent.args];
+  if (!args.includes("--print") && !args.includes("-p")) {
+    args.push("--print");
+  }
+  if (!args.includes("--output-format")) {
+    args.push("--output-format", "stream-json");
+  }
+  if (!hasAnyFlag(args, ["--yolo", "--yes", "-y"])) {
+    args.push("--yolo");
+  }
+  if (job.agent.model && !hasAnyFlag(args, ["--model", "-m"])) {
+    args.push("--model", job.agent.model);
+  }
+  const resume = job.resumeSessionId ?? job.agent.env?.KIMI_SESSION_ID ?? null;
+  if (resume && !hasAnyFlag(args, ["--session", "-S", "-r", "--resume", "--continue", "-C"])) {
+    args.push("-r", resume);
+  }
+  const cwd = job.agent.cwd ?? process.cwd();
+  let prompt = job.query;
+  if (!resume) {
+    const agentsMdPath = join5(cwd, "AGENTS.md");
+    if (existsSync5(agentsMdPath)) {
+      try {
+        const primer = readFileSync3(agentsMdPath, "utf-8").trim();
+        if (primer) {
+          prompt = `# System instructions (read carefully before responding)
+
+${primer}
+
+---
+
+# Your task
+
+${job.query}`;
+        }
+      } catch {
+      }
+    }
+  }
+  const child = spawn3(job.agent.command, args, {
+    cwd,
+    env: { ...process.env, ...job.agent.env ?? {} },
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  child.stdin.write(prompt);
+  child.stdin.end();
+  let stderr = "";
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+  const result = {
+    kind: "kimi",
+    text: "",
+    messages: [],
+    toolCalls: [],
+    sessionId: resume,
+    rawEvents: []
+  };
+  const toolCalls = /* @__PURE__ */ new Map();
+  function ingestAssistantContent(blocks) {
+    for (const block of blocks) {
+      if (!block || typeof block !== "object") continue;
+      if (block.type === "text" && typeof block.text === "string") {
+        result.messages.push(block.text);
+        update({ kind: "message", text: block.text });
+      }
+    }
+  }
+  function ingestToolCalls(calls) {
+    for (const call of calls) {
+      if (!call || typeof call !== "object") continue;
+      const id = typeof call.id === "string" ? call.id : null;
+      if (!id) continue;
+      const name = String(call.function?.name ?? call.name ?? "tool");
+      let input2 = call.function?.arguments ?? call.arguments;
+      if (typeof input2 === "string") {
+        try {
+          input2 = JSON.parse(input2);
+        } catch {
+        }
+      }
+      const next = { ...toolCalls.get(id) ?? {}, id, name, input: input2 };
+      toolCalls.set(id, next);
+      update({ kind: "tool_call", toolCall: next });
+    }
+  }
+  function ingestToolResult(event) {
+    const id = event?.tool_call_id;
+    if (typeof id !== "string") return;
+    const existing = toolCalls.get(id) ?? { id, name: "tool" };
+    const output2 = typeof event.content === "string" ? event.content : JSON.stringify(event.content);
+    const next = { ...existing, output: output2 };
+    toolCalls.set(id, next);
+    update({ kind: "tool_call", toolCall: next });
+  }
+  function processLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed[0] !== "{") return;
+    let event;
+    try {
+      event = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    result.rawEvents.push(event);
+    update({ kind: "kimi_event", event });
+    if (event.role === "assistant") {
+      if (Array.isArray(event.content)) ingestAssistantContent(event.content);
+      if (Array.isArray(event.tool_calls)) ingestToolCalls(event.tool_calls);
+    } else if (event.role === "tool") {
+      ingestToolResult(event);
+    }
+  }
+  const rl = createInterface2({ input: child.stdout });
+  rl.on("line", processLine);
+  const code = await new Promise((resolve11) => child.on("close", resolve11));
+  const resumeMatch = stderr.match(/To resume this session:\s*kimi\s+-r\s+([A-Za-z0-9_-]+)/);
+  if (resumeMatch) result.sessionId = resumeMatch[1];
+  if (code !== 0) {
+    throw new Error(stderr.trim() || `Kimi Code exited with code ${code}`);
   }
   if (!result.text) {
     result.text = result.messages.at(-1)?.trim() ?? "";
@@ -992,7 +1757,7 @@ async function runOpenClawAgent(job, update) {
   }
   let requestedSessionId = getFlagValue(args, "--session-id");
   if (!requestedSessionId) {
-    requestedSessionId = job.resumeSessionId || `botapp-${randomUUID()}`;
+    requestedSessionId = job.resumeSessionId || `botapp-${randomUUID2()}`;
     args.push("--session-id", requestedSessionId);
   }
   if (!hasFlag(args, "--verbose")) {
@@ -1002,7 +1767,7 @@ async function runOpenClawAgent(job, update) {
   const state = {
     startedAtMs: Date.now(),
     sessionDir,
-    sessionStorePath: join3(sessionDir, "sessions.json"),
+    sessionStorePath: join5(sessionDir, "sessions.json"),
     requestedSessionId,
     sessionKey: null,
     sessionId: null,
@@ -1026,14 +1791,23 @@ async function runOpenClawAgent(job, update) {
   };
   const toolCalls = /* @__PURE__ */ new Map();
   let stderr = "";
+  const stdoutLines = [];
   let stopPolling = false;
-  const child = spawn2(job.agent.command, args, {
+  const child = spawn3(job.agent.command, args, {
     cwd: job.agent.cwd ?? process.cwd(),
     env,
     stdio: ["ignore", "pipe", "pipe"]
   });
   const stdout = createInterface2({ input: child.stdout });
-  stdout.on("line", () => {
+  stdout.on("line", (line) => {
+    const text = line.trim();
+    if (!text) return;
+    stdoutLines.push(text);
+    const stdoutText = extractOpenClawStdoutText(text);
+    if (!stdoutText) return;
+    result.text = stdoutText;
+    result.messages.push(stdoutText);
+    update({ kind: "message", text: stdoutText });
   });
   const stderrReader = createInterface2({ input: child.stderr });
   stderrReader.on("line", (line) => {
@@ -1065,11 +1839,11 @@ async function runOpenClawAgent(job, update) {
   }
   result.sessionFile = state.selectedFile;
   result.toolCalls = [...toolCalls.values()];
-  result.text = result.text || result.messages.at(-1)?.trim() || "";
+  result.text = result.text || result.messages.at(-1)?.trim() || extractOpenClawStdoutText(stdoutLines.at(-1) ?? "") || "";
   if (code !== 0) {
     throw new Error(stderr.trim() || `OpenClaw exited with code ${code}`);
   }
-  if (!result.sessionId) {
+  if (!result.sessionId && !result.text && result.toolCalls.length === 0) {
     throw new Error(
       [
         "OpenClaw completed, but the session key was not resolved from sessions.json.",
@@ -1090,11 +1864,22 @@ async function runOpenClawAgent(job, update) {
   }
   return JSON.stringify(result);
 }
+function extractOpenClawStdoutText(line) {
+  const text = line.trim();
+  if (!text) return "";
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed && typeof parsed === "object") return JSON.stringify(parsed);
+    if (typeof parsed === "string") return parsed;
+  } catch {
+  }
+  return text;
+}
 function resolveOpenClawSessionDir(args, env) {
   const configured = env.BOTAPP_OPENCLAW_SESSION_DIR ?? env.OPENCLAW_SESSION_DIR;
   if (configured) return expandPath(configured);
   const agentName = resolveOpenClawAgentName(args);
-  return join3(homedir3(), ".openclaw", "agents", agentName, "sessions");
+  return join5(homedir5(), ".openclaw", "agents", agentName, "sessions");
 }
 function resolveOpenClawAgentName(args) {
   return getFlagValue(args, "--agent") ?? "main";
@@ -1103,7 +1888,7 @@ function snapshotOpenClawSessionOffsets(sessionDir) {
   const offsets = /* @__PURE__ */ new Map();
   for (const file of listOpenClawSessionFiles(sessionDir)) {
     try {
-      offsets.set(file, statSync(file).size);
+      offsets.set(file, statSync3(file).size);
     } catch {
     }
   }
@@ -1179,7 +1964,7 @@ function selectOpenClawSessionFile(state) {
   const files = listOpenClawSessionFiles(state.sessionDir);
   if (files.length === 0) return null;
   if (state.sessionId) {
-    const exact = join3(state.sessionDir, `${state.sessionId}.jsonl`);
+    const exact = join5(state.sessionDir, `${state.sessionId}.jsonl`);
     if (files.includes(exact)) return exact;
     const matching = files.filter((file) => file.includes(state.sessionId ?? ""));
     if (matching.length > 0) return newestFile(matching);
@@ -1187,7 +1972,7 @@ function selectOpenClawSessionFile(state) {
   if (files.length === 1) return files[0];
   const recent = files.filter((file) => {
     try {
-      return statSync(file).mtimeMs >= state.startedAtMs - 1e3;
+      return statSync3(file).mtimeMs >= state.startedAtMs - 1e3;
     } catch {
       return false;
     }
@@ -1196,10 +1981,10 @@ function selectOpenClawSessionFile(state) {
 }
 function listOpenClawSessionFiles(sessionDir) {
   try {
-    if (!existsSync4(sessionDir)) return [];
-    return readdirSync(sessionDir).filter((name) => name.endsWith(".jsonl")).map((name) => join3(sessionDir, name)).filter((file) => {
+    if (!existsSync5(sessionDir)) return [];
+    return readdirSync(sessionDir).filter((name) => name.endsWith(".jsonl")).map((name) => join5(sessionDir, name)).filter((file) => {
       try {
-        return statSync(file).isFile();
+        return statSync3(file).isFile();
       } catch {
         return false;
       }
@@ -1212,7 +1997,7 @@ function newestFile(files) {
   if (files.length === 0) return null;
   return files.reduce((selected, file) => {
     try {
-      return statSync(file).mtimeMs > statSync(selected).mtimeMs ? file : selected;
+      return statSync3(file).mtimeMs > statSync3(selected).mtimeMs ? file : selected;
     } catch {
       return selected;
     }
@@ -1336,7 +2121,7 @@ async function runHermesAgent(job, update) {
   let stderr = "";
   let stdoutText = "";
   let stopPolling = false;
-  const child = spawn2(job.agent.command, args, {
+  const child = spawn3(job.agent.command, args, {
     cwd: job.agent.cwd ?? process.cwd(),
     env,
     stdio: ["ignore", "pipe", "pipe"]
@@ -1403,10 +2188,10 @@ async function runHermesAgent(job, update) {
 function resolveHermesSessionDir(env) {
   const configured = env.BOTAPP_HERMES_SESSION_DIR ?? env.HERMES_SESSION_DIR;
   if (configured) return expandPath(configured);
-  return join3(homedir3(), ".hermes", "sessions");
+  return join5(homedir5(), ".hermes", "sessions");
 }
 function hermesSessionFile(sessionDir, sessionId) {
-  return join3(sessionDir, `session_${sessionId}.json`);
+  return join5(sessionDir, `session_${sessionId}.json`);
 }
 function parseHermesSessionId(text) {
   const match = text.match(/session_id:\s*([A-Za-z0-9_-]+)/);
@@ -1454,13 +2239,13 @@ function readHermesSessionUpdates(state, result, toolCalls, update, final = fals
 function selectHermesSessionFile(state) {
   if (state.resumeSessionId) {
     const exact = hermesSessionFile(state.sessionDir, state.resumeSessionId);
-    if (existsSync4(exact)) return exact;
+    if (existsSync5(exact)) return exact;
   }
   const files = listHermesSessionFiles(state.sessionDir);
   if (files.length === 0) return null;
   const recent = files.filter((file) => {
     try {
-      return statSync(file).mtimeMs >= state.startedAtMs - 1e3;
+      return statSync3(file).mtimeMs >= state.startedAtMs - 1e3;
     } catch {
       return false;
     }
@@ -1469,10 +2254,10 @@ function selectHermesSessionFile(state) {
 }
 function listHermesSessionFiles(sessionDir) {
   try {
-    if (!existsSync4(sessionDir)) return [];
-    return readdirSync(sessionDir).filter((name) => /^session_.+\.json$/.test(name)).map((name) => join3(sessionDir, name)).filter((file) => {
+    if (!existsSync5(sessionDir)) return [];
+    return readdirSync(sessionDir).filter((name) => /^session_.+\.json$/.test(name)).map((name) => join5(sessionDir, name)).filter((file) => {
       try {
-        return statSync(file).isFile();
+        return statSync3(file).isFile();
       } catch {
         return false;
       }
@@ -1492,7 +2277,7 @@ function ingestHermesMessage(message, result, toolCalls, update) {
     }
     if (Array.isArray(message.tool_calls)) {
       for (const call of message.tool_calls) {
-        const id = String(call?.id ?? call?.call_id ?? call?.response_item_id ?? randomUUID());
+        const id = String(call?.id ?? call?.call_id ?? call?.response_item_id ?? randomUUID2());
         const name = String(call?.function?.name ?? call?.name ?? "tool");
         const next = {
           ...toolCalls.get(id),
@@ -1521,7 +2306,7 @@ function ingestHermesMessage(message, result, toolCalls, update) {
   }
 }
 async function runAcpAgent(job) {
-  const child = spawn2(job.agent.command, job.agent.args, {
+  const child = spawn3(job.agent.command, job.agent.args, {
     cwd: job.agent.cwd ?? process.cwd(),
     env: { ...process.env, ...job.agent.env ?? {} },
     stdio: ["pipe", "pipe", "pipe"]
@@ -1577,8 +2362,8 @@ Invalid ACP stdout: ${line}`;
   function request2(method, params) {
     const id = nextId++;
     child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n");
-    return new Promise((resolve7, reject) => {
-      pending.set(id, { resolve: resolve7, reject });
+    return new Promise((resolve11, reject) => {
+      pending.set(id, { resolve: resolve11, reject });
     });
   }
   child.on("exit", (code) => {
@@ -1602,7 +2387,7 @@ Invalid ACP stdout: ${line}`;
       clientInfo: {
         name: "botapp-daemon",
         title: "botapp daemon",
-        version: "0.2.4"
+        version: "0.2.7"
       }
     });
     const session = await request2("session/new", {
@@ -1694,9 +2479,9 @@ function hasAnyFlag(args, flags) {
   return flags.some((flag) => hasFlag(args, flag));
 }
 function expandPath(path) {
-  if (path === "~") return homedir3();
-  if (path.startsWith("~/")) return join3(homedir3(), path.slice(2));
-  return resolve3(path);
+  if (path === "~") return homedir5();
+  if (path.startsWith("~/")) return join5(homedir5(), path.slice(2));
+  return resolve4(path);
 }
 function envNumber(env, name, fallback) {
   const value = env[name];
@@ -1752,10 +2537,10 @@ async function waitForChild(child, timeoutMs, label) {
 
 // src/commands/launch.ts
 import { Command as Command4 } from "commander";
-import { spawn as spawn4 } from "child_process";
-import { resolve as resolve4, join as join5 } from "path";
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, openSync, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir5 } from "os";
+import { spawn as spawn5 } from "child_process";
+import { resolve as resolve5, join as join7 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, openSync, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir7 } from "os";
 import { createInterface as createInterface3 } from "readline";
 import { hostname } from "os";
 import pc5 from "picocolors";
@@ -1763,7 +2548,7 @@ import pc5 from "picocolors";
 // src/auth/browser-auth.ts
 import { createServer } from "http";
 import { randomBytes } from "crypto";
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import pc4 from "picocolors";
 var OK_HTML = `<!doctype html>
 <meta charset="utf-8">
@@ -1858,11 +2643,11 @@ async function startLoopback(expectedState) {
   let rejectCb = () => {
   };
   let settled = false;
-  const callbackPromise = new Promise((resolve7, reject) => {
+  const callbackPromise = new Promise((resolve11, reject) => {
     resolveCb = (p) => {
       if (settled) return;
       settled = true;
-      resolve7(p);
+      resolve11(p);
     };
     rejectCb = (e) => {
       if (settled) return;
@@ -1873,11 +2658,11 @@ async function startLoopback(expectedState) {
   const server = createServer((req, res) => {
     void handleLoopback(req, res, expectedState, resolveCb, rejectCb);
   });
-  await new Promise((resolve7, reject) => {
+  await new Promise((resolve11, reject) => {
     server.once("error", reject);
     server.listen(0, "127.0.0.1", () => {
       server.removeListener("error", reject);
-      resolve7();
+      resolve11();
     });
   });
   const address = server.address();
@@ -1989,7 +2774,7 @@ function asString(v) {
   return typeof v === "string" ? v : void 0;
 }
 function readJsonBody(req) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve11, reject) => {
     const chunks = [];
     let total = 0;
     req.on("data", (c) => {
@@ -2003,9 +2788,9 @@ function readJsonBody(req) {
     });
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
-      if (!raw) return resolve7(null);
+      if (!raw) return resolve11(null);
       try {
-        resolve7(JSON.parse(raw));
+        resolve11(JSON.parse(raw));
       } catch (e) {
         reject(e);
       }
@@ -2017,20 +2802,20 @@ function openUrl(url) {
   const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
   const args = process.platform === "win32" ? ["/c", "start", '""', url] : [url];
   try {
-    spawn3(cmd, args, { stdio: "ignore", detached: true }).unref();
+    spawn4(cmd, args, { stdio: "ignore", detached: true }).unref();
   } catch {
   }
 }
 
 // src/commands/daemon-supervisor.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4, unlinkSync } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join4 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync4, unlinkSync } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join6 } from "path";
 function daemonPidFile() {
-  return join4(homedir4(), ".botapp", "daemon.pid");
+  return join6(homedir6(), ".botapp", "daemon.pid");
 }
 function isDaemonRunningLocally(pidFile = daemonPidFile()) {
-  if (!existsSync5(pidFile)) return false;
+  if (!existsSync6(pidFile)) return false;
   try {
     const pid = parseInt(readFileSync4(pidFile, "utf-8").trim(), 10);
     if (!Number.isInteger(pid) || pid <= 0) return false;
@@ -2177,7 +2962,8 @@ Configured for ${serverUrl}`));
           server: result.serverUrl ?? serverUrl,
           daemonId: data.daemon.id,
           daemonName: data.daemon.name,
-          token: data.token
+          token: data.token,
+          userEmail: result.userEmail
         });
         console.log(
           `  Daemon:  ${pc5.bold(data.daemon.name)} ${pc5.dim(`(${data.daemon.id})`)}` + pc5.dim(` profile=${savedProfile.alias}`)
@@ -2198,20 +2984,20 @@ async function autoStartDaemon(opts, serverUrl, daemonId) {
 Next: run \`bot daemon run\` to bring this machine online.`));
     return;
   }
-  const dir = join5(homedir5(), ".botapp");
-  const pidFile = join5(dir, "daemon.pid");
-  const logFile = join5(dir, "daemon.log");
+  const dir = join7(homedir7(), ".botapp");
+  const pidFile = join7(dir, "daemon.pid");
+  const logFile = join7(dir, "daemon.log");
   mkdirSync3(dir, { recursive: true });
   if (isDaemonRunningLocally(pidFile)) {
     stopExistingDaemon(pidFile);
   }
   const botBin = process.argv[1];
-  if (!botBin || !existsSync6(botBin)) {
+  if (!botBin || !existsSync7(botBin)) {
     console.log(pc5.yellow(`  Running: cannot resolve \`bot\` binary \u2014 run \`bot daemon run\` manually`));
     return;
   }
   const logFd = openSync(logFile, "a");
-  const child = spawn4(process.execPath, [botBin, "daemon", "run"], {
+  const child = spawn5(process.execPath, [botBin, "daemon", "run"], {
     stdio: ["ignore", logFd, logFd],
     detached: true
   });
@@ -2316,7 +3102,7 @@ Or run a local server from source:
     return false;
   }
   console.log(pc5.blue("Starting local server..."));
-  const child = spawn4("node", ["--import", "tsx", serverEntry], {
+  const child = spawn5("node", ["--import", "tsx", serverEntry], {
     env: { ...process.env, PORT: opts.port },
     stdio: opts.background ? "ignore" : "inherit",
     detached: opts.background
@@ -2333,12 +3119,12 @@ Or run a local server from source:
 }
 function findServerEntry2() {
   const candidates = [
-    resolve4(process.cwd(), "packages/server/src/index.ts"),
-    resolve4(process.cwd(), "../server/src/index.ts"),
-    resolve4(process.cwd(), "../../packages/server/src/index.ts")
+    resolve5(process.cwd(), "packages/server/src/index.ts"),
+    resolve5(process.cwd(), "../server/src/index.ts"),
+    resolve5(process.cwd(), "../../packages/server/src/index.ts")
   ];
   for (const c of candidates) {
-    if (existsSync6(c)) return c;
+    if (existsSync7(c)) return c;
   }
   return null;
 }
@@ -2540,21 +3326,21 @@ var loginCommand = new Command7("login").description("Login to a botapp server")
 
 // src/commands/install.ts
 import { Command as Command8 } from "commander";
-import { resolve as resolve5, basename } from "path";
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, symlinkSync, cpSync, readFileSync as readFileSync5 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join6 } from "path";
+import { resolve as resolve6, basename } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, symlinkSync, cpSync, readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join8 } from "path";
 import pc9 from "picocolors";
-var APPS_DIR = join6(homedir6(), ".botapp", "apps");
+var APPS_DIR = join8(homedir8(), ".botapp", "apps");
 var installCommand = new Command8("install").description("Install an app from a local path").argument("<path>", "Path to the app directory").option("--dev", "Install in dev mode (symlink)").action(async (appPath, opts) => {
-  const absPath = resolve5(appPath);
-  if (!existsSync7(absPath)) {
+  const absPath = resolve6(appPath);
+  if (!existsSync8(absPath)) {
     console.error(pc9.red(`Path not found: ${absPath}`));
     process.exitCode = 1;
     return;
   }
-  const manifestPath = join6(absPath, "botapp.app.json");
-  if (!existsSync7(manifestPath)) {
+  const manifestPath = join8(absPath, "botapp.app.json");
+  if (!existsSync8(manifestPath)) {
     console.error(pc9.red(`No botapp.app.json found in ${absPath}`));
     process.exitCode = 1;
     return;
@@ -2568,9 +3354,9 @@ var installCommand = new Command8("install").description("Install an app from a
     return;
   }
   const appName = manifest.name || basename(absPath);
-  const targetDir = join6(APPS_DIR, appName);
+  const targetDir = join8(APPS_DIR, appName);
   mkdirSync4(APPS_DIR, { recursive: true });
-  if (existsSync7(targetDir)) {
+  if (existsSync8(targetDir)) {
     console.log(pc9.yellow(`App "${appName}" is already installed. Reinstalling...`));
     const { rmSync: rmSync2 } = await import("fs");
     rmSync2(targetDir, { recursive: true, force: true });
@@ -2589,14 +3375,14 @@ var installCommand = new Command8("install").description("Install an app from a
 
 // src/commands/uninstall.ts
 import { Command as Command9 } from "commander";
-import { existsSync as existsSync8, rmSync } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join7 } from "path";
+import { existsSync as existsSync9, rmSync } from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join9 } from "path";
 import pc10 from "picocolors";
-var APPS_DIR2 = join7(homedir7(), ".botapp", "apps");
+var APPS_DIR2 = join9(homedir9(), ".botapp", "apps");
 var uninstallCommand = new Command9("uninstall").description("Uninstall an app").argument("<name>", "App name to uninstall").action(async (name) => {
-  const targetDir = join7(APPS_DIR2, name);
-  if (!existsSync8(targetDir)) {
+  const targetDir = join9(APPS_DIR2, name);
+  if (!existsSync9(targetDir)) {
     console.error(pc10.red(`App "${name}" is not installed`));
     process.exitCode = 1;
     return;
@@ -2608,21 +3394,21 @@ var uninstallCommand = new Command9("uninstall").description("Uninstall an app")
 
 // src/commands/dev.ts
 import { Command as Command10 } from "commander";
-import { resolve as resolve6, basename as basename2, join as join8 } from "path";
-import { existsSync as existsSync9, mkdirSync as mkdirSync5, symlinkSync as symlinkSync2, readFileSync as readFileSync6, lstatSync } from "fs";
-import { homedir as homedir8 } from "os";
-import { spawn as spawn5 } from "child_process";
+import { resolve as resolve7, basename as basename2, join as join10 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, symlinkSync as symlinkSync2, readFileSync as readFileSync6, lstatSync } from "fs";
+import { homedir as homedir10 } from "os";
+import { spawn as spawn6 } from "child_process";
 import pc11 from "picocolors";
-var APPS_DIR3 = join8(homedir8(), ".botapp", "apps");
+var APPS_DIR3 = join10(homedir10(), ".botapp", "apps");
 var devCommand = new Command10("dev").description("Start development mode for an app").argument("[path]", "Path to the app directory", ".").option("-p, --port <port>", "Server port", "7100").action(async (appPath, opts) => {
-  const absPath = resolve6(appPath);
-  if (!existsSync9(absPath)) {
+  const absPath = resolve7(appPath);
+  if (!existsSync10(absPath)) {
     console.error(pc11.red(`Path not found: ${absPath}`));
     process.exitCode = 1;
     return;
   }
-  const manifestPath = join8(absPath, "botapp.app.json");
-  if (!existsSync9(manifestPath)) {
+  const manifestPath = join10(absPath, "botapp.app.json");
+  if (!existsSync10(manifestPath)) {
     console.error(pc11.red(`No botapp.app.json found in ${absPath}`));
     process.exitCode = 1;
     return;
@@ -2636,9 +3422,9 @@ var devCommand = new Command10("dev").description("Start development mode for an
     return;
   }
   const appName = manifest.name || basename2(absPath);
-  const targetDir = join8(APPS_DIR3, appName);
+  const targetDir = join10(APPS_DIR3, appName);
   mkdirSync5(APPS_DIR3, { recursive: true });
-  if (!existsSync9(targetDir)) {
+  if (!existsSync10(targetDir)) {
     symlinkSync2(absPath, targetDir, "dir");
     console.log(pc11.blue(`Linked ${pc11.bold(appName)} \u2192 ${pc11.dim(absPath)}`));
   } else {
@@ -2671,7 +3457,7 @@ Start the server separately, then restart it to load the app:
       return;
     }
     console.log(pc11.blue("Starting botapp server..."));
-    const child = spawn5("node", ["--import", "tsx", serverEntry], {
+    const child = spawn6("node", ["--import", "tsx", serverEntry], {
       env: { ...process.env, PORT: opts.port },
       stdio: "inherit"
     });
@@ -2685,11 +3471,11 @@ Start the server separately, then restart it to load the app:
 });
 function findServerEntry3() {
   const candidates = [
-    resolve6(process.cwd(), "packages/server/src/index.ts"),
-    resolve6(process.cwd(), "../server/src/index.ts")
+    resolve7(process.cwd(), "packages/server/src/index.ts"),
+    resolve7(process.cwd(), "../server/src/index.ts")
   ];
   for (const c of candidates) {
-    if (existsSync9(c)) return c;
+    if (existsSync10(c)) return c;
   }
   return null;
 }
@@ -2923,13 +3709,13 @@ All agents:`);
 
 // src/commands/register.ts
 import { Command as Command14 } from "commander";
-import { readFileSync as readFileSync7, existsSync as existsSync10 } from "fs";
+import { readFileSync as readFileSync7, existsSync as existsSync11 } from "fs";
 import pc15 from "picocolors";
 var registerCommand = new Command14("register").description("Register an external app via HTTP bridge manifest").argument("<manifest>", "Path to YAML manifest file").option("--adapter <url>", "Override base URL from manifest").action(async (manifestPath, opts, cmd) => {
   const globalOpts = cmd.parent?.opts() ?? {};
   const serverUrl = resolveServerUrl(globalOpts.server);
   const token = resolveToken(globalOpts.token);
-  if (!existsSync10(manifestPath)) {
+  if (!existsSync11(manifestPath)) {
     console.error(pc15.red(`Error: Manifest not found: ${manifestPath}`));
     process.exitCode = 1;
     return;
@@ -2966,13 +3752,13 @@ var registerCommand = new Command14("register").description("Register an externa
 
 // src/commands/wrap.ts
 import { Command as Command15 } from "commander";
-import { readFileSync as readFileSync8, existsSync as existsSync11 } from "fs";
+import { readFileSync as readFileSync8, existsSync as existsSync12 } from "fs";
 import pc16 from "picocolors";
 var wrapCommand = new Command15("wrap").description("Register CLI tool as app commands via YAML manifest").argument("<manifest>", "Path to CLI wrapper YAML manifest").action(async (manifestPath, _opts, cmd) => {
   const globalOpts = cmd.parent?.opts() ?? {};
   const serverUrl = resolveServerUrl(globalOpts.server);
   const token = resolveToken(globalOpts.token);
-  if (!existsSync11(manifestPath)) {
+  if (!existsSync12(manifestPath)) {
     console.error(pc16.red(`Error: Manifest not found: ${manifestPath}`));
     process.exitCode = 1;
     return;
@@ -3236,7 +4022,8 @@ var pairingCommand = new Command18("pairing").alias("pair").description("Pair th
       server: serverUrl,
       daemonId: data.daemon.id,
       daemonName: data.daemon.name,
-      token: data.token
+      token: data.token,
+      userEmail: grant.userEmail
     });
     console.log(pc19.green(`Paired daemon: ${pc19.bold(data.daemon.name)}`));
     console.log(`  ID:      ${data.daemon.id}`);
@@ -3272,13 +4059,130 @@ async function obtainPairingToken(opts) {
   return { pairingToken: result.pairingToken, userEmail: result.userEmail };
 }
 
-// src/commands/update.ts
-import { spawn as spawn6 } from "child_process";
-import { realpathSync } from "fs";
+// src/commands/doctor.ts
 import { Command as Command19 } from "commander";
 import pc20 from "picocolors";
+var doctorCommand = new Command19("doctor").description("Diagnose paired daemon profiles (server reachability, token validity, account ownership)").action(async () => {
+  const profiles = loadDaemonProfiles();
+  if (profiles.length === 0) {
+    console.log(pc20.dim("No paired daemons in ~/.botapp/daemon.yaml."));
+    console.log(pc20.dim("Run `bot pair` to add one."));
+    return;
+  }
+  let warns = 0;
+  let fails = 0;
+  for (const profile of profiles) {
+    console.log(pc20.bold(`
+[${profile.alias ?? profile.server}]`));
+    console.log(`  Server: ${profile.server}`);
+    console.log(`  Daemon: ${profile.daemonName} ${pc20.dim(`(${profile.daemonId})`)}`);
+    const findings = await checkProfile(profile);
+    for (const f of findings) {
+      const tag = f.severity === "ok" ? pc20.green("  \u2713 ") : f.severity === "warn" ? pc20.yellow("  \u26A0 ") : pc20.red("  \u2717 ");
+      console.log(`${tag}${f.message}`);
+      if (f.fix) console.log(pc20.dim(`     \u2192 ${f.fix}`));
+      if (f.severity === "warn") warns += 1;
+      if (f.severity === "fail") fails += 1;
+    }
+  }
+  console.log("");
+  if (fails === 0 && warns === 0) {
+    console.log(pc20.green("All checks passed."));
+  } else {
+    const parts = [];
+    if (fails > 0) parts.push(pc20.red(`${fails} failing`));
+    if (warns > 0) parts.push(pc20.yellow(`${warns} warning${warns === 1 ? "" : "s"}`));
+    console.log(parts.join(", ") + ".");
+    if (fails > 0) process.exitCode = 1;
+  }
+});
+async function checkProfile(profile) {
+  const findings = [];
+  let serverOk = false;
+  try {
+    const res = await fetch(`${profile.server}/health`, {
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (res.ok) {
+      findings.push({ severity: "ok", message: "Server reachable" });
+      serverOk = true;
+    } else {
+      findings.push({
+        severity: "fail",
+        message: `Server returned ${res.status} ${res.statusText}`,
+        fix: `Verify the server at ${profile.server} is running.`
+      });
+    }
+  } catch (e) {
+    findings.push({
+      severity: "fail",
+      message: `Server unreachable: ${e.message ?? e}`,
+      fix: `Start the server, or remove this profile with \`bot daemon unpair ${profile.alias ?? profile.server}\`.`
+    });
+  }
+  if (!serverOk) return findings;
+  let serverEmail = null;
+  try {
+    const data = await daemonRequest(profile.server, profile.token, "/api/daemon/self");
+    findings.push({ severity: "ok", message: "Token valid" });
+    serverEmail = data.user?.email ?? null;
+    if (serverEmail) {
+      findings.push({
+        severity: "ok",
+        message: `Token paired under ${pc20.bold(serverEmail)}`
+      });
+    } else {
+      findings.push({
+        severity: "warn",
+        message: "Server returned no user record for this daemon",
+        fix: "The owning user may have been deleted. Re-pair with `bot pair`."
+      });
+    }
+    if (data.daemon?.status === "online") {
+      findings.push({ severity: "ok", message: "Daemon currently online" });
+    } else {
+      findings.push({
+        severity: "warn",
+        message: `Daemon status: ${data.daemon?.status ?? "unknown"}`,
+        fix: `Run \`bot daemon run --server ${profile.server}\` to bring it online.`
+      });
+    }
+  } catch (e) {
+    const msg = e?.message ?? String(e);
+    if (/unauthor/i.test(msg) || /token/i.test(msg)) {
+      findings.push({
+        severity: "fail",
+        message: `Token rejected: ${msg}`,
+        fix: "The token is stale (likely the server DB was reset). Re-pair with `bot pair`."
+      });
+      return findings;
+    }
+    findings.push({ severity: "fail", message: `Identity probe failed: ${msg}` });
+    return findings;
+  }
+  if (profile.userEmail && serverEmail && profile.userEmail !== serverEmail) {
+    findings.push({
+      severity: "warn",
+      message: `daemon.yaml says \`userEmail: ${profile.userEmail}\` but server says \`${serverEmail}\``,
+      fix: "Re-pair to refresh the recorded email."
+    });
+  } else if (!profile.userEmail && serverEmail) {
+    findings.push({
+      severity: "warn",
+      message: "daemon.yaml has no userEmail recorded",
+      fix: "Re-pair to capture it (cosmetic \u2014 auth still works)."
+    });
+  }
+  return findings;
+}
+
+// src/commands/update.ts
+import { spawn as spawn7 } from "child_process";
+import { realpathSync as realpathSync2 } from "fs";
+import { Command as Command20 } from "commander";
+import pc21 from "picocolors";
 var PACKAGE_NAME = "botapp-cli";
-var updateCommand = new Command19("update").description("Update the `bot` CLI itself to the latest published version").option(
+var updateCommand = new Command20("update").description("Update the `bot` CLI itself to the latest published version").option(
   "--manager <pm>",
   "Force a package manager: npm | pnpm | yarn | brew (default: auto-detect)"
 ).option("--dry-run", "Print the command that would run, but do not execute it").action(async (opts) => {
@@ -3286,12 +4190,12 @@ var updateCommand = new Command19("update").description("Update the `bot` CLI it
   const manager = forced ?? detectPackageManager();
   if (manager === "npx") {
     console.log(
-      pc20.green(
+      pc21.green(
         "You are running `bot` via `npx -y botapp-cli@latest` \u2014 every invocation already fetches the latest version."
       )
     );
     console.log(
-      pc20.dim(
+      pc21.dim(
         "For a faster startup, install it globally instead:\n  npm  i -g botapp-cli@latest\n  pnpm add -g botapp-cli@latest"
       )
     );
@@ -3299,40 +4203,40 @@ var updateCommand = new Command19("update").description("Update the `bot` CLI it
   }
   if (!manager) {
     console.error(
-      pc20.red(
+      pc21.red(
         "Couldn't detect how `bot` was installed. Pick one of these manually:"
       )
     );
-    console.log(pc20.cyan("  npm  i -g botapp-cli@latest"));
-    console.log(pc20.cyan("  pnpm add -g botapp-cli@latest"));
-    console.log(pc20.cyan("  yarn global add botapp-cli@latest"));
-    console.log(pc20.cyan("  brew upgrade botapp-cli"));
+    console.log(pc21.cyan("  npm  i -g botapp-cli@latest"));
+    console.log(pc21.cyan("  pnpm add -g botapp-cli@latest"));
+    console.log(pc21.cyan("  yarn global add botapp-cli@latest"));
+    console.log(pc21.cyan("  brew upgrade botapp-cli"));
     process.exitCode = 1;
     return;
   }
   const { command, args } = updateCommandFor(manager);
-  console.log(pc20.dim(`$ ${command} ${args.join(" ")}`));
+  console.log(pc21.dim(`$ ${command} ${args.join(" ")}`));
   if (opts.dryRun) return;
-  const child = spawn6(command, args, { stdio: "inherit" });
-  const code = await new Promise((resolve7) => {
+  const child = spawn7(command, args, { stdio: "inherit" });
+  const code = await new Promise((resolve11) => {
     child.once("error", (err) => {
-      console.error(pc20.red(`Failed to spawn ${command}: ${err.message}`));
-      resolve7(127);
+      console.error(pc21.red(`Failed to spawn ${command}: ${err.message}`));
+      resolve11(127);
     });
-    child.once("close", resolve7);
+    child.once("close", resolve11);
   });
   if (code !== 0) {
-    console.error(pc20.red(`Update failed (exit ${code}).`));
+    console.error(pc21.red(`Update failed (exit ${code}).`));
     process.exitCode = code ?? 1;
     return;
   }
-  console.log(pc20.green("botapp-cli updated. Run `bot --version` to confirm."));
+  console.log(pc21.green("botapp-cli updated. Run `bot --version` to confirm."));
 });
 function detectPackageManager() {
   const argv = process.argv[1] ?? "";
   let real = "";
   try {
-    real = argv ? realpathSync(argv) : "";
+    real = argv ? realpathSync2(argv) : "";
   } catch {
   }
   const candidates = [argv, real].filter(Boolean);
@@ -3360,9 +4264,755 @@ function updateCommandFor(manager) {
   }
 }
 
+// src/commands/simulate.ts
+import { Command as Command21 } from "commander";
+import { resolve as resolve8, join as join11 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync9 } from "fs";
+import { spawn as spawn8 } from "child_process";
+import pc22 from "picocolors";
+var simulateCommand = new Command21("simulate").description("Dev-tunnel a local app to a botapp server (per-user shadow)").argument("[path]", "Path to the app directory", ".").option("-s, --server <url>", "botapp server URL (default: active profile / $BOTAPP_SERVER)").option("-t, --token <token>", "auth token (default: active profile / $BOTAPP_TOKEN)").option("--entry <file>", "override the manifest entry path").option("--lifetime <minutes>", "dev-session token lifetime in minutes", "480").action(async (appPath, opts) => {
+  const absPath = resolve8(appPath);
+  if (!existsSync13(absPath)) {
+    console.error(pc22.red(`Path not found: ${absPath}`));
+    process.exitCode = 1;
+    return;
+  }
+  const manifestPath = join11(absPath, "botapp.app.json");
+  if (!existsSync13(manifestPath)) {
+    console.error(pc22.red(`No botapp.app.json found in ${absPath}`));
+    process.exitCode = 1;
+    return;
+  }
+  const manifest = JSON.parse(readFileSync9(manifestPath, "utf8"));
+  if (!manifest.name) {
+    console.error(pc22.red('manifest missing "name"'));
+    process.exitCode = 1;
+    return;
+  }
+  const httpServer = resolveServerUrl(opts.server);
+  const wsServer = httpServer.replace(/^http:/, "ws:").replace(/^https:/, "wss:") + "/ws/host";
+  const token = resolveToken(opts.token);
+  if (!token) {
+    console.error(pc22.red("not logged in: run `bot login` or pass --token"));
+    process.exitCode = 1;
+    return;
+  }
+  const lifetimeMs = Math.max(6e4, Number(opts.lifetime) * 6e4);
+  console.log(pc22.dim(`requesting dev token for "${manifest.name}" from ${httpServer}...`));
+  const devToken = await issueDevToken({
+    serverUrl: httpServer,
+    token,
+    appName: manifest.name,
+    lifetimeMs
+  });
+  console.log(pc22.green("\u2713"), `dev token issued (lifetime ${opts.lifetime} min)`);
+  const entryPath = resolveEntry(absPath, opts.entry ?? manifest.entry);
+  if (!existsSync13(entryPath)) {
+    console.error(pc22.red(`entry not found: ${entryPath}`));
+    console.error(pc22.dim("  run `pnpm build` (or your build script) first."));
+    process.exitCode = 1;
+    return;
+  }
+  console.log(pc22.dim(`spawning ${entryPath} ...`));
+  console.log(pc22.dim(`  BOTAPP_SERVER=${wsServer}`));
+  console.log(pc22.dim(`  BOTAPP_APP_NAME=${manifest.name}`));
+  console.log(
+    pc22.cyan(
+      `
+When ready, your dashboard at ${httpServer} will route "${manifest.name}" to this process for your account only.
+`
+    )
+  );
+  const child = spawn8("node", [entryPath], {
+    cwd: absPath,
+    env: {
+      ...process.env,
+      BOTAPP_SERVER: wsServer,
+      BOTAPP_APP_TOKEN: devToken,
+      BOTAPP_APP_NAME: manifest.name,
+      BOTAPP_DATA_DIR: join11(absPath, ".botapp-sim")
+    },
+    stdio: "inherit"
+  });
+  const stop = (signal) => {
+    console.log(pc22.dim(`
+stopping (${signal})...`));
+    if (!child.killed) child.kill(signal);
+  };
+  process.on("SIGINT", () => stop("SIGINT"));
+  process.on("SIGTERM", () => stop("SIGTERM"));
+  child.on("exit", (code, sig) => {
+    const reason = sig ? `signal ${sig}` : `exit ${code}`;
+    console.log(pc22.dim(`child exited (${reason})`));
+    process.exit(typeof code === "number" ? code : 0);
+  });
+});
+async function issueDevToken(opts) {
+  const res = await fetch(`${opts.serverUrl}/api/dev/token`, {
+    method: "POST",
+    headers: authHeaders(opts.token),
+    body: JSON.stringify({ appName: opts.appName, lifetimeMs: opts.lifetimeMs })
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`dev-token request failed (${res.status}): ${text}`);
+  }
+  const data = await res.json();
+  if (!data.token) {
+    throw new Error(`dev-token response missing token: ${JSON.stringify(data)}`);
+  }
+  return data.token;
+}
+function resolveEntry(appDir, entry) {
+  const candidates = [
+    entry,
+    "dist/api.js",
+    "dist/api/index.js",
+    "dist/index.js",
+    "api/index.ts",
+    "api/index.js"
+  ].filter(Boolean);
+  for (const c of candidates) {
+    const full = resolve8(appDir, c);
+    if (existsSync13(full)) return full;
+  }
+  return resolve8(appDir, candidates[0] ?? "dist/api.js");
+}
+
+// src/commands/init.ts
+import { Command as Command22 } from "commander";
+import { existsSync as existsSync14, mkdirSync as mkdirSync6, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve9, join as join12 } from "path";
+import pc23 from "picocolors";
+var initCommand = new Command22("init").description("Scaffold a new hosted-tier botapp app project").argument("<name>", "App name (kebab-case; used in URL paths and manifest)").option("-d, --dir <path>", "Output directory (default: ./<name>)").option("--headless", "No frontend \u2014 backend-only app (skip src/, tailwind, etc.)").option("--description <text>", "Short description for AI agents to read").option("-f, --force", "Overwrite existing directory contents").action(async (name, opts) => {
+  if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+    console.error(pc23.red("Invalid name. Use lowercase letters, digits, dashes; must start with a letter."));
+    console.error(pc23.dim("  e.g. my-app, todo-tracker, gomoku-2"));
+    process.exitCode = 1;
+    return;
+  }
+  const targetDir = resolve9(opts.dir ?? `./${name}`);
+  if (existsSync14(targetDir) && !opts.force) {
+    const stat = (() => {
+      try {
+        return __require("fs").readdirSync(targetDir);
+      } catch {
+        return [];
+      }
+    })();
+    if (Array.isArray(stat) && stat.length > 0) {
+      console.error(pc23.red(`Target directory exists and is not empty: ${targetDir}`));
+      console.error(pc23.dim("  pass --force to overwrite, or pick a different --dir"));
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const ctx = {
+    name,
+    description: opts.description ?? `${name} \u2014 a botapp app`,
+    headless: !!opts.headless
+  };
+  mkdirSync6(targetDir, { recursive: true });
+  const files = ctx.headless ? headlessFiles(ctx) : fullFiles(ctx);
+  for (const [rel, content] of Object.entries(files)) {
+    const full = join12(targetDir, rel);
+    mkdirSync6(dirname2(full), { recursive: true });
+    writeFileSync4(full, content);
+  }
+  console.log(pc23.green("\u2713"), `Scaffolded ${ctx.headless ? "headless " : ""}app at`, pc23.cyan(targetDir));
+  console.log();
+  console.log("Next steps:");
+  console.log(pc23.dim(`  cd ${targetDir.replace(process.cwd() + "/", "")}`));
+  console.log(pc23.dim("  pnpm install        # or npm install"));
+  if (!ctx.headless) console.log(pc23.dim("  pnpm build          # builds api/ + frontend (dist/)"));
+  else console.log(pc23.dim("  pnpm build          # builds api/ to dist/api.js"));
+  console.log(pc23.dim(`  bot login --server <your-botapp-server>`));
+  console.log(pc23.dim(`  bot simulate        # dev-tunnel into the server, hot-reload as you build`));
+  console.log();
+  console.log(
+    pc23.dim("Once it works, `bot publish` ships it to the server (per-user install by default).")
+  );
+});
+function fullFiles(ctx) {
+  return {
+    "botapp.app.json": manifestJson(ctx),
+    "package.json": packageJson(
+      ctx,
+      /*headless*/
+      false
+    ),
+    "tsconfig.json": tsconfigJson(false),
+    "tsconfig.api.json": tsconfigApiJson(),
+    "tsconfig.frontend.json": tsconfigFrontendJson(),
+    "tsup.api.config.ts": tsupApiConfig(),
+    "vite.config.ts": viteConfig(ctx),
+    "index.html": indexHtml(ctx),
+    "api/index.ts": apiEntryTs(ctx, false),
+    "src/main.tsx": srcMainTsx(ctx),
+    "src/App.tsx": srcAppTsx(ctx),
+    "src/lib/api.ts": srcApiTs(),
+    "contracts/types.ts": contractsTs(ctx),
+    ".gitignore": gitignore(),
+    "README.md": readme(ctx, false)
+  };
+}
+function headlessFiles(ctx) {
+  return {
+    "botapp.app.json": manifestJson(ctx),
+    "package.json": packageJson(
+      ctx,
+      /*headless*/
+      true
+    ),
+    "tsconfig.json": tsconfigJson(true),
+    "tsup.api.config.ts": tsupApiConfig(),
+    "api/index.ts": apiEntryTs(ctx, true),
+    "contracts/types.ts": contractsTs(ctx),
+    ".gitignore": gitignore(),
+    "README.md": readme(ctx, true)
+  };
+}
+function manifestJson(ctx) {
+  const m = {
+    name: ctx.name,
+    version: "0.1.0",
+    description: ctx.description,
+    entry: "./dist/api.js",
+    tier: "user",
+    visibility: "private"
+  };
+  if (!ctx.headless) {
+    m.hasFrontend = true;
+  }
+  return JSON.stringify(m, null, 2) + "\n";
+}
+function packageJson(ctx, headless) {
+  const scripts = {
+    build: headless ? "tsup --config tsup.api.config.ts" : "tsup --config tsup.api.config.ts && vite build",
+    "build:api": "tsup --config tsup.api.config.ts",
+    dev: headless ? "tsup --config tsup.api.config.ts --watch" : "tsup --config tsup.api.config.ts --watch & vite",
+    typecheck: "tsc --noEmit"
+  };
+  const deps = {
+    "botapp-sdk": "^0.1.0",
+    ws: "^8.18.0"
+  };
+  const devDeps = {
+    tsup: "^8.4.0",
+    typescript: "^5.8.0",
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.5.0"
+  };
+  if (!headless) {
+    Object.assign(deps, {
+      react: "^19.0.0",
+      "react-dom": "^19.0.0"
+    });
+    Object.assign(devDeps, {
+      vite: "^7.0.0",
+      "@vitejs/plugin-react": "^5.0.0",
+      "@types/react": "^19.0.0",
+      "@types/react-dom": "^19.0.0"
+    });
+  }
+  return JSON.stringify(
+    {
+      name: ctx.name,
+      version: "0.1.0",
+      description: ctx.description,
+      type: "module",
+      private: true,
+      scripts,
+      dependencies: deps,
+      devDependencies: devDeps
+    },
+    null,
+    2
+  ) + "\n";
+}
+function tsconfigJson(headless) {
+  if (headless) {
+    return JSON.stringify(
+      {
+        compilerOptions: {
+          target: "ES2022",
+          module: "ESNext",
+          moduleResolution: "bundler",
+          esModuleInterop: true,
+          strict: true,
+          skipLibCheck: true,
+          noEmit: true
+        },
+        include: ["api/**/*.ts", "contracts/**/*.ts"]
+      },
+      null,
+      2
+    ) + "\n";
+  }
+  return JSON.stringify(
+    {
+      files: [],
+      references: [
+        { path: "./tsconfig.api.json" },
+        { path: "./tsconfig.frontend.json" }
+      ]
+    },
+    null,
+    2
+  ) + "\n";
+}
+function tsconfigApiJson() {
+  return JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        esModuleInterop: true,
+        strict: true,
+        skipLibCheck: true,
+        noEmit: true
+      },
+      include: ["api/**/*.ts", "contracts/**/*.ts"]
+    },
+    null,
+    2
+  ) + "\n";
+}
+function tsconfigFrontendJson() {
+  return JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        esModuleInterop: true,
+        strict: true,
+        skipLibCheck: true,
+        jsx: "react-jsx",
+        lib: ["ES2022", "DOM", "DOM.Iterable"],
+        noEmit: true
+      },
+      include: ["src/**/*.ts", "src/**/*.tsx", "contracts/**/*.ts"]
+    },
+    null,
+    2
+  ) + "\n";
+}
+function tsupApiConfig() {
+  return `import { defineConfig } from 'tsup'
+
+export default defineConfig({
+  entry: { api: 'api/index.ts' },
+  format: ['esm'],
+  outDir: 'dist',
+  clean: true,
+  sourcemap: true,
+  noExternal: [],
+})
+`;
+}
+function viteConfig(ctx) {
+  return `import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+export default defineConfig({
+  plugins: [react()],
+  base: '/apps/${ctx.name}/',
+  build: {
+    outDir: 'dist/public',
+    emptyOutDir: true,
+  },
+})
+`;
+}
+function indexHtml(ctx) {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${escapeHtml(ctx.description)}</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
+`;
+}
+function apiEntryTs(ctx, headless) {
+  const widget = headless ? "" : `
+    ctx.registerWidget({
+      refresh: { intervalMs: 30_000 },
+      render: async ({ state }) => {
+        const count = (await state.get('count')) ?? 0
+        return {
+          html: \`<div class="card"><div class="label">${ctx.name.toUpperCase()}</div><div class="value">\${count}</div></div>\`,
+          css: \`.card { padding: 20px; font-family: sans-serif; } .value { font-size: 32px; font-weight: 700; }\`,
+        }
+      },
+    })
+
+    ctx.serveStatic('./dist/public')
+`;
+  return `import { BotApp } from 'botapp-sdk'
+
+const app = new BotApp({
+  name: '${ctx.name}',
+  version: '0.1.0',
+  description: '${ctx.description.replace(/'/g, "\\'")}',
+  async setup(ctx) {
+    ctx.registerCommand('hello', {
+      description: 'Greet the caller',
+      params: {
+        name: { type: 'string', required: false, default: 'world', description: 'Who to greet' },
+      },
+      handler: async ({ name }, cmdCtx) => {
+        const count = ((await cmdCtx.state.get('count')) as number | null) ?? 0
+        await cmdCtx.state.set('count', count + 1)
+        ctx.invalidateWidget?.()
+        return \`Hello, \${name}! (called \${count + 1}x by \${cmdCtx.agent.id})\`
+      },
+    })
+${widget}  },
+})
+
+await app.start()
+`;
+}
+function srcMainTsx(_ctx) {
+  return `import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import { App } from './App'
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)
+`;
+}
+function srcAppTsx(ctx) {
+  return `import { useEffect, useState } from 'react'
+import { callCommand } from './lib/api'
+
+export function App() {
+  const [count, setCount] = useState<number | null>(null)
+  const [error, setError] = useState<string | null>(null)
+  useEffect(() => {
+    callCommand('hello', { name: 'browser' })
+      .then((res) => {
+        const m = /\\(called (\\d+)x/.exec(String(res))
+        if (m) setCount(Number(m[1]))
+      })
+      .catch((e: Error) => setError(e.message))
+  }, [])
+  return (
+    <main style={{ fontFamily: 'sans-serif', padding: 24 }}>
+      <h1>${ctx.name}</h1>
+      {error ? <pre style={{ color: 'crimson' }}>{error}</pre> : <p>Calls so far: {count ?? '...'}</p>}
+    </main>
+  )
+}
+`;
+}
+function srcApiTs() {
+  return `// Tiny client for calling app routes/commands from the browser.
+// Routes resolve as /apps/<name>/* on the platform; the platform forwards
+// each request to your app's WebSocket session.
+
+const APP_BASE = ((): string => {
+  const m = location.pathname.match(/^\\/apps\\/[^/]+\\//)
+  return m ? m[0] : '/'
+})()
+
+export async function callCommand(name: string, params: Record<string, unknown> = {}) {
+  const r = await fetch(\`\${APP_BASE}api/commands/\${encodeURIComponent(name)}\`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(params),
+  })
+  if (!r.ok) throw new Error(await r.text())
+  return r.json()
+}
+
+export async function callAction(name: string, params: Record<string, unknown> = {}) {
+  const r = await fetch(\`\${APP_BASE}api/actions/\${encodeURIComponent(name)}\`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(params),
+  })
+  if (!r.ok) throw new Error(await r.text())
+  return r.json()
+}
+`;
+}
+function contractsTs(ctx) {
+  return `// Types shared between api/ (backend) and src/ (frontend).
+// Importing from one side picks up changes on the other immediately.
+
+export interface ${pascal(ctx.name)}State {
+  count: number
+}
+`;
+}
+function gitignore() {
+  return `node_modules/
+dist/
+.botapp-sim/
+*.log
+.DS_Store
+.env*.local
+`;
+}
+function readme(ctx, headless) {
+  const surfaces = headless ? "- Backend only (no frontend)" : "- React + Vite frontend (built to `dist/public/`)\n- Dashboard widget (declared in `api/index.ts`)";
+  return `# ${ctx.name}
+
+${ctx.description}
+
+## Surfaces
+
+${surfaces}
+- One agent-facing command: \`hello\`
+
+## Develop
+
+\`\`\`bash
+pnpm install
+pnpm build           # api \u2192 dist/api.js${headless ? "" : ", frontend \u2192 dist/public/"}
+bot login --server <your-botapp-server>
+bot simulate         # dev-tunnel; hot-reload as you build
+\`\`\`
+
+The simulator opens a per-user shadow of this app on the server. Your
+real dashboard at the server's URL routes the app to *your* local
+process; nobody else sees it.
+
+## Publish
+
+\`\`\`bash
+bot publish              # private, only you see it
+bot publish --public     # requests admin review for public visibility
+\`\`\`
+`;
+}
+function escapeHtml(s) {
+  return s.replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c]);
+}
+function pascal(s) {
+  return s.split(/[-_\s]+/).filter(Boolean).map((w) => w[0].toUpperCase() + w.slice(1)).join("");
+}
+function dirname2(p) {
+  const i = p.lastIndexOf("/");
+  return i < 0 ? "." : p.slice(0, i);
+}
+
+// src/commands/publish.ts
+import { Command as Command23 } from "commander";
+import { resolve as resolve10, join as join13, relative as relative2 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync10, statSync as statSync4, readdirSync as readdirSync2 } from "fs";
+import { createGzip } from "zlib";
+import { spawn as spawn9 } from "child_process";
+import pc24 from "picocolors";
+var publishCommand = new Command23("publish").description("Build, pack, and upload an app to a botapp server").argument("[path]", "App directory", ".").option("-s, --server <url>", "Server URL (default: active profile / $BOTAPP_SERVER)").option("-t, --token <token>", "Auth token (default: active profile / $BOTAPP_TOKEN)").option("--public", "Request public visibility (queues admin review). Default: private.").option("--no-build", "Skip running `pnpm build` / `npm run build`").option("--bundle-dir <dir>", "Directory to bundle into tar.gz (default: dist/public if exists, else dist)").action(async (appPath, opts) => {
+  const absPath = resolve10(appPath);
+  const manifestPath = join13(absPath, "botapp.app.json");
+  if (!existsSync15(manifestPath)) {
+    console.error(pc24.red(`No botapp.app.json found in ${absPath}`));
+    process.exitCode = 1;
+    return;
+  }
+  const manifest = JSON.parse(readFileSync10(manifestPath, "utf8"));
+  if (!manifest.name) {
+    console.error(pc24.red('manifest missing "name"'));
+    process.exitCode = 1;
+    return;
+  }
+  const server = resolveServerUrl(opts.server);
+  const token = resolveToken(opts.token);
+  if (!token) {
+    console.error(pc24.red("not logged in: run `bot login` or pass --token"));
+    process.exitCode = 1;
+    return;
+  }
+  if (opts.build !== false) {
+    console.log(pc24.dim("building app..."));
+    const ok = await runBuild(absPath);
+    if (!ok) {
+      console.error(pc24.red("build failed; aborting"));
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const bundleDir = opts.bundleDir ? resolve10(absPath, opts.bundleDir) : pickBundleDir(absPath);
+  let bundleB64;
+  if (bundleDir && existsSync15(bundleDir)) {
+    console.log(pc24.dim(`packing ${relative2(absPath, bundleDir)}/ \u2192 tar.gz...`));
+    const bytes = await packDirToTarGz(bundleDir);
+    bundleB64 = bytes.toString("base64");
+    console.log(pc24.dim(`  bundle: ${(bytes.length / 1024).toFixed(1)} KiB`));
+  } else {
+    console.log(pc24.dim("no frontend bundle to upload (headless app or no dist/public)"));
+  }
+  console.log(pc24.dim(`uploading to ${server}/api/apps/upload (${opts.public ? "public" : "private"})...`));
+  const res = await fetch(`${server}/api/apps/upload`, {
+    method: "POST",
+    headers: authHeaders(token),
+    body: JSON.stringify({
+      manifest,
+      bundleB64,
+      visibility: opts.public ? "public" : "private"
+    })
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    console.error(pc24.red(`upload failed (${res.status}): ${body}`));
+    process.exitCode = 1;
+    return;
+  }
+  const data = await res.json();
+  if (!data.ok) {
+    console.error(pc24.red(`upload rejected: ${data.error ?? "unknown"}`));
+    process.exitCode = 1;
+    return;
+  }
+  console.log(pc24.green("\u2713"), data.message ?? "uploaded");
+  if (data.install) {
+    console.log(pc24.dim(`  id: ${data.install.id}`));
+    console.log(pc24.dim(`  version: ${data.install.version}`));
+    console.log(pc24.dim(`  visibility: ${data.install.visibility}`));
+    if (data.install.reviewStatus !== "none") {
+      console.log(pc24.dim(`  review: ${data.install.reviewStatus}`));
+    }
+  }
+});
+function runBuild(cwd) {
+  const pkgManager = existsSync15(join13(cwd, "pnpm-lock.yaml")) ? "pnpm" : "npm";
+  const args = pkgManager === "pnpm" ? ["build"] : ["run", "build"];
+  return new Promise((resolveP) => {
+    const child = spawn9(pkgManager, args, { cwd, stdio: "inherit" });
+    child.on("exit", (code) => resolveP(code === 0));
+    child.on("error", () => resolveP(false));
+  });
+}
+function pickBundleDir(appDir) {
+  const distPublic = join13(appDir, "dist", "public");
+  if (existsSync15(distPublic)) return distPublic;
+  const dist = join13(appDir, "dist");
+  if (existsSync15(dist)) return dist;
+  return null;
+}
+async function packDirToTarGz(rootDir) {
+  const entries = [];
+  walk(rootDir, "", entries);
+  const blocks = [];
+  for (const e of entries) {
+    blocks.push(tarHeader(e.name, e.size));
+    blocks.push(e.data);
+    const pad = (512 - e.size % 512) % 512;
+    if (pad) blocks.push(Buffer.alloc(pad));
+  }
+  blocks.push(Buffer.alloc(1024));
+  const tar = Buffer.concat(blocks);
+  return await gzip(tar);
+}
+function walk(root, prefix, out) {
+  for (const entry of readdirSync2(root)) {
+    const full = join13(root, entry);
+    const st = statSync4(full);
+    const rel = (prefix ? `${prefix}/` : "") + entry;
+    if (st.isDirectory()) {
+      walk(full, rel, out);
+    } else if (st.isFile()) {
+      const data = readFileSync10(full);
+      out.push({ name: rel, size: data.length, data });
+    }
+  }
+}
+function tarHeader(name, size) {
+  const h = Buffer.alloc(512);
+  h.write(name.length > 100 ? name.slice(name.length - 100) : name, 0, 100);
+  h.write("0000644", 100, 7);
+  h.write("0000000", 108, 7);
+  h.write("0000000", 116, 7);
+  h.write(size.toString(8).padStart(11, "0"), 124, 11);
+  h.write(Math.floor(Date.now() / 1e3).toString(8).padStart(11, "0"), 136, 11);
+  h.write("        ", 148, 8);
+  h.write("0", 156, 1);
+  h.write("ustar  ", 257, 8);
+  let cksum = 0;
+  for (const b of h) cksum += b;
+  h.write(cksum.toString(8).padStart(6, "0") + "\0 ", 148, 8);
+  return h;
+}
+function gzip(input2) {
+  return new Promise((resolveP, rejectP) => {
+    const gz = createGzip();
+    const chunks = [];
+    gz.on("data", (c) => chunks.push(c));
+    gz.on("end", () => resolveP(Buffer.concat(chunks)));
+    gz.on("error", rejectP);
+    gz.end(input2);
+  });
+}
+
+// src/commands/review.ts
+import { Command as Command24 } from "commander";
+import pc25 from "picocolors";
+var reviewCommand = new Command24("review").description("Admin: review queue for public-visibility uploads");
+reviewCommand.command("list").description("List pending public-visibility uploads").option("-s, --server <url>", "Server URL").option("-t, --token <token>", "Auth token").action(async (opts) => {
+  const server = resolveServerUrl(opts.server);
+  const token = resolveToken(opts.token);
+  if (!token) return die("not logged in: run `bot login` or pass --token");
+  const res = await fetch(`${server}/api/admin/review-queue`, { headers: authHeaders(token) });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    return die(`request failed (${res.status}): ${body}`);
+  }
+  const data = await res.json();
+  if (!data.pending?.length) {
+    console.log(pc25.dim("queue empty"));
+    return;
+  }
+  for (const i of data.pending) {
+    console.log(pc25.bold(i.id), pc25.cyan(i.appName), pc25.dim(`v${i.version}`));
+    console.log(pc25.dim(`  uploader: ${i.ownerUserId ?? "(server-wide)"}`));
+    console.log(pc25.dim(`  uploaded: ${i.uploadedAt}`));
+    const desc = i.manifest?.description;
+    if (desc) console.log(pc25.dim(`  description: ${desc}`));
+    console.log();
+  }
+});
+reviewCommand.command("approve <id>").description("Approve a pending public install").option("--notes <text>", "Optional reviewer notes").option("-s, --server <url>", "Server URL").option("-t, --token <token>", "Auth token").action(async (id, opts) => decide(id, "approve", opts));
+reviewCommand.command("reject <id>").description("Reject a pending public install").requiredOption("--notes <text>", "Reason for rejection (required)").option("-s, --server <url>", "Server URL").option("-t, --token <token>", "Auth token").action(async (id, opts) => decide(id, "reject", opts));
+async function decide(id, decision, opts) {
+  const server = resolveServerUrl(opts.server);
+  const token = resolveToken(opts.token);
+  if (!token) return die("not logged in: run `bot login` or pass --token");
+  const res = await fetch(`${server}/api/admin/review/${encodeURIComponent(id)}`, {
+    method: "POST",
+    headers: authHeaders(token),
+    body: JSON.stringify({ decision, notes: opts.notes })
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    return die(`request failed (${res.status}): ${body}`);
+  }
+  const data = await res.json();
+  if (!data.ok) return die(`server rejected: ${data.error ?? "unknown"}`);
+  console.log(pc25.green("\u2713"), `${decision}d`, data.install?.appName, pc25.dim(`(${data.install?.id})`));
+  if (data.install?.reviewNotes) console.log(pc25.dim(`  notes: ${data.install.reviewNotes}`));
+}
+function die(msg) {
+  console.error(pc25.red(msg));
+  process.exitCode = 1;
+}
+
 // src/index.ts
-var version = "0.2.4";
-var program = new Command20().name("bot").description("botapp CLI \u2014 operate apps from the command line").version(version).enablePositionalOptions(true).option("--json", "Output as JSON").option("-s, --server <url>", "Server URL override").option("-t, --token <token>", "Auth token override").option("-v, --verbose", "Verbose output");
+var version = "0.2.7";
+var program = new Command25().name("bot").description("botapp CLI \u2014 operate apps from the command line").version(version).enablePositionalOptions(true).option("--json", "Output as JSON").option("-s, --server <url>", "Server URL override").option("-t, --token <token>", "Auth token override").option("-v, --verbose", "Verbose output");
 program.addCommand(launchCommand);
 program.addCommand(runCommand);
 program.addCommand(appsCommand);
@@ -3373,10 +5023,15 @@ program.addCommand(loginCommand);
 program.addCommand(agentCommand);
 program.addCommand(pairingCommand);
 program.addCommand(daemonCommand);
+program.addCommand(doctorCommand);
+program.addCommand(initCommand);
 program.addCommand(installCommand);
 program.addCommand(uninstallCommand);
 program.addCommand(reloadCommand);
 program.addCommand(configCommand);
+program.addCommand(simulateCommand);
+program.addCommand(publishCommand);
+program.addCommand(reviewCommand);
 program.addCommand(serverCommand);
 program.addCommand(updateCommand);
 program.addCommand(devCommand, { hidden: true });
@@ -3420,29 +5075,29 @@ To discover what params a command accepts:
 program.on("command:*", (operands) => {
   const first = operands[0];
   const known = program.commands.filter((c) => !c._hidden).map((c) => c.name());
-  const topLevelHint = `Run ${pc21.cyan("bot --help")} for the list of top-level commands.`;
+  const topLevelHint = `Run ${pc26.cyan("bot --help")} for the list of top-level commands.`;
   const argv = process.argv.slice(2);
   const firstIdx = argv.indexOf(first);
   const tail = firstIdx >= 0 ? argv.slice(firstIdx + 1) : [];
   if (tail.length > 0) {
     const suggested = `bot run ${first} ${tail.join(" ")}`;
     console.error(
-      pc21.red(`error: unknown command '${first}'`) + `
+      pc26.red(`error: unknown command '${first}'`) + `
 
-App commands go through ${pc21.bold("bot run")}. Did you mean:
+App commands go through ${pc26.bold("bot run")}. Did you mean:
 
-  ${pc21.cyan(suggested)}
+  ${pc26.cyan(suggested)}
 
 ${topLevelHint}`
     );
     process.exit(1);
   }
   console.error(
-    pc21.red(`error: unknown command '${first}'`) + `
+    pc26.red(`error: unknown command '${first}'`) + `
 
 If '${first}' is an app name, invoke one of its commands with:
-  ${pc21.cyan(`bot run ${first} <command> [--key value ...]`)}
-  ${pc21.cyan("bot apps --json")}   ${pc21.dim("(to see what commands exist)")}
+  ${pc26.cyan(`bot run ${first} <command> [--key value ...]`)}
+  ${pc26.cyan("bot apps --json")}   ${pc26.dim("(to see what commands exist)")}
 
 Top-level commands: ${known.join(", ")}
 ${topLevelHint}`