@indigoai-us/hq-cli 5.345.179 → 5.345.180

package/dist/hq-cloud-sync-runner/package.json

@@ -1 +1 @@
-{"name":"hq-cli-daemon-sync-runner","type":"module","version":"6.18.104","bundleSha256":"40c72e049db21ee4551fa737676d8022cd090149ede9e3c9e53a9fae3f28dadc","formatVersion":1}
+{"name":"hq-cli-daemon-sync-runner","type":"module","version":"6.18.105","bundleSha256":"f57aa12671cdfcf08ce39f11ce6885d6e52d5478f2ae77a75d38d79162194ce5","formatVersion":1}

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

@@ -1,6 +1,7 @@
 /**
  * bot.json — non-secret per-bot configuration (local-bots US-003/US-005).
  */
+import type { BotRuntimeAuthMap } from "./runtime-auth.js";
 export declare const BOT_RUNTIMES: readonly ["claude", "codex", "grok"];
 export type BotRuntimeId = (typeof BOT_RUNTIMES)[number];
 export declare const HQ_FLEET_RUNTIME_ENGINE_ID: "hq-fleet-runtime";
@@ -167,6 +168,13 @@ export interface BotConfig {
      * setup bots, which only need files and shell commands.
      */
     lean?: boolean;
+    /**
+     * Which model login each runtime uses (see runtime-auth.ts): unset = the
+     * owner's default sign-in; { mode: "own" } = the bot's own login under
+     * ~/.hq/bots/<name>/auth/<runtime>; { mode: "account", account } = a
+     * capacity account home. Names only, never a credential.
+     */
+    runtimeAuth?: BotRuntimeAuthMap;
 }
 export declare function readBotConfig(dir: string): BotConfig | null;
 export declare function writeBotConfig(dir: string, config: BotConfig): void;

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

@@ -133,7 +133,7 @@ export interface FleetLocalRemovalResult {
     credentialsRemoved: number;
 }
 export declare const HQ_FLEET_LOCAL_RELEASE: FleetLocalReleasePin;
-export declare const HQ_FLEET_LOCAL_PUBLIC_KEY = "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAbYvc1pwOmiCUPJv8yIa3E9RXfniFA84nH2+ROmLMGZU=\n-----END PUBLIC KEY-----\n";
+export declare const HQ_FLEET_LOCAL_PUBLIC_KEY = "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEARXr2I8RNcw2c0Ep77XkYGwylresXBFn8dm9pxN2Zq/U=\n-----END PUBLIC KEY-----\n";
 export declare function fleetHome(home?: string, env?: NodeJS.ProcessEnv): string;
 export declare function verifyFleetLocalRelease(files: FleetLocalReleaseFiles, release?: FleetLocalReleasePin, publicKey?: string): void;
 export declare function resolveFleetReleaseToken(env?: NodeJS.ProcessEnv): string;

package/dist/lib/bot/fleet-local.js

@@ -4,6 +4,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { HQ_FLEET_RUNTIME_ENGINE_ID, } from "./config.js";
+import { withBotLock } from "./lock.js";
 import { ensureFleetPython, fleetUvEnv } from "./fleet-python.js";
 import { ensureCognitoToken } from "../../utils/cognito-session.js";
 import { vaultApiFetch } from "../../utils/vault-api.js";
@@ -35,18 +36,18 @@ export function fleetProviderNeedsSignIn(provider) {
 }
 export const HQ_FLEET_LOCAL_RELEASE = {
     repository: "indigoai-us/hq-fleet-local",
-    tag: "v0.4.13",
-    version: "0.4.13",
-    artifact: "hq-fleet-local-0.4.13.zip",
-    artifactSha256: "81b129ac129578240af9091b06ae190f47f6be38ff933b35ae5459d5b78c72df",
+    tag: "v0.4.14",
+    version: "0.4.14",
+    artifact: "hq-fleet-local-0.4.14.zip",
+    artifactSha256: "9ff6ad4f7235988468e1913008c5650f5d064210078d6d20c407b17120310f47",
     runtimeArtifact: "hq-fleet-runtime-abccac13bd9e.tar",
     runtimeArtifactSha256: "29bcfe718ad7fbd3636afd00623772f2a25bc84c4f6f10d8d57f38e549d528d5",
-    manifestSha256: "42654f91264099ce173ce3a9f42e207f566e1412ea4b550dc21775d764327bbb",
-    signatureSha256: "93cf9b0a94d75c532454243e3391e421e2743f59f8e65989a5a56ec9152e2fa4",
+    manifestSha256: "88e71a733a5f57089764cbf9947fb88025c2263c5f3d62a2c6f5ab3635538871",
+    signatureSha256: "b892b54d6fcb2aaca86d049d7662fe5549a250d81877d6c529288e79ae1565d9",
     runtimeCommit: "abccac13bd9ea593b24c8cd9c0ba28d5c6050cc9",
 };
 export const HQ_FLEET_LOCAL_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
-MCowBQYDK2VwAyEAbYvc1pwOmiCUPJv8yIa3E9RXfniFA84nH2+ROmLMGZU=
+MCowBQYDK2VwAyEARXr2I8RNcw2c0Ep77XkYGwylresXBFn8dm9pxN2Zq/U=
 -----END PUBLIC KEY-----
 `;
 function digest(value) {
@@ -162,7 +163,7 @@ function trustedReleaseLink(url) {
         return false;
     }
 }
-async function downloadFleetLocalReleaseFromHq(release, fetcher, links) {
+async function downloadFleetLocalReleaseFromHq(release, fetcher, links, cachedRuntime) {
     const get = async (name, timeoutMs) => {
         const url = links.get(name);
         if (!url)
@@ -178,7 +179,7 @@ async function downloadFleetLocalReleaseFromHq(release, fetcher, links) {
     };
     const [archive, runtimeArchive, manifest, signature] = await Promise.all([
         get(release.artifact, FLEET_LOCAL_ARCHIVE_DOWNLOAD_TIMEOUT_MS),
-        get(release.runtimeArtifact, FLEET_LOCAL_RUNTIME_DOWNLOAD_TIMEOUT_MS),
+        cachedRuntime ?? get(release.runtimeArtifact, FLEET_LOCAL_RUNTIME_DOWNLOAD_TIMEOUT_MS),
         get("release-manifest.json", FLEET_LOCAL_METADATA_DOWNLOAD_TIMEOUT_MS),
         get("release-manifest.sig", FLEET_LOCAL_METADATA_DOWNLOAD_TIMEOUT_MS),
     ]);
@@ -193,7 +194,7 @@ async function responseBytes(response, label) {
 export const FLEET_LOCAL_METADATA_DOWNLOAD_TIMEOUT_MS = 30_000;
 export const FLEET_LOCAL_ARCHIVE_DOWNLOAD_TIMEOUT_MS = 5 * 60_000;
 export const FLEET_LOCAL_RUNTIME_DOWNLOAD_TIMEOUT_MS = 20 * 60_000;
-async function downloadFleetLocalRelease(release, fetcher, token) {
+async function downloadFleetLocalRelease(release, fetcher, token, cachedRuntime) {
     const headers = {
         Accept: "application/vnd.github+json",
         Authorization: `Bearer ${token}`,
@@ -223,7 +224,7 @@ async function downloadFleetLocalRelease(release, fetcher, token) {
     };
     const [archive, runtimeArchive, manifest, signature] = await Promise.all([
         get(release.artifact, FLEET_LOCAL_ARCHIVE_DOWNLOAD_TIMEOUT_MS),
-        get(release.runtimeArtifact, FLEET_LOCAL_RUNTIME_DOWNLOAD_TIMEOUT_MS),
+        cachedRuntime ?? get(release.runtimeArtifact, FLEET_LOCAL_RUNTIME_DOWNLOAD_TIMEOUT_MS),
         get("release-manifest.json", FLEET_LOCAL_METADATA_DOWNLOAD_TIMEOUT_MS),
         get("release-manifest.sig", FLEET_LOCAL_METADATA_DOWNLOAD_TIMEOUT_MS),
     ]);
@@ -274,6 +275,24 @@ function installFiles(target, files, release, publicKey) {
             fs.rmSync(staging, { recursive: true, force: true });
     }
 }
+function cachedRuntimeArchive(root, release) {
+    const distributions = path.join(root, "distributions", "hq-fleet-local");
+    if (!fs.existsSync(distributions))
+        return null;
+    for (const entry of fs.readdirSync(distributions, { withFileTypes: true })) {
+        if (!entry.isDirectory() || entry.name.startsWith("."))
+            continue;
+        const directory = path.join(distributions, entry.name);
+        for (const file of fs.readdirSync(directory, { withFileTypes: true })) {
+            if (!file.isFile() || !file.name.startsWith("hq-fleet-runtime-") || !file.name.endsWith(".tar"))
+                continue;
+            const bytes = fs.readFileSync(path.join(directory, file.name));
+            if (digest(bytes) === release.runtimeArtifactSha256)
+                return bytes;
+        }
+    }
+    return null;
+}
 export async function installPinnedFleetLocalDistribution(deps = {}) {
     const release = deps.release ?? HQ_FLEET_LOCAL_RELEASE;
     const publicKey = deps.publicKey ?? HQ_FLEET_LOCAL_PUBLIC_KEY;
@@ -286,9 +305,10 @@ export async function installPinnedFleetLocalDistribution(deps = {}) {
     else {
         const fetcher = deps.fetch ?? fetch;
         const links = await (deps.hqReleaseLinks ?? fetchHqFleetReleaseLinks)(release);
+        const cachedRuntime = cachedRuntimeArchive(root, release);
         const files = links
-            ? await downloadFleetLocalReleaseFromHq(release, fetcher, links)
-            : await downloadFleetLocalRelease(release, fetcher, (deps.token ?? resolveFleetReleaseToken)());
+            ? await downloadFleetLocalReleaseFromHq(release, fetcher, links, cachedRuntime)
+            : await downloadFleetLocalRelease(release, fetcher, (deps.token ?? resolveFleetReleaseToken)(), cachedRuntime);
         verifyFleetLocalRelease(files, release, publicKey);
         installFiles(dir, files, release, publicKey);
     }
@@ -744,21 +764,30 @@ export function importFleetLocalMachineCredential(agentUid, machineCredentials,
     ], { input: machineValue, stdio: ["pipe", "ignore", "pipe"] }, "machine credential import");
     fs.rmSync(machineCredentials, { force: true });
 }
-export async function bootstrapFleetLocalBot(input, deps = {}) {
-    const run = deps.run ?? execFileSync;
-    const platform = deps.platform ?? process.platform;
-    const root = deps.fleetHome ?? fleetHome();
-    const python = deps.python ?? await ensureFleetPython({ fleetHome: root, platform, run });
-    const profileDir = profileRoot(input.agentUid, root);
-    const sources = path.join(profileDir, "sources");
-    const distributionSource = path.join(sources, "distribution");
-    const runtimeSource = path.join(sources, "runtime");
-    const runtimeDir = path.join(profileDir, "runtime");
-    const marker = path.join(profileDir, "bootstrap.json");
-    fs.mkdirSync(profileDir, { recursive: true, mode: 0o700 });
-    if (!fs.existsSync(marker)) {
-        fs.rmSync(sources, { recursive: true, force: true });
-        fs.rmSync(runtimeDir, { recursive: true, force: true });
+async function installSharedFleetRuntime(installation, root, python, platform, run) {
+    const identity = digest(Buffer.from(JSON.stringify({
+        version: installation.release.version,
+        distribution: installation.release.artifactSha256,
+        runtime: installation.release.runtimeArtifactSha256,
+        python: python.python,
+        platform,
+        extras: ["mcp", "anthropic"],
+    })));
+    const shared = path.join(root, "runtimes", identity);
+    return withBotLock(identity, async () => {
+        const marker = path.join(shared, "ready.json");
+        const sources = path.join(shared, "sources");
+        const distributionSource = path.join(sources, "distribution");
+        const runtimeSource = path.join(sources, "runtime");
+        const runtimeDir = path.join(shared, "runtime");
+        const executables = ["python", "hq-fleet", "hq-fleet-local"];
+        if (fs.existsSync(marker)) {
+            if (!executables.every((name) => fs.existsSync(venvExecutable(runtimeDir, name, platform)))) {
+                throw expectedError("The shared HQ Fleet Runtime is incomplete. Reinstall it before creating another bot.");
+            }
+            return shared;
+        }
+        fs.rmSync(shared, { recursive: true, force: true });
         fs.mkdirSync(distributionSource, { recursive: true, mode: 0o700 });
         fs.mkdirSync(runtimeSource, { recursive: true, mode: 0o700 });
         const uvEnv = fleetUvEnv(python.pythonDir);
@@ -766,14 +795,14 @@ export async function bootstrapFleetLocalBot(input, deps = {}) {
             "-m",
             "zipfile",
             "-e",
-            input.installation.archive,
+            installation.archive,
             distributionSource,
         ], { stdio: "ignore" }, "distribution extraction");
         checkedRun(run, python.python, [
             "-m",
             "tarfile",
             "-e",
-            input.installation.runtimeArchive,
+            installation.runtimeArchive,
             runtimeSource,
         ], { stdio: "ignore" }, "runtime extraction");
         checkedRun(run, python.uv, [
@@ -794,6 +823,29 @@ export async function bootstrapFleetLocalBot(input, deps = {}) {
             `${runtimeSource}[mcp,anthropic]`,
             distributionSource,
         ], { stdio: ["ignore", 2, 2], env: uvEnv }, "package installation");
+        if (!executables.every((name) => fs.existsSync(venvExecutable(runtimeDir, name, platform)))) {
+            throw expectedError("HQ Fleet Local installed without its runtime executables.");
+        }
+        fs.writeFileSync(marker, `${JSON.stringify({ schemaVersion: 1, engine: installation.engine })}\n`, { mode: 0o600 });
+        return shared;
+    }, { root: path.join(root, "runtimes"), command: "HQ Fleet Runtime installation", waitMs: 20 * 60_000, staleMs: 2 * 60 * 60_000 });
+}
+export async function bootstrapFleetLocalBot(input, deps = {}) {
+    const run = deps.run ?? execFileSync;
+    const platform = deps.platform ?? process.platform;
+    const root = deps.fleetHome ?? fleetHome();
+    const python = deps.python ?? await ensureFleetPython({ fleetHome: root, platform, run });
+    const profileDir = profileRoot(input.agentUid, root);
+    const runtimeDir = path.join(profileDir, "runtime");
+    const marker = path.join(profileDir, "bootstrap.json");
+    fs.mkdirSync(profileDir, { recursive: true, mode: 0o700 });
+    if (!fs.existsSync(marker)) {
+        const shared = await installSharedFleetRuntime(input.installation, root, python, platform, run);
+        for (const name of ["sources", "runtime"]) {
+            const target = path.join(profileDir, name);
+            fs.rmSync(target, { recursive: true, force: true });
+            fs.symlinkSync(path.join(shared, name), target, platform === "win32" ? "junction" : "dir");
+        }
         fs.writeFileSync(marker, `${JSON.stringify({ schemaVersion: 1, engine: input.installation.engine }, null, 2)}\n`, { mode: 0o600 });
     }
     const { systemPrompt, ...profileInput } = input;

package/dist/lib/bot/run.js

@@ -46,6 +46,7 @@
  *
  * Everything with a side effect is injectable so the loop is unit-testable.
  */
+import { botAuthEnv, describeBotAuth, formatBotAuth } from "./runtime-auth.js";
 import { ownerContextBlock } from "./owner-context.js";
 import { randomUUID } from "node:crypto";
 import { hasPromotionHold } from "./promotion-hold.js";
@@ -558,6 +559,12 @@ export async function runBot(deps) {
     setStatus({ ...fallback(), pid, state: "starting", canDrainForPromotion: false, runtimeSignIn: null, cliVersion });
     log("info", `starting ${config.name} on hq-cli ${cliVersion} (${config.runtime}, ${kind} bot${companies.length ? ` of ${companies.join(", ")}` : ""}) as ${config.agentUid} for ${config.ownerUid}`);
     log("info", `${runtime.id} binary: ${describeRuntimeBinary(runtime, turnEnv(process.env, kind, config.agentUid, companySlug), turnCwd)}`);
+    {
+        const login = describeBotAuth(dir, config);
+        log("info", `${runtime.id} login: ${formatBotAuth(login, config.name)}`);
+        if (login.login === "own" && !login.present)
+            setStatus({ lastError: `own ${runtime.id} login missing: run hq bot login ${config.name} --runtime ${runtime.id}` });
+    }
     deps.cliUpdate?.startup(log);
     try {
         const record = await api.getAgent(config.agentUid);
@@ -1048,7 +1055,15 @@ export async function runBot(deps) {
             // resets). Claude gets the full hook set via its payload session id;
             // Codex/Grok only see HQ_SESSION_ID.
             const sid = session?.sessionId ?? randomUUID();
-            const env = withOsUser(turnEnv(process.env, kind, config.agentUid, companySlug));
+            let env;
+            try {
+                // The bot's own login or account, when set. A missing one fails the
+                // turn loudly (status + reply); it never falls back to the owner's login.
+                env = withOsUser(botAuthEnv(dir, { ...live, runtime: config.runtime }, turnEnv(process.env, kind, config.agentUid, companySlug)));
+            }
+            catch (err) {
+                throw new CompanyBindingError(`I can't answer yet: ${err instanceof Error ? err.message : String(err)} I did not use anyone else's login; this work is still pending.`);
+            }
             let bind = { env };
             if (companySlug) {
                 try {
@@ -1941,7 +1956,29 @@ export async function runBot(deps) {
             // The job's stored company is checked against the bot's current config
             // (read fresh from disk) every time it fires. A company the bot no longer
             // serves is never synced: the run is skipped and the job removed.
-            const currentCompany = currentHotSignalSyncCompany(readBotConfig(dir) ?? config);
+            const freshConfig = readBotConfig(dir);
+            if (!freshConfig) {
+                // bot.json is missing or unreadable, so which company the bot serves is
+                // unknown. Skip this run without writing anything; the job stays for the
+                // next fire.
+                const text = `Skipped the hot-channel sync for ${syncCompany}: the bot's config (bot.json) could not be read, so nothing was written. The job will try again at its next run.`;
+                markProcessed(dir, id, now().toISOString());
+                try {
+                    await sendToPerson(text);
+                }
+                catch (err) {
+                    log("warn", `report for run ${id} of job ${jobId} was not delivered: ${err instanceof Error ? err.message : String(err)}`);
+                }
+                await completeJobRun(jobId, id, { status: "skipped-precondition", output: jobRunOutput(text) });
+                markReported("skipped-precondition");
+                await api.ackInbox(config.agentUid, id);
+                clearInflight(dir, id);
+                attempts.delete(id);
+                setStatus({ lastActivityAt: now().toISOString() });
+                log("warn", `hot-signal-sync job ${jobId} run ${id} skipped: bot.json missing or unreadable`);
+                return;
+            }
+            const currentCompany = currentHotSignalSyncCompany(freshConfig);
             if (currentCompany !== syncCompany) {
                 let removedNote = "";
                 try {

package/dist/lib/bot/runtime-auth.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Which model login a local bot uses, per runtime.
+ *
+ * - default: the owner's own sign-in for that runtime (no config dir set).
+ * - own:     a sign-in that belongs to the bot alone, kept in
+ *            ~/.hq/bots/<name>/auth/<runtime>/ (CLAUDE_CONFIG_DIR / CODEX_HOME).
+ * - account: an existing `hq capacity` / lanes account home, by id.
+ *
+ * Also the session set-aside a runtime switch needs: session files belong to
+ * one runtime, so they move to a backup folder and the new runtime starts
+ * fresh. DM history, memory and the cloud identity are never touched.
+ *
+ * This module never reads, prints, copies or hashes a credential. It only
+ * names directories and checks whether they exist.
+ */
+import type { BotConfig, BotRuntimeId } from "./config.js";
+import type { LanesConfig } from "../lanes/types.js";
+/** Runtimes `hq bot login` can sign in for (each has a config-dir variable and a login command). */
+export declare const BOT_LOGIN_RUNTIMES: readonly ["claude", "codex"];
+export type BotLoginRuntime = (typeof BOT_LOGIN_RUNTIMES)[number];
+export declare function isBotLoginRuntime(value: unknown): value is BotLoginRuntime;
+export type BotRuntimeAuth = {
+    mode: "own";
+} | {
+    mode: "account";
+    account: string;
+};
+export type BotRuntimeAuthMap = Partial<Record<BotRuntimeId, BotRuntimeAuth>>;
+export declare const BOT_AUTH_DIRNAME = "auth";
+export declare const BOT_SESSION_ARCHIVE_DIRNAME = "session-archive";
+export declare const VENDOR_LOGIN: Record<BotLoginRuntime, {
+    command: string;
+    args: string[];
+}>;
+export declare const VENDOR_LOGOUT: Record<BotLoginRuntime, {
+    command: string;
+    args: string[];
+}>;
+/** The bot's own config home for a runtime: <botDir>/auth/<runtime>. */
+export declare function botOwnAuthHome(dir: string, runtime: BotRuntimeId): string;
+/** The saved login choice for a runtime, or null for the owner's default. Tolerant of junk on read. */
+export declare function botRuntimeAuth(config: Pick<BotConfig, "runtime" | "runtimeAuth">, runtime?: BotRuntimeId): BotRuntimeAuth | null;
+/** A copy of the map with `runtime` set to `auth` (null = back to the owner's default). */
+export declare function withRuntimeAuth(map: BotRuntimeAuthMap | undefined, runtime: BotRuntimeId, auth: BotRuntimeAuth | null): BotRuntimeAuthMap | undefined;
+export interface AccountLookupDeps {
+    loadConfig?: (hqRoot: string) => LanesConfig;
+    existsSync?: (p: string) => boolean;
+}
+/** The home directory of a capacity account for a runtime. Throws an expected error when it is not usable. */
+export declare function capacityAccountHome(hqRoot: string, runtime: BotRuntimeId, accountId: string, deps?: AccountLookupDeps): string;
+/**
+ * The environment a bot's model turn runs with: `base` with the runtime's
+ * config-dir variable pointed at the bot's chosen login. A missing own login
+ * or a gone account is an error: falling back to the owner's login is the
+ * thing this setting exists to prevent.
+ */
+export declare function botAuthEnv(dir: string, config: Pick<BotConfig, "name" | "runtime" | "runtimeAuth" | "hqRoot">, base: NodeJS.ProcessEnv, deps?: AccountLookupDeps): NodeJS.ProcessEnv;
+export interface BotAuthDescription {
+    runtime: BotRuntimeId;
+    login: "default" | "own" | "account" | "invalid";
+    account?: string;
+    /** The config-dir variable the bot's turns set (never its value's contents). */
+    envVar?: string;
+    /** Own login: whether its folder exists. Never a token check. */
+    present?: boolean;
+}
+export declare function describeBotAuth(dir: string, config: Pick<BotConfig, "runtime" | "runtimeAuth">, existsSync?: (p: string) => boolean): BotAuthDescription;
+export declare function formatBotAuth(d: BotAuthDescription, name: string): string;
+export type SpawnInteractive = (command: string, args: string[], env: NodeJS.ProcessEnv) => {
+    status: number | null;
+    error?: Error;
+};
+/** Runs the vendor's own login/logout with the terminal attached. Its output goes to the terminal only, never to HQ's log. */
+export declare const defaultSpawnInteractive: SpawnInteractive;
+/** Logout runs quietly: nothing it prints is shown or logged. */
+export declare const defaultSpawnQuiet: SpawnInteractive;
+/**
+ * Sign a bot in with its own login for `runtime`. The vendor CLI writes the
+ * credential into the bot's home (or, for Claude on macOS, a keychain item
+ * keyed by that home). HQ never sees it.
+ */
+export declare function signInBotRuntime(dir: string, runtime: BotLoginRuntime, deps?: {
+    spawn?: SpawnInteractive;
+    quietSpawn?: SpawnInteractive;
+    env?: NodeJS.ProcessEnv;
+}): {
+    home: string;
+    created: boolean;
+};
+/**
+ * Sign the bot's own login out and delete its home. The vendor logout runs
+ * first so a Claude keychain item keyed by the home is removed too.
+ */
+export declare function signOutBotRuntime(dir: string, runtime: BotLoginRuntime, deps?: {
+    spawn?: SpawnInteractive;
+    env?: NodeJS.ProcessEnv;
+}): {
+    removed: boolean;
+    vendorLogout: "ok" | "failed" | "skipped";
+};
+/** True for the model-session files of a bot dir (owner DM, other DMs, rooms, jobs). */
+export declare function isBotSessionFile(name: string): boolean;
+export interface SessionSetAside {
+    archiveDir: string;
+    moved: string[];
+}
+/**
+ * Before a runtime switch: back up bot.json and move every session file into
+ * <dir>/session-archive/<stamp>-<oldRuntime>/, so the new runtime starts
+ * fresh and the old sessions can be put back.
+ */
+export declare function setAsideBotSessions(dir: string, oldRuntime: BotRuntimeId, now?: Date): SessionSetAside;
+/**
+ * Undo setAsideBotSessions: the moved session files go back. bot.json is not
+ * overwritten (the bot may have written fields since); the caller patches the
+ * settings it changed back. The backup folder stays for manual recovery.
+ */
+export declare function restoreBotSessions(dir: string, aside: SessionSetAside): void;
+//# sourceMappingURL=runtime-auth.d.ts.map