@indigoai-us/hq-cli 5.345.178 → 5.345.180

package/dist/commands/bot-jobs.js

@@ -5,14 +5,13 @@
  *   hq bot jobs <botName> --add "<what to do>" --every "<plain english>"
  *   hq bot jobs <botName> --add "<what to do>" --cron "0 9 * * 1-5"
  *   hq bot jobs <botName> --rm <jobId>
+ *   hq bot jobs <botName> --reschedule <jobId> --every "<plain english>"
  *
- * The schedule lives in the cloud, never on this computer: hq-pro-agents holds
- * the job and fires it on an EventBridge schedule, and the bot's inbox loop
- * runs the fired run (see lib/bot/job-run.ts). Nothing here writes a crontab,
- * a launchd plist, or a systemd unit — by rule.
- *
- * The routes are self-only per agent, so every call uses the BOT's own machine
- * identity — the same credential path its turns use — not the owner's session.
+ * The schedule lives with the bot: its jobs sit in the bot's own folder
+ * (lib/bot/local-jobs.ts) and the bot's inbox loop fires them while it runs
+ * (see lib/bot/job-run.ts). Nothing here writes a crontab, a launchd plist, or
+ * a systemd unit — by rule. Schedules are still written in the EventBridge form
+ * and held to the same limits, so a job reads the same wherever it runs.
  */
 import chalk from "chalk";
 import { localJobsClient } from "../lib/bot/local-jobs.js";
@@ -365,12 +364,56 @@ export async function runBotJobs(nameArg, opts, deps) {
         client = deps.apiFor ? deps.apiFor(dir) : localJobsClient(dir);
         return client;
     };
-    if (opts.add !== undefined && opts.rm !== undefined) {
-        refuse("Add a job or remove one, not both in the same command.");
+    if ([opts.add, opts.rm, opts.reschedule].filter((value) => value !== undefined).length > 1) {
+        refuse("Add, remove, or reschedule one job at a time, not several in the same command.");
     }
     if (opts.quiet && opts.add === undefined) {
         refuse("Use --quiet with --add to set a scheduled job's delivery option.");
     }
+    // Shared by --add and --reschedule: one schedule from --every or --cron, in
+    // the stored form, held to the same floor.
+    const scheduleFromOptions = () => {
+        if (!opts.every && !opts.cron) {
+            refuse(`Say how often it should run: --every "every weekday at 9am", or --cron "0 9 * * 1-5".`);
+        }
+        if (opts.every && opts.cron)
+            refuse("Use --every or --cron, not both.");
+        const timezone = opts.tz?.trim() || (deps.timezone ?? machineTimezone)();
+        // An unknown zone would throw RangeError on every inbox poll; refuse it now.
+        try {
+            new Intl.DateTimeFormat("en-US", { timeZone: timezone });
+        }
+        catch {
+            refuse(`"${timezone}" is not a known IANA time zone (for example America/New_York or Europe/London).`);
+        }
+        const parse = deps.parseSchedule ?? parseScheduleText;
+        return opts.every ? parse(opts.every, { timezone }) : { cron: opts.cron, timezone };
+    };
+    if (opts.reschedule !== undefined) {
+        const jobId = opts.reschedule.trim();
+        if (!jobId)
+            refuse("Say which job to reschedule: --reschedule <jobId>");
+        const schedule = scheduleFromOptions();
+        const cron = toEventBridgeCron(schedule.cron);
+        assertScheduleWithinFloor(cron);
+        const api = await jobsApi();
+        if (!api.rescheduleJob)
+            refuse(`${name}'s jobs cannot be rescheduled in place. Remove the job and add it again.`);
+        let updated;
+        try {
+            updated = await api.rescheduleJob(config.agentUid, jobId, { cron, timezone: schedule.timezone });
+        }
+        catch (err) {
+            refuse(jobsErrorMessage(err, ctx));
+        }
+        if (opts.json) {
+            out(JSON.stringify({ ok: true, job: updated }, null, 2));
+            return;
+        }
+        const words = schedule.human || describeSchedule(updated);
+        out(chalk.green(`Rescheduled ${updated.jobId}: ${name} now runs it ${words}.`));
+        return;
+    }
     if (opts.rm !== undefined) {
         const jobId = opts.rm.trim();
         if (!jobId)
@@ -389,16 +432,7 @@ export async function runBotJobs(nameArg, opts, deps) {
         if (opts.quiet && !(await quietOptionEnabled())) {
             refuse(`--quiet requires the ${BOT_JOB_QUIET_OPTION_FLAG} flag, which is currently disabled.`);
         }
-        if (!opts.every && !opts.cron) {
-            refuse(`Say how often it should run: --every "every weekday at 9am", or --cron "0 9 * * 1-5".`);
-        }
-        if (opts.every && opts.cron)
-            refuse("Use --every or --cron, not both.");
-        const timezone = opts.tz?.trim() || (deps.timezone ?? machineTimezone)();
-        const parse = deps.parseSchedule ?? parseScheduleText;
-        const schedule = opts.every
-            ? parse(opts.every, { timezone })
-            : { cron: opts.cron, timezone };
+        const schedule = scheduleFromOptions();
         const body = buildCreateJobBody({ prompt: opts.add, cron: schedule.cron, timezone: schedule.timezone, quiet: opts.quiet });
         const api = await jobsApi();
         let created;
@@ -412,7 +446,7 @@ export async function runBotJobs(nameArg, opts, deps) {
             out(JSON.stringify({ ok: true, job: created }, null, 2));
             return;
         }
-        const words = ("human" in schedule && schedule.human) || describeSchedule(created);
+        const words = schedule.human || describeSchedule(created);
         out(chalk.green(`Scheduled ${created.jobId}: ${name} will ${body.prompt.replace(/\s+/g, " ").slice(0, 120)} — ${words}.`));
         out(chalk.gray(`It runs on this computer while ${name} is running. If a run is due while the computer is asleep or ` +
             `${name} is stopped, it runs once, as a catch-up, the next time ${name} is running.`));
@@ -432,13 +466,14 @@ export async function runBotJobs(nameArg, opts, deps) {
 export function registerBotJobsCommand(bot, deps) {
     bot
         .command("jobs <name>")
-        .description("Show, schedule, or remove a bot's recurring jobs (the schedule runs in the cloud, not on this computer)")
+        .description("Show, schedule, reschedule, or remove a bot's recurring jobs (they run on this computer while the bot runs)")
         .option("--add <what>", "Schedule new work, in plain language")
         .option("--every <when>", 'How often, in plain language (e.g. "every weekday at 9am")')
         .option("--cron <expr>", 'How often, as a cron expression (e.g. "0 9 * * 1-5")')
         .option("--tz <zone>", "IANA timezone for the schedule (default: this computer's)")
         .option("--quiet", "Skip owner DMs after successful runs (requires rollout flag)")
         .option("--rm <jobId>", "Remove a scheduled job")
+        .option("--reschedule <jobId>", "Change a job's schedule (with --every or --cron)")
         .option("--json", "Print machine-readable JSON")
         .action(async (name, opts) => {
         try {

package/dist/commands/bot.d.ts

@@ -2,6 +2,7 @@ import { Command } from "commander";
 import { type RuntimeSignInCheck, type RuntimeSignInIssue } from "../lib/bot/runtime-sign-in.js";
 import type { BotStatusFile } from "../lib/bot/status.js";
 import { probeBotRuntime, type RuntimeProbeResult } from "../lib/bot/probe.js";
+import { type SpawnInteractive } from "../lib/bot/runtime-auth.js";
 import { type BotLocalConfig, type MyLocalBot, type BotKind, type BotMemoryMode, type BotNotRunnableReason, type RuntimeCrash, type BotConfig, type BotRuntimeId, type LaunchctlExec, type BotRole } from "../lib/bot/index.js";
 /** Real launchctl; every failure is a non-ok result, never a throw. */
 export declare const defaultLaunchctl: LaunchctlExec;
@@ -193,12 +194,39 @@ export declare function runBotWorkers(opts: {
  * from HQ changes nothing and fails.
  */
 export interface BotSetOptions {
+    runtime?: string;
+    /** A capacity account id for the bot's runtime, or "default" for the owner's own sign-in. */
+    account?: string;
     model?: string;
     effort?: string;
     displayName?: string;
     json?: boolean;
 }
-export declare function runBotSet(nameArg: string, opts: BotSetOptions): Promise<void>;
+export interface BotSetDeps {
+    probe?: typeof probeBotRuntime;
+    /** Test seam: stop and start the bot process. */
+    lifecycle?: {
+        isRunning: (dir: string) => boolean;
+        stop: (name: string, dir: string, config: BotConfig) => Promise<boolean>;
+        start: (name: string, dir: string, config: BotConfig) => Promise<boolean>;
+    };
+}
+export declare function runBotSet(nameArg: string, opts: BotSetOptions, deps?: BotSetDeps): Promise<void>;
+/** `hq bot login <name>`: sign the bot in with a login of its own. */
+export declare function runBotLogin(nameArg: string, opts: {
+    runtime?: string;
+    json?: boolean;
+}, deps?: {
+    spawn?: SpawnInteractive;
+    interactive?: boolean;
+}): Promise<void>;
+/** `hq bot logout <name>`: sign the bot's own login out and delete it. */
+export declare function runBotLogout(nameArg: string, opts: {
+    runtime?: string;
+    json?: boolean;
+}, deps?: {
+    spawn?: SpawnInteractive;
+}): Promise<void>;
 /** `hq bot probe`: exit code 0 when the runtime answered, 1 when it did not. */
 export declare function runBotProbe(opts: {
     runtime?: string;
@@ -379,4 +407,12 @@ export interface RemoteBotRow {
     ownerUid: string | null;
 }
 export declare function registerBotCommand(program: Command): void;
+/**
+ * The company a bot's hot-signal-sync job syncs: the bot's own company, else
+ * the first company it serves. Null = none, and no job is registered. There is
+ * no fallback to the HQ's active company: a personal bot syncs a company only
+ * when it was given one explicitly (`--company`), so the job never writes into
+ * a vault the bot does not belong to.
+ */
+export declare function hotSignalSyncCompany(config: Pick<BotConfig, "companySlug" | "kind" | "companies" | "workerId">): string | null;
 //# sourceMappingURL=bot.d.ts.map

package/dist/commands/bot.js

@@ -1,4 +1,8 @@
 import { withLocalJobs } from "../lib/bot/local-jobs.js";
+import { currentHotSignalSyncCompany, ensureHotSignalSyncJob, removeStaleHotSignalSyncJobs, runHotSignalSyncJob } from "../lib/bot/jobs/hot-signal-sync.js";
+import { createClaudeSignalsPass } from "../lib/hot-channels/signals-pass.js";
+import { machineTimeZone } from "../lib/bot/job-run.js";
+import { runCompanyHotChannelSync } from "./sources.js";
 import { OwnerContextCache, lookupOwnerContext } from "../lib/bot/owner-context.js";
 import { hasActivePromotion } from "../lib/bot/promotion-receipt.js";
 import { readInflightTurns } from "../lib/bot/inflight.js";
@@ -52,6 +56,7 @@ import { isAncestorProcess } from "../lib/bot/self-process.js";
 import { runtimeDisplayName, signInCommand } from "../lib/bot/runtime-sign-in.js";
 import { classifyRuntimeFailure, runtimeFailureReason } from "../lib/bot/runtime-failure.js";
 import { PROBE_DEFAULT_TIMEOUT_MS, probeBotRuntime } from "../lib/bot/probe.js";
+import { BOT_LOGIN_RUNTIMES, botAuthEnv, botRuntimeAuth, capacityAccountHome, describeBotAuth, formatBotAuth, isBotLoginRuntime, restoreBotSessions, setAsideBotSessions, signInBotRuntime, signOutBotRuntime, withRuntimeAuth, } from "../lib/bot/runtime-auth.js";
 import { BotApi, BotApiError, BOT_RESTORE_DEFAULTS, buildBotLocalConfig, describeBotLocalConfig, orphanBotRunMessage, parseBotLocalConfig, removeOrphanBotDaemon, botDaemonStatus, botDir, botCredsPath, botLogPath, botsRoot, botTokenStateDir, botWorkerRelDir, buildBotDaemonPaths, createBotLogger, deleteBotCreds, installBotDaemon, repairBotDaemonIfStale, healBotDaemonNodeFromJob, introDmText, isBotMemoryMode, botLocalMemoryDir, botMemoryMode, resolveBotMemoryDir, validateBotIntro, validateBotDisplayName, validateBotKickoff, validateBotEffort, validateBotModel, effectiveBotEffort, BOT_EFFORT_LEVELS, DEFAULT_BOT_EFFORT, BOT_MEMORY_MODES, BOT_KINDS, isBotKind, effectiveBotKind, effectiveBotCompanies, normalizeBotCompanies, SETUP_BOT_WORKER_ID, isBotRuntimeId, localNameForRemoteBot, remoteBotRunnability, isPidAlive, listBotWorkerOptions, patchBotConfig, readBotConfig, readBotCredsIdentity, readBotStatus, runtimeCrashSinceStart, resolveBotWorker, runBot, runtimeFor, scaffoldBotMemory, scaffoldBotWorker, startBotDaemon, stopBotDaemon, uninstallBotDaemon, validateBotName, writeBotConfig, writeBotCreds, BOT_RUNTIMES, BOT_INTRO_MAX_CHARS, BOT_DISPLAY_NAME_MAX_CHARS, BOT_KICKOFF_MAX_CHARS, detectBotPlatform, withBotLock, localBotRole, remoteBotRole, remoteBotDisplayName, personFacingName, writeCloudDisplayName, setupSlugFor, ASSISTANT_ROLE, HQ_FLEET_RUNTIME_ENGINE_ID, authenticateFleetLocalBot, bootstrapFleetLocalBot, buildSystemPrompt, controlFleetLocalBot, ensureFleetPython, fleetLocalGatewayPid, fleetProviderForRuntime, importFleetLocalMachineCredential, fleetProviderNeedsSignIn, fleetDefaultCompanies, fleetOwnerCompanies, fleetRuntimeIsDefault, refreshFleetLocalInstructions, fleetLocalPromotionRuntime, installPinnedFleetLocalDistribution, readPromptSources, removeFleetLocalBot, } from "../lib/bot/index.js";
 function collectRepeated(value, previous) {
     return [...previous, value];
@@ -796,6 +801,11 @@ async function runBotCreateLocked(name, opts) {
     // cost an identity).
     const worker = opts.worker?.trim() ? resolveBotWorker(hqRoot, opts.worker) : null;
     const { kind, companies } = resolveCreateKind(opts, worker);
+    if (requestedFleetRuntime && kind === "company" && companies.length !== 1) {
+        throw Object.assign(new Error("An HQ Fleet company bot must belong to exactly one company."), {
+            expected: true,
+        });
+    }
     // Companies with the fleet-default flag get their personal bots on
     // the HQ Fleet Runtime; --legacy-runtime keeps the model-CLI runner.
     const fleetCandidate = requestedFleetRuntime ||
@@ -804,12 +814,11 @@ async function runBotCreateLocked(name, opts) {
     // and only where the company turned the flag on.
     const flaggedCompanies = fleetCandidate && kind === "personal" ? await fleetDefaultCompanies(hqRoot) : [];
     const useFleetRuntime = requestedFleetRuntime || (fleetCandidate && fleetRuntimeIsDefault(flaggedCompanies));
-    const ownerCompanies = useFleetRuntime && kind === "personal" ? await fleetOwnerCompanies() : [];
-    if (useFleetRuntime && kind !== "personal") {
-        throw Object.assign(new Error("--hq-fleet-runtime creates a personal bot. Drop --kind company and --company."), {
-            expected: true,
-        });
-    }
+    const ownerCompanies = useFleetRuntime
+        ? kind === "personal"
+            ? await fleetOwnerCompanies()
+            : companies
+        : [];
     const isSetupBot = name === RESERVED_SETUP_BOT_NAME && kind === "personal" && worker?.id === SETUP_BOT_WORKER_ID;
     if (name === RESERVED_SETUP_BOT_NAME && kind === "personal" && !isSetupBot) {
         throw Object.assign(new Error(`The name ${RESERVED_SETUP_BOT_NAME} is reserved for HQ's assistant; create it with --worker ${RESERVED_SETUP_BOT_NAME}.`), { expected: true });
@@ -1274,6 +1283,27 @@ async function runBotResident(nameArg) {
     const token = botTokenSupplier(dir);
     // The bot's own schedule lives in its folder and fires from this loop.
     const api = withLocalJobs(new BotApi({ token }), dir);
+    // The built-in hot-signal-sync job, registered once in the bot's own
+    // jobs.json (06:30 daily in this computer's time zone until the owner
+    // reschedules it with `hq bot jobs`). It runs in-process, with no model turn.
+    const syncCompany = hotSignalSyncCompany(config);
+    try {
+        // A job for a company the bot no longer serves is removed before anything runs.
+        for (const stale of removeStaleHotSignalSyncJobs(dir, syncCompany)) {
+            console.log(`Removed the hot-channel sync job ${stale.jobId}: this bot no longer syncs that company.`);
+        }
+    }
+    catch (err) {
+        console.error(`Could not check the hot-channel sync jobs: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (syncCompany) {
+        try {
+            ensureHotSignalSyncJob(dir, { company: syncCompany, timezone: machineTimeZone() });
+        }
+        catch (err) {
+            console.error(`Could not register the hot-channel sync job for ${syncCompany}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     const owner = new OwnerContextCache(() => lookupOwnerContext(config.ownerUid), Date.now, undefined, config.ownerUid);
     const handle = await runBot({
         dir,
@@ -1281,6 +1311,15 @@ async function runBotResident(nameArg) {
         api,
         runtime: runtimeFor(config.runtime),
         ownerContext: () => owner.get(),
+        hotSignalSync: ({ company, catchUp, now, sendAlert }) => runHotSignalSyncJob({
+            company,
+            catchUp,
+            now,
+            sendAlert,
+            sync: (input) => runCompanyHotChannelSync({ hqRoot: config.hqRoot, ...input }),
+            // A new pass per run: the login preflight and the 20-document cap are per run.
+            signalsPass: createClaudeSignalsPass({ hqRoot: config.hqRoot, company }),
+        }),
         // US-005: decision picks in the owner DM, with the bot's own machine token
         // (never the owner's login).
         decisions: new DecisionsClient(token),
@@ -1353,14 +1392,16 @@ async function runBotStatus(nameArg, opts) {
     const status = readBotStatus(dir);
     const creds = readBotCredsIdentity(dir);
     if (opts.json) {
-        console.log(JSON.stringify({ ...row, ...(fleet ? { engine: config.engine } : {}), credsPresent: fleet || !!creds, status }, null, 2));
+        console.log(JSON.stringify({ ...row, ...(fleet ? { engine: config.engine } : {}), credsPresent: fleet || !!creds, login: describeBotAuth(dir, config), status }, null, 2));
         return;
     }
     console.log(`${chalk.bold(name)}  ${row.agentUid}`);
     if (fleet)
         console.log(`  engine:     HQ Fleet Runtime ${config.engine?.version ?? ""}  ${chalk.dim(`logs ~/.hq-fleet/profiles/${config.agentUid}/logs`)}`);
     console.log(`  kind:       ${describeKind(row.kind, row.companies)}`);
+    const login = describeBotAuth(dir, config);
     console.log(`  runtime:    ${row.runtime}  model ${row.model ?? "default"}  thinking ${row.effort}${row.effortIsDefault ? " (default)" : ""}`);
+    console.log(`  login:      ${login.login === "own" && !login.present ? chalk.red(formatBotAuth(login, name)) : formatBotAuth(login, name)}`);
     if (row.workerId)
         console.log(`  worker:     ${row.workerId}${row.companySlug ? ` (company ${row.companySlug})` : ""}  ${chalk.dim(row.workerDir)}`);
     console.log(`  memory:     ${row.memory}  ${chalk.dim(row.memoryDir)}`);
@@ -1387,7 +1428,13 @@ async function runBotStatus(nameArg, opts) {
         if (status.runtimeSignIn) {
             const tool = runtimeDisplayName(status.runtimeSignIn.runtime);
             const what = status.runtimeSignIn.state === "signed-out" ? `${tool} is not signed in for ${name}` : `${tool} needs to sign in again`;
-            console.log(`  ${chalk.yellow(what)} — sign in from HQ, or run \`${signInCommand(status.runtimeSignIn.runtime)}\`; ${name} checks again on its own`);
+            const which = login.login === "default" ? "" : ` (${formatBotAuth(login, name)})`;
+            const fix = login.login === "own"
+                ? `run \`hq bot login ${name} --runtime ${status.runtimeSignIn.runtime}\`, then \`hq bot restart ${name}\``
+                : login.login === "account"
+                    ? `run \`hq capacity login ${status.runtimeSignIn.runtime} --account ${login.account}\`, then \`hq bot restart ${name}\``
+                    : `sign in from HQ, or run \`${signInCommand(status.runtimeSignIn.runtime)}\`; ${name} checks again on its own`;
+            console.log(`  ${chalk.yellow(`${what}${which}`)} — ${fix}`);
         }
         else if (status.runtimeSignInCheck) {
             const c = status.runtimeSignInCheck;
@@ -1667,9 +1714,9 @@ async function runBotRmLocked(validated, opts) {
         console.log(chalk.dim(`  HQ did not finish: ${incomplete.steps.join(", ")}`));
     throw Object.assign(new Error(message), { expected: true });
 }
-export async function runBotSet(nameArg, opts) {
+export async function runBotSet(nameArg, opts, deps = {}) {
     const name = validateBotName(nameArg);
-    await withBotLock(name, () => runBotSetLocked(name, opts), { command: "hq bot set" });
+    await withBotLock(name, () => runBotSetLocked(name, opts, deps), { command: "hq bot set" });
 }
 /** A sentence for a refused name write: the status only, never the server's text. */
 function nameWriteRefused(name, err) {
@@ -1696,12 +1743,48 @@ function nameWriteRefused(name, err) {
         expected: true,
     });
 }
-async function runBotSetLocked(nameArg, opts) {
+const defaultSetLifecycle = {
+    isRunning: (dir) => {
+        const s = readBotStatus(dir);
+        return !!s && isPidAlive(s.pid) && s.state === "running";
+    },
+    stop: async (name, dir, config) => {
+        await stopBot(name, dir, config, "silent");
+        return waitFor(() => {
+            const s = readBotStatus(dir);
+            return !s || !isPidAlive(s.pid);
+        }, 15_000);
+    },
+    start: async (name, dir, config) => (await startBot(name, dir, config, "silent")).running,
+};
+async function runBotSetLocked(nameArg, opts, deps = {}) {
     const { name, dir, config } = requireBot(nameArg);
     if (hasPromotionHold(dir))
         throw new Error("This bot is held for cloud promotion. Continue its promotion before changing local settings or lifecycle.");
-    if (opts.model === undefined && opts.effort === undefined && opts.displayName === undefined) {
-        throw Object.assign(new Error("Nothing to change: pass --model <id|default>, --effort <level|default> and/or --display-name <name>."), { expected: true });
+    if (opts.runtime === undefined && opts.account === undefined && opts.model === undefined && opts.effort === undefined && opts.displayName === undefined) {
+        throw Object.assign(new Error("Nothing to change: pass --runtime <runtime>, --account <id|default>, --model <id|default>, --effort <level|default> and/or --display-name <name>."), { expected: true });
+    }
+    if (opts.runtime !== undefined && !isBotRuntimeId(opts.runtime)) {
+        throw Object.assign(new Error(`--runtime must be one of ${BOT_RUNTIMES.join(", ")}`), { expected: true });
+    }
+    const targetRuntime = opts.runtime ?? config.runtime;
+    const switching = targetRuntime !== config.runtime;
+    if ((switching || opts.account !== undefined) && opts.displayName !== undefined) {
+        throw Object.assign(new Error("Change --display-name on its own, not together with --runtime or --account."), { expected: true });
+    }
+    let runtimeAuth = config.runtimeAuth;
+    if (opts.account !== undefined) {
+        const id = opts.account.trim();
+        let auth = null;
+        if (id && id.toLowerCase() !== "default") {
+            // Checked now so a typo never reaches a turn.
+            capacityAccountHome(config.hqRoot, targetRuntime, id);
+            auth = { mode: "account", account: id };
+        }
+        runtimeAuth = withRuntimeAuth(runtimeAuth, targetRuntime, auth);
+    }
+    if (switching || opts.account !== undefined) {
+        return switchRuntimeOrAccount({ name, dir, config, targetRuntime, switching, runtimeAuth, opts, deps });
     }
     // Only the keys this command changes are written, onto a fresh read of
     // bot.json: the running bot writes it too (introSentAt, kickoff state), and
@@ -1778,6 +1861,174 @@ async function runBotSetLocked(nameArg, opts) {
         console.log(chalk.green(`${name} is now called ${displayName}`) + chalk.dim(`${where}${how}`));
     }
 }
+/**
+ * `hq bot set --runtime/--account`: probe the new setup first (nothing changes
+ * when it cannot answer), stop a running bot, back up bot.json and set the
+ * old runtime's session files aside, save, and start it again. A bot that does
+ * not come back is rolled back to its old settings and sessions.
+ */
+async function switchRuntimeOrAccount(input) {
+    const { name, dir, config, targetRuntime, switching, runtimeAuth, opts, deps } = input;
+    const life = deps.lifecycle ?? defaultSetLifecycle;
+    const patch = { runtime: targetRuntime, runtimeAuth };
+    // Model ids and thinking levels belong to one runtime: a switch resets what does not carry over.
+    patch.model = opts.model !== undefined ? validateBotModel(opts.model) || undefined : switching ? undefined : config.model;
+    patch.effort =
+        opts.effort !== undefined
+            ? validateBotEffort(targetRuntime, opts.effort) || undefined
+            : config.effort && BOT_EFFORT_LEVELS[targetRuntime].includes(config.effort)
+                ? config.effort
+                : undefined;
+    const candidate = { ...config, ...patch };
+    const probeEnv = botAuthEnv(dir, candidate, process.env);
+    const probe = await (deps.probe ?? probeBotRuntime)({
+        runtime: targetRuntime,
+        ...(candidate.model ? { model: candidate.model } : {}),
+        ...(candidate.effort ? { effort: candidate.effort } : {}),
+        env: probeEnv,
+    });
+    if (!probe.ok) {
+        throw Object.assign(new Error(`${name} stays on ${config.runtime}: ${probe.detail} Nothing was changed.`), { expected: true });
+    }
+    const status = readBotStatus(dir);
+    if (status && isPidAlive(status.pid) && selfStopProbe(status.pid)) {
+        throw Object.assign(new Error(`${name} cannot change its runtime or login from inside one of its own turns. Run this from outside the bot. Nothing was changed.`), { expected: true });
+    }
+    const wasRunning = life.isRunning(dir);
+    if (wasRunning && !(await life.stop(name, dir, config))) {
+        throw Object.assign(new Error(`${name} did not stop, so nothing was changed. Try again, or run hq bot stop ${name} first.`), { expected: true });
+    }
+    let aside = null;
+    // Only the settings this command changed go back, onto a fresh bot.json.
+    const rollBack = () => {
+        if (aside)
+            restoreBotSessions(dir, aside);
+        return patchBotConfig(dir, { runtime: config.runtime, runtimeAuth: config.runtimeAuth, model: config.model, effort: config.effort });
+    };
+    let next;
+    let running = false;
+    let rolledBack = false;
+    try {
+        if (switching)
+            aside = setAsideBotSessions(dir, config.runtime);
+        next = patchBotConfig(dir, patch);
+        if (wasRunning)
+            running = await life.start(name, dir, next);
+    }
+    catch (err) {
+        // Any failure part-way puts the old settings and sessions back, and the bot back up.
+        try {
+            await life.stop(name, dir, config);
+        }
+        catch { /* best effort */ }
+        const old = rollBack();
+        if (wasRunning)
+            await life.start(name, dir, old);
+        throw err;
+    }
+    const login = describeBotAuth(dir, next);
+    createBotLogger(dir)("info", `settings: runtime=${next.runtime} login=${login.login}${login.account ? ` account=${login.account}` : ""} model=${next.model ?? "default"} effort=${effectiveBotEffort(next)}${aside ? ` (sessions set aside in ${aside.archiveDir})` : ""}`);
+    if (wasRunning && !running) {
+        await life.stop(name, dir, next);
+        const old = rollBack();
+        rolledBack = true;
+        running = await life.start(name, dir, old);
+        createBotLogger(dir)("warn", `settings rolled back: ${name} did not start on ${next.runtime}`);
+    }
+    const result = {
+        ok: !rolledBack,
+        name,
+        runtime: rolledBack ? config.runtime : next.runtime,
+        previousRuntime: config.runtime,
+        login: rolledBack ? describeBotAuth(dir, config) : login,
+        model: rolledBack ? config.model ?? null : next.model ?? null,
+        effort: effectiveBotEffort(rolledBack ? config : next),
+        sessionsSetAside: aside && !rolledBack ? { dir: aside.archiveDir, files: aside.moved.length } : null,
+        backup: aside ? path.join(aside.archiveDir, "bot.json") : null,
+        running,
+        restarted: wasRunning,
+        rolledBack,
+    };
+    if (rolledBack)
+        process.exitCode = 1;
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (rolledBack) {
+        console.log(chalk.red(`${name} did not start on ${next.runtime}, so it is back on ${config.runtime} with its old sessions. Check: hq bot logs ${name}`));
+        return;
+    }
+    if (switching) {
+        console.log(chalk.green(`${name} now runs on ${next.runtime} (${formatBotAuth(login, name)}), model ${next.model ?? "default"}, thinking ${result.effort}.`));
+        console.log(chalk.dim(`  ${aside.moved.length} ${config.runtime} session file(s) set aside in ${aside.archiveDir}; DM history and memory are unchanged.`));
+    }
+    else {
+        console.log(chalk.green(`${name} now uses ${formatBotAuth(login, name)} for ${next.runtime}.`));
+    }
+    if (wasRunning)
+        console.log(chalk.dim(running ? "  restarted" : `  did not report running; check: hq bot logs ${name}`));
+}
+/** `hq bot login <name>`: sign the bot in with a login of its own. */
+export async function runBotLogin(nameArg, opts, deps = {}) {
+    const name = validateBotName(nameArg);
+    await withBotLock(name, async () => {
+        const { dir, config } = requireBot(name);
+        const runtime = opts.runtime ?? config.runtime;
+        if (!isBotLoginRuntime(runtime)) {
+            throw Object.assign(new Error(`hq bot login supports ${BOT_LOGIN_RUNTIMES.join(", ")}${opts.runtime ? "" : `; ${name} runs on ${runtime}, pass --runtime`}.`), { expected: true });
+        }
+        if (!(deps.interactive ?? process.stdin.isTTY === true)) {
+            throw Object.assign(new Error("hq bot login needs an interactive terminal: the sign-in opens in your browser."), { expected: true });
+        }
+        signInBotRuntime(dir, runtime, deps.spawn ? { spawn: deps.spawn } : {});
+        const next = patchBotConfig(dir, { runtimeAuth: withRuntimeAuth(config.runtimeAuth, runtime, { mode: "own" }) });
+        createBotLogger(dir)("info", `login: own ${runtime} login set`);
+        const login = describeBotAuth(dir, { ...next, runtime });
+        if (opts.json)
+            console.log(JSON.stringify({ ok: true, name, runtime, login }, null, 2));
+        else
+            console.log(chalk.green(`${name} now uses its own ${runtime} login${runtime === config.runtime ? " from its next message" : ` when it runs on ${runtime}`}.`));
+    }, { command: "hq bot login" });
+}
+/** `hq bot logout <name>`: sign the bot's own login out and delete it. */
+export async function runBotLogout(nameArg, opts, deps = {}) {
+    const name = validateBotName(nameArg);
+    await withBotLock(name, async () => {
+        const { dir, config } = requireBot(name);
+        if (opts.runtime !== undefined && !isBotLoginRuntime(opts.runtime)) {
+            throw Object.assign(new Error(`--runtime must be one of ${BOT_LOGIN_RUNTIMES.join(", ")}`), { expected: true });
+        }
+        const runtimes = opts.runtime ? [opts.runtime] : [...BOT_LOGIN_RUNTIMES];
+        let runtimeAuth = config.runtimeAuth;
+        const results = [];
+        for (const rt of runtimes) {
+            const r = signOutBotRuntime(dir, rt, deps.spawn ? { spawn: deps.spawn } : {});
+            results.push({ runtime: rt, ...r });
+            // A failed vendor logout keeps the folder and the setting, so the bot never drops to your login.
+            if (r.removed && botRuntimeAuth({ runtime: rt, runtimeAuth }, rt)?.mode === "own")
+                runtimeAuth = withRuntimeAuth(runtimeAuth, rt, null);
+        }
+        patchBotConfig(dir, { runtimeAuth });
+        createBotLogger(dir)("info", `logout: ${results.map((r) => `${r.runtime}=${r.removed ? "removed" : "none"}`).join(" ")}`);
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: true, name, results }, null, 2));
+            return;
+        }
+        const failed = results.filter((r) => r.vendorLogout === "failed");
+        for (const r of results) {
+            if (r.removed)
+                console.log(chalk.green(`${name}'s own ${r.runtime} login is signed out and removed.`));
+            else if (r.vendorLogout === "failed")
+                console.log(chalk.yellow(`${r.runtime} logout did not finish, so ${name}'s own ${r.runtime} login was kept. Make sure ${r.runtime} is installed, then run hq bot logout ${name} --runtime ${r.runtime} again.`));
+        }
+        if (failed.length)
+            process.exitCode = 1;
+        if (!results.some((r) => r.removed || r.vendorLogout === "failed"))
+            console.log(`${name} has no login of its own${opts.runtime ? ` for ${opts.runtime}` : ""}.`);
+        console.log(chalk.dim(`  ${name} now uses your default sign-in for ${runtimes.join(" and ")} unless an account is set (hq bot set ${name} --account <id>).`));
+    }, { command: "hq bot logout" });
+}
 /** `hq bot probe`: exit code 0 when the runtime answered, 1 when it did not. */
 export async function runBotProbe(opts, deps = {}) {
     const saved = opts.bot ? requireBot(opts.bot).config : undefined;
@@ -1795,6 +2046,7 @@ export async function runBotProbe(opts, deps = {}) {
         ...(model ? { model } : {}),
         ...(effort ? { effort } : {}),
         timeoutMs,
+        ...(opts.bot && saved ? { env: botAuthEnv(botDir(validateBotName(opts.bot)), { ...saved, runtime }, process.env) } : {}),
     });
     if (!result.ok)
         process.exitCode = 1;
@@ -2588,11 +2840,25 @@ export function registerBotCommand(program) {
     bot
         .command("set <name>")
         .description("Change the model and thinking level a bot uses (applies from its next message), or the name people see for it (saved in HQ; a running bot restarts to use it)")
+        .option("--runtime <runtime>", `Switch the model CLI: ${BOT_RUNTIMES.join("|")}. Checked with one test turn first; the old runtime's sessions are set aside (backed up), DM history and memory stay`)
+        .option("--account <id>", "Use this hq capacity account's login for the bot's runtime, or default for your own sign-in")
         .option("--model <model>", "Model id for the runtime CLI, or default for the CLI's own default")
         .option("--display-name <name>", `The name people see for the bot in HQ (up to ${BOT_DISPLAY_NAME_MAX_CHARS} chars). The handle stays <name>`)
         .option("--effort <level>", `Thinking level (claude ${BOT_EFFORT_LEVELS.claude.join("|")}; codex ${BOT_EFFORT_LEVELS.codex.join("|")}; grok ${BOT_EFFORT_LEVELS.grok.join("|")}), or default (${DEFAULT_BOT_EFFORT})`)
         .option("--json", "Print machine-readable JSON")
         .action((name, opts) => wrap(() => runBotSet(name, opts))());
+    bot
+        .command("login <name>")
+        .description("Give the bot a model login of its own, so it does not use yours: runs the runtime's own sign-in into ~/.hq/bots/<name>/auth/<runtime>")
+        .option("--runtime <runtime>", `${BOT_LOGIN_RUNTIMES.join("|")} (default: the bot's runtime)`)
+        .option("--json", "Print machine-readable JSON")
+        .action((name, opts) => wrap(() => runBotLogin(name, opts))());
+    bot
+        .command("logout <name>")
+        .description("Sign the bot's own model login out and delete it; the bot goes back to your default sign-in")
+        .option("--runtime <runtime>", `${BOT_LOGIN_RUNTIMES.join("|")} (default: both)`)
+        .option("--json", "Print machine-readable JSON")
+        .action((name, opts) => wrap(() => runBotLogout(name, opts))());
     bot
         .command("set-model <name> <model>")
         .description("Set the model this bot asks its runtime for (stored in the bot's own settings; the runtime's own config is never changed), or default to clear it")
@@ -2641,4 +2907,14 @@ export function registerBotCommand(program) {
         console.log(opts.json ? JSON.stringify({ ok: true, ...r }, null, 2) : r.message);
     })());
 }
+/**
+ * The company a bot's hot-signal-sync job syncs: the bot's own company, else
+ * the first company it serves. Null = none, and no job is registered. There is
+ * no fallback to the HQ's active company: a personal bot syncs a company only
+ * when it was given one explicitly (`--company`), so the job never writes into
+ * a vault the bot does not belong to.
+ */
+export function hotSignalSyncCompany(config) {
+    return currentHotSignalSyncCompany(config);
+}
 //# sourceMappingURL=bot.js.map

package/dist/commands/channels.d.ts

@@ -1,5 +1,5 @@
 import { Command } from "commander";
-import { type ChannelSummary } from "./dm.js";
+import { type ChannelSummary, type DmContact } from "./dm.js";
 /**
  * Human label for a channel row. Named channels (personal/company) show their
  * name + a `hq dm <slug>` hint; unnamed group DMs are identified by their
@@ -38,6 +38,23 @@ export declare function parseActiveSince(value: string, now?: number): number |
  * original order). Pure → unit-testable.
  */
 export declare function channelsByActivity<T extends ChannelWithActivity>(channels: T[], sinceMs?: number): T[];
+/**
+ * Resolve the `<member>` argument of `hq channels add|remove` to a person or
+ * agent uid. Accepts a uid (`prs_…`, `agt_…`), an email, or a display name /
+ * @handle matched against the caller's DM contacts (which include the bots the
+ * caller owns). Pure → unit-testable. Returns an error sentence on no or
+ * ambiguous match so the caller never guesses. Feedback e165b286.
+ */
+export declare function resolveMemberTarget(contacts: DmContact[], raw: string): {
+    ok: true;
+    personUid: string;
+    displayName: string;
+} | {
+    ok: false;
+    error: string;
+};
+/** The server's refusal, as one plain sentence. */
+export declare function channelMembershipError(res: Response, verb: "add" | "remove", fallback: string): Promise<string>;
 export declare function registerChannelsCommand(program: Command): void;
 export {};
 //# sourceMappingURL=channels.d.ts.map