@indigoai-us/hq-cli 5.345.194 → 5.345.195

package/CHANGELOG.md

@@ -2,6 +2,40 @@
 
 ## [Unreleased]
 
+## [5.345.195] — 2026-11-03
+- Legacy local bots now move to the HQ Fleet Runtime. A Claude bot moves on
+  its next start (`hq bot start`, `hq bot restart`, or its launchd or
+  `hq daemon` start at login): it keeps its identity, settings, worker folder
+  and scheduled jobs, its legacy runner stops, and its legacy startup agent is
+  removed. If the Fleet install fails, the bot runs on its legacy runner that
+  time and tries again at its next start. A ChatGPT or Grok bot needs its own
+  sign-in on the Fleet Runtime, so it stays on its legacy runner until the
+  owner runs `hq bot auth <name>`, which now moves it; a failed sign-in puts it
+  back on its legacy runner. Set `HQ_BOT_KEEP_LEGACY_RUNTIME=1` to keep a bot
+  on its legacy runner. `hq bot run` on a bot that already moved removes a
+  leftover legacy startup agent and exits 0 instead of failing, so launchd
+  stops relaunching it.
+- `hq-hook`: the `policy-enforcement-gate` port is now a full native port of the gate at
+  hq-core-staging 7a5677db (#1746, sha256 0a5f4849). It answers PreToolUse, PostToolUse and
+  UserPromptSubmit with the same exit code, stdout, stderr and state files as the bash gate, on
+  macOS and on Windows with Git Bash. The bridge pin moves to that version only, and the old
+  allow-only port and its fixture are removed. The port hands a call back to bash (exit 75) only
+  when the gate's `hook-lib.sh` or `session-id.sh` is not the pinned version, or a host program
+  it needs is missing. The port flag stays off.
+- `hq-hook`: in the gate port, a one-time override token is removed only once the native answer stands; a hand-back (exit 75) or a `shadow` run leaves it for bash. Under Git Bash a project root in MSYS form, or a hook bash that is not Git Bash, goes back to bash, and read receipts follow `pwd -P` spelling.
+- The native hook package release no longer reports a successful npm publish as a
+  failure. The download check now waits for npm to serve the exact new version,
+  polling every 15 seconds for up to 15 minutes, before it compares the published
+  bytes with the tested package. A re-run skips the publish when npm already has
+  that version with the same integrity, and fails with a clear message when the
+  published bytes differ.
+- Local bots now install HQ Fleet Local 0.4.21 on HQ Fleet Runtime main 24211b85.
+  The owner's own DMs run commands without approval prompts, while teammate, job
+  and email turns keep prompting unless the bot was created with `--auto-approve`.
+  A bot reads up to four HQ DM inbox items at once, so one slow request no longer
+  holds up the rest, and a restart no longer replays messages it already handled.
+  Existing Fleet bots move to 0.4.21 at their next start.
+
 ## [5.345.194] — 2026-11-03
 - Meeting and other hot-channel documents that land over the signals pass's
   20-document limit now get signals on a later run. Before this fix, a large

package/dist/commands/bot.js

@@ -1,4 +1,5 @@
 import { withLocalJobs } from "../lib/bot/local-jobs.js";
+import { fleetMoveFailurePath, fleetMoveRecentlyFailed, legacyConversionDecision, writeFleetMoveFailure } from "../lib/bot/legacy-convert.js";
 import { runSignals } from "../lib/signals/engine.js";
 import { BOT_SIGNALS_ENGINE_JOB_FLAG, signalsEngineForJob } from "../lib/bot/signals-engine-flag.js";
 import { resolveProcessFlagGate } from "../lib/flag-registry.js";
@@ -505,11 +506,14 @@ function stopProcess(dir) {
  * restore brings several bots back and its own JSON must be the only document
  * on stdout (the desktop app parses it whole).
  */
-async function startBot(name, dir, config, output, extra = {}) {
+async function startBot(name, dir, config, output, extra = {}, opts = {}) {
     if (hasPromotionHold(dir))
         throw new Error("This bot is held for cloud promotion. Continue its promotion before changing local settings or lifecycle.");
     if (isFleetRuntimeBot(config))
         return startFleetRuntimeBot(name, dir, config, output, extra);
+    const converted = opts.keepLegacy ? null : await convertLegacyBotToFleet(name, dir, config, "start");
+    if (converted)
+        return reportFleetBotStart(name, dir, converted, output, { ...extra, movedToFleet: true }, true, "started by the HQ Fleet Runtime");
     if (config.enabled === false)
         patchBotConfig(dir, { enabled: true });
     const paths = buildBotDaemonPaths({ name, botDir: dir, hqRoot: config.hqRoot });
@@ -571,6 +575,102 @@ async function startBot(name, dir, config, output, extra = {}) {
     }
     return { running, how };
 }
+/**
+ * Move a legacy bot onto the HQ Fleet Runtime under the same identity.
+ * Returns the bot's new settings, or null when it stays on the legacy runner
+ * (it needs its own sign-in, the move is turned off, or the move failed, in
+ * which case the next start tries again).
+ *
+ * bot.json switches to Fleet only after the Fleet service is installed, so a
+ * failure or a kill at any earlier step leaves a legacy bot that starts as
+ * before. Legacy jobs move and the legacy startup agent goes after that.
+ *
+ * `from: "start"` stops the legacy runner first; a failed move leaves it
+ * stopped and the caller starts it again. `from: "run"` is the legacy runner
+ * itself starting (launchd, hq daemon or a detached run), before it polls:
+ * its own startup agent is booted out last, detached.
+ */
+async function convertLegacyBotToFleet(name, dir, config, from) {
+    if (!legacyConversionDecision(config).convert || hasPromotionHold(dir))
+        return null;
+    // A launchd or daemon restart loop would otherwise retry a failing install before every start.
+    if (from === "run" && fleetMoveRecentlyFailed(dir))
+        return null;
+    if (from === "start") {
+        const running = readBotStatus(dir);
+        if (running && isPidAlive(running.pid) && selfStopProbe(running.pid))
+            return null;
+    }
+    const log = createBotLogger(dir);
+    const keepLegacy = (step, err) => {
+        writeFleetMoveFailure(dir);
+        log("warn", `could not ${step} ${name} on the HQ Fleet Runtime (${err instanceof Error ? err.message : String(err)}); it runs on ${config.runtime} this time and tries again at its next start`);
+    };
+    let engine;
+    try {
+        engine = await installFleetRuntimeProfile(name, dir, config, { force: true, keepCredentials: true });
+        if (!engine)
+            throw new Error("no HQ Fleet Local release was available");
+    }
+    catch (err) {
+        keepLegacy("install", err);
+        return null;
+    }
+    const fleet = { ...(readBotConfig(dir) ?? config), engine, enabled: true, fleetServiceInstallPending: false };
+    if (from === "start")
+        await stopBot(name, dir, config, "silent");
+    let failure = null;
+    try {
+        refreshFleetLocalInstructions(config.agentUid, fleetBotSystemPrompt(name, fleet));
+        const result = controlFleetLocalBot(config.agentUid, "install");
+        if (result.ok !== true)
+            failure = new Error(typeof result.summary === "string" ? result.summary : "the service did not install");
+    }
+    catch (err) {
+        failure = err;
+    }
+    if (failure !== null) {
+        try {
+            controlFleetLocalBot(config.agentUid, "stop");
+        }
+        catch {
+            /* nothing was running */
+        }
+        keepLegacy("start", failure);
+        return null;
+    }
+    writeBotConfig(dir, fleet);
+    fs.rmSync(fleetMoveFailurePath(dir), { force: true });
+    // The legacy runner's copy of the machine credentials goes only now: a failed move above still needs it.
+    fs.rmSync(botCredsPath(dir), { force: true });
+    log("info", `moved ${name} to the HQ Fleet Runtime under the same identity; its ${config.runtime} runner is retired`);
+    syncFleetRuntimeJobs(name, dir, fleet);
+    retireLegacyBotAgent(name, dir, config, from === "run" ? "detached" : "inline");
+    return fleet;
+}
+/** Remove a legacy bot's own startup agent once the bot runs on the HQ Fleet Runtime. True when there was one. */
+function retireLegacyBotAgent(name, dir, config, bootout) {
+    const paths = buildBotDaemonPaths({ name, botDir: dir, hqRoot: config.hqRoot });
+    if (!fs.existsSync(paths.plistPath) && !fs.existsSync(paths.systemdUnitPath))
+        return false;
+    const log = createBotLogger(dir);
+    const systemd = process.platform === "linux" && fs.existsSync(paths.systemdUnitPath);
+    if (systemd)
+        systemctlUser(["disable", path.basename(paths.systemdUnitPath)]);
+    uninstallBotDaemon(paths, { ...daemonDeps(), bootout, announce: (r) => log("info", `${r.message}: ${name} runs under the HQ Fleet Runtime service now`) });
+    if (systemd)
+        systemctlUser(["daemon-reload"]);
+    return true;
+}
+/** Best effort: the systemd user unit is an optional extra the owner may never have enabled. */
+function systemctlUser(args) {
+    try {
+        execFileSync("systemctl", ["--user", ...args], { stdio: "ignore", timeout: 10_000 });
+    }
+    catch {
+        /* not enabled, or no user systemd */
+    }
+}
 /** Start (or restart) an HQ Fleet Runtime bot under its own service, with fresh instructions. */
 async function startFleetRuntimeBot(name, dir, config, output, extra) {
     if (config.fleetAuthPending === true) {
@@ -591,7 +691,11 @@ async function startFleetRuntimeBot(name, dir, config, output, extra) {
     if (installService && result.ok)
         patchBotConfig(dir, { fleetServiceInstallPending: false, enabled: true });
     const how = alreadyRunning ? "restarted by the HQ Fleet Runtime" : "started by the HQ Fleet Runtime";
-    const running = result.ok === true && (await waitFor(() => {
+    return reportFleetBotStart(name, dir, config, output, extra, result.ok === true, how);
+}
+/** Wait for a just-started HQ Fleet gateway to report running, and print the outcome. */
+async function reportFleetBotStart(name, dir, config, output, extra, started, how) {
+    const running = started && (await waitFor(() => {
         const s = readBotStatus(dir);
         return !!s && s.state === "running" && isPidAlive(s.pid);
     }, 45_000));
@@ -609,11 +713,24 @@ async function startFleetRuntimeBot(name, dir, config, output, extra) {
     return { running, how };
 }
 async function adoptFleetRuntimeProfile(name, dir, config, opts = {}) {
+    const engine = await installFleetRuntimeProfile(name, dir, config, opts);
+    if (!engine)
+        return false;
+    patchBotConfig(dir, { engine });
+    return true;
+}
+/**
+ * Install or refresh the bot's HQ Fleet profile and return the engine it now
+ * runs, without touching bot.json. Null when nothing was installed. `force`
+ * rebuilds a profile that already matches the release (a legacy bot whose
+ * earlier move did not finish).
+ */
+async function installFleetRuntimeProfile(name, dir, config, opts = {}) {
     const target = opts.pointerOnly ? await resolveFleetLocalPointerTarget() : await resolveFleetLocalTargetRelease();
     if (!target)
-        return false;
-    if (!fleetLocalProfileNeedsAdoption(config.agentUid, { release: target.release }))
-        return false;
+        return null;
+    if (!opts.force && !fleetLocalProfileNeedsAdoption(config.agentUid, { release: target.release }))
+        return null;
     let installation;
     try {
         installation = await installTargetFleetLocalDistribution({ target });
@@ -623,11 +740,11 @@ async function adoptFleetRuntimeProfile(name, dir, config, opts = {}) {
             throw err;
         if (opts.pointerOnly) {
             createBotLogger(dir)("warn", `could not install HQ Fleet Local ${target.release.version} (${err instanceof Error ? err.message : String(err)}); the bot stays on its current release`);
-            return false;
+            return null;
         }
         createBotLogger(dir)("warn", `could not install HQ Fleet Local ${target.release.version} (${err instanceof Error ? err.message : String(err)}); staying on ${HQ_FLEET_LOCAL_RELEASE.version}`);
-        if (!fleetLocalProfileNeedsAdoption(config.agentUid, { release: HQ_FLEET_LOCAL_RELEASE }))
-            return false;
+        if (!opts.force && !fleetLocalProfileNeedsAdoption(config.agentUid, { release: HQ_FLEET_LOCAL_RELEASE }))
+            return null;
         installation = await installPinnedFleetLocalDistribution();
     }
     const python = await ensureFleetPython();
@@ -645,11 +762,10 @@ async function adoptFleetRuntimeProfile(name, dir, config, opts = {}) {
         ownerCompanies: companyScope,
         ...(config.autoApprove === true ? { autoApprove: true } : {}),
     }, { python, start: false });
-    patchBotConfig(dir, { engine: installation.engine });
     const credentials = botCredsPath(dir);
     if (fs.existsSync(credentials))
-        importFleetLocalMachineCredential(config.agentUid, credentials);
-    return true;
+        importFleetLocalMachineCredential(config.agentUid, credentials, {}, { keepSource: opts.keepCredentials === true });
+    return installation.engine;
 }
 /**
  * `output`: "json" | "text" print a result; "silent" prints nothing — used
@@ -1393,6 +1509,10 @@ async function runBotResident(nameArg) {
     const name = validateBotName(nameArg);
     const dir = botDir(name);
     const config = readBotConfig(dir);
+    // A legacy startup agent left behind after the move to Fleet: exiting
+    // non-zero would have launchd relaunch it forever. Remove it and exit 0.
+    if (config && isFleetRuntimeBot(config) && retireLegacyBotAgent(name, dir, config, "detached"))
+        return;
     if (config && isFleetRuntimeBot(config)) {
         throw Object.assign(new Error(`${name} runs on the HQ Fleet Runtime under its own background service. Use hq bot start ${name}, hq bot status ${name} or hq bot logs ${name}.`), { expected: true });
     }
@@ -1420,6 +1540,8 @@ async function runBotResident(nameArg) {
             console.log(orphanBotRunMessage(name, outcome));
         return;
     }
+    if (await convertLegacyBotToFleet(name, dir, config, "run"))
+        return;
     if (healNodePathFromJob(name, dir, config))
         return;
     const token = botTokenSupplier(dir);
@@ -2273,35 +2395,84 @@ export async function runBotRestart(nameArg, opts = {}) {
 }
 async function runBotAuth(nameArg, opts) {
     const b = requireBot(nameArg);
-    if (!isFleetRuntimeBot(b.config)) {
-        throw Object.assign(new Error(`hq bot auth is for bots created with --hq-fleet-runtime. ${b.name} uses ${b.config.runtime}.`), { expected: true });
-    }
     const apiKey = opts.apiKey ? fs.readFileSync(0, "utf8").trim() : undefined;
     if (opts.apiKey && !apiKey) {
         throw Object.assign(new Error("No API key was received on stdin."), { expected: true });
     }
-    const adopted = await adoptFleetRuntimeProfile(b.name, b.dir, b.config);
-    const result = authenticateFleetLocalBot({
-        agentUid: b.config.agentUid,
-        provider: opts.provider,
-        ...(adopted || b.config.fleetAuthPending === true ? { installService: true } : {}),
-        ...(opts.model ? { model: opts.model } : {}),
-        ...(apiKey ? { apiKey } : {}),
-        ...(opts.baseUrl ? { baseUrl: opts.baseUrl } : {}),
-        ...(opts.transport ? { transport: opts.transport } : {}),
-        openBrowser: opts.browser !== false,
-    });
+    // A legacy bot moves to the HQ Fleet Runtime as part of its sign-in. Its
+    // legacy runner stops for the sign-in and comes back if the sign-in fails.
+    const legacy = isFleetRuntimeBot(b.config) ? null : b.config;
+    if (legacy) {
+        refuseHeldFleetBot(b.dir);
+        const running = readBotStatus(b.dir);
+        if (running && isPidAlive(running.pid) && selfStopProbe(running.pid)) {
+            throw Object.assign(new Error(`${b.name} cannot move itself to the HQ Fleet Runtime from inside one of its own turns. Run hq bot auth ${b.name} --provider ${opts.provider} from outside the bot.`), { expected: true });
+        }
+    }
+    // bot.json stays legacy until the sign-in succeeds, so an interrupted sign-in leaves a legacy bot.
+    const engine = legacy ? await installFleetRuntimeProfile(b.name, b.dir, legacy, { force: true, keepCredentials: true }) : null;
+    if (legacy && !engine) {
+        throw Object.assign(new Error(`No HQ Fleet Local release could be installed for ${b.name}; it stays on ${legacy.runtime}.`), { expected: true });
+    }
+    const adopted = legacy ? true : await adoptFleetRuntimeProfile(b.name, b.dir, b.config);
+    if (legacy)
+        await stopBot(b.name, b.dir, legacy, "silent");
+    // Ctrl-C reaches the sign-in helper too; keep this process alive so the rollback below runs.
+    const keepAliveOnInterrupt = () => undefined;
+    if (legacy)
+        process.on("SIGINT", keepAliveOnInterrupt);
+    let result;
+    try {
+        result = authenticateFleetLocalBot({
+            agentUid: b.config.agentUid,
+            provider: opts.provider,
+            ...(adopted || legacy || b.config.fleetAuthPending === true ? { installService: true } : {}),
+            ...(opts.model ? { model: opts.model } : {}),
+            ...(apiKey ? { apiKey } : {}),
+            ...(opts.baseUrl ? { baseUrl: opts.baseUrl } : {}),
+            ...(opts.transport ? { transport: opts.transport } : {}),
+            openBrowser: opts.browser !== false,
+        });
+        if (result.authenticated !== true)
+            throw Object.assign(new Error("The provider has not completed sign-in."), { expected: true });
+        if (legacy && result.restarted !== true) {
+            throw Object.assign(new Error(`${b.name} signed in, but its HQ Fleet service did not start; it stays on ${legacy.runtime}. Run hq bot auth ${b.name} --provider ${opts.provider} again.`), { expected: true });
+        }
+    }
+    catch (err) {
+        if (legacy) {
+            try {
+                controlFleetLocalBot(legacy.agentUid, "stop");
+            }
+            catch {
+                /* nothing was running */
+            }
+            await startBot(b.name, b.dir, legacy, "silent", {}, { keepLegacy: true }).catch(() => undefined);
+        }
+        throw err;
+    }
+    finally {
+        if (legacy)
+            process.off("SIGINT", keepAliveOnInterrupt);
+    }
+    if (legacy && engine) {
+        const moved = { ...(readBotConfig(b.dir) ?? legacy), engine };
+        writeBotConfig(b.dir, moved);
+        fs.rmSync(botCredsPath(b.dir), { force: true });
+        createBotLogger(b.dir)("info", `moved ${b.name} to the HQ Fleet Runtime with its ${opts.provider} sign-in; its ${legacy.runtime} runner is retired`);
+        syncFleetRuntimeJobs(b.name, b.dir, moved);
+        retireLegacyBotAgent(b.name, b.dir, legacy, "inline");
+    }
     const signedInRuntime = result.runtimeProvider === "anthropic" ? "claude" : result.runtimeProvider === "xai-oauth" ? "grok" : result.runtimeProvider === "openai-codex" ? "codex" : null;
-    if (result.authenticated !== true)
-        throw Object.assign(new Error("The provider has not completed sign-in."), { expected: true });
+    const pending = b.config.fleetAuthPending === true || legacy !== null;
     patchBotConfig(b.dir, {
         ...(signedInRuntime ? { runtime: signedInRuntime } : {}),
         model: result.model,
-        ...(b.config.fleetAuthPending === true ? { fleetAuthPending: false, fleetServiceInstallPending: !result.restarted, enabled: result.restarted } : {}),
+        ...(pending ? { fleetAuthPending: false, fleetServiceInstallPending: !result.restarted, enabled: result.restarted } : {}),
     });
     const running = await fleetGatewayComesUp(b.config.agentUid, result.restarted ? fleetStartWaitMs() : 0);
     if (opts.json) {
-        console.log(JSON.stringify({ ok: true, name: b.name, runtime: HQ_FLEET_RUNTIME_ENGINE_ID, ...result, needsSignIn: false, running, serviceInstallPending: b.config.fleetAuthPending === true && !result.restarted }, null, 2));
+        console.log(JSON.stringify({ ok: true, name: b.name, runtime: HQ_FLEET_RUNTIME_ENGINE_ID, ...result, needsSignIn: false, running, serviceInstallPending: pending && !result.restarted, ...(legacy ? { movedToFleet: true } : {}) }, null, 2));
         return;
     }
     console.log(running

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

@@ -324,7 +324,9 @@ export declare function pipeInheritedStdio(stdio: unknown): {
  */
 export declare function windowsExtractionPathProblem(destination: string, longest: number, longPathsEnabled: number | null): string | null;
 /** Moves a fresh machine credential into the bot's secure store and deletes the file. */
-export declare function importFleetLocalMachineCredential(agentUid: string, machineCredentials: string, deps?: FleetLocalControlDeps): void;
+export declare function importFleetLocalMachineCredential(agentUid: string, machineCredentials: string, deps?: FleetLocalControlDeps, opts?: {
+    keepSource?: boolean;
+}): void;
 export declare function bootstrapFleetLocalBot(input: FleetLocalProfileInput & {
     machineCredentials?: string;
 }, deps?: FleetLocalBootstrapDeps): Promise<FleetLocalBootstrapResult>;

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

@@ -79,15 +79,15 @@ export function sharedRuntimeLayout(root, id, platform) {
 }
 export const HQ_FLEET_LOCAL_RELEASE = {
     repository: "indigoai-us/hq-fleet-local",
-    tag: "v0.4.20",
-    version: "0.4.20",
-    artifact: "hq-fleet-local-0.4.20.zip",
-    artifactSha256: "5c49402f17408f3eaf99d27b3c2d4d0f59a24f33946aa8dfc3098a3d09e13798",
-    runtimeArtifact: "hq-fleet-runtime-abccac13bd9e.tar",
-    runtimeArtifactSha256: "29bcfe718ad7fbd3636afd00623772f2a25bc84c4f6f10d8d57f38e549d528d5",
-    manifestSha256: "3cec47eb7f47af13e66d4ad29669d3c103e1ca452661f5eaad760243118ce214",
-    signatureSha256: "5504c3a956f36d148f3cdf2212a9b171d852098c82eb199c7c415ad3545e3b05",
-    runtimeCommit: "abccac13bd9ea593b24c8cd9c0ba28d5c6050cc9",
+    tag: "v0.4.21",
+    version: "0.4.21",
+    artifact: "hq-fleet-local-0.4.21.zip",
+    artifactSha256: "24162dcc733fdc4a8e7a3482f5b2c445f5b6af96acf1695dd7dc5c7803272e3f",
+    runtimeArtifact: "hq-fleet-runtime-24211b85a414.tar",
+    runtimeArtifactSha256: "9084d88147bc9d70052aa00cc963eec2f80525bf61539d22abf45497712bd8b2",
+    manifestSha256: "5b52bd4f071470941ab1cd9a4f6baf614179f70073f60bfdf63f8a7ba38aa7ad",
+    signatureSha256: "85c35d5b2ca365503c408cd83a6d19758382f2e3049840fa055860e6f2d21746",
+    runtimeCommit: "24211b85a414441bac6405d862b1c872b44a78a1",
 };
 /** hq-fleet-local trust/release-public.pem (rotated 2026-10-30; signed v0.4.17). */
 export const HQ_FLEET_LOCAL_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
@@ -1585,7 +1585,7 @@ function assertWindowsExtractionFits(run, python, archive, destination) {
         throw expectedError(problem);
 }
 /** Moves a fresh machine credential into the bot's secure store and deletes the file. */
-export function importFleetLocalMachineCredential(agentUid, machineCredentials, deps = {}) {
+export function importFleetLocalMachineCredential(agentUid, machineCredentials, deps = {}, opts = {}) {
     const run = deps.run ?? execFileSync;
     const files = fleetLocalExecutables(agentUid, deps);
     const machineValue = fs.readFileSync(machineCredentials, "utf8").trim();
@@ -1600,7 +1600,8 @@ export function importFleetLocalMachineCredential(agentUid, machineCredentials,
         "--bot-id",
         agentUid,
     ], { input: machineValue, stdio: ["pipe", "ignore", "pipe"] }, "machine credential import");
-    fs.rmSync(machineCredentials, { force: true });
+    if (!opts.keepSource)
+        fs.rmSync(machineCredentials, { force: true });
 }
 async function installSharedFleetRuntime(installation, root, python, platform, run, spawn) {
     const identity = digest(Buffer.from(JSON.stringify({

package/dist/lib/bot/legacy-convert.d.ts

@@ -0,0 +1,15 @@
+import { type BotConfig } from "./config.js";
+export declare const KEEP_LEGACY_RUNTIME_ENV = "HQ_BOT_KEEP_LEGACY_RUNTIME";
+export type LegacyConversionDecision = {
+    convert: true;
+} | {
+    convert: false;
+    reason: "already-fleet" | "kept-by-env" | "needs-sign-in" | "own-claude-account";
+};
+export declare function legacyConversionDecision(config: Pick<BotConfig, "engine" | "runtime" | "runtimeAuth">, env?: NodeJS.ProcessEnv): LegacyConversionDecision;
+/** How long a legacy runner's own start skips the move after one failed. */
+export declare const FLEET_MOVE_RETRY_MS: number;
+export declare function fleetMoveFailurePath(dir: string): string;
+export declare function writeFleetMoveFailure(dir: string, now?: Date): void;
+export declare function fleetMoveRecentlyFailed(dir: string, now?: number): boolean;
+//# sourceMappingURL=legacy-convert.d.ts.map

package/dist/lib/bot/legacy-convert.js

@@ -0,0 +1,38 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { HQ_FLEET_RUNTIME_ENGINE_ID } from "./config.js";
+export const KEEP_LEGACY_RUNTIME_ENV = "HQ_BOT_KEEP_LEGACY_RUNTIME";
+export function legacyConversionDecision(config, env = process.env) {
+    if (config.engine?.id === HQ_FLEET_RUNTIME_ENGINE_ID)
+        return { convert: false, reason: "already-fleet" };
+    if (env[KEEP_LEGACY_RUNTIME_ENV] === "1")
+        return { convert: false, reason: "kept-by-env" };
+    if (config.runtime !== "claude")
+        return { convert: false, reason: "needs-sign-in" };
+    if (config.runtimeAuth?.claude)
+        return { convert: false, reason: "own-claude-account" };
+    return { convert: true };
+}
+/** How long a legacy runner's own start skips the move after one failed. */
+export const FLEET_MOVE_RETRY_MS = 60 * 60 * 1000;
+export function fleetMoveFailurePath(dir) {
+    return path.join(dir, "fleet-move-failed.json");
+}
+export function writeFleetMoveFailure(dir, now = new Date()) {
+    try {
+        fs.writeFileSync(fleetMoveFailurePath(dir), JSON.stringify({ at: now.toISOString() }) + "\n", { mode: 0o600 });
+    }
+    catch {
+        /* the next start just tries again */
+    }
+}
+export function fleetMoveRecentlyFailed(dir, now = Date.now()) {
+    try {
+        const at = Date.parse(JSON.parse(fs.readFileSync(fleetMoveFailurePath(dir), "utf8")).at ?? "");
+        return Number.isFinite(at) && now - at < FLEET_MOVE_RETRY_MS;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=legacy-convert.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.345.194",
+  "version": "5.345.195",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {
@@ -114,11 +114,11 @@
     "*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}": "eslint --cache --no-error-on-unmatched-pattern"
   },
   "optionalDependencies": {
-    "@indigoai-us/hq-hook-win32-x64": "5.345.194",
-    "@indigoai-us/hq-hook-win32-arm64": "5.345.194",
-    "@indigoai-us/hq-hook-darwin-x64": "5.345.194",
-    "@indigoai-us/hq-hook-darwin-arm64": "5.345.194",
-    "@indigoai-us/hq-hook-linux-x64": "5.345.194",
-    "@indigoai-us/hq-hook-linux-arm64": "5.345.194"
+    "@indigoai-us/hq-hook-win32-x64": "5.345.195",
+    "@indigoai-us/hq-hook-win32-arm64": "5.345.195",
+    "@indigoai-us/hq-hook-darwin-x64": "5.345.195",
+    "@indigoai-us/hq-hook-darwin-arm64": "5.345.195",
+    "@indigoai-us/hq-hook-linux-x64": "5.345.195",
+    "@indigoai-us/hq-hook-linux-arm64": "5.345.195"
   }
 }