@indigoai-us/hq-cli 5.109.15 → 5.110.0

package/dist/commands/bot.js

@@ -0,0 +1,776 @@
+import { OwnerContextCache, lookupOwnerContext } from "../lib/bot/owner-context.js";
+import { hasActivePromotion } from "../lib/bot/promotion-receipt.js";
+import { hasPromotionHold, promotionHoldSummary } from "../lib/bot/promotion-hold.js";
+/**
+ * `hq bot` — personal local bots (local-bots US-003/US-004/US-005).
+ *
+ *   hq bot create <name> [--runtime claude|codex|grok] [--model m] [--effort level] [--worker id] [--intro text] [--kickoff prompt] [--memory synced|local] [--no-daemon]
+ *   hq bot workers [--json]              (company + core workers a bot can be created from)
+ *   hq bot list [--json]
+ *   hq bot start|stop|restart <name>
+ *   hq bot status <name> [--json]
+ *   hq bot logs <name> [--follow] [-n N]
+ *   hq bot run <name>                     (the resident process; launchd runs this)
+ *   hq bot daemon install|uninstall|status <name>
+ *   hq bot rm <name> [--yes]
+ *   hq bot intro <name>                   (re-send the introduction DM)
+ *
+ * The bot's own identity (agt_) authenticates with 0600 machine creds under
+ * ~/.hq/bots/<name>/; the OWNER's cached session is used only for create,
+ * list (online flag), and rm. Secrets are never printed.
+ */
+import { promoteLocalBot } from "../lib/bot/promote.js";
+import { registerBotContinuityCommand } from "./bot-continuity.js";
+import chalk from "chalk";
+import { execFileSync, spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as readline from "node:readline";
+import { DEFAULT_COGNITO, ensureCognitoToken, resolveDefaultHqRoot, } from "../utils/cognito-session.js";
+import { resolveVaultCredential } from "../utils/resolve-vault-credential.js";
+import { resolveCallerPersonUid } from "../utils/vault-api.js";
+import { resolveHqBinary } from "../lib/mesh/live/daemon/install.js";
+import { BotApi, BotApiError, botDaemonStatus, botDir, botCredsPath, botLogPath, botsRoot, botTokenStateDir, botWorkerRelDir, buildBotDaemonPaths, createBotLogger, deleteBotCreds, installBotDaemon, introDmText, isBotMemoryMode, botLocalMemoryDir, botMemoryMode, resolveBotMemoryDir, validateBotIntro, validateBotKickoff, validateBotEffort, validateBotModel, effectiveBotEffort, BOT_EFFORT_LEVELS, DEFAULT_BOT_EFFORT, BOT_MEMORY_MODES, isBotRuntimeId, isPidAlive, listBotWorkerOptions, patchBotConfig, readBotConfig, readBotCredsIdentity, readBotStatus, resolveBotWorker, runBot, runtimeFor, scaffoldBotMemory, scaffoldBotWorker, startBotDaemon, stopBotDaemon, uninstallBotDaemon, validateBotName, writeBotConfig, writeBotCreds, BOT_RUNTIMES, BOT_INTRO_MAX_CHARS, BOT_KICKOFF_MAX_CHARS, } from "../lib/bot/index.js";
+function fail(message) {
+    console.error(chalk.red(message));
+    process.exit(1);
+}
+function wrap(action) {
+    return async () => {
+        try {
+            await action();
+        }
+        catch (err) {
+            fail(err instanceof Error ? err.message : String(err));
+        }
+    };
+}
+/** Real launchctl; every failure is a non-ok result, never a throw. */
+export const defaultLaunchctl = (args) => {
+    try {
+        const stdout = execFileSync("launchctl", args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+        return { ok: true, stdout, stderr: "" };
+    }
+    catch (err) {
+        const e = err;
+        return { ok: false, stdout: String(e.stdout ?? ""), stderr: String(e.stderr ?? e.message ?? "") };
+    }
+};
+/** The desktop app creates HQ's setup bot under this name, always from the `setup` worker. */
+export const RESERVED_SETUP_BOT_NAME = "setup";
+function daemonDeps() {
+    return process.platform === "darwin" ? { launchctl: defaultLaunchctl } : {};
+}
+export function listBotNames(root) {
+    if (!fs.existsSync(root))
+        return [];
+    return fs
+        .readdirSync(root, { withFileTypes: true })
+        .filter((d) => d.isDirectory() && readBotConfig(path.join(root, d.name)) !== null)
+        .map((d) => d.name)
+        .sort();
+}
+function requireBot(name) {
+    const valid = validateBotName(name);
+    const dir = botDir(valid);
+    const config = readBotConfig(dir);
+    if (!config) {
+        throw Object.assign(new Error(`No bot named "${valid}". Create one with: hq bot create ${valid}`), {
+            expected: true,
+        });
+    }
+    return { name: valid, dir, config };
+}
+/** Bot-identity token supplier: per-bot creds + per-bot token cache dir. */
+export function botTokenSupplier(dir) {
+    process.env.HQ_MACHINE_CREDS_FILE = botCredsPath(dir);
+    process.env.HQ_MACHINE_TOKEN_STATE_DIR = botTokenStateDir(dir);
+    return () => ensureCognitoToken({ tokenSource: "machine", interactive: false });
+}
+async function ownerToken(interactive = process.stdin.isTTY === true) {
+    // Under the desktop app (no TTY) never open a browser login; the app owns
+    // sign-in and shares the same cached session file.
+    const cred = await resolveVaultCredential({ interactive });
+    if (cred.kind !== "cognito") {
+        throw Object.assign(new Error("hq bot needs your HQ login session (HQ_API_KEY is not supported here). Run `hq login`."), {
+            expected: true,
+        });
+    }
+    return cred.token;
+}
+function rowFor(name, opts = {}) {
+    const dir = botDir(name);
+    const config = readBotConfig(dir);
+    const status = readBotStatus(dir);
+    const pid = status?.pid ?? null;
+    const processAlive = pid !== null && isPidAlive(pid) && status?.state === "running";
+    let daemonInstalled = false;
+    let daemonLoaded = false;
+    if (opts.withDaemon !== false) {
+        try {
+            const d = botDaemonStatus(buildBotDaemonPaths({ name, botDir: dir, hqRoot: config.hqRoot }), daemonDeps());
+            daemonInstalled = d.installed;
+            daemonLoaded = d.loaded;
+        }
+        catch {
+            /* hq binary unresolvable in odd environments — daemon status unknown */
+        }
+    }
+    return {
+        name,
+        agentUid: config.agentUid,
+        ownerUid: config.ownerUid,
+        runtime: config.runtime,
+        model: config.model,
+        effort: effectiveBotEffort(config),
+        effortIsDefault: !config.effort,
+        state: processAlive ? "running" : status?.state === "failed" ? "failed" : "stopped",
+        pid: processAlive ? pid : null,
+        processAlive,
+        hosting: hasActivePromotion(dir, config.agentUid, config.ownerUid) ? "cloud" : "local",
+        promotionHold: promotionHoldSummary(dir, config.agentUid, config.ownerUid),
+        online: null,
+        lastHeartbeatAt: status?.lastHeartbeatAt ?? null,
+        daemonInstalled,
+        daemonLoaded,
+        dir,
+        introSentAt: config.introSentAt,
+        workerSource: config.workerSource ?? "scaffold",
+        workerDir: config.workerDir,
+        ...(config.workerId ? { workerId: config.workerId } : {}),
+        ...(config.companySlug ? { companySlug: config.companySlug } : {}),
+        memory: botMemoryMode(config),
+        memoryDir: resolveBotMemoryDir(config),
+        ...(config.intro ? { intro: config.intro } : {}),
+        ...(config.kickoff ? { kickoff: config.kickoff } : {}),
+    };
+}
+async function decorateOnline(rows) {
+    if (rows.length === 0)
+        return;
+    let token;
+    try {
+        token = await ownerToken(false);
+    }
+    catch {
+        return;
+    }
+    const api = new BotApi({ token: async () => token });
+    await Promise.all(rows.map(async (row) => {
+        try {
+            const rec = await api.getAgent(row.agentUid);
+            row.online = rec.online === true;
+            row.lastHeartbeatAt = rec.runtime?.lastHeartbeat?.at ?? row.lastHeartbeatAt;
+        }
+        catch {
+            row.online = null;
+        }
+    }));
+}
+function humanOnline(row) {
+    if (row.online === true)
+        return chalk.green("online");
+    if (row.online === false)
+        return chalk.gray("offline");
+    return chalk.gray("unknown");
+}
+/** Spawn `hq bot run <name>` detached (no launchd). */
+export function spawnDetachedRun(name, dir) {
+    const entry = process.argv[1] && fs.existsSync(process.argv[1]) ? process.argv[1] : resolveHqBinary();
+    fs.mkdirSync(path.dirname(botLogPath(dir)), { recursive: true, mode: 0o700 });
+    const fd = fs.openSync(botLogPath(dir), "a");
+    const child = spawn(process.execPath, [entry, "bot", "run", name], {
+        detached: true,
+        stdio: ["ignore", fd, fd],
+        env: { ...process.env, HQ_NO_UPDATE_CHECK: "1" },
+    });
+    fs.closeSync(fd);
+    child.unref();
+    if (!child.pid)
+        throw new Error("Unable to start the bot process");
+    return child.pid;
+}
+async function waitFor(pred, timeoutMs, stepMs = 250) {
+    const until = Date.now() + timeoutMs;
+    while (Date.now() < until) {
+        if (pred())
+            return true;
+        await new Promise((r) => setTimeout(r, stepMs));
+    }
+    return pred();
+}
+function stopProcess(dir) {
+    const status = readBotStatus(dir);
+    if (!status || !isPidAlive(status.pid))
+        return false;
+    try {
+        process.kill(status.pid, "SIGTERM");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function startBot(name, dir, config, json, extra = {}) {
+    if (hasPromotionHold(dir))
+        throw new Error("This bot is held for cloud promotion. Continue its promotion before changing local settings or lifecycle.");
+    if (config.enabled === false)
+        patchBotConfig(dir, { enabled: true });
+    const paths = buildBotDaemonPaths({ name, botDir: dir, hqRoot: config.hqRoot });
+    const d = botDaemonStatus(paths, daemonDeps());
+    let how;
+    if (d.installed && process.platform === "darwin") {
+        const r = startBotDaemon(paths, daemonDeps());
+        how = r.message;
+    }
+    else {
+        const before = readBotStatus(dir);
+        if (before && isPidAlive(before.pid) && before.state === "running") {
+            how = `already running (pid ${before.pid})`;
+        }
+        else {
+            how = `started pid ${spawnDetachedRun(name, dir)}`;
+        }
+    }
+    const running = await waitFor(() => {
+        const s = readBotStatus(dir);
+        return !!s && s.state === "running" && isPidAlive(s.pid);
+    }, 15_000);
+    const status = readBotStatus(dir);
+    if (json) {
+        console.log(JSON.stringify({ ok: running, name, ...extra, how, state: status?.state ?? "unknown", pid: status?.pid ?? null, lastError: status?.lastError ?? null }, null, 2));
+        return;
+    }
+    if (running)
+        console.log(chalk.green(`${name} is running`) + chalk.dim(` (${how})`));
+    else {
+        console.log(chalk.yellow(`${name} did not report running within 15s`) + chalk.dim(` (${how})`));
+        if (status?.lastError)
+            console.log(chalk.dim(`  last error: ${status.lastError}`));
+        console.log(chalk.dim(`  logs: hq bot logs ${name}`));
+    }
+}
+/**
+ * `output`: "json" | "text" print a result; "silent" prints nothing — used
+ * when stop is a step inside rm/restart, whose own JSON must be the only
+ * document on stdout (the desktop app parses it; a second object made it
+ * "unreadable output: trailing characters").
+ */
+async function stopBot(name, dir, config, output) {
+    if (hasPromotionHold(dir))
+        throw new Error("This bot is held for cloud promotion. Continue its promotion before changing local settings or lifecycle.");
+    const paths = buildBotDaemonPaths({ name, botDir: dir, hqRoot: config.hqRoot });
+    if (process.platform === "darwin")
+        stopBotDaemon(paths, daemonDeps());
+    const signalled = stopProcess(dir);
+    const gone = await waitFor(() => {
+        const s = readBotStatus(dir);
+        return !s || !isPidAlive(s.pid);
+    }, 10_000);
+    if (!gone) {
+        const s = readBotStatus(dir);
+        if (s) {
+            try {
+                process.kill(s.pid, "SIGKILL");
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+    if (output === "silent")
+        return;
+    if (output === "json") {
+        console.log(JSON.stringify({ ok: true, name, signalled, stopped: gone }, null, 2));
+        return;
+    }
+    console.log(signalled || gone ? chalk.green(`${name} stopped`) : chalk.dim(`${name} was not running`));
+}
+// ── create ───────────────────────────────────────────────────────────────────
+export async function runBotCreate(nameArg, opts) {
+    const name = validateBotName(nameArg);
+    const runtime = opts.runtime ?? "claude";
+    if (!isBotRuntimeId(runtime)) {
+        throw Object.assign(new Error(`--runtime must be one of ${BOT_RUNTIMES.join(", ")}`), { expected: true });
+    }
+    const memoryMode = opts.memory ?? "synced";
+    if (!isBotMemoryMode(memoryMode)) {
+        throw Object.assign(new Error(`--memory must be one of ${BOT_MEMORY_MODES.join(", ")}`), { expected: true });
+    }
+    const intro = opts.intro !== undefined ? validateBotIntro(opts.intro) : undefined;
+    const kickoff = opts.kickoff !== undefined ? validateBotKickoff(opts.kickoff) : undefined;
+    const model = opts.model !== undefined ? validateBotModel(opts.model) : undefined;
+    const effort = opts.effort !== undefined ? validateBotEffort(runtime, opts.effort) : undefined;
+    if (name === RESERVED_SETUP_BOT_NAME && opts.worker?.trim() !== RESERVED_SETUP_BOT_NAME) {
+        throw Object.assign(new Error(`The name ${RESERVED_SETUP_BOT_NAME} is reserved for HQ's setup bot; create it with --worker ${RESERVED_SETUP_BOT_NAME}.`), { expected: true });
+    }
+    const dir = botDir(name);
+    if (readBotConfig(dir)) {
+        throw Object.assign(new Error(`Bot "${name}" already exists (${dir}). Use hq bot start ${name} or hq bot rm ${name}.`), {
+            expected: true,
+        });
+    }
+    const hqRoot = resolveDefaultHqRoot({ onMissing: "throw" });
+    // Resolve the company worker before provisioning anything (a typo must not
+    // cost an identity).
+    const worker = opts.worker?.trim() ? resolveBotWorker(hqRoot, opts.worker) : null;
+    const token = await ownerToken();
+    const owner = await resolveCallerPersonUid(token);
+    if (!owner)
+        throw Object.assign(new Error("Your HQ login has no person entity yet; open the HQ desktop app once, then retry."), { expected: true });
+    const api = new BotApi({ token: async () => token });
+    let created;
+    try {
+        created = await api.createLocalBot({ name });
+    }
+    catch (err) {
+        if (err instanceof BotApiError && err.code === "LOCAL_BOT_CAP_REACHED") {
+            // Only an older server still enforces a cap; current hq-pro-agents has none.
+            throw Object.assign(new Error("The server refused another bot (its bot limit is reached). Remove one with hq bot rm <name>, or update the server."), {
+                expected: true,
+            });
+        }
+        throw err;
+    }
+    const agentUid = created.agent.uid;
+    writeBotCreds(dir, {
+        username: created.identity.cognitoUsername,
+        secret: created.identity.secret,
+        entityType: "agent",
+        entityUid: agentUid,
+        clientId: DEFAULT_COGNITO.clientId,
+        region: DEFAULT_COGNITO.region,
+    });
+    const config = {
+        v: 1,
+        name,
+        agentUid,
+        ownerUid: created.agent.ownerUid ?? owner,
+        runtime,
+        ...(model ? { model } : {}),
+        ...(effort ? { effort } : {}),
+        ...(opts.autoApprove === false ? { autoApprove: false } : {}),
+        hqRoot,
+        ...(worker
+            ? {
+                workerDir: worker.path,
+                workerSource: "worker",
+                workerId: worker.id,
+                ...(worker.company ? { companySlug: worker.company } : {}),
+            }
+            : { workerDir: botWorkerRelDir(name) }),
+        // "local" memory is an absolute path outside the synced HQ tree; "synced"
+        // memory is hqRoot-relative (and, for a worker-sourced bot, the bot's own
+        // personal/workers/<name>/memory so the shared company tree is never
+        // written to).
+        ...(memoryMode === "local"
+            ? { memoryDir: botLocalMemoryDir(dir) }
+            : worker
+                ? { memoryDir: path.join(botWorkerRelDir(name), "memory") }
+                : {}),
+        ...(intro ? { intro } : {}),
+        ...(kickoff ? { kickoff } : {}),
+        createdAt: new Date().toISOString(),
+        enabled: true,
+    };
+    writeBotConfig(dir, config);
+    // A worker-sourced bot never writes into the company tree: only its own
+    // memory folder is scaffolded.
+    const scaffoldOpts = { memoryDir: config.memoryDir };
+    const scaffold = worker
+        ? scaffoldBotMemory(hqRoot, name, undefined, scaffoldOpts)
+        : scaffoldBotWorker(hqRoot, name, agentUid, runtime, undefined, scaffoldOpts);
+    createBotLogger(dir)("info", `created ${name} (${agentUid}) runtime=${runtime}${worker ? ` worker=${worker.id} company=${worker.company ?? "-"}` : ""} memory=${memoryMode}`);
+    const created_ = {
+        agentUid,
+        runtime,
+        dir,
+        worker: worker ? path.join(hqRoot, worker.path) : scaffold.dir,
+        workerId: worker?.id ?? null,
+        companySlug: worker?.company ?? null,
+        memory: memoryMode,
+        memoryDir: scaffold.memoryDir,
+        intro: intro ?? null,
+        kickoff: kickoff ?? null,
+        model: model ?? null,
+        effort: effort ?? DEFAULT_BOT_EFFORT,
+    };
+    let daemonMessage = null;
+    if (opts.daemon !== false && process.platform === "darwin") {
+        const r = installBotDaemon(buildBotDaemonPaths({ name, botDir: dir, hqRoot }), daemonDeps());
+        daemonMessage = r.message;
+    }
+    if (!opts.json) {
+        console.log(chalk.green(`Created bot ${chalk.bold(name)}`) + chalk.dim(` (${agentUid}, ${runtime})`));
+        if (worker)
+            console.log(chalk.dim(`  worker: ${worker.id}${worker.company ? ` (${worker.company})` : ""} — ${path.join(hqRoot, worker.path)}`));
+        if (!worker)
+            console.log(chalk.dim(`  worker: ${scaffold.dir}`));
+        console.log(chalk.dim(`  memory: ${scaffold.memoryDir} (${memoryMode})`));
+        console.log(chalk.dim(`  state:  ${dir}`));
+        if (daemonMessage)
+            console.log(chalk.dim(`  ${daemonMessage}`));
+    }
+    if (opts.start !== false) {
+        if (daemonMessage && /loaded\)/.test(daemonMessage)) {
+            // RunAtLoad already started it.
+            const running = await waitFor(() => readBotStatus(dir)?.state === "running", 20_000);
+            if (opts.json) {
+                console.log(JSON.stringify({ ok: true, name, ...created_, daemon: daemonMessage, running }, null, 2));
+            }
+            else if (running)
+                console.log(chalk.green(`${name} is online — it will DM you an introduction shortly.`));
+            else
+                console.log(chalk.yellow(`${name} has not reported running yet; check hq bot logs ${name}`));
+            return;
+        }
+        await startBot(name, dir, config, Boolean(opts.json), { ...created_, daemon: daemonMessage });
+        return;
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ ok: true, name, ...created_, daemon: daemonMessage, running: false }, null, 2));
+    }
+}
+// ── workers ──────────────────────────────────────────────────────────────────
+export async function runBotWorkers(opts) {
+    const hqRoot = resolveDefaultHqRoot({ onMissing: "throw" });
+    const workers = listBotWorkerOptions(hqRoot);
+    if (opts.json) {
+        console.log(JSON.stringify({ workers }, null, 2));
+        return;
+    }
+    if (workers.length === 0) {
+        console.log(chalk.gray("No workers in this HQ (a worker needs a worker.yaml under companies/<co>/workers/<id>/ or core/workers/)."));
+        return;
+    }
+    for (const w of workers) {
+        console.log(`${chalk.bold(w.id.padEnd(28))} ${(w.company ?? (w.source === "core" ? "core" : "-")).padEnd(14)} ${w.type.padEnd(12)} ${chalk.dim(w.summary.slice(0, 80))}`);
+    }
+    console.log(chalk.dim(`\nCreate a bot from one: hq bot create <name> --worker <id>`));
+}
+// ── run (resident) ───────────────────────────────────────────────────────────
+async function runBotResident(nameArg) {
+    const { name, dir, config } = requireBot(nameArg);
+    const api = new BotApi({ token: botTokenSupplier(dir) });
+    const owner = new OwnerContextCache(() => lookupOwnerContext(config.ownerUid), Date.now, undefined, config.ownerUid);
+    const handle = await runBot({ dir, config, api, runtime: runtimeFor(config.runtime), ownerContext: () => owner.get() });
+    await handle.done;
+    void name;
+}
+// ── list / status / logs ─────────────────────────────────────────────────────
+async function runBotList(opts) {
+    const rows = listBotNames(botsRoot()).map((n) => rowFor(n));
+    await decorateOnline(rows);
+    if (opts.json) {
+        console.log(JSON.stringify({ bots: rows }, null, 2));
+        return;
+    }
+    if (rows.length === 0) {
+        console.log(chalk.gray("No local bots yet. Create one with: hq bot create assistant"));
+        return;
+    }
+    for (const r of rows) {
+        console.log(`${chalk.bold(r.name.padEnd(16))} ${r.agentUid}  ${r.runtime.padEnd(6)}  ${humanOnline(r).padEnd(8)}  ${r.processAlive ? chalk.green(`pid ${r.pid}`) : chalk.gray(r.state)}${r.daemonInstalled ? chalk.dim("  launchd") : ""}${r.workerId ? chalk.dim(`  worker ${r.workerId}${r.companySlug ? ` (${r.companySlug})` : ""}`) : ""}`);
+    }
+}
+async function runBotStatus(nameArg, opts) {
+    const { name, dir } = requireBot(nameArg);
+    const row = rowFor(name);
+    await decorateOnline([row]);
+    const status = readBotStatus(dir);
+    const creds = readBotCredsIdentity(dir);
+    if (opts.json) {
+        console.log(JSON.stringify({ ...row, credsPresent: !!creds, status }, null, 2));
+        return;
+    }
+    console.log(`${chalk.bold(name)}  ${row.agentUid}`);
+    console.log(`  runtime:    ${row.runtime}  model ${row.model ?? "default"}  thinking ${row.effort}${row.effortIsDefault ? " (default)" : ""}`);
+    if (row.workerId)
+        console.log(`  worker:     ${row.workerId}${row.companySlug ? ` (company ${row.companySlug})` : ""}  ${chalk.dim(row.workerDir)}`);
+    console.log(`  memory:     ${row.memory}  ${chalk.dim(row.memoryDir)}`);
+    console.log(`  process:    ${row.processAlive ? chalk.green(`running (pid ${row.pid})`) : chalk.gray(row.state)}`);
+    console.log(`  HQ online:  ${humanOnline(row)}${row.lastHeartbeatAt ? chalk.dim(`  last heartbeat ${row.lastHeartbeatAt}`) : ""}`);
+    console.log(`  launchd:    ${row.daemonInstalled ? (row.daemonLoaded ? "installed, loaded" : "installed, not loaded") : "not installed"}`);
+    console.log(`  creds:      ${creds ? `present for ${creds.entityUid}` : chalk.red("missing")}`);
+    if (status) {
+        console.log(`  started:    ${status.startedAt}   restarts: ${status.restarts}   replies: ${status.repliesSent}`);
+        if (status.lastError)
+            console.log(`  last error: ${chalk.yellow(status.lastError)}`);
+    }
+    console.log(chalk.dim(`  state dir:  ${dir}`));
+}
+async function runBotLogs(nameArg, opts) {
+    const { dir } = requireBot(nameArg);
+    const file = botLogPath(dir);
+    const n = Math.max(1, Number.parseInt(opts.lines ?? "50", 10) || 50);
+    if (!fs.existsSync(file)) {
+        console.log(chalk.gray("No log yet."));
+        return;
+    }
+    const initial = fs.readFileSync(file, "utf8").split("\n").filter(Boolean);
+    for (const line of initial.slice(-n))
+        console.log(line);
+    if (!opts.follow)
+        return;
+    let size = fs.statSync(file).size;
+    await new Promise(() => {
+        fs.watchFile(file, { interval: 500 }, (curr) => {
+            if (curr.size < size)
+                size = 0;
+            if (curr.size > size) {
+                const fd = fs.openSync(file, "r");
+                const buf = Buffer.alloc(curr.size - size);
+                fs.readSync(fd, buf, 0, buf.length, size);
+                fs.closeSync(fd);
+                process.stdout.write(buf.toString());
+                size = curr.size;
+            }
+        });
+    });
+}
+// ── rm ───────────────────────────────────────────────────────────────────────
+async function confirm(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(/^y(es)?$/i.test(answer.trim()));
+        });
+    });
+}
+async function runBotRm(nameArg, opts) {
+    const { name, dir, config } = requireBot(nameArg);
+    if (hasPromotionHold(dir))
+        throw new Error("This bot is held for cloud promotion. Continue its promotion before changing local settings or lifecycle.");
+    if (!opts.yes) {
+        const ok = await confirm(`Remove bot "${name}" (${config.agentUid}), its identity, and its local state? [y/N] `);
+        if (!ok) {
+            console.log(chalk.dim("Cancelled."));
+            return;
+        }
+    }
+    await stopBot(name, dir, config, "silent").catch(() => { });
+    const paths = buildBotDaemonPaths({ name, botDir: dir, hqRoot: config.hqRoot });
+    const daemon = uninstallBotDaemon(paths, daemonDeps());
+    const token = await ownerToken();
+    const api = new BotApi({ token: async () => token });
+    let identity;
+    try {
+        identity = await api.deleteLocalBot(config.agentUid);
+    }
+    catch (err) {
+        if (err instanceof BotApiError && err.status === 404)
+            identity = { alreadyGone: true };
+        else
+            throw err;
+    }
+    const terminal = "alreadyGone" in identity ? true : identity.terminal;
+    deleteBotCreds(dir);
+    if (terminal)
+        fs.rmSync(dir, { recursive: true, force: true });
+    if (opts.json) {
+        console.log(JSON.stringify({ ok: terminal, name, agentUid: config.agentUid, daemon: daemon.message, identity, localStateRemoved: terminal, workerKept: path.join(config.hqRoot, config.workerDir) }, null, 2));
+        return;
+    }
+    if (terminal) {
+        console.log(chalk.green(`Removed bot ${name}`) + chalk.dim(` (${config.agentUid}); worker folder kept at ${path.join(config.hqRoot, config.workerDir)}`));
+    }
+    else {
+        console.log(chalk.yellow(`Bot ${name} is stopped locally but its cloud identity is not fully removed yet.`));
+        if ("failures" in identity && identity.failures) {
+            for (const [step, msg] of Object.entries(identity.failures))
+                console.log(chalk.dim(`  ${step}: ${msg}`));
+        }
+        console.log(chalk.dim(`  Re-run: hq bot rm ${name} --yes`));
+    }
+}
+/**
+ * `hq bot set <name> --model <id|default> --effort <level|default>`: change
+ * what the bot thinks with. bot.json is re-read on every turn, so the next
+ * message uses it; no restart.
+ */
+export async function runBotSet(nameArg, opts) {
+    const { name, dir, config } = requireBot(nameArg);
+    if (hasPromotionHold(dir))
+        throw new Error("This bot is held for cloud promotion. Continue its promotion before changing local settings or lifecycle.");
+    if (opts.model === undefined && opts.effort === undefined) {
+        throw Object.assign(new Error("Nothing to change: pass --model <id|default> and/or --effort <level|default>."), { expected: true });
+    }
+    const next = { ...config };
+    if (opts.model !== undefined) {
+        const model = validateBotModel(opts.model);
+        if (model)
+            next.model = model;
+        else
+            delete next.model;
+    }
+    if (opts.effort !== undefined) {
+        const effort = validateBotEffort(config.runtime, opts.effort);
+        if (effort)
+            next.effort = effort;
+        else
+            delete next.effort;
+    }
+    writeBotConfig(dir, next);
+    createBotLogger(dir)("info", `settings: model=${next.model ?? "default"} effort=${effectiveBotEffort(next)}${next.effort ? "" : " (default)"}`);
+    const result = {
+        ok: true,
+        name,
+        runtime: config.runtime,
+        model: next.model ?? null,
+        effort: effectiveBotEffort(next),
+        effortIsDefault: !next.effort,
+        effortLevels: BOT_EFFORT_LEVELS[config.runtime],
+    };
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    console.log(chalk.green(`${name} now thinks with ${result.model ?? "the default model"} at ${result.effort} effort (from its next message).`));
+}
+async function runBotIntro(nameArg) {
+    const { name, dir, config } = requireBot(nameArg);
+    if (hasPromotionHold(dir))
+        throw new Error("This bot is held for cloud promotion. Continue its promotion before changing local settings or lifecycle.");
+    const api = new BotApi({ token: botTokenSupplier(dir) });
+    await api.sendDm({ toPersonUid: config.ownerUid, body: introDmText(name, config.runtime, config.intro) });
+    patchBotConfig(dir, { introSentAt: new Date().toISOString() });
+    console.log(chalk.green(`${name} introduced itself to you.`));
+}
+// ── registration ─────────────────────────────────────────────────────────────
+export function registerBotCommand(program) {
+    const bot = program
+        .command("bot")
+        .description("Personal local bots that run on this computer with your own model login");
+    registerBotContinuityCommand(bot);
+    bot.command("promote <name>")
+        .description("Move this local bot to cloud compute, preserving its identity and private context")
+        .requiredOption("--company <uid>", "Destination company identity")
+        .option("--json", "Print promotion progress as JSON")
+        .action((name, opts) => wrap(async () => {
+        const { dir, config } = requireBot(name);
+        const token = await ownerToken(false);
+        const api = new BotApi({ token: async () => token });
+        const result = await promoteLocalBot({ dir, config, companyUid: opts.company, api });
+        const details = result.pending ? await api.promotionDetails(config.agentUid, opts.company) : null;
+        if (opts.json)
+            console.log(JSON.stringify({ ...result, pairing: details?.pairing ?? null, ...(details?.failure ? { failure: details.failure } : {}) }));
+        else if (details?.failure)
+            console.log(`${name}: ${details.failure}`);
+        else if (details?.pairing)
+            console.log(`${name}: connect the cloud bot to your ChatGPT subscription at ${details.pairing.url}, using code ${details.pairing.code}. Then run the same command to continue.`);
+        else
+            console.log(`${name}: ${result.promotion.phase}.${result.pending ? " Run the same command to continue promotion." : ""}`);
+    })());
+    bot
+        .command("create <name>")
+        .description("Provision a local bot identity, scaffold its worker folder, install its launchd agent, and start it")
+        .option("--runtime <runtime>", `Model CLI to run the bot with: ${BOT_RUNTIMES.join("|")}`, "claude")
+        .option("--model <model>", "Model override passed to the runtime CLI")
+        .option("--effort <level>", `Thinking level: claude ${BOT_EFFORT_LEVELS.claude.join("|")}; codex ${BOT_EFFORT_LEVELS.codex.join("|")}; grok ${BOT_EFFORT_LEVELS.grok.join("|")} (default ${DEFAULT_BOT_EFFORT})`)
+        .option("--no-auto-approve", "Keep the runtime's permission gates (default: everything pre-approved; a headless bot cannot answer prompts)")
+        .option("--worker <workerId>", "Run an existing company or core worker (see hq bot workers): its instructions, skills, context, and company policies; a company worker binds the bot to that company on every turn")
+        .option("--intro <text>", `The hello the bot DMs you when it first comes online (verbatim, up to ${BOT_INTRO_MAX_CHARS} chars)`)
+        .option("--kickoff <prompt>", `A first task the bot starts on by itself right after its hello: one model turn run as if you had sent it, answered in your DM, once (up to ${BOT_KICKOFF_MAX_CHARS} chars)`)
+        .option("--memory <where>", "Where the bot keeps its memory: synced (personal/workers/<name>/memory in HQ) or local (~/.hq/bots/<name>/memory, this computer only)", "synced")
+        .option("--no-daemon", "Do not install the launchd agent (macOS)")
+        .option("--no-start", "Create without starting")
+        .option("--json", "Print machine-readable JSON")
+        .action((name, opts) => wrap(() => runBotCreate(name, opts))());
+    bot
+        .command("workers")
+        .description("List the workers (templates) a bot can be created from (hq bot create <name> --worker <id>)")
+        .option("--json", "Print machine-readable JSON")
+        .action((opts) => wrap(() => runBotWorkers(opts))());
+    bot
+        .command("list")
+        .description("List local bots with runtime, online state, and pid")
+        .option("--json", "Print machine-readable JSON")
+        .action((opts) => wrap(() => runBotList(opts))());
+    bot
+        .command("start <name>")
+        .description("Start the bot (via launchd when installed, else a detached process)")
+        .option("--json", "Print machine-readable JSON")
+        .action((name, opts) => wrap(async () => {
+        const b = requireBot(name);
+        await startBot(b.name, b.dir, b.config, Boolean(opts.json));
+    })());
+    bot
+        .command("stop <name>")
+        .description("Stop the bot process (it starts again at next login while its launchd agent is installed)")
+        .option("--json", "Print machine-readable JSON")
+        .action((name, opts) => wrap(async () => {
+        const b = requireBot(name);
+        await stopBot(b.name, b.dir, b.config, opts.json ? "json" : "text");
+    })());
+    bot
+        .command("restart <name>")
+        .description("Stop then start the bot")
+        .option("--json", "Print machine-readable JSON")
+        .action((name, opts) => wrap(async () => {
+        const b = requireBot(name);
+        await stopBot(b.name, b.dir, b.config, "silent");
+        await startBot(b.name, b.dir, b.config, Boolean(opts.json));
+    })());
+    bot
+        .command("status <name>")
+        .description("Show the bot's process, heartbeat, launchd, and credential state")
+        .option("--json", "Print machine-readable JSON")
+        .action((name, opts) => wrap(() => runBotStatus(name, opts))());
+    bot
+        .command("logs <name>")
+        .description("Show the bot's log")
+        .option("-f, --follow", "Keep printing new lines")
+        .option("-n, --lines <n>", "Number of trailing lines", "50")
+        .action((name, opts) => wrap(() => runBotLogs(name, opts))());
+    bot
+        .command("run <name>")
+        .description("Run the bot in the foreground (this is what launchd runs)")
+        .action((name) => wrap(() => runBotResident(name))());
+    bot
+        .command("rm <name>")
+        .description("Stop the bot, remove its launchd agent, delete its cloud identity and local state")
+        .option("-y, --yes", "Skip the confirmation prompt")
+        .option("--json", "Print machine-readable JSON")
+        .action((name, opts) => wrap(() => runBotRm(name, opts))());
+    bot
+        .command("set <name>")
+        .description("Change the model and thinking level a bot uses (applies from its next message)")
+        .option("--model <model>", "Model id for the runtime CLI, or default for the CLI's own default")
+        .option("--effort <level>", `Thinking level (claude ${BOT_EFFORT_LEVELS.claude.join("|")}; codex ${BOT_EFFORT_LEVELS.codex.join("|")}; grok ${BOT_EFFORT_LEVELS.grok.join("|")}), or default (${DEFAULT_BOT_EFFORT})`)
+        .option("--json", "Print machine-readable JSON")
+        .action((name, opts) => wrap(() => runBotSet(name, opts))());
+    bot
+        .command("intro <name>")
+        .description("Have the bot re-send its introduction DM to you")
+        .action((name) => wrap(() => runBotIntro(name))());
+    const daemon = bot.command("daemon").description("Manage the bot's launchd user agent (macOS)");
+    daemon
+        .command("install <name>")
+        .description("Install and load the LaunchAgent so the bot starts at login and restarts on crash")
+        .option("--json", "Print machine-readable JSON")
+        .action((name, opts) => wrap(async () => {
+        const b = requireBot(name);
+        const r = installBotDaemon(buildBotDaemonPaths({ name: b.name, botDir: b.dir, hqRoot: b.config.hqRoot }), daemonDeps());
+        console.log(opts.json ? JSON.stringify({ ok: r.installed, ...r }, null, 2) : r.message);
+    })());
+    daemon
+        .command("uninstall <name>")
+        .description("Unload and remove the LaunchAgent")
+        .option("--json", "Print machine-readable JSON")
+        .action((name, opts) => wrap(async () => {
+        const b = requireBot(name);
+        const r = uninstallBotDaemon(buildBotDaemonPaths({ name: b.name, botDir: b.dir, hqRoot: b.config.hqRoot }), daemonDeps());
+        console.log(opts.json ? JSON.stringify({ ok: true, ...r }, null, 2) : r.message);
+    })());
+    daemon
+        .command("status <name>")
+        .description("Show whether the LaunchAgent is installed and loaded")
+        .option("--json", "Print machine-readable JSON")
+        .action((name, opts) => wrap(async () => {
+        const b = requireBot(name);
+        const r = botDaemonStatus(buildBotDaemonPaths({ name: b.name, botDir: b.dir, hqRoot: b.config.hqRoot }), daemonDeps());
+        console.log(opts.json ? JSON.stringify({ ok: true, ...r }, null, 2) : r.message);
+    })());
+}
+//# sourceMappingURL=bot.js.map