@indigoai-us/hq-cli 5.314.0 → 5.316.0

package/dist/lib/lanes/reconcile.js

@@ -0,0 +1,3343 @@
+/**
+ * Periodic reconcile pass (spec §5.7, §6.8, §9).
+ *
+ * Owned by the machine, not by any lane. Reads never mutate; every write is a
+ * compare-and-set. The per-lane watcher owns progress/terminal/silence of a
+ * live process — this pass owns the transitions no single lane can own.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { parseUserYaml } from "../../utils/user-yaml-error.js";
+import { compareLaneQueueOrder, hasActiveAdmissionReservation, hasActivePendingResume, laneAdmissionCapReason, laneRunsOnHost, withAllLaneAdmissionLocks, } from "./admission.js";
+import { accountStatus, isCredentialProven, resolveAccount } from "./accounts.js";
+import { effectiveAccountHome } from "./account-home.js";
+import { enforceRegistryApprovalGate } from "./approval-gate.js";
+import { loadLanesConfig, providerQuotaDefaultHoldMs } from "./config.js";
+import { MAX_LANE_DEPTH } from "./constants.js";
+import { AccountResolutionError, LanesError, isLaneVersionConflict } from "./errors.js";
+import { loadWorkerProfile } from "./profile.js";
+import { terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./grants.js";
+import { classifySessionLiveness, defaultLivenessDeps, loadLivenessIndex, readDaemonPresenceConnected, unindexedClaudeSessionLiveness, } from "./liveness.js";
+import { ANSWERED_QUESTIONS_FILE, armLaneWatcher, envelopeRepairMode, isPidRecordAlive, laneRunDir, readPidRecord, readProcStarttime, readSpawnManifest, markSpawnFailure, stopLaneProcesses, spawnEnvelopeRepair, spawnLaneWorker, retryLaneOnAlternateAccount, } from "./spawn.js";
+import { appendCappedHistory, lanesStoreRoot, parseLaneRecord, parseQuestionRecord, readLane, readQuestion, listQuestionIds, updateLane, updateQuestion, } from "./store.js";
+import { applyThrottleDecision, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, sampleCpuBusyObservation, recordCpuBusyObservation, throttleStatePath, writeThrottleState, } from "./throttle.js";
+import { readLanesRegistryFlag, readLanesRegistryFlagFailOff } from "./registry-flag.js";
+import { LANE_HIRE_GRANT_FINISHED_LANES_FLAG } from "./flag-keys.js";
+import { checkLaneDiskSpace, configuredCodexRolloutHomes, lowDiskGuardEnabledForLane, retainCodexRollouts } from "./disk-guard.js";
+import { laneCompanyUidSource, resolveLaneCompany } from "./lane-company.js";
+import { appendDropboxMessage } from "./dropbox.js";
+import { DEFAULT_RUNAWAY_SEARCH_GUARD_CONFIG, listHostProcesses, runRunawayToolGuard, RUNAWAY_TOOL_GUARD_FLAG, } from "./runaway-tool-guard.js";
+import { LEAD_LANE_KEEP_ALIVE_FLAG, LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG, LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_FLAG, LEAD_LANE_KEEP_ALIVE_FIRST_RESUME_SETTLE_MS, LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_MAX_DELAY_MS, LEAD_LANE_KEEP_ALIVE_BLOCKED_GRACE_MS, LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT, queueLaneTerminalResume, LEAD_LANE_KEEP_ALIVE_INTERRUPTED_RESUME_TEXT, LEAD_LANE_KEEP_ALIVE_MAX_RESUMES, LEAD_LANE_KEEP_ALIVE_RESUME_TEXT, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, doneKeepAliveVerdict, hasPendingKeepAliveWork, keepAliveExclusion, loadRetiredLaneIds, leadLaneKeepAliveBackoffMs, undeliveredAnsweredQuestions, } from "./keep-alive.js";
+import { providerSupportsSessionResume } from "./delivery.js";
+import { applyDefaultQuotaHold, clearAccountQuotaAfterSuccessfulTurnBestEffort, readQuotaSignal, recordAccountQuota, } from "./quota.js";
+import { answeredQuestionEntries, questionRecordRefusalCode, raiseEnvelopeQuestions, resolveQuestionCompanyWithFallback, } from "./questions.js";
+import { SILENCE_MS, appendWatcherEvent, classifyLaneExit, isPidAlive, missingExpectedEnvelopeFile, readLatestEnvelopeFile, readLatestEnvelopeRecord, watcherEventsPath, watcherOutLogPath, writeWatcherDecision, } from "./watcher.js";
+import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshCompany, } from "./mesh-events.js";
+import { activeLaneStories, laneStories, terminalEnvelopeStoryStatus } from "./stories.js";
+import { applyStorySwitchEnvelope } from "./story-switch.js";
+import { readProjectStoryStates } from "./story-ledger.js";
+import { decideEnvelopeRepair, envelopeQuestionIds, routeProviderFailure } from "./watcher.js";
+import { PROVIDER_REJECTED_REASON, providerRejectionDetails, readProviderRejection, } from "./provider-rejection.js";
+/** Spec §9: unanswered at the current hop for 60 minutes → one hop. */
+export const QUESTION_AGE_MS = 60 * 60 * 1000;
+/** Spec §6.6 + §9: a depth-3 worker has two hops to age toward the user. */
+export const MAX_AGED_ADVANCES = MAX_LANE_DEPTH - 1;
+/** Aligns with watcher silence: a host that has not reported for this long is dead. */
+export const DEAD_HOST_MS = SILENCE_MS;
+export const RECONCILE_LOCK_STALE_MS = 30_000;
+export const RECONCILE_LOCK_TIMEOUT_MS = 5_000;
+/** A pickup probe that has not cleared its marker within this window is abandoned. */
+export const PICKUP_VALIDATION_MAX_AGE_MS = 15 * 60 * 1000;
+export const PICKUP_VALIDATION_TIMEOUT_REASON = "pickup_validation_timeout";
+export const CLOSE_INTERRUPTED_DONE_STORY_WORKERS_FLAG = "lanes.close-interrupted-done-story-workers";
+const INTERRUPTED_DONE_STORY_MIN_AGE_MS = 24 * 60 * 60 * 1000;
+export const RECONCILE_UNIT_NAME = "hq-lanes-reconcile.service";
+export const RECONCILE_TIMER_NAME = "hq-lanes-reconcile.timer";
+function spawnDepsForHost(deps) {
+    return {
+        ...(deps.spawnLaneDeps ?? {}),
+        env: deps.spawnLaneDeps?.env ?? deps.env ?? process.env,
+        hostname: deps.host.hostname,
+        admissionHost: deps.host,
+    };
+}
+function logSkip(skip) {
+    process.stderr.write(`hq lanes reconcile: skipped ${skip.kind}${skip.id ? ` ${skip.id}` : ""}: ${skip.why}\n`);
+}
+function emptySummary(dryRun) {
+    return {
+        ok: true,
+        action: "reconcile",
+        dry_run: dryRun,
+        admitted: [],
+        overdue: [],
+        aged: [],
+        advanced: [],
+        resumed: [],
+        dead_host: [],
+        heartbeats: [],
+        skipped: [],
+        keep_alive_blocked: [],
+        errors: [],
+        heartbeat_at: null,
+    };
+}
+function markDirty(summary, skip) {
+    summary.skipped.push(skip);
+    summary.ok = false;
+    logSkip(skip);
+}
+function terminalizeModelUnsupported(hqRoot, lane, err) {
+    if (!(err instanceof LanesError) || err.error !== "model_unsupported")
+        return;
+    try {
+        markSpawnFailure(hqRoot, lane.lane_id, err.error, {
+            ...err.details,
+            message: err.message,
+        });
+    }
+    catch (writeErr) {
+        process.stderr.write(`hq lanes reconcile: failed to terminalize ${lane.lane_id} after model validation: ${writeErr instanceof Error ? writeErr.message : String(writeErr)}\n`);
+    }
+}
+function markError(summary, err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const code = err instanceof LanesError ? err.error : undefined;
+    summary.errors.push(code ? { message, code } : { message });
+    summary.ok = false;
+    process.stderr.write(`hq lanes reconcile: ${message}${err instanceof Error && err.stack ? `\n${err.stack}` : ""}\n`);
+}
+export function reconcileHeartbeatPath(hqRoot) {
+    return path.join(hqRoot, "workspace", "lanes-runs", "reconcile-heartbeat.json");
+}
+export function timeoutPath(hqRoot, laneId) {
+    return path.join(laneRunDir(hqRoot, laneId), "timeout.json");
+}
+export function laneRunsHere(lane, host) {
+    return laneRunsOnHost(lane, host);
+}
+function hasFreshAdmissionReservation(lane, nowMs) {
+    return hasActiveAdmissionReservation(lane, nowMs);
+}
+export function agedAdvanceCount(question) {
+    return question.routing_history.filter((entry) => entry.reason === "unanswered_timeout").length;
+}
+export function currentHopStartedAtMs(question) {
+    const atCurrent = [...question.routing_history]
+        .reverse()
+        .find((entry) => entry.hop === question.hop);
+    const raw = atCurrent?.at ?? question.asked_at;
+    const ms = Date.parse(raw);
+    return Number.isFinite(ms) ? ms : Number.NEGATIVE_INFINITY;
+}
+export function shouldAgeQuestion(question, audience, nowMs, ageWindowMs = QUESTION_AGE_MS) {
+    if (question.status !== "pending")
+        return false;
+    if (audience.kind === "user")
+        return false;
+    if (agedAdvanceCount(question) >= MAX_AGED_ADVANCES)
+        return false;
+    const started = currentHopStartedAtMs(question);
+    if (started === Number.NEGATIVE_INFINITY)
+        return false;
+    return nowMs - started >= ageWindowMs;
+}
+export function shouldAdvanceAudienceEnded(audience, liveness) {
+    if (audience.kind === "user")
+        return false;
+    if (audience.kind !== "session")
+        return false;
+    return liveness === "ended";
+}
+export function readTimeoutDeadline(hqRoot, laneId) {
+    const filePath = timeoutPath(hqRoot, laneId);
+    let text;
+    try {
+        text = fs.readFileSync(filePath, "utf8");
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return null;
+        throw err;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (err) {
+        throw new LanesError("timeout_unreadable", `Timeout file for ${laneId} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`, { lane_id: laneId, path: filePath });
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new LanesError("timeout_unreadable", `Timeout file for ${laneId} is not an object`, { lane_id: laneId, path: filePath });
+    }
+    const deadline = parsed.deadline_at;
+    if (typeof deadline !== "string" || !Number.isFinite(Date.parse(deadline))) {
+        return null;
+    }
+    const timeoutSecs = parsed.timeout_secs;
+    return {
+        deadline_at: deadline,
+        timeout_secs: typeof timeoutSecs === "number" && Number.isInteger(timeoutSecs)
+            ? timeoutSecs
+            : undefined,
+    };
+}
+export function isDeadlinePassed(deadlineAt, nowMs) {
+    const at = Date.parse(deadlineAt);
+    if (!Number.isFinite(at))
+        return false;
+    return nowMs > at;
+}
+function readDirJsonIds(dir, label) {
+    let names;
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return [];
+        throw new LanesError("store_unreadable", `Failed to read ${label} directory ${dir}: ${err instanceof Error ? err.message : String(err)}`, { path: dir });
+    }
+    return names.filter((name) => typeof name === "string" &&
+        name.endsWith(".json") &&
+        !name.startsWith(".") &&
+        !name.includes(".conflict-"));
+}
+function loadLaneRecords(hqRoot, summary) {
+    const dir = path.join(lanesStoreRoot(hqRoot), "lanes");
+    const names = readDirJsonIds(dir, "lane");
+    const lanes = [];
+    for (const name of names) {
+        const filePath = path.join(dir, name);
+        const id = name.slice(0, -".json".length);
+        try {
+            const text = fs.readFileSync(filePath, "utf8");
+            const parsed = JSON.parse(text);
+            lanes.push(parseLaneRecord(parsed, filePath));
+        }
+        catch (err) {
+            markDirty(summary, {
+                kind: "lane",
+                id,
+                why: `unreadable: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    return lanes;
+}
+function loadQuestionRecords(hqRoot, summary) {
+    const dir = path.join(lanesStoreRoot(hqRoot), "questions");
+    const names = readDirJsonIds(dir, "question");
+    const questions = [];
+    for (const name of names) {
+        const filePath = path.join(dir, name);
+        const id = name.slice(0, -".json".length);
+        try {
+            const text = fs.readFileSync(filePath, "utf8");
+            const parsed = JSON.parse(text);
+            questions.push(parseQuestionRecord(parsed, filePath));
+        }
+        catch (err) {
+            markDirty(summary, {
+                kind: "question",
+                id,
+                why: `unreadable: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    return questions;
+}
+function defaultReadSessionSenior(hqRoot, sessionId) {
+    const filePath = path.join(hqRoot, "workspace", "sessions", sessionId, "meta.yaml");
+    let text;
+    try {
+        text = fs.readFileSync(filePath, "utf8");
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return { kind: "user" };
+        throw err;
+    }
+    const doc = parseUserYaml(text, filePath);
+    if (doc === null || typeof doc !== "object" || Array.isArray(doc)) {
+        return { kind: "user" };
+    }
+    const senior = doc.senior;
+    if (senior === "user" || senior === undefined || senior === null) {
+        return { kind: "user" };
+    }
+    if (typeof senior === "string") {
+        const colon = senior.indexOf(":");
+        if (colon <= 0)
+            return { kind: "user" };
+        const kind = senior.slice(0, colon);
+        const id = senior.slice(colon + 1);
+        if (kind === "session" || kind === "lane")
+            return { kind, id };
+        if (kind === "user")
+            return { kind: "user" };
+    }
+    if (typeof senior === "object" && !Array.isArray(senior)) {
+        const rec = senior;
+        if (rec.kind === "user")
+            return { kind: "user" };
+        if ((rec.kind === "session" || rec.kind === "lane") &&
+            typeof rec.id === "string" &&
+            rec.id.length > 0) {
+            return { kind: rec.kind, id: rec.id };
+        }
+    }
+    return { kind: "user" };
+}
+export function resolveQuestionAudience(question, readLaneSenior, readSessionSenior) {
+    let current = { kind: "lane", id: question.origin.id };
+    for (let hop = 0; hop < question.hop; hop += 1) {
+        if (current.kind === "user")
+            return current;
+        if (current.kind === "lane") {
+            if (!current.id)
+                return current;
+            current = readLaneSenior(current.id);
+            continue;
+        }
+        if (!current.id)
+            return current;
+        current = readSessionSenior(current.id);
+    }
+    return current;
+}
+function casLaneIf(hqRoot, laneId, shouldWrite, updater, dryRun) {
+    for (let i = 0; i < 5; i += 1) {
+        const current = readLane(hqRoot, laneId);
+        if (!shouldWrite(current))
+            return { changed: false, record: current };
+        if (dryRun)
+            return { changed: true, record: updater(current) };
+        try {
+            return {
+                changed: true,
+                record: updateLane(hqRoot, laneId, current.version, "reconcile", updater),
+            };
+        }
+        catch (err) {
+            if (!isLaneVersionConflict(err) || i === 4)
+                throw err;
+        }
+    }
+    throw new LanesError("version_conflict", `Exhausted CAS retries for lane ${laneId}`, { lane_id: laneId });
+}
+function laneStoryLedgerIsClosed(hqRoot, lane) {
+    const stories = laneStories(lane);
+    if (stories.length === 0)
+        return { closed: false, states: [] };
+    const states = [];
+    for (const projectId of new Set(stories.map((story) => story.project_id))) {
+        const projectStories = stories.filter((story) => story.project_id === projectId);
+        const ledgerStates = readProjectStoryStates(hqRoot, projectId, projectStories.map((story) => story.story_id), lane.company?.slug);
+        for (const story of projectStories) {
+            const state = ledgerStates.get(story.story_id);
+            if (state === undefined)
+                return { closed: false, states: [...states, "missing"] };
+            states.push(state);
+        }
+    }
+    return { closed: states.length > 0 && states.every((state) => state === "done" || state === "dropped"), states };
+}
+async function closeInterruptedDoneStoryWorkers(hqRoot, lanes, questions, summary, deps, now, enabledByCompany) {
+    if (deps.dryRun)
+        return;
+    const nowMs = now.getTime();
+    const at = now.toISOString();
+    for (const lane of lanes) {
+        if (lane.depth < 1 || lane.state !== "interrupted" || lane.keep_alive === true ||
+            !laneRunsHere(lane, deps.host) || !lane.interrupted_at ||
+            !Number.isFinite(Date.parse(lane.interrupted_at)) ||
+            nowMs - Date.parse(lane.interrupted_at) < INTERRUPTED_DONE_STORY_MIN_AGE_MS ||
+            hasPendingKeepAliveWork(hqRoot, lane, questions))
+            continue;
+        let company;
+        try {
+            company = resolveLaneCompany(hqRoot, lane).company;
+        }
+        catch (err) {
+            markDirty(summary, { kind: "lane", id: lane.lane_id, why: `story close company lookup failed: ${err instanceof Error ? err.message : String(err)}` });
+            continue;
+        }
+        if (!company || enabledByCompany.get(keepAliveCompanyKey(company)) !== true)
+            continue;
+        let ledger;
+        try {
+            ledger = laneStoryLedgerIsClosed(hqRoot, lane);
+        }
+        catch (err) {
+            markDirty(summary, { kind: "lane", id: lane.lane_id, why: `story close ledger read failed: ${err instanceof Error ? err.message : String(err)}` });
+            continue;
+        }
+        if (!ledger.closed)
+            continue;
+        try {
+            const result = casLaneIf(hqRoot, lane.lane_id, (current) => {
+                const currentCompany = resolveLaneCompany(hqRoot, current).company;
+                if (current.state !== "interrupted" || current.depth < 1 || current.keep_alive === true ||
+                    !currentCompany || enabledByCompany.get(keepAliveCompanyKey(currentCompany)) !== true ||
+                    !laneRunsHere(current, deps.host) || !current.interrupted_at ||
+                    !Number.isFinite(Date.parse(current.interrupted_at)) ||
+                    nowMs - Date.parse(current.interrupted_at) < INTERRUPTED_DONE_STORY_MIN_AGE_MS ||
+                    hasPendingKeepAliveWork(hqRoot, current, questions))
+                    return false;
+                return laneStoryLedgerIsClosed(hqRoot, current).closed;
+            }, (current) => ({
+                ...current,
+                state: "killed",
+                queued_reason: undefined,
+                queued_details: undefined,
+                updated_at: at,
+                terminal_reason: "story_closed",
+                terminal_details: { ...(current.terminal_details ?? {}), operator_reason: "story_closed" },
+                stop_history: [...(current.stop_history ?? []), { at, reason: "story_closed" }],
+            }), false);
+            if (!result.changed)
+                continue;
+            stopLaneProcesses(hqRoot, lane.lane_id, {
+                killProcess: deps.spawnLaneDeps?.killProcess,
+                isAlive: deps.isAlive,
+            });
+            for (const question of questions) {
+                if (question.origin.id !== lane.lane_id || question.status !== "pending")
+                    continue;
+                casQuestionIf(hqRoot, question.question_id, (current) => current.status === "pending", (current) => ({
+                    ...current,
+                    status: "cancelled",
+                    routing_history: appendCappedHistory(current.routing_history, {
+                        hop: current.hop,
+                        audience: { kind: "user" },
+                        at,
+                        reason: "cancelled",
+                    }),
+                }), false);
+            }
+            appendWatcherEvent(watcherEventsPath(hqRoot, lane.lane_id), {
+                event: "story_closed",
+                at,
+                lane_id: lane.lane_id,
+                story_state: [...new Set(ledger.states)].join(","),
+                terminal_reason: "story_closed",
+            });
+            const mesh = deps.mesh === undefined ? createLaneMesh({ interactive: false }) : deps.mesh;
+            if (mesh) {
+                const timeoutMs = deps.meshEmitTimeoutMs ?? 10_000;
+                let timer;
+                try {
+                    await Promise.race([
+                        emitLaneTerminalStateEvent(mesh, result.record, "killed", "story_closed"),
+                        new Promise((_resolve, reject) => {
+                            timer = setTimeout(() => reject(new Error(`terminal mesh emit timed out after ${timeoutMs}ms`)), timeoutMs);
+                        }),
+                    ]);
+                }
+                catch (err) {
+                    markDirty(summary, { kind: "lane", id: lane.lane_id, why: `story close mesh emit failed: ${err instanceof Error ? err.message : String(err)}` });
+                }
+                finally {
+                    if (timer)
+                        clearTimeout(timer);
+                }
+            }
+        }
+        catch (err) {
+            markDirty(summary, { kind: "lane", id: lane.lane_id, why: `story close failed: ${err instanceof Error ? err.message : String(err)}` });
+        }
+    }
+}
+function writeQueueReason(hqRoot, lane, reason, dryRun) {
+    if (lane.queued_reason === reason)
+        return;
+    casLaneIf(hqRoot, lane.lane_id, (current) => current.state === "queued" && current.queued_reason !== reason, (current) => ({ ...current, queued_reason: reason, queued_details: undefined, admission_reserved_at: undefined }), dryRun);
+}
+function availableBalancedAccount(hqRoot, lane, occupying, config, host, profileMaxConcurrent, nowMs) {
+    if (!lane.account || !lane.admission_accounts?.includes(lane.account))
+        return undefined;
+    if (laneAdmissionCapReason(occupying, lane, config, host, profileMaxConcurrent, nowMs) !== "account_cap") {
+        return undefined;
+    }
+    const pinnedModel = lane.model_source === undefined || lane.model_source === "cli" || lane.model_source === "preserved"
+        ? lane.model
+        : lane.model_source === "profile"
+            ? lane.model
+            : undefined;
+    for (const account of lane.admission_accounts) {
+        if (account === lane.account)
+            continue;
+        if (config.providers[lane.provider].accounts[account]?.enabled !== true)
+            continue;
+        const status = accountStatus(lane.provider, account, config, {
+            hostname: host.hostname,
+            existsSync: (file) => fs.existsSync(file),
+        });
+        if (!isCredentialProven(status))
+            continue;
+        try {
+            resolveAccount(lane.provider, account, config, {
+                hqRoot,
+                hostname: host.hostname,
+                ...(pinnedModel !== undefined ? { model: pinnedModel } : {}),
+            });
+        }
+        catch (err) {
+            if (err instanceof AccountResolutionError)
+                continue;
+            throw err;
+        }
+        const candidate = { ...lane, account };
+        if (laneAdmissionCapReason(occupying, candidate, config, host, profileMaxConcurrent, nowMs) === undefined) {
+            return account;
+        }
+    }
+    return undefined;
+}
+function writeAdmissionAccount(hqRoot, lane, account, dryRun) {
+    return casLaneIf(hqRoot, lane.lane_id, (current) => current.state === "queued" &&
+        current.account === lane.account &&
+        current.admission_accounts?.includes(account) === true, (current) => ({ ...current, account }), dryRun).record;
+}
+function casQuestionIf(hqRoot, questionId, shouldWrite, updater, dryRun) {
+    for (let i = 0; i < 5; i += 1) {
+        const current = readQuestion(hqRoot, questionId);
+        if (!shouldWrite(current))
+            return { changed: false, record: current };
+        if (dryRun)
+            return { changed: true, record: updater(current) };
+        try {
+            return {
+                changed: true,
+                record: updateQuestion(hqRoot, questionId, current.version, updater),
+            };
+        }
+        catch (err) {
+            if (!isLaneVersionConflict(err) || i === 4)
+                throw err;
+        }
+    }
+    throw new LanesError("version_conflict", `Exhausted CAS retries for question ${questionId}`, { question_id: questionId });
+}
+async function emitAgedQuestionAtUser(summary, deps, lane, question) {
+    if (deps.dryRun)
+        return;
+    const mesh = deps.mesh === undefined ? createLaneMesh({ interactive: false }) : deps.mesh;
+    const company = laneMeshCompany(lane);
+    if (!mesh || !company || !lane.thread_id)
+        return;
+    const timeoutMs = deps.meshEmitTimeoutMs ?? 10_000;
+    let timer;
+    try {
+        await Promise.race([
+            mesh.appendThreadEvent(company, lane.thread_id, "lane_question_at_user", { lane_id: lane.lane_id, question_id: question.question_id }),
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new Error(`question-at-user mesh emit timed out after ${timeoutMs}ms`)), timeoutMs);
+            }),
+        ]);
+    }
+    catch (err) {
+        markDirty(summary, {
+            kind: "question",
+            id: question.question_id,
+            why: `question-at-user mesh emit failed: ${err instanceof Error ? err.message : String(err)}`,
+        });
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+function pickupValidationPendingAtMs(lane) {
+    const raw = lane.pickup_validation_pending_since ?? lane.updated_at;
+    const at = Date.parse(raw);
+    return Number.isFinite(at) ? at : null;
+}
+function pickupValidationExpired(lane, nowMs) {
+    const pendingAtMs = pickupValidationPendingAtMs(lane);
+    return pendingAtMs === null || nowMs - pendingAtMs > PICKUP_VALIDATION_MAX_AGE_MS;
+}
+function expireAbandonedPickupValidation(hqRoot, lanes, summary, deps, now) {
+    const nowMs = now.getTime();
+    for (const lane of lanes) {
+        if (lane.state !== "queued" ||
+            lane.pickup_validation_pending !== true ||
+            !laneRunsHere(lane, deps.host) ||
+            !pickupValidationExpired(lane, nowMs)) {
+            continue;
+        }
+        try {
+            const result = casLaneIf(hqRoot, lane.lane_id, (current) => current.state === "queued" &&
+                current.pickup_validation_pending === true &&
+                pickupValidationExpired(current, nowMs), (current) => {
+                const pendingAtMs = pickupValidationPendingAtMs(current);
+                return {
+                    ...current,
+                    state: "failed",
+                    queued_reason: undefined,
+                    queued_details: undefined,
+                    pickup_validation_pending: undefined,
+                    pickup_validation_pending_since: undefined,
+                    terminal_reason: PICKUP_VALIDATION_TIMEOUT_REASON,
+                    terminal_details: {
+                        pickup_validation_pending_since: current.pickup_validation_pending_since ?? current.updated_at,
+                        age_ms: pendingAtMs === null ? null : Math.max(0, nowMs - pendingAtMs),
+                        max_age_ms: PICKUP_VALIDATION_MAX_AGE_MS,
+                    },
+                };
+            }, deps.dryRun);
+            if (result.changed) {
+                summary.aged.push({
+                    id: lane.lane_id,
+                    from: "queued",
+                    to: "failed",
+                    reason: PICKUP_VALIDATION_TIMEOUT_REASON,
+                });
+            }
+        }
+        catch (err) {
+            markDirty(summary, {
+                kind: "lane",
+                id: lane.lane_id,
+                why: `pickup validation expiry failed: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+}
+function fileNonEmpty(filePath) {
+    try {
+        return fs.statSync(filePath).size > 0;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return false;
+        throw err;
+    }
+}
+function lastHostReportMs(lane) {
+    const raw = lane.last_host_report_at ?? lane.updated_at;
+    const ms = Date.parse(raw);
+    return Number.isFinite(ms) ? ms : 0;
+}
+function writeHeartbeatFile(hqRoot, summary, at) {
+    const filePath = reconcileHeartbeatPath(hqRoot);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    const body = `${JSON.stringify({ at, ok: summary.ok, action: "reconcile" }, null, 2)}\n`;
+    try {
+        fs.writeFileSync(tmp, body, { encoding: "utf8" });
+        fs.renameSync(tmp, filePath);
+    }
+    catch (err) {
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch (unlinkErr) {
+            const code = unlinkErr.code;
+            if (code !== "ENOENT") {
+                process.stderr.write(`hq lanes reconcile: unlink heartbeat tmp failed: ${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}\n`);
+            }
+        }
+        throw err;
+    }
+}
+function writeAnsweredQuestions(hqRoot, lane, questions) {
+    const filePath = path.join(laneRunDir(hqRoot, lane.lane_id), ANSWERED_QUESTIONS_FILE);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(answeredQuestionEntries(hqRoot, lane, questions), null, 2)}\n`, "utf8");
+}
+async function withReconcileLock(hqRoot, fn) {
+    const lockPath = path.join(hqRoot, "workspace", "lanes-runs", ".admission-locks", "reconcile.lock");
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    const started = Date.now();
+    while (true) {
+        let fd;
+        try {
+            fd = fs.openSync(lockPath, "wx");
+            try {
+                fs.writeSync(fd, Buffer.from(`${process.pid}\n${Date.now()}\n`, "utf8"));
+            }
+            catch (err) {
+                fs.closeSync(fd);
+                fd = undefined;
+                throw err;
+            }
+            try {
+                return await fn();
+            }
+            finally {
+                try {
+                    fs.closeSync(fd);
+                }
+                catch (err) {
+                    process.stderr.write(`hq lanes reconcile: lock close failed: ${err instanceof Error ? err.message : String(err)}\n`);
+                }
+                try {
+                    fs.unlinkSync(lockPath);
+                }
+                catch (err) {
+                    const code = err.code;
+                    if (code !== "ENOENT") {
+                        process.stderr.write(`hq lanes reconcile: lock unlink failed: ${err instanceof Error ? err.message : String(err)}\n`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            const code = err.code;
+            if (code !== "EEXIST")
+                throw err;
+            if (Date.now() - started > RECONCILE_LOCK_TIMEOUT_MS) {
+                throw new LanesError("store_lock_timeout", `Timed out waiting for reconcile lock ${lockPath}`, { path: lockPath });
+            }
+            try {
+                const raw = fs.readFileSync(lockPath, "utf8");
+                const tsLine = raw.split("\n")[1];
+                const ts = tsLine ? Number(tsLine) : NaN;
+                if (Number.isFinite(ts) && Date.now() - ts > RECONCILE_LOCK_STALE_MS) {
+                    try {
+                        fs.unlinkSync(lockPath);
+                    }
+                    catch (unlinkErr) {
+                        const unlinkCode = unlinkErr.code;
+                        if (unlinkCode !== "ENOENT")
+                            throw unlinkErr;
+                    }
+                    continue;
+                }
+            }
+            catch (statErr) {
+                const statCode = statErr.code;
+                if (statCode !== "ENOENT") {
+                    process.stderr.write(`hq lanes reconcile: stale-lock probe failed: ${statErr instanceof Error ? statErr.message : String(statErr)}\n`);
+                }
+            }
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+        }
+    }
+}
+function classifyDeadLocalLane(hqRoot, laneId, now) {
+    const runDir = laneRunDir(hqRoot, laneId);
+    const manifest = readSpawnManifest(runDir);
+    const minEnvelopeName = manifest.envelope_path ? path.basename(manifest.envelope_path) : undefined;
+    const latest = readLatestEnvelopeRecord(hqRoot, laneId, minEnvelopeName);
+    const envelope = latest?.envelope ?? null;
+    const hasPartialOutput = [
+        path.join(runDir, "logs", "worker.out"),
+        path.join(runDir, "logs", "worker.err"),
+        path.join(runDir, "logs", "last-message.txt"),
+    ].some((file) => fileNonEmpty(file));
+    const lane = readLane(hqRoot, laneId);
+    // The same routing as the watcher's exit path (watcher.ts): a provider
+    // failure on the stream is read first, a 429 or quota-worded one becomes
+    // the quota signal, any other becomes provider_rejected, and only a stream
+    // with no failure object falls back to the quota reader.
+    const workerOutOffset = readSpawnManifest(runDir).worker_out_offset ?? 0;
+    const routed = envelope
+        ? { quota: null, rejection: null }
+        : routeProviderFailure(readProviderRejection(runDir, lane.provider, workerOutOffset), () => readQuotaSignal(runDir, lane.model, now, workerOutOffset), lane.model, now);
+    // As in the watcher: a reset-less 429 gets the provider's default hold.
+    const quota = routed.quota
+        ? applyDefaultQuotaHold(routed.quota, providerQuotaDefaultHoldMs(loadLanesConfig(hqRoot).providers[lane.provider]), now)
+        : null;
+    return {
+        classification: classifyLaneExit({
+            envelope,
+            hasPartialOutput,
+            quota,
+            providerRejection: routed.rejection,
+        }),
+        latest,
+        quota,
+        providerRejection: routed.rejection,
+        lane,
+    };
+}
+function runawayGuardCompanyKey(company) {
+    return company
+        ? `${company.uid ?? ""}\u0000${company.slug ?? ""}`
+        : "unresolved-company";
+}
+function reportRunawayGuardError(summary, stage, error) {
+    summary.ok = false;
+    summary.errors.push({
+        code: `runaway_tool_guard_${stage}_failed`,
+        message: `runaway search guard ${stage} failed; no additional search processes were stopped`,
+    });
+    process.stderr.write(`${JSON.stringify({
+        event: "lanes.runaway_tool_guard.failed",
+        stage,
+        error: error instanceof Error ? error.name : "UnknownError",
+        fallback: "continue_without_argv",
+    })}\n`);
+}
+async function runRunawayToolGuardPass(hqRoot, lanes, config, deps, now, summary) {
+    if (deps.dryRun)
+        return;
+    const localRunningLanes = lanes.filter((lane) => lane.state === "running" && laneRunsHere(lane, deps.host));
+    if (localRunningLanes.length === 0)
+        return;
+    const groups = new Map();
+    for (const lane of localRunningLanes) {
+        let worker;
+        try {
+            worker = readPidRecord(path.join(laneRunDir(hqRoot, lane.lane_id), "worker.pid"));
+            if (!worker ||
+                worker.starttime === undefined ||
+                !isPidRecordAlive(worker, deps.isAlive))
+                continue;
+        }
+        catch (error) {
+            reportRunawayGuardError(summary, "worker_pid_read", error);
+            continue;
+        }
+        let company;
+        try {
+            company = resolveLaneCompany(hqRoot, lane).company;
+        }
+        catch (error) {
+            reportRunawayGuardError(summary, "company_resolution", error);
+            continue;
+        }
+        const key = runawayGuardCompanyKey(company);
+        const group = groups.get(key) ?? { company, lanes: [] };
+        group.lanes.push({ laneId: lane.lane_id, agentPid: worker.pid, agentStarttime: worker.starttime });
+        groups.set(key, group);
+    }
+    if (groups.size === 0)
+        return;
+    const readRegistryFlag = deps.readRegistryFlag ?? readLanesRegistryFlag;
+    const enabledGroups = new Set();
+    const env = deps.env ?? process.env;
+    await Promise.all([...groups.entries()].map(async ([key, group]) => {
+        try {
+            const enabled = await readRegistryFlag(RUNAWAY_TOOL_GUARD_FLAG, {
+                company: group.company ?? undefined,
+                env,
+            });
+            if (enabled)
+                enabledGroups.add(key);
+        }
+        catch (error) {
+            reportRunawayGuardError(summary, "flag_read", error);
+        }
+    }));
+    if (enabledGroups.size === 0)
+        return;
+    const laneProcesses = [...groups.entries()]
+        .filter(([key]) => enabledGroups.has(key))
+        .flatMap(([, group]) => group.lanes);
+    if (laneProcesses.length === 0)
+        return;
+    let processes;
+    try {
+        processes = (deps.runawayToolProcessLister ?? listHostProcesses)();
+    }
+    catch (error) {
+        reportRunawayGuardError(summary, "process_table_read", error);
+        return;
+    }
+    const runawayConfig = config.runaway_search_guard ?? DEFAULT_RUNAWAY_SEARCH_GUARD_CONFIG;
+    try {
+        runRunawayToolGuard({
+            hqRoot,
+            lanes: laneProcesses,
+            processes,
+            config: runawayConfig,
+            now,
+            currentUid: process.getuid?.() ?? -1,
+            isCurrentProcess: deps.runawayToolProcessIsCurrent ??
+                ((pid, expectedStarttime) => readProcStarttime(pid) === expectedStarttime),
+            signal: deps.runawayToolProcessSignal ?? ((pid, signal) => process.kill(pid, signal)),
+            recordEvent: (laneId, event) => appendWatcherEvent(watcherEventsPath(hqRoot, laneId), event, deps.runawayToolEventAppend),
+            notifyLane: (laneId, text) => appendDropboxMessage(hqRoot, laneId, {
+                at: now.toISOString(),
+                message_id: `runaway-search-guard:${laneId}:${now.getTime()}`,
+                kind: "system_notice",
+                text,
+            }),
+            reportError: (stage, errorName) => {
+                summary.ok = false;
+                summary.errors.push({
+                    code: `runaway_tool_guard_${stage}_failed`,
+                    message: `runaway search guard could not ${stage} a stopped process (${errorName})`,
+                });
+                process.stderr.write(`${JSON.stringify({
+                    event: "lanes.runaway_tool_guard.failed",
+                    stage,
+                    error: errorName,
+                    fallback: "continue_without_argv",
+                })}\n`);
+            },
+        });
+    }
+    catch (error) {
+        reportRunawayGuardError(summary, "execution", error);
+    }
+}
+/** Unlocked pass body. `runReconcilePass` takes the process lock around this. */
+export async function runPassBody(hqRoot, deps) {
+    const now = deps.now();
+    const nowMs = now.getTime();
+    const nowIso = now.toISOString();
+    const summary = emptySummary(deps.dryRun);
+    const livenessDeps = deps.livenessDeps ?? defaultLivenessDeps();
+    let lanes;
+    let questions;
+    try {
+        lanes = loadLaneRecords(hqRoot, summary);
+        questions = loadQuestionRecords(hqRoot, summary);
+    }
+    catch (err) {
+        markError(summary, err);
+        return summary;
+    }
+    if (deps.terminalKeepAliveCandidate) {
+        return runTerminalKeepAliveCandidatePass(hqRoot, lanes, summary, deps, now, deps.terminalKeepAliveCandidate);
+    }
+    let presenceConnected;
+    try {
+        presenceConnected =
+            deps.presenceConnected ?? readDaemonPresenceConnected(livenessDeps);
+    }
+    catch (err) {
+        markError(summary, err);
+        return summary;
+    }
+    let livenessIndex;
+    try {
+        livenessIndex = loadLivenessIndex(hqRoot, undefined, livenessDeps, !deps.dryRun);
+    }
+    catch (err) {
+        markError(summary, err);
+        return summary;
+    }
+    const config = loadLanesConfig(hqRoot);
+    try {
+        const companyRefs = new Map();
+        for (const lane of lanes) {
+            const company = resolveLaneCompany(hqRoot, lane).company;
+            if (company)
+                companyRefs.set(company.uid ?? company.slug, company);
+        }
+        const readFlag = deps.readRegistryFlag ?? readLanesRegistryFlag;
+        const homes = configuredCodexRolloutHomes(hqRoot, config, deps.host.hostname);
+        let retentionEnabled = false;
+        for (const company of homes.length > 0 ? companyRefs.values() : []) {
+            retentionEnabled ||= await readFlag("lanes.codex-rollout-retention", { company });
+            if (retentionEnabled)
+                break;
+        }
+        if (retentionEnabled) {
+            const statePath = path.join(hqRoot, "workspace", "lanes-runs", `.rollout-retention-${deps.host.hostname.replaceAll(/[^a-zA-Z0-9_-]/g, "_")}.json`);
+            let lastRunAt;
+            try {
+                const state = JSON.parse(fs.readFileSync(statePath, "utf8"));
+                if (typeof state.last_run_at !== "string" || !Number.isFinite(Date.parse(state.last_run_at))) {
+                    throw new LanesError("rollout_retention_state_invalid", `Invalid rollout-retention state at ${statePath}`, { path: statePath });
+                }
+                lastRunAt = Date.parse(state.last_run_at);
+            }
+            catch (err) {
+                if (err.code !== "ENOENT")
+                    throw err;
+            }
+            const lowDisk = homes.some((home) => checkLaneDiskSpace(hqRoot, home, deps.spawnLaneDeps?.statfs, config.low_disk_min_free_bytes).low);
+            if (lowDisk || lastRunAt === undefined || nowMs - lastRunAt >= 60 * 60 * 1000) {
+                const result = await retainCodexRollouts({
+                    homes,
+                    lanes,
+                    nowMs,
+                    compressAfterMs: config.codex_rollout_compress_after_hours * 60 * 60 * 1000,
+                    deleteAfterMs: config.codex_rollout_delete_after_days * 24 * 60 * 60 * 1000,
+                });
+                summary.rollout_retention = result;
+                fs.mkdirSync(path.dirname(statePath), { recursive: true });
+                const tempPath = `${statePath}.${process.pid}.tmp`;
+                fs.writeFileSync(tempPath, `${JSON.stringify({ last_run_at: nowIso }, null, 2)}\n`, { flag: "wx" });
+                fs.renameSync(tempPath, statePath);
+            }
+        }
+    }
+    catch (err) {
+        markDirty(summary, { kind: "store", why: `Codex rollout retention failed: ${err instanceof Error ? err.message : String(err)}` });
+    }
+    const laneById = new Map(lanes.map((lane) => [lane.lane_id, lane]));
+    const readLaneSenior = (laneId) => {
+        const lane = laneById.get(laneId);
+        if (lane)
+            return lane.senior;
+        try {
+            return readLane(hqRoot, laneId).senior;
+        }
+        catch (err) {
+            throw new LanesError("lane_not_found", `Cannot resolve senior for missing lane ${laneId}: ${err instanceof Error ? err.message : String(err)}`, { lane_id: laneId });
+        }
+    };
+    const readSessionSenior = deps.readSessionSenior ??
+        ((sessionId) => defaultReadSessionSenior(hqRoot, sessionId));
+    const configuredClaudeHomes = Object.values(config.providers.claude.accounts).map((account) => effectiveAccountHome(account, deps.host.hostname).home);
+    const sessionStateCache = new Map();
+    const sessionState = (sessionId) => {
+        if (sessionStateCache.has(sessionId)) {
+            return sessionStateCache.get(sessionId) ?? null;
+        }
+        const entry = livenessIndex.sessions[sessionId];
+        if (!entry) {
+            const state = unindexedClaudeSessionLiveness(sessionId, nowMs, config.liveness, livenessDeps, configuredClaudeHomes);
+            sessionStateCache.set(sessionId, state);
+            return state;
+        }
+        const state = classifySessionLiveness(entry, nowMs, presenceConnected, config.liveness);
+        sessionStateCache.set(sessionId, state);
+        return state;
+    };
+    const questionAgeWindowMs = (audience) => audience.kind === "session"
+        ? config.session_question_timeout_secs * 1000
+        : QUESTION_AGE_MS;
+    if (deps.afterLoad)
+        await deps.afterLoad();
+    await runRunawayToolGuardPass(hqRoot, lanes, config, deps, now, summary);
+    const startDeps = deps;
+    markOverdueLanes(hqRoot, lanes, summary, deps, now);
+    await heartbeatAndDeadHosts(hqRoot, lanes, summary, startDeps, now);
+    for (const question of questions) {
+        if (question.status !== "pending")
+            continue;
+        let audience;
+        try {
+            audience = resolveQuestionAudience(question, readLaneSenior, readSessionSenior);
+        }
+        catch (err) {
+            markDirty(summary, {
+                kind: "question",
+                id: question.question_id,
+                why: `audience unreadable: ${err instanceof Error ? err.message : String(err)}`,
+            });
+            continue;
+        }
+        try {
+            let liveness;
+            try {
+                liveness =
+                    audience.kind === "session" && audience.id
+                        ? sessionState(audience.id)
+                        : audience.kind === "user"
+                            ? "live"
+                            : null;
+            }
+            catch (err) {
+                // A failed metadata probe cannot prove that the session ended, but it
+                // must not suppress the independent unanswered-timeout rule below.
+                markError(summary, err);
+                liveness = null;
+            }
+            if (shouldAdvanceAudienceEnded(audience, liveness)) {
+                const nextHop = question.hop + 1;
+                const nextAudience = resolveQuestionAudience({ ...question, hop: nextHop }, readLaneSenior, readSessionSenior);
+                const result = casQuestionIf(hqRoot, question.question_id, (current) => current.status === "pending" && current.hop === question.hop, (current) => {
+                    const entry = {
+                        hop: nextHop,
+                        audience: nextAudience,
+                        at: nowIso,
+                        reason: "audience_ended",
+                    };
+                    return {
+                        ...current,
+                        hop: nextHop,
+                        routing_history: appendCappedHistory(current.routing_history, entry),
+                    };
+                }, deps.dryRun);
+                if (result.changed) {
+                    summary.advanced.push({
+                        id: question.question_id,
+                        from: String(question.hop),
+                        to: String(nextHop),
+                        reason: "audience_ended",
+                    });
+                }
+                continue;
+            }
+            if (shouldAgeQuestion(question, audience, nowMs, questionAgeWindowMs(audience))) {
+                const nextHop = question.hop + 1;
+                const nextAudience = resolveQuestionAudience({ ...question, hop: nextHop }, readLaneSenior, readSessionSenior);
+                const result = casQuestionIf(hqRoot, question.question_id, (current) => {
+                    if (current.status !== "pending" ||
+                        agedAdvanceCount(current) >= MAX_AGED_ADVANCES) {
+                        return false;
+                    }
+                    const currentAudience = resolveQuestionAudience(current, readLaneSenior, readSessionSenior);
+                    return shouldAgeQuestion(current, currentAudience, nowMs, questionAgeWindowMs(currentAudience));
+                }, (current) => {
+                    const entry = {
+                        hop: current.hop + 1,
+                        audience: nextAudience,
+                        at: nowIso,
+                        reason: "unanswered_timeout",
+                    };
+                    return {
+                        ...current,
+                        hop: current.hop + 1,
+                        routing_history: appendCappedHistory(current.routing_history, entry),
+                    };
+                }, deps.dryRun);
+                if (result.changed) {
+                    summary.aged.push({
+                        id: question.question_id,
+                        from: String(question.hop),
+                        to: String(nextHop),
+                        reason: "unanswered_timeout",
+                    });
+                    if (nextAudience.kind === "user") {
+                        const originLane = laneById.get(question.lane_id) ?? readLane(hqRoot, question.lane_id);
+                        await emitAgedQuestionAtUser(summary, deps, originLane, result.record);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            markDirty(summary, {
+                kind: "question",
+                id: question.question_id,
+                why: `advance failed: ${err instanceof LanesError ? `${err.error}: ` : ""}${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    const readRegistryFlag = deps.readRegistryFlag ?? readLanesRegistryFlag;
+    const storyCloseCompanies = new Map();
+    for (const lane of lanes) {
+        if (lane.depth < 1 || lane.state !== "interrupted" || lane.keep_alive === true ||
+            !laneRunsHere(lane, deps.host) || !lane.interrupted_at ||
+            !Number.isFinite(Date.parse(lane.interrupted_at)) ||
+            nowMs - Date.parse(lane.interrupted_at) < INTERRUPTED_DONE_STORY_MIN_AGE_MS ||
+            hasPendingKeepAliveWork(hqRoot, lane, questions) || laneStories(lane).length === 0)
+            continue;
+        try {
+            const company = resolveLaneCompany(hqRoot, lane).company;
+            if (company)
+                storyCloseCompanies.set(keepAliveCompanyKey(company), company);
+        }
+        catch (err) {
+            markDirty(summary, { kind: "lane", id: lane.lane_id, why: `story close company lookup failed: ${err instanceof Error ? err.message : String(err)}` });
+        }
+    }
+    const storyCloseEnabledByCompany = new Map();
+    const env = deps.env ?? process.env;
+    await Promise.all([...storyCloseCompanies.entries()].map(async ([key, company]) => {
+        try {
+            storyCloseEnabledByCompany.set(key, await readRegistryFlag(CLOSE_INTERRUPTED_DONE_STORY_WORKERS_FLAG, {
+                company: company ?? undefined,
+                env,
+            }));
+        }
+        catch (err) {
+            storyCloseEnabledByCompany.set(key, false);
+            markDirty(summary, { kind: "lane", why: `story close flag read failed for ${company?.slug ?? "unresolved company"}: ${err instanceof Error ? err.message : String(err)}` });
+        }
+    }));
+    const keepAliveFlagCompanies = new Map();
+    for (const lane of lanes) {
+        if (!(lane.state === "done" || lane.state === "interrupted" || lane.state === "blocked" || lane.state === "killed" || lane.state === "cancelled" || lane.state === "failed") ||
+            (lane.keep_alive !== true && lane.worker_profile === undefined) ||
+            (lane.state === "blocked" && lane.keep_alive !== true) ||
+            !laneRunsHere(lane, deps.host) ||
+            (lane.state === "done" && (lane.terminal_reason === PROVIDER_REJECTED_REASON ||
+                lane.terminal_reason === "account_not_logged_in" ||
+                !providerSupportsSessionResume(lane.provider) ||
+                !(lane.provider_session_id ?? lane.last_resume?.session_id))))
+            continue;
+        if (lane.state === "done") {
+            const envelope = readLatestEnvelopeRecord(hqRoot, lane.lane_id)?.envelope;
+            if (!envelope || envelope.decision !== "done")
+                continue;
+            const hasQueuedWork = lane.keep_alive_standing === true && hasPendingKeepAliveWork(hqRoot, lane, questions);
+            if (doneKeepAliveVerdict(lane, envelope, hasQueuedWork, {
+                hasPendingWork: hasPendingKeepAliveWork(hqRoot, lane, questions),
+                nowMs: now.getTime(),
+                nextCheckAnchorMs: Date.parse(lane.last_envelope?.at ?? lane.updated_at),
+            }) !== "eligible")
+                continue;
+        }
+        const company = resolveLaneCompany(hqRoot, lane).company;
+        if (company === null)
+            continue;
+        const key = keepAliveCompanyKey(company);
+        keepAliveFlagCompanies.set(key, company);
+    }
+    const keepAliveFlagByCompany = new Map();
+    const blockedResumeFlagByCompany = new Map();
+    const immediateFirstResumeFlagByCompany = new Map();
+    const supersessionLineageAwareByCompany = new Map();
+    await Promise.all([...keepAliveFlagCompanies.entries()].map(async ([key, company]) => {
+        const options = {
+            company: company ?? undefined,
+            env,
+        };
+        const hasBlockedKeepAliveLane = lanes.some((lane) => lane.state === "blocked" &&
+            lane.keep_alive === true &&
+            laneRunsHere(lane, startDeps.host) &&
+            keepAliveCompanyKey(resolveLaneCompany(hqRoot, lane).company) === key);
+        const [keepAliveEnabled, lineageAware, blockedResumeEnabled, immediateFirstResumeEnabled] = await Promise.all([
+            readRegistryFlag(LEAD_LANE_KEEP_ALIVE_FLAG, options),
+            readRegistryFlag(LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, options),
+            hasBlockedKeepAliveLane
+                ? readRegistryFlag(LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG, options)
+                : Promise.resolve(false),
+            readRegistryFlag(LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_FLAG, options),
+        ]);
+        keepAliveFlagByCompany.set(key, keepAliveEnabled);
+        blockedResumeFlagByCompany.set(key, blockedResumeEnabled);
+        immediateFirstResumeFlagByCompany.set(key, immediateFirstResumeEnabled);
+        supersessionLineageAwareByCompany.set(key, lineageAware);
+    }));
+    const admissionThrottleDeps = startDeps.throttleDeps ?? defaultThrottleDeps(startDeps.env ?? process.env);
+    const hasAdmissionCandidates = lanes.some((lane) => laneRunsHere(lane, startDeps.host) &&
+        (lane.state === "queued" || lane.state === "awaiting_input")) || [...keepAliveFlagByCompany.values()].some(Boolean);
+    const priorThrottleState = readThrottleState(throttleStatePath(hqRoot), admissionThrottleDeps);
+    const priorThrottleSnapshot = priorThrottleState === "missing" || priorThrottleState === "unreadable"
+        ? undefined
+        : priorThrottleState.cpu_snapshot;
+    const cpuObservation = await sampleCpuBusyObservation(admissionThrottleDeps, priorThrottleSnapshot, { measureBusy: hasAdmissionCandidates });
+    const admissionDeps = {
+        ...startDeps,
+        cpuBusyFraction: cpuObservation.busy,
+        cpuObservation,
+        skipAdmissionWithoutCpuSample: !hasAdmissionCandidates,
+    };
+    await withAllLaneAdmissionLocks(hqRoot, async () => {
+        const freshLanes = loadLaneRecords(hqRoot, summary);
+        const freshQuestions = loadQuestionRecords(hqRoot, summary);
+        await closeInterruptedDoneStoryWorkers(hqRoot, freshLanes, freshQuestions, summary, admissionDeps, now, storyCloseEnabledByCompany);
+        await resumeKeepAlive(hqRoot, freshLanes, freshQuestions, summary, admissionDeps, now, keepAliveFlagByCompany, supersessionLineageAwareByCompany, blockedResumeFlagByCompany, immediateFirstResumeFlagByCompany, deps.terminalKeepAliveCandidate);
+        const drainLanes = loadLaneRecords(hqRoot, summary);
+        await admitQueued(hqRoot, drainLanes, summary, admissionDeps, now);
+        await resumeAwaiting(hqRoot, drainLanes, freshQuestions, summary, admissionDeps);
+    });
+    if (!deps.dryRun && cpuObservation.snapshot !== undefined) {
+        const latestThrottleState = readThrottleState(throttleStatePath(hqRoot), admissionThrottleDeps);
+        if (latestThrottleState === "unreadable") {
+            markError(summary, new LanesError("throttle_state_unreadable", "Throttle state became unreadable while reconciling"));
+        }
+        else {
+            const currentThrottleState = latestThrottleState === "missing"
+                ? emptyThrottleState()
+                : latestThrottleState;
+            writeThrottleState(throttleStatePath(hqRoot), recordCpuBusyObservation(currentThrottleState, cpuObservation), admissionThrottleDeps);
+        }
+    }
+    if (!deps.dryRun && summary.errors.length === 0) {
+        try {
+            writeHeartbeatFile(hqRoot, summary, nowIso);
+            summary.heartbeat_at = nowIso;
+        }
+        catch (err) {
+            markError(summary, err);
+        }
+    }
+    return summary;
+}
+function markOverdueLanes(hqRoot, lanes, summary, deps, now) {
+    const nowMs = now.getTime();
+    const nowIso = now.toISOString();
+    for (const lane of lanes) {
+        if (lane.overdue === true)
+            continue;
+        if (!laneRunsHere(lane, deps.host))
+            continue;
+        let deadline;
+        try {
+            deadline = readTimeoutDeadline(hqRoot, lane.lane_id);
+        }
+        catch (err) {
+            markDirty(summary, {
+                kind: "lane",
+                id: lane.lane_id,
+                why: `timeout unreadable: ${err instanceof Error ? err.message : String(err)}`,
+            });
+            continue;
+        }
+        if (!deadline || !isDeadlinePassed(deadline.deadline_at, nowMs))
+            continue;
+        try {
+            const result = casLaneIf(hqRoot, lane.lane_id, (current) => current.overdue !== true, (current) => ({
+                ...current,
+                overdue: true,
+                overdue_at: nowIso,
+            }), deps.dryRun);
+            if (result.changed) {
+                summary.overdue.push({
+                    id: lane.lane_id,
+                    from: "ok",
+                    to: "overdue",
+                });
+            }
+        }
+        catch (err) {
+            markDirty(summary, {
+                kind: "lane",
+                id: lane.lane_id,
+                why: `overdue CAS failed: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+}
+async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
+    const nowMs = now.getTime();
+    const nowIso = now.toISOString();
+    const isAlive = deps.isAlive ?? isPidAlive;
+    for (const lane of lanes) {
+        if (lane.state !== "running")
+            continue;
+        const local = laneRunsHere(lane, deps.host);
+        if (local) {
+            const runDir = laneRunDir(hqRoot, lane.lane_id);
+            let workerPid;
+            let watcherPid;
+            let workerAlive;
+            let watcherAlive;
+            try {
+                const workerRec = readPidRecord(path.join(runDir, "worker.pid"));
+                const watcherRec = readPidRecord(path.join(runDir, "watcher.pid"));
+                workerPid = workerRec?.pid ?? null;
+                watcherPid = watcherRec?.pid ?? null;
+                workerAlive = workerRec !== null && isPidRecordAlive(workerRec, isAlive);
+                watcherAlive = watcherRec !== null && isPidRecordAlive(watcherRec, isAlive);
+            }
+            catch (err) {
+                markDirty(summary, {
+                    kind: "lane",
+                    id: lane.lane_id,
+                    why: `pid file unreadable: ${err instanceof Error ? err.message : String(err)}`,
+                });
+                continue;
+            }
+            if (workerAlive) {
+                try {
+                    const result = casLaneIf(hqRoot, lane.lane_id, (current) => current.last_host_report_at !== nowIso, (current) => ({ ...current, last_host_report_at: nowIso }), deps.dryRun);
+                    if (result.changed)
+                        summary.heartbeats.push(lane.lane_id);
+                }
+                catch (err) {
+                    markDirty(summary, {
+                        kind: "lane",
+                        id: lane.lane_id,
+                        why: `heartbeat CAS failed: ${err instanceof Error ? err.message : String(err)}`,
+                    });
+                }
+                if (!watcherAlive && !deps.dryRun) {
+                    try {
+                        armLaneWatcher(hqRoot, lane.lane_id, spawnDepsForHost(deps));
+                        summary.heartbeats.push(`${lane.lane_id}:watcher-rearmed`);
+                    }
+                    catch (err) {
+                        markDirty(summary, {
+                            kind: "lane",
+                            id: lane.lane_id,
+                            why: `watcher re-arm failed: ${err instanceof Error ? err.message : String(err)}`,
+                        });
+                    }
+                }
+                continue;
+            }
+            if (watcherAlive) {
+                // Watcher owns terminal classification of a process that has just exited.
+                continue;
+            }
+            const hadPids = workerPid !== null || watcherPid !== null;
+            if (!hadPids && nowMs - lastHostReportMs(lane) < DEAD_HOST_MS) {
+                try {
+                    const result = casLaneIf(hqRoot, lane.lane_id, (current) => current.last_host_report_at !== nowIso, (current) => ({ ...current, last_host_report_at: nowIso }), deps.dryRun);
+                    if (result.changed)
+                        summary.heartbeats.push(lane.lane_id);
+                }
+                catch (err) {
+                    markDirty(summary, {
+                        kind: "lane",
+                        id: lane.lane_id,
+                        why: `heartbeat CAS failed: ${err instanceof Error ? err.message : String(err)}`,
+                    });
+                }
+                continue;
+            }
+            try {
+                const { classification, latest, quota, providerRejection, lane: classified } = classifyDeadLocalLane(hqRoot, lane.lane_id, now);
+                // Match the watcher's one-repair decision before classifying an
+                // unparseable envelope after both processes have died. As in the
+                // watcher, a provider rejection or a quota signal skips the repair.
+                const runDir = laneRunDir(hqRoot, lane.lane_id);
+                const manifest = readSpawnManifest(runDir);
+                const minEnvelopeName = manifest.envelope_path ? path.basename(manifest.envelope_path) : undefined;
+                const rawLatest = readLatestEnvelopeFile(hqRoot, lane.lane_id, minEnvelopeName);
+                const missingExpected = rawLatest === null
+                    ? missingExpectedEnvelopeFile(hqRoot, lane.lane_id, manifest.envelope_path)
+                    : null;
+                const repairCandidate = rawLatest ?? missingExpected;
+                let invalidEnvelope = null;
+                if (!deps.dryRun &&
+                    !providerRejection &&
+                    !quota &&
+                    repairCandidate &&
+                    repairCandidate.envelope === null &&
+                    (!repairCandidate.missing || envelopeRepairMode(classified.provider) === "resume")) {
+                    if (await lowDiskGuardEnabledForLane(hqRoot, classified, deps.readRegistryFlag)) {
+                        const repairConfig = loadLanesConfig(hqRoot);
+                        const repairAccount = classified.account
+                            ? repairConfig.providers[classified.provider].accounts[classified.account]
+                            : undefined;
+                        if (!repairAccount) {
+                            throw new LanesError("low_disk_account_unavailable", `Cannot determine provider home for envelope repair of lane ${classified.lane_id}`, { lane_id: classified.lane_id });
+                        }
+                        const providerHome = effectiveAccountHome(repairAccount, deps.host.hostname).home;
+                        const free = checkLaneDiskSpace(hqRoot, providerHome, deps.spawnLaneDeps?.statfs, repairConfig.low_disk_min_free_bytes);
+                        if (free.low) {
+                            const measuredAt = now.toISOString();
+                            updateLane(hqRoot, classified.lane_id, classified.version, "reconcile", (current) => ({
+                                ...current,
+                                state: "queued",
+                                queued_reason: "low_disk",
+                                queued_details: { reason: "low_disk", hq_free_bytes: free.hq.free_bytes, provider_free_bytes: free.provider.free_bytes, measured_at: measuredAt },
+                                queued_at: current.queued_at ?? measuredAt,
+                                admission_reserved_at: undefined,
+                                terminal_reason: undefined,
+                                terminal_details: undefined,
+                            }));
+                            summary.skipped.push({ kind: "lane", id: classified.lane_id, why: `low_disk: hq=${free.hq.free_bytes} provider=${free.provider.free_bytes}` });
+                            continue;
+                        }
+                    }
+                    const spawnRepair = deps.spawnRepair ??
+                        ((root, repairLane, input) => spawnEnvelopeRepair(root, repairLane, input, spawnDepsForHost(deps)));
+                    const repair = decideEnvelopeRepair(hqRoot, lane.lane_id, repairCandidate, nowMs, spawnRepair, () => undefined);
+                    if (repair.action === "spawned") {
+                        armLaneWatcher(hqRoot, lane.lane_id, spawnDepsForHost(deps));
+                        summary.heartbeats.push(`${lane.lane_id}:envelope-repair`);
+                        continue;
+                    }
+                    if (!repairCandidate.missing)
+                        invalidEnvelope = { errors: repair.errors };
+                }
+                let repairedClassification = invalidEnvelope
+                    ? classifyLaneExit({ envelope: null, hasPartialOutput: false, invalidEnvelope })
+                    : classification;
+                let questionRefusalCode = null;
+                const accountRetryReason = quota
+                    ? "usage_limit"
+                    : providerRejection && classification.reason === "account_not_logged_in"
+                        ? "account_unavailable"
+                        : null;
+                if (!deps.dryRun &&
+                    quota &&
+                    classified.account &&
+                    (classification.reason === "account_quota_exhausted" ||
+                        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", {
+                            ...spawnDepsForHost(deps),
+                        });
+                        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 &&
+                    (latest.envelope.questions?.length ?? 0) > 0) {
+                    const questionLane = readLane(hqRoot, lane.lane_id);
+                    try {
+                        const activeCompany = await resolveQuestionCompanyWithFallback(hqRoot, questionLane, deps.resolveQuestionActiveCompany);
+                        raiseEnvelopeQuestions(hqRoot, questionLane, latest.envelope, latest.ref, nowIso, undefined, activeCompany);
+                    }
+                    catch (err) {
+                        questionRefusalCode = questionRecordRefusalCode(err);
+                        if (questionRefusalCode === null)
+                            throw err;
+                        repairedClassification = {
+                            state: "failed",
+                            reason: `question_record_refused:${questionRefusalCode}`,
+                        };
+                        process.stderr.write(`hq lanes reconcile: terminal ask refused for ${lane.lane_id}: ${questionRefusalCode}\n`);
+                    }
+                }
+                let terminalEnvelope = latest?.envelope;
+                let terminalClassification = repairedClassification;
+                const result = casLaneIf(hqRoot, lane.lane_id, (current) => current.state === "running", (current) => {
+                    const approvalGate = latest?.envelope
+                        ? enforceRegistryApprovalGate(current, latest.envelope)
+                        : undefined;
+                    terminalEnvelope = approvalGate?.envelope ?? latest?.envelope;
+                    terminalClassification = approvalGate?.violation
+                        ? { state: "blocked", reason: "approval_gate_violated" }
+                        : repairedClassification;
+                    const next = {
+                        ...current,
+                        state: terminalClassification.state,
+                        queued_reason: undefined,
+                        queued_details: undefined,
+                        terminal_reason: terminalClassification.reason ?? "host_lost",
+                        interrupted_at: terminalClassification.state === "interrupted" ? nowIso : undefined,
+                        ...(providerRejection
+                            ? { terminal_details: providerRejectionDetails(providerRejection, current) }
+                            : {}),
+                        ...(quota?.quota_reset_at ? { quota_reset_at: quota.quota_reset_at } : {}),
+                        ...(quota?.marker ? { model_quota_marker: quota.marker } : {}),
+                        last_host_report_at: nowIso,
+                    };
+                    if (approvalGate && !approvalGate.violation && approvalGate.approvedIdsToConsume.length > 0) {
+                        next.registry_worker_approval_history = approvalGate.approvedIdsToConsume.reduce((history, approvalId) => appendCappedHistory(history, {
+                            event: "consumed",
+                            approval_id: approvalId,
+                            envelope_ref: latest.ref,
+                            at: nowIso,
+                        }), current.registry_worker_approval_history ?? []);
+                    }
+                    if (terminalEnvelope && latest) {
+                        const envelope = terminalEnvelope;
+                        next.last_envelope = {
+                            ref: latest.ref,
+                            decision: envelope.decision,
+                            at: nowIso,
+                            artifacts: envelope.artifacts,
+                            ...(envelope.blocked_reason !== undefined ? { blocked_reason: envelope.blocked_reason } : {}),
+                        };
+                        const storySwitch = applyStorySwitchEnvelope(current, envelope, nowIso, latest.ref);
+                        if (storySwitch.clearPending) {
+                            next.story_switch_pending = undefined;
+                        }
+                        if (storySwitch.storySwitchUnacknowledged !== undefined) {
+                            next.story_switch_unacknowledged = storySwitch.storySwitchUnacknowledged;
+                            next.attribution_history = storySwitch.attributionHistory ?? current.attribution_history;
+                        }
+                        const storyStatus = storySwitch.suppressCompletion
+                            ? "in_progress"
+                            : terminalEnvelopeStoryStatus(current, envelope.decision, envelope.story_status);
+                        if (storyStatus !== undefined) {
+                            next.story_status = storySwitch.suppressCompletion ? "in_progress" : envelope.story_status;
+                            next.story_complete = storySwitch.suppressCompletion ? false : envelope.story_complete;
+                            next.story_complete_reason = storySwitch.suppressCompletion ? undefined : envelope.story_complete_reason;
+                            next.stories = laneStories(current).map((story) => story.project_id === current.project_id && story.story_id === current.story_id
+                                ? {
+                                    ...story,
+                                    status: storyStatus,
+                                    updated_at: nowIso,
+                                    ...(envelope.decision === "blocked"
+                                        ? { blocked_reason: envelope.blocked_reason ?? "" }
+                                        : { blocked_reason: undefined }),
+                                }
+                                : story);
+                        }
+                        if (approvalGate?.violation) {
+                            next.last_envelope = {
+                                ref: latest.ref,
+                                decision: envelope.decision,
+                                at: nowIso,
+                                artifacts: envelope.artifacts,
+                                blocked_reason: envelope.blocked_reason,
+                            };
+                        }
+                    }
+                    return next;
+                }, deps.dryRun);
+                if (!deps.dryRun &&
+                    result.changed &&
+                    result.record.state === "done" &&
+                    terminalClassification.state === "done" &&
+                    terminalEnvelope?.decision === "done" &&
+                    !quota &&
+                    !providerRejection &&
+                    result.record.account &&
+                    result.record.model) {
+                    clearAccountQuotaAfterSuccessfulTurnBestEffort(hqRoot, result.record.provider, result.record.account, result.record.model, new Date(nowIso));
+                }
+                if (result.changed) {
+                    summary.dead_host.push({
+                        id: lane.lane_id,
+                        from: "running",
+                        to: terminalClassification.state,
+                        reason: terminalClassification.reason ?? "host_lost",
+                    });
+                    if (terminalEnvelope && latest && questionRefusalCode === null) {
+                        const mesh = deps.mesh === undefined ? createLaneMesh({ interactive: false }) : deps.mesh;
+                        if (mesh) {
+                            const meshEmitTimeoutMs = deps.meshEmitTimeoutMs ?? 10_000;
+                            let timer;
+                            try {
+                                const questionIds = terminalEnvelope.decision === "ask"
+                                    ? envelopeQuestionIds(lane.lane_id, latest.ref, terminalEnvelope)
+                                    : undefined;
+                                await Promise.race([
+                                    emitLaneDecisionEvents(mesh, result.record, terminalEnvelope, { questionIds }),
+                                    new Promise((_resolve, reject) => {
+                                        timer = setTimeout(() => reject(new Error(`terminal mesh emit timed out after ${meshEmitTimeoutMs}ms`)), meshEmitTimeoutMs);
+                                    }),
+                                ]);
+                            }
+                            catch (err) {
+                                markDirty(summary, {
+                                    kind: "lane",
+                                    id: lane.lane_id,
+                                    why: `terminal mesh emit failed: ${err instanceof Error ? err.message : String(err)}`,
+                                });
+                            }
+                            finally {
+                                if (timer)
+                                    clearTimeout(timer);
+                            }
+                        }
+                    }
+                    else if (!deps.dryRun &&
+                        (result.record.state === "failed" || result.record.state === "interrupted" ||
+                            result.record.state === "cancelled" || result.record.state === "killed")) {
+                        const mesh = deps.mesh === undefined ? createLaneMesh({ interactive: false }) : deps.mesh;
+                        if (mesh) {
+                            const meshEmitTimeoutMs = deps.meshEmitTimeoutMs ?? 10_000;
+                            let timer;
+                            try {
+                                await Promise.race([
+                                    emitLaneTerminalStateEvent(mesh, result.record, result.record.state, result.record.terminal_reason),
+                                    new Promise((_resolve, reject) => {
+                                        timer = setTimeout(() => reject(new Error(`terminal mesh emit timed out after ${meshEmitTimeoutMs}ms`)), meshEmitTimeoutMs);
+                                    }),
+                                ]);
+                            }
+                            catch (err) {
+                                markDirty(summary, {
+                                    kind: "lane",
+                                    id: lane.lane_id,
+                                    why: `terminal mesh emit failed: ${err instanceof Error ? err.message : String(err)}`,
+                                });
+                            }
+                            finally {
+                                if (timer)
+                                    clearTimeout(timer);
+                            }
+                        }
+                    }
+                    if (!deps.dryRun && deps.recoverQueuedMessages) {
+                        try {
+                            await deps.recoverQueuedMessages(result.record);
+                        }
+                        catch (err) {
+                            markDirty(summary, {
+                                kind: "lane",
+                                id: lane.lane_id,
+                                why: `queued message recovery failed: ${err instanceof Error ? err.message : String(err)}`,
+                            });
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                markDirty(summary, {
+                    kind: "lane",
+                    id: lane.lane_id,
+                    why: `dead-host classify failed: ${err instanceof Error ? err.message : String(err)}`,
+                });
+            }
+            continue;
+        }
+        if (nowMs - lastHostReportMs(lane) < DEAD_HOST_MS)
+            continue;
+        try {
+            const result = casLaneIf(hqRoot, lane.lane_id, (current) => current.state === "running" &&
+                nowMs - lastHostReportMs(current) >= DEAD_HOST_MS, (current) => ({
+                ...current,
+                state: "interrupted",
+                queued_reason: undefined,
+                queued_details: undefined,
+                terminal_reason: "host_lost",
+                interrupted_at: nowIso,
+            }), deps.dryRun);
+            if (result.changed) {
+                summary.dead_host.push({
+                    id: lane.lane_id,
+                    from: "running",
+                    to: "interrupted",
+                    reason: "host_lost",
+                });
+                const mesh = !deps.dryRun
+                    ? deps.mesh === undefined ? createLaneMesh({ interactive: false }) : deps.mesh
+                    : null;
+                if (mesh) {
+                    const meshEmitTimeoutMs = deps.meshEmitTimeoutMs ?? 10_000;
+                    let timer;
+                    try {
+                        await Promise.race([
+                            emitLaneTerminalStateEvent(mesh, result.record, "interrupted", "host_lost"),
+                            new Promise((_resolve, reject) => {
+                                timer = setTimeout(() => reject(new Error(`terminal mesh emit timed out after ${meshEmitTimeoutMs}ms`)), meshEmitTimeoutMs);
+                            }),
+                        ]);
+                    }
+                    catch (err) {
+                        markDirty(summary, {
+                            kind: "lane",
+                            id: lane.lane_id,
+                            why: `terminal mesh emit failed: ${err instanceof Error ? err.message : String(err)}`,
+                        });
+                    }
+                    finally {
+                        if (timer)
+                            clearTimeout(timer);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            markDirty(summary, {
+                kind: "lane",
+                id: lane.lane_id,
+                why: `dead-host CAS failed: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+}
+async function admitQueued(hqRoot, lanes, summary, deps, now, onlyLaneIds) {
+    if (onlyLaneIds === undefined)
+        expireAbandonedPickupValidation(hqRoot, lanes, summary, deps, now);
+    // A lane whose pickup probe is still out is not admitted: its record is
+    // about to be bound or failed by the pickup, and a worker spawned now
+    // would keep running behind that write.
+    const localQueued = lanes
+        .filter((lane) => lane.state === "queued" &&
+        (onlyLaneIds === undefined || onlyLaneIds.has(lane.lane_id)) &&
+        lane.pickup_validation_pending !== true &&
+        laneRunsHere(lane, deps.host))
+        .filter((lane) => !hasFreshAdmissionReservation(lane, now.getTime()))
+        .sort(compareLaneQueueOrder);
+    if (localQueued.length === 0 || deps.skipAdmissionWithoutCpuSample === true)
+        return;
+    const config = loadLanesConfig(hqRoot);
+    const throttleDeps = deps.throttleDeps ?? defaultThrottleDeps(deps.env ?? process.env);
+    const filePath = throttleStatePath(hqRoot);
+    const loaded = readThrottleState(filePath, throttleDeps);
+    const throttleState = loaded === "unreadable"
+        ? "unreadable"
+        : loaded === "missing"
+            ? emptyThrottleState()
+            : loaded;
+    const busy = deps.cpuBusyFraction !== undefined
+        ? deps.cpuBusyFraction
+        : await resolveCpuBusyFraction(throttleDeps);
+    const availableMemMb = readAvailableMemMb(throttleDeps);
+    const nowMs = now.getTime();
+    const decision = evaluateThrottle({
+        busy,
+        availableMemMb,
+        cpuCheckEnabled: isCpuCheckEnabled(throttleDeps.env),
+        state: throttleState,
+        throttle: config.throttle,
+        nowMs,
+    });
+    const spawnFn = deps.spawn ??
+        (async (root, lane) => spawnLaneWorker(root, lane, {
+            ...spawnDepsForHost(deps),
+            lowDiskGuardEnabled: await lowDiskGuardEnabledForLane(root, lane, deps.readRegistryFlag),
+        }));
+    const running = lanes.filter((lane) => (lane.state === "running" ||
+        hasFreshAdmissionReservation(lane, now.getTime()) ||
+        hasActivePendingResume(lane, now.getTime())) &&
+        laneRunsHere(lane, deps.host));
+    const spawned = [];
+    if (!decision.admit) {
+        for (const lane of localQueued) {
+            let profileMaxConcurrent;
+            if (lane.worker_profile !== undefined) {
+                try {
+                    profileMaxConcurrent = loadWorkerProfile(hqRoot, lane.worker_profile).meta.max_concurrent;
+                }
+                catch (err) {
+                    markDirty(summary, {
+                        kind: "lane",
+                        id: lane.lane_id,
+                        why: `profile admission failed: ${err instanceof Error ? err.message : String(err)}`,
+                    });
+                    continue;
+                }
+            }
+            const capReason = laneAdmissionCapReason(running, lane, config, deps.host, profileMaxConcurrent, now.getTime());
+            writeQueueReason(hqRoot, lane, capReason ?? "throttle", deps.dryRun);
+        }
+        if (!deps.dryRun && throttleState !== "unreadable") {
+            writeThrottleState(filePath, applyThrottleDecision(throttleState, decision, nowMs), throttleDeps);
+        }
+        return;
+    }
+    for (const lane of localQueued) {
+        let profileMaxConcurrent;
+        if (lane.worker_profile !== undefined) {
+            try {
+                profileMaxConcurrent = loadWorkerProfile(hqRoot, lane.worker_profile).meta.max_concurrent;
+            }
+            catch (err) {
+                markDirty(summary, {
+                    kind: "lane",
+                    id: lane.lane_id,
+                    why: `profile admission failed: ${err instanceof Error ? err.message : String(err)}`,
+                });
+                continue;
+            }
+        }
+        const projected = [...running, ...spawned];
+        const alternateAccount = availableBalancedAccount(hqRoot, lane, projected, config, deps.host, profileMaxConcurrent, now.getTime());
+        const admittedLane = alternateAccount !== undefined
+            ? writeAdmissionAccount(hqRoot, lane, alternateAccount, deps.dryRun)
+            : lane;
+        const baseCap = laneAdmissionCapReason(running, admittedLane, config, deps.host, profileMaxConcurrent, now.getTime());
+        const currentCap = laneAdmissionCapReason([...running, ...spawned], admittedLane, config, deps.host, profileMaxConcurrent, now.getTime());
+        let blockedBy;
+        if (currentCap !== undefined) {
+            blockedBy = baseCap ?? "queue_position";
+        }
+        if (!blockedBy && !decision.admit)
+            blockedBy = "throttle";
+        if (blockedBy) {
+            writeQueueReason(hqRoot, admittedLane, blockedBy, deps.dryRun);
+            continue;
+        }
+        try {
+            if (deps.dryRun) {
+                summary.admitted.push({
+                    id: lane.lane_id,
+                    from: "queued",
+                    to: "running",
+                    reason: decision.reason,
+                });
+                spawned.push({ ...admittedLane, state: "running" });
+                continue;
+            }
+            const started = await spawnFn(hqRoot, admittedLane);
+            if (decision.reason === "starvation_bound") {
+                casLaneIf(hqRoot, lane.lane_id, (current) => current.admitted_reason !== "starvation_bound", (current) => ({ ...current, admitted_reason: "starvation_bound" }), false);
+            }
+            summary.admitted.push({
+                id: started.lane_id,
+                from: "queued",
+                to: started.state,
+                reason: started.queued_reason ?? decision.reason,
+                ...(started.queued_reason === "provider_binary_missing" &&
+                    typeof started.terminal_details?.searched_path === "string"
+                    ? {
+                        searched_path: started.terminal_details.searched_path,
+                    }
+                    : {}),
+            });
+            spawned.push(started);
+        }
+        catch (err) {
+            if (err instanceof LanesError && err.error === "worker_profile_hash_mismatch") {
+                const expectedHash = typeof err.details.expected_hash === "string"
+                    ? err.details.expected_hash
+                    : null;
+                const actualHash = typeof err.details.actual_hash === "string"
+                    ? err.details.actual_hash
+                    : undefined;
+                const workerProfile = typeof err.details.worker === "string"
+                    ? err.details.worker
+                    : lane.worker_profile;
+                if (actualHash !== undefined && workerProfile !== undefined) {
+                    casLaneIf(hqRoot, lane.lane_id, (current) => current.state === "queued", (current) => ({
+                        ...current,
+                        queued_reason: "worker_profile_changed",
+                        queued_details: {
+                            reason: "worker_profile_changed",
+                            expected_hash: expectedHash,
+                            actual_hash: actualHash,
+                            recovery_command: `hq lanes resume ${lane.lane_id} --worker ${workerProfile}`,
+                        },
+                        admission_reserved_at: undefined,
+                    }), false);
+                    summary.skipped.push({
+                        kind: "lane",
+                        id: lane.lane_id,
+                        why: "worker_profile_changed",
+                    });
+                    continue;
+                }
+            }
+            terminalizeModelUnsupported(hqRoot, lane, err);
+            markDirty(summary, {
+                kind: "lane",
+                id: lane.lane_id,
+                why: `admit failed: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    if (!deps.dryRun) {
+        const admittedAny = spawned.length > 0;
+        const applied = admittedAny
+            ? { admit: true, reason: decision.reason }
+            : decision;
+        const base = throttleState === "unreadable" ? emptyThrottleState() : throttleState;
+        writeThrottleState(filePath, applyThrottleDecision(base, applied, nowMs), throttleDeps);
+    }
+}
+function keepAliveCompanyKey(company) {
+    return JSON.stringify([company?.uid ?? null, company?.slug ?? null]);
+}
+function hasKeepAliveProgress(lane) {
+    return (lane.keep_alive_resume_count ?? 0) !== 0 ||
+        lane.keep_alive_last_resume_at !== undefined ||
+        lane.keep_alive_next_eligible_at !== undefined ||
+        lane.keep_alive_exhausted_at !== undefined;
+}
+function clearedKeepAliveProgress(lane) {
+    return {
+        ...lane,
+        keep_alive_resume_count: 0,
+        keep_alive_last_resume_at: undefined,
+        keep_alive_next_eligible_at: undefined,
+        keep_alive_exhausted_at: undefined,
+    };
+}
+function keepAliveProgressResetByHuman(lane) {
+    const count = lane.keep_alive_resume_count ?? 0;
+    const lastAutoMs = Date.parse(lane.keep_alive_last_resume_at ?? "");
+    if (count > 0 && !Number.isFinite(lastAutoMs))
+        return true;
+    const messageMs = Date.parse(lane.last_message_at ?? "");
+    const resumeMs = lane.last_resume?.text === LEAD_LANE_KEEP_ALIVE_RESUME_TEXT ||
+        lane.last_resume?.text === LEAD_LANE_KEEP_ALIVE_INTERRUPTED_RESUME_TEXT ||
+        lane.last_resume?.text === LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT
+        ? Number.NaN
+        : Date.parse(lane.last_resume?.at ?? "");
+    return Number.isFinite(lastAutoMs) &&
+        ((Number.isFinite(messageMs) && messageMs > lastAutoMs) ||
+            (Number.isFinite(resumeMs) && resumeMs > lastAutoMs));
+}
+function recordKeepAliveEvent(hqRoot, laneId, summary, event) {
+    try {
+        writeWatcherDecision(watcherEventsPath(hqRoot, laneId), {
+            lane_id: laneId,
+            ...event,
+        });
+    }
+    catch (err) {
+        markDirty(summary, {
+            kind: "lane",
+            id: laneId,
+            why: `keep-alive event write failed: ${err instanceof Error ? err.message : String(err)}`,
+        });
+    }
+}
+function keepAliveAccountSelectionEvidence(selection) {
+    if (selection === undefined)
+        return undefined;
+    return {
+        account: selection.account,
+        selected_at: selection.selected_at,
+        reason: selection.reason,
+        considered: selection.considered.map((row) => ({
+            account: row.account,
+            live_lanes: row.live_lanes,
+            eligible: row.eligible,
+            reason: row.ineligible_reason ?? null,
+        })),
+    };
+}
+function keepAliveSkipGuidance(laneId, reason) {
+    switch (reason) {
+        case "missing_opt_in_time":
+            return `if appropriate, run hq lanes keep-alive ${laneId} --on`;
+        case "not_opted_in":
+            return "explicit opt-in is required before keep-alive can resume this lane";
+        case "envelope_before_opt_in":
+            return `the latest envelope predates opt-in; review the lane with hq lanes show ${laneId}`;
+        case "interruption_before_opt_in":
+            return `the interruption predates opt-in; review the lane with hq lanes show ${laneId}`;
+        case "missing_interruption_time":
+            return "the interruption time is unavailable; inspect the watcher classification before resuming";
+        case "retired":
+            return "the lane is retired; resolve its retired status before resuming";
+        case "superseded":
+            return "a newer lead exists for this project; continue on that lane";
+        case "retired_list_invalid":
+            return "the retired lane list is invalid; repair workspace/lane-briefs/juniors.json before retrying";
+        case "terminal_state":
+            return `the lane is in a terminal state; review it with hq lanes show ${laneId} before starting replacement work`;
+    }
+}
+function recordKeepAliveSkip(hqRoot, lane, reason, summary, deps, detail) {
+    summary.skipped.push({
+        kind: "lane",
+        id: lane.lane_id,
+        why: `keep_alive_${reason}${detail ? `: ${detail}` : ""}`,
+    });
+    if (lane.keep_alive === true) {
+        summary.keep_alive_blocked.push({ id: lane.lane_id, reason });
+        process.stderr.write(`hq lanes reconcile: keep-alive blocked for lane ${lane.lane_id} (${reason}); ${keepAliveSkipGuidance(lane.lane_id, reason)}\n`);
+    }
+    if (deps.dryRun)
+        return;
+    let laneVersion = lane.version;
+    if (lane.keep_alive_blocked_reason !== reason) {
+        try {
+            const update = casLaneIf(hqRoot, lane.lane_id, (current) => current.version === lane.version && current.state === lane.state, (current) => ({ ...current, keep_alive_blocked_reason: reason }), false);
+            laneVersion = update.record.version;
+        }
+        catch (err) {
+            markDirty(summary, {
+                kind: "lane",
+                id: lane.lane_id,
+                why: `keep-alive skip state write failed: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    if (lane.keep_alive === true) {
+        recordKeepAliveSkipEvent(hqRoot, lane, reason, laneVersion, summary, deps, detail);
+    }
+}
+function recordDoneKeepAlivePolicySkip(hqRoot, summary, lane, verdict, deps) {
+    summary.skipped.push({
+        kind: "lane",
+        id: lane.lane_id,
+        why: `keep_alive_${verdict}`,
+    });
+    if (lane.keep_alive === true && !deps.dryRun) {
+        recordKeepAliveSkipEvent(hqRoot, lane, verdict, lane.version, summary, deps);
+    }
+}
+function recordKeepAliveSkipEvent(hqRoot, lane, reason, laneVersion, summary, deps, detail) {
+    if (lane.keep_alive !== true || deps.dryRun)
+        return;
+    const eventsPath = watcherEventsPath(hqRoot, lane.lane_id);
+    try {
+        let lastSkip;
+        try {
+            const scanBackwards = (body, targetReason, targetVersion) => {
+                const lines = body.split(/\r?\n/);
+                for (let index = lines.length - 1; index >= 0; index -= 1) {
+                    if (!lines[index])
+                        continue;
+                    try {
+                        const value = JSON.parse(lines[index]);
+                        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+                            const event = value;
+                            if (event.event === "keep_alive_skip" &&
+                                (targetReason === undefined || (event.reason === targetReason && event.lane_version === targetVersion))) {
+                                return event;
+                            }
+                        }
+                    }
+                    catch {
+                        // A partial concurrent append must not prevent future skip events.
+                    }
+                }
+                return undefined;
+            };
+            const maxTailBytes = 64 * 1024;
+            const fd = fs.openSync(eventsPath, "r");
+            let fileSize;
+            let tail;
+            let tailOffset;
+            try {
+                fileSize = fs.fstatSync(fd).size;
+                tailOffset = Math.max(0, fileSize - maxTailBytes);
+                const buffer = Buffer.alloc(fileSize - tailOffset);
+                let bytesRead = 0;
+                while (bytesRead < buffer.length) {
+                    const count = fs.readSync(fd, buffer, bytesRead, buffer.length - bytesRead, tailOffset + bytesRead);
+                    if (count === 0)
+                        break;
+                    bytesRead += count;
+                }
+                tail = buffer.subarray(0, bytesRead).toString("utf8");
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            // When the bounded read starts mid-line, ignore that incomplete prefix.
+            if (tailOffset > 0) {
+                const firstNewline = tail.indexOf("\n");
+                tail = firstNewline < 0 ? "" : tail.slice(firstNewline + 1);
+            }
+            lastSkip = scanBackwards(tail, reason === "next_check_at" ? reason : undefined, laneVersion);
+            // For small logs the tail is not a complete record boundary if a single
+            // record exceeded the bound, so allow one full-file scan as a fallback.
+            if (!lastSkip && fileSize < maxTailBytes) {
+                lastSkip = scanBackwards(fs.readFileSync(eventsPath, "utf8"), reason === "next_check_at" ? reason : undefined, laneVersion);
+            }
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+        }
+        if (lastSkip?.reason === reason && lastSkip.lane_version === laneVersion)
+            return;
+        recordKeepAliveEvent(hqRoot, lane.lane_id, summary, {
+            event: "keep_alive_skip",
+            at: deps.now().toISOString(),
+            reason,
+            ...(detail === undefined ? {} : { detail }),
+            lane_version: laneVersion,
+            lane_state: lane.state,
+        });
+    }
+    catch (err) {
+        markDirty(summary, {
+            kind: "lane",
+            id: lane.lane_id,
+            why: `keep-alive skip event dedupe failed: ${err instanceof Error ? err.message : String(err)}`,
+        });
+    }
+}
+function readLatestInterruptedClassificationAt(hqRoot, lane) {
+    const logPath = watcherOutLogPath(hqRoot, lane.lane_id);
+    let body;
+    try {
+        body = fs.readFileSync(logPath, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return undefined;
+        throw err;
+    }
+    let latestClassification;
+    for (const line of body.split(/\r?\n/).filter(Boolean)) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+            continue;
+        const record = parsed;
+        if (record.event === "classification")
+            latestClassification = record;
+    }
+    const at = latestClassification?.at;
+    if (latestClassification?.state !== "interrupted" ||
+        latestClassification.reason !== lane.terminal_reason ||
+        typeof at !== "string" ||
+        !Number.isFinite(Date.parse(at)) ||
+        new Date(Date.parse(at)).toISOString() !== at)
+        return undefined;
+    return at;
+}
+function latestEnvelopeMtimeMs(hqRoot, lane, ref) {
+    const filePath = path.join(laneRunDir(hqRoot, lane.lane_id), ref);
+    try {
+        return fs.statSync(filePath).mtimeMs;
+    }
+    catch (err) {
+        throw new LanesError("keep_alive_envelope_timestamp_unavailable", `Cannot stat latest envelope for lane ${lane.lane_id}: ${err instanceof Error ? err.message : String(err)}`, { lane_id: lane.lane_id, path: filePath });
+    }
+}
+async function resumeBlockedKeepAlive(hqRoot, lane, questions, summary, deps, now, keepAliveFlags, blockedFlags, companyForLane, lanes, retiredLaneIds, lineageAwareByCompany) {
+    const company = companyForLane(lane);
+    if (company === null) {
+        summary.skipped.push({ kind: "lane", id: lane.lane_id, why: "keep_alive_company_unresolved" });
+        return;
+    }
+    const key = keepAliveCompanyKey(company);
+    if (keepAliveFlags.get(key) !== true || blockedFlags.get(key) !== true) {
+        summary.skipped.push({ kind: "lane", id: lane.lane_id, why: "keep_alive_blocked" });
+        return;
+    }
+    if (lane.terminal_reason === "approval_gate_violated" || lane.last_envelope?.blocked_reason === "approval_gate_violated") {
+        summary.skipped.push({ kind: "lane", id: lane.lane_id, why: "keep_alive_approval_gate_violated" });
+        return;
+    }
+    if (lane.last_envelope?.decision !== "blocked") {
+        summary.skipped.push({ kind: "lane", id: lane.lane_id, why: "keep_alive_missing_blocked_envelope" });
+        return;
+    }
+    if (retiredLaneIds === null) {
+        recordKeepAliveSkip(hqRoot, lane, "retired_list_invalid", summary, deps);
+        return;
+    }
+    const exclusion = keepAliveExclusion(lane, lanes, retiredLaneIds, lineageAwareByCompany.get(key) === true, companyForLane);
+    if (exclusion !== undefined) {
+        recordKeepAliveSkip(hqRoot, lane, exclusion, summary, deps);
+        return;
+    }
+    const terminalAt = lane.last_envelope.at;
+    const terminalMs = Date.parse(terminalAt ?? "");
+    if (!Number.isFinite(terminalMs)) {
+        recordKeepAliveSkip(hqRoot, lane, "missing_interruption_time", summary, deps, "blocked terminal time is invalid");
+        return;
+    }
+    if (activeLaneStories(lane).length === 0) {
+        summary.skipped.push({ kind: "lane", id: lane.lane_id, why: "keep_alive_no_open_stories" });
+        return;
+    }
+    let pendingQuestion = questions.some((question) => question.lane_id === lane.lane_id && question.status === "pending");
+    try {
+        for (const id of listQuestionIds(hqRoot)) {
+            const question = readQuestion(hqRoot, id);
+            if (question.lane_id === lane.lane_id && question.status === "pending")
+                pendingQuestion = true;
+        }
+    }
+    catch (error) {
+        markDirty(summary, { kind: "lane", id: lane.lane_id, why: "blocked keep-alive question read failed: " + (error instanceof Error ? error.message : String(error)) });
+        return;
+    }
+    const blockedHistory = lane.status_gate_history ?? [];
+    const priorResumes = lane.keep_alive_blocked_resume_streak ?? 0;
+    const alreadyEscalated = blockedHistory.some((entry) => entry.event === "keep_alive_blocked_escalated" && entry.terminal_at === terminalAt);
+    if (pendingQuestion) {
+        appendBlockedKeepAliveHistory(hqRoot, lane, terminalAt, now.toISOString(), "open_question", deps);
+        return;
+    }
+    if (priorResumes >= 2) {
+        if (!alreadyEscalated) {
+            casLaneIf(hqRoot, lane.lane_id, (current) => current.version === lane.version && current.state === "blocked" && current.last_envelope?.at === terminalAt, (current) => ({
+                ...current,
+                status_gate_history: appendCappedHistory(current.status_gate_history ?? [], {
+                    event: "keep_alive_blocked_escalated",
+                    at: now.toISOString(),
+                    terminal_at: terminalAt,
+                }),
+            }), deps.dryRun);
+        }
+        summary.skipped.push({ kind: "lane", id: lane.lane_id, why: "keep_alive_blocked_escalated" });
+        return;
+    }
+    if ((lane.keep_alive_resume_count ?? 0) >= LEAD_LANE_KEEP_ALIVE_MAX_RESUMES || lane.keep_alive_exhausted_at !== undefined) {
+        if (lane.keep_alive_exhausted_at === undefined && !deps.dryRun) {
+            casLaneIf(hqRoot, lane.lane_id, (current) => current.version === lane.version && current.state === "blocked" &&
+                (current.keep_alive_resume_count ?? 0) >= LEAD_LANE_KEEP_ALIVE_MAX_RESUMES, (current) => ({ ...current, keep_alive_exhausted_at: now.toISOString() }), false);
+        }
+        summary.skipped.push({ kind: "lane", id: lane.lane_id, why: "keep_alive_exhausted" });
+        return;
+    }
+    if (now.getTime() - terminalMs < LEAD_LANE_KEEP_ALIVE_BLOCKED_GRACE_MS) {
+        appendBlockedKeepAliveHistory(hqRoot, lane, terminalAt, now.toISOString(), "blocked_grace", deps);
+        return;
+    }
+    const latest = deps.readKeepAliveRecheckLane?.(hqRoot, lane.lane_id) ?? readLane(hqRoot, lane.lane_id);
+    if (latest.version !== lane.version || latest.state !== "blocked" || latest.last_envelope?.decision !== "blocked" || latest.last_envelope.at !== terminalAt)
+        return;
+    let hasOpenQuestion;
+    try {
+        hasOpenQuestion = listQuestionIds(hqRoot).some((id) => {
+            const question = readQuestion(hqRoot, id);
+            return question.lane_id === lane.lane_id && question.status === "pending";
+        });
+    }
+    catch (error) {
+        markDirty(summary, { kind: "lane", id: lane.lane_id, why: "blocked keep-alive question recheck failed: " + (error instanceof Error ? error.message : String(error)) });
+        return;
+    }
+    if (hasOpenQuestion) {
+        appendBlockedKeepAliveHistory(hqRoot, latest, terminalAt, now.toISOString(), "open_question", deps);
+        return;
+    }
+    let current = latest;
+    let accountSelection;
+    if (current.provider === "claude" && deps.prepareKeepAliveClaudeResume !== undefined) {
+        try {
+            const prepared = await deps.prepareKeepAliveClaudeResume(current);
+            current = prepared.lane;
+            accountSelection = prepared.accountSelection;
+        }
+        catch (error) {
+            markDirty(summary, { kind: "lane", id: lane.lane_id, why: `blocked keep-alive account preparation failed: ${error instanceof Error ? error.message : String(error)}` });
+            return;
+        }
+        const afterPreparation = deps.readKeepAliveRecheckLane?.(hqRoot, lane.lane_id) ?? readLane(hqRoot, lane.lane_id);
+        if (afterPreparation.state !== "blocked" || afterPreparation.last_envelope?.decision !== "blocked" || afterPreparation.last_envelope.at !== terminalAt)
+            return;
+        current = afterPreparation;
+    }
+    const expectedVersion = current.version;
+    const result = queueLaneTerminalResume(current, now.toISOString(), LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT, { allowBlockedResume: true, trigger: "resume" });
+    if (!result.resumeQueued) {
+        if (result.resumeSkippedReason !== undefined) {
+            summary.skipped.push({ kind: "lane", id: lane.lane_id, why: "keep_alive_" + result.resumeSkippedReason });
+        }
+        return;
+    }
+    const queued = casLaneIf(hqRoot, latest.lane_id, (latestRecord) => latestRecord.version === expectedVersion && latestRecord.state === "blocked" && latestRecord.last_envelope?.decision === "blocked" && latestRecord.last_envelope.at === terminalAt, (current) => ({
+        ...result.lane,
+        version: current.version,
+        pending_resume: result.lane.pending_resume === undefined
+            ? undefined
+            : { ...result.lane.pending_resume, keep_alive: true },
+        keep_alive_blocked_resume_streak: priorResumes + 1,
+        keep_alive_resume_count: (current.keep_alive_resume_count ?? 0) + 1,
+        keep_alive_history: appendCappedHistory(current.keep_alive_history ?? [], {
+            at: now.toISOString(),
+            resumed_from: "blocked",
+            account: current.account ?? null,
+        }),
+        keep_alive_last_resume_at: now.toISOString(),
+        status_gate_history: appendCappedHistory(current.status_gate_history ?? [], {
+            event: "keep_alive_blocked_resumed",
+            at: now.toISOString(),
+            terminal_at: terminalAt,
+            resume_queued: true,
+        }),
+    }), deps.dryRun);
+    if (queued.changed) {
+        summary.resumed.push({ id: lane.lane_id, from: "blocked", to: "queued", reason: "keep_alive_blocked" });
+        if (!deps.dryRun) {
+            recordKeepAliveEvent(hqRoot, lane.lane_id, summary, {
+                event: "keep_alive_resume",
+                at: now.toISOString(),
+                attempt: (lane.keep_alive_resume_count ?? 0) + 1,
+                resumed_from: "blocked",
+                reason: "backoff",
+                ...(accountSelection !== undefined
+                    ? { account_selection: keepAliveAccountSelectionEvidence(accountSelection) }
+                    : {}),
+            });
+        }
+    }
+}
+function appendBlockedKeepAliveHistory(hqRoot, lane, terminalAt, at, reason, deps) {
+    if (deps.dryRun || lane.status_gate_history?.some((entry) => entry.event === "keep_alive_blocked_grace" && entry.terminal_at === terminalAt && entry.resume_skipped_reason === reason))
+        return;
+    casLaneIf(hqRoot, lane.lane_id, (current) => current.version === lane.version && current.state === "blocked" && current.last_envelope?.at === terminalAt, (current) => ({
+        ...current,
+        status_gate_history: appendCappedHistory(current.status_gate_history ?? [], {
+            event: "keep_alive_blocked_grace",
+            at,
+            terminal_at: terminalAt,
+            resume_skipped_reason: reason,
+        }),
+    }), false);
+}
+async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCompany, supersessionLineageAwareByCompany, blockedResumeFlagByCompany, immediateFirstResumeFlagByCompany, terminalKeepAliveCandidate) {
+    const nowMs = now.getTime();
+    const nowIso = now.toISOString();
+    const config = loadLanesConfig(hqRoot);
+    const resolvedCompanyByLaneVersion = new Map();
+    const companyForLane = (candidate) => {
+        const key = `${candidate.lane_id}\u0000${candidate.version}`;
+        if (resolvedCompanyByLaneVersion.has(key))
+            return resolvedCompanyByLaneVersion.get(key) ?? null;
+        const company = resolveLaneCompany(hqRoot, candidate).company;
+        resolvedCompanyByLaneVersion.set(key, company);
+        return company;
+    };
+    const keepAliveEnabled = [...flagByCompany.values()].some((enabled) => enabled) || [...blockedResumeFlagByCompany.values()].some(Boolean);
+    let retiredLaneIds = null;
+    if (keepAliveEnabled) {
+        try {
+            retiredLaneIds = loadRetiredLaneIds(hqRoot);
+        }
+        catch (err) {
+            markError(summary, err);
+        }
+    }
+    for (const originalLane of lanes) {
+        if (terminalKeepAliveCandidate && (originalLane.lane_id !== terminalKeepAliveCandidate.laneId ||
+            originalLane.version !== terminalKeepAliveCandidate.version ||
+            originalLane.state !== "done"))
+            continue;
+        if (!laneRunsHere(originalLane, deps.host))
+            continue;
+        if (originalLane.state === "killed" ||
+            originalLane.state === "cancelled" ||
+            originalLane.state === "failed") {
+            if (originalLane.keep_alive === true &&
+                flagByCompany.get(keepAliveCompanyKey(companyForLane(originalLane))) === true)
+                recordKeepAliveSkip(hqRoot, originalLane, "terminal_state", summary, deps);
+            continue;
+        }
+        if (originalLane.state === "blocked" && originalLane.keep_alive === true) {
+            await resumeBlockedKeepAlive(hqRoot, originalLane, questions, summary, deps, now, flagByCompany, blockedResumeFlagByCompany, companyForLane, lanes, retiredLaneIds, supersessionLineageAwareByCompany);
+            continue;
+        }
+        if ((originalLane.state !== "done" && originalLane.state !== "interrupted") ||
+            (originalLane.keep_alive !== true && originalLane.worker_profile === undefined))
+            continue;
+        const initialState = originalLane.state;
+        let lane = originalLane;
+        if (initialState === "done") {
+            const envelope = readLatestEnvelopeRecord(hqRoot, lane.lane_id)?.envelope;
+            if (!envelope || envelope.decision !== "done")
+                continue;
+            const hasPendingWork = hasPendingKeepAliveWork(hqRoot, lane, questions);
+            const hasQueuedWork = lane.keep_alive_standing === true && hasPendingWork;
+            const verdict = doneKeepAliveVerdict(lane, envelope, hasQueuedWork, {
+                hasPendingWork,
+                nowMs,
+                nextCheckAnchorMs: Date.parse(lane.last_envelope?.at ?? lane.updated_at),
+            });
+            if (verdict !== "eligible") {
+                let skipLane = lane;
+                if (envelope.story_complete === true && lane.keep_alive_standing !== true && hasKeepAliveProgress(lane)) {
+                    skipLane = casLaneIf(hqRoot, lane.lane_id, (current) => current.version === lane.version &&
+                        current.state === "done" &&
+                        current.keep_alive === lane.keep_alive, (current) => ({ ...clearedKeepAliveProgress(current), keep_alive_blocked_reason: undefined }), deps.dryRun).record;
+                }
+                if (verdict !== null)
+                    recordDoneKeepAlivePolicySkip(hqRoot, summary, skipLane, verdict, deps);
+                continue;
+            }
+        }
+        const company = companyForLane(lane);
+        if (company === null) {
+            if (lane.keep_alive === true) {
+                summary.skipped.push({
+                    kind: "lane",
+                    id: lane.lane_id,
+                    why: "keep_alive_company_unresolved",
+                });
+                recordKeepAliveSkipEvent(hqRoot, lane, "company_unresolved", lane.version, summary, deps);
+            }
+            continue;
+        }
+        const companyKey = keepAliveCompanyKey(company);
+        if (flagByCompany.get(companyKey) !== true) {
+            if (lane.keep_alive === true) {
+                summary.skipped.push({
+                    kind: "lane",
+                    id: lane.lane_id,
+                    why: "keep_alive_flag_off",
+                });
+                recordKeepAliveSkipEvent(hqRoot, lane, "keep_alive_flag_off", lane.version, summary, deps);
+            }
+            continue;
+        }
+        // Persist a stable timestamp for legacy interrupted rows before a later
+        // keep-alive status write can advance their general updated_at clock. The
+        // watcher classification is the interruption time; updated_at is only an
+        // upper bound and can postdate explicit opt-in.
+        if (initialState === "interrupted" && lane.keep_alive === true && lane.interrupted_at === undefined) {
+            let interruptedAt;
+            try {
+                interruptedAt = readLatestInterruptedClassificationAt(hqRoot, lane);
+            }
+            catch (err) {
+                const detail = `watcher classification read failed: ${err instanceof Error ? err.message : String(err)}`;
+                recordKeepAliveSkip(hqRoot, lane, "missing_interruption_time", summary, deps, detail);
+                const skip = summary.skipped[summary.skipped.length - 1];
+                if (skip) {
+                    summary.ok = false;
+                    logSkip(skip);
+                }
+                continue;
+            }
+            if (interruptedAt === undefined) {
+                recordKeepAliveSkip(hqRoot, lane, "missing_interruption_time", summary, deps, "no latest matching watcher classification event");
+                const skip = summary.skipped[summary.skipped.length - 1];
+                if (skip) {
+                    summary.ok = false;
+                    logSkip(skip);
+                }
+                continue;
+            }
+            try {
+                const backfill = casLaneIf(hqRoot, lane.lane_id, (current) => current.version === lane.version &&
+                    current.state === "interrupted" &&
+                    current.keep_alive === true &&
+                    current.terminal_reason === lane.terminal_reason &&
+                    current.interrupted_at === undefined, (current) => ({ ...current, interrupted_at: interruptedAt }), deps.dryRun);
+                lane = backfill.record;
+                if (lane.interrupted_at === undefined) {
+                    recordKeepAliveSkip(hqRoot, lane, "missing_interruption_time", summary, deps, "lane changed before watcher classification timestamp could be recorded");
+                    const skip = summary.skipped[summary.skipped.length - 1];
+                    if (skip) {
+                        summary.ok = false;
+                        logSkip(skip);
+                    }
+                    continue;
+                }
+            }
+            catch (err) {
+                markDirty(summary, {
+                    kind: "lane",
+                    id: lane.lane_id,
+                    why: `keep-alive interruption timestamp backfill failed: ${err instanceof Error ? err.message : String(err)}`,
+                });
+                continue;
+            }
+        }
+        if (initialState === "interrupted" && lane.terminal_reason !== "exited_with_partial_output") {
+            recordKeepAliveSkip(hqRoot, lane, "terminal_state", summary, deps, lane.terminal_reason ?? "missing interruption reason");
+            continue;
+        }
+        if (initialState === "done" && (lane.terminal_reason === PROVIDER_REJECTED_REASON ||
+            lane.terminal_reason === "account_not_logged_in")) {
+            recordKeepAliveSkip(hqRoot, lane, "terminal_state", summary, deps, lane.terminal_reason);
+            continue;
+        }
+        if (lane.keep_alive !== true) {
+            recordKeepAliveSkip(hqRoot, lane, "not_opted_in", summary, deps);
+            continue;
+        }
+        const optedInAtMs = Date.parse(lane.keep_alive_opted_in_at ?? "");
+        if (!Number.isFinite(optedInAtMs)) {
+            recordKeepAliveSkip(hqRoot, lane, "missing_opt_in_time", summary, deps);
+            continue;
+        }
+        let eligibilityAtMs;
+        if (initialState === "done") {
+            const latest = readLatestEnvelopeRecord(hqRoot, lane.lane_id);
+            if (!latest || latest.envelope.decision !== "done")
+                continue;
+            const hasPendingWork = hasPendingKeepAliveWork(hqRoot, lane, questions);
+            const hasQueuedWork = lane.keep_alive_standing === true && hasPendingWork;
+            const verdict = doneKeepAliveVerdict(lane, latest.envelope, hasQueuedWork, {
+                hasPendingWork,
+                nowMs,
+                nextCheckAnchorMs: Date.parse(lane.last_envelope?.at ?? lane.updated_at),
+            });
+            if (verdict !== "eligible") {
+                let skipLane = lane;
+                if (latest.envelope.story_complete === true && lane.keep_alive_standing !== true && hasKeepAliveProgress(lane)) {
+                    skipLane = casLaneIf(hqRoot, lane.lane_id, (current) => current.version === lane.version && current.state === "done", (current) => ({ ...clearedKeepAliveProgress(current), keep_alive_blocked_reason: undefined }), deps.dryRun).record;
+                }
+                if (verdict !== null)
+                    recordDoneKeepAlivePolicySkip(hqRoot, summary, skipLane, verdict, deps);
+                continue;
+            }
+            try {
+                eligibilityAtMs = latestEnvelopeMtimeMs(hqRoot, lane, latest.ref);
+            }
+            catch (err) {
+                markDirty(summary, {
+                    kind: "lane",
+                    id: lane.lane_id,
+                    why: `keep-alive envelope timestamp unavailable: ${err instanceof Error ? err.message : String(err)}`,
+                });
+                continue;
+            }
+        }
+        else {
+            eligibilityAtMs = Date.parse(lane.interrupted_at ?? "");
+            if (!Number.isFinite(eligibilityAtMs)) {
+                recordKeepAliveSkip(hqRoot, lane, "missing_interruption_time", summary, deps);
+                continue;
+            }
+        }
+        const initialTimeBlockReason = initialState === "done"
+            ? "envelope_before_opt_in"
+            : "interruption_before_opt_in";
+        if (eligibilityAtMs <= optedInAtMs) {
+            recordKeepAliveSkip(hqRoot, lane, initialTimeBlockReason, summary, deps);
+            continue;
+        }
+        if (retiredLaneIds === null) {
+            recordKeepAliveSkip(hqRoot, lane, "retired_list_invalid", summary, deps);
+            continue;
+        }
+        const exclusion = keepAliveExclusion(lane, lanes, retiredLaneIds, supersessionLineageAwareByCompany.get(companyKey) === true, companyForLane);
+        if (exclusion !== undefined) {
+            recordKeepAliveSkip(hqRoot, lane, exclusion, summary, deps);
+            continue;
+        }
+        const providerSessionId = lane.provider_session_id ?? lane.last_resume?.session_id;
+        if (!providerSupportsSessionResume(lane.provider) ||
+            typeof providerSessionId !== "string" ||
+            providerSessionId.trim().length === 0) {
+            if (initialState === "interrupted") {
+                recordKeepAliveSkip(hqRoot, lane, "terminal_state", summary, deps, "provider session cannot be resumed");
+            }
+            continue;
+        }
+        // This second read is intentionally independent of the pass snapshot. The
+        // final timestamp comparison below closes the opt-in race before the CAS.
+        const rechecked = deps.readKeepAliveRecheckLane?.(hqRoot, lane.lane_id) ?? readLane(hqRoot, lane.lane_id);
+        // Dry-run backfills only in memory. Carry that simulated legacy timestamp
+        // through the fresh read when the stored lane version has not changed.
+        let current = deps.dryRun &&
+            initialState === "interrupted" &&
+            originalLane.interrupted_at === undefined &&
+            lane.interrupted_at !== undefined &&
+            rechecked.version === lane.version &&
+            rechecked.interrupted_at === undefined
+            ? { ...rechecked, interrupted_at: lane.interrupted_at }
+            : rechecked;
+        if (current.state !== initialState || !laneRunsHere(current, deps.host))
+            continue;
+        if (current.keep_alive !== true) {
+            recordKeepAliveSkip(hqRoot, current, "not_opted_in", summary, deps);
+            continue;
+        }
+        if (initialState === "interrupted" && current.terminal_reason !== "exited_with_partial_output") {
+            recordKeepAliveSkip(hqRoot, current, "terminal_state", summary, deps, current.terminal_reason ?? "missing interruption reason");
+            continue;
+        }
+        let currentEligibilityAtMs;
+        if (initialState === "done") {
+            const currentEnvelope = readLatestEnvelopeRecord(hqRoot, current.lane_id);
+            if (!currentEnvelope || currentEnvelope.envelope.decision !== "done")
+                continue;
+            const hasPendingWork = hasPendingKeepAliveWork(hqRoot, current, questions);
+            const hasQueuedWork = current.keep_alive_standing === true && hasPendingWork;
+            const verdict = doneKeepAliveVerdict(current, currentEnvelope.envelope, hasQueuedWork, {
+                hasPendingWork,
+                nowMs,
+                nextCheckAnchorMs: Date.parse(current.last_envelope?.at ?? current.updated_at),
+            });
+            if (verdict !== "eligible") {
+                let skipLane = current;
+                if (currentEnvelope.envelope.story_complete === true && current.keep_alive_standing !== true && hasKeepAliveProgress(current)) {
+                    skipLane = casLaneIf(hqRoot, current.lane_id, (latestLane) => latestLane.version === current.version &&
+                        latestLane.state === "done" &&
+                        latestLane.keep_alive === true &&
+                        latestLane.keep_alive_opted_in_at === current.keep_alive_opted_in_at, (latestLane) => ({ ...clearedKeepAliveProgress(latestLane), keep_alive_blocked_reason: undefined }), deps.dryRun).record;
+                }
+                if (verdict !== null)
+                    recordDoneKeepAlivePolicySkip(hqRoot, summary, skipLane, verdict, deps);
+                continue;
+            }
+            try {
+                currentEligibilityAtMs = latestEnvelopeMtimeMs(hqRoot, current, currentEnvelope.ref);
+            }
+            catch (err) {
+                markDirty(summary, {
+                    kind: "lane",
+                    id: current.lane_id,
+                    why: `keep-alive envelope timestamp unavailable: ${err instanceof Error ? err.message : String(err)}`,
+                });
+                continue;
+            }
+        }
+        else {
+            currentEligibilityAtMs = Date.parse(current.interrupted_at ?? "");
+            if (!Number.isFinite(currentEligibilityAtMs)) {
+                recordKeepAliveSkip(hqRoot, current, "missing_interruption_time", summary, deps);
+                continue;
+            }
+        }
+        const currentOptedInAtMs = Date.parse(current.keep_alive_opted_in_at ?? "");
+        if (!Number.isFinite(currentOptedInAtMs)) {
+            recordKeepAliveSkip(hqRoot, current, "missing_opt_in_time", summary, deps);
+            continue;
+        }
+        const currentTimeBlockReason = initialState === "done"
+            ? "envelope_before_opt_in"
+            : "interruption_before_opt_in";
+        if (currentEligibilityAtMs <= currentOptedInAtMs) {
+            recordKeepAliveSkip(hqRoot, current, currentTimeBlockReason, summary, deps);
+            continue;
+        }
+        if (retiredLaneIds === null) {
+            recordKeepAliveSkip(hqRoot, current, "retired_list_invalid", summary, deps);
+            continue;
+        }
+        const currentLanes = loadLaneRecords(hqRoot, summary);
+        const currentCompany = companyForLane(current);
+        if (currentCompany === null) {
+            summary.skipped.push({
+                kind: "lane",
+                id: current.lane_id,
+                why: "keep_alive_company_unresolved",
+            });
+            recordKeepAliveSkipEvent(hqRoot, current, "company_unresolved", current.version, summary, deps);
+            continue;
+        }
+        const currentCompanyKey = keepAliveCompanyKey(currentCompany);
+        if (flagByCompany.get(currentCompanyKey) !== true) {
+            summary.skipped.push({
+                kind: "lane",
+                id: current.lane_id,
+                why: "keep_alive_flag_off",
+            });
+            recordKeepAliveSkipEvent(hqRoot, current, "keep_alive_flag_off", current.version, summary, deps);
+            continue;
+        }
+        const currentExclusion = keepAliveExclusion(current, currentLanes, retiredLaneIds, supersessionLineageAwareByCompany.get(currentCompanyKey) === true, companyForLane);
+        if (currentExclusion !== undefined) {
+            recordKeepAliveSkip(hqRoot, current, currentExclusion, summary, deps);
+            continue;
+        }
+        if (current.keep_alive_blocked_reason === "superseded") {
+            // The fresh exclusion check found no active successor. Clear the stale
+            // reason before any later exit (backoff, queue full, retry cap, hire
+            // refusal) so the watcher keeps treating the lane as resumable.
+            const cleared = casLaneIf(hqRoot, current.lane_id, (latestLane) => latestLane.version === current.version &&
+                latestLane.state === current.state &&
+                latestLane.keep_alive === true &&
+                latestLane.keep_alive_opted_in_at === current.keep_alive_opted_in_at &&
+                latestLane.keep_alive_blocked_reason === "superseded", (latestLane) => ({ ...latestLane, keep_alive_blocked_reason: undefined }), deps.dryRun);
+            if (!cleared.changed)
+                continue;
+            current = cleared.record;
+        }
+        const currentSessionId = current.provider_session_id ?? current.last_resume?.session_id;
+        if (!providerSupportsSessionResume(current.provider) ||
+            typeof currentSessionId !== "string" ||
+            currentSessionId.trim().length === 0)
+            continue;
+        const resetByHuman = keepAliveProgressResetByHuman(current);
+        const attempts = resetByHuman ? 0 : current.keep_alive_resume_count ?? 0;
+        if (attempts >= LEAD_LANE_KEEP_ALIVE_MAX_RESUMES) {
+            if (current.keep_alive_exhausted_at !== undefined)
+                continue;
+            const exhausted = casLaneIf(hqRoot, current.lane_id, (latestLane) => latestLane.version === current.version &&
+                latestLane.state === current.state &&
+                latestLane.keep_alive === true &&
+                latestLane.keep_alive_opted_in_at === current.keep_alive_opted_in_at &&
+                (latestLane.keep_alive_resume_count ?? 0) >= LEAD_LANE_KEEP_ALIVE_MAX_RESUMES &&
+                latestLane.keep_alive_exhausted_at === undefined, (latestLane) => ({ ...latestLane, keep_alive_exhausted_at: nowIso }), deps.dryRun);
+            if (exhausted.changed && !deps.dryRun) {
+                recordKeepAliveEvent(hqRoot, current.lane_id, summary, {
+                    event: "keep_alive_exhausted",
+                    at: nowIso,
+                    attempt: attempts,
+                    resumed_from: current.state,
+                });
+            }
+            continue;
+        }
+        const attempt = attempts + 1;
+        // A done turn ends no later than its done envelope. Bookkeeping writes
+        // (such as clearing a stale block) move updated_at but not the envelope,
+        // so they cannot push the retry clock forward.
+        const terminalAtMs = initialState === "done"
+            ? Math.min(Date.parse(current.updated_at), currentEligibilityAtMs)
+            : currentEligibilityAtMs;
+        const immediateFirstResumeEnabled = initialState === "done" &&
+            immediateFirstResumeFlagByCompany.get(keepAliveCompanyKey(companyForLane(current))) === true;
+        const attemptDelayMs = immediateFirstResumeEnabled && attempt === 1
+            ? LEAD_LANE_KEEP_ALIVE_FIRST_RESUME_SETTLE_MS
+            : leadLaneKeepAliveBackoffMs(immediateFirstResumeEnabled ? Math.max(1, attempt - 1) : attempt);
+        const attemptEligibleMs = terminalAtMs + attemptDelayMs;
+        const storedNextMs = resetByHuman
+            ? Number.NaN
+            : Date.parse(current.keep_alive_next_eligible_at ?? "");
+        const nextEligibleMs = Number.isFinite(storedNextMs)
+            ? Math.max(attemptEligibleMs, storedNextMs)
+            : attemptEligibleMs;
+        if (nowMs < nextEligibleMs) {
+            let skipLane = current;
+            if (resetByHuman && hasKeepAliveProgress(current)) {
+                const clearedProgress = casLaneIf(hqRoot, current.lane_id, (latestLane) => latestLane.version === current.version &&
+                    latestLane.state === current.state &&
+                    latestLane.keep_alive === true &&
+                    latestLane.keep_alive_opted_in_at === current.keep_alive_opted_in_at, (latestLane) => clearedKeepAliveProgress(latestLane), deps.dryRun);
+                skipLane = clearedProgress.record;
+            }
+            recordKeepAliveSkipEvent(hqRoot, skipLane, "backoff", skipLane.version, summary, deps, new Date(nextEligibleMs).toISOString());
+            continue;
+        }
+        const nextEligibleAt = new Date(nowMs + leadLaneKeepAliveBackoffMs(immediateFirstResumeEnabled ? attempt : attempt + 1)).toISOString();
+        let resumeReason = "backoff";
+        if (initialState === "done") {
+            if (hasPendingKeepAliveWork(hqRoot, current, questions)) {
+                resumeReason = "pending_work";
+            }
+            else {
+                const finalEnvelope = readLatestEnvelopeRecord(hqRoot, current.lane_id)?.envelope;
+                const nextCheckMs = Date.parse(finalEnvelope?.next_check_at ?? "");
+                const anchorMs = Date.parse(current.last_envelope?.at ?? current.updated_at);
+                if (Number.isFinite(nextCheckMs) && Number.isFinite(anchorMs)) {
+                    const cappedNextCheckMs = Math.min(nextCheckMs, anchorMs + LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_MAX_DELAY_MS);
+                    if (cappedNextCheckMs > nextEligibleMs && cappedNextCheckMs <= nowMs) {
+                        resumeReason = "next_check_at_due";
+                    }
+                }
+            }
+        }
+        const queuedCount = loadLaneRecords(hqRoot, summary).filter((queuedLane) => queuedLane.state === "queued" &&
+            queuedLane.provider === current.provider &&
+            laneRunsHere(queuedLane, deps.host) &&
+            !hasFreshAdmissionReservation(queuedLane, nowMs)).length;
+        const maxQueued = config.providers[current.provider].max_queued;
+        if (queuedCount >= maxQueued) {
+            summary.skipped.push({
+                kind: "lane",
+                id: current.lane_id,
+                why: `lane_queue_full: ${current.provider} queue has ${queuedCount}/${maxQueued} lanes`,
+            });
+            recordKeepAliveSkipEvent(hqRoot, current, "lane_queue_full", current.version, summary, deps, `${current.provider} queue has ${queuedCount}/${maxQueued} lanes`);
+            continue;
+        }
+        const seniorId = current.senior.kind === "lane" ? current.senior.id : undefined;
+        let finishedChildrenDoNotCount = false;
+        if (seniorId !== undefined) {
+            let grantPreflight;
+            try {
+                const companyResolution = resolveLaneCompany(hqRoot, current);
+                const company = companyResolution.company ?? undefined;
+                finishedChildrenDoNotCount = await readLanesRegistryFlagFailOff(LANE_HIRE_GRANT_FINISHED_LANES_FLAG, {
+                    company,
+                    ...(company ? { companyUidSource: laneCompanyUidSource(companyResolution.source) } : {}),
+                    env: deps.env,
+                }, deps.readRegistryFlag ?? readLanesRegistryFlag);
+                grantPreflight = withHireGrantAdmission(hqRoot, seniorId, (snapshot) => {
+                    const latestLane = readLane(hqRoot, current.lane_id);
+                    if (latestLane.version !== current.version ||
+                        latestLane.state !== current.state ||
+                        latestLane.keep_alive !== true ||
+                        latestLane.keep_alive_opted_in_at !== current.keep_alive_opted_in_at ||
+                        latestLane.senior.kind !== "lane" ||
+                        latestLane.senior.id !== seniorId)
+                        return { kind: "stale" };
+                    const refusal = terminalChildResumeHireGrantError(latestLane, snapshot, finishedChildrenDoNotCount);
+                    return refusal === null
+                        ? { kind: "eligible" }
+                        : { kind: "refused", error: refusal.error, message: refusal.message };
+                }, undefined, new Set(), finishedChildrenDoNotCount);
+            }
+            catch (err) {
+                markDirty(summary, {
+                    kind: "lane",
+                    id: current.lane_id,
+                    why: `keep-alive hire admission preflight failed: ${err instanceof Error ? err.message : String(err)}`,
+                });
+                continue;
+            }
+            if (grantPreflight.kind === "stale")
+                continue;
+            if (grantPreflight.kind === "refused") {
+                summary.skipped.push({
+                    kind: "lane",
+                    id: current.lane_id,
+                    why: `keep_alive_hire_admission: ${grantPreflight.error}: ${grantPreflight.message}`,
+                });
+                recordKeepAliveSkipEvent(hqRoot, current, "hire_admission", current.version, summary, deps, `${grantPreflight.error}: ${grantPreflight.message}`);
+                continue;
+            }
+        }
+        const resumedFrom = current.state === "done" ? "done" : "interrupted";
+        const resumeText = resumedFrom === "interrupted"
+            ? LEAD_LANE_KEEP_ALIVE_INTERRUPTED_RESUME_TEXT
+            : LEAD_LANE_KEEP_ALIVE_RESUME_TEXT;
+        const carriesAnsweredQuestions = resumedFrom === "done" &&
+            current.keep_alive_standing === true &&
+            undeliveredAnsweredQuestions(current, questions).length > 0;
+        if (carriesAnsweredQuestions && !deps.dryRun) {
+            writeAnsweredQuestions(hqRoot, current, questions);
+        }
+        let accountSelectionFailure;
+        let accountSelection;
+        if (current.provider === "claude" && deps.prepareKeepAliveClaudeResume !== undefined) {
+            const optInBeforePreparation = current.keep_alive_opted_in_at;
+            let preparedLane;
+            try {
+                const prepared = await deps.prepareKeepAliveClaudeResume(current);
+                preparedLane = prepared.lane;
+                accountSelectionFailure = prepared.selectionFailure;
+                accountSelection = prepared.accountSelection;
+            }
+            catch (err) {
+                // Account balancing is best-effort for keep-alive. A failure to read
+                // balance inputs must not prevent the existing session from resuming.
+                try {
+                    preparedLane = readLane(hqRoot, current.lane_id);
+                }
+                catch (readErr) {
+                    markDirty(summary, {
+                        kind: "lane",
+                        id: current.lane_id,
+                        why: `keep-alive account selection failed and lane could not be re-read: ${readErr instanceof Error ? readErr.message : String(readErr)}`,
+                    });
+                    continue;
+                }
+                accountSelectionFailure = err instanceof Error ? err.message : String(err);
+            }
+            const preparedSessionId = preparedLane.provider_session_id ?? preparedLane.last_resume?.session_id;
+            if (preparedLane.state !== initialState ||
+                preparedLane.keep_alive !== true ||
+                !laneRunsHere(preparedLane, deps.host) ||
+                preparedSessionId !== currentSessionId)
+                continue;
+            let latest;
+            try {
+                latest = deps.dryRun
+                    ? (deps.readKeepAliveRecheckLane?.(hqRoot, current.lane_id) ?? readLane(hqRoot, current.lane_id))
+                    : readLane(hqRoot, current.lane_id);
+            }
+            catch (err) {
+                markDirty(summary, {
+                    kind: "lane",
+                    id: current.lane_id,
+                    why: `keep-alive eligibility recheck failed after account selection: ${err instanceof Error ? err.message : String(err)}`,
+                });
+                continue;
+            }
+            if (latest.state !== initialState || !laneRunsHere(latest, deps.host))
+                continue;
+            if (latest.keep_alive !== true) {
+                recordKeepAliveSkip(hqRoot, latest, "not_opted_in", summary, deps);
+                continue;
+            }
+            if (latest.keep_alive_opted_in_at !== optInBeforePreparation) {
+                summary.skipped.push({
+                    kind: "lane",
+                    id: latest.lane_id,
+                    why: "keep_alive_eligibility_changed_during_account_selection",
+                });
+                continue;
+            }
+            const latestSessionId = latest.provider_session_id ?? latest.last_resume?.session_id;
+            if (latestSessionId !== currentSessionId)
+                continue;
+            let latestEligibilityAtMs;
+            if (initialState === "done") {
+                const envelope = readLatestEnvelopeRecord(hqRoot, latest.lane_id);
+                if (!envelope || envelope.envelope.decision !== "done")
+                    continue;
+                const hasPendingWork = hasPendingKeepAliveWork(hqRoot, latest, questions);
+                const finalDoneVerdict = doneKeepAliveVerdict(latest, envelope.envelope, latest.keep_alive_standing === true && hasPendingWork, {
+                    hasPendingWork,
+                    nowMs,
+                    nextCheckAnchorMs: Date.parse(latest.last_envelope?.at ?? latest.updated_at),
+                });
+                if (finalDoneVerdict !== "eligible") {
+                    if (finalDoneVerdict === "next_check_at") {
+                        recordDoneKeepAlivePolicySkip(hqRoot, summary, latest, finalDoneVerdict, deps);
+                    }
+                    continue;
+                }
+                try {
+                    latestEligibilityAtMs = latestEnvelopeMtimeMs(hqRoot, latest, envelope.ref);
+                }
+                catch (err) {
+                    markDirty(summary, {
+                        kind: "lane",
+                        id: latest.lane_id,
+                        why: `keep-alive envelope timestamp unavailable after account selection: ${err instanceof Error ? err.message : String(err)}`,
+                    });
+                    continue;
+                }
+            }
+            else {
+                latestEligibilityAtMs = Date.parse(latest.interrupted_at ?? "");
+            }
+            const latestOptedInAtMs = Date.parse(latest.keep_alive_opted_in_at ?? "");
+            if (!Number.isFinite(latestEligibilityAtMs) || !Number.isFinite(latestOptedInAtMs))
+                continue;
+            if (latestEligibilityAtMs <= latestOptedInAtMs) {
+                recordKeepAliveSkip(hqRoot, latest, initialState === "done" ? "envelope_before_opt_in" : "interruption_before_opt_in", summary, deps);
+                continue;
+            }
+            current = deps.dryRun ? preparedLane : latest;
+        }
+        if (accountSelectionFailure !== undefined) {
+            summary.skipped.push({
+                kind: "lane",
+                id: current.lane_id,
+                why: `keep_alive_account_selection_failed: ${accountSelectionFailure}`,
+            });
+            if (!deps.dryRun) {
+                recordKeepAliveSkipEvent(hqRoot, current, "account_selection_failed", current.version, summary, deps, accountSelectionFailure);
+                recordKeepAliveEvent(hqRoot, current.lane_id, summary, {
+                    event: "keep_alive_account_selection_failed",
+                    at: nowIso,
+                    account: current.account ?? null,
+                    reason: accountSelectionFailure,
+                });
+            }
+        }
+        const queue = (expectedSeniorId) => casLaneIf(hqRoot, current.lane_id, (latestLane) => latestLane.version === current.version &&
+            latestLane.state === current.state &&
+            latestLane.keep_alive === true &&
+            latestLane.keep_alive_opted_in_at === current.keep_alive_opted_in_at &&
+            (expectedSeniorId === undefined ||
+                (latestLane.senior.kind === "lane" && latestLane.senior.id === expectedSeniorId)), (latestLane) => ({
+            ...latestLane,
+            state: "queued",
+            queued_reason: undefined,
+            queued_details: undefined,
+            queued_at: nowIso,
+            admission_reserved_at: undefined,
+            terminal_reason: undefined,
+            terminal_details: undefined,
+            pending_resume: {
+                session_id: currentSessionId,
+                trigger: carriesAnsweredQuestions ? "answered_questions" : "resume",
+                keep_alive: true,
+                resumed_from: resumedFrom,
+                text: resumeText,
+                compact: true,
+                at: nowIso,
+            },
+            keep_alive_resume_count: attempt,
+            keep_alive_history: appendCappedHistory(latestLane.keep_alive_history ?? [], {
+                at: nowIso,
+                resumed_from: resumedFrom,
+                account: latestLane.account ?? null,
+            }),
+            keep_alive_last_resume_at: nowIso,
+            keep_alive_next_eligible_at: nextEligibleAt,
+            keep_alive_exhausted_at: undefined,
+            keep_alive_blocked_reason: undefined,
+        }), deps.dryRun);
+        let queued;
+        if (seniorId) {
+            try {
+                queued = withHireGrantAdmission(hqRoot, seniorId, (snapshot) => {
+                    const latestLane = readLane(hqRoot, current.lane_id);
+                    if (latestLane.version !== current.version ||
+                        latestLane.senior.kind !== "lane" ||
+                        latestLane.senior.id !== seniorId)
+                        return { changed: false, record: latestLane };
+                    const refusal = terminalChildResumeHireGrantError(latestLane, snapshot, finishedChildrenDoNotCount);
+                    if (refusal !== null) {
+                        summary.skipped.push({
+                            kind: "lane",
+                            id: current.lane_id,
+                            why: `keep_alive_hire_admission: ${refusal.error}: ${refusal.message}`,
+                        });
+                        return { changed: false, record: latestLane };
+                    }
+                    return queue(seniorId);
+                }, undefined, new Set(), finishedChildrenDoNotCount);
+            }
+            catch (err) {
+                markDirty(summary, {
+                    kind: "lane",
+                    id: current.lane_id,
+                    why: `keep-alive hire admission failed: ${err instanceof Error ? err.message : String(err)}`,
+                });
+                continue;
+            }
+        }
+        else {
+            queued = queue(seniorId);
+        }
+        if (!queued.changed)
+            continue;
+        summary.resumed.push({
+            id: current.lane_id,
+            from: resumedFrom,
+            to: "queued",
+            reason: "keep_alive",
+        });
+        if (!deps.dryRun) {
+            recordKeepAliveEvent(hqRoot, current.lane_id, summary, {
+                event: "keep_alive_resume",
+                at: nowIso,
+                attempt,
+                next_eligible_at: nextEligibleAt,
+                resumed_from: resumedFrom,
+                reason: resumeReason,
+                ...(accountSelection !== undefined
+                    ? { account_selection: keepAliveAccountSelectionEvidence(accountSelection) }
+                    : {}),
+            });
+        }
+    }
+}
+async function resumeAwaiting(hqRoot, lanes, questions, summary, deps, onlyLaneIds) {
+    const config = loadLanesConfig(hqRoot);
+    const awaiting = lanes.filter((lane) => lane.state === "awaiting_input" &&
+        laneRunsHere(lane, deps.host) &&
+        (onlyLaneIds === undefined || onlyLaneIds.has(lane.lane_id)));
+    if (awaiting.length === 0 || deps.skipAdmissionWithoutCpuSample === true)
+        return;
+    const throttleDeps = deps.throttleDeps ?? defaultThrottleDeps(deps.env ?? process.env);
+    let throttleDecision;
+    if (deps.dryRun) {
+        const loaded = readThrottleState(throttleStatePath(hqRoot), throttleDeps);
+        const state = loaded === "missing" ? emptyThrottleState() : loaded;
+        throttleDecision = evaluateThrottle({
+            busy: deps.cpuBusyFraction !== undefined
+                ? deps.cpuBusyFraction
+                : deps.cpuObservation?.busy ?? await resolveCpuBusyFraction(throttleDeps),
+            availableMemMb: readAvailableMemMb(throttleDeps),
+            cpuCheckEnabled: isCpuCheckEnabled(throttleDeps.env),
+            state,
+            throttle: config.throttle,
+            nowMs: deps.now().getTime(),
+        });
+    }
+    else {
+        const throttle = await decideAdmission(hqRoot, config.throttle, throttleDeps, deps.cpuBusyFraction, deps.cpuObservation);
+        throttleDecision = throttle.decision;
+    }
+    const spawnFn = deps.spawn ?? (async (root, lane) => spawnLaneWorker(root, lane, {
+        ...spawnDepsForHost(deps),
+        lowDiskGuardEnabled: await lowDiskGuardEnabledForLane(root, lane, deps.readRegistryFlag),
+    }));
+    const nowMs = deps.now().getTime();
+    const fallbackAnswerAt = new Date(nowMs).toISOString();
+    const answerAtByLane = new Map();
+    for (const question of questions) {
+        if (question.status !== "answered")
+            continue;
+        const at = question.answer?.answered_at ?? question.asked_at;
+        const previous = answerAtByLane.get(question.origin.id);
+        if (previous === undefined || Date.parse(at) > Date.parse(previous)) {
+            answerAtByLane.set(question.origin.id, at);
+        }
+    }
+    const latestAnswerAt = (lane) => answerAtByLane.get(lane.lane_id) ?? fallbackAnswerAt;
+    awaiting.sort((a, b) => {
+        const byAnswerTime = Date.parse(latestAnswerAt(a)) - Date.parse(latestAnswerAt(b));
+        return byAnswerTime || compareLaneQueueOrder(a, b);
+    });
+    const capacityLanes = lanes.map((lane) => {
+        try {
+            return readLane(hqRoot, lane.lane_id);
+        }
+        catch {
+            return lane;
+        }
+    });
+    const running = capacityLanes.filter((lane) => (lane.state === "running" ||
+        hasFreshAdmissionReservation(lane, nowMs) ||
+        hasActivePendingResume(lane, nowMs)) &&
+        laneRunsHere(lane, deps.host));
+    for (const lane of awaiting) {
+        const current = readLane(hqRoot, lane.lane_id);
+        if (current.state !== "awaiting_input")
+            continue;
+        const pending = questions.filter((q) => q.origin.id === lane.lane_id && q.status === "pending");
+        const answered = questions.filter((q) => q.origin.id === lane.lane_id && q.status === "answered");
+        if (pending.length > 0 || answered.length === 0)
+            continue;
+        try {
+            if (current.senior.kind === "lane" && current.senior.id !== undefined) {
+                const companyResolution = resolveLaneCompany(hqRoot, current);
+                const company = companyResolution.company ?? undefined;
+                const finishedChildrenDoNotCount = await readLanesRegistryFlagFailOff(LANE_HIRE_GRANT_FINISHED_LANES_FLAG, {
+                    company,
+                    ...(company ? { companyUidSource: laneCompanyUidSource(companyResolution.source) } : {}),
+                    env: deps.env,
+                }, deps.readRegistryFlag ?? readLanesRegistryFlag);
+                if (finishedChildrenDoNotCount) {
+                    const admission = withHireGrantAdmission(hqRoot, current.senior.id, (snapshot) => {
+                        const latest = readLane(hqRoot, current.lane_id);
+                        if (latest.version !== current.version || latest.state !== "awaiting_input") {
+                            return { kind: "stale" };
+                        }
+                        const refusal = terminalChildResumeHireGrantError(latest, snapshot, true);
+                        return refusal === null
+                            ? { kind: "eligible" }
+                            : { kind: "refused", error: refusal.error, message: refusal.message };
+                    }, undefined, new Set(), true);
+                    if (admission.kind === "stale")
+                        continue;
+                    if (admission.kind === "refused") {
+                        if (!deps.dryRun)
+                            writeAnsweredQuestions(hqRoot, current, questions);
+                        summary.skipped.push({
+                            kind: "lane",
+                            id: current.lane_id,
+                            why: `${admission.error}: ${admission.message}`,
+                        });
+                        continue;
+                    }
+                }
+            }
+            let profileMaxConcurrent;
+            if (current.worker_profile !== undefined) {
+                profileMaxConcurrent = loadWorkerProfile(hqRoot, current.worker_profile).meta.max_concurrent;
+            }
+            const capReason = laneAdmissionCapReason(running, current, config, deps.host, profileMaxConcurrent, nowMs);
+            const answeredAt = latestAnswerAt(current);
+            const queueCandidate = { ...current, state: "queued", queued_at: answeredAt };
+            const earlierQueued = capacityLanes.some((queued) => queued.lane_id !== current.lane_id &&
+                queued.state === "queued" &&
+                queued.provider === current.provider &&
+                laneRunsHere(queued, deps.host) &&
+                compareLaneQueueOrder(queued, queueCandidate) < 0);
+            const queueReason = !throttleDecision.admit
+                ? "throttle"
+                : capReason ?? (earlierQueued ? "queue_position" : undefined);
+            if (queueReason !== undefined) {
+                const queuedCount = capacityLanes.filter((queued) => queued.state === "queued" &&
+                    queued.provider === current.provider &&
+                    laneRunsHere(queued, deps.host) &&
+                    !hasFreshAdmissionReservation(queued, nowMs)).length;
+                const maxQueued = config.providers[current.provider].max_queued;
+                if (queuedCount >= maxQueued) {
+                    summary.skipped.push({
+                        kind: "lane",
+                        id: current.lane_id,
+                        why: `lane_queue_full: ${current.provider} queue has ${queuedCount}/${maxQueued} lanes`,
+                    });
+                    continue;
+                }
+            }
+            if (!deps.dryRun)
+                writeAnsweredQuestions(hqRoot, current, questions);
+            if (queueReason !== undefined) {
+                const answerEnv = deps.spawnLaneDeps?.env ?? deps.env ?? process.env;
+                const answerCaller = typeof answerEnv.HQ_LANE_ID === "string"
+                    ? answerEnv.HQ_LANE_ID.trim() || "user"
+                    : "user";
+                const queued = casLaneIf(hqRoot, current.lane_id, (latest) => latest.state === "awaiting_input", (latest) => ({
+                    ...latest,
+                    state: "queued",
+                    queued_reason: queueReason,
+                    queued_details: undefined,
+                    queued_at: answeredAt,
+                    pending_resume: {
+                        ...(latest.provider_session_id
+                            ? { session_id: latest.provider_session_id }
+                            : {}),
+                        trigger: "answered_questions",
+                        caller: answerCaller,
+                        at: answeredAt,
+                    },
+                }), deps.dryRun);
+                summary.resumed.push({
+                    id: queued.record.lane_id,
+                    from: "awaiting_input",
+                    to: "queued",
+                    reason: queueReason,
+                });
+                capacityLanes.push(queued.record);
+                continue;
+            }
+            if (deps.dryRun) {
+                summary.resumed.push({
+                    id: lane.lane_id,
+                    from: "awaiting_input",
+                    to: "running",
+                });
+                running.push({ ...current, state: "running" });
+                continue;
+            }
+            const started = await spawnFn(hqRoot, lane);
+            if (started.state === "running")
+                running.push(started);
+            summary.resumed.push({
+                id: started.lane_id,
+                from: "awaiting_input",
+                to: started.state,
+            });
+        }
+        catch (err) {
+            terminalizeModelUnsupported(hqRoot, lane, err);
+            const errorName = err instanceof LanesError ? `${err.error}: ` : "";
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            markDirty(summary, {
+                kind: "lane",
+                id: lane.lane_id,
+                why: `resume failed: ${errorName}${errorMessage}`,
+            });
+        }
+    }
+}
+/**
+ * One idempotent reconcile pass. Throws only when the store directory itself
+ * cannot be listed; per-record failures are logged onto the summary and set
+ * `ok: false` rather than being swallowed.
+ */
+export async function runReconcilePass(hqRoot, deps) {
+    return withReconcileLock(hqRoot, async () => runPassBody(hqRoot, deps));
+}
+async function runTerminalKeepAliveCandidatePass(hqRoot, lanes, summary, deps, now, candidate) {
+    const lane = lanes.find((row) => row.lane_id === candidate.laneId);
+    if (!lane || lane.version !== candidate.version || lane.state !== "done" ||
+        lane.keep_alive !== true || !laneRunsHere(lane, deps.host))
+        return summary;
+    let company;
+    try {
+        company = resolveLaneCompany(hqRoot, lane).company;
+    }
+    catch (err) {
+        markDirty(summary, { kind: "lane", id: lane.lane_id, why: `keep-alive company lookup failed: ${err instanceof Error ? err.message : String(err)}` });
+        return summary;
+    }
+    if (company === null)
+        return summary;
+    const readFlag = deps.readRegistryFlag ?? readLanesRegistryFlag;
+    const options = { company, env: deps.env ?? process.env };
+    let keepAliveEnabled;
+    let lineageAware;
+    let immediateFirstResumeEnabled;
+    try {
+        [keepAliveEnabled, lineageAware, immediateFirstResumeEnabled] = await Promise.all([
+            readFlag(LEAD_LANE_KEEP_ALIVE_FLAG, options),
+            readFlag(LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, options),
+            readFlag(LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_FLAG, options),
+        ]);
+    }
+    catch (err) {
+        markDirty(summary, { kind: "lane", id: lane.lane_id, why: `keep-alive flag read failed: ${err instanceof Error ? err.message : String(err)}` });
+        return summary;
+    }
+    if (!keepAliveEnabled)
+        return summary;
+    await withAllLaneAdmissionLocks(hqRoot, async () => {
+        const freshLanes = loadLaneRecords(hqRoot, summary);
+        const freshQuestions = loadQuestionRecords(hqRoot, summary);
+        const current = freshLanes.find((row) => row.lane_id === candidate.laneId);
+        if (!current || current.version !== candidate.version || current.state !== "done")
+            return;
+        await resumeKeepAlive(hqRoot, freshLanes, freshQuestions, summary, deps, now, new Map([[keepAliveCompanyKey(company), true]]), new Map([[keepAliveCompanyKey(company), lineageAware]]), new Map(), new Map([[keepAliveCompanyKey(company), immediateFirstResumeEnabled]]), candidate);
+        await admitQueued(hqRoot, loadLaneRecords(hqRoot, summary), summary, deps, now, new Set([candidate.laneId]));
+    });
+    return summary;
+}
+/** Run the reconcile answer-resume path for one lane before questions answer returns. */
+export async function wakeAnsweredLaneNow(hqRoot, laneId, deps) {
+    const summary = emptySummary(deps.dryRun);
+    const throttleDeps = deps.throttleDeps ?? defaultThrottleDeps(deps.env ?? process.env);
+    await withReconcileLock(hqRoot, async () => {
+        const previousState = readThrottleState(throttleStatePath(hqRoot), throttleDeps);
+        const previousSnapshot = previousState === "missing" || previousState === "unreadable"
+            ? undefined
+            : previousState.cpu_snapshot;
+        const cpuObservation = await sampleCpuBusyObservation(throttleDeps, previousSnapshot);
+        const admissionDeps = {
+            ...deps,
+            cpuBusyFraction: cpuObservation.busy,
+            cpuObservation,
+            skipAdmissionWithoutCpuSample: false,
+        };
+        await withAllLaneAdmissionLocks(hqRoot, async () => {
+            const lanes = loadLaneRecords(hqRoot, summary);
+            const questions = loadQuestionRecords(hqRoot, summary);
+            if (!lanes.some((lane) => lane.lane_id === laneId)) {
+                throw new LanesError("lane_not_found", `Lane ${laneId} was not found`, { lane_id: laneId });
+            }
+            await resumeAwaiting(hqRoot, lanes, questions, summary, admissionDeps, new Set([laneId]));
+        });
+    });
+    const latest = readLane(hqRoot, laneId);
+    const laneQuestions = loadQuestionRecords(hqRoot, emptySummary(false)).filter((question) => question.origin.id === laneId);
+    const remaining = laneQuestions
+        .filter((question) => question.status === "pending")
+        .map((question) => question.question_id)
+        .sort();
+    if (latest.state === "running") {
+        return { status: "resumed", lane_state: latest.state };
+    }
+    if (latest.state === "queued" && latest.pending_resume?.trigger === "answered_questions") {
+        return {
+            status: "queued",
+            lane_state: latest.state,
+            ...(latest.queued_reason !== undefined ? { queued_reason: latest.queued_reason } : {}),
+        };
+    }
+    if (latest.state === "awaiting_input" && remaining.length > 0) {
+        return {
+            status: "awaiting_answers",
+            lane_state: latest.state,
+            remaining_question_ids: remaining,
+        };
+    }
+    const failure = summary.skipped.find((skip) => skip.kind === "lane" && skip.id === laneId);
+    if (latest.state === "awaiting_input" && failure?.why.startsWith("hire_grant_exhausted:")) {
+        return {
+            status: "deferred",
+            lane_state: latest.state,
+            error: failure.why,
+        };
+    }
+    return {
+        status: "failed",
+        lane_state: latest.state,
+        error: failure?.why ?? `Lane ${laneId} did not leave awaiting_input after its questions were answered`,
+    };
+}
+//# sourceMappingURL=reconcile.js.map