@indigoai-us/hq-cli 5.314.0 → 5.316.0

package/dist/lib/bot/attachments.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Chat attachments for local bot turns (`hq bot run`).
+ *
+ * A local bot's runtime (claude / codex / grok) runs without the `hq agent
+ * mcp` server, so it cannot call `hq_attachment_fetch`. The runner therefore
+ * downloads every file named on an inbox item BEFORE the turn, through the
+ * same validated path the MCP tool uses (`fetchChatAttachment`: key shape,
+ * DM-pair membership, company gate, size cap, private file), with the bot's
+ * own machine credentials, into the bot's own directory. The turn text gets a
+ * short block naming each file and where it is on disk; a file that could
+ * not be fetched gets a one-line reason instead of a path. Doing it in the
+ * runner makes it work the same for every runtime.
+ */
+import type { VaultObjectDownloader } from "../agent-kit/attachment-download.js";
+import type { InboxAttachment } from "../agent-kit/inbox-state.js";
+export interface TurnAttachment {
+    /** Display name (sanitized file name once saved). */
+    name: string;
+    contentType?: string;
+    sizeBytes?: number;
+    /** Set when the file was saved; absent when `error` is set. */
+    localPath?: string;
+    /** Bounded inline rendering for text-like files. */
+    text?: string;
+    /** How to open a non-text file. */
+    note?: string;
+    /** One-line reason the file was not downloaded. */
+    error?: string;
+}
+/**
+ * Download each attachment for one turn. Never throws: a per-file failure is
+ * returned as `error` (the caller logs it and shows it to the model), so one
+ * bad reference never costs the sender their reply.
+ */
+export declare function downloadTurnAttachments(input: {
+    attachments: readonly InboxAttachment[];
+    botEntityUid: string;
+    attachmentsDir: string;
+    /** The bot's own company uids (its server memberships); consulted only for a cmp_ scope. */
+    resolveBotCompanyUids: () => Promise<readonly string[]>;
+    download?: VaultObjectDownloader;
+}): Promise<TurnAttachment[]>;
+/** The plain block appended to the turn text. Empty when there are no files. */
+export declare function attachmentTurnBlock(files: readonly TurnAttachment[]): string;
+//# sourceMappingURL=attachments.d.ts.map

package/dist/lib/bot/attachments.js

@@ -0,0 +1,89 @@
+/**
+ * Chat attachments for local bot turns (`hq bot run`).
+ *
+ * A local bot's runtime (claude / codex / grok) runs without the `hq agent
+ * mcp` server, so it cannot call `hq_attachment_fetch`. The runner therefore
+ * downloads every file named on an inbox item BEFORE the turn, through the
+ * same validated path the MCP tool uses (`fetchChatAttachment`: key shape,
+ * DM-pair membership, company gate, size cap, private file), with the bot's
+ * own machine credentials, into the bot's own directory. The turn text gets a
+ * short block naming each file and where it is on disk; a file that could
+ * not be fetched gets a one-line reason instead of a path. Doing it in the
+ * runner makes it work the same for every runtime.
+ */
+import { fetchChatAttachment, sanitizeAttachmentFileName } from "../agent-kit/mcp/attachments.js";
+function oneLine(s, max = 300) {
+    const flat = s.replace(/\s+/g, " ").trim();
+    return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+}
+/**
+ * Download each attachment for one turn. Never throws: a per-file failure is
+ * returned as `error` (the caller logs it and shows it to the model), so one
+ * bad reference never costs the sender their reply.
+ */
+export async function downloadTurnAttachments(input) {
+    const out = [];
+    for (const ref of input.attachments) {
+        const name = sanitizeAttachmentFileName(ref.name || ref.vaultPath.split("/").pop() || "file");
+        const base = {
+            name,
+            ...(ref.contentType ? { contentType: ref.contentType } : {}),
+            ...(typeof ref.sizeBytes === "number" ? { sizeBytes: ref.sizeBytes } : {}),
+        };
+        if (!ref.companyUid) {
+            out.push({ ...base, error: "the message did not say which vault holds this file (no companyUid)" });
+            continue;
+        }
+        if (!input.download) {
+            out.push({ ...base, error: "this bot runner cannot download attachments" });
+            continue;
+        }
+        try {
+            const saved = await fetchChatAttachment({
+                vaultPath: ref.vaultPath,
+                scopeUid: ref.companyUid,
+                ...(ref.name ? { name: ref.name } : {}),
+                ...(ref.contentType ? { contentType: ref.contentType } : {}),
+                botEntityUid: input.botEntityUid,
+                resolveBotCompanyUids: input.resolveBotCompanyUids,
+                attachmentsDir: input.attachmentsDir,
+                download: input.download,
+            });
+            out.push({
+                name: saved.name,
+                ...(saved.contentType ? { contentType: saved.contentType } : {}),
+                sizeBytes: saved.sizeBytes,
+                localPath: saved.localPath,
+                ...(saved.text !== undefined ? { text: saved.text } : {}),
+                ...(saved.note ? { note: saved.note } : {}),
+            });
+        }
+        catch (err) {
+            out.push({ ...base, error: oneLine(err instanceof Error ? err.message : String(err)) });
+        }
+    }
+    return out;
+}
+/** The plain block appended to the turn text. Empty when there are no files. */
+export function attachmentTurnBlock(files) {
+    if (files.length === 0)
+        return "";
+    const lines = [`[Attached files: ${files.length}]`];
+    for (const f of files) {
+        const meta = [f.contentType, typeof f.sizeBytes === "number" ? `${f.sizeBytes} bytes` : undefined].filter(Boolean).join(", ");
+        const head = `- ${f.name}${meta ? ` (${meta})` : ""}`;
+        if (f.error || !f.localPath) {
+            lines.push(`${head}: not downloaded: ${f.error ?? "unknown error"}`);
+            continue;
+        }
+        lines.push(`${head}: saved at ${f.localPath}`);
+        if (f.text !== undefined) {
+            lines.push(`  Contents of ${f.name}:`, `----- begin ${f.name} -----`, f.text, `----- end ${f.name} -----`);
+        }
+        else if (f.note) {
+            lines.push(`  ${f.note.replace(/localPath/g, "the saved file")}`);
+        }
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=attachments.js.map

package/dist/lib/bot/cli-update.d.ts

@@ -0,0 +1,138 @@
+/**
+ * A resident bot notices that the hq-cli install it was started from has been
+ * updated on disk, and restarts itself onto the new code.
+ *
+ * `hq bot run <name>` loads the CLI once and runs for days. The install under
+ * it moves on (the attended self-updater, the `hq daemon` updater, a manual
+ * `npm i -g`), but nothing reloaded a running bot: on 2026-09-24 the bot
+ * dr-love was still running code from 2026-09-19 while its install had moved
+ * to 5.163.0, so a shipped attachment fix never reached it.
+ *
+ * The watcher re-resolves the entry script the process was launched with
+ * (process.argv[1], the same path launchd / systemd / `hq daemon` will launch
+ * again) to its package.json on a timer. Once a complete, valid, different
+ * version is seen on consecutive checks, the run loop stops taking new inbox
+ * items, lets the running turns finish, and exits with
+ * CLI_UPDATE_RESTART_EXIT_CODE so its supervisor starts it again on the new
+ * code (or, with no supervisor, starts its own replacement first).
+ *
+ * Convergence (policy hq-self-updater-must-verify-convergence-after-install):
+ * the restart is recorded in <botDir>/cli-update.json before the exit. The next
+ * process checks the version it actually loaded against that record: a match
+ * is logged as converged; a process that came back on the OLD version blocks
+ * that target for CLI_UPDATE_NOT_CONVERGED_COOLDOWN_MS instead of restarting
+ * again. Restarts are also capped per window, so an install that keeps
+ * flipping cannot turn into a restart loop.
+ */
+import type { BotLogger } from "./log.js";
+/**
+ * Exit code for "restart me onto the updated CLI". Non-zero on purpose: every
+ * supervisor a bot runs under restarts only a failed exit — launchd
+ * KeepAlive{SuccessfulExit:false}, systemd Restart=on-failure, and the
+ * `hq daemon` "on-failure" bot units — while a clean exit 0 (a stopped or
+ * disabled bot) stays down. Same value as the daemon's RESTART_EXIT_CODE.
+ */
+export declare const CLI_UPDATE_RESTART_EXIT_CODE = 75;
+/** How often the installed package.json is read. */
+export declare const CLI_UPDATE_CHECK_INTERVAL_MS = 60000;
+/** Set to "1" to turn the watcher off (development runs). */
+export declare const CLI_UPDATE_DISABLE_ENV = "HQ_BOT_NO_CLI_UPDATE_RESTART";
+export type InstalledCliRead = {
+    ok: true;
+    version: string;
+    packageRoot: string;
+} | {
+    ok: false;
+    reason: string;
+    packageRoot?: string;
+};
+export interface InstalledCliFs {
+    realpathSync(p: string): string;
+    readFileSync(p: string, encoding: "utf8"): string;
+}
+/**
+ * The hq-cli version installed behind `entry`, resolved the way the next launch
+ * of the same command line will resolve it: follow the symlinks now (a pnpm or
+ * versioned layout moves the link, npm rewrites the directory in place), then
+ * walk up to the package.json that names this CLI. Anything short of a
+ * readable manifest with a valid semver version is not a version.
+ */
+export declare function readInstalledCli(entry: string, io?: InstalledCliFs): InstalledCliRead;
+export interface CliUpdate {
+    from: string;
+    to: string;
+    packageRoot: string;
+}
+interface CliUpdateLedger {
+    v: 1;
+    /** Written just before an update restart; settled by the next process. */
+    pending?: {
+        from: string;
+        to: string;
+        at: string;
+    };
+    /** ISO times of recent update restarts (for the per-window cap). */
+    restarts: string[];
+    /** A target that did not converge, and when it may be tried again. */
+    blocked?: {
+        version: string;
+        until: string;
+    };
+}
+export declare function readCliUpdateLedger(dir: string): CliUpdateLedger;
+/** What the run loop needs from the watcher (injectable in tests). */
+export interface CliUpdateWatch {
+    /** The version of the code this process loaded. */
+    readonly runningVersion: string;
+    /** Settle the previous restart (converged or not) and say what is watched. */
+    startup(log: BotLogger): void;
+    /** A confirmed update to restart onto, or null. Cheap; rate-limits itself. */
+    poll(log: BotLogger): CliUpdate | null;
+    /** Record the restart about to happen, before the process exits. */
+    recordRestart(update: CliUpdate): void;
+}
+export interface CliUpdateWatcherOptions {
+    dir: string;
+    /** The script this process was launched with (process.argv[1]); null = do not watch. */
+    entry: string | null;
+    runningVersion?: string;
+    now?: () => number;
+    read?: (entry: string) => InstalledCliRead;
+    /** True while an installer is provably rewriting the package dir. */
+    rewriteInProgress?: (packageRoot: string) => boolean;
+    checkIntervalMs?: number;
+    confirmations?: number;
+    restartLimit?: number;
+    restartWindowMs?: number;
+    cooldownMs?: number;
+}
+export declare function createCliUpdateWatcher(opts: CliUpdateWatcherOptions): CliUpdateWatch;
+/**
+ * Who starts this bot again after it exits.
+ *
+ * - "hq-daemon": `hq daemon` sets HQ_DAEMON_UNIT=bots:<name> on its children;
+ *   the unit is "on-failure" (supervisor.ts).
+ * - "launchd": launchd sets XPC_SERVICE_NAME to the job label for every job it
+ *   spawns, including LaunchAgents installed before this code existed.
+ * - "systemd": the unit `hq-bot-<name>.service` shows up in the process cgroup.
+ * - "none": `hq bot start` without a service (Windows, --no-daemon, a Linux
+ *   unit never enabled) or a foreground run. Nobody restarts this process.
+ */
+export type BotSupervisor = "hq-daemon" | "launchd" | "systemd" | "none";
+export declare function detectBotSupervisor(name: string, opts?: {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    readCgroup?: () => string | null;
+}): BotSupervisor;
+/**
+ * The last step of an update restart, run after the pid lock is released and
+ * just before the exit. A supervised bot only has to exit; an unsupervised one
+ * starts its replacement on the same entry script (now the new code) first,
+ * because nothing else will.
+ */
+export declare function handOffToUpdatedCli(name: string, log: BotLogger, deps: {
+    supervisor?: BotSupervisor;
+    spawnReplacement: () => number;
+}): BotSupervisor;
+export {};
+//# sourceMappingURL=cli-update.d.ts.map

package/dist/lib/bot/cli-update.js

@@ -0,0 +1,278 @@
+/**
+ * A resident bot notices that the hq-cli install it was started from has been
+ * updated on disk, and restarts itself onto the new code.
+ *
+ * `hq bot run <name>` loads the CLI once and runs for days. The install under
+ * it moves on (the attended self-updater, the `hq daemon` updater, a manual
+ * `npm i -g`), but nothing reloaded a running bot: on 2026-09-24 the bot
+ * dr-love was still running code from 2026-09-19 while its install had moved
+ * to 5.163.0, so a shipped attachment fix never reached it.
+ *
+ * The watcher re-resolves the entry script the process was launched with
+ * (process.argv[1], the same path launchd / systemd / `hq daemon` will launch
+ * again) to its package.json on a timer. Once a complete, valid, different
+ * version is seen on consecutive checks, the run loop stops taking new inbox
+ * items, lets the running turns finish, and exits with
+ * CLI_UPDATE_RESTART_EXIT_CODE so its supervisor starts it again on the new
+ * code (or, with no supervisor, starts its own replacement first).
+ *
+ * Convergence (policy hq-self-updater-must-verify-convergence-after-install):
+ * the restart is recorded in <botDir>/cli-update.json before the exit. The next
+ * process checks the version it actually loaded against that record: a match
+ * is logged as converged; a process that came back on the OLD version blocks
+ * that target for CLI_UPDATE_NOT_CONVERGED_COOLDOWN_MS instead of restarting
+ * again. Restarts are also capped per window, so an install that keeps
+ * flipping cannot turn into a restart loop.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import semver from "semver";
+import { CLI_NAME, CLI_VERSION } from "../../cli-version.js";
+import { installRewriteInProgress } from "../../utils/install-tree-torn.js";
+import { updateLockPath } from "../../utils/update-lock.js";
+import { launchdLabel } from "./paths.js";
+/**
+ * Exit code for "restart me onto the updated CLI". Non-zero on purpose: every
+ * supervisor a bot runs under restarts only a failed exit — launchd
+ * KeepAlive{SuccessfulExit:false}, systemd Restart=on-failure, and the
+ * `hq daemon` "on-failure" bot units — while a clean exit 0 (a stopped or
+ * disabled bot) stays down. Same value as the daemon's RESTART_EXIT_CODE.
+ */
+export const CLI_UPDATE_RESTART_EXIT_CODE = 75;
+/** How often the installed package.json is read. */
+export const CLI_UPDATE_CHECK_INTERVAL_MS = 60_000;
+/** Consecutive checks that must agree on the new version before acting. */
+const CLI_UPDATE_CONFIRMATIONS = 2;
+/** At most this many update restarts per window, whatever the versions. */
+const CLI_UPDATE_RESTART_LIMIT = 4;
+const CLI_UPDATE_RESTART_WINDOW_MS = 60 * 60_000;
+/** A restart that came back on the old version blocks that target this long. */
+const CLI_UPDATE_NOT_CONVERGED_COOLDOWN_MS = 6 * 60 * 60_000;
+/** Set to "1" to turn the watcher off (development runs). */
+export const CLI_UPDATE_DISABLE_ENV = "HQ_BOT_NO_CLI_UPDATE_RESTART";
+const CLI_UPDATE_LEDGER_FILE = "cli-update.json";
+/**
+ * The hq-cli version installed behind `entry`, resolved the way the next launch
+ * of the same command line will resolve it: follow the symlinks now (a pnpm or
+ * versioned layout moves the link, npm rewrites the directory in place), then
+ * walk up to the package.json that names this CLI. Anything short of a
+ * readable manifest with a valid semver version is not a version.
+ */
+export function readInstalledCli(entry, io = fs) {
+    let real;
+    try {
+        real = io.realpathSync(entry);
+    }
+    catch {
+        return { ok: false, reason: `${entry} does not resolve` };
+    }
+    let dir = path.dirname(real);
+    for (let i = 0; i < 8; i++) {
+        const manifest = path.join(dir, "package.json");
+        let raw;
+        try {
+            raw = io.readFileSync(manifest, "utf8");
+        }
+        catch {
+            raw = null;
+        }
+        if (raw !== null) {
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch {
+                return { ok: false, reason: `${manifest} is not valid JSON`, packageRoot: dir };
+            }
+            if (parsed.name === CLI_NAME) {
+                const version = typeof parsed.version === "string" ? semver.valid(parsed.version) : null;
+                if (!version)
+                    return { ok: false, reason: `${manifest} has no valid version`, packageRoot: dir };
+                return { ok: true, version, packageRoot: dir };
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return { ok: false, reason: `no ${CLI_NAME} package.json above ${real}` };
+}
+function ledgerPath(dir) {
+    return path.join(dir, CLI_UPDATE_LEDGER_FILE);
+}
+export function readCliUpdateLedger(dir) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(ledgerPath(dir), "utf8"));
+        return {
+            v: 1,
+            restarts: Array.isArray(raw.restarts) ? raw.restarts.filter((s) => typeof s === "string") : [],
+            ...(raw.pending && typeof raw.pending.from === "string" && typeof raw.pending.to === "string" ? { pending: raw.pending } : {}),
+            ...(raw.blocked && typeof raw.blocked.version === "string" && typeof raw.blocked.until === "string" ? { blocked: raw.blocked } : {}),
+        };
+    }
+    catch {
+        return { v: 1, restarts: [] };
+    }
+}
+function writeCliUpdateLedger(dir, ledger) {
+    const target = ledgerPath(dir);
+    const tmp = `${target}.${process.pid}.tmp`;
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(tmp, `${JSON.stringify(ledger, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(tmp, target);
+}
+export function createCliUpdateWatcher(opts) {
+    const runningVersion = opts.runningVersion ?? CLI_VERSION;
+    const now = opts.now ?? Date.now;
+    const read = opts.read ?? ((entry) => readInstalledCli(entry));
+    const rewriteInProgress = opts.rewriteInProgress ?? ((packageRoot) => installRewriteInProgress({ packageRoot, lockPath: updateLockPath() }));
+    const checkIntervalMs = opts.checkIntervalMs ?? CLI_UPDATE_CHECK_INTERVAL_MS;
+    const confirmations = Math.max(1, opts.confirmations ?? CLI_UPDATE_CONFIRMATIONS);
+    const restartLimit = Math.max(1, opts.restartLimit ?? CLI_UPDATE_RESTART_LIMIT);
+    const restartWindowMs = opts.restartWindowMs ?? CLI_UPDATE_RESTART_WINDOW_MS;
+    const cooldownMs = opts.cooldownMs ?? CLI_UPDATE_NOT_CONVERGED_COOLDOWN_MS;
+    const { dir, entry } = opts;
+    let nextCheckAt = now() + checkIntervalMs;
+    let candidate = null;
+    let seen = 0;
+    /** Last "why not" line, so a condition that persists is logged once. */
+    let lastNote = null;
+    const note = (log, level, message) => {
+        if (message === lastNote)
+            return;
+        lastNote = message;
+        log(level, message);
+    };
+    const recentRestarts = (ledger, at) => ledger.restarts.filter((iso) => {
+        const t = Date.parse(iso);
+        return Number.isFinite(t) && at - t < restartWindowMs;
+    });
+    return {
+        runningVersion,
+        startup(log) {
+            if (!entry) {
+                log("info", "not watching for hq-cli updates (no entry script)");
+                return;
+            }
+            const ledger = readCliUpdateLedger(dir);
+            const pending = ledger.pending;
+            if (pending) {
+                delete ledger.pending;
+                if (runningVersion === pending.to) {
+                    log("info", `hq-cli update converged: now running ${runningVersion} (was ${pending.from})`);
+                    if (ledger.blocked?.version === runningVersion)
+                        delete ledger.blocked;
+                }
+                else if (runningVersion === pending.from) {
+                    const until = new Date(now() + cooldownMs).toISOString();
+                    ledger.blocked = { version: pending.to, until };
+                    log("error", `restarted to load hq-cli ${pending.to} but this process still loaded ${runningVersion}; ` +
+                        `not restarting for ${pending.to} again until ${until} (check which install ${entry} resolves to)`);
+                }
+                else {
+                    log("info", `restarted for hq-cli ${pending.to}; now running ${runningVersion}`);
+                }
+                try {
+                    writeCliUpdateLedger(dir, ledger);
+                }
+                catch (err) {
+                    log("warn", `could not update ${CLI_UPDATE_LEDGER_FILE}: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            log("info", `watching ${entry} for hq-cli updates (running ${runningVersion})`);
+        },
+        poll(log) {
+            if (!entry)
+                return null;
+            const at = now();
+            if (at < nextCheckAt)
+                return null;
+            nextCheckAt = at + checkIntervalMs;
+            const installed = read(entry);
+            if (!installed.ok) {
+                candidate = null;
+                seen = 0;
+                note(log, "warn", `hq-cli install not readable, not restarting: ${installed.reason}`);
+                return null;
+            }
+            if (installed.version === runningVersion) {
+                candidate = null;
+                seen = 0;
+                lastNote = null;
+                return null;
+            }
+            if (rewriteInProgress(installed.packageRoot)) {
+                candidate = null;
+                seen = 0;
+                note(log, "info", `hq-cli ${installed.version} is still being installed; waiting for it to finish`);
+                return null;
+            }
+            if (candidate === installed.version)
+                seen += 1;
+            else {
+                candidate = installed.version;
+                seen = 1;
+            }
+            if (seen < confirmations) {
+                note(log, "info", `hq-cli ${installed.version} is installed (running ${runningVersion}); confirming before restarting`);
+                return null;
+            }
+            const ledger = readCliUpdateLedger(dir);
+            if (ledger.blocked?.version === installed.version && at < Date.parse(ledger.blocked.until)) {
+                note(log, "warn", `not restarting for hq-cli ${installed.version}: an earlier restart for it did not load it (retry after ${ledger.blocked.until})`);
+                return null;
+            }
+            if (recentRestarts(ledger, at).length >= restartLimit) {
+                note(log, "warn", `not restarting for hq-cli ${installed.version}: already restarted ${restartLimit} times for updates in the last ${Math.round(restartWindowMs / 60_000)} minutes`);
+                return null;
+            }
+            return { from: runningVersion, to: installed.version, packageRoot: installed.packageRoot };
+        },
+        recordRestart(update) {
+            const at = now();
+            const ledger = readCliUpdateLedger(dir);
+            ledger.restarts = [...recentRestarts(ledger, at), new Date(at).toISOString()];
+            ledger.pending = { from: update.from, to: update.to, at: new Date(at).toISOString() };
+            writeCliUpdateLedger(dir, ledger);
+        },
+    };
+}
+export function detectBotSupervisor(name, opts = {}) {
+    const env = opts.env ?? process.env;
+    const platform = opts.platform ?? process.platform;
+    if (env.HQ_DAEMON_UNIT === `bots:${name}`)
+        return "hq-daemon";
+    if (platform === "darwin" && env.XPC_SERVICE_NAME === launchdLabel(name))
+        return "launchd";
+    if (platform === "linux") {
+        const readCgroup = opts.readCgroup ??
+            (() => {
+                try {
+                    return fs.readFileSync("/proc/self/cgroup", "utf8");
+                }
+                catch {
+                    return null;
+                }
+            });
+        if (readCgroup()?.includes(`/hq-bot-${name}.service`))
+            return "systemd";
+    }
+    return "none";
+}
+/**
+ * The last step of an update restart, run after the pid lock is released and
+ * just before the exit. A supervised bot only has to exit; an unsupervised one
+ * starts its replacement on the same entry script (now the new code) first,
+ * because nothing else will.
+ */
+export function handOffToUpdatedCli(name, log, deps) {
+    const supervisor = deps.supervisor ?? detectBotSupervisor(name);
+    if (supervisor !== "none") {
+        log("info", `exiting for ${supervisor} to start the updated hq-cli`);
+        return supervisor;
+    }
+    log("info", `no supervisor; started replacement pid ${deps.spawnReplacement()}`);
+    return supervisor;
+}
+//# sourceMappingURL=cli-update.js.map

package/dist/lib/bot/company-bind.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Company bind for worker-sourced bots (local-bots Feature 4).
+ *
+ * HQ's company hooks key on workspace/sessions/<sid>/meta.yaml `company_slug`,
+ * where <sid> is the Claude session id carried in the hook payload. A bot that
+ * runs a company worker writes that file for the session id it is about to
+ * use, before every turn, so the hooks resolve the company exactly as they do
+ * for the owner. Idempotent: an existing file keeps its other keys and only
+ * has `company_slug` replaced.
+ *
+ * Coverage note: Claude bots get the full company hook set (their session id
+ * is in the hook payload). Codex/Grok bots only see HQ_SESSION_ID in the env.
+ */
+export interface CompanyBindFs {
+    existsSync: (p: string) => boolean;
+    readFileSync: (p: string) => string;
+    writeFileSync: (p: string, body: string) => void;
+    mkdirSync: (p: string) => void;
+}
+export declare const defaultCompanyBindFs: CompanyBindFs;
+export declare function botSessionMetaRelPath(sessionId: string): string;
+export declare function ensureBotSessionMeta(hqRoot: string, sessionId: string, companySlug: string, io?: CompanyBindFs, now?: () => Date): {
+    path: string;
+    created: boolean;
+    changed: boolean;
+};
+//# sourceMappingURL=company-bind.d.ts.map

package/dist/lib/bot/company-bind.js

@@ -0,0 +1,62 @@
+/**
+ * Company bind for worker-sourced bots (local-bots Feature 4).
+ *
+ * HQ's company hooks key on workspace/sessions/<sid>/meta.yaml `company_slug`,
+ * where <sid> is the Claude session id carried in the hook payload. A bot that
+ * runs a company worker writes that file for the session id it is about to
+ * use, before every turn, so the hooks resolve the company exactly as they do
+ * for the owner. Idempotent: an existing file keeps its other keys and only
+ * has `company_slug` replaced.
+ *
+ * Coverage note: Claude bots get the full company hook set (their session id
+ * is in the hook payload). Codex/Grok bots only see HQ_SESSION_ID in the env.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const defaultCompanyBindFs = {
+    existsSync: (p) => fs.existsSync(p),
+    readFileSync: (p) => fs.readFileSync(p, "utf8"),
+    writeFileSync: (p, body) => fs.writeFileSync(p, body, { mode: 0o644 }),
+    mkdirSync: (p) => fs.mkdirSync(p, { recursive: true }),
+};
+const SESSION_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const COMPANY_SLUG_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+export function botSessionMetaRelPath(sessionId) {
+    return path.join("workspace", "sessions", sessionId, "meta.yaml");
+}
+export function ensureBotSessionMeta(hqRoot, sessionId, companySlug, io = defaultCompanyBindFs, now = () => new Date()) {
+    if (!SESSION_ID_RE.test(sessionId))
+        throw new Error(`Invalid session id for company bind: "${sessionId}"`);
+    if (!COMPANY_SLUG_RE.test(companySlug))
+        throw new Error(`Invalid company slug for company bind: "${companySlug}"`);
+    const file = path.join(hqRoot, botSessionMetaRelPath(sessionId));
+    io.mkdirSync(path.dirname(file));
+    if (!io.existsSync(file)) {
+        const body = `session_id: ${sessionId}\nstarted_at: "${now().toISOString()}"\ncompany_slug: ${companySlug}\n`;
+        io.writeFileSync(file, body);
+        return { path: file, created: true, changed: true };
+    }
+    const current = io.readFileSync(file);
+    const lines = current.split("\n");
+    let replaced = false;
+    const next = lines.map((line) => {
+        if (/^company_slug\s*:/.test(line)) {
+            replaced = true;
+            return `company_slug: ${companySlug}`;
+        }
+        return line;
+    });
+    if (!replaced) {
+        while (next.length > 0 && next[next.length - 1] === "")
+            next.pop();
+        next.push(`company_slug: ${companySlug}`);
+    }
+    if (!next.some((l) => /^session_id\s*:/.test(l)))
+        next.unshift(`session_id: ${sessionId}`);
+    const body = `${next.join("\n").replace(/\n+$/, "")}\n`;
+    if (body === current)
+        return { path: file, created: false, changed: false };
+    io.writeFileSync(file, body);
+    return { path: file, created: false, changed: true };
+}
+//# sourceMappingURL=company-bind.js.map