@indigoai-us/hq-cli 5.203.0 → 5.205.0

package/dist/lib/lanes/profile.js

@@ -28,6 +28,7 @@ const PROFILE_META_KEYS = new Set([
     "max_concurrent",
     "source",
     "accounts",
+    "keep_alive",
 ]);
 function isPlainObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -164,6 +165,12 @@ function parseMeta(id, dir, raw) {
             value: raw.fast_mode,
         });
     }
+    if (raw.keep_alive !== undefined && typeof raw.keep_alive !== "boolean") {
+        throw profileError(id, dir, "meta.yaml keep_alive must be a boolean when present", {
+            field: "keep_alive",
+            value: raw.keep_alive,
+        });
+    }
     let version;
     if (raw.version !== undefined) {
         if (typeof raw.version !== "string" || raw.version.trim().length === 0) {
@@ -211,6 +218,7 @@ function parseMeta(id, dir, raw) {
         ...(account !== undefined ? { account } : {}),
         ...(effort !== undefined ? { effort } : {}),
         ...(raw.fast_mode !== undefined ? { fast_mode: raw.fast_mode } : {}),
+        ...(raw.keep_alive !== undefined ? { keep_alive: raw.keep_alive } : {}),
         ...(maxConcurrent !== undefined ? { max_concurrent: maxConcurrent } : {}),
         ...(source !== undefined ? { source } : {}),
         ...(accounts !== undefined ? { accounts } : {}),

package/dist/lib/lanes/provider-rejection.d.ts

@@ -35,7 +35,7 @@ export interface ProviderRejection {
     /** Derived from the status: a transient class (408, 425, 5xx) is retryable; a 4xx is not. */
     retryable: boolean;
     /** Which event on the stream carried the failure. */
-    event: "codex.turn.failed" | "claude.result.is_error" | "grok.error";
+    event: "codex.turn.failed" | "claude.result.is_error" | "claude.result.login_failure" | "grok.error";
 }
 export declare function isProviderLoginFailure(failure: ProviderRejection | null): boolean;
 export declare function capMessage(message: string): string;

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

@@ -28,7 +28,7 @@ export const QUOTA_STATUS = 429;
 function isProviderLoginMessage(provider, message) {
     switch (provider) {
         case "claude":
-            return /\bnot logged in\b/i.test(message);
+            return /(?:\bnot logged in\b|\bplease run\s+\/login\b)/i.test(message);
         case "codex":
             return /\bnot logged in\b/i.test(message) ||
                 /\bmissing bearer or basic authentication in header\b/i.test(message);
@@ -40,6 +40,11 @@ function isProviderLoginMessage(provider, message) {
         }
     }
 }
+/** Successful Claude results can contain worker prose, so only accept its short CLI login banner. */
+function isClaudeSuccessLoginMessage(message) {
+    const trimmed = message.trim();
+    return trimmed.length <= 80 && /^not logged in\b.{0,40}please run \/login\.?$/i.test(trimmed);
+}
 export function isProviderLoginFailure(failure) {
     return failure !== null && isProviderLoginMessage(failure.provider, failure.message);
 }
@@ -163,11 +168,14 @@ export function parseClaudeResultRejection(text) {
     const found = scanJsonLinesBackward(text, (rec) => {
         if (rec.type !== "result")
             return null;
-        if (rec.is_error !== true)
+        const message = typeof rec.result === "string" ? rec.result : "";
+        const loginFailure = rec.is_error === true
+            ? isProviderLoginMessage("claude", message)
+            : isClaudeSuccessLoginMessage(message);
+        if (rec.is_error !== true && !loginFailure)
             return NOT_REJECTED;
         const status = statusOf(rec.api_error_status);
-        const message = typeof rec.result === "string" ? rec.result : "";
-        if (status === null && !isProviderLoginMessage("claude", message))
+        if (status === null && !loginFailure)
             return NOT_REJECTED;
         return {
             reason: PROVIDER_REJECTED_REASON,
@@ -176,7 +184,9 @@ export function parseClaudeResultRejection(text) {
             status,
             error_type: typeof rec.subtype === "string" ? rec.subtype : null,
             retryable: retryableFromStatus(status),
-            event: "claude.result.is_error",
+            event: loginFailure && rec.is_error !== true
+                ? "claude.result.login_failure"
+                : "claude.result.is_error",
         };
     });
     return found === NOT_REJECTED ? null : found;

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

@@ -8,6 +8,7 @@
 import { type LivenessDeps } from "./liveness.js";
 import { type EnvelopeRepairSpawnInput, type SpawnLaneDeps } from "./spawn.js";
 import { type ThrottleDeps } from "./throttle.js";
+import { readLanesRegistryFlag } from "./registry-flag.js";
 import type { LaneRecord, LivenessState, QueuedReason, QuestionRecord, SeniorRef } from "./types.js";
 import { type LaneMesh } from "./mesh-events.js";
 /** Spec §9: unanswered at the current hop for 60 minutes → one hop. */
@@ -71,6 +72,8 @@ export interface ReconcileDeps {
     readSessionSenior?: (sessionId: string) => SeniorRef;
     presenceConnected?: boolean;
     env?: NodeJS.ProcessEnv;
+    /** Flag reader seam used to assert rollout reads happen before admission locks. */
+    readRegistryFlag?: typeof readLanesRegistryFlag;
     /** Detached mesh seam for dead-watcher recovery. */
     mesh?: LaneMesh | null;
     /** Bound on one terminal mesh emit during dead-host recovery. Default 10 s. */

package/dist/lib/lanes/reconcile.js

@@ -10,21 +10,26 @@ 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 { loadLanesConfig, providerQuotaDefaultHoldMs } from "./config.js";
 import { MAX_LANE_DEPTH } from "./constants.js";
 import { AccountResolutionError, LanesError, isLaneVersionConflict } from "./errors.js";
+import { LANE_HIRE_GRANTS_FLAG, terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./hire-grants.js";
 import { loadWorkerProfile } from "./profile.js";
 import { classifySessionLiveness, defaultLivenessDeps, loadLivenessIndex, readDaemonPresenceConnected, unindexedClaudeSessionLiveness, } from "./liveness.js";
 import { ANSWERED_QUESTIONS_FILE, armLaneWatcher, envelopeRepairMode, isPidRecordAlive, laneRunDir, readPidRecord, readSpawnManifest, markSpawnFailure, spawnEnvelopeRepair, spawnLaneWorker, retryLaneOnAlternateAccount, } from "./spawn.js";
 import { appendCappedHistory, lanesStoreRoot, parseLaneRecord, parseQuestionRecord, readLane, readQuestion, updateLane, updateQuestion, } from "./store.js";
 import { applyThrottleDecision, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, throttleStatePath, writeThrottleState, } from "./throttle.js";
+import { readLanesRegistryFlag } from "./registry-flag.js";
+import { LEAD_LANE_KEEP_ALIVE_FLAG, LEAD_LANE_KEEP_ALIVE_MAX_RESUMES, LEAD_LANE_KEEP_ALIVE_RESUME_TEXT, leadLaneKeepAliveBackoffMs, } from "./keep-alive.js";
+import { providerSupportsSessionResume } from "./delivery.js";
 import { applyDefaultQuotaHold, readQuotaSignal, recordAccountQuota } from "./quota.js";
 import { answeredQuestionEntries, raiseEnvelopeQuestions } from "./questions.js";
-import { SILENCE_MS, classifyLaneExit, isPidAlive, missingExpectedEnvelopeFile, readLatestEnvelopeFile, readLatestEnvelopeRecord, } from "./watcher.js";
+import { SILENCE_MS, classifyLaneExit, isPidAlive, missingExpectedEnvelopeFile, readLatestEnvelopeFile, readLatestEnvelopeRecord, watcherEventsPath, writeWatcherDecision, } from "./watcher.js";
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshCompany, } from "./mesh-events.js";
 import { laneStories, storyStatusForEnvelope } from "./stories.js";
 import { decideEnvelopeRepair, envelopeQuestionIds, routeProviderFailure } from "./watcher.js";
-import { providerRejectionDetails, readProviderRejection, } from "./provider-rejection.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. */
@@ -38,6 +43,13 @@ export const PICKUP_VALIDATION_MAX_AGE_MS = 15 * 60 * 1000;
 export const PICKUP_VALIDATION_TIMEOUT_REASON = "pickup_validation_timeout";
 export const RECONCILE_UNIT_NAME = "hq-lanes-reconcile.service";
 export const RECONCILE_TIMER_NAME = "hq-lanes-reconcile.timer";
+function spawnDepsForHost(deps) {
+    return {
+        ...(deps.spawnLaneDeps ?? {}),
+        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`);
 }
@@ -326,12 +338,16 @@ function availableBalancedAccount(hqRoot, lane, occupying, config, host, profile
             continue;
         if (config.providers[lane.provider].accounts[account]?.enabled !== true)
             continue;
-        const status = accountStatus(lane.provider, account, config);
+        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 } : {}),
             });
         }
@@ -655,7 +671,7 @@ export async function runPassBody(hqRoot, deps) {
     };
     const readSessionSenior = deps.readSessionSenior ??
         ((sessionId) => defaultReadSessionSenior(hqRoot, sessionId));
-    const configuredClaudeHomes = Object.values(config.providers.claude.accounts).map((account) => account.home);
+    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)) {
@@ -780,11 +796,51 @@ export async function runPassBody(hqRoot, deps) {
             });
         }
     }
+    const readRegistryFlag = deps.readRegistryFlag ?? readLanesRegistryFlag;
+    const keepAliveFlagCompanies = new Map();
+    const keepAliveHireGrantFlagCompanies = new Map();
+    for (const lane of lanes) {
+        if (lane.state !== "done" ||
+            lane.keep_alive !== true ||
+            !laneRunsHere(lane, deps.host) ||
+            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;
+        const envelope = readLatestEnvelopeRecord(hqRoot, lane.lane_id)?.envelope;
+        if (!envelope || envelope.decision !== "done" || envelope.story_complete === true)
+            continue;
+        const key = keepAliveCompanyKey(lane.company);
+        keepAliveFlagCompanies.set(key, lane.company);
+        if (lane.senior.kind === "lane" && lane.senior.id) {
+            keepAliveHireGrantFlagCompanies.set(key, lane.company);
+        }
+    }
+    const keepAliveFlagByCompany = new Map();
+    const keepAliveHireGrantFlagByCompany = new Map();
+    const env = deps.env ?? process.env;
+    await Promise.all([
+        ...[...keepAliveFlagCompanies.entries()].map(async ([key, company]) => {
+            keepAliveFlagByCompany.set(key, await readRegistryFlag(LEAD_LANE_KEEP_ALIVE_FLAG, {
+                company: company ?? undefined,
+                env,
+            }));
+        }),
+        ...[...keepAliveHireGrantFlagCompanies.entries()].map(async ([key, company]) => {
+            keepAliveHireGrantFlagByCompany.set(key, await readRegistryFlag(LANE_HIRE_GRANTS_FLAG, {
+                company: company ?? undefined,
+                env,
+            }));
+        }),
+    ]);
     await withAllLaneAdmissionLocks(hqRoot, async () => {
         const freshLanes = loadLaneRecords(hqRoot, summary);
+        resumeDoneKeepAlive(hqRoot, freshLanes, summary, deps, now, keepAliveFlagByCompany, keepAliveHireGrantFlagByCompany);
+        const drainLanes = loadLaneRecords(hqRoot, summary);
         const freshQuestions = loadQuestionRecords(hqRoot, summary);
-        await admitQueued(hqRoot, freshLanes, summary, deps, now);
-        await resumeAwaiting(hqRoot, freshLanes, freshQuestions, summary, deps);
+        await admitQueued(hqRoot, drainLanes, summary, deps, now);
+        await resumeAwaiting(hqRoot, drainLanes, freshQuestions, summary, deps);
     });
     if (!deps.dryRun && summary.errors.length === 0) {
         try {
@@ -887,7 +943,7 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                 }
                 if (!watcherAlive && !deps.dryRun) {
                     try {
-                        armLaneWatcher(hqRoot, lane.lane_id, deps.spawnLaneDeps ?? {});
+                        armLaneWatcher(hqRoot, lane.lane_id, spawnDepsForHost(deps));
                         summary.heartbeats.push(`${lane.lane_id}:watcher-rearmed`);
                     }
                     catch (err) {
@@ -941,10 +997,10 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                     repairCandidate.envelope === null &&
                     (!repairCandidate.missing || envelopeRepairMode(classified.provider) === "resume")) {
                     const spawnRepair = deps.spawnRepair ??
-                        ((root, repairLane, input) => spawnEnvelopeRepair(root, repairLane, input, deps.spawnLaneDeps));
+                        ((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, deps.spawnLaneDeps);
+                        armLaneWatcher(hqRoot, lane.lane_id, spawnDepsForHost(deps));
                         summary.heartbeats.push(`${lane.lane_id}:envelope-repair`);
                         continue;
                     }
@@ -969,8 +1025,7 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                 if (!deps.dryRun && accountRetryReason && classified.account) {
                     try {
                         const recovered = await retryLaneOnAlternateAccount(hqRoot, classified, accountRetryReason, "reconcile", {
-                            ...(deps.spawnLaneDeps ?? {}),
-                            admissionHost: deps.host,
+                            ...spawnDepsForHost(deps),
                         });
                         summary.dead_host.push({
                             id: lane.lane_id,
@@ -1197,7 +1252,7 @@ async function admitQueued(hqRoot, lanes, summary, deps, now) {
         nowMs,
     });
     const spawnFn = deps.spawn ??
-        ((root, lane) => spawnLaneWorker(root, lane, deps.spawnLaneDeps));
+        ((root, lane) => spawnLaneWorker(root, lane, spawnDepsForHost(deps)));
     const running = lanes.filter((lane) => (lane.state === "running" ||
         hasFreshAdmissionReservation(lane, now.getTime()) ||
         hasActivePendingResume(lane, now.getTime())) &&
@@ -1311,6 +1366,231 @@ async function admitQueued(hqRoot, lanes, summary, deps, now) {
         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
+        ? 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 resumeDoneKeepAlive(hqRoot, lanes, summary, deps, now, flagByCompany, hireGrantFlagByCompany) {
+    const nowMs = now.getTime();
+    const nowIso = now.toISOString();
+    const config = loadLanesConfig(hqRoot);
+    for (const lane of lanes) {
+        if (lane.state !== "done" ||
+            lane.keep_alive !== true ||
+            !laneRunsHere(lane, deps.host))
+            continue;
+        const latest = readLatestEnvelopeRecord(hqRoot, lane.lane_id);
+        const envelope = latest?.envelope;
+        if (!envelope || envelope.decision !== "done")
+            continue;
+        if (envelope.story_complete === true) {
+            if (hasKeepAliveProgress(lane)) {
+                casLaneIf(hqRoot, lane.lane_id, (current) => current.version === lane.version &&
+                    current.state === "done" &&
+                    current.keep_alive === true, (current) => clearedKeepAliveProgress(current), deps.dryRun);
+            }
+            continue;
+        }
+        if (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 (flagByCompany.get(keepAliveCompanyKey(lane.company)) !== true)
+            continue;
+        const current = readLane(hqRoot, lane.lane_id);
+        if (current.version !== lane.version ||
+            current.state !== "done" ||
+            current.keep_alive !== true ||
+            !laneRunsHere(current, deps.host))
+            continue;
+        const currentEnvelope = readLatestEnvelopeRecord(hqRoot, current.lane_id)?.envelope;
+        if (!currentEnvelope || currentEnvelope.decision !== "done")
+            continue;
+        if (currentEnvelope.story_complete === true) {
+            if (hasKeepAliveProgress(current)) {
+                casLaneIf(hqRoot, current.lane_id, (latestLane) => latestLane.version === current.version &&
+                    latestLane.state === "done" &&
+                    latestLane.keep_alive === true, (latestLane) => clearedKeepAliveProgress(latestLane), deps.dryRun);
+            }
+            continue;
+        }
+        const providerSessionId = current.provider_session_id ?? current.last_resume?.session_id;
+        if (current.terminal_reason === PROVIDER_REJECTED_REASON ||
+            current.terminal_reason === "account_not_logged_in" ||
+            typeof providerSessionId !== "string" ||
+            providerSessionId.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 === "done" &&
+                latestLane.keep_alive === true &&
+                (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,
+                });
+            }
+            continue;
+        }
+        const attempt = attempts + 1;
+        const doneAtMs = Date.parse(current.updated_at);
+        const attemptEligibleMs = doneAtMs + leadLaneKeepAliveBackoffMs(attempt);
+        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) {
+            if (resetByHuman && hasKeepAliveProgress(current)) {
+                casLaneIf(hqRoot, current.lane_id, (latestLane) => latestLane.version === current.version &&
+                    latestLane.state === "done" &&
+                    latestLane.keep_alive === true, (latestLane) => clearedKeepAliveProgress(latestLane), deps.dryRun);
+            }
+            continue;
+        }
+        const nextEligibleAt = new Date(nowMs + leadLaneKeepAliveBackoffMs(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`,
+            });
+            continue;
+        }
+        const queue = (expectedSeniorId) => casLaneIf(hqRoot, current.lane_id, (latestLane) => latestLane.version === current.version &&
+            latestLane.state === "done" &&
+            latestLane.keep_alive === true &&
+            (expectedSeniorId === undefined ||
+                (latestLane.senior.kind === "lane" && latestLane.senior.id === expectedSeniorId)), (latestLane) => ({
+            ...latestLane,
+            state: "queued",
+            queued_reason: undefined,
+            queued_at: nowIso,
+            admission_reserved_at: undefined,
+            terminal_reason: undefined,
+            terminal_details: undefined,
+            pending_resume: {
+                session_id: providerSessionId,
+                trigger: "resume",
+                resumed_from: "done",
+                text: LEAD_LANE_KEEP_ALIVE_RESUME_TEXT,
+                compact: true,
+                at: nowIso,
+            },
+            keep_alive_resume_count: attempt,
+            keep_alive_last_resume_at: nowIso,
+            keep_alive_next_eligible_at: nextEligibleAt,
+            keep_alive_exhausted_at: undefined,
+        }), deps.dryRun);
+        const seniorId = current.senior.kind === "lane" ? current.senior.id : undefined;
+        let queued;
+        if (seniorId &&
+            hireGrantFlagByCompany.get(keepAliveCompanyKey(current.company)) === true) {
+            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: "done",
+            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,
+            });
+        }
+    }
+}
 async function resumeAwaiting(hqRoot, lanes, questions, summary, deps, onlyLaneIds) {
     const config = loadLanesConfig(hqRoot);
     const awaiting = lanes.filter((lane) => lane.state === "awaiting_input" &&
@@ -1336,7 +1616,7 @@ async function resumeAwaiting(hqRoot, lanes, questions, summary, deps, onlyLaneI
         const throttle = await decideAdmission(hqRoot, config.throttle, throttleDeps);
         throttleDecision = throttle.decision;
     }
-    const spawnFn = deps.spawn ?? ((root, lane) => spawnLaneWorker(root, lane, deps.spawnLaneDeps));
+    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();

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

@@ -68,6 +68,7 @@ export type ProveDetachedFn = (pid: number) => DetachProof;
 export type KillProcessFn = (pid: number, signal?: NodeJS.Signals) => void;
 export interface SpawnLaneDeps {
     env?: NodeJS.ProcessEnv;
+    hostname?: string;
     /** The caller's host scope for admission checks; reconcile supplies its resolved host. */
     admissionHost?: AdmissionHost;
     /** Provider model catalog dependencies, shared with create in tests. */