@indigoai-us/hq-cli 5.312.2-beta.0 → 5.314.0

package/dist/lib/lanes/reconcile.js

@@ -1,3193 +0,0 @@
-/**
- * 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 } from "./registry-flag.js";
-import { 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_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);
-    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")) {
-                    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 ??
-        ((root, lane) => spawnLaneWorker(root, lane, spawnDepsForHost(deps)));
-    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 = 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: 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",
-                ...(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();
-        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;
-        if (seniorId !== undefined) {
-            let grantPreflight;
-            try {
-                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);
-                    return refusal === null
-                        ? { kind: "eligible" }
-                        : { kind: "refused", error: refusal.error, message: refusal.message };
-                });
-            }
-            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);
-                    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);
-                });
-            }
-            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,
-                ...(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 ?? ((root, lane) => spawnLaneWorker(root, lane, spawnDepsForHost(deps)));
-    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 {
-            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 = 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);
-    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