@indigoai-us/hq-cli 5.114.0 → 5.115.1

package/CHANGELOG.md

@@ -2,6 +2,51 @@
 
 ## [Unreleased]
 
+## [5.115.1] — 2026-09-15
+
+### Fixed
+
+- `hq bot create --kind company` now sends the bot's companies with the create, as the cloud requires, so a company bot can actually be created; the cloud makes it a member of each company, and a company you are not an owner or admin of is refused before anything is created.
+
+## [5.115.0] — 2026-09-15
+
+### Added
+
+- Local bots now come in two kinds. A **personal bot** acts as you: everything
+  it does — in your direct messages, in rooms, and on its first task — runs
+  under your own account, so it reaches every company and file you can and
+  can create companies, bots, invites and shares for you. A **company bot**
+  acts as itself, like a cloud agent: it is a member of one or more companies
+  and reaches only those companies' files, memory and secrets; it never acts
+  as you and says so if asked to create something for you, suggesting you ask
+  a personal bot instead. `hq bot create <name> --kind personal|company
+  --company <slug>` (repeat `--company` for several) picks the kind; a
+  company bot is invited into each company as you create it, and the command
+  tells you exactly which invite did not go through. `hq bot companies
+  <name> --add/--remove <slug>` changes a company bot's memberships later.
+  `hq bot list --json` and `hq bot status` show each bot's kind and
+  companies, and every bot's instructions say which kind it is. Bots created
+  before this release keep working, as personal bots (including one created
+  from a company worker, and the setup bot). Removing a company bot with
+  `hq bot rm` also takes it out of its companies.
+- A personal bot now runs `hq` commands as you in rooms too, not only in your
+  direct messages (before, its room turns used the bot's own identity).
+
+### Fixed
+
+- When a local bot's coding tool (Claude Code, Codex or Grok) has lost its
+  sign-in, the bot no longer answers every message with "Failed to
+  authenticate". It says once that the tool needs you to sign in again, keeps
+  your message, and answers it on its own as soon as the sign-in works (right
+  away after `hq bot restart`). A setup bot's first step waits the same way.
+  `hq bot list --json` reports `runtimeSignIn` while this is the case.
+- In your direct messages, a local bot now does what you ask under your own
+  account: creating a company, a bot, an invite or a share works directly,
+  instead of the bot explaining that the cloud refuses to let it act in your
+  name and asking you to run a command in a terminal. In rooms, bots still act
+  as themselves. A company you create this way now also adds that bot as a
+  member, so it can keep helping inside the new company.
+
 ## [5.114.0] — 2026-09-15
 
 ### Changed

package/dist/command-catalog.generated.d.ts

@@ -6129,6 +6129,12 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly variadic: false;
         }];
         readonly options: readonly [{
+            readonly flags: "--kind <kind>";
+            readonly description: "personal (acts as you, everywhere you are) or company (acts as itself, as a member of its companies). Default: personal, or company when created from a company worker";
+        }, {
+            readonly flags: "--company <slug>";
+            readonly description: "Company bots: a company the bot is a member of (repeat for several); the owner invites it on creation";
+        }, {
             readonly flags: "--runtime <runtime>";
             readonly description: "Model CLI to run the bot with: claude|codex|grok";
         }, {
@@ -6163,6 +6169,28 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly description: "Print machine-readable JSON";
         }];
         readonly subcommands: readonly [];
+    }, {
+        readonly name: "companies";
+        readonly description: "Show or change which companies a company bot is a member of (you invite or remove it; a personal bot has no list of its own)";
+        readonly aliases: readonly [];
+        readonly hidden: false;
+        readonly usage: "[options] <name>";
+        readonly arguments: readonly [{
+            readonly name: "name";
+            readonly required: true;
+            readonly variadic: false;
+        }];
+        readonly options: readonly [{
+            readonly flags: "--add <slug>";
+            readonly description: "Add the bot to this company (repeatable)";
+        }, {
+            readonly flags: "--remove <slug>";
+            readonly description: "Remove the bot from this company (repeatable)";
+        }, {
+            readonly flags: "--json";
+            readonly description: "Print machine-readable JSON";
+        }];
+        readonly subcommands: readonly [];
     }, {
         readonly name: "workers";
         readonly description: "List the workers (templates) a bot can be created from (hq bot create <name> --worker <id>)";

package/dist/command-catalog.generated.js

@@ -7923,6 +7923,14 @@ export const COMMAND_CATALOG = [
                     }
                 ],
                 "options": [
+                    {
+                        "flags": "--kind <kind>",
+                        "description": "personal (acts as you, everywhere you are) or company (acts as itself, as a member of its companies). Default: personal, or company when created from a company worker"
+                    },
+                    {
+                        "flags": "--company <slug>",
+                        "description": "Company bots: a company the bot is a member of (repeat for several); the owner invites it on creation"
+                    },
                     {
                         "flags": "--runtime <runtime>",
                         "description": "Model CLI to run the bot with: claude|codex|grok"
@@ -7970,6 +7978,35 @@ export const COMMAND_CATALOG = [
                 ],
                 "subcommands": []
             },
+            {
+                "name": "companies",
+                "description": "Show or change which companies a company bot is a member of (you invite or remove it; a personal bot has no list of its own)",
+                "aliases": [],
+                "hidden": false,
+                "usage": "[options] <name>",
+                "arguments": [
+                    {
+                        "name": "name",
+                        "required": true,
+                        "variadic": false
+                    }
+                ],
+                "options": [
+                    {
+                        "flags": "--add <slug>",
+                        "description": "Add the bot to this company (repeatable)"
+                    },
+                    {
+                        "flags": "--remove <slug>",
+                        "description": "Remove the bot from this company (repeatable)"
+                    },
+                    {
+                        "flags": "--json",
+                        "description": "Print machine-readable JSON"
+                    }
+                ],
+                "subcommands": []
+            },
             {
                 "name": "workers",
                 "description": "List the workers (templates) a bot can be created from (hq bot create <name> --worker <id>)",

package/dist/commands/bot-companies.d.ts

@@ -0,0 +1,40 @@
+/**
+ * A company bot's memberships (BOT-KINDS, 2026-09-15). A company bot acts as
+ * itself, so it must be a member of every company it works for; the OWNER
+ * (person token) invites it, the same `agt_` member/admin route fleet agents
+ * use. Slugs resolve to company uids with the owner's sign-in.
+ *
+ * Both helpers keep going after a failure and report every slug's outcome,
+ * so `hq bot create` can say exactly which invite did not go through.
+ */
+import { inviteMember, revokeInvite } from "./members.js";
+export interface BotCompanyDeps {
+    companyUid: (token: string, slug: string) => Promise<string>;
+    callerUid: (token: string) => Promise<string>;
+    invite: typeof inviteMember;
+    revoke: typeof revokeInvite;
+}
+export interface BotCompanyOutcome {
+    /** Slugs the change went through for. */
+    done: string[];
+    /** Slugs it did not, with the reason. */
+    failed: Array<{
+        slug: string;
+        reason: string;
+    }>;
+}
+/** Invite the bot as a member of each company, with the person's token. */
+export declare function addBotToCompanies(input: {
+    agentUid: string;
+    companies: readonly string[];
+    token: string;
+}, deps?: BotCompanyDeps): Promise<BotCompanyOutcome>;
+/** Remove the bot's membership in each company (the `hq members revoke` route). */
+export declare function removeBotFromCompanies(input: {
+    agentUid: string;
+    companies: readonly string[];
+    token: string;
+}, deps?: BotCompanyDeps): Promise<BotCompanyOutcome>;
+/** One line per failure, for an error message or a log. */
+export declare function describeCompanyFailures(failed: BotCompanyOutcome["failed"]): string;
+//# sourceMappingURL=bot-companies.d.ts.map

package/dist/commands/bot-companies.js

@@ -0,0 +1,64 @@
+/**
+ * A company bot's memberships (BOT-KINDS, 2026-09-15). A company bot acts as
+ * itself, so it must be a member of every company it works for; the OWNER
+ * (person token) invites it, the same `agt_` member/admin route fleet agents
+ * use. Slugs resolve to company uids with the owner's sign-in.
+ *
+ * Both helpers keep going after a failure and report every slug's outcome,
+ * so `hq bot create` can say exactly which invite did not go through.
+ */
+import { getCallerPersonUid, inviteMember, resolveRevokeTargetToMembershipKey, revokeInvite } from "./members.js";
+import { getCompanyUid } from "../utils/vault-api.js";
+const defaultDeps = {
+    companyUid: getCompanyUid,
+    callerUid: getCallerPersonUid,
+    invite: inviteMember,
+    revoke: revokeInvite,
+};
+function reasonOf(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/** Invite the bot as a member of each company, with the person's token. */
+export async function addBotToCompanies(input, deps = defaultDeps) {
+    const out = { done: [], failed: [] };
+    if (input.companies.length === 0)
+        return out;
+    let callerUid;
+    try {
+        callerUid = await deps.callerUid(input.token);
+    }
+    catch (err) {
+        return { done: [], failed: input.companies.map((slug) => ({ slug, reason: reasonOf(err) })) };
+    }
+    for (const slug of input.companies) {
+        try {
+            const companyUid = await deps.companyUid(input.token, slug);
+            await deps.invite({ target: input.agentUid, role: "member", sendEmail: false, companyUid, callerUid, token: input.token });
+            out.done.push(slug);
+        }
+        catch (err) {
+            out.failed.push({ slug, reason: reasonOf(err) });
+        }
+    }
+    return out;
+}
+/** Remove the bot's membership in each company (the `hq members revoke` route). */
+export async function removeBotFromCompanies(input, deps = defaultDeps) {
+    const out = { done: [], failed: [] };
+    for (const slug of input.companies) {
+        try {
+            const companyUid = await deps.companyUid(input.token, slug);
+            await deps.revoke(input.token, resolveRevokeTargetToMembershipKey(input.agentUid, companyUid), companyUid);
+            out.done.push(slug);
+        }
+        catch (err) {
+            out.failed.push({ slug, reason: reasonOf(err) });
+        }
+    }
+    return out;
+}
+/** One line per failure, for an error message or a log. */
+export function describeCompanyFailures(failed) {
+    return failed.map((f) => `${f.slug} (${f.reason})`).join("; ");
+}
+//# sourceMappingURL=bot-companies.js.map

package/dist/commands/bot.d.ts

@@ -1,5 +1,6 @@
 import { Command } from "commander";
-import { type BotMemoryMode, type BotRuntimeId, type LaunchctlExec } from "../lib/bot/index.js";
+import { type RuntimeSignInIssue } from "../lib/bot/runtime-sign-in.js";
+import { type BotKind, type BotMemoryMode, type BotRuntimeId, type LaunchctlExec } from "../lib/bot/index.js";
 /** Real launchctl; every failure is a non-ok result, never a throw. */
 export declare const defaultLaunchctl: LaunchctlExec;
 /** The desktop app creates HQ's setup bot under this name, always from the `setup` worker. */
@@ -23,10 +24,16 @@ export interface BotRow {
     } | null;
     online: boolean | null;
     lastHeartbeatAt: string | null;
+    /** Present while the coding tool needs a new sign-in before the bot can work. */
+    runtimeSignIn: RuntimeSignInIssue | null;
     daemonInstalled: boolean;
     daemonLoaded: boolean;
     dir: string;
     introSentAt?: string;
+    /** "personal" acts as its owner everywhere; "company" acts as itself. */
+    kind: BotKind;
+    /** Company bots: the companies the bot is a member of (empty for a personal bot). */
+    companies: string[];
     workerSource: "scaffold" | "worker";
     workerDir: string;
     workerId?: string;
@@ -43,6 +50,24 @@ export declare function listBotNames(root: string): string[];
 export declare function botTokenSupplier(dir: string): () => Promise<string>;
 /** Spawn `hq bot run <name>` detached (no launchd). */
 export declare function spawnDetachedRun(name: string, dir: string): number;
+/**
+ * The kind a new bot gets, before anything is provisioned. Personal unless
+ * `--kind company` is given (the desktop app always passes --kind). A company
+ * bot needs at least one company: `--company`, or the company worker's own
+ * company when created from one. A personal bot takes no `--company`, and
+ * HQ's setup bot is always personal.
+ */
+export declare function resolveCreateKind(opts: {
+    kind?: string;
+    company?: string[];
+    worker?: string;
+}, worker: {
+    id: string;
+    company?: string | null;
+} | null): {
+    kind: BotKind;
+    companies: string[];
+};
 export declare function runBotCreate(nameArg: string, opts: {
     runtime?: string;
     model?: string;
@@ -55,6 +80,13 @@ export declare function runBotCreate(nameArg: string, opts: {
     intro?: string;
     kickoff?: string;
     memory?: string;
+    kind?: string;
+    company?: string[];
+}): Promise<void>;
+export declare function runBotCompanies(nameArg: string, opts: {
+    add?: string[];
+    remove?: string[];
+    json?: boolean;
 }): Promise<void>;
 export declare function runBotWorkers(opts: {
     json?: boolean;

package/dist/commands/bot.js

@@ -4,7 +4,8 @@ import { hasPromotionHold, promotionHoldSummary } from "../lib/bot/promotion-hol
 /**
  * `hq bot` — personal local bots (local-bots US-003/US-004/US-005).
  *
- *   hq bot create <name> [--runtime claude|codex|grok] [--model m] [--effort level] [--worker id] [--intro text] [--kickoff prompt] [--memory synced|local] [--no-daemon]
+ *   hq bot create <name> [--kind personal|company] [--company slug]... [--runtime claude|codex|grok] [--model m] [--effort level] [--worker id] [--intro text] [--kickoff prompt] [--memory synced|local] [--no-daemon]
+ *   hq bot companies <name> [--add slug]... [--remove slug]...   (a company bot's memberships)
  *   hq bot workers [--json]              (company + core workers a bot can be created from)
  *   hq bot list [--json]
  *   hq bot start|stop|restart <name>
@@ -20,6 +21,7 @@ import { hasPromotionHold, promotionHoldSummary } from "../lib/bot/promotion-hol
  * list (online flag), and rm. Secrets are never printed.
  */
 import { promoteLocalBot } from "../lib/bot/promote.js";
+import { addBotToCompanies, describeCompanyFailures, removeBotFromCompanies } from "./bot-companies.js";
 import { registerBotContinuityCommand } from "./bot-continuity.js";
 import chalk from "chalk";
 import { execFileSync, spawn } from "node:child_process";
@@ -28,9 +30,13 @@ import * as path from "node:path";
 import * as readline from "node:readline";
 import { DEFAULT_COGNITO, ensureCognitoToken, resolveDefaultHqRoot, } from "../utils/cognito-session.js";
 import { peekHqApiKey } from "../utils/resolve-vault-credential.js";
-import { resolveCallerPersonUid } from "../utils/vault-api.js";
+import { getCompanyUid, resolveCallerPersonUid } from "../utils/vault-api.js";
 import { resolveHqBinary } from "../lib/mesh/live/daemon/install.js";
-import { BotApi, BotApiError, botDaemonStatus, botDir, botCredsPath, botLogPath, botsRoot, botTokenStateDir, botWorkerRelDir, buildBotDaemonPaths, createBotLogger, deleteBotCreds, installBotDaemon, introDmText, isBotMemoryMode, botLocalMemoryDir, botMemoryMode, resolveBotMemoryDir, validateBotIntro, validateBotKickoff, validateBotEffort, validateBotModel, effectiveBotEffort, BOT_EFFORT_LEVELS, DEFAULT_BOT_EFFORT, BOT_MEMORY_MODES, isBotRuntimeId, isPidAlive, listBotWorkerOptions, patchBotConfig, readBotConfig, readBotCredsIdentity, readBotStatus, resolveBotWorker, runBot, runtimeFor, scaffoldBotMemory, scaffoldBotWorker, startBotDaemon, stopBotDaemon, uninstallBotDaemon, validateBotName, writeBotConfig, writeBotCreds, BOT_RUNTIMES, BOT_INTRO_MAX_CHARS, BOT_KICKOFF_MAX_CHARS, } from "../lib/bot/index.js";
+import { runtimeDisplayName } from "../lib/bot/runtime-sign-in.js";
+import { BotApi, BotApiError, botDaemonStatus, botDir, botCredsPath, botLogPath, botsRoot, botTokenStateDir, botWorkerRelDir, buildBotDaemonPaths, createBotLogger, deleteBotCreds, installBotDaemon, introDmText, isBotMemoryMode, botLocalMemoryDir, botMemoryMode, resolveBotMemoryDir, validateBotIntro, validateBotKickoff, validateBotEffort, validateBotModel, effectiveBotEffort, BOT_EFFORT_LEVELS, DEFAULT_BOT_EFFORT, BOT_MEMORY_MODES, BOT_KINDS, isBotKind, effectiveBotKind, effectiveBotCompanies, normalizeBotCompanies, SETUP_BOT_WORKER_ID, isBotRuntimeId, isPidAlive, listBotWorkerOptions, patchBotConfig, readBotConfig, readBotCredsIdentity, readBotStatus, resolveBotWorker, runBot, runtimeFor, scaffoldBotMemory, scaffoldBotWorker, startBotDaemon, stopBotDaemon, uninstallBotDaemon, validateBotName, writeBotConfig, writeBotCreds, BOT_RUNTIMES, BOT_INTRO_MAX_CHARS, BOT_KICKOFF_MAX_CHARS, } from "../lib/bot/index.js";
+function collectRepeated(value, previous) {
+    return [...previous, value];
+}
 function fail(message) {
     console.error(chalk.red(message));
     process.exit(1);
@@ -134,10 +140,13 @@ function rowFor(name, opts = {}) {
         promotionHold: promotionHoldSummary(dir, config.agentUid, config.ownerUid),
         online: null,
         lastHeartbeatAt: status?.lastHeartbeatAt ?? null,
+        runtimeSignIn: status?.runtimeSignIn ?? null,
         daemonInstalled,
         daemonLoaded,
         dir,
         introSentAt: config.introSentAt,
+        kind: effectiveBotKind(config),
+        companies: effectiveBotCompanies(config),
         workerSource: config.workerSource ?? "scaffold",
         workerDir: config.workerDir,
         ...(config.workerId ? { workerId: config.workerId } : {}),
@@ -290,6 +299,42 @@ async function stopBot(name, dir, config, output) {
     console.log(signalled || gone ? chalk.green(`${name} stopped`) : chalk.dim(`${name} was not running`));
 }
 // ── create ───────────────────────────────────────────────────────────────────
+/** "personal (acts as you)" / "company (acts as itself; member of a, b)". */
+function describeKind(kind, companies) {
+    return kind === "company"
+        ? `company (acts as itself; member of ${companies.length ? companies.join(", ") : "no company"})`
+        : "personal (acts as you)";
+}
+/**
+ * The kind a new bot gets, before anything is provisioned. Personal unless
+ * `--kind company` is given (the desktop app always passes --kind). A company
+ * bot needs at least one company: `--company`, or the company worker's own
+ * company when created from one. A personal bot takes no `--company`, and
+ * HQ's setup bot is always personal.
+ */
+export function resolveCreateKind(opts, worker) {
+    const given = opts.kind?.trim().toLowerCase();
+    if (given !== undefined && given !== "" && !isBotKind(given)) {
+        throw Object.assign(new Error(`--kind must be one of ${BOT_KINDS.join(", ")}`), { expected: true });
+    }
+    const requested = normalizeBotCompanies(opts.company);
+    const isSetup = worker?.id === SETUP_BOT_WORKER_ID;
+    const kind = isBotKind(given) ? given : "personal";
+    if (kind === "personal") {
+        if (requested.length > 0) {
+            throw Object.assign(new Error("--company only applies to a company bot (a personal bot acts as you, in every company you belong to). Add --kind company, or drop --company."), { expected: true });
+        }
+        return { kind, companies: [] };
+    }
+    if (isSetup) {
+        throw Object.assign(new Error("HQ's setup bot is always a personal bot; drop --kind company."), { expected: true });
+    }
+    const companies = requested.length > 0 ? requested : normalizeBotCompanies(worker?.company ? [worker.company] : []);
+    if (companies.length === 0) {
+        throw Object.assign(new Error("A company bot needs at least one company: add --company <slug> (repeat it for several), or create the bot from a company worker."), { expected: true });
+    }
+    return { kind, companies };
+}
 export async function runBotCreate(nameArg, opts) {
     const name = validateBotName(nameArg);
     const runtime = opts.runtime ?? "claude";
@@ -317,16 +362,38 @@ export async function runBotCreate(nameArg, opts) {
     // Resolve the company worker before provisioning anything (a typo must not
     // cost an identity).
     const worker = opts.worker?.trim() ? resolveBotWorker(hqRoot, opts.worker) : null;
+    const { kind, companies } = resolveCreateKind(opts, worker);
     const token = await ownerToken();
     const owner = await resolveCallerPersonUid(token);
     if (!owner)
         throw Object.assign(new Error("Your HQ login has no person entity yet; open the HQ desktop app once, then retry."), { expected: true });
     const api = new BotApi({ token: async () => token });
+    // A company bot's companies are resolved first (a typo must not cost an
+    // identity) and sent with the create: the server makes the bot a member of
+    // each and refuses the whole create if the owner cannot add agents there.
+    const companyUids = [];
+    for (const slug of companies) {
+        try {
+            companyUids.push(await getCompanyUid(token, slug));
+        }
+        catch (err) {
+            throw Object.assign(new Error(`Cannot create ${name}: ${err instanceof Error ? err.message : String(err)} (company "${slug}").`), { expected: true });
+        }
+    }
     let created;
     try {
-        created = await api.createLocalBot({ name });
+        created = await api.createLocalBot({
+            name,
+            kind,
+            ...(kind === "company" ? { companyUid: companyUids[0], companyMemberships: companyUids.slice(1) } : {}),
+        });
     }
     catch (err) {
+        if (err instanceof BotApiError && err.code === "COMPANY_BOT_CREATE_NOT_ALLOWED") {
+            throw Object.assign(new Error(`The server refused to create ${name}: ${err.message} Only an owner or admin of each company can create a company bot there.`), {
+                expected: true,
+            });
+        }
         if (err instanceof BotApiError && err.code === "LOCAL_BOT_CAP_REACHED") {
             // Only an older server still enforces a cap; current hq-pro-agents has none.
             throw Object.assign(new Error("The server refused another bot (its bot limit is reached). Remove one with hq bot rm <name>, or update the server."), {
@@ -350,6 +417,9 @@ export async function runBotCreate(nameArg, opts) {
         agentUid,
         ownerUid: created.agent.ownerUid ?? owner,
         runtime,
+        kind,
+        // A company bot's list is filled in below, with the invites that went through.
+        ...(kind === "company" ? { companies: [] } : {}),
         ...(model ? { model } : {}),
         ...(effort ? { effort } : {}),
         ...(opts.autoApprove === false ? { autoApprove: false } : {}),
@@ -377,15 +447,36 @@ export async function runBotCreate(nameArg, opts) {
         enabled: true,
     };
     writeBotConfig(dir, config);
+    // A company bot acts as itself, so it must be a member of each of its
+    // companies. Only the companies it actually joined are recorded, so after a failed invite the identity
+    // and bot.json stay on disk and `hq bot companies <name> --add <slug>`
+    // retries exactly the missing ones (or `hq bot rm <name>` undoes it all).
+    if (kind === "company") {
+        // The server already made it a member of the companies it reports back;
+        // only the rest (an older server reports none) are invited here.
+        const joined = new Set(created.agent.companyMemberships ?? []);
+        const already = companies.filter((_, i) => joined.has(companyUids[i]));
+        const missing = companies.filter((_, i) => !joined.has(companyUids[i]));
+        const outcome = await addBotToCompanies({ agentUid, companies: missing, token });
+        config.companies = [...already, ...outcome.done];
+        writeBotConfig(dir, config);
+        if (outcome.failed.length > 0) {
+            createBotLogger(dir)("error", `created ${name} (${agentUid}) but could not add it to: ${describeCompanyFailures(outcome.failed)}`);
+            throw Object.assign(new Error(`Created the bot identity ${agentUid} but could not add it to ${outcome.failed.length === 1 ? "a company" : `${outcome.failed.length} companies`}: ${describeCompanyFailures(outcome.failed)}. ` +
+                `Fix the cause and run \`hq bot companies ${name} --add ${outcome.failed.map((f) => f.slug).join(" --add ")}\`, or remove the bot with \`hq bot rm ${name}\`.`), { expected: true });
+        }
+    }
     // A worker-sourced bot never writes into the company tree: only its own
     // memory folder is scaffolded.
     const scaffoldOpts = { memoryDir: config.memoryDir };
     const scaffold = worker
         ? scaffoldBotMemory(hqRoot, name, undefined, scaffoldOpts)
         : scaffoldBotWorker(hqRoot, name, agentUid, runtime, undefined, scaffoldOpts);
-    createBotLogger(dir)("info", `created ${name} (${agentUid}) runtime=${runtime}${worker ? ` worker=${worker.id} company=${worker.company ?? "-"}` : ""} memory=${memoryMode}`);
+    createBotLogger(dir)("info", `created ${name} (${agentUid}) kind=${kind}${companies.length ? ` companies=${companies.join(",")}` : ""} runtime=${runtime}${worker ? ` worker=${worker.id} company=${worker.company ?? "-"}` : ""} memory=${memoryMode}`);
     const created_ = {
         agentUid,
+        kind,
+        companies,
         runtime,
         dir,
         worker: worker ? path.join(hqRoot, worker.path) : scaffold.dir,
@@ -405,6 +496,7 @@ export async function runBotCreate(nameArg, opts) {
     }
     if (!opts.json) {
         console.log(chalk.green(`Created bot ${chalk.bold(name)}`) + chalk.dim(` (${agentUid}, ${runtime})`));
+        console.log(chalk.dim(`  kind:   ${describeKind(kind, companies)}`));
         if (worker)
             console.log(chalk.dim(`  worker: ${worker.id}${worker.company ? ` (${worker.company})` : ""} — ${path.join(hqRoot, worker.path)}`));
         if (!worker)
@@ -434,6 +526,66 @@ export async function runBotCreate(nameArg, opts) {
         console.log(JSON.stringify({ ok: true, name, ...created_, daemon: daemonMessage, running: false }, null, 2));
     }
 }
+// ── companies ────────────────────────────────────────────────────────────────
+export async function runBotCompanies(nameArg, opts) {
+    const { name, dir, config } = requireBot(nameArg);
+    const kind = effectiveBotKind(config);
+    const add = normalizeBotCompanies(opts.add);
+    const remove = normalizeBotCompanies(opts.remove);
+    if (kind !== "company") {
+        throw Object.assign(new Error(`${name} is a personal bot: it acts as you, in every company you belong to, so it has no company list of its own. Create a company bot with: hq bot create <name> --kind company --company <slug>`), { expected: true });
+    }
+    const current = effectiveBotCompanies(config);
+    const both = add.filter((c) => remove.includes(c));
+    if (both.length > 0) {
+        throw Object.assign(new Error(`--add and --remove name the same company: ${both.join(", ")}`), { expected: true });
+    }
+    const toAdd = add.filter((c) => !current.includes(c));
+    const toRemove = remove.filter((c) => current.includes(c));
+    const unknown = remove.filter((c) => !current.includes(c));
+    if (unknown.length > 0) {
+        throw Object.assign(new Error(`${name} is not in ${unknown.join(", ")} (its companies: ${current.join(", ") || "none"}).`), { expected: true });
+    }
+    const next = [...current.filter((c) => !toRemove.includes(c)), ...toAdd];
+    if (next.length === 0) {
+        throw Object.assign(new Error(`A company bot needs at least one company; ${name} would be left with none. Remove the bot instead with: hq bot rm ${name}`), { expected: true });
+    }
+    const failed = [];
+    let added = [];
+    let removed = [];
+    if (toAdd.length > 0 || toRemove.length > 0) {
+        const token = await ownerToken();
+        if (toAdd.length > 0) {
+            const r = await addBotToCompanies({ agentUid: config.agentUid, companies: toAdd, token });
+            added = r.done;
+            failed.push(...r.failed);
+        }
+        if (toRemove.length > 0) {
+            const r = await removeBotFromCompanies({ agentUid: config.agentUid, companies: toRemove, token });
+            removed = r.done;
+            failed.push(...r.failed);
+        }
+    }
+    const companies = [...current.filter((c) => !removed.includes(c)), ...added];
+    if (added.length > 0 || removed.length > 0)
+        patchBotConfig(dir, { kind: "company", companies });
+    if (opts.json) {
+        console.log(JSON.stringify({ ok: failed.length === 0, name, kind, companies, added, removed, failed }, null, 2));
+    }
+    else {
+        console.log(`${chalk.bold(name)}  company bot, member of: ${companies.join(", ")}`);
+        if (added.length > 0)
+            console.log(chalk.green(`  added:   ${added.join(", ")}`));
+        if (removed.length > 0)
+            console.log(chalk.green(`  removed: ${removed.join(", ")}`));
+        if (companies.length > 0 && (added.length > 0 || removed.length > 0)) {
+            console.log(chalk.dim(`  restart the bot so its instructions pick this up: hq bot restart ${name}`));
+        }
+    }
+    if (failed.length > 0) {
+        throw Object.assign(new Error(`Could not change ${name}'s membership in: ${describeCompanyFailures(failed)}`), { expected: true });
+    }
+}
 // ── workers ──────────────────────────────────────────────────────────────────
 export async function runBotWorkers(opts) {
     const hqRoot = resolveDefaultHqRoot({ onMissing: "throw" });
@@ -473,7 +625,7 @@ async function runBotList(opts) {
         return;
     }
     for (const r of rows) {
-        console.log(`${chalk.bold(r.name.padEnd(16))} ${r.agentUid}  ${r.runtime.padEnd(6)}  ${humanOnline(r).padEnd(8)}  ${r.processAlive ? chalk.green(`pid ${r.pid}`) : chalk.gray(r.state)}${r.daemonInstalled ? chalk.dim("  launchd") : ""}${r.workerId ? chalk.dim(`  worker ${r.workerId}${r.companySlug ? ` (${r.companySlug})` : ""}`) : ""}`);
+        console.log(`${chalk.bold(r.name.padEnd(16))} ${r.agentUid}  ${r.runtime.padEnd(6)}  ${humanOnline(r).padEnd(8)}  ${r.processAlive ? chalk.green(`pid ${r.pid}`) : chalk.gray(r.state)}${chalk.dim(`  ${r.kind === "company" ? `company bot: ${r.companies.join(", ") || "no company"}` : "personal"}`)}${r.daemonInstalled ? chalk.dim("  launchd") : ""}${r.workerId ? chalk.dim(`  worker ${r.workerId}${r.companySlug ? ` (${r.companySlug})` : ""}`) : ""}`);
     }
 }
 async function runBotStatus(nameArg, opts) {
@@ -487,6 +639,7 @@ async function runBotStatus(nameArg, opts) {
         return;
     }
     console.log(`${chalk.bold(name)}  ${row.agentUid}`);
+    console.log(`  kind:       ${describeKind(row.kind, row.companies)}`);
     console.log(`  runtime:    ${row.runtime}  model ${row.model ?? "default"}  thinking ${row.effort}${row.effortIsDefault ? " (default)" : ""}`);
     if (row.workerId)
         console.log(`  worker:     ${row.workerId}${row.companySlug ? ` (company ${row.companySlug})` : ""}  ${chalk.dim(row.workerDir)}`);
@@ -497,6 +650,10 @@ async function runBotStatus(nameArg, opts) {
     console.log(`  creds:      ${creds ? `present for ${creds.entityUid}` : chalk.red("missing")}`);
     if (status) {
         console.log(`  started:    ${status.startedAt}   restarts: ${status.restarts}   replies: ${status.repliesSent}`);
+        if (status.runtimeSignIn?.state === "expired") {
+            const tool = runtimeDisplayName(status.runtimeSignIn.runtime);
+            console.log(`  ${chalk.yellow(`${tool} needs to sign in again`)} — sign in from HQ, or run \`${status.runtimeSignIn.runtime} ${status.runtimeSignIn.runtime === "claude" ? "auth login" : "login"}\`, then \`hq bot restart ${name}\``);
+        }
         if (status.lastError)
             console.log(`  last error: ${chalk.yellow(status.lastError)}`);
     }
@@ -568,15 +725,22 @@ async function runBotRm(nameArg, opts) {
             throw err;
     }
     const terminal = "alreadyGone" in identity ? true : identity.terminal;
+    // A company bot is a member of its companies: leave them too. Best effort —
+    // a stale membership row must not keep the bot's local state around.
+    const memberships = effectiveBotCompanies(config);
+    const left = memberships.length > 0 ? await removeBotFromCompanies({ agentUid: config.agentUid, companies: memberships, token }) : { done: [], failed: [] };
     deleteBotCreds(dir);
     if (terminal)
         fs.rmSync(dir, { recursive: true, force: true });
     if (opts.json) {
-        console.log(JSON.stringify({ ok: terminal, name, agentUid: config.agentUid, daemon: daemon.message, identity, localStateRemoved: terminal, workerKept: path.join(config.hqRoot, config.workerDir) }, null, 2));
+        console.log(JSON.stringify({ ok: terminal, name, agentUid: config.agentUid, daemon: daemon.message, identity, companiesLeft: left.done, companiesNotLeft: left.failed, localStateRemoved: terminal, workerKept: path.join(config.hqRoot, config.workerDir) }, null, 2));
         return;
     }
+    for (const f of left.failed) {
+        console.log(chalk.yellow(`  could not remove ${name} from ${f.slug}: ${f.reason}`) + chalk.dim(` — remove it by hand: hq members --company ${f.slug} revoke ${config.agentUid}`));
+    }
     if (terminal) {
-        console.log(chalk.green(`Removed bot ${name}`) + chalk.dim(` (${config.agentUid}); worker folder kept at ${path.join(config.hqRoot, config.workerDir)}`));
+        console.log(chalk.green(`Removed bot ${name}`) + chalk.dim(` (${config.agentUid}${left.done.length ? `; left ${left.done.join(", ")}` : ""}); worker folder kept at ${path.join(config.hqRoot, config.workerDir)}`));
     }
     else {
         console.log(chalk.yellow(`Bot ${name} is stopped locally but its cloud identity is not fully removed yet.`));
@@ -668,6 +832,8 @@ export function registerBotCommand(program) {
     bot
         .command("create <name>")
         .description("Provision a local bot identity, scaffold its worker folder, install its launchd agent, and start it")
+        .option("--kind <kind>", `personal (acts as you, everywhere you are) or company (acts as itself, as a member of its companies). Default: personal, or company when created from a company worker`)
+        .option("--company <slug>", "Company bots: a company the bot is a member of (repeat for several); the owner invites it on creation", collectRepeated, [])
         .option("--runtime <runtime>", `Model CLI to run the bot with: ${BOT_RUNTIMES.join("|")}`, "claude")
         .option("--model <model>", "Model override passed to the runtime CLI")
         .option("--effort <level>", `Thinking level: claude ${BOT_EFFORT_LEVELS.claude.join("|")}; codex ${BOT_EFFORT_LEVELS.codex.join("|")}; grok ${BOT_EFFORT_LEVELS.grok.join("|")} (default ${DEFAULT_BOT_EFFORT})`)
@@ -680,6 +846,13 @@ export function registerBotCommand(program) {
         .option("--no-start", "Create without starting")
         .option("--json", "Print machine-readable JSON")
         .action((name, opts) => wrap(() => runBotCreate(name, opts))());
+    bot
+        .command("companies <name>")
+        .description("Show or change which companies a company bot is a member of (you invite or remove it; a personal bot has no list of its own)")
+        .option("--add <slug>", "Add the bot to this company (repeatable)", collectRepeated, [])
+        .option("--remove <slug>", "Remove the bot from this company (repeatable)", collectRepeated, [])
+        .option("--json", "Print machine-readable JSON")
+        .action((name, opts) => wrap(() => runBotCompanies(name, opts))());
     bot
         .command("workers")
         .description("List the workers (templates) a bot can be created from (hq bot create <name> --worker <id>)")