@indigoai-us/hq-cli 5.115.6 → 5.117.0

package/dist/lib/agent-kit/skills.js

@@ -0,0 +1,149 @@
+/**
+ * The skills directory the kit ships to ~/.hq-agent/skills/<name>/SKILL.md.
+ *
+ * agentskills.io format: YAML frontmatter with `name` and `description`, then
+ * markdown the bot's framework loads as an instruction. Each skill drives
+ * the `hq` CLI, which authenticates as the machine identity on its own, so
+ * no skill ever embeds or asks for a token or secret value.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const KIT_SKILLS = [
+    {
+        name: "dm",
+        description: "Send and read HQ direct messages and channel messages as this agent using the hq CLI.",
+        body: `# HQ direct messages
+
+Use the \`hq dm\` command to talk to teammates (people and other agents) in HQ.
+The CLI authenticates as this agent automatically — never ask for a token.
+
+## Send
+
+\`\`\`bash
+hq dm <email-or-uid> "message text"        # 1:1 to a person (prs_…) or agent (agt_…)
+hq dm <uid1>,<uid2> "message text"         # group DM
+hq dm '#channel-name' "message text"       # channel
+\`\`\`
+
+## Read
+
+\`\`\`bash
+hq dm inbox --unread            # unread DMs addressed to you
+hq dm thread <email-or-uid>     # the 1:1 conversation
+hq dm inbox --mark-read         # mark what you have read
+hq dm channel <name>            # read a channel
+\`\`\`
+
+New inbound messages are also mirrored by the kit's inbox poller to
+\`~/.hq-agent/inbox/<id>.json\` (and \`inbox.jsonl\`) — check there when
+you are asked whether anyone has messaged you.
+
+## Rules
+
+- Reply in the same thread you were messaged in.
+- Keep messages short; link to files in the vault instead of pasting them.
+- Never include secrets or credentials in a message.
+`,
+    },
+    {
+        name: "search",
+        description: "Search the company vault (documents, knowledge, meeting notes) with the hq CLI's local index.",
+        body: `# HQ search
+
+The company vault is synced to the kit's HQ root (see \`~/.hq-agent/kit.json\`,
+\`hqRoot\`). Search it with:
+
+\`\`\`bash
+hq search "<query>"                        # ranked results across the synced vault
+hq search "<query>" --mode hybrid          # keyword + semantic
+hq search "<query>" --json                 # machine-readable
+hq files search "<query>" --company <slug> # server-side vault search (no local index needed)
+\`\`\`
+
+If results look stale, the sync loop may not have run yet:
+\`hq sync pull --all --on-conflict keep --hq-root <hqRoot>\` pulls now.
+
+Cite the file path of anything you quote so a teammate can open it.
+`,
+    },
+    {
+        name: "files",
+        description: "Read, list and write files in the company vault through the hq CLI (hq files).",
+        body: `# HQ vault files
+
+\`\`\`bash
+hq files browse companies/<slug>/<folder>   # list a vault folder without syncing it
+hq files cat companies/<slug>/<file>        # print one file
+hq files get companies/<slug>/<file>        # fetch one file into the local HQ tree
+hq files share companies/<slug>/<path>      # share a path with a teammate
+hq files versions companies/<slug>/<file>   # version history
+\`\`\`
+
+Paths are vault-relative and start with \`companies/<slug>/\`. The synced copy
+lives under the kit's HQ root (\`~/.hq-agent/kit.json\` → \`hqRoot\`); edit files
+there and run \`hq sync push --hq-root <hqRoot>\` to publish. Writes are
+audited under this agent's identity — only write where you were asked to,
+and prefer creating a new file over overwriting one you did not author.
+`,
+    },
+    {
+        name: "secrets-exec",
+        description: "Run a command with company secrets injected as environment variables, without ever printing them.",
+        body: `# Run with HQ secrets
+
+Secrets never appear in chat, logs or files. Inject them into a child
+process instead:
+
+\`\`\`bash
+hq secrets list                                   # names only, never values
+hq secrets exec --only <NAME>[,<NAME>] -- <cmd>   # run <cmd> with those vars set
+hq run <script>                                   # run a vault script with its declared secrets
+\`\`\`
+
+Rules:
+
+- Never \`echo\`, \`printenv\` or otherwise print a secret, even to "check" it.
+- Request the narrowest \`--only\` set the command needs.
+- If a secret is missing, say which NAME is missing and ask a human admin to
+  add it with \`hq secrets set\` — do not ask for the value in chat.
+`,
+    },
+    {
+        name: "work-mesh-status",
+        description: "Report and update this agent's live work status and read the team's work mesh via the hq CLI.",
+        body: `# Work mesh status
+
+The work mesh is HQ's live board of who is working on what. It is the source
+of truth for project stories and active sessions; the kit's listener keeps a
+local cache under \`~/.hq/work-mesh/cache/\`.
+
+\`\`\`bash
+hq mesh session status --company <slug>          # who is working on what right now
+hq mesh start --company <slug> --project <slug> --summary "<what you are starting>"
+hq mesh progress --company <slug> --project <slug> --summary "<what changed>"
+hq mesh blocked --company <slug> --project <slug> --summary "<what blocks you>"
+hq mesh done --company <slug> --project <slug> --summary "<what you finished>"
+hq mesh note --company <slug> --project <slug> --summary "<short note>"
+\`\`\`
+
+Post \`start\` when you pick up a piece of work and \`done\` when you finish it.
+Keep entries to one line. Presence (online / stale / offline) is derived
+from the kit heartbeat automatically — you do not need to report it.
+`,
+    },
+];
+export function renderSkillMarkdown(skill) {
+    return `---\nname: ${skill.name}\ndescription: ${JSON.stringify(skill.description)}\n---\n\n${skill.body}`;
+}
+export function writeKitSkills(paths) {
+    const written = [];
+    for (const skill of KIT_SKILLS) {
+        const dir = path.join(paths.skillsDir, skill.name);
+        fs.mkdirSync(dir, { recursive: true, mode: 0o755 });
+        const dest = path.join(dir, "SKILL.md");
+        fs.writeFileSync(dest, renderSkillMarkdown(skill), { mode: 0o644 });
+        written.push(dest);
+    }
+    return written;
+}
+//# sourceMappingURL=skills.js.map

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