@indigoai-us/hq-cli 5.153.0 → 5.155.0

package/dist/lib/lanes/provider-rejection.js

@@ -24,6 +24,25 @@ export const PROVIDER_REJECTED_REASON = "provider_rejected";
 export const PROVIDER_REJECTION_MESSAGE_CAP = 2000;
 /** Status the watcher routes to the quota path instead of `provider_rejected`. */
 export const QUOTA_STATUS = 429;
+/** Exact auth failures observed from each installed CLI in an empty home. */
+function isProviderLoginMessage(provider, message) {
+    switch (provider) {
+        case "claude":
+            return /\bnot logged in\b/i.test(message);
+        case "codex":
+            return /\bnot logged in\b/i.test(message) ||
+                /\bmissing bearer or basic authentication in header\b/i.test(message);
+        case "grok":
+            return /^\s*not signed in\b/i.test(message);
+        default: {
+            const _exhaustive = provider;
+            return _exhaustive;
+        }
+    }
+}
+export function isProviderLoginFailure(failure) {
+    return failure !== null && isProviderLoginMessage(failure.provider, failure.message);
+}
 function isPlainObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -134,10 +153,9 @@ export function parseCodexTurnFailed(text) {
 }
 /**
  * Claude `-p --output-format json`: the last `type: "result"` object with
- * `is_error: true` and a numeric `api_error_status`. A result that is an
- * error with no status is not a provider rejection: it is either the quota
- * text shape quota.ts reads, or the worker's own failure, and keeps the
- * existing classification.
+ * `is_error: true` and a numeric `api_error_status`, or the CLI's explicit
+ * unauthenticated message. Other status-less errors keep the existing
+ * classification because they may be quota text or a worker failure.
  */
 export function parseClaudeResultRejection(text) {
     // The last `result` decides: a success or a status-less error there is
@@ -148,9 +166,9 @@ export function parseClaudeResultRejection(text) {
         if (rec.is_error !== true)
             return NOT_REJECTED;
         const status = statusOf(rec.api_error_status);
-        if (status === null)
-            return NOT_REJECTED;
         const message = typeof rec.result === "string" ? rec.result : "";
+        if (status === null && !isProviderLoginMessage("claude", message))
+            return NOT_REJECTED;
         return {
             reason: PROVIDER_REJECTED_REASON,
             provider: "claude",

package/dist/lib/lanes/reconcile.js

@@ -15,7 +15,7 @@ import { MAX_LANE_DEPTH } from "./constants.js";
 import { AccountResolutionError, LanesError, isLaneVersionConflict } from "./errors.js";
 import { loadWorkerProfile } from "./profile.js";
 import { classifySessionLiveness, defaultLivenessDeps, loadLivenessIndex, readDaemonPresenceConnected, } from "./liveness.js";
-import { ANSWERED_QUESTIONS_FILE, armLaneWatcher, isPidRecordAlive, laneRunDir, readPidRecord, readSpawnManifest, markSpawnFailure, spawnEnvelopeRepair, spawnLaneWorker, } from "./spawn.js";
+import { ANSWERED_QUESTIONS_FILE, armLaneWatcher, isPidRecordAlive, laneRunDir, readPidRecord, readSpawnManifest, markSpawnFailure, spawnEnvelopeRepair, spawnLaneWorker, retryLaneOnAlternateAccount, } from "./spawn.js";
 import { appendCappedHistory, lanesStoreRoot, parseLaneRecord, parseQuestionRecord, readLane, readQuestion, updateLane, updateQuestion, } from "./store.js";
 import { applyThrottleDecision, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, throttleStatePath, writeThrottleState, } from "./throttle.js";
 import { applyDefaultQuotaHold, readQuotaSignal, recordAccountQuota } from "./quota.js";
@@ -916,6 +916,11 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                 const repairedClassification = invalidEnvelope
                     ? classifyLaneExit({ envelope: null, hasPartialOutput: false, invalidEnvelope })
                     : classification;
+                const accountRetryReason = quota
+                    ? "usage_limit"
+                    : providerRejection && classification.reason === "account_not_logged_in"
+                        ? "account_unavailable"
+                        : null;
                 if (!deps.dryRun &&
                     quota &&
                     classified.account &&
@@ -923,6 +928,30 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                         classification.reason === "account_model_unavailable")) {
                     recordAccountQuota(hqRoot, classified.provider, classified.account, quota);
                 }
+                if (!deps.dryRun && accountRetryReason && classified.account) {
+                    try {
+                        const recovered = await retryLaneOnAlternateAccount(hqRoot, classified, accountRetryReason, "reconcile", {
+                            ...(deps.spawnLaneDeps ?? {}),
+                            admissionHost: deps.host,
+                        });
+                        summary.dead_host.push({
+                            id: lane.lane_id,
+                            from: "running",
+                            to: recovered.state,
+                            reason: accountRetryReason,
+                        });
+                        summary.heartbeats.push(`${lane.lane_id}:account-retry`);
+                        continue;
+                    }
+                    catch (err) {
+                        const message = err instanceof Error ? err.message : String(err);
+                        process.stderr.write(`hq lanes reconcile: account failover failed for ${lane.lane_id}: ${message}\n`);
+                        if (readLane(hqRoot, lane.lane_id).state !== "running") {
+                            summary.errors.push({ message: `${lane.lane_id}: account failover left a non-running record after ${message}` });
+                            continue;
+                        }
+                    }
+                }
                 if (!deps.dryRun &&
                     classification.state === "awaiting_input" &&
                     latest &&

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

@@ -12,7 +12,8 @@ import { type RunCompactionFn } from "./compaction.js";
 import { type KnownModelsDeps } from "./models.js";
 import { type LaunchTrigger } from "./delivery.js";
 import { type MachineIdentity } from "./machine-identity.js";
-import { type LaneCompanyRef, type LaneProvider, type LaneRecord } from "./types.js";
+import { type AdmissionHost } from "./admission.js";
+import { type LaneCompanyRef, type LaneProvider, type LaneRecord, type AccountHistoryEntry } from "./types.js";
 export declare const LANES_RUNS_REL: string;
 /** Written by reconcile before a resume spawn; the worker prompt names this path. */
 export declare const ANSWERED_QUESTIONS_FILE = "answered-questions.json";
@@ -32,6 +33,9 @@ export declare function resolveLaneModel(input: {
     accountModel?: string;
     providerModel?: string;
 }): string | undefined;
+type AutomaticAccountChangeReason = Exclude<AccountHistoryEntry["reason"], "operator_move">;
+/** Change account only after a provider/runtime account failure, then re-admit. */
+export declare function retryLaneOnAlternateAccount(hqRoot: string, lane: LaneRecord, reason: Extract<AutomaticAccountChangeReason, "usage_limit" | "account_unavailable">, writer?: "watcher" | "reconcile", deps?: SpawnLaneDeps): Promise<LaneRecord>;
 export declare function appendModelFlag(provider: LaneProvider, args: string[], model: string | undefined): string[];
 /** Add Codex fast-mode flags before the prompt/positional separator. */
 export declare function appendFastModeFlags(provider: LaneProvider, args: string[], enabled: boolean | undefined): string[];
@@ -63,8 +67,12 @@ export type ProveDetachedFn = (pid: number) => DetachProof;
 export type KillProcessFn = (pid: number, signal?: NodeJS.Signals) => void;
 export interface SpawnLaneDeps {
     env?: NodeJS.ProcessEnv;
+    /** The caller's host scope for admission checks; reconcile supplies its resolved host. */
+    admissionHost?: AdmissionHost;
     /** Provider model catalog dependencies, shared with create in tests. */
     modelDeps?: KnownModelsDeps;
+    /** Create validated this exact account/model candidate before its admission lock. */
+    currentModelValidated?: boolean;
     existsSync?: (p: string) => boolean;
     spawnProcess?: SpawnProcessFn;
     proveDetached?: ProveDetachedFn;

package/dist/lib/lanes/spawn.js

@@ -11,18 +11,21 @@ import { spawn, spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import { PROVIDER_HOME_ENV, accountStatus, isLoggedOut, resolveAccount, } from "./accounts.js";
+import { PROVIDER_HOME_ENV, accountStatus, isLoggedOut, resolveAccount, selectBalancedAccount, } from "./accounts.js";
 import { COMPACTION_PROMPT, compactionAfterUsage, compactionDue, compactLaneSession, } from "./compaction.js";
 import { installDrainHook } from "./hooks-install.js";
 import { loadLanesConfig, providerAutoCompactTokens, providerCompactAfterMs, } from "./config.js";
 import { appendEffortFlag, resolveLaneEffort } from "./effort.js";
-import { validateProfileLaneModel, } from "./models.js";
+import { defaultProbe, validateLaneModel, validateProfileLaneModel, } from "./models.js";
 import { claimableStatesFor, planLaneLaunch, providerSupportsSessionResume, } from "./delivery.js";
 import { AccountResolutionError, LanesError } from "./errors.js";
 import { ignoredWorkerProfileFields, loadWorkerProfile, materializeWorkerProfile, workerProfilePrompt, } from "./profile.js";
 import { resolveMachineIdentity, } from "./machine-identity.js";
-import { readLane, retryUpdateLane } from "./store.js";
+import { appendCappedHistory, listLaneIds, readLane, retryUpdateLane } from "./store.js";
+import { copySessionFiles, planSessionCopy } from "./move-account.js";
 import { ensureSessionHome } from "./session-relink.js";
+import { hasEarlierEligibleQueuedLane, laneAdmissionCapReason, withLaneAdmissionLock, } from "./admission.js";
+import { resolveAdmissionHost } from "./admission-host.js";
 import { LANE_ENVELOPE_JSON_SCHEMA, parseLaneProvider, } from "./types.js";
 export const LANES_RUNS_REL = path.join("workspace", "lanes-runs");
 /** Written by reconcile before a resume spawn; the worker prompt names this path. */
@@ -101,6 +104,365 @@ export function resolveLaneModel(input) {
     }
     return undefined;
 }
+function accountModelForSpawn(provider, accountId, config, pinnedModel, profileModel) {
+    return resolveLaneModel({
+        cliModel: pinnedModel,
+        profileModel,
+        accountModel: config.providers[provider].accounts[accountId]?.model,
+        providerModel: config.providers[provider].model,
+    });
+}
+function supportsSpawnModel(provider, accountId, config, pinnedModel, profileModel, modelDeps) {
+    const account = config.providers[provider].accounts[accountId];
+    if (account === undefined)
+        return false;
+    const model = accountModelForSpawn(provider, accountId, config, pinnedModel, profileModel);
+    if (model === undefined)
+        return true;
+    try {
+        validateLaneModel(provider, model, account.home, modelDeps);
+        return true;
+    }
+    catch (err) {
+        if (err instanceof LanesError && err.error === "model_unsupported")
+            return false;
+        throw err;
+    }
+}
+function spawnModelFailure(provider, accountId, config, pinnedModel, profileModel, profileId, modelDeps) {
+    const account = config.providers[provider].accounts[accountId];
+    if (account === undefined)
+        return new LanesError("unknown_account", `Unknown account ${accountId} for ${provider}`, { provider, account: accountId });
+    const model = accountModelForSpawn(provider, accountId, config, pinnedModel, profileModel);
+    if (model === undefined)
+        return null;
+    try {
+        validateLaneModel(provider, model, account.home, modelDeps);
+        return null;
+    }
+    catch (err) {
+        if (!(err instanceof LanesError) || err.error !== "model_unsupported")
+            throw err;
+        if (profileModel !== undefined && pinnedModel === undefined && profileId !== undefined) {
+            return new LanesError(err.error, err.message, {
+                ...err.details,
+                profile_id: profileId,
+                worker_profile: profileId,
+                model_source: "profile",
+            });
+        }
+        return err;
+    }
+}
+function selectSpawnAccount(input) {
+    const { hqRoot, lane, config, existsSync, accountDeps, modelDeps, pinnedModel, profileModel, currentModelValidated } = input;
+    const context = {
+        hqRoot,
+        existsSync,
+        accountDeps,
+        ...(pinnedModel ?? profileModel ? { model: pinnedModel ?? profileModel } : {}),
+    };
+    if (lane.account === undefined) {
+        const modelSpecified = pinnedModel !== undefined || profileModel !== undefined;
+        const allowedAccounts = modelSpecified
+            ? Object.keys(config.providers[lane.provider].accounts).filter((id) => supportsSpawnModel(lane.provider, id, config, pinnedModel, profileModel, modelDeps))
+            : undefined;
+        return {
+            account: selectBalancedAccount(lane.provider, config, {
+                ...context,
+                ...(allowedAccounts !== undefined ? { allowedAccounts } : {}),
+                preferredAccounts: config.providers[lane.provider].preferred_accounts ?? [],
+            }),
+            changeReason: "first_assignment",
+        };
+    }
+    const current = config.providers[lane.provider].accounts[lane.account];
+    let reason;
+    let refusal;
+    const operatorMovePending = lane.pending_resume !== undefined &&
+        lane.account_history?.at(-1)?.reason === "operator_move";
+    if (current === undefined || !current.enabled) {
+        reason = "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 {
+        const status = accountStatus(lane.provider, lane.account, config, {
+            existsSync,
+            ...(accountDeps?.probe ? { probe: accountDeps.probe } : {}),
+            ...(accountDeps?.env ? { env: accountDeps.env } : {}),
+        });
+        if (isLoggedOut(status)) {
+            reason = "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 {
+            try {
+                resolveAccount(lane.provider, lane.account, config, context);
+                const modelFailure = currentModelValidated
+                    ? null
+                    : spawnModelFailure(lane.provider, lane.account, config, pinnedModel, profileModel, lane.worker_profile, modelDeps);
+                if (modelFailure !== null) {
+                    reason = "model_change";
+                    refusal = modelFailure;
+                }
+                else {
+                    return { account: resolveAccount(lane.provider, lane.account, config, context) };
+                }
+            }
+            catch (err) {
+                if (err instanceof AccountResolutionError && err.error === "account_quota_exhausted") {
+                    reason = "usage_limit";
+                    refusal = err;
+                }
+                else if (err instanceof AccountResolutionError && err.error === "account_model_unavailable") {
+                    reason = "usage_limit";
+                    refusal = err;
+                }
+                else if (err instanceof LanesError && err.error === "model_unsupported") {
+                    reason = "model_change";
+                    refusal = err;
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+    }
+    if (operatorMovePending) {
+        if (refusal instanceof Error)
+            throw refusal;
+        throw new LanesError("account_unavailable", `Explicit account move target ${lane.account} is unavailable`, {
+            provider: lane.provider,
+            account: lane.account,
+        });
+    }
+    const allowedAccounts = Object.entries(config.providers[lane.provider].accounts)
+        .filter(([id, account]) => id !== lane.account && account.enabled)
+        .filter(([id]) => accountStatus(lane.provider, id, config, {
+        existsSync,
+        ...(accountDeps?.probe ? { probe: accountDeps.probe } : {}),
+        ...(accountDeps?.env ? { env: accountDeps.env } : {}),
+    }).logged_in === true)
+        .filter(([id]) => supportsSpawnModel(lane.provider, id, config, pinnedModel, profileModel, modelDeps))
+        .map(([id]) => id);
+    try {
+        return {
+            account: selectBalancedAccount(lane.provider, config, { ...context, allowedAccounts }),
+            changeReason: reason,
+        };
+    }
+    catch (err) {
+        if (reason === "account_unavailable") {
+            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 });
+        }
+        if (refusal instanceof Error)
+            throw refusal;
+        throw err;
+    }
+}
+function previouslyUnavailableAccounts(lane) {
+    const excluded = new Set();
+    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)
+            excluded.add(entry.from);
+    }
+    return excluded;
+}
+function archivedResumeMessageText(hqRoot, laneId, messageId) {
+    if (!messageId || /[\\/\0]/.test(messageId))
+        return undefined;
+    const file = path.join(laneRunDir(hqRoot, laneId), "dropbox", "delivered", `${messageId}.resume.jsonl`);
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return undefined;
+        throw new LanesError("account_retry_context_unreadable", `Could not read the archived message needed to resume lane ${laneId}`, { lane_id: laneId, message_id: messageId });
+    }
+    const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    if (lines.length !== 1) {
+        throw new LanesError("account_retry_context_invalid", `The archived message needed to resume lane ${laneId} is malformed`, { lane_id: laneId, message_id: messageId });
+    }
+    let value;
+    try {
+        value = JSON.parse(lines[0]);
+    }
+    catch {
+        throw new LanesError("account_retry_context_invalid", `The archived message needed to resume lane ${laneId} is malformed`, { lane_id: laneId, message_id: messageId });
+    }
+    if (value === null ||
+        typeof value !== "object" ||
+        value.message_id !== messageId ||
+        typeof value.text !== "string") {
+        throw new LanesError("account_retry_context_invalid", `The archived message needed to resume lane ${laneId} is malformed`, { lane_id: laneId, message_id: messageId });
+    }
+    return value.text;
+}
+function pendingResumeForRetry(hqRoot, lane, sessionId, at) {
+    const last = lane.last_resume;
+    if (last === undefined || last.session_id !== sessionId) {
+        return { session_id: sessionId, trigger: "resume", resumed_from: "interrupted", at };
+    }
+    const compact = last.compact === undefined ? {} : { compact: last.compact };
+    if (last.trigger === "answered_questions") {
+        return { session_id: sessionId, trigger: "answered_questions", at, ...compact };
+    }
+    if (last.trigger === "message") {
+        if (last.message_id === undefined) {
+            throw new LanesError("account_retry_context_missing", `The message id needed to resume lane ${lane.lane_id} is missing`, { lane_id: lane.lane_id, trigger: last.trigger });
+        }
+        const text = last.text ?? archivedResumeMessageText(hqRoot, lane.lane_id, last.message_id);
+        if (text === undefined) {
+            throw new LanesError("account_retry_context_missing", `The operator message needed to resume lane ${lane.lane_id} is unavailable`, { lane_id: lane.lane_id, message_id: last.message_id });
+        }
+        return {
+            session_id: sessionId,
+            trigger: "message",
+            text,
+            message_id: last.message_id,
+            at,
+            ...compact,
+        };
+    }
+    return {
+        session_id: sessionId,
+        trigger: "resume",
+        resumed_from: last.resumed_from ?? "interrupted",
+        ...(last.text !== undefined ? { text: last.text } : {}),
+        ...(last.message_id !== undefined ? { message_id: last.message_id } : {}),
+        at,
+        ...compact,
+    };
+}
+/** Change account only after a provider/runtime account failure, then re-admit. */
+export async function retryLaneOnAlternateAccount(hqRoot, lane, reason, writer = "watcher", deps = {}) {
+    const config = loadLanesConfig(hqRoot);
+    const existsSync = deps.existsSync ?? ((p) => fs.existsSync(p));
+    const env = deps.env ?? process.env;
+    const modelDeps = {
+        ...deps.modelDeps,
+        env: deps.modelDeps?.env ?? env,
+    };
+    const accountDeps = {
+        probe: modelDeps.probe ?? defaultProbe,
+        env,
+    };
+    const admissionHost = deps.admissionHost ?? resolveAdmissionHost();
+    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 unavailableAccounts = previouslyUnavailableAccounts(lane);
+    const allowedAccounts = Object.entries(config.providers[lane.provider].accounts)
+        .filter(([id, account]) => id !== lane.account && !unavailableAccounts.has(id) && account.enabled)
+        .filter(([id]) => accountStatus(lane.provider, id, config, {
+        existsSync,
+        ...(accountDeps?.probe ? { probe: accountDeps.probe } : {}),
+        ...(accountDeps?.env ? { env: accountDeps.env } : {}),
+    }).logged_in === true)
+        .filter(([id]) => supportsSpawnModel(lane.provider, id, config, pinnedModel, profileModel, modelDeps))
+        .map(([id]) => id);
+    const modelContext = {
+        hqRoot,
+        existsSync,
+        accountDeps,
+        ...(pinnedModel ?? profileModel ? { model: pinnedModel ?? profileModel } : {}),
+        allowedAccounts,
+    };
+    let target;
+    try {
+        target = selectBalancedAccount(lane.provider, config, modelContext);
+    }
+    catch (err) {
+        if (reason === "account_unavailable" || unavailableAccounts.size > 0) {
+            throw new LanesError("account_not_logged_in", `Account ${lane.account ?? "(none)"} for ${lane.provider} is unavailable and no other logged-in account can serve this lane`, { provider: lane.provider, account: lane.account ?? null });
+        }
+        throw err;
+    }
+    const source = lane.account ? config.providers[lane.provider].accounts[lane.account] : undefined;
+    const sessionId = providerSupportsSessionResume(lane.provider) &&
+        typeof lane.provider_session_id === "string" &&
+        lane.provider_session_id.trim().length > 0
+        ? lane.provider_session_id
+        : undefined;
+    if (source && sessionId) {
+        copySessionFiles(planSessionCopy(lane.provider, {
+            sourceHome: source.home,
+            targetHome: target.home,
+            cwd: hqRoot,
+            sessionId,
+        }));
+    }
+    const now = (deps.now ?? (() => new Date()))();
+    const at = now.toISOString();
+    const nowMs = now.getTime();
+    return withLaneAdmissionLock(hqRoot, lane.provider, async () => {
+        const current = readLane(hqRoot, lane.lane_id);
+        if (current.state !== "running" ||
+            current.account !== lane.account ||
+            current.provider_session_id !== lane.provider_session_id) {
+            throw new LanesError("account_retry_conflict", `Lane ${lane.lane_id} changed while account recovery was prepared`, {
+                lane_id: lane.lane_id,
+                state: current.state,
+                account: current.account ?? null,
+                provider_session_id_changed: current.provider_session_id !== lane.provider_session_id,
+            });
+        }
+        const moveToRetryQueue = (row) => {
+            const entry = {
+                from: row.account ?? null,
+                to: target.id,
+                at,
+                reason,
+            };
+            return {
+                ...row,
+                state: "queued",
+                queued_reason: "account_retry",
+                queued_at: at,
+                admission_reserved_at: undefined,
+                terminal_reason: undefined,
+                terminal_details: undefined,
+                account: target.id,
+                account_history: appendCappedHistory(row.account_history ?? [], entry),
+                pending_resume: sessionId
+                    ? pendingResumeForRetry(hqRoot, row, sessionId, at)
+                    : undefined,
+            };
+        };
+        const candidate = moveToRetryQueue(current);
+        const admissionLanes = listLaneIds(hqRoot)
+            .filter((id) => id !== current.lane_id)
+            .map((id) => readLane(hqRoot, id));
+        admissionLanes.push(candidate);
+        const profileMaxFor = (row) => row.worker_profile === undefined
+            ? undefined
+            : loadWorkerProfile(hqRoot, row.worker_profile).meta.max_concurrent;
+        const capacityReason = laneAdmissionCapReason(admissionLanes, candidate, config, admissionHost, profile?.meta.max_concurrent, nowMs);
+        const earlierEligibleLane = hasEarlierEligibleQueuedLane(admissionLanes, candidate, config, admissionHost, profileMaxFor, nowMs);
+        const moved = retryUpdateLane(hqRoot, lane.lane_id, writer, (row) => {
+            if (row.state !== "running" ||
+                row.account !== lane.account ||
+                row.provider_session_id !== lane.provider_session_id) {
+                throw new LanesError("account_retry_conflict", `Lane ${lane.lane_id} changed while account recovery was prepared`, {
+                    lane_id: lane.lane_id,
+                    state: row.state,
+                    account: row.account ?? null,
+                    provider_session_id_changed: row.provider_session_id !== lane.provider_session_id,
+                });
+            }
+            return moveToRetryQueue(row);
+        });
+        if (capacityReason !== undefined || earlierEligibleLane)
+            return moved;
+        return spawnLaneWorker(hqRoot, moved, deps);
+    });
+}
 export function appendModelFlag(provider, args, model) {
     if (model === undefined)
         return args;
@@ -1157,16 +1519,28 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     const pinnedModel = existing.model_source === undefined || existing.model_source === "cli"
         ? existing.model
         : undefined;
-    let resolved;
+    const accountDeps = {
+        probe: modelDeps.probe ?? defaultProbe,
+        env,
+    };
+    let selection;
     try {
-        resolved = resolveAccount(lane.provider, lane.account, config, {
+        selection = selectSpawnAccount({
             hqRoot,
+            lane: existing,
+            config,
             existsSync,
-            model: pinnedModel ?? profileModel,
+            accountDeps,
+            modelDeps,
+            pinnedModel,
+            profileModel,
+            currentModelValidated: deps.currentModelValidated === true,
         });
     }
     catch (err) {
-        if (err instanceof AccountResolutionError) {
+        if (err instanceof AccountResolutionError ||
+            (err instanceof LanesError &&
+                (err.error === "account_not_logged_in" || err.error === "model_unsupported"))) {
             if (markPreSpawnFailure) {
                 markSpawnFailure(hqRoot, lane.lane_id, err.error, err.details);
             }
@@ -1175,6 +1549,7 @@ 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 resolved = selection.account;
     const status = accountStatus(lane.provider, resolved.id, config, { existsSync });
     if (isLoggedOut(status)) {
         const failed = markPreSpawnFailure
@@ -1185,8 +1560,20 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             : existing;
         throw new LanesError("account_not_logged_in", `Account ${resolved.id} for ${lane.provider} is not logged in (no credential file)`, { provider: lane.provider, account: resolved.id, lane_id: lane.lane_id, lane: failed });
     }
-    if (profileDefaultsApply && profileModel !== undefined && pinnedModel === undefined) {
-        validateProfileLaneModel(existing.provider, profileModel, resolved.home, profile.id, modelDeps);
+    if (existing.account !== resolved.id) {
+        const source = existing.account
+            ? config.providers[existing.provider].accounts[existing.account]
+            : undefined;
+        if (source &&
+            existing.provider_session_id &&
+            providerSupportsSessionResume(existing.provider)) {
+            copySessionFiles(planSessionCopy(existing.provider, {
+                sourceHome: source.home,
+                targetHome: resolved.home,
+                cwd: hqRoot,
+                sessionId: existing.provider_session_id,
+            }));
+        }
     }
     if (plan.mode === "resume" && existing.provider !== "grok") {
         ensureSessionHome({
@@ -1199,11 +1586,26 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             providerHomeAtSpawn: existing.provider_home_at_spawn,
         });
     }
-    if (lane.account !== resolved.id) {
+    if (existing.account !== resolved.id) {
+        const at = (deps.now ?? (() => new Date()))().toISOString();
+        const reason = selection.changeReason ?? "first_assignment";
         retryUpdateLane(hqRoot, lane.lane_id, "spawn", (current) => {
             if (current.account === resolved.id)
                 return current;
-            return { ...current, account: resolved.id };
+            if (current.account !== existing.account) {
+                throw new LanesError("account_bind_conflict", `Lane ${lane.lane_id} changed accounts while its worker spawn was prepared`, { lane_id: lane.lane_id, expected_account: existing.account ?? null, account: current.account ?? null });
+            }
+            const entry = {
+                from: current.account ?? null,
+                to: resolved.id,
+                at,
+                reason,
+            };
+            return {
+                ...current,
+                account: resolved.id,
+                account_history: appendCappedHistory(current.account_history ?? [], entry),
+            };
         });
     }
     try {
@@ -1255,10 +1657,10 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
                         ? trigger.text
                         : pendingResume?.text,
                 resumedFrom: trigger.kind === "resume" ? trigger.from : pendingResume?.resumed_from,
-                answersPath: trigger.kind === "answered_questions" && existsSync(answersPath)
+                answersPath: (trigger.kind === "answered_questions" || pendingResume?.trigger === "answered_questions") && existsSync(answersPath)
                     ? answersPath
                     : undefined,
-                answers: trigger.kind === "answered_questions" && existsSync(answersPath)
+                answers: (trigger.kind === "answered_questions" || pendingResume?.trigger === "answered_questions") && existsSync(answersPath)
                     ? readAnsweredQuestionLines(answersPath)
                     : undefined,
             }),
@@ -1425,6 +1827,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
                 ...(pendingResume.message_id !== undefined ? { message_id: pendingResume.message_id } : {}),
                 ...(pendingResume.resumed_from !== undefined ? { resumed_from: pendingResume.resumed_from } : {}),
                 ...(pendingResume.text !== undefined ? { text: pendingResume.text } : {}),
+                ...(pendingResume.compact !== undefined ? { compact: pendingResume.compact } : {}),
             };
         }
         else if (resume && trigger.kind !== "admit") {
@@ -1433,7 +1836,10 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
                 at: nowIso,
                 account: resolved.id,
                 trigger: trigger.kind,
-                ...(trigger.kind === "message" ? { message_id: trigger.message_id } : {}),
+                ...(trigger.kind === "message"
+                    ? { message_id: trigger.message_id, text: trigger.text }
+                    : {}),
+                ...(launch.compact !== undefined ? { compact: launch.compact } : {}),
                 ...(trigger.kind === "resume"
                     ? {
                         resumed_from: trigger.from,