@indigoai-us/hq-cli 5.116.0 → 5.117.0

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

@@ -6,6 +6,7 @@
  * existing Cognito machinery. `fetch` is injectable for tests.
  */
 import { vaultApiFetch } from "../../utils/vault-api.js";
+import { type BotLocalConfig } from "./local-config.js";
 export type TokenSupplier = () => Promise<string>;
 /**
  * One agent-inbox item. DMs carry the base fields; room (channel / group chat)
@@ -55,6 +56,31 @@ export interface AgentRecord {
         } | null;
     };
 }
+/**
+ * One of the caller's own local bots, as `GET /v1/agents/mine?local=1` lists
+ * them — enough to tell a bot that is missing from this machine from one that
+ * is already here, and to rebuild it.
+ */
+export interface MyLocalBot {
+    agentUid: string;
+    slug?: string;
+    name?: string;
+    botKind?: "personal" | "company";
+    computeMode?: string;
+    ownerUid?: string;
+    online?: boolean;
+    lastHeartbeatAt?: string | null;
+    localConfig?: unknown;
+}
+/** What the credential re-issue route hands back (a rotated machine secret). */
+export interface ReissuedBotCredentials {
+    agent: AgentRecord;
+    identity: {
+        cognitoUsername: string;
+        secret: string;
+    };
+    localConfig: unknown;
+}
 export declare class BotApiError extends Error {
     readonly status: number;
     readonly path: string;
@@ -194,6 +220,12 @@ export declare class BotApi {
         /** Company bots: the company it acts for, plus any further companies. The server makes it a member of each. */
         companyUid?: string;
         companyMemberships?: string[];
+        /**
+         * The bot's non-secret settings, kept by the cloud so a reinstall can
+         * rebuild it. Checked here too: the server 400s on any key that looks
+         * like a credential.
+         */
+        localConfig?: BotLocalConfig;
     }): Promise<{
         agent: AgentRecord;
         identity: {
@@ -201,6 +233,25 @@ export declare class BotApi {
             secret: string;
         };
     }>;
+    /**
+     * POST /v1/agents/{uid}/credentials — owner-only, local bots only: mint a
+     * fresh machine secret for a bot this account already owns, so it can come
+     * back after a reinstall or move to another Mac.
+     *
+     * This ROTATES the secret: whatever machine held the bot before stops being
+     * able to authenticate as it (one machine runs a local bot at a time).
+     */
+    reissueCredentials(agentUid: string, input?: {
+        machineId?: string;
+        reason?: "reinstall" | "move";
+    }): Promise<ReissuedBotCredentials>;
+    /**
+     * GET /v1/agents/mine — the caller's own agents; `local: true` narrows it to
+     * the local bots they own in any company, which is what a restore works from.
+     */
+    listMine(opts?: {
+        local?: boolean;
+    }): Promise<MyLocalBot[]>;
     /** DELETE /v1/agents/{uid} — owner tears the identity down. */
     deleteLocalBot(agentUid: string): Promise<{
         uid: string;

package/dist/lib/bot/api.js

@@ -6,6 +6,7 @@
  * existing Cognito machinery. `fetch` is injectable for tests.
  */
 import { vaultApiFetch } from "../../utils/vault-api.js";
+import { assertNoSecretKeys } from "./local-config.js";
 export class BotApiError extends Error {
     status;
     path;
@@ -186,6 +187,8 @@ export class BotApi {
      * "company" is evaluated as itself through its memberships). Default personal.
      */
     async createLocalBot(input) {
+        if (input.localConfig)
+            assertNoSecretKeys(input.localConfig);
         const { body } = await this.call("/v1/agents", {
             method: "POST",
             body: {
@@ -196,10 +199,39 @@ export class BotApi {
                 ...(input.companyUid ? { companyUid: input.companyUid } : {}),
                 ...(input.companyMemberships?.length ? { companyMemberships: input.companyMemberships } : {}),
                 role: "local-bot",
+                ...(input.localConfig ? { localConfig: input.localConfig } : {}),
             },
         });
         return body;
     }
+    /**
+     * POST /v1/agents/{uid}/credentials — owner-only, local bots only: mint a
+     * fresh machine secret for a bot this account already owns, so it can come
+     * back after a reinstall or move to another Mac.
+     *
+     * This ROTATES the secret: whatever machine held the bot before stops being
+     * able to authenticate as it (one machine runs a local bot at a time).
+     */
+    async reissueCredentials(agentUid, input = {}) {
+        const { body } = await this.call(`/v1/agents/${encodeURIComponent(agentUid)}/credentials`, {
+            method: "POST",
+            body: {
+                ...(input.machineId ? { machineId: input.machineId } : {}),
+                ...(input.reason ? { reason: input.reason } : {}),
+            },
+        }, [200]);
+        return { agent: body.agent, identity: body.identity, localConfig: body.localConfig ?? null };
+    }
+    /**
+     * GET /v1/agents/mine — the caller's own agents; `local: true` narrows it to
+     * the local bots they own in any company, which is what a restore works from.
+     */
+    async listMine(opts = {}) {
+        const { body } = await this.call("/v1/agents/mine", {
+            ...(opts.local ? { query: { local: "1" } } : {}),
+        });
+        return Array.isArray(body.agents) ? body.agents : [];
+    }
     /** DELETE /v1/agents/{uid} — owner tears the identity down. */
     async deleteLocalBot(agentUid) {
         const { body } = await this.call(`/v1/agents/${encodeURIComponent(agentUid)}`, { method: "DELETE" });

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

@@ -63,6 +63,23 @@ export interface BotDaemonDeps {
     fsImpl?: Pick<typeof fs, "existsSync" | "writeFileSync" | "mkdirSync" | "unlinkSync">;
     /** Blocking sleep, injectable for tests. */
     sleepMs?: (ms: number) => void;
+    /**
+     * How `uninstallBotDaemon` issues its final `launchctl bootout`.
+     *
+     * "inline" (default) runs it in this process, which is right when something
+     * other than the job itself is doing the removing. "detached" hands it to a
+     * short-lived grandchild in its own session instead, which is the only way
+     * that works when the caller IS the launchd job being booted out: `bootout`
+     * kills the job, so an inline call never returns.
+     */
+    bootout?: "inline" | "detached";
+    /** Injectable detached spawn, so tests never reach the real service manager. */
+    spawnDetached?: (command: string, args: string[]) => void;
+    /**
+     * Called once the removal is durable (plist gone) but before the bootout —
+     * the last moment a self-booting-out caller is still alive to say anything.
+     */
+    announce?: (result: BotDaemonResult) => void;
 }
 /** Write the unit and load it (RunAtLoad starts the bot immediately). */
 export declare function installBotDaemon(p: BotDaemonPaths, deps?: BotDaemonDeps): BotDaemonResult;

package/dist/lib/bot/daemon.js

@@ -12,6 +12,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { spawn } from "node:child_process";
 import { resolveHqBinary, resolveNodeBinary } from "../mesh/live/daemon/install.js";
 import { botLogPath, launchdLabel } from "./paths.js";
 export function detectBotPlatform(platform = process.platform) {
@@ -142,6 +143,31 @@ export function launchdDomain(uid = os.userInfo().uid) {
 function blockingSleep(ms) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
+function shQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+/** Detached `launchctl bootout` that outlives the process asking for it. */
+function defaultSpawnDetached(command, args) {
+    const child = spawn(command, args, { detached: true, stdio: "ignore" });
+    child.unref();
+}
+/**
+ * Take the job out of the launchd session.
+ *
+ * When `deps.bootout` is "detached" the call is handed to a new session
+ * (`sh -c 'sleep 1; exec launchctl bootout …'`) so the caller can be the job
+ * being removed: the caller exits 0 first — which KeepAlive{SuccessfulExit:
+ * false} leaves alone — and the grandchild, in a session launchd is not
+ * tearing down, finishes the job a second later.
+ */
+function bootoutLaunchd(p, deps) {
+    const target = `${launchdDomain(deps.uid)}/${p.label}`;
+    if (deps.bootout === "detached") {
+        (deps.spawnDetached ?? defaultSpawnDetached)("/bin/sh", ["-c", `sleep 1; exec launchctl bootout ${shQuote(target)}`]);
+        return;
+    }
+    deps.launchctl?.(["bootout", target]);
+}
 /**
  * `launchctl bootout` returns before the job is actually gone; a `bootstrap`
  * issued right away fails ("service already loaded" / EIO) and the old job
@@ -174,6 +200,11 @@ export function installBotDaemon(p, deps = {}) {
     io.mkdirSync(path.dirname(p.logPath), { recursive: true, mode: 0o700 });
     if (platform === "darwin") {
         io.mkdirSync(path.dirname(p.plistPath), { recursive: true });
+        // Replace rather than overwrite, so re-adopting a bot over the stale plist
+        // a wiped ~/.hq left behind lands a fresh file at 0600 (writeFileSync
+        // keeps the mode an existing file already has).
+        if (io.existsSync(p.plistPath))
+            io.unlinkSync(p.plistPath);
         io.writeFileSync(p.plistPath, renderBotLaunchdPlist(p), { mode: 0o600 });
         let loaded = false;
         if (deps.launchctl) {
@@ -224,11 +255,16 @@ export function uninstallBotDaemon(p, deps = {}) {
     const platform = deps.platform ?? detectBotPlatform();
     const io = deps.fsImpl ?? fs;
     if (platform === "darwin") {
-        deps.launchctl?.(["bootout", `${launchdDomain(deps.uid)}/${p.label}`]);
+        // Order is load-bearing. `bootout` used to run first, which is fine from a
+        // shell and fatal from inside the job: when the orphan self-heal is itself
+        // the launchd job, bootout kills it, so the unlink below and the log line
+        // the person reads never happened — on a real Mac the stale plist survived
+        // and RunAtLoad resurrected the orphan at every login. Remove the file
+        // first, say so, and boot out last (detached when the caller is the job).
         const existed = io.existsSync(p.plistPath);
         if (existed)
             io.unlinkSync(p.plistPath);
-        return {
+        const result = {
             platform,
             action: "uninstall",
             installed: false,
@@ -236,12 +272,15 @@ export function uninstallBotDaemon(p, deps = {}) {
             dest: p.plistPath,
             message: existed ? `Removed LaunchAgent ${p.label}` : `LaunchAgent ${p.label} was not installed`,
         };
+        deps.announce?.(result);
+        bootoutLaunchd(p, deps);
+        return result;
     }
     if (platform === "linux") {
         const existed = io.existsSync(p.systemdUnitPath);
         if (existed)
             io.unlinkSync(p.systemdUnitPath);
-        return {
+        const result = {
             platform,
             action: "uninstall",
             installed: false,
@@ -249,6 +288,8 @@ export function uninstallBotDaemon(p, deps = {}) {
             dest: p.systemdUnitPath,
             message: existed ? `Removed systemd unit for ${p.name}` : `No systemd unit for ${p.name}`,
         };
+        deps.announce?.(result);
+        return result;
     }
     return { platform, action: "uninstall", installed: false, loaded: false, message: "Nothing to uninstall on this platform" };
 }

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

@@ -13,4 +13,8 @@ export * from "./worker-source.js";
 export * from "./company-bind.js";
 export * from "./run.js";
 export * from "./runtime/index.js";
+export * from "./local-config.js";
+export * from "./self-heal.js";
+export * from "./runnable.js";
+export * from "./local-name.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/lib/bot/index.js

@@ -13,4 +13,8 @@ export * from "./worker-source.js";
 export * from "./company-bind.js";
 export * from "./run.js";
 export * from "./runtime/index.js";
+export * from "./local-config.js";
+export * from "./self-heal.js";
+export * from "./runnable.js";
+export * from "./local-name.js";
 //# sourceMappingURL=index.js.map

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

@@ -37,6 +37,20 @@ export interface InflightTurn {
      * restart posts this instead of "did not finish".
      */
     reply?: string;
+    /**
+     * The message to deliver, already cut to the body limit (split.ts). Recovery
+     * resends from `replyPartsDelivered` on, so a part the person has already
+     * read is never posted twice.
+     */
+    replyParts?: string[];
+    /** How many of `replyParts` actually reached the chat. */
+    replyPartsDelivered?: number;
+    /**
+     * Consecutive failed attempts to deliver this marker. A body the server will
+     * never accept must not be retried for ever, so the bot gives up after
+     * RECOVERY_ATTEMPT_LIMIT and says so once (run.ts).
+     */
+    recoveryFailures?: number;
 }
 export declare function botInflightPath(dir: string): string;
 /** Every turn that was in progress, oldest first. */

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

@@ -0,0 +1,70 @@
+/**
+ * `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";
+/** Same limit the server enforces on the stored value. */
+export declare const BOT_LOCAL_CONFIG_MAX_BYTES: number;
+/** Key names the server rejects outright (case-insensitive, substring). */
+export declare const BOT_LOCAL_CONFIG_FORBIDDEN_KEY_RE: RegExp;
+/**
+ * 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;
+    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" | "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;
+/** Exported so callers can present the accepted values without importing config.ts. */
+export declare const BOT_LOCAL_CONFIG_VALUES: {
+    readonly runtimes: readonly ["claude", "codex", "grok"];
+    readonly kinds: readonly ["personal", "company"];
+    readonly memoryModes: readonly ["synced", "local"];
+};
+//# sourceMappingURL=local-config.d.ts.map

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

@@ -0,0 +1,147 @@
+/**
+ * `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 { BOT_KINDS, BOT_MEMORY_MODES, BOT_RUNTIMES, botMemoryMode, effectiveBotCompanies, effectiveBotKind, isBotKind, isBotMemoryMode, isBotRuntimeId, } from "./config.js";
+/** Same limit the server enforces on the stored value. */
+export const BOT_LOCAL_CONFIG_MAX_BYTES = 8 * 1024;
+/** Key names the server rejects outright (case-insensitive, substring). */
+export const BOT_LOCAL_CONFIG_FORBIDDEN_KEY_RE = /secret|token|password|creds/i;
+/** Walks a value and throws when any key looks like it could carry a secret. */
+export function assertNoSecretKeys(value, path = "localConfig") {
+    if (Array.isArray(value)) {
+        value.forEach((item, i) => assertNoSecretKeys(item, `${path}[${i}]`));
+        return;
+    }
+    if (!value || typeof value !== "object")
+        return;
+    for (const [key, child] of Object.entries(value)) {
+        if (BOT_LOCAL_CONFIG_FORBIDDEN_KEY_RE.test(key)) {
+            throw Object.assign(new Error(`${path}.${key} looks like a credential; a bot's saved settings never carry one.`), {
+                expected: true,
+            });
+        }
+        assertNoSecretKeys(child, `${path}.${key}`);
+    }
+}
+/**
+ * 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 function buildBotLocalConfig(config) {
+    const kind = effectiveBotKind(config);
+    const companies = effectiveBotCompanies(config);
+    const local = {
+        v: 1,
+        runtime: config.runtime,
+        workerSource: config.workerSource ?? "scaffold",
+        ...(config.workerId ? { workerId: config.workerId } : {}),
+        ...(config.companySlug ? { companySlug: config.companySlug } : {}),
+        ...(config.model ? { model: config.model } : {}),
+        ...(config.effort ? { effort: config.effort } : {}),
+        kind,
+        ...(kind === "company" ? { companies } : {}),
+        ...(config.autoApprove === false ? { autoApprove: false } : {}),
+        memory: botMemoryMode(config),
+        ...(config.intro ? { intro: config.intro } : {}),
+        ...(config.kickoff ? { kickoff: config.kickoff } : {}),
+    };
+    assertNoSecretKeys(local);
+    if (Buffer.byteLength(JSON.stringify(local), "utf8") > BOT_LOCAL_CONFIG_MAX_BYTES) {
+        throw Object.assign(new Error("This bot's settings are too large to save in the cloud (over 8 KB)."), {
+            expected: true,
+        });
+    }
+    return local;
+}
+/**
+ * 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 function parseBotLocalConfig(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const raw = value;
+    const str = (key) => {
+        const v = raw[key];
+        return typeof v === "string" && v.trim() ? v.trim() : undefined;
+    };
+    const out = { v: 1 };
+    const runtime = str("runtime");
+    if (isBotRuntimeId(runtime))
+        out.runtime = runtime;
+    const workerSource = str("workerSource");
+    if (workerSource === "worker" || workerSource === "scaffold")
+        out.workerSource = workerSource;
+    const workerId = str("workerId");
+    if (workerId)
+        out.workerId = workerId;
+    const companySlug = str("companySlug");
+    if (companySlug)
+        out.companySlug = companySlug;
+    const model = str("model");
+    if (model)
+        out.model = model;
+    const effort = str("effort");
+    if (effort)
+        out.effort = effort;
+    const kind = str("kind");
+    if (isBotKind(kind))
+        out.kind = kind;
+    if (Array.isArray(raw.companies)) {
+        const companies = raw.companies.filter((c) => typeof c === "string" && c.trim().length > 0).map((c) => c.trim());
+        if (companies.length > 0)
+            out.companies = [...new Set(companies)];
+    }
+    if (raw.autoApprove === false)
+        out.autoApprove = false;
+    const memory = str("memory");
+    if (isBotMemoryMode(memory))
+        out.memory = memory;
+    const intro = str("intro");
+    if (intro)
+        out.intro = intro;
+    const kickoff = str("kickoff");
+    if (kickoff)
+        out.kickoff = kickoff;
+    // A record with nothing recognisable in it is the same as none at all.
+    return Object.keys(out).length > 1 ? out : null;
+}
+/** What a restore falls back to for a bot created before localConfig existed. */
+export const BOT_RESTORE_DEFAULTS = {
+    runtime: "claude",
+    memory: "synced",
+    kind: "personal",
+};
+/** Human summary of the settings a restore is about to apply. */
+export function describeBotLocalConfig(local) {
+    if (!local) {
+        return `defaults (${BOT_RESTORE_DEFAULTS.runtime}, ${BOT_RESTORE_DEFAULTS.memory} memory, ${BOT_RESTORE_DEFAULTS.kind})`;
+    }
+    const bits = [
+        local.runtime ?? BOT_RESTORE_DEFAULTS.runtime,
+        `${local.memory ?? BOT_RESTORE_DEFAULTS.memory} memory`,
+        local.kind ?? BOT_RESTORE_DEFAULTS.kind,
+    ];
+    if (local.workerId)
+        bits.push(`worker ${local.workerId}`);
+    if (local.model)
+        bits.push(local.model);
+    return bits.join(", ");
+}
+/** Exported so callers can present the accepted values without importing config.ts. */
+export const BOT_LOCAL_CONFIG_VALUES = {
+    runtimes: BOT_RUNTIMES,
+    kinds: BOT_KINDS,
+    memoryModes: BOT_MEMORY_MODES,
+};
+//# sourceMappingURL=local-config.js.map

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

@@ -0,0 +1,54 @@
+/**
+ * Which folder under ~/.hq/bots/ a cloud bot belongs to.
+ *
+ * HQ gives a bot's cloud record a slug carrying the owner's suffix: a bot
+ * created here as `qa-x` is `qa-x-rg13gzm4` in the cloud. Deriving the local
+ * name from the slug alone meant re-adopting that bot built a SECOND directory
+ * next to the first — `~/.hq/bots/qa-x-rg13gzm4/` beside `~/.hq/bots/qa-x/` —
+ * with a second LaunchAgent label and a second memory folder, while the
+ * original kept live machine credentials that nothing would ever clean up and
+ * `hq bot rm qa-x` could no longer reach.
+ *
+ * One bot, one directory. So:
+ *
+ *   1. If any directory here already carries this bot's agent uid — in its
+ *      bot.json, or (when a wipe took the config but left the credentials) in
+ *      its machine-creds.json — that IS the bot's directory. Reuse it and
+ *      repair in place.
+ *   2. Otherwise strip the owner's suffix off the slug, so a bot created here
+ *      comes back under the name it was created with.
+ *   3. Unless that name is already taken by a DIFFERENT bot, in which case the
+ *      full slug keeps the two apart.
+ */
+import type { MyLocalBot } from "./api.js";
+export interface LocalBotDirectory {
+    name: string;
+    dir: string;
+    /** The identity the directory holds, from bot.json or its credentials; null when it holds neither. */
+    agentUid: string | null;
+}
+/** A cloud name as a folder name here, or null when it cannot be one. */
+export declare function botNameFromSlug(value: string | undefined | null): string | null;
+/** Every bot directory on this computer, with the identity it holds. */
+export declare function localBotDirectories(root?: string): LocalBotDirectory[];
+/** The directory this identity already has here, however it is named. */
+export declare function findLocalBotByAgentUid(agentUid: string, root?: string): LocalBotDirectory | null;
+/**
+ * `qa-x-rg13gzm4` → `qa-x`, when `rg13gzm4` is this owner's suffix. The suffix
+ * is whatever tail of the owner's uid HQ appended, so it is recognised by
+ * matching the tail against the uid rather than by assuming its length.
+ * Anything unrecognised is left exactly as it is.
+ */
+export declare function stripOwnerSuffix(slug: string, ownerUid: string | null | undefined): string;
+/**
+ * The folder name this cloud bot has (or should have) on this computer, or
+ * null when its name cannot be a folder name here at all.
+ *
+ * `ownerUid` is the signed-in account, used when the listing did not say who
+ * owns the bot; the listing's own `ownerUid` wins when it is there.
+ */
+export declare function localNameForRemoteBot(bot: MyLocalBot, opts?: {
+    ownerUid?: string | null;
+    root?: string;
+}): string | null;
+//# sourceMappingURL=local-name.d.ts.map