@indigoai-us/hq-cli 5.222.0 → 5.224.0

package/dist/commands/lanes.js

@@ -15,6 +15,7 @@ import { Option } from "commander";
 import { registerOutpostPrunerCommand } from "./outpost-pruner.js";
 import { registerLaneChecksCommand } from "./lanes-checks.js";
 import { registerLaneReportCommands } from "./lanes-report.js";
+import { registerLaneTrackerImportCommand } from "./lanes-import.js";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
@@ -42,7 +43,7 @@ import { effectiveAccountHome } from "../lib/lanes/account-home.js";
 import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, createQuestion, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, hireGrantCapacityError, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseLivenessState, parseQuestionRecord, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, runReconcilePass, wakeAnsweredLaneNow, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withAllLaneAdmissionLocks, withLaneHireLocks, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
 import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
 import { resolveLaneKeepAlive } from "../lib/lanes/profile.js";
-import { keepAliveExclusion, loadRetiredLaneIds, } from "../lib/lanes/keep-alive.js";
+import { keepAliveExclusion, LEAD_LANE_KEEP_ALIVE_FLAG, loadRetiredLaneIds, } from "../lib/lanes/keep-alive.js";
 import { questionBodyAbsPath, resolveQuestionCompanyWithFallback, resolveProjectQuestionCompany, } from "../lib/lanes/questions.js";
 import { assertQuestionBodySecretSafe } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
@@ -1262,10 +1263,75 @@ function resolveMonitorEngine(requested, env) {
 }
 async function runWatch(ctx, laneIds, opts) {
     const rawInterval = opts.intervalMs === undefined ? undefined : Number(opts.intervalMs);
-    await runLaneWatch(ctx.hqRoot(), laneIds, {
+    const hqRoot = ctx.hqRoot();
+    await runLaneWatch(hqRoot, laneIds, {
         intervalMs: rawInterval,
         sleep: ctx.sleep,
+        keepAliveEnabled: (lane) => readLanesRegistryFlag(LEAD_LANE_KEEP_ALIVE_FLAG, {
+            company: lane.company,
+            env: ctx.env,
+        }),
+        readAccountStatuses: async (lanes) => {
+            if (lanes.length === 0)
+                return [];
+            const config = loadLanesConfig(hqRoot);
+            const currentHost = laneHostFromCtx(ctx);
+            const currentHostname = ctx.hostname().trim();
+            const isCurrentHost = (host) => (host.kind === currentHost.kind && host.id === currentHost.id) ||
+                (host.kind === "local" && host.id === currentHostname);
+            const remoteOutpostIds = [...new Set(lanes
+                    .filter((lane) => lane.host.kind === "outpost" && !isCurrentHost(lane.host))
+                    .map((lane) => lane.host.id))];
+            const remoteOutposts = await Promise.all(remoteOutpostIds.map(async (id) => [id, await readOutpostCapacity(ctx, id)]));
+            const outpostSnapshots = new Map(remoteOutposts);
+            const remoteLocalLanes = lanes.filter((lane) => lane.host.kind === "local" && !isCurrentHost(lane.host));
+            const remoteLocalHosts = remoteLocalLanes.length > 0
+                ? await loadClaudeBalanceHostSnapshots(ctx, hqRoot, config)
+                : undefined;
+            const localStatusCache = new Map();
+            return lanes.map((lane) => {
+                if (config.providers[lane.provider].accounts[lane.account] === undefined) {
+                    throw new LanesError("watch_account_unconfigured", `Lane ${lane.lane_id} records unconfigured ${lane.provider} account ${lane.account}`, { lane_id: lane.lane_id, provider: lane.provider, account: lane.account, host: lane.host });
+                }
+                let loggedIn;
+                if (isCurrentHost(lane.host)) {
+                    const key = JSON.stringify([lane.provider, lane.account, currentHost.kind, currentHost.id]);
+                    if (!localStatusCache.has(key)) {
+                        localStatusCache.set(key, accountStatus(lane.provider, lane.account, config, {
+                            existsSync: ctx.existsSync,
+                            probe: ctx.probeProvider,
+                            env: ctx.env,
+                            hostname: currentHostname,
+                        }).logged_in);
+                    }
+                    loggedIn = localStatusCache.get(key);
+                }
+                else if (lane.host.kind === "outpost") {
+                    loggedIn = outpostSnapshots.get(lane.host.id)?.providers[lane.provider].accounts[lane.account]?.logged_in;
+                }
+                else {
+                    const snapshot = remoteLocalHosts?.snapshots.find((candidate) => candidate.capacity.host.kind === lane.host.kind &&
+                        candidate.capacity.host.id === lane.host.id);
+                    if (!snapshot) {
+                        const gap = remoteLocalHosts?.unavailableHosts.find((candidate) => candidate.host.kind === lane.host.kind && candidate.host.id === lane.host.id);
+                        throw new LanesError("watch_account_host_unavailable", `Cannot check ${lane.provider} account ${lane.account} on ${lane.host.kind}:${lane.host.id}${gap ? `: ${gap.reason}` : ""}`, { lane_id: lane.lane_id, provider: lane.provider, account: lane.account, host: lane.host });
+                    }
+                    loggedIn = snapshot.capacity.providers[lane.provider].accounts[lane.account]?.logged_in;
+                }
+                if (loggedIn === undefined) {
+                    throw new LanesError("watch_account_unconfigured", `Lane ${lane.lane_id} records unconfigured ${lane.provider} account ${lane.account} on ${lane.host.kind}:${lane.host.id}`, { lane_id: lane.lane_id, provider: lane.provider, account: lane.account, host: lane.host });
+                }
+                return {
+                    lane_id: lane.lane_id,
+                    provider: lane.provider,
+                    account: lane.account,
+                    host: lane.host,
+                    logged_in: loggedIn,
+                };
+            });
+        },
         writeLine: (line) => console.log(opts.json ? JSON.stringify({ event: line }) : line),
+        writeAccountEvent: (event) => console.log(opts.json ? JSON.stringify(event) : `account_logged_out provider=${event.provider} account=${event.account} host=${event.host.kind}:${event.host.id} lane_ids=${event.lane_ids.join(",")}`),
         writeError: (line) => process.stderr.write(`${line}\n`),
     });
     return 0;
@@ -5002,7 +5068,8 @@ function resolveResumeProfile(ctx, lane, workerId) {
 function validateResumeProfileModel(ctx, lane, profile) {
     if (profile.meta.provider !== lane.provider ||
         profile.meta.model === undefined ||
-        lane.model_source === "cli") {
+        lane.model_source === "cli" ||
+        lane.model_source === "preserved") {
         return;
     }
     const hqRoot = ctx.hqRoot();
@@ -5036,7 +5103,7 @@ function applyResumeProfileAndEffort(current, next, input) {
                 : undefined;
             next.keep_alive_blocked_reason = undefined;
         }
-        if (next.model_source !== "cli") {
+        if (next.model_source !== "cli" && next.model_source !== "preserved") {
             if (profile.meta.provider === current.provider && profile.meta.model !== undefined) {
                 next.model = profile.meta.model;
                 next.model_source = "profile";
@@ -5130,7 +5197,7 @@ function resolveResumeEffort(ctx, lane, input) {
         ? undefined
         : providerConfig.accounts[accountId];
     const profileDefaultsApply = input.profile?.profile.meta.provider === lane.provider;
-    const pinnedModel = lane.model_source === undefined || lane.model_source === "cli"
+    const pinnedModel = lane.model_source === undefined || lane.model_source === "cli" || lane.model_source === "preserved"
         ? lane.model
         : undefined;
     const model = resolveLaneModel({
@@ -5225,11 +5292,11 @@ async function prepareAccountMove(ctx, lane, input) {
         ? loadWorkerProfile(hqRoot, lane.worker_profile)
         : undefined);
     const profileDefaultsApply = profile !== undefined && profile.meta.provider === lane.provider;
-    const pinnedModel = input.workerProfile !== undefined
-        ? lane.model_source === "cli" ? lane.model : undefined
-        : lane.model_source === undefined || lane.model_source === "cli"
+    const pinnedModel = input.preservedModel ?? (input.workerProfile !== undefined
+        ? lane.model_source === "cli" || lane.model_source === "preserved" ? lane.model : undefined
+        : lane.model_source === undefined || lane.model_source === "cli" || lane.model_source === "preserved"
             ? lane.model
-            : undefined;
+            : undefined);
     const profileModel = profileDefaultsApply ? profile?.meta.model : undefined;
     if (input.cliModel === undefined && profileDefaultsApply && profileModel !== undefined && pinnedModel === undefined) {
         validateProfileLaneModel(lane.provider, profileModel, targetHome, profile.id, {
@@ -5313,12 +5380,14 @@ async function prepareAccountMove(ctx, lane, input) {
                 provider_session_id_absent: undefined,
                 ...(input.cliModel !== undefined
                     ? { model: input.cliModel, model_source: "cli" }
-                    : {}),
+                    : input.preservedModel !== undefined
+                        ? { model: input.preservedModel, model_source: "preserved" }
+                        : {}),
                 account_history: appendCappedHistory(current.account_history ?? [], {
                     from,
                     to: target,
                     at,
-                    reason: SESSION_MOVE_REASON,
+                    reason: input.accountHistoryReason ?? SESSION_MOVE_REASON,
                 }),
                 pending_resume: input.deferTurnStart
                     ? undefined
@@ -5345,31 +5414,39 @@ async function prepareAccountMove(ctx, lane, input) {
         return { lane: moved, from, to: target, copy, queued };
     }, ctx.sleep);
 }
-async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile) {
+async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile, options = {}) {
     if (lane.provider !== "claude")
         return undefined;
-    if (!await ctx.laneClaudeAccountBalanceEnabled(lane.company)) {
+    const balanceEnabled = await ctx.laneClaudeAccountBalanceEnabled(lane.company);
+    const hqRoot = ctx.hqRoot();
+    const config = loadLanesConfig(hqRoot);
+    const currentConfig = lane.account === undefined
+        ? undefined
+        : config.providers.claude.accounts[lane.account];
+    const currentLogin = lane.account === undefined || currentConfig === undefined
+        ? false
+        : accountStatus("claude", lane.account, config, {
+            existsSync: ctx.existsSync,
+            hostname: ctx.hostname(),
+            probe: ctx.probeProvider,
+            env: ctx.env,
+        }).logged_in;
+    const accountNeedsRepair = lane.account !== undefined &&
+        (currentConfig?.enabled !== true || currentLogin === false);
+    const repairUnavailableAccount = options.repairUnavailableAccount === true && accountNeedsRepair;
+    if (!balanceEnabled && !(options.repairUnavailableAccount && accountNeedsRepair)) {
         if (lane.account === undefined)
             return undefined;
-        const config = loadLanesConfig(ctx.hqRoot());
-        const currentConfig = config.providers.claude.accounts[lane.account];
         if (currentConfig === undefined || !currentConfig.enabled) {
             throw new AccountResolutionError(currentConfig === undefined ? "unknown_account" : "account_disabled", currentConfig === undefined
                 ? `Lane ${lane.lane_id} records account ${JSON.stringify(lane.account)} which is not configured for claude`
                 : `Account ${JSON.stringify(lane.account)} is unavailable for claude`, { provider: "claude", account: lane.account });
         }
-        if (accountStatus("claude", lane.account, config, {
-            existsSync: ctx.existsSync,
-            hostname: ctx.hostname(),
-            probe: ctx.probeProvider,
-            env: ctx.env,
-        }).logged_in === false) {
+        if (currentLogin === false) {
             throw new LanesError("account_not_logged_in", `Account ${lane.account} for claude is not logged in`, { provider: "claude", account: lane.account, lane_id: lane.lane_id });
         }
         return undefined;
     }
-    const hqRoot = ctx.hqRoot();
-    const config = loadLanesConfig(hqRoot);
     const profile = workerProfile?.profile ?? (lane.worker_profile !== undefined
         ? loadWorkerProfile(hqRoot, lane.worker_profile)
         : undefined);
@@ -5380,33 +5457,45 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile) {
     const allowedAccounts = profilePin !== undefined && lane.admission_accounts !== undefined
         ? profilePin.filter((account) => lane.admission_accounts.includes(account))
         : profilePin ?? lane.admission_accounts;
-    const currentConfig = lane.account === undefined
-        ? undefined
-        : config.providers.claude.accounts[lane.account];
-    const currentLogin = lane.account === undefined || currentConfig === undefined
-        ? false
-        : accountStatus("claude", lane.account, config, {
-            existsSync: ctx.existsSync,
-            hostname: ctx.hostname(),
-            probe: ctx.probeProvider,
-            env: ctx.env,
-        }).logged_in;
     const pinnedModel = workerProfile !== undefined
-        ? lane.model_source === "cli" ? lane.model : undefined
-        : lane.model_source === undefined || lane.model_source === "cli"
+        ? lane.model_source === "cli" || lane.model_source === "preserved" ? lane.model : undefined
+        : lane.model_source === undefined || lane.model_source === "cli" || lane.model_source === "preserved"
             ? lane.model
             : undefined;
+    const preservedModel = repairUnavailableAccount && lane.model_source === "account"
+        ? lane.model ?? currentConfig?.model
+        : undefined;
     const model = resolveLaneModel({
-        cliModel: pinnedModel,
+        cliModel: preservedModel ?? pinnedModel,
         profileModel: profileDefaultsApply ? profile?.meta.model : undefined,
         accountModel: lane.account === undefined ? undefined : config.providers.claude.accounts[lane.account]?.model,
         providerModel: config.providers.claude.model,
     });
-    const accountNeedsRepair = currentConfig?.enabled !== true || currentLogin === false;
     const mayRebalance = BALANCE_MOVABLE_STATES.includes(lane.state);
     if (!accountNeedsRepair && !mayRebalance)
         return undefined;
-    const balanceHosts = await loadClaudeBalanceHostSnapshots(ctx, hqRoot, config);
+    const balanceHosts = balanceEnabled
+        ? await loadClaudeBalanceHostSnapshots(ctx, hqRoot, config)
+        : (() => {
+            const lanes = loadAllLanes(hqRoot).filter((candidate) => candidate.host.kind === lane.host.kind && candidate.host.id === lane.host.id);
+            return {
+                snapshots: [{
+                        capacity: buildHostCapacitySnapshot({
+                            host: lane.host,
+                            lanes,
+                            config,
+                            existsSync: ctx.existsSync,
+                            probe: ctx.probeProvider,
+                            env: ctx.env,
+                            hostname: ctx.hostname(),
+                            now: ctx.now(),
+                        }),
+                        lanes,
+                        laneListAvailable: true,
+                    }],
+                unavailableHosts: [],
+            };
+        })();
     const targetHost = balanceHosts.snapshots.find((host) => host.capacity.host.kind === lane.host.kind && host.capacity.host.id === lane.host.id);
     const currentTargetAccount = lane.account === undefined
         ? undefined
@@ -5423,11 +5512,15 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile) {
         hosts: balanceHosts.snapshots,
         targetHost: lane.host,
         config,
-        ...(allowedAccounts !== undefined ? { allowedAccounts } : {}),
+        ...(!repairUnavailableAccount && allowedAccounts !== undefined ? { allowedAccounts } : {}),
         ...(model !== undefined ? { model } : {}),
         unavailableHosts: balanceHosts.unavailableHosts,
     });
-    return { ...selected, selected_at: ctx.now().toISOString() };
+    return {
+        selection: { ...selected, selected_at: ctx.now().toISOString() },
+        ...(repairUnavailableAccount ? { historyReason: "recorded_account_logged_out" } : {}),
+        ...(preservedModel !== undefined ? { preservedModel } : {}),
+    };
 }
 function accountRequestKeepsCurrentLane(lane, rawAccount) {
     const raw = rawAccount.trim();
@@ -5525,7 +5618,7 @@ async function runMessage(ctx, laneId, opts) {
     const resumeEffort = resolveResumeEffort(ctx, lane, {
         cliEffort,
         profile: resumeProfile,
-        account: keepCurrentAccount ? lane.account : opts.account ?? automaticAccountSelection?.account,
+        account: keepCurrentAccount ? lane.account : opts.account ?? automaticAccountSelection?.selection.account,
         model: opts.model,
     });
     const messageId = mintMessageId();
@@ -5585,12 +5678,14 @@ async function runMessage(ctx, laneId, opts) {
         }
     }
     else if (mechanism === "resume") {
-        const selection = automaticAccountSelection;
-        if (selection !== undefined) {
+        const automatic = automaticAccountSelection;
+        if (automatic !== undefined) {
+            const selection = automatic.selection;
             if (selection.account !== lane.account) {
                 move = await prepareAccountMove(ctx, lane, {
                     account: selection.account,
                     cliModel: undefined,
+                    ...(automatic.historyReason !== undefined ? { accountHistoryReason: automatic.historyReason } : {}),
                     ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
                     ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                     pending: {
@@ -6063,12 +6158,12 @@ async function runResume(ctx, laneId, opts) {
         validateResumeProfileModel(ctx, lane, resumeProfile.profile);
     }
     const automaticAccountSelection = opts.account === undefined
-        ? await selectAutomaticClaudeResumeAccount(ctx, lane, resumeProfile)
+        ? await selectAutomaticClaudeResumeAccount(ctx, lane, resumeProfile, { repairUnavailableAccount: true })
         : undefined;
     const resumeEffort = resolveResumeEffort(ctx, lane, {
         cliEffort,
         profile: resumeProfile,
-        account: keepCurrentAccount ? lane.account : opts.account ?? automaticAccountSelection?.account,
+        account: keepCurrentAccount ? lane.account : opts.account ?? automaticAccountSelection?.selection.account,
         model: opts.model,
     });
     let move = null;
@@ -6089,10 +6184,17 @@ async function runResume(ctx, laneId, opts) {
         lane = move.lane;
     }
     else if (automaticAccountSelection !== undefined) {
-        if (automaticAccountSelection.account !== lane.account) {
+        const selection = automaticAccountSelection.selection;
+        if (selection.account !== lane.account) {
             move = await prepareAccountMove(ctx, lane, {
-                account: automaticAccountSelection.account,
+                account: selection.account,
                 cliModel: undefined,
+                ...(automaticAccountSelection.historyReason !== undefined
+                    ? { accountHistoryReason: automaticAccountSelection.historyReason }
+                    : {}),
+                ...(automaticAccountSelection.preservedModel !== undefined
+                    ? { preservedModel: automaticAccountSelection.preservedModel }
+                    : {}),
                 ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
                 ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                 pending: {
@@ -6102,12 +6204,12 @@ async function runResume(ctx, laneId, opts) {
                     ...(messageId !== undefined ? { message_id: messageId } : {}),
                     compact: opts.compact !== false,
                 },
-                accountSelection: automaticAccountSelection,
+                accountSelection: selection,
             });
             lane = move.lane;
         }
         else {
-            lane = persistClaudeAccountSelection(hqRoot, lane, automaticAccountSelection);
+            lane = persistClaudeAccountSelection(hqRoot, lane, selection);
         }
     }
     lane = recordResumeSetup(ctx, lane, {
@@ -8412,6 +8514,11 @@ async function runReconcile(ctx, opts) {
         dryRun: Boolean(opts.dryRun),
         spawnLaneDeps: {
             env: ctx.env,
+            modelDeps: {
+                readFileSync: ctx.readFileSync,
+                probe: ctx.probeProvider,
+                env: ctx.env,
+            },
             existsSync: ctx.existsSync,
             spawnProcess: ctx.spawnProcess,
             proveDetached: ctx.proveDetached,
@@ -8505,6 +8612,13 @@ export function registerLanesCommand(parent, deps = {}) {
         now: ctx.now,
         actor: ctx.trackerActor,
     }, wrap);
+    registerLaneTrackerImportCommand(lanes, {
+        hqRoot: ctx.hqRoot,
+        resolveCompany: ctx.resolveCompany,
+        trackerEnabled: ctx.laneTrackerEnabled,
+        trackerMeshEnabled: ctx.laneTrackerMeshEnabled,
+        now: ctx.now,
+    }, wrap);
     registerLaneChecksCommand(lanes, {
         hqRoot: ctx.hqRoot,
         resolveCompany: ctx.resolveCompany,

package/dist/lib/daemon/hq-cloud.d.ts

@@ -14,6 +14,8 @@ export interface HqCloudCopy {
 }
 export interface PickedHqCloud extends HqCloudCopy {
     source: "bundled" | "managed";
+    /** Set when a version is pinned but that version is not the installed managed copy. */
+    pinnedVersionMissing?: string;
 }
 export declare function managedHqCloudDir(daemonRoot: string): string;
 /** The package folder inside the updater's install prefix. */

package/dist/lib/daemon/hq-cloud.js

@@ -44,8 +44,14 @@ export function pickHqCloud(bundled, managed, usable = () => true, pinnedVersion
         if (managed && managed.version === pinnedVersion && b && m && m[0] === b[0] && usable(managed)) {
             return { ...managed, source: "managed" };
         }
-        return { ...bundled, source: "bundled" };
+        // The pinned version is not installed yet (the updater installs it). Keep
+        // running the newest usable copy meanwhile instead of dropping to an older
+        // bundled one, and report the missing pin.
+        return { ...pickNewest(bundled, managed, b, m, usable), pinnedVersionMissing: pinnedVersion };
     }
+    return pickNewest(bundled, managed, b, m, usable);
+}
+function pickNewest(bundled, managed, b, m, usable) {
     if (managed && b && m && m[0] === b[0] && newer(m, b) && usable(managed))
         return { ...managed, source: "managed" };
     return { ...bundled, source: "bundled" };

package/dist/lib/daemon/run.js

@@ -243,6 +243,7 @@ export async function runDaemon(opts) {
         }
         return legacyCache.units;
     };
+    let warnedMissingPin = null;
     const plan = () => {
         const config = readDaemonConfig(paths.configPath);
         const legacy = legacyUnits();
@@ -250,6 +251,13 @@ export async function runDaemon(opts) {
         const hqRoot = configured && fs.existsSync(configured) ? configured : undefined;
         // Re-picked every reconcile, so a newer hq-cloud from the updater is used as soon as it lands.
         const hqCloud = currentHqCloud(paths.root);
+        const missingPin = hqCloud?.pinnedVersionMissing ?? null;
+        if (missingPin !== warnedMissingPin) {
+            warnedMissingPin = missingPin;
+            if (missingPin && hqCloud) {
+                log("warn", `hq-cloud is pinned to ${missingPin}, which is not installed; running ${hqCloud.version} (${hqCloud.source}) until the updater installs it`);
+            }
+        }
         const runners = hqCloud ? hqCloudRunners(hqCloud.root) : { syncRunner: null, heartbeat: null, sessionHost: null };
         return planUnits(enabledServices(machineType, config), {
             machineType,

package/dist/lib/lanes/reconcile.js

@@ -329,7 +329,7 @@ function availableBalancedAccount(hqRoot, lane, occupying, config, host, profile
     if (laneAdmissionCapReason(occupying, lane, config, host, profileMaxConcurrent, nowMs) !== "account_cap") {
         return undefined;
     }
-    const pinnedModel = lane.model_source === undefined || lane.model_source === "cli"
+    const pinnedModel = lane.model_source === undefined || lane.model_source === "cli" || lane.model_source === "preserved"
         ? lane.model
         : lane.model_source === "profile"
             ? lane.model

package/dist/lib/lanes/spawn.js

@@ -14,6 +14,8 @@ import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { PROVIDER_HOME_ENV, accountStatus, isLoggedOut, resolveAccount, selectBalancedAccount, } from "./accounts.js";
 import { effectiveAccountHome } from "./account-home.js";
+import { buildHostCapacitySnapshot } from "./host-capacity.js";
+import { selectClaudeAccount } from "./claude-account-balance.js";
 import { COMPACTION_PROMPT, compactionAfterUsage, compactionDue, compactLaneSession, } from "./compaction.js";
 import { installDrainHook } from "./hooks-install.js";
 import { loadLanesConfig, providerAutoCompactTokens, providerCompactAfterMs, } from "./config.js";
@@ -159,7 +161,7 @@ function spawnModelFailure(provider, accountId, config, pinnedModel, profileMode
     }
 }
 function selectSpawnAccount(input) {
-    const { hqRoot, lane, config, existsSync, accountDeps, modelDeps, pinnedModel, profileModel, currentModelValidated, hostname } = input;
+    const { hqRoot, lane, config, existsSync, accountDeps, modelDeps, pinnedModel, profileModel, currentModelValidated, hostname, repairRecordedAccount, recordedModel, now } = input;
     const context = {
         hqRoot,
         existsSync,
@@ -187,7 +189,7 @@ function selectSpawnAccount(input) {
     const operatorMovePending = lane.pending_resume !== undefined &&
         lane.account_history?.at(-1)?.reason === "operator_move";
     if (current === undefined || !current.enabled) {
-        reason = "account_unavailable";
+        reason = repairRecordedAccount ? "recorded_account_logged_out" : "account_unavailable";
         refusal = new AccountResolutionError(current === undefined ? "unknown_account" : "account_disabled", `Account ${JSON.stringify(lane.account)} is unavailable for ${lane.provider}`, { provider: lane.provider, account: lane.account });
     }
     else {
@@ -198,7 +200,7 @@ function selectSpawnAccount(input) {
             ...(accountDeps?.env ? { env: accountDeps.env } : {}),
         });
         if (isLoggedOut(status)) {
-            reason = "account_unavailable";
+            reason = repairRecordedAccount ? "recorded_account_logged_out" : "account_unavailable";
             refusal = new LanesError("account_not_logged_in", `Account ${lane.account} for ${lane.provider} is not logged in`, { provider: lane.provider, account: lane.account });
         }
         else {
@@ -242,6 +244,33 @@ function selectSpawnAccount(input) {
             account: lane.account,
         });
     }
+    if (reason === "recorded_account_logged_out" && lane.provider === "claude") {
+        const lanes = listLaneIds(hqRoot)
+            .map((laneId) => readLane(hqRoot, laneId))
+            .filter((record) => record.host.kind === lane.host.kind && record.host.id === lane.host.id);
+        const capacity = buildHostCapacitySnapshot({
+            host: lane.host,
+            lanes,
+            config,
+            existsSync,
+            probe: accountDeps?.probe,
+            env: accountDeps?.env,
+            hostname,
+            now,
+        });
+        const selection = selectClaudeAccount({
+            hosts: [{ capacity, lanes, laneListAvailable: true }],
+            targetHost: lane.host,
+            config,
+            ...((recordedModel ?? pinnedModel ?? profileModel) !== undefined
+                ? { model: recordedModel ?? pinnedModel ?? profileModel }
+                : {}),
+        });
+        return {
+            account: resolveAccount(lane.provider, selection.account, config, context),
+            changeReason: "recorded_account_logged_out",
+        };
+    }
     const allowedAccounts = Object.entries(config.providers[lane.provider].accounts)
         .filter(([id, account]) => id !== lane.account && account.enabled)
         .filter(([id]) => accountStatus(lane.provider, id, config, {
@@ -254,12 +283,15 @@ function selectSpawnAccount(input) {
         .map(([id]) => id);
     try {
         return {
-            account: selectBalancedAccount(lane.provider, config, { ...context, allowedAccounts }),
+            account: selectBalancedAccount(lane.provider, config, {
+                ...context,
+                allowedAccounts,
+            }),
             changeReason: reason,
         };
     }
     catch (err) {
-        if (reason === "account_unavailable") {
+        if (reason === "account_unavailable" || reason === "recorded_account_logged_out") {
             if (refusal instanceof Error)
                 throw refusal;
             throw new LanesError("account_not_logged_in", `Account ${lane.account} for ${lane.provider} is not logged in or available, and no other logged-in account can serve this lane`, { provider: lane.provider, account: lane.account });
@@ -274,7 +306,8 @@ function previouslyUnavailableAccounts(lane) {
     for (const entry of [...(lane.account_history ?? [])].reverse()) {
         if (entry.reason === "first_assignment" || entry.reason === "operator_move")
             break;
-        if (entry.reason === "account_unavailable" && entry.from !== null)
+        if ((entry.reason === "account_unavailable" || entry.reason === "recorded_account_logged_out") &&
+            entry.from !== null)
             excluded.add(entry.from);
     }
     return excluded;
@@ -364,7 +397,9 @@ export async function retryLaneOnAlternateAccount(hqRoot, lane, reason, writer =
     };
     const profile = lane.worker_profile ? loadWorkerProfile(hqRoot, lane.worker_profile) : undefined;
     const profileModel = profile?.meta.provider === lane.provider ? profile.meta.model : undefined;
-    const pinnedModel = lane.model_source === undefined || lane.model_source === "cli" ? lane.model : undefined;
+    const pinnedModel = lane.model_source === undefined || lane.model_source === "cli" || lane.model_source === "preserved"
+        ? lane.model
+        : undefined;
     const unavailableAccounts = previouslyUnavailableAccounts(lane);
     const allowedAccounts = Object.entries(config.providers[lane.provider].accounts)
         .filter(([id, account]) => id !== lane.account && !unavailableAccounts.has(id) && account.enabled)
@@ -1649,7 +1684,12 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         : undefined;
     const profileChanged = profile !== undefined && existing.worker_profile_hash !== profile.contentHash;
     const config = loadLanesConfig(hqRoot);
-    const pinnedModel = existing.model_source === undefined || existing.model_source === "cli"
+    const repairRecordedAccount = plan.mode === "resume" &&
+        (trigger.kind === "resume" || pendingResume?.trigger === "resume");
+    const recordedModel = repairRecordedAccount && existing.model_source === "account"
+        ? existing.model
+        : undefined;
+    let pinnedModel = existing.model_source === undefined || existing.model_source === "cli" || existing.model_source === "preserved"
         ? existing.model
         : undefined;
     const accountDeps = {
@@ -1669,6 +1709,9 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             profileModel,
             currentModelValidated: deps.currentModelValidated === true,
             hostname,
+            repairRecordedAccount,
+            ...(recordedModel !== undefined ? { recordedModel } : {}),
+            now: (deps.now ?? (() => new Date()))(),
         });
     }
     catch (err) {
@@ -1683,6 +1726,9 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         process.stderr.write(`hq lanes: account bind failed for ${lane.lane_id}: ${err instanceof Error ? err.message : String(err)}\n`);
         throw err;
     }
+    const preservedAccountModel = selection.changeReason === "recorded_account_logged_out" ? recordedModel : undefined;
+    if (preservedAccountModel !== undefined)
+        pinnedModel = preservedAccountModel;
     const resolved = selection.account;
     const status = accountStatus(lane.provider, resolved.id, config, { existsSync, hostname });
     if (isLoggedOut(status)) {
@@ -1738,6 +1784,9 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             return {
                 ...current,
                 account: resolved.id,
+                ...(preservedAccountModel !== undefined
+                    ? { model: preservedAccountModel, model_source: "preserved" }
+                    : {}),
                 account_history: appendCappedHistory(current.account_history ?? [], entry),
             };
         });
@@ -1934,7 +1983,9 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             ...(model !== undefined
                 ? {
                     model_source: pinnedModel !== undefined
-                        ? "cli"
+                        ? preservedAccountModel !== undefined || existing.model_source === "preserved"
+                            ? "preserved"
+                            : "cli"
                         : profileModel !== undefined
                             ? "profile"
                             : accountCfg?.model !== undefined
@@ -2195,7 +2246,7 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
             ignoredFields: ignoredProfileFields,
         }
         : undefined;
-    const pinnedModel = lane.model_source === undefined || lane.model_source === "cli"
+    const pinnedModel = lane.model_source === undefined || lane.model_source === "cli" || lane.model_source === "preserved"
         ? lane.model
         : undefined;
     const resolved = resolveAccount(lane.provider, lane.account, config, {
@@ -2307,7 +2358,7 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
                 if (model !== undefined) {
                     next.model = model;
                     next.model_source = pinnedModel !== undefined
-                        ? "cli"
+                        ? lane.model_source === "preserved" ? "preserved" : "cli"
                         : profileModel !== undefined
                             ? "profile"
                             : accountCfg?.model !== undefined

package/dist/lib/lanes/types.d.ts

@@ -412,8 +412,8 @@ export interface LaneRecord {
     last_envelope?: LastEnvelopeRef;
     /** Effective model id recorded at create/spawn. Omitted when the provider chooses. */
     model?: string;
-    /** Where the effective model came from; profile values are re-read on spawn. */
-    model_source?: "cli" | "profile" | "account" | "provider" | "none";
+    /** Where the effective model came from; repaired models stay pinned across the account move. */
+    model_source?: "cli" | "profile" | "account" | "provider" | "preserved" | "none";
     /** Effective effort level passed to the provider at the last spawn (effort.ts). */
     effort?: string;
     /** Where `effort` came from. `cli` pins it across later spawns. */
@@ -523,7 +523,7 @@ export interface AccountHistoryEntry {
     from: string | null;
     to: string;
     at: string;
-    reason: "first_assignment" | "model_change" | "usage_limit" | "account_unavailable" | "operator_move";
+    reason: "first_assignment" | "model_change" | "usage_limit" | "account_unavailable" | "recorded_account_logged_out" | "operator_move";
 }
 export interface PendingResume {
     /** Fresh answered-question launches need no previous session id. */