@indigoai-us/hq-cli 5.109.15 → 5.110.0

package/dist/lib/bot/daemon.js

@@ -0,0 +1,316 @@
+/**
+ * Per-bot launchd user agent (local-bots US-005). macOS only for this PRD;
+ * Linux writes a systemd user unit as a best-effort extra.
+ *
+ *   ~/Library/LaunchAgents/ai.getindigo.hq-bot.<name>.plist
+ *     ProgramArguments: <node> <hq> bot run <name>
+ *     RunAtLoad + KeepAlive{SuccessfulExit:false}  — starts at login, restarts
+ *     on crash, but a clean exit 0 (bot disabled via `hq bot stop`) stays down.
+ *
+ * `launchctl` is injected so tests never touch the real service manager.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { resolveHqBinary, resolveNodeBinary } from "../mesh/live/daemon/install.js";
+import { botLogPath, launchdLabel } from "./paths.js";
+export function detectBotPlatform(platform = process.platform) {
+    if (platform === "darwin")
+        return "darwin";
+    if (platform === "linux")
+        return "linux";
+    return "other";
+}
+export function defaultPathEntries(home) {
+    const toolchain = path.join(home, "Library", "Application Support", "Indigo HQ", "toolchain");
+    return [
+        // launchd does not load shell profiles; npm CLIs also need env node.
+        path.join(toolchain, "node", "bin"),
+        path.join(toolchain, "npm-global", "bin"),
+        path.join(home, ".local", "bin"),
+        path.join(home, ".grok", "bin"),
+        path.join(home, "Library", "pnpm"),
+        path.join(home, ".npm-global", "bin"),
+        "/opt/homebrew/bin",
+        "/usr/local/bin",
+        "/usr/bin",
+        "/bin",
+    ];
+}
+export function buildBotDaemonPaths(opts) {
+    const home = opts.home ?? os.homedir();
+    const env = opts.env ?? process.env;
+    const label = launchdLabel(opts.name);
+    return {
+        home,
+        name: opts.name,
+        label,
+        hqBinary: opts.hqBinary ?? resolveHqBinary(opts.argv, env),
+        nodeBinary: opts.nodeBinary ?? resolveNodeBinary(opts.execPath, env),
+        botDir: opts.botDir,
+        logPath: botLogPath(opts.botDir),
+        plistPath: path.join(home, "Library", "LaunchAgents", `${label}.plist`),
+        systemdUnitPath: path.join(home, ".config", "systemd", "user", `hq-bot-${opts.name}.service`),
+        pathEntries: defaultPathEntries(home),
+        hqRoot: opts.hqRoot,
+    };
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+export function renderBotLaunchdPlist(p) {
+    const envRows = [
+        ["HOME", p.home],
+        ["PATH", p.pathEntries.join(":")],
+        ["HQ_NO_UPDATE_CHECK", "1"],
+        ...(p.hqRoot ? [["HQ_ROOT", p.hqRoot]] : []),
+    ]
+        .map(([k, v]) => `    <key>${escapeXml(k)}</key>\n    <string>${escapeXml(v)}</string>`)
+        .join("\n");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${escapeXml(p.label)}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${escapeXml(p.nodeBinary)}</string>
+    <string>${escapeXml(p.hqBinary)}</string>
+    <string>bot</string>
+    <string>run</string>
+    <string>${escapeXml(p.name)}</string>
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${escapeXml(p.hqRoot ?? p.botDir)}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>5</integer>
+  <key>ProcessType</key>
+  <!-- Interactive, not Background: launchd throttles Background processes
+       (CPU/IO/network), which doubled every model turn (63 s vs 28 s for the
+       same Grok call, 2026-09-11). The bot answers a person in real time. -->
+  <string>Interactive</string>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(p.logPath)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(p.logPath)}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+${envRows}
+  </dict>
+</dict>
+</plist>
+`;
+}
+export function renderBotSystemdUnit(p) {
+    const q = (v) => (/^[A-Za-z0-9_./:-]+$/.test(v) ? v : `'${v.replace(/'/g, `'\\''`)}'`);
+    return `[Unit]
+Description=HQ local bot ${p.name}
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${q(p.nodeBinary)} ${q(p.hqBinary)} bot run ${p.name}
+WorkingDirectory=${p.hqRoot ?? p.botDir}
+Restart=on-failure
+RestartSec=5
+Environment=HOME=${p.home}
+Environment=PATH=${p.pathEntries.join(":")}
+Environment=HQ_NO_UPDATE_CHECK=1
+${p.hqRoot ? `Environment=HQ_ROOT=${p.hqRoot}\n` : ""}StandardOutput=append:${p.logPath}
+StandardError=append:${p.logPath}
+
+[Install]
+WantedBy=default.target
+`;
+}
+export function launchdDomain(uid = os.userInfo().uid) {
+    return `gui/${uid}`;
+}
+function blockingSleep(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+/**
+ * `launchctl bootout` returns before the job is actually gone; a `bootstrap`
+ * issued right away fails ("service already loaded" / EIO) and the old job
+ * then finishes unloading, leaving nothing running even though `print` said
+ * loaded a moment ago. Wait for the unload, then bootstrap with retries.
+ */
+function rebootstrapLaunchd(p, deps) {
+    const launchctl = deps.launchctl;
+    const sleep = deps.sleepMs ?? blockingSleep;
+    launchctl(["bootout", `${launchdDomain(deps.uid)}/${p.label}`]);
+    for (let i = 0; i < 20 && launchdLoaded(p, deps); i++)
+        sleep(250);
+    let r = launchctl(["bootstrap", launchdDomain(deps.uid), p.plistPath]);
+    for (let i = 0; i < 3 && !r.ok; i++) {
+        sleep(500);
+        r = launchctl(["bootstrap", launchdDomain(deps.uid), p.plistPath]);
+    }
+    return r;
+}
+function launchdLoaded(p, deps) {
+    if (!deps.launchctl)
+        return false;
+    return deps.launchctl(["print", `${launchdDomain(deps.uid)}/${p.label}`]).ok;
+}
+/** Write the unit and load it (RunAtLoad starts the bot immediately). */
+export function installBotDaemon(p, deps = {}) {
+    const platform = deps.platform ?? detectBotPlatform();
+    const io = deps.fsImpl ?? fs;
+    io.mkdirSync(p.botDir, { recursive: true, mode: 0o700 });
+    io.mkdirSync(path.dirname(p.logPath), { recursive: true, mode: 0o700 });
+    if (platform === "darwin") {
+        io.mkdirSync(path.dirname(p.plistPath), { recursive: true });
+        io.writeFileSync(p.plistPath, renderBotLaunchdPlist(p), { mode: 0o600 });
+        let loaded = false;
+        if (deps.launchctl) {
+            // bootout first so a re-install picks up a changed plist.
+            const r = rebootstrapLaunchd(p, deps);
+            loaded = r.ok || launchdLoaded(p, deps);
+            if (!loaded) {
+                return {
+                    platform,
+                    action: "install",
+                    installed: true,
+                    loaded: false,
+                    dest: p.plistPath,
+                    message: `Wrote ${p.plistPath} but launchctl bootstrap failed: ${(r.stderr || r.stdout).trim().slice(0, 200)}`,
+                };
+            }
+        }
+        return {
+            platform,
+            action: "install",
+            installed: true,
+            loaded,
+            dest: p.plistPath,
+            message: `Installed LaunchAgent ${p.label} (${loaded ? "loaded" : "not loaded"})`,
+        };
+    }
+    if (platform === "linux") {
+        io.mkdirSync(path.dirname(p.systemdUnitPath), { recursive: true });
+        io.writeFileSync(p.systemdUnitPath, renderBotSystemdUnit(p), { mode: 0o600 });
+        return {
+            platform,
+            action: "install",
+            installed: true,
+            loaded: false,
+            dest: p.systemdUnitPath,
+            message: `Wrote systemd user unit ${p.systemdUnitPath}. Enable with: systemctl --user daemon-reload && systemctl --user enable --now hq-bot-${p.name}.service`,
+        };
+    }
+    return {
+        platform,
+        action: "install",
+        installed: false,
+        loaded: false,
+        message: `No service manager integration on this platform; run: ${p.nodeBinary} ${p.hqBinary} bot run ${p.name}`,
+    };
+}
+export function uninstallBotDaemon(p, deps = {}) {
+    const platform = deps.platform ?? detectBotPlatform();
+    const io = deps.fsImpl ?? fs;
+    if (platform === "darwin") {
+        deps.launchctl?.(["bootout", `${launchdDomain(deps.uid)}/${p.label}`]);
+        const existed = io.existsSync(p.plistPath);
+        if (existed)
+            io.unlinkSync(p.plistPath);
+        return {
+            platform,
+            action: "uninstall",
+            installed: false,
+            loaded: false,
+            dest: p.plistPath,
+            message: existed ? `Removed LaunchAgent ${p.label}` : `LaunchAgent ${p.label} was not installed`,
+        };
+    }
+    if (platform === "linux") {
+        const existed = io.existsSync(p.systemdUnitPath);
+        if (existed)
+            io.unlinkSync(p.systemdUnitPath);
+        return {
+            platform,
+            action: "uninstall",
+            installed: false,
+            loaded: false,
+            dest: p.systemdUnitPath,
+            message: existed ? `Removed systemd unit for ${p.name}` : `No systemd unit for ${p.name}`,
+        };
+    }
+    return { platform, action: "uninstall", installed: false, loaded: false, message: "Nothing to uninstall on this platform" };
+}
+export function botDaemonStatus(p, deps = {}) {
+    const platform = deps.platform ?? detectBotPlatform();
+    const io = deps.fsImpl ?? fs;
+    if (platform === "darwin") {
+        const installed = io.existsSync(p.plistPath);
+        const loaded = installed && launchdLoaded(p, deps);
+        return {
+            platform,
+            action: "status",
+            installed,
+            loaded,
+            dest: p.plistPath,
+            message: installed
+                ? `LaunchAgent ${p.label}: ${loaded ? "loaded" : "installed (not loaded)"}`
+                : `LaunchAgent ${p.label}: not installed`,
+        };
+    }
+    if (platform === "linux") {
+        const installed = io.existsSync(p.systemdUnitPath);
+        return {
+            platform,
+            action: "status",
+            installed,
+            loaded: false,
+            dest: p.systemdUnitPath,
+            message: installed ? `systemd unit for ${p.name}: installed` : `systemd unit for ${p.name}: not installed`,
+        };
+    }
+    return { platform, action: "status", installed: false, loaded: false, message: "No service manager integration on this platform" };
+}
+/** Load an installed LaunchAgent (idempotent: already-loaded is fine). */
+export function startBotDaemon(p, deps = {}) {
+    const platform = deps.platform ?? detectBotPlatform();
+    const io = deps.fsImpl ?? fs;
+    if (platform !== "darwin" || !deps.launchctl || !io.existsSync(p.plistPath)) {
+        return { ...botDaemonStatus(p, deps), action: "start" };
+    }
+    if (launchdLoaded(p, deps)) {
+        // Already loaded: kick the job so a stopped (exit-0) bot runs again.
+        deps.launchctl(["kickstart", `${launchdDomain(deps.uid)}/${p.label}`]);
+        return { platform, action: "start", installed: true, loaded: true, dest: p.plistPath, message: `LaunchAgent ${p.label} kicked` };
+    }
+    const r = deps.launchctl(["bootstrap", launchdDomain(deps.uid), p.plistPath]);
+    const loaded = r.ok || launchdLoaded(p, deps);
+    return {
+        platform,
+        action: "start",
+        installed: true,
+        loaded,
+        dest: p.plistPath,
+        message: loaded ? `LaunchAgent ${p.label} loaded` : `launchctl bootstrap failed: ${(r.stderr || r.stdout).trim().slice(0, 200)}`,
+    };
+}
+/** Unload the job (plist stays, so the bot returns at next login unless disabled). */
+export function stopBotDaemon(p, deps = {}) {
+    const platform = deps.platform ?? detectBotPlatform();
+    if (platform === "darwin" && deps.launchctl) {
+        deps.launchctl(["bootout", `${launchdDomain(deps.uid)}/${p.label}`]);
+    }
+    return { ...botDaemonStatus(p, deps), action: "stop" };
+}
+//# sourceMappingURL=daemon.js.map

package/dist/lib/bot/inbox-state.d.ts

@@ -0,0 +1,18 @@
+/**
+ * inbox-state.json — processed messageIds so a DM pulled but not acked
+ * before a crash is answered exactly once after restart (local-bots US-004).
+ */
+export declare const INBOX_STATE_MAX_ENTRIES = 500;
+export interface InboxStateFile {
+    v: 1;
+    /** messageId → ISO time the reply was sent (or the refusal was sent). */
+    processed: Record<string, string>;
+    updatedAt: string;
+}
+export declare function readInboxState(dir: string): InboxStateFile;
+export declare function writeInboxState(dir: string, state: InboxStateFile): void;
+export declare function isProcessed(state: InboxStateFile, messageId: string): boolean;
+/** Record a processed id, trimming the oldest entries past the cap. Pure. */
+export declare function withProcessed(state: InboxStateFile, messageId: string, at: string, cap?: number): InboxStateFile;
+export declare function markProcessed(dir: string, messageId: string, at?: string): InboxStateFile;
+//# sourceMappingURL=inbox-state.d.ts.map

package/dist/lib/bot/inbox-state.js

@@ -0,0 +1,51 @@
+/**
+ * inbox-state.json — processed messageIds so a DM pulled but not acked
+ * before a crash is answered exactly once after restart (local-bots US-004).
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { botInboxStatePath } from "./paths.js";
+export const INBOX_STATE_MAX_ENTRIES = 500;
+export function readInboxState(dir) {
+    const p = botInboxStatePath(dir);
+    if (!fs.existsSync(p))
+        return { v: 1, processed: {}, updatedAt: new Date(0).toISOString() };
+    try {
+        const raw = JSON.parse(fs.readFileSync(p, "utf8"));
+        if (raw.v !== 1 || typeof raw.processed !== "object" || !raw.processed) {
+            return { v: 1, processed: {}, updatedAt: new Date(0).toISOString() };
+        }
+        return raw;
+    }
+    catch {
+        return { v: 1, processed: {}, updatedAt: new Date(0).toISOString() };
+    }
+}
+export function writeInboxState(dir, state) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const dest = botInboxStatePath(dir);
+    const tmp = path.join(dir, `.inbox.tmp.${process.pid}.${Date.now()}`);
+    fs.writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(tmp, dest);
+}
+export function isProcessed(state, messageId) {
+    return Object.prototype.hasOwnProperty.call(state.processed, messageId);
+}
+/** Record a processed id, trimming the oldest entries past the cap. Pure. */
+export function withProcessed(state, messageId, at, cap = INBOX_STATE_MAX_ENTRIES) {
+    const processed = { ...state.processed, [messageId]: at };
+    const keys = Object.keys(processed);
+    if (keys.length > cap) {
+        keys
+            .sort((a, b) => processed[a].localeCompare(processed[b]))
+            .slice(0, keys.length - cap)
+            .forEach((k) => delete processed[k]);
+    }
+    return { v: 1, processed, updatedAt: at };
+}
+export function markProcessed(dir, messageId, at = new Date().toISOString()) {
+    const next = withProcessed(readInboxState(dir), messageId, at);
+    writeInboxState(dir, next);
+    return next;
+}
+//# sourceMappingURL=inbox-state.js.map

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

@@ -0,0 +1,16 @@
+export * from "./paths.js";
+export * from "./config.js";
+export * from "./creds.js";
+export * from "./status.js";
+export * from "./log.js";
+export * from "./inbox-state.js";
+export * from "./session.js";
+export * from "./prompt.js";
+export * from "./api.js";
+export * from "./daemon.js";
+export * from "./scaffold.js";
+export * from "./worker-source.js";
+export * from "./company-bind.js";
+export * from "./run.js";
+export * from "./runtime/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/bot/index.js

@@ -0,0 +1,16 @@
+export * from "./paths.js";
+export * from "./config.js";
+export * from "./creds.js";
+export * from "./status.js";
+export * from "./log.js";
+export * from "./inbox-state.js";
+export * from "./session.js";
+export * from "./prompt.js";
+export * from "./api.js";
+export * from "./daemon.js";
+export * from "./scaffold.js";
+export * from "./worker-source.js";
+export * from "./company-bind.js";
+export * from "./run.js";
+export * from "./runtime/index.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,40 @@
+/**
+ * inflight.json — the message a model turn is working on right now.
+ *
+ * Written before the model process starts and removed once the message is
+ * answered (or answered with "did not finish"). If the bot restarts while the
+ * file exists, the turn was cut off: the bot tells the person instead of
+ * running the message again, because the first run may already have done
+ * things outside this Mac (sent something, published something).
+ */
+export declare const BOT_INFLIGHT_NAME = "inflight.json";
+export interface InflightTurn {
+    v: 1;
+    /** Inbox message id, or `kickoff` for the first-start kickoff turn. */
+    messageId: string;
+    /** Where replies for this message go. */
+    target: {
+        kind: "dm";
+        peerUid: string;
+    } | {
+        kind: "room";
+        channelId: string;
+    };
+    rootEventId?: string;
+    /** DM message carrying the thinking reaction, so a restart can clear it. */
+    reactionEventId?: string;
+    startedAt: string;
+    /** Progress messages already posted for this turn. */
+    progressPosted?: number;
+    /**
+     * The finished answer, when the turn completed but posting it failed. A
+     * restart posts this instead of "did not finish".
+     */
+    reply?: string;
+}
+export declare function botInflightPath(dir: string): string;
+export declare function readInflight(dir: string): InflightTurn | null;
+export declare function writeInflight(dir: string, turn: InflightTurn): void;
+export declare function patchInflight(dir: string, messageId: string, patch: Partial<InflightTurn>): void;
+export declare function clearInflight(dir: string, messageId?: string): void;
+//# sourceMappingURL=inflight.d.ts.map

package/dist/lib/bot/inflight.js

@@ -0,0 +1,44 @@
+/**
+ * inflight.json — the message a model turn is working on right now.
+ *
+ * Written before the model process starts and removed once the message is
+ * answered (or answered with "did not finish"). If the bot restarts while the
+ * file exists, the turn was cut off: the bot tells the person instead of
+ * running the message again, because the first run may already have done
+ * things outside this Mac (sent something, published something).
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const BOT_INFLIGHT_NAME = "inflight.json";
+export function botInflightPath(dir) {
+    return path.join(dir, BOT_INFLIGHT_NAME);
+}
+export function readInflight(dir) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(botInflightPath(dir), "utf8"));
+        if (raw?.v !== 1 || typeof raw.messageId !== "string" || !raw.target)
+            return null;
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeInflight(dir, turn) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const tmp = path.join(dir, `.inflight.tmp.${process.pid}.${Date.now()}`);
+    fs.writeFileSync(tmp, `${JSON.stringify(turn, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(tmp, botInflightPath(dir));
+}
+export function patchInflight(dir, messageId, patch) {
+    const current = readInflight(dir);
+    if (!current || current.messageId !== messageId)
+        return;
+    writeInflight(dir, { ...current, ...patch });
+}
+export function clearInflight(dir, messageId) {
+    if (messageId !== undefined && readInflight(dir)?.messageId !== messageId)
+        return;
+    fs.rmSync(botInflightPath(dir), { force: true });
+}
+//# sourceMappingURL=inflight.js.map

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

@@ -0,0 +1,13 @@
+/**
+ * ~/.hq/bots/<name>/logs/bot.log with rotation at 5MB. Never writes prompts,
+ * tokens, credentials, or DM bodies — only metadata and bounded error text.
+ */
+export declare function ensureBotLog(dir: string): string;
+export declare function rotateBotLogIfNeeded(dir: string, maxBytes?: number): void;
+/** Strip anything that looks like a bearer token, secret, or op:// ref. */
+export declare function redactForLog(message: string): string;
+export declare function botLogLine(level: "info" | "warn" | "error", message: string, now?: () => Date): string;
+export declare function appendBotLog(dir: string, line: string): void;
+export type BotLogger = (level: "info" | "warn" | "error", message: string) => void;
+export declare function createBotLogger(dir: string, now?: () => Date): BotLogger;
+//# sourceMappingURL=log.d.ts.map

package/dist/lib/bot/log.js

@@ -0,0 +1,59 @@
+/**
+ * ~/.hq/bots/<name>/logs/bot.log with rotation at 5MB. Never writes prompts,
+ * tokens, credentials, or DM bodies — only metadata and bounded error text.
+ */
+import * as fs from "node:fs";
+import { BOT_LOG_MAX_BYTES, botLogPath, botLogsDir } from "./paths.js";
+export function ensureBotLog(dir) {
+    fs.mkdirSync(botLogsDir(dir), { recursive: true, mode: 0o700 });
+    const logPath = botLogPath(dir);
+    if (!fs.existsSync(logPath))
+        fs.writeFileSync(logPath, "", { mode: 0o600 });
+    return logPath;
+}
+export function rotateBotLogIfNeeded(dir, maxBytes = BOT_LOG_MAX_BYTES) {
+    const logPath = botLogPath(dir);
+    try {
+        if (!fs.existsSync(logPath))
+            return;
+        if (fs.statSync(logPath).size <= maxBytes)
+            return;
+        const rotated = `${logPath}.1`;
+        try {
+            fs.unlinkSync(rotated);
+        }
+        catch {
+            /* ignore */
+        }
+        fs.renameSync(logPath, rotated);
+        fs.writeFileSync(logPath, "", { mode: 0o600 });
+    }
+    catch {
+        /* best-effort */
+    }
+}
+/** Strip anything that looks like a bearer token, secret, or op:// ref. */
+export function redactForLog(message) {
+    return message
+        .replace(/Bearer\s+[A-Za-z0-9._-]+/gi, "Bearer [REDACTED]")
+        .replace(/op:\/\/[^\s"]+/g, "op://[REDACTED]")
+        .replace(/"secret"\s*:\s*"[^"]*"/g, '"secret":"[REDACTED]"')
+        .replace(/eyJ[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{10,}/g, "[REDACTED_JWT]");
+}
+export function botLogLine(level, message, now = () => new Date()) {
+    return `${now().toISOString()} ${level} ${redactForLog(message).slice(0, 600)}`;
+}
+export function appendBotLog(dir, line) {
+    rotateBotLogIfNeeded(dir);
+    const logPath = ensureBotLog(dir);
+    try {
+        fs.appendFileSync(logPath, line.endsWith("\n") ? line : `${line}\n`);
+    }
+    catch {
+        /* best-effort */
+    }
+}
+export function createBotLogger(dir, now = () => new Date()) {
+    return (level, message) => appendBotLog(dir, botLogLine(level, message, now));
+}
+//# sourceMappingURL=log.js.map

package/dist/lib/bot/owner-context.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Owner context: who the bot's owner is and which companies they belong to.
+ *
+ * A local bot runs under its OWN HQ identity (per-bot machine credentials set
+ * for the whole resident process, and inherited by the model subprocess). So
+ * any membership lookup the model makes with `hq` describes the bot, and a bot
+ * usually belongs to no company. Bots were reading that empty answer as "your
+ * owner has no company".
+ *
+ * The resident process (trusted code, not the model) looks the owner up with
+ * the owner's own cached HQ session, strictly non-interactively, and verifies
+ * the session really is the owner before trusting it. Only the result (company
+ * slugs, uids, roles) reaches the model; the owner's token never does. A failed
+ * lookup is reported as "could not check", never as "no companies".
+ */
+export interface OwnerCompany {
+    companyUid: string;
+    /** Present when the server enriched it. */
+    companySlug?: string;
+    role: string;
+}
+export type OwnerContext = {
+    status: "ok";
+    ownerUid: string;
+    companies: OwnerCompany[];
+    checkedAt: string;
+} | {
+    status: "unavailable";
+    ownerUid: string;
+    reason: string;
+    checkedAt: string;
+} | {
+    status: "mismatch";
+    ownerUid: string;
+    signedInAs: string;
+    checkedAt: string;
+};
+export interface OwnerLookupIo {
+    /** The owner's own session token; must never prompt or open a browser. */
+    personToken: () => Promise<string>;
+    /** `prs_*` uid the token belongs to. */
+    callerPersonUid: (token: string) => Promise<string>;
+    /** Raw memberships for the token's subject. */
+    memberships: (token: string) => Promise<Array<{
+        companyUid: string;
+        companySlug?: string;
+        role: string;
+        status: string;
+    }>>;
+    now?: () => Date;
+}
+export declare const defaultOwnerLookupIo: OwnerLookupIo;
+export declare function lookupOwnerContext(ownerUid: string, io?: OwnerLookupIo): Promise<OwnerContext>;
+/** Successful lookups are reused for 5 minutes, failures retried after 1 minute. */
+export declare const OWNER_CONTEXT_TTL_MS: number;
+export declare const OWNER_CONTEXT_RETRY_MS = 60000;
+/** A turn never waits longer than this for a refresh; the lookup keeps going in the background. */
+export declare const OWNER_CONTEXT_WAIT_MS = 8000;
+export declare class OwnerContextCache {
+    private readonly lookup;
+    private readonly nowMs;
+    private readonly waitMs;
+    private readonly ownerUid;
+    private value;
+    private at;
+    private pending;
+    constructor(lookup: () => Promise<OwnerContext>, nowMs?: () => number, waitMs?: number, ownerUid?: string);
+    get(): Promise<OwnerContext>;
+}
+/**
+ * The block prepended to every owner DM turn. It names its subject explicitly so the
+ * model cannot confuse the owner's memberships with its own.
+ */
+export declare function ownerContextBlock(ctx: OwnerContext, agentUid: string): string;
+//# sourceMappingURL=owner-context.d.ts.map