@indigoai-us/hq-cli 5.313.0 → 5.314.0

package/dist/lib/bot/job-completions.js

@@ -1,132 +0,0 @@
-/**
- * job-completions.json — run completions the cloud has not accepted yet.
- *
- * Reporting a finished run is MANDATORY: nothing else clears the job's
- * in-progress flag, and until it is cleared every later fire of that job is
- * skipped as an overlap for up to an hour. So when the completion call fails
- * (the network was down, the token was stale), the bot logs it loudly, still
- * acks the inbox item — the work is done and must never run twice — and keeps
- * the completion here to retry.
- *
- * A retry only re-sends a small report; it never re-runs the work.
- *
- * Retries are spaced by EXPONENTIAL BACKOFF and given up on by WALL-CLOCK AGE,
- * not by a count of attempts. The inbox polls every 2 seconds, so a fixed
- * ten-attempt budget was spent in about twenty seconds — an ordinary sixty-
- * second network drop permanently lost the completion and wedged that job for
- * the rest of the server's in-progress hour. Giving up is pegged to that same
- * hour, after which the cloud releases the slot by itself anyway.
- *
- * ── After a reinstall: restore, adopt, repair (decision, 2026-09-16) ─────────
- *
- * This file lives in the bot's own folder (~/.hq/bots/<name>/), which is never
- * synced. What `hq bot restore` / `hq bot adopt` do to it decides what happens
- * to a completion owed by a run on the OLD machine:
- *
- * - REPAIR (the folder is still here; only the credentials are re-issued): the
- *   file survives and its completions are still reported, with the new
- *   credentials. That is correct — it is the same agent, and the complete route
- *   authorizes by agent identity, not by machine.
- * - ADOPT onto a fresh machine: there is no file, so nothing is reported from
- *   here. That is not a lost report: the old machine ACKED the run before it
- *   queued the completion (the work must never run twice), so the cloud will
- *   not redeliver it, and the job's in-progress slot is released by the cloud
- *   itself within the hour. Not duplicated, and not jammed for longer than the
- *   outage already cost.
- * - ADOPT into a folder that SURVIVED (bot.json gone, the rest left behind):
- *   completions stamped with THIS bot's agentUid are reported as normal. A
- *   completion stamped with a DIFFERENT agentUid — a same-named bot that was
- *   deleted and re-created — is dropped, never sent: it belongs to another
- *   identity, and reporting it against this one would be a cross-identity
- *   write that can only fail or, worse, land on the wrong run.
- *
- * Per-job model SESSIONS (session-job-<jobId>.json) need no such care: a job
- * that finds no session simply starts a fresh one, and a scheduled run carries
- * everything it needs in its own prompt.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-const BOT_JOB_COMPLETIONS_NAME = "job-completions.json";
-/** First retry gap; each failure doubles it. */
-export const COMPLETION_RETRY_BASE_MS = 2_000;
-/** Never wait longer than this between retries. */
-export const COMPLETION_RETRY_MAX_MS = 5 * 60_000;
-/**
- * Stop retrying a completion older than this. Matches the server's
- * DEFAULT_JOBS_MAX_IN_PROGRESS_SECONDS: past it the cloud reclaims the job's
- * in-progress slot on its own, so a later report changes nothing.
- */
-export const MAX_COMPLETION_AGE_MS = 60 * 60_000;
-function botJobCompletionsPath(dir) {
-    return path.join(dir, BOT_JOB_COMPLETIONS_NAME);
-}
-function isPending(raw) {
-    const c = raw;
-    return c?.v === 1 && typeof c.jobId === "string" && typeof c.messageId === "string" && typeof c.status === "string";
-}
-export function readPendingJobCompletions(dir) {
-    try {
-        const raw = JSON.parse(fs.readFileSync(botJobCompletionsPath(dir), "utf8"));
-        if (raw?.v !== 1 || !Array.isArray(raw.completions))
-            return [];
-        return raw.completions.filter(isPending);
-    }
-    catch {
-        return [];
-    }
-}
-/** The gap before attempt N (1-based), doubling and capped. */
-export function completionRetryDelayMs(attempts) {
-    const exponent = Math.max(0, attempts - 1);
-    // Bound the shift so a long-lived entry cannot overflow into Infinity.
-    const raw = COMPLETION_RETRY_BASE_MS * 2 ** Math.min(exponent, 20);
-    return Math.min(COMPLETION_RETRY_MAX_MS, raw);
-}
-/** True when this entry is due for another attempt. */
-export function isCompletionDue(entry, nowMs) {
-    return nowMs >= (entry.nextAttemptAt ?? 0);
-}
-/** True when this entry was owed by a different bot identity than `agentUid`. */
-export function isCompletionForOtherAgent(entry, agentUid) {
-    return typeof entry.agentUid === "string" && entry.agentUid !== "" && entry.agentUid !== agentUid;
-}
-/** True when the cloud has already reclaimed the slot; retrying changes nothing. */
-export function isCompletionExpired(entry, nowMs) {
-    const first = new Date(entry.firstFailedAt).getTime();
-    if (Number.isNaN(first))
-        return false;
-    return nowMs - first >= MAX_COMPLETION_AGE_MS;
-}
-function write(dir, completions) {
-    if (completions.length === 0) {
-        fs.rmSync(botJobCompletionsPath(dir), { force: true });
-        return;
-    }
-    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-    const tmp = path.join(dir, `.job-completions.tmp.${process.pid}.${Date.now()}`);
-    const file = { v: 1, completions };
-    fs.writeFileSync(tmp, `${JSON.stringify(file, null, 2)}\n`, { mode: 0o600 });
-    fs.renameSync(tmp, botJobCompletionsPath(dir));
-}
-/** Record (or back off) a completion the cloud has not taken. */
-export function recordPendingJobCompletion(dir, entry, now) {
-    const rest = readPendingJobCompletions(dir);
-    const existing = rest.find((c) => c.messageId === entry.messageId);
-    const attempts = (existing?.attempts ?? 0) + 1;
-    const next = {
-        v: 1,
-        ...entry,
-        firstFailedAt: existing?.firstFailedAt ?? now.toISOString(),
-        attempts,
-        nextAttemptAt: now.getTime() + completionRetryDelayMs(attempts),
-    };
-    write(dir, [...rest.filter((c) => c.messageId !== entry.messageId), next]);
-    return next;
-}
-export function clearPendingJobCompletion(dir, messageId) {
-    const rest = readPendingJobCompletions(dir);
-    const kept = rest.filter((c) => c.messageId !== messageId);
-    if (kept.length !== rest.length)
-        write(dir, kept);
-}
-//# sourceMappingURL=job-completions.js.map

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

@@ -1,109 +0,0 @@
-/**
- * Scheduled job runs: the third kind of inbox item a bot can be handed.
- *
- * The cloud does all the scheduling. hq-pro-agents fires a job on an
- * EventBridge schedule and writes a DURABLE inbox item for the agent
- * (`channel: "job"`) carrying the job's own prompt. Nothing is scheduled on
- * this computer — there is no crontab, no launchd timer, no local clock.
- *
- * Two rules shape everything here (owner decisions, 2026-09-15):
- *
- * - CATCH-UP, never skip. A run whose `staleAfter` has passed is still run,
- *   once, and the bot says in its report that it is a catch-up and names the
- *   time the run was originally due. A Mac that was asleep overnight wakes up
- *   and does the morning job late rather than silently dropping it.
- * - ONE catch-up per job per wake. If several runs of the SAME job are pending
- *   (a long sleep over many fires), only the newest runs; the older ones are
- *   reported to the cloud as `skipped-precondition` with a plain disposition,
- *   so the job's in-progress flag is released and the history is honest.
- *
- * Everything in this file is pure so the rules are unit-testable.
- */
-import type { InboxItem } from "./api.js";
-/** The job fields an inbox item carries when `channel === "job"`. */
-export interface JobRunFields {
-    jobId: string;
-    prompt: string;
-    /** Opaque metadata from the job record (an object on the wire). */
-    context?: Record<string, unknown> | string;
-    script?: string;
-    /** When the schedule fired (ISO-8601) — the time the run was due. */
-    firedAt?: string;
-    /** Delivery deadline (ISO-8601); past it, this is a catch-up. */
-    staleAfter?: string;
-    requestId?: string;
-}
-export declare function isJobItem(item: Pick<InboxItem, "channel">): boolean;
-/**
- * The job fields of an inbox item, or null when it is not a usable job run.
- * A job item with no jobId or no prompt is nothing the bot can run; the caller
- * acks it rather than looping on it forever.
- */
-export declare function readJobRun(item: InboxItem): JobRunFields | null;
-/** The run's extra context as text for the turn, or null when there is none. */
-export declare function jobContextText(context: JobRunFields["context"]): string | null;
-/** The zone this computer is in — where the owner scheduled the job. */
-export declare function machineTimeZone(): string;
-/**
- * A readable instant for a person: "2026-09-15 09:00 EDT".
- *
- * Rendered in the OWNER's zone, not UTC. Schedules are created in the machine's
- * zone ("every weekday at 9am" means 9am where the owner lives), so reporting
- * the same run as "due 13:00 UTC" reads as the wrong time to the only person
- * who sees it. The format is fixed (en-CA + explicit parts) rather than
- * locale-default, so the bot reads the same on every machine and the output is
- * testable.
- */
-export declare function formatJobTime(iso: string | undefined, timeZone?: string): string;
-/** True when the delivery deadline has passed: this run is late, not skipped. */
-export declare function isCatchUpRun(job: JobRunFields, now: Date): boolean;
-/**
- * The user turn for a fired job. It says plainly that this is a scheduled run
- * so the model does not answer as if a person had just spoken, and (for a late
- * run) that it is a catch-up, naming the time the run was originally due.
- */
-export declare function buildJobTurnPrompt(job: JobRunFields, opts: {
-    now: Date;
-    timeZone?: string;
-}): string;
-/**
- * The line the bot's DM report starts with, so the owner sees at a glance that
- * this is a scheduled run and not a reply to something they said.
- */
-export declare function jobReportHeader(job: JobRunFields, catchUp: boolean, timeZone?: string): string;
-/**
- * Sort key for "which pending run of this job is the newest".
- *
- * A run with NO timestamp must sort LOWEST, never highest. Falling back to the
- * messageId was a real bug: an id like `jobrun-…` sorts above any ISO timestamp
- * (letters beat digits), so a run missing `firedAt` would win as "newest" and
- * supersede a genuinely newer run — the newer work would be skipped and the
- * older one would run.
- */
-export declare function jobRunOrderKey(item: InboxItem): string;
-/** The disposition reported for an older pending run of the same job. */
-export declare const SUPERSEDED_DISPOSITION = "a newer pending run of this job ran instead (the computer was asleep through several fires)";
-/**
- * Decide which pending job runs to actually run. `handled` maps jobId to the
- * newest run key this process has already picked up; it is UPDATED in place so
- * a later poll cannot resurrect an older run of a job whose newer run already
- * finished and was acked.
- *
- * Returns the message ids that must NOT be run — they are reported to the
- * cloud as `skipped-precondition` instead.
- */
-export declare function planJobRuns(items: InboxItem[], handled: Map<string, string>): {
-    superseded: Set<string>;
-};
-/**
- * The most run output the cloud keeps (hq-pro-agents jobs/results.ts
- * `MAX_JOB_RUN_OUTPUT_BYTES`). The server bounds it itself; the client sends up
- * to the same bound rather than an arbitrary shorter cut, so a long report is
- * recorded in full wherever the cloud can hold it.
- */
-export declare const MAX_JOB_RUN_OUTPUT_BYTES: number;
-/** Cut `text` to at most `maxBytes` of UTF-8 without splitting a character. */
-export declare function jobRunOutput(text: string, maxBytes?: number): string;
-/** A saved report body with the run's header taken back off, for the cloud's record. */
-export declare function stripJobHeader(body: string, header: string | undefined): string;
-//# sourceMappingURL=job-run.d.ts.map

package/dist/lib/bot/job-run.js

@@ -1,246 +0,0 @@
-/**
- * Scheduled job runs: the third kind of inbox item a bot can be handed.
- *
- * The cloud does all the scheduling. hq-pro-agents fires a job on an
- * EventBridge schedule and writes a DURABLE inbox item for the agent
- * (`channel: "job"`) carrying the job's own prompt. Nothing is scheduled on
- * this computer — there is no crontab, no launchd timer, no local clock.
- *
- * Two rules shape everything here (owner decisions, 2026-09-15):
- *
- * - CATCH-UP, never skip. A run whose `staleAfter` has passed is still run,
- *   once, and the bot says in its report that it is a catch-up and names the
- *   time the run was originally due. A Mac that was asleep overnight wakes up
- *   and does the morning job late rather than silently dropping it.
- * - ONE catch-up per job per wake. If several runs of the SAME job are pending
- *   (a long sleep over many fires), only the newest runs; the older ones are
- *   reported to the cloud as `skipped-precondition` with a plain disposition,
- *   so the job's in-progress flag is released and the history is honest.
- *
- * Everything in this file is pure so the rules are unit-testable.
- */
-export function isJobItem(item) {
-    return item.channel === "job";
-}
-/**
- * The job fields of an inbox item, or null when it is not a usable job run.
- * A job item with no jobId or no prompt is nothing the bot can run; the caller
- * acks it rather than looping on it forever.
- */
-export function readJobRun(item) {
-    if (!isJobItem(item))
-        return null;
-    const jobId = typeof item.jobId === "string" ? item.jobId.trim() : "";
-    const prompt = typeof item.prompt === "string" ? item.prompt.trim() : "";
-    if (!jobId || !prompt)
-        return null;
-    return {
-        jobId,
-        prompt,
-        ...(item.context !== undefined && item.context !== null ? { context: item.context } : {}),
-        ...(typeof item.script === "string" && item.script.trim() ? { script: item.script } : {}),
-        ...(typeof item.firedAt === "string" && item.firedAt.trim() ? { firedAt: item.firedAt.trim() } : {}),
-        ...(typeof item.staleAfter === "string" && item.staleAfter.trim() ? { staleAfter: item.staleAfter.trim() } : {}),
-        ...(typeof item.requestId === "string" && item.requestId.trim() ? { requestId: item.requestId.trim() } : {}),
-    };
-}
-/** The run's extra context as text for the turn, or null when there is none. */
-export function jobContextText(context) {
-    if (context === undefined || context === null)
-        return null;
-    if (typeof context === "string")
-        return context.trim() || null;
-    try {
-        const keys = Object.keys(context);
-        if (keys.length === 0)
-            return null;
-        return JSON.stringify(context, null, 2);
-    }
-    catch {
-        return null;
-    }
-}
-/** The zone this computer is in — where the owner scheduled the job. */
-export function machineTimeZone() {
-    try {
-        return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
-    }
-    catch {
-        return "UTC";
-    }
-}
-/**
- * A readable instant for a person: "2026-09-15 09:00 EDT".
- *
- * Rendered in the OWNER's zone, not UTC. Schedules are created in the machine's
- * zone ("every weekday at 9am" means 9am where the owner lives), so reporting
- * the same run as "due 13:00 UTC" reads as the wrong time to the only person
- * who sees it. The format is fixed (en-CA + explicit parts) rather than
- * locale-default, so the bot reads the same on every machine and the output is
- * testable.
- */
-export function formatJobTime(iso, timeZone = machineTimeZone()) {
-    if (!iso)
-        return "an unknown time";
-    const d = new Date(iso);
-    if (Number.isNaN(d.getTime()))
-        return iso;
-    try {
-        const parts = new Intl.DateTimeFormat("en-CA", {
-            timeZone,
-            year: "numeric",
-            month: "2-digit",
-            day: "2-digit",
-            hour: "2-digit",
-            minute: "2-digit",
-            hour12: false,
-            timeZoneName: "short",
-        }).formatToParts(d);
-        const get = (type) => parts.find((p) => p.type === type)?.value ?? "";
-        const [year, month, day, hour, minute, zone] = [
-            get("year"),
-            get("month"),
-            get("day"),
-            get("hour"),
-            get("minute"),
-            get("timeZoneName"),
-        ];
-        if (!year || !month || !day || !hour || !minute)
-            throw new Error("incomplete");
-        // Intl renders midnight as "24" in some hourCycles; normalise to 00.
-        const h = hour === "24" ? "00" : hour;
-        return `${year}-${month}-${day} ${h}:${minute}${zone ? ` ${zone}` : ""}`;
-    }
-    catch {
-        return `${d.toISOString().slice(0, 16).replace("T", " ")} UTC`;
-    }
-}
-/** True when the delivery deadline has passed: this run is late, not skipped. */
-export function isCatchUpRun(job, now) {
-    if (!job.staleAfter)
-        return false;
-    const deadline = new Date(job.staleAfter);
-    if (Number.isNaN(deadline.getTime()))
-        return false;
-    return now.getTime() > deadline.getTime();
-}
-/**
- * The user turn for a fired job. It says plainly that this is a scheduled run
- * so the model does not answer as if a person had just spoken, and (for a late
- * run) that it is a catch-up, naming the time the run was originally due.
- */
-export function buildJobTurnPrompt(job, opts) {
-    const catchUp = isCatchUpRun(job, opts.now);
-    const due = formatJobTime(job.firedAt, opts.timeZone);
-    const lines = [];
-    // The due time is stated EXACTLY once: in the late sentence for a catch-up,
-    // in the opening sentence otherwise. Saying it twice reads as two times.
-    lines.push(`[Scheduled job · ${job.jobId}]`);
-    lines.push(`This is a scheduled run that fired on its own${catchUp ? "" : `, due at ${due}`}. Nobody just sent you a ` +
-        "message and nobody is waiting in a chat. Do the work described below, then finish with a short " +
-        "plain-language report of what you did and what you found — that report is what your owner reads.");
-    if (catchUp) {
-        lines.push(`This run is late: it was due at ${due} and is only running now because this computer was asleep ` +
-            "or switched off. Do it as a catch-up, skip anything that no longer makes sense at this hour, " +
-            "and say in your report that it ran late.");
-    }
-    const body = [lines.join("\n"), job.prompt];
-    const context = jobContextText(job.context);
-    if (context)
-        body.push(`Extra context for this run:\n${context}`);
-    return body.join("\n\n");
-}
-/**
- * The line the bot's DM report starts with, so the owner sees at a glance that
- * this is a scheduled run and not a reply to something they said.
- */
-export function jobReportHeader(job, catchUp, timeZone) {
-    const base = `⏰ Scheduled job \`${job.jobId}\``;
-    return catchUp
-        ? `${base} — catch-up for the run due ${formatJobTime(job.firedAt, timeZone)}\n\n`
-        : `${base}\n\n`;
-}
-/**
- * Sort key for "which pending run of this job is the newest".
- *
- * A run with NO timestamp must sort LOWEST, never highest. Falling back to the
- * messageId was a real bug: an id like `jobrun-…` sorts above any ISO timestamp
- * (letters beat digits), so a run missing `firedAt` would win as "newest" and
- * supersede a genuinely newer run — the newer work would be skipped and the
- * older one would run.
- */
-export function jobRunOrderKey(item) {
-    const fired = typeof item.firedAt === "string" ? item.firedAt.trim() : "";
-    if (fired)
-        return fired;
-    const received = typeof item.receivedAt === "string" ? item.receivedAt.trim() : "";
-    if (received)
-        return received;
-    return "";
-}
-/** The disposition reported for an older pending run of the same job. */
-export const SUPERSEDED_DISPOSITION = "a newer pending run of this job ran instead (the computer was asleep through several fires)";
-/**
- * Decide which pending job runs to actually run. `handled` maps jobId to the
- * newest run key this process has already picked up; it is UPDATED in place so
- * a later poll cannot resurrect an older run of a job whose newer run already
- * finished and was acked.
- *
- * Returns the message ids that must NOT be run — they are reported to the
- * cloud as `skipped-precondition` instead.
- */
-export function planJobRuns(items, handled) {
-    const superseded = new Set();
-    const byJob = new Map();
-    for (const item of items) {
-        const job = readJobRun(item);
-        if (!job)
-            continue;
-        const list = byJob.get(job.jobId);
-        if (list)
-            list.push(item);
-        else
-            byJob.set(job.jobId, [item]);
-    }
-    for (const [jobId, runs] of byJob) {
-        let newest = handled.get(jobId) ?? "";
-        for (const run of runs) {
-            const key = jobRunOrderKey(run);
-            if (key > newest)
-                newest = key;
-        }
-        handled.set(jobId, newest);
-        let keptNewest = false;
-        for (const run of runs) {
-            if (jobRunOrderKey(run) === newest && !keptNewest) {
-                keptNewest = true;
-                continue;
-            }
-            superseded.add(run.messageId);
-        }
-    }
-    return { superseded };
-}
-/**
- * The most run output the cloud keeps (hq-pro-agents jobs/results.ts
- * `MAX_JOB_RUN_OUTPUT_BYTES`). The server bounds it itself; the client sends up
- * to the same bound rather than an arbitrary shorter cut, so a long report is
- * recorded in full wherever the cloud can hold it.
- */
-export const MAX_JOB_RUN_OUTPUT_BYTES = 64 * 1024;
-/** Cut `text` to at most `maxBytes` of UTF-8 without splitting a character. */
-export function jobRunOutput(text, maxBytes = MAX_JOB_RUN_OUTPUT_BYTES) {
-    const bytes = Buffer.from(text, "utf8");
-    if (bytes.byteLength <= maxBytes)
-        return text;
-    let end = maxBytes;
-    // Step back over UTF-8 continuation bytes (10xxxxxx) to a character boundary.
-    while (end > 0 && (bytes[end] & 0xc0) === 0x80)
-        end -= 1;
-    return bytes.subarray(0, end).toString("utf8");
-}
-/** A saved report body with the run's header taken back off, for the cloud's record. */
-export function stripJobHeader(body, header) {
-    return header && body.startsWith(header) ? body.slice(header.length) : body;
-}
-//# sourceMappingURL=job-run.js.map

package/dist/lib/bot/local-config.d.ts

@@ -1,61 +0,0 @@
-/**
- * `localConfig` — the non-secret shape of a bot's bot.json that the cloud
- * stores alongside the agent record, so a reinstall (or a second Mac) can
- * rebuild the same bot instead of re-creating it.
- *
- * The server treats it as opaque, caps it at 8 KB, and refuses any value that
- * carries a key named secret/token/password/creds (case-insensitive). The CLI
- * therefore builds it from an explicit allow-list of bot.json fields and
- * checks the result before it leaves this machine: a bot's machine credentials
- * live only in ~/.hq/bots/<name>/machine-creds.json and never travel here.
- */
-import { type BotConfig, type BotKind, type BotMemoryMode, type BotRuntimeId } from "./config.js";
-/**
- * Everything needed to rebuild a bot here, minus anything secret. Written on
- * create, returned by `GET /v1/agents/mine?local=1` and by the credential
- * re-issue route.
- */
-export interface BotLocalConfig {
-    v: 1;
-    runtime?: BotRuntimeId;
-    /** "scaffold" (its own personal/workers/<name>) or "worker" (an HQ worker). */
-    workerSource?: "scaffold" | "worker";
-    workerId?: string;
-    companySlug?: string;
-    model?: string;
-    effort?: string;
-    kind?: BotKind;
-    /** Company bots: the company slugs it is a member of. */
-    companies?: string[];
-    autoApprove?: boolean;
-    /** Only the memory *kind* travels — never an absolute path from another Mac. */
-    memory?: BotMemoryMode;
-    displayName?: string;
-    intro?: string;
-    kickoff?: string;
-}
-/** Walks a value and throws when any key looks like it could carry a secret. */
-export declare function assertNoSecretKeys(value: unknown, path?: string): void;
-/** The bot.json fields a localConfig is built from — nothing else is read. */
-export type BotLocalConfigSource = Pick<BotConfig, "runtime" | "workerSource" | "workerId" | "companySlug" | "model" | "effort" | "kind" | "companies" | "autoApprove" | "memoryDir" | "displayName" | "intro" | "kickoff">;
-/**
- * The non-secret settings of a bot, for the cloud to keep. Absolute paths
- * (hqRoot, memoryDir, workerDir) are deliberately left out: they belong to the
- * machine the bot was created on, and a restore rebuilds them locally.
- */
-export declare function buildBotLocalConfig(config: BotLocalConfigSource): BotLocalConfig;
-/**
- * Tolerant read of whatever the server handed back: an older bot has no
- * localConfig at all, and a field HQ no longer understands is dropped rather
- * than losing the bot. Returns null when nothing usable was stored.
- */
-export declare function parseBotLocalConfig(value: unknown): BotLocalConfig | null;
-/** What a restore falls back to for a bot created before localConfig existed. */
-export declare const BOT_RESTORE_DEFAULTS: {
-    runtime: BotRuntimeId;
-    memory: BotMemoryMode;
-    kind: BotKind;
-};
-/** Human summary of the settings a restore is about to apply. */
-export declare function describeBotLocalConfig(local: BotLocalConfig | null): string;
-//# sourceMappingURL=local-config.d.ts.map