@indigoai-us/hq-cli 5.222.0 → 5.223.0

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [5.223.0] — 2026-09-26
+
+### Fixed
+
+- Manual resume and explicitly opted-in keep-alive reconcile can move a lane
+  off a disabled or logged-out Claude account on the same host, preserving the
+  provider session, provider, and model. `hq lanes watch` reports each
+  logged-in-to-logged-out transition once with the affected lane ids. The
+  watcher stops polling terminal keep-alive lanes when no resume can run and
+  shares one local account probe across matching lanes per poll. Quota and
+  model failures keep their existing account-selection path and reason.
+
 ## [5.222.0] — 2026-09-26
 
 - Checkpoint ontology, behind `checkpoint.ontology.multi-writer` (off by

package/dist/commands/lanes.js

@@ -42,7 +42,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 +1262,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 +5067,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 +5102,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 +5196,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 +5291,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 +5379,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 +5413,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 +5456,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 +5511,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 +5617,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 +5677,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 +6157,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 +6183,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 +6203,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 +8513,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,

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. */

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

@@ -1,16 +1,33 @@
-import { type LaneRecord, type QuestionRecord } from "./types.js";
+import { type LaneHost, type LaneProvider, type LaneRecord, type QuestionRecord } from "./types.js";
 export declare const DEFAULT_LANE_WATCH_INTERVAL_MS = 5000;
 export declare const MAX_LANE_WATCH_INTERVAL_MS = 30000;
 export declare const MAX_WATCHED_LANES = 64;
 export declare const MAX_WATCH_OUTPUT_LINES = 512;
+export interface LaneWatchAccountStatus {
+    lane_id: string;
+    provider: LaneProvider;
+    account: string;
+    host: LaneHost;
+    logged_in: boolean | null;
+}
+export interface LaneAccountLoggedOutEvent {
+    event: "account_logged_out";
+    provider: LaneProvider;
+    account: string;
+    host: LaneHost;
+    lane_ids: string[];
+}
 export interface LaneWatchDeps {
     readLane?: (hqRoot: string, laneId: string) => LaneRecord | null;
     listQuestionIds?: (hqRoot: string) => string[];
     readQuestion?: (hqRoot: string, questionId: string) => QuestionRecord | null;
+    readAccountStatuses?: (lanes: readonly LaneRecord[]) => Promise<readonly LaneWatchAccountStatus[]>;
+    keepAliveEnabled?: (lane: LaneRecord) => boolean | Promise<boolean>;
     sleep?: (ms: number) => Promise<void>;
     intervalMs?: number;
     maxOutputLines?: number;
     writeLine?: (line: string) => void;
+    writeAccountEvent?: (event: LaneAccountLoggedOutEvent) => void;
     writeError?: (line: string) => void;
 }
 export interface LaneWatchResult {

package/dist/lib/lanes/watch.js

@@ -1,6 +1,8 @@
 import { listQuestionIds, readLane, readQuestion, } from "./store.js";
 import { LaneNotFoundError, LanesError } from "./errors.js";
-import { isTerminalLaneState } from "./types.js";
+import { providerSupportsSessionResume } from "./delivery.js";
+import { LEAD_LANE_KEEP_ALIVE_MAX_RESUMES } from "./keep-alive.js";
+import { isTerminalLaneState, } from "./types.js";
 export const DEFAULT_LANE_WATCH_INTERVAL_MS = 5_000;
 export const MAX_LANE_WATCH_INTERVAL_MS = 30_000;
 export const MAX_WATCHED_LANES = 64;
@@ -30,6 +32,30 @@ function validateLaneIds(laneIds) {
     }
     return unique;
 }
+function canResumeKeepAliveLane(lane) {
+    if (lane.keep_alive !== true ||
+        lane.keep_alive_opted_in_at === undefined ||
+        !Number.isFinite(Date.parse(lane.keep_alive_opted_in_at)) ||
+        lane.keep_alive_exhausted_at !== undefined ||
+        (lane.keep_alive_resume_count ?? 0) >= LEAD_LANE_KEEP_ALIVE_MAX_RESUMES ||
+        lane.keep_alive_blocked_reason === "retired" ||
+        lane.keep_alive_blocked_reason === "superseded" ||
+        lane.keep_alive_blocked_reason === "retired_list_invalid" ||
+        lane.keep_alive_blocked_reason === "terminal_state" ||
+        !providerSupportsSessionResume(lane.provider) ||
+        !(lane.provider_session_id ?? lane.last_resume?.session_id))
+        return false;
+    if (lane.state === "interrupted") {
+        return lane.terminal_reason === "exited_with_partial_output";
+    }
+    if (lane.state === "done") {
+        return lane.last_envelope?.decision === "done" &&
+            lane.story_complete !== true &&
+            lane.terminal_reason !== "provider_rejected" &&
+            lane.terminal_reason !== "account_not_logged_in";
+    }
+    return false;
+}
 export async function runLaneWatch(hqRoot, laneIds, deps = {}) {
     const watchedIds = validateLaneIds(laneIds);
     const readLaneRecord = deps.readLane ?? readLane;
@@ -37,11 +63,15 @@ export async function runLaneWatch(hqRoot, laneIds, deps = {}) {
     const readQuestionRecord = deps.readQuestion ?? readQuestion;
     const sleep = deps.sleep ?? defaultSleep;
     const writeLine = deps.writeLine ?? ((line) => console.log(line));
+    const writeAccountEvent = deps.writeAccountEvent ?? ((event) => {
+        writeLine(`account_logged_out provider=${event.provider} account=${event.account} host=${event.host.kind}:${event.host.id} lane_ids=${event.lane_ids.join(",")}`);
+    });
     const writeError = deps.writeError ?? ((line) => process.stderr.write(`${line}\n`));
     const maxOutputLines = Math.max(1, Math.floor(deps.maxOutputLines ?? MAX_WATCH_OUTPUT_LINES));
     const intervalMs = boundedInterval(deps.intervalMs);
     const previousStates = new Map();
     const previousQuestionStatuses = new Map();
+    const previousAccountLogin = new Map();
     let polls = 0;
     let lines = 0;
     let suppressed = false;
@@ -57,6 +87,18 @@ export async function runLaneWatch(hqRoot, laneIds, deps = {}) {
             suppressed = true;
         }
     };
+    const emitAccountEvent = (event) => {
+        if (lines < maxOutputLines - 1) {
+            writeAccountEvent(event);
+            lines += 1;
+            return;
+        }
+        if (!suppressed) {
+            writeLine("lane watch: output limit reached; further events suppressed");
+            lines = maxOutputLines;
+            suppressed = true;
+        }
+    };
     const unreadable = (kind, id, err) => {
         const message = `${kind} ${id}: unreadable record (${readableError(err)})`;
         writeError(`lane watch: ${message}`);
@@ -87,6 +129,15 @@ export async function runLaneWatch(hqRoot, laneIds, deps = {}) {
                 previousStates.set(laneId, record.state);
             }
         }
+        const keepAliveWaiting = new Set();
+        if (deps.keepAliveEnabled !== undefined) {
+            for (const record of records) {
+                if (isTerminalLaneState(record.state) &&
+                    canResumeKeepAliveLane(record) &&
+                    await deps.keepAliveEnabled(record))
+                    keepAliveWaiting.add(record.lane_id);
+            }
+        }
         let questionIds = [];
         try {
             questionIds = listQuestions(hqRoot);
@@ -113,7 +164,76 @@ export async function runLaneWatch(hqRoot, laneIds, deps = {}) {
             }
             previousQuestionStatuses.set(questionId, record.status);
         }
-        if (records.every((record) => isTerminalLaneState(record.state))) {
+        if (deps.readAccountStatuses !== undefined) {
+            const accountLanes = records.filter((record) => record.account !== undefined &&
+                (!isTerminalLaneState(record.state) || keepAliveWaiting.has(record.lane_id)));
+            let statuses;
+            try {
+                statuses = await deps.readAccountStatuses(accountLanes);
+            }
+            catch (err) {
+                const message = `account login status: ${readableError(err)}`;
+                writeError(`lane watch: ${message}`);
+                throw new LanesError("watch_account_status_unavailable", message, {
+                    cause: readableError(err),
+                });
+            }
+            const statusLanes = new Map(accountLanes.map((record) => [record.lane_id, record]));
+            const grouped = new Map();
+            const seenLaneIds = new Set();
+            for (const status of statuses) {
+                const lane = statusLanes.get(status.lane_id);
+                if (!lane || lane.provider !== status.provider || lane.account !== status.account ||
+                    lane.host.kind !== status.host.kind || lane.host.id !== status.host.id ||
+                    (status.logged_in !== true && status.logged_in !== false && status.logged_in !== null) ||
+                    seenLaneIds.has(status.lane_id)) {
+                    const message = `malformed account login status for lane ${JSON.stringify(status.lane_id)}`;
+                    writeError(`lane watch: ${message}`);
+                    throw new LanesError("watch_account_status_invalid", message, {
+                        lane_id: status.lane_id,
+                    });
+                }
+                seenLaneIds.add(status.lane_id);
+                const key = JSON.stringify([status.provider, status.account, status.host.kind, status.host.id]);
+                const existing = grouped.get(key);
+                if (existing && existing.status.logged_in !== status.logged_in) {
+                    const message = `conflicting account login statuses for ${status.provider} account ${status.account} on ${status.host.kind}:${status.host.id}`;
+                    writeError(`lane watch: ${message}`);
+                    throw new LanesError("watch_account_status_invalid", message, {
+                        provider: status.provider,
+                        account: status.account,
+                        host: status.host,
+                    });
+                }
+                const group = existing ?? { status, laneIds: new Set() };
+                group.laneIds.add(status.lane_id);
+                grouped.set(key, group);
+            }
+            const missingLane = accountLanes.find((lane) => !seenLaneIds.has(lane.lane_id));
+            if (missingLane) {
+                const message = `account login status is missing for lane ${missingLane.lane_id}`;
+                writeError(`lane watch: ${message}`);
+                throw new LanesError("watch_account_status_invalid", message, {
+                    lane_id: missingLane.lane_id,
+                });
+            }
+            for (const [key, group] of grouped) {
+                const { status } = group;
+                const prior = previousAccountLogin.get(key);
+                if (prior === true && status.logged_in === false) {
+                    emitAccountEvent({
+                        event: "account_logged_out",
+                        provider: status.provider,
+                        account: status.account,
+                        host: status.host,
+                        lane_ids: [...group.laneIds].sort(),
+                    });
+                }
+                if (status.logged_in !== null)
+                    previousAccountLogin.set(key, status.logged_in);
+            }
+        }
+        if (records.every((record) => isTerminalLaneState(record.state) && !keepAliveWaiting.has(record.lane_id))) {
             return { polls, lines, suppressed };
         }
         await sleep(intervalMs);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.222.0",
+  "version": "5.223.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {