@indigoai-us/hq-cli 5.109.16 → 5.111.0

package/dist/lib/bot/prompt.js

@@ -0,0 +1,329 @@
+/**
+ * System context for the bot's model session (local-bots US-003/US-006, Feature 4).
+ *
+ * Scaffolded bot — assembled from the bot's own worker folder under the HQ root:
+ *   personal/workers/<name>/worker.yaml   identity + capabilities
+ *   personal/workers/<name>/persona.md    voice and standing instructions
+ *   personal/workers/<name>/memory/*.md   durable memory the bot may edit
+ *
+ * Worker-sourced bot (workerSource "worker") — the bot runs a company worker:
+ *   companies/<co>/workers/<id>/worker.yaml   parsed: instructions, identity.persona,
+ *                                             skills (→ skills/<name>.md | skills/<name>/SKILL.md),
+ *                                             context.base (inlined under a budget)
+ *   companies/<co>/policies/*.md              listed as paths (hard rules; read before acting)
+ *   <memoryDir>/*.md                          the bot's own memory (personal/workers/<bot>/memory,
+ *                                             or an absolute ~/.hq/bots/<bot>/memory for local memory)
+ *
+ * Pure over an injected reader so tests never touch the real HQ.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as yaml from "js-yaml";
+import { packageRoot } from "../../utils/hq-roots.js";
+export const MEMORY_FILE_BUDGET_BYTES = 64 * 1024;
+export const MEMORY_TOTAL_BUDGET_BYTES = 192 * 1024;
+export const CONTEXT_FILE_BUDGET_BYTES = 32 * 1024;
+export const CONTEXT_TOTAL_BUDGET_BYTES = 96 * 1024;
+export const defaultPromptFs = {
+    existsSync: (p) => fs.existsSync(p),
+    readFileSync: (p) => fs.readFileSync(p, "utf8"),
+    readdirSync: (p) => fs.readdirSync(p),
+};
+export function resolveMemoryDir(workerDir, memoryDir) {
+    return memoryDir?.trim() ? memoryDir.replace(/\/+$/, "") : path.join(workerDir, "memory");
+}
+function readMemory(hqRoot, memoryRel, io) {
+    const memory = [];
+    const memDir = path.isAbsolute(memoryRel) ? memoryRel : path.join(hqRoot, memoryRel);
+    if (!io.existsSync(memDir))
+        return memory;
+    let total = 0;
+    let names;
+    try {
+        names = io.readdirSync(memDir).sort();
+    }
+    catch {
+        return memory;
+    }
+    for (const name of names) {
+        if (!name.endsWith(".md") || name.startsWith("."))
+            continue;
+        let body;
+        try {
+            body = io.readFileSync(path.join(memDir, name));
+        }
+        catch {
+            continue;
+        }
+        if (body.length > MEMORY_FILE_BUDGET_BYTES) {
+            body = `${body.slice(0, MEMORY_FILE_BUDGET_BYTES)}\n\n[truncated: ${name} exceeds the memory file budget]`;
+        }
+        if (total + body.length > MEMORY_TOTAL_BUDGET_BYTES)
+            break;
+        total += body.length;
+        memory.push({ name, body });
+    }
+    return memory;
+}
+/** A path is usable only when it stays inside the HQ root (no `..`, no absolute escapes). */
+function insideHqRoot(hqRoot, rel) {
+    const root = path.resolve(hqRoot);
+    const abs = path.resolve(root, rel);
+    if (abs === root || !abs.startsWith(root + path.sep))
+        return null;
+    return abs;
+}
+function asString(v) {
+    return typeof v === "string" && v.trim() ? v.trim() : undefined;
+}
+/** `instructions` may be a string, a block scalar, or a list of strings/objects. */
+export function normalizeInstructions(raw) {
+    if (typeof raw === "string")
+        return raw.trim() || undefined;
+    if (Array.isArray(raw)) {
+        const lines = raw
+            .map((item) => {
+            if (typeof item === "string")
+                return item.trim();
+            if (item && typeof item === "object")
+                return yaml.dump(item, { lineWidth: -1 }).trim();
+            return item === null || item === undefined ? "" : String(item);
+        })
+            .filter(Boolean)
+            .map((line) => `- ${line.replace(/\n/g, "\n  ")}`);
+        return lines.length > 0 ? lines.join("\n") : undefined;
+    }
+    return undefined;
+}
+function resolveSkillFile(hqRoot, workerDir, name, doc, io) {
+    const candidates = [];
+    const docRel = asString(doc);
+    if (docRel)
+        candidates.push(path.isAbsolute(docRel) ? docRel : path.join(workerDir, docRel));
+    candidates.push(path.join(workerDir, "skills", `${name}.md`), path.join(workerDir, "skills", name, "SKILL.md"));
+    for (const rel of candidates) {
+        let abs = insideHqRoot(hqRoot, rel);
+        // The portable setup template is shipped outside the HQ tree. Only its
+        // own skills may cross that boundary; other workers keep the HQ guard.
+        if (!abs) {
+            const bundled = path.join(packageRoot(), "assets", "bot-workers", "setup");
+            if (path.resolve(hqRoot, workerDir) === bundled) {
+                abs = insideHqRoot(path.join(bundled, "skills"), path.resolve(hqRoot, rel));
+            }
+        }
+        if (abs && io.existsSync(abs))
+            return path.relative(path.resolve(hqRoot), abs);
+    }
+    return undefined;
+}
+function readWorkerSource(hqRoot, workerDir, workerYaml, io, companyOverride) {
+    const out = { skills: [], contextFiles: [], contextPaths: [], policyPaths: [] };
+    let doc = {};
+    if (workerYaml) {
+        try {
+            const parsed = yaml.load(workerYaml);
+            if (parsed && typeof parsed === "object")
+                doc = parsed;
+        }
+        catch {
+            doc = {};
+        }
+    }
+    const meta = (doc.worker && typeof doc.worker === "object" ? doc.worker : {});
+    out.id = asString(meta.id);
+    out.name = asString(meta.name);
+    out.company = companyOverride ?? asString(meta.company);
+    out.description = asString(meta.description);
+    out.instructions = normalizeInstructions(doc.instructions);
+    const identity = (doc.identity && typeof doc.identity === "object" ? doc.identity : {});
+    out.persona = asString(identity.persona);
+    if (Array.isArray(doc.skills)) {
+        for (const item of doc.skills) {
+            if (!item || typeof item !== "object")
+                continue;
+            const s = item;
+            const name = asString(s.name);
+            if (!name)
+                continue;
+            const file = resolveSkillFile(hqRoot, workerDir, name, s.doc, io);
+            out.skills.push({ name, ...(asString(s.description) ? { description: asString(s.description) } : {}), ...(file ? { file } : {}) });
+        }
+    }
+    const context = (doc.context && typeof doc.context === "object" ? doc.context : {});
+    const bundledSetup = path.resolve(hqRoot, workerDir) === path.join(packageRoot(), "assets", "bot-workers", "setup");
+    if (Array.isArray(context.base)) {
+        let total = 0;
+        for (const entry of context.base) {
+            const rel = asString(typeof entry === "string" ? entry : entry?.path);
+            if (!rel)
+                continue;
+            const abs = bundledSetup ? insideHqRoot(path.join(packageRoot(), "assets", "bot-workers", "setup"), rel) : insideHqRoot(hqRoot, rel);
+            if (!abs)
+                continue;
+            const shown = rel.replace(/^\.\//, "");
+            if (rel.endsWith("/") || !io.existsSync(abs)) {
+                out.contextPaths.push(shown);
+                continue;
+            }
+            let body;
+            try {
+                body = io.readFileSync(abs);
+            }
+            catch {
+                out.contextPaths.push(shown);
+                continue;
+            }
+            let truncated = false;
+            if (body.length > CONTEXT_FILE_BUDGET_BYTES) {
+                body = `${body.slice(0, CONTEXT_FILE_BUDGET_BYTES)}\n\n[truncated: ${shown} exceeds the context file budget — read the file for the rest]`;
+                truncated = true;
+            }
+            if (total + body.length > CONTEXT_TOTAL_BUDGET_BYTES) {
+                out.contextPaths.push(shown);
+                continue;
+            }
+            total += body.length;
+            out.contextFiles.push({ path: shown, body, ...(truncated ? { truncated } : {}) });
+        }
+    }
+    if (out.company) {
+        const policiesRel = path.join("companies", out.company, "policies");
+        const policiesAbs = insideHqRoot(hqRoot, policiesRel);
+        if (policiesAbs && io.existsSync(policiesAbs)) {
+            let names;
+            try {
+                names = io.readdirSync(policiesAbs).sort();
+            }
+            catch {
+                names = [];
+            }
+            out.policyPaths = names
+                .filter((n) => n.endsWith(".md") && !n.startsWith(".") && !n.includes(".conflict-"))
+                .map((n) => path.join(policiesRel, n));
+        }
+    }
+    return out;
+}
+export function readPromptSources(hqRoot, workerDir, io = defaultPromptFs, opts = {}) {
+    const base = path.join(hqRoot, workerDir);
+    const read = (file) => {
+        const p = path.join(base, file);
+        if (!io.existsSync(p))
+            return undefined;
+        try {
+            return io.readFileSync(p);
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const memory = readMemory(hqRoot, resolveMemoryDir(workerDir, opts.memoryDir), io);
+    const workerYaml = read("worker.yaml");
+    if (opts.workerSource === "worker") {
+        return {
+            workerYaml,
+            persona: read("persona.md"),
+            memory,
+            worker: readWorkerSource(hqRoot, workerDir, workerYaml, io, opts.companySlug),
+        };
+    }
+    return { workerYaml, persona: read("persona.md"), memory };
+}
+/**
+ * The standing instructions the bot runs under. The DM body is delivered as
+ * the user turn; this text is the system prompt (claude/codex) or the prompt
+ * preamble (grok).
+ */
+export function buildSystemPrompt(input) {
+    const memoryDir = resolveMemoryDir(input.workerDir, input.memoryDir);
+    const workerMode = input.workerSource === "worker" && input.sources.worker !== undefined;
+    const worker = input.sources.worker;
+    const workerId = input.workerId ?? worker?.id ?? path.basename(input.workerDir);
+    const company = input.companySlug ?? worker?.company;
+    const parts = [];
+    const opening = workerMode
+        ? `You are "${input.botName}", a personal HQ bot running the company worker \`${workerId}\`${company ? ` for \`${company}\`` : ""}, locally on your owner's computer.` +
+            (worker?.name ? ` The worker is "${worker.name}".` : "") +
+            (worker?.description ? ` ${worker.description}` : "") +
+            `\nYou work only inside \`${company ?? "this company"}\`'s context: its files, policies, services, and credentials — never another company's.`
+        : `You are "${input.botName}", a personal HQ bot that runs locally on your owner's computer.`;
+    parts.push(`${opening}\n` +
+        `Your HQ identity is ${input.agentUid}. Your owner is ${input.ownerUid}; only your owner can message you.\n` +
+        `You act with your owner's permissions, and every tool and command is pre-approved for you — do not ask for approval, just do the work. ` +
+        `Their HQ folder is ${input.hqRoot}; it is your working directory, so its files, skills, and \`hq\` commands are available directly.\n` +
+        `\`hq\` commands you run authenticate as you, the bot (${input.agentUid}), not as your owner: \`hq whoami\`, membership and company lookups describe the bot, ` +
+        `and a bot usually belongs to no company. Never use them to say who your owner is or which companies they belong to. ` +
+        `Direct messages from your owner start with an "Owner context" block checked with your owner's own sign-in; that is the only source for your owner's companies. ` +
+        `If it says the check failed, say you could not check; never say your owner has no company unless that block says so. ` +
+        `Room messages do not carry it: in a room, never state which companies your owner belongs to.\n` +
+        `Each message you receive is a direct message from your owner. Whatever you print as your final answer is sent back as a DM reply, ` +
+        `so answer the person directly, in plain language, and keep it as short as the request allows. ` +
+        `Do not narrate tool use or repeat the question. If you cannot do something, say so and suggest the nearest thing you can do.\n` +
+        `Your standing memory lives in ${memoryDir}/ (markdown). When you learn something durable about your owner or their preferences, ` +
+        `write it there in a short note so future turns remember it; never store secrets there.\n` +
+        `Your owner can also add you to group chats and channels. A message that starts with a \`[#channel · N members · from Name]\` line ` +
+        `comes from a room with other people in it (a "Recent messages:" block may follow for context; the last part is the message you are answering). ` +
+        `Answer for the room: reply to the person who asked, keep it short, and never repeat your private memory, your owner's files, ` +
+        `or anything from your DMs to other people.`);
+    if (workerMode && worker) {
+        const yamlPath = path.join(input.workerDir, "worker.yaml");
+        if (worker.instructions) {
+            parts.push(`## Worker instructions (${yamlPath})\n\n${worker.instructions}`);
+        }
+        if (worker.persona) {
+            parts.push(`## Persona\n\n${worker.persona}`);
+        }
+        if (worker.skills.length > 0) {
+            const lines = worker.skills.map((s) => {
+                const desc = s.description ? ` — ${s.description}` : "";
+                const file = s.file ? ` — ${s.file}` : " — (no skill file on disk)";
+                return `- ${s.name}${desc}${file}`;
+            });
+            parts.push(`## Skills (${path.join(input.workerDir, "skills")}/)\n\n` +
+                `These are the worker's skills. When a request matches one, read its file first and follow it.\n\n${lines.join("\n")}`);
+        }
+        if (worker.policyPaths.length > 0) {
+            parts.push(`## Company policies (companies/${company}/policies/)\n\n` +
+                `Hard rules for \`${company}\`. Read the relevant ones before acting; they override anything else in this prompt.\n\n` +
+                worker.policyPaths.map((p) => `- ${p}`).join("\n"));
+        }
+        if (worker.contextFiles.length > 0 || worker.contextPaths.length > 0) {
+            const blocks = worker.contextFiles.map((c) => `### ${c.path}\n\n${c.body.trim()}`);
+            const more = worker.contextPaths.length > 0
+                ? `\n\nAlso part of this worker's context (read on demand):\n${worker.contextPaths.map((p) => `- ${p}`).join("\n")}`
+                : "";
+            parts.push(`## Context (worker context.base)\n\n${blocks.join("\n\n")}${more}`.replace(/\n\n\n\n/g, "\n\n"));
+        }
+    }
+    else {
+        if (input.sources.workerYaml) {
+            parts.push(`## Worker definition (${path.join(input.workerDir, "worker.yaml")})\n\n\`\`\`yaml\n${input.sources.workerYaml.trim()}\n\`\`\``);
+        }
+        if (input.sources.persona) {
+            parts.push(`## Persona (${path.join(input.workerDir, "persona.md")})\n\n${input.sources.persona.trim()}`);
+        }
+    }
+    if (input.sources.memory.length > 0) {
+        const blocks = input.sources.memory.map((m) => `### ${m.name}\n\n${m.body.trim()}`);
+        parts.push(`## Memory (${memoryDir}/)\n\n${blocks.join("\n\n")}`);
+    }
+    return `${parts.join("\n\n")}\n`;
+}
+/** Fixed text sent to any non-owner who DMs the bot (never reaches the model). */
+export function nonOwnerRefusalText(botName) {
+    return `Hi — I'm ${botName}, a personal bot, and I only take messages from my owner. Please reach out to them directly.`;
+}
+/**
+ * The one-time introduction the bot DMs its owner when it first comes online.
+ * A bot created with `--intro` sends that text verbatim instead.
+ */
+export function introDmText(botName, runtime, intro) {
+    if (intro?.trim())
+        return intro.trim();
+    const runtimeLabel = runtime === "claude" ? "Claude Code" : runtime === "codex" ? "Codex" : runtime === "grok" ? "Grok" : runtime;
+    return (`Hi, I'm ${botName} — your HQ bot. I run locally on this computer using your ${runtimeLabel} login, so I can work inside your HQ with your permissions.\n\n` +
+        `You can message me here from the desktop app or your phone whenever this computer is on, and I'll reply in this thread. ` +
+        `You can also open me in Claude Code or Codex from your HQ folder.\n\n` +
+        `What would you like me to do first?`);
+}
+//# sourceMappingURL=prompt.js.map

package/dist/lib/bot/room-policy.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Who the bot answers, and where the answer goes (local-bots: group chats).
+ *
+ * Pure policy over one inbox item (owner decisions, 2026-09-11):
+ * - DMs: owner only. A non-owner DM is NOT this module's concern — run.ts
+ *   sends the fixed refusal before consulting this policy; here it resolves
+ *   to `null` (ack silently) so nothing else can leak a model turn.
+ * - Rooms (channels / group chats): answer anyone who @mentions the bot, plus
+ *   plain (unmentioned) messages from the OWNER when the room is a small
+ *   group (`channelScope === "group"`). Everything else is acked without a
+ *   turn. The bot never answers its own posts.
+ * - Placement: a threaded trigger (item.rootEventId) gets a threaded reply;
+ *   a top-level mention gets a top-level reply.
+ * - Claim unit: the trigger message itself (eventId / messageId). Only an
+ *   UNMENTIONED responder (owner-in-group) claims it, so several of the
+ *   owner's bots in one group produce one answer, not one each. An explicit
+ *   @mention is never claimed: the person asked that bot, so it answers even
+ *   if a sibling bot was faster (observed live 2026-09-11: claude-bot claimed
+ *   the message that @mentioned iris).
+ * - Addressed elsewhere: the inbox item only carries `mentionedMe`, not the
+ *   full mention list, so an unmentioned bot reads the text — a message that
+ *   @mentions someone else is not for it and is acked silently.
+ */
+import type { InboxItem } from "./api.js";
+import { type BotSessionScope } from "./paths.js";
+export type ReplyTarget = {
+    kind: "dm";
+    peerUid: string;
+} | {
+    kind: "room";
+    channelId: string;
+    rootEventId?: string;
+    unitId: string;
+    sessionScope: BotSessionScope;
+    /** True when this bot was @mentioned: answer without claiming. */
+    mentioned: boolean;
+};
+export declare function textAddressesSomeone(text: string | undefined): boolean;
+export interface ReplyPolicyConfig {
+    ownerUid: string;
+    agentUid: string;
+    /**
+     * The bot's name, so a plain-text `@<name>` counts as a mention. Group DMs
+     * sent from the CLI carry no structured mentions (only channels resolve
+     * `@name`), so without this "@claude-bot …" in a group would be treated as
+     * addressed to someone else and nobody would answer.
+     */
+    name?: string;
+}
+export declare function textMentionsName(text: string | undefined, name: string | undefined): boolean;
+export declare function isDmItem(item: Pick<InboxItem, "channel">): boolean;
+export declare function resolveReplyTarget(item: InboxItem, config: ReplyPolicyConfig): ReplyTarget | null;
+//# sourceMappingURL=room-policy.d.ts.map

package/dist/lib/bot/room-policy.js

@@ -0,0 +1,73 @@
+/**
+ * Who the bot answers, and where the answer goes (local-bots: group chats).
+ *
+ * Pure policy over one inbox item (owner decisions, 2026-09-11):
+ * - DMs: owner only. A non-owner DM is NOT this module's concern — run.ts
+ *   sends the fixed refusal before consulting this policy; here it resolves
+ *   to `null` (ack silently) so nothing else can leak a model turn.
+ * - Rooms (channels / group chats): answer anyone who @mentions the bot, plus
+ *   plain (unmentioned) messages from the OWNER when the room is a small
+ *   group (`channelScope === "group"`). Everything else is acked without a
+ *   turn. The bot never answers its own posts.
+ * - Placement: a threaded trigger (item.rootEventId) gets a threaded reply;
+ *   a top-level mention gets a top-level reply.
+ * - Claim unit: the trigger message itself (eventId / messageId). Only an
+ *   UNMENTIONED responder (owner-in-group) claims it, so several of the
+ *   owner's bots in one group produce one answer, not one each. An explicit
+ *   @mention is never claimed: the person asked that bot, so it answers even
+ *   if a sibling bot was faster (observed live 2026-09-11: claude-bot claimed
+ *   the message that @mentioned iris).
+ * - Addressed elsewhere: the inbox item only carries `mentionedMe`, not the
+ *   full mention list, so an unmentioned bot reads the text — a message that
+ *   @mentions someone else is not for it and is acked silently.
+ */
+import { roomSessionScope } from "./paths.js";
+/** `@name` (word-boundary) anywhere in the text — "a@b.com" does not count. */
+const MENTION_RE = /(^|[^\w@])@[A-Za-z0-9][\w.-]*/;
+export function textAddressesSomeone(text) {
+    return typeof text === "string" && MENTION_RE.test(text);
+}
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function textMentionsName(text, name) {
+    if (typeof text !== "string" || !name?.trim())
+        return false;
+    return new RegExp(`(^|[^\\w@])@${escapeRegExp(name.trim())}(?![\\w.-])`, "i").test(text);
+}
+export function isDmItem(item) {
+    return !item.channel || item.channel === "dm";
+}
+export function resolveReplyTarget(item, config) {
+    const sender = item.fromPersonUid ?? "";
+    if (isDmItem(item)) {
+        return sender === config.ownerUid ? { kind: "dm", peerUid: config.ownerUid } : null;
+    }
+    if (item.channel !== "room")
+        return null;
+    const channelId = typeof item.channelId === "string" ? item.channelId.trim() : "";
+    if (!channelId)
+        return null;
+    if (sender && sender === config.agentUid)
+        return null;
+    const mentioned = item.mentionedMe === true || textMentionsName(item.text, config.name);
+    const ownerInGroup = item.channelScope === "group" && sender === config.ownerUid;
+    if (!mentioned && !ownerInGroup)
+        return null;
+    // The owner addressed another member by name: not for this bot.
+    if (!mentioned && textAddressesSomeone(item.text))
+        return null;
+    const unitId = (item.eventId ?? item.messageId ?? "").trim();
+    if (!unitId)
+        return null;
+    const rootEventId = typeof item.rootEventId === "string" && item.rootEventId.trim() ? item.rootEventId.trim() : undefined;
+    return {
+        kind: "room",
+        channelId,
+        ...(rootEventId ? { rootEventId } : {}),
+        unitId,
+        sessionScope: roomSessionScope(channelId),
+        mentioned,
+    };
+}
+//# sourceMappingURL=room-policy.js.map

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

@@ -0,0 +1,98 @@
+/**
+ * The resident bot process: `hq bot run <name>` (local-bots US-003/US-004).
+ *
+ * - pid lock in ~/.hq/bots/<name>/pid; status.json is the observable state
+ * - refuses to start unless the creds file names this bot's agt_ AND the
+ *   server-side record is owned by the configured owner
+ * - heartbeat every 30s (POST /v1/agents/{uid}/heartbeat, agent JWT)
+ * - inbox poll every 5s: owner DMs go to ONE headless model turn (resumed by
+ *   session id); the reply is sent as the bot; the message is acked only after
+ *   the reply is sent; processed ids persist so a crash between reply and ack
+ *   never answers twice
+ * - non-owner DM senders get a fixed refusal and never reach the model
+ * - first start only: the intro DM, then (when bot.json has `kickoff`) ONE
+ *   model turn on that prompt as if the owner sent it, answered in the DM, so
+ *   a guided bot starts working without waiting for the owner to type
+ * - room items (channels / group chats): answered when the bot is @mentioned,
+ *   or when the owner posts in a small group (see room-policy.ts); claimed
+ *   first (first-claim-wins), one session per room, reply posted in the room
+ * - while a turn runs, each finished assistant message is posted as its own
+ *   message (progress.ts); turns have no time limit
+ * - every received message gets a reply: a turn that fails after the model
+ *   started (error, crash, owner stop, restart) posts one "did not finish"
+ *   message and is NOT run again — it may already have done outward things.
+ *   inflight.json marks the turn in progress so a restart can say so.
+ * - failures before the model starts (missing binary) retry with backoff;
+ *   5 model failures in 10 minutes → state `failed` and a clean exit (launchd
+ *   does not respawn a clean exit). Owner stops never count.
+ *
+ * Everything with a side effect is injectable so the loop is unit-testable.
+ */
+import { type OwnerContext } from "./owner-context.js";
+import type { BotApi } from "./api.js";
+import type { BotConfig } from "./config.js";
+import { type ProgressPosterOptions } from "./progress.js";
+import { type BotLogger } from "./log.js";
+import { type BotRuntime, type RuntimeTurnInput, type RuntimeTurnResult } from "./runtime/index.js";
+import { type BotState, type BotStatusFile } from "./status.js";
+export declare const INBOX_POLL_INTERVAL_MS = 2000;
+export declare const HEARTBEAT_INTERVAL_MS = 30000;
+export declare const FAILURE_WINDOW_MS: number;
+export declare const FAILURE_LIMIT = 5;
+export declare const MAX_ATTEMPTS_PER_MESSAGE = 3;
+export declare const THINKING_EMOJI = "\uD83D\uDC40";
+export declare const ROOM_THINKING_STATUS = "is thinking\u2026";
+export declare const RECENT_MESSAGES_LIMIT = 15;
+export declare const RECENT_MESSAGE_MAX_CHARS = 400;
+export type SleepFn = (ms: number) => Promise<void>;
+export interface BotRunDeps {
+    dir: string;
+    config: BotConfig;
+    api: BotApi;
+    runtime: BotRuntime;
+    runTurn?: (runtime: BotRuntime, input: RuntimeTurnInput) => Promise<RuntimeTurnResult>;
+    now?: () => Date;
+    sleep?: SleepFn;
+    random?: () => number;
+    log?: BotLogger;
+    pid?: number;
+    isProcessAlive?: (pid: number) => boolean;
+    inboxIntervalMs?: number;
+    heartbeatIntervalMs?: number;
+    /** Override the rendered system prompt (tests). */
+    systemPromptOverride?: string;
+    /** Signal source; defaults to `process`. */
+    processEvents?: {
+        once(event: "SIGTERM" | "SIGINT" | "SIGUSR2", cb: () => void): unknown;
+    };
+    /** Called when the loop ends; defaults to process.exit. */
+    exit?: (code: number) => void;
+    /** Skip the pid lock (tests that run several bots in one process). */
+    skipPidLock?: boolean;
+    /** Progress-post timing overrides (tests). */
+    progress?: Pick<ProgressPosterOptions, "coalesceMs" | "minGapMs" | "workingNoticeMs" | "setTimer" | "clearTimer" | "now">;
+    /**
+     * The owner's verified company context, prepended to every owner DM turn
+     * (never room turns) so the model never mistakes the bot's own (empty)
+     * memberships for its owner's.
+     * Omitted in tests that do not exercise it.
+     */
+    ownerContext?: () => Promise<OwnerContext>;
+}
+export declare const KICKOFF_MESSAGE_ID = "kickoff";
+/** The core worker HQ's setup bot runs. */
+export declare const SETUP_WORKER_ID = "setup";
+/** The one message a person gets when a turn on their message did not finish. */
+export declare function didNotFinishText(reason: string, progressPosted: boolean): string;
+/** Owner stop, `hq bot stop` or `hq bot restart`: all arrive as the same signal. */
+export declare const STOPPED_BY_OWNER_REASON = "I was stopped before I was done";
+export declare const RESTARTED_REASON = "I was restarted while I was working on it";
+export interface BotHandle {
+    stop(mode?: "abort" | "drain"): Promise<void>;
+    /** Resolves when both loops have ended (state stopped or failed). */
+    done: Promise<BotState>;
+    status(): BotStatusFile | null;
+}
+export declare function preflightCreds(dir: string, config: BotConfig): string | null;
+export declare function runBot(deps: BotRunDeps): Promise<BotHandle>;
+//# sourceMappingURL=run.d.ts.map