@indigoai-us/hq-cli 5.109.16 → 5.111.0

package/dist/lib/bot/promote.js

@@ -0,0 +1,106 @@
+import { recordActivePromotion } from "./promotion-receipt.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+import { botCredsPath } from "./paths.js";
+import { snapshotBotContinuity, validateBotContinuity } from "./continuity.js";
+import { attestPromotionDrain, holdForPromotion, waitForPromotionDrain } from "./promotion-hold.js";
+import { uploadLocalBotPromotion } from "./promotion-upload.js";
+/** Private bounded reads; never expose parser errors containing credential bytes. */
+function readPrivateJson(file, limit) {
+    if (fs.realpathSync(file) !== path.resolve(file))
+        throw new Error("Promotion files cannot use symlinks");
+    const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+    try {
+        const stat = fs.fstatSync(fd);
+        if (!stat.isFile() || stat.size > limit || (stat.mode & 0o077))
+            throw new Error("Promotion requires a bounded private regular file");
+        const bytes = Buffer.alloc(stat.size);
+        let offset = 0;
+        while (offset < bytes.length) {
+            const n = fs.readSync(fd, bytes, offset, bytes.length - offset, offset);
+            if (!n)
+                throw new Error("Promotion file changed");
+            offset += n;
+        }
+        try {
+            return JSON.parse(bytes.toString("utf8"));
+        }
+        catch {
+            throw new Error("Promotion file contains invalid JSON");
+        }
+        finally {
+            bytes.fill(0);
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** One recoverable local-to-cloud step, used by CLI and desktop. Never kills the
+ * local runtime, recopies provider login files, or changes another bot.
+ */
+export async function promoteLocalBot(input) {
+    const { dir, config, companyUid, api } = input;
+    const existing = await api.promotionStatus(config.agentUid, companyUid);
+    const holdFile = path.join(dir, "promotion-hold.json");
+    const localHold = fs.existsSync(holdFile) ? readPrivateJson(holdFile, 2048) : null;
+    const operationId = existing?.operationId ?? localHold?.operationId ?? randomUUID();
+    if (!/^[A-Za-z0-9_-]{16,128}$/.test(operationId))
+        throw new Error("Invalid saved promotion operation");
+    const hold = { agentUid: config.agentUid, ownerUid: config.ownerUid, companyUid, operationId };
+    if (existing && (existing.agentUid !== config.agentUid || existing.ownerUid !== config.ownerUid || existing.companyUid !== companyUid))
+        throw new Error("Promotion belongs to another bot or destination");
+    if (existing?.phase === "cancelled")
+        throw new Error("This promotion was cancelled");
+    holdForPromotion(dir, hold);
+    if (existing?.phase === "active") {
+        recordActivePromotion(dir, hold, existing);
+        return { promotion: existing, pending: false };
+    }
+    await waitForPromotionDrain(dir, input.drainTimeoutMs ?? 60_000);
+    const file = path.join(dir, `promotion-snapshot-${operationId}.json`);
+    if (!fs.existsSync(file)) {
+        if (existing)
+            throw new Error("The original frozen snapshot is missing. Restore it before retrying.");
+        const snapshot = snapshotBotContinuity(config, dir);
+        const temp = `${file}.${randomUUID()}.tmp`;
+        fs.writeFileSync(temp, JSON.stringify(snapshot), { mode: 0o600, flag: "wx" });
+        try {
+            fs.linkSync(temp, file);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+        finally {
+            fs.unlinkSync(temp);
+        }
+    }
+    const bundle = readPrivateJson(file, 48 * 1024 * 1024);
+    validateBotContinuity(bundle, { agentUid: config.agentUid, ownerUid: config.ownerUid });
+    if (existing && existing.snapshotSha256 !== bundle.digest)
+        throw new Error("Frozen snapshot does not match the cloud operation");
+    let state = existing;
+    if (!state || state.phase === "preparing") {
+        const machine = readPrivateJson(botCredsPath(dir), 8192);
+        if (!machine || typeof machine !== "object" || typeof machine.secret !== "string")
+            throw new Error("Invalid bot machine credential");
+        try {
+            state = await uploadLocalBotPromotion({ api, bundle, machine, companyUid, operationId });
+            const proof = await attestPromotionDrain(dir, hold, bundle.digest, machine);
+            state = await api.confirmPromotionStopped(config.agentUid, { companyUid, operationId, proof });
+        }
+        finally {
+            machine.secret = "";
+        }
+    }
+    if (state.phase === "local-stopped" || state.phase === "imported" || state.phase === "cloud-ready") {
+        const result = await api.resumePromotion(config.agentUid, { companyUid, operationId });
+        if (result.promotion.phase === "active")
+            recordActivePromotion(dir, hold, result.promotion);
+        return result;
+    }
+    return { promotion: state, pending: state.phase !== "active" };
+}
+//# sourceMappingURL=promote.js.map

package/dist/lib/bot/promotion-hold.d.ts

@@ -0,0 +1,24 @@
+import type { BotMachineCreds } from "./creds.js";
+/** Even a malformed marker stops startup; never silently discard a handoff. */
+export declare function hasPromotionHold(dir: string): boolean;
+export interface LocalPromotionHold {
+    agentUid: string;
+    ownerUid: string;
+    companyUid: string;
+    operationId: string;
+}
+/** Durable, exclusive intent. The running bot observes it without signalling a
+ * possibly reused PID; it finishes its current reply/ACK and exits cleanly.
+ */
+export declare function holdForPromotion(dir: string, hold: LocalPromotionHold): void;
+/** A timeout leaves the hold intact and never aborts the model turn. */
+export declare function waitForPromotionDrain(dir: string, timeoutMs?: number): Promise<void>;
+/** Called after freezing/uploading the snapshot; rechecks the durable hold and
+ * exited process immediately before authorizing the server handoff boundary.
+ */
+export declare function attestPromotionDrain(dir: string, hold: LocalPromotionHold, snapshotSha256: string, machine: BotMachineCreds): Promise<string>;
+/** Display-only summary. Any unreadable or mismatched hold still blocks local controls. */
+export declare function promotionHoldSummary(dir: string, agentUid: string, ownerUid: string): {
+    companyUid: string | null;
+} | null;
+//# sourceMappingURL=promotion-hold.d.ts.map

package/dist/lib/bot/promotion-hold.js

@@ -0,0 +1,103 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createHmac } from "node:crypto";
+import { readPidLock } from "../mesh/live/daemon/pid-lock.js";
+import { daemonPidPath } from "../mesh/live/daemon/paths.js";
+import { isPidAlive, readBotStatus } from "./status.js";
+import { botInflightPath } from "./inflight.js";
+const holdPath = (dir) => path.join(dir, "promotion-hold.json");
+/** Even a malformed marker stops startup; never silently discard a handoff. */
+export function hasPromotionHold(dir) {
+    try {
+        fs.lstatSync(holdPath(dir));
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+/** Durable, exclusive intent. The running bot observes it without signalling a
+ * possibly reused PID; it finishes its current reply/ACK and exits cleanly.
+ */
+export function holdForPromotion(dir, hold) {
+    if (!/^agt_[A-Za-z0-9]+$/.test(hold.agentUid) || !/^prs_[A-Za-z0-9]+$/.test(hold.ownerUid) ||
+        !/^cmp_[A-Za-z0-9]+$/.test(hold.companyUid) || !/^[A-Za-z0-9_-]{16,128}$/.test(hold.operationId))
+        throw new Error("Invalid local promotion operation");
+    const serialized = JSON.stringify(hold);
+    try {
+        fs.writeFileSync(holdPath(dir), serialized, { flag: "wx", mode: 0o600 });
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+        const stat = fs.lstatSync(holdPath(dir));
+        if (!stat.isFile() || stat.size > 2048 || fs.readFileSync(holdPath(dir), "utf8") !== serialized)
+            throw new Error("Another promotion owns this local bot");
+    }
+}
+/** A timeout leaves the hold intact and never aborts the model turn. */
+export async function waitForPromotionDrain(dir, timeoutMs = 60_000) {
+    if (!hasPromotionHold(dir))
+        throw new Error("Promotion hold is missing");
+    if (!Number.isFinite(timeoutMs) || timeoutMs < 0 || timeoutMs > 300_000)
+        throw new Error("Invalid drain timeout");
+    const deadline = Date.now() + timeoutMs;
+    do {
+        const lock = readPidLock(daemonPidPath(dir));
+        if (!lock && fs.existsSync(daemonPidPath(dir)))
+            throw new Error("The local process lock could not be verified");
+        const status = readBotStatus(dir);
+        const alive = (lock && isPidAlive(lock.pid)) || (status && isPidAlive(status.pid));
+        if (!alive) {
+            if (fs.existsSync(botInflightPath(dir)))
+                throw new Error("The local bot has an unfinished reply. Recover it before promotion.");
+            return;
+        }
+        if (!status?.canDrainForPromotion)
+            throw new Error("Update the local bot before promoting it");
+        if (Date.now() >= deadline)
+            break;
+        await new Promise(resolve => setTimeout(resolve, Math.min(250, deadline - Date.now())));
+    } while (Date.now() <= deadline);
+    throw new Error("The bot is finishing its current reply. Retry promotion when it has stopped.");
+}
+/** Called after freezing/uploading the snapshot; rechecks the durable hold and
+ * exited process immediately before authorizing the server handoff boundary.
+ */
+export async function attestPromotionDrain(dir, hold, snapshotSha256, machine) {
+    if (!/^[a-f0-9]{64}$/.test(snapshotSha256) || machine.entityType !== "agent" || machine.entityUid !== hold.agentUid ||
+        machine.username !== `agt-${hold.agentUid.slice(4).toLowerCase()}@agents.getindigo.ai` ||
+        typeof machine.secret !== "string" || machine.secret.length < 32 || machine.secret.length > 256)
+        throw new Error("Invalid promotion signing identity");
+    holdForPromotion(dir, hold);
+    await waitForPromotionDrain(dir, 0);
+    return createHmac("sha256", machine.secret).update(JSON.stringify(["hq-local-bot-drained-v1", hold.agentUid, hold.ownerUid, hold.companyUid, hold.operationId, snapshotSha256])).digest("hex");
+}
+/** Display-only summary. Any unreadable or mismatched hold still blocks local controls. */
+export function promotionHoldSummary(dir, agentUid, ownerUid) {
+    if (!hasPromotionHold(dir))
+        return null;
+    let fd;
+    try {
+        fd = fs.openSync(holdPath(dir), fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+        const stat = fs.fstatSync(fd);
+        if (!stat.isFile() || stat.size > 2048)
+            return { companyUid: null };
+        const bytes = Buffer.alloc(stat.size);
+        if (fs.readSync(fd, bytes, 0, bytes.length, 0) !== bytes.length)
+            return { companyUid: null };
+        const hold = JSON.parse(bytes.toString("utf8"));
+        return { companyUid: hold?.agentUid === agentUid && hold?.ownerUid === ownerUid &&
+                typeof hold.companyUid === "string" && /^cmp_[A-Za-z0-9]+$/.test(hold.companyUid) ? hold.companyUid : null };
+    }
+    catch {
+        return { companyUid: null };
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+}
+//# sourceMappingURL=promotion-hold.js.map

package/dist/lib/bot/promotion-receipt.d.ts

@@ -0,0 +1,9 @@
+import type { BotPromotionState } from "./api.js";
+import { type LocalPromotionHold } from "./promotion-hold.js";
+/** Cache only the authenticated server's terminal response. The local hold is
+ * permanent until an explicit rollback; this receipt controls presentation only.
+ */
+export declare function recordActivePromotion(dir: string, hold: LocalPromotionHold, state: BotPromotionState): void;
+/** Invalid receipts never cause a local bot to be presented as cloud-hosted. */
+export declare function hasActivePromotion(dir: string, agentUid: string, ownerUid: string): boolean;
+//# sourceMappingURL=promotion-receipt.d.ts.map

package/dist/lib/bot/promotion-receipt.js

@@ -0,0 +1,56 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+import { holdForPromotion } from "./promotion-hold.js";
+const receiptPath = (dir) => path.join(dir, "promotion-active.json");
+/** Cache only the authenticated server's terminal response. The local hold is
+ * permanent until an explicit rollback; this receipt controls presentation only.
+ */
+export function recordActivePromotion(dir, hold, state) {
+    if (state.phase !== "active" || !Number.isInteger(state.version) || state.version < 1 ||
+        !/^[a-f0-9]{64}$/.test(state.snapshotSha256) ||
+        Object.entries(hold).some(([key, value]) => state[key] !== value)) {
+        throw new Error("Cloud activation does not match this local bot promotion");
+    }
+    holdForPromotion(dir, hold);
+    const value = { ...hold, phase: "active", version: state.version, snapshotSha256: state.snapshotSha256 };
+    const temp = `${receiptPath(dir)}.${randomUUID()}.tmp`;
+    fs.writeFileSync(temp, JSON.stringify(value), { flag: "wx", mode: 0o600 });
+    try {
+        fs.renameSync(temp, receiptPath(dir));
+    }
+    finally {
+        fs.rmSync(temp, { force: true });
+    }
+}
+/** Invalid receipts never cause a local bot to be presented as cloud-hosted. */
+export function hasActivePromotion(dir, agentUid, ownerUid) {
+    let fd;
+    try {
+        fd = fs.openSync(receiptPath(dir), fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+        const stat = fs.fstatSync(fd);
+        if (!stat.isFile() || stat.size > 2048 || (stat.mode & 0o077))
+            return false;
+        const bytes = Buffer.alloc(stat.size);
+        if (fs.readSync(fd, bytes, 0, bytes.length, 0) !== bytes.length)
+            return false;
+        const state = JSON.parse(bytes.toString("utf8"));
+        if (state?.agentUid !== agentUid || state?.ownerUid !== ownerUid || state?.phase !== "active" ||
+            !Number.isInteger(state.version) || state.version < 1 || !/^[a-f0-9]{64}$/.test(state.snapshotSha256))
+            return false;
+        const holdFile = path.join(dir, "promotion-hold.json");
+        const holdStat = fs.lstatSync(holdFile);
+        if (!holdStat.isFile() || holdStat.size > 2048)
+            return false;
+        const hold = JSON.parse(fs.readFileSync(holdFile, "utf8"));
+        return ["agentUid", "ownerUid", "companyUid", "operationId"].every(key => typeof state[key] === "string" && state[key] === hold[key]);
+    }
+    catch {
+        return false;
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+}
+//# sourceMappingURL=promotion-receipt.js.map

package/dist/lib/bot/promotion-upload.d.ts

@@ -0,0 +1,16 @@
+import type { BotMachineCreds } from "./creds.js";
+import { BotApi, type BotPromotionState } from "./api.js";
+import { type BotContinuityBundle } from "./continuity.js";
+/** Upload a frozen local snapshot plus ONLY its HQ machine credential. The
+ * caller owns draining and a durable local operation lock across this method.
+ * No model-provider auth files are read or accepted. No runtime is activated.
+ */
+export declare function uploadLocalBotPromotion(input: {
+    api: BotApi;
+    bundle: BotContinuityBundle;
+    machine: BotMachineCreds;
+    companyUid: string;
+    operationId: string;
+    fetchImpl?: typeof fetch;
+}): Promise<BotPromotionState>;
+//# sourceMappingURL=promotion-upload.d.ts.map

package/dist/lib/bot/promotion-upload.js

@@ -0,0 +1,65 @@
+import { createHash } from "node:crypto";
+import { validateBotContinuity } from "./continuity.js";
+function sha(bytes) { return createHash("sha256").update(bytes).digest("hex"); }
+function assertState(state, bundle, companyUid, operationId) {
+    if (!state || state.agentUid !== bundle.agentUid || state.ownerUid !== bundle.ownerUid ||
+        state.companyUid !== companyUid || state.operationId !== operationId || state.snapshotSha256 !== bundle.digest ||
+        state.phase !== "preparing")
+        throw new Error("Promotion preparation returned a different identity or phase");
+}
+/** Only the presigned object request receives these bytes. Owner authorization
+ * is handled by BotApi and is never forwarded to S3 or a redirect destination.
+ */
+async function uploadObject(upload, bytes, fetchImpl) {
+    const url = new URL(upload.url);
+    if (url.protocol !== "https:" || url.username || url.password || url.port ||
+        !/^[a-z0-9.-]+\.s3(?:[.-][a-z0-9-]+)?\.amazonaws\.com$/.test(url.hostname) ||
+        upload.method !== "PUT" || upload.bytes !== bytes.length || upload.sha256 !== sha(bytes) ||
+        upload.headers["x-amz-server-side-encryption"] !== "aws:kms" ||
+        !upload.headers["x-amz-server-side-encryption-aws-kms-key-id"] ||
+        upload.headers["if-none-match"] !== "*" ||
+        upload.headers["x-amz-checksum-sha256"] !== Buffer.from(upload.sha256, "hex").toString("base64") ||
+        Object.keys(upload.headers).some(key => /^(authorization|cookie)$/i.test(key))) {
+        throw new Error("Invalid private promotion upload destination");
+    }
+    const response = await fetchImpl(url, { method: "PUT", headers: upload.headers,
+        body: new Uint8Array(bytes), redirect: "error", signal: AbortSignal.timeout(60_000) });
+    // The key is immutable and content-addressed. A repeat PUT cannot replace it;
+    // the server's checksum/KMS readback still verifies it before any import.
+    if (!response.ok && response.status !== 412)
+        throw new Error(`Promotion upload failed (${response.status})`);
+    await response.body?.cancel();
+}
+/** Upload a frozen local snapshot plus ONLY its HQ machine credential. The
+ * caller owns draining and a durable local operation lock across this method.
+ * No model-provider auth files are read or accepted. No runtime is activated.
+ */
+export async function uploadLocalBotPromotion(input) {
+    const { api, bundle, machine, companyUid, operationId } = input;
+    validateBotContinuity(bundle, { agentUid: bundle.agentUid, ownerUid: bundle.ownerUid });
+    if (!/^cmp_[A-Za-z0-9]+$/.test(companyUid) || !/^[A-Za-z0-9_-]{16,128}$/.test(operationId) ||
+        machine.entityType !== "agent" || machine.entityUid !== bundle.agentUid ||
+        machine.username !== `agt-${bundle.agentUid.slice(4).toLowerCase()}@agents.getindigo.ai` ||
+        typeof machine.secret !== "string" || machine.secret.length < 32 || machine.secret.length > 256) {
+        throw new Error("Invalid bot promotion identity");
+    }
+    const snapshot = Buffer.from(JSON.stringify(bundle));
+    const credential = Buffer.from(JSON.stringify({ kind: "hq-bot-machine-credential-v1", agentUid: bundle.agentUid,
+        ownerUid: bundle.ownerUid, digest: bundle.digest, operationId, username: machine.username, secret: machine.secret }));
+    try {
+        let state = await api.preparePromotion(bundle.agentUid, { companyUid, operationId, snapshotSha256: bundle.digest });
+        assertState(state, bundle, companyUid, operationId);
+        for (const [kind, bytes] of [["snapshot", snapshot], ["machine-credential", credential]]) {
+            const signed = await api.promotionUpload(bundle.agentUid, { companyUid, operationId, kind, bytes: bytes.length, sha256: sha(bytes) });
+            assertState(signed.promotion, bundle, companyUid, operationId);
+            await uploadObject(signed.upload, bytes, input.fetchImpl ?? fetch);
+            state = signed.promotion;
+        }
+        return state;
+    }
+    finally {
+        credential.fill(0);
+        snapshot.fill(0);
+    }
+}
+//# sourceMappingURL=promotion-upload.js.map

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

@@ -0,0 +1,103 @@
+/**
+ * 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.
+ */
+export declare const MEMORY_FILE_BUDGET_BYTES: number;
+export declare const MEMORY_TOTAL_BUDGET_BYTES: number;
+export declare const CONTEXT_FILE_BUDGET_BYTES: number;
+export declare const CONTEXT_TOTAL_BUDGET_BYTES: number;
+export interface WorkerSkillSource {
+    name: string;
+    description?: string;
+    /** hqRoot-relative path of the skill body, when one exists on disk. */
+    file?: string;
+}
+export interface WorkerContextFile {
+    /** hqRoot-relative path. */
+    path: string;
+    body: string;
+    truncated?: boolean;
+}
+export interface WorkerPromptSource {
+    id?: string;
+    name?: string;
+    company?: string;
+    description?: string;
+    instructions?: string;
+    persona?: string;
+    skills: WorkerSkillSource[];
+    /** context.base files inlined (within budget). */
+    contextFiles: WorkerContextFile[];
+    /** context.base entries that could not be inlined (over budget / unreadable). */
+    contextPaths: string[];
+    /** companies/<co>/policies/*.md, hqRoot-relative. */
+    policyPaths: string[];
+}
+export interface PromptSources {
+    workerYaml?: string;
+    persona?: string;
+    memory: Array<{
+        name: string;
+        body: string;
+    }>;
+    /** Present in worker mode only. */
+    worker?: WorkerPromptSource;
+}
+export interface PromptFs {
+    existsSync: (p: string) => boolean;
+    readFileSync: (p: string) => string;
+    readdirSync: (p: string) => string[];
+}
+export declare const defaultPromptFs: PromptFs;
+export interface ReadPromptSourcesOptions {
+    /** Memory folder: hqRoot-relative (default `${workerDir}/memory`) or absolute. */
+    memoryDir?: string;
+    workerSource?: "scaffold" | "worker";
+    /** Company whose policies are listed (default: `worker.company` from worker.yaml). */
+    companySlug?: string;
+}
+export declare function resolveMemoryDir(workerDir: string, memoryDir?: string): string;
+/** `instructions` may be a string, a block scalar, or a list of strings/objects. */
+export declare function normalizeInstructions(raw: unknown): string | undefined;
+export declare function readPromptSources(hqRoot: string, workerDir: string, io?: PromptFs, opts?: ReadPromptSourcesOptions): PromptSources;
+export interface BuildSystemPromptInput {
+    botName: string;
+    agentUid: string;
+    ownerUid: string;
+    hqRoot: string;
+    workerDir: string;
+    sources: PromptSources;
+    workerSource?: "scaffold" | "worker";
+    workerId?: string;
+    companySlug?: string;
+    /** hqRoot-relative (default `${workerDir}/memory`) or absolute. */
+    memoryDir?: string;
+}
+/**
+ * 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 declare function buildSystemPrompt(input: BuildSystemPromptInput): string;
+/** Fixed text sent to any non-owner who DMs the bot (never reaches the model). */
+export declare function nonOwnerRefusalText(botName: string): string;
+/**
+ * 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 declare function introDmText(botName: string, runtime: string, intro?: string): string;
+//# sourceMappingURL=prompt.d.ts.map