@indigoai-us/hq-cli 5.204.0 → 5.205.0

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ## [Unreleased]
 
+## [5.205.0] — 2026-09-26
+
+### Added
+
+- `hq lanes create` and `hq lanes resume` accept `--keep-alive`. When the
+  default-off `lanes.lead-keep-alive` flag is enabled, an opted-in lead lane
+  resumes after a `done` turn that leaves its story open. The first resume
+  waits at least five minutes; later attempts back off to an hour and stop
+  after 24 consecutive attempts.
+  `hq lanes show --json` reports the counter and next eligible time.
+- Worker profiles accept boolean `keep_alive`. Add this key only after the
+  hq-cli release with this change is installed; older CLIs reject unknown
+  profile metadata.
+
+### Fixed
+
+- Claude result text that says `Not logged in` or `Please run /login` now marks
+  a lane failed with `account_not_logged_in` when no envelope was written.
+
 ## [5.204.0] — 2026-09-26
 
 ### Added

package/dist/command-catalog.generated.d.ts

@@ -7345,6 +7345,9 @@ export declare const COMMAND_CATALOG: readonly [{
         }, {
             readonly flags: "--hire-grant <n>";
             readonly description: "Maximum alive direct child lanes assigned to this lane; set by its senior";
+        }, {
+            readonly flags: "--keep-alive";
+            readonly description: "Automatically resume done lead lanes while their story remains open";
         }, {
             readonly flags: "--timeout <secs>";
             readonly description: "Deadline in seconds (warns, does not kill)";
@@ -7878,6 +7881,9 @@ export declare const COMMAND_CATALOG: readonly [{
         }, {
             readonly flags: "--worker <profile>";
             readonly description: "Attach a personal worker profile for the resumed turn";
+        }, {
+            readonly flags: "--keep-alive";
+            readonly description: "Automatically resume done lead lanes while their story remains open";
         }, {
             readonly flags: "--mesh-company <slug>";
             readonly description: "Attach Work Mesh attribution after verifying company membership";

package/dist/command-catalog.generated.js

@@ -9494,6 +9494,10 @@ export const COMMAND_CATALOG = [
                         "flags": "--hire-grant <n>",
                         "description": "Maximum alive direct child lanes assigned to this lane; set by its senior"
                     },
+                    {
+                        "flags": "--keep-alive",
+                        "description": "Automatically resume done lead lanes while their story remains open"
+                    },
                     {
                         "flags": "--timeout <secs>",
                         "description": "Deadline in seconds (warns, does not kill)"
@@ -10189,6 +10193,10 @@ export const COMMAND_CATALOG = [
                         "flags": "--worker <profile>",
                         "description": "Attach a personal worker profile for the resumed turn"
                     },
+                    {
+                        "flags": "--keep-alive",
+                        "description": "Automatically resume done lead lanes while their story remains open"
+                    },
                     {
                         "flags": "--mesh-company <slug>",
                         "description": "Attach Work Mesh attribution after verifying company membership"

package/dist/commands/lanes.js

@@ -34,7 +34,7 @@ import { openMeshTransport } from "../lib/mesh/client.js";
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshEventIdentity, } from "../lib/lanes/mesh-events.js";
 import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
 import { effectiveAccountHome } from "../lib/lanes/account-home.js";
-import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, createQuestion, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseLivenessState, parseQuestionRecord, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, runReconcilePass, wakeAnsweredLaneNow, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withLaneHireLocks, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
+import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, createQuestion, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseLivenessState, parseQuestionRecord, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, runReconcilePass, wakeAnsweredLaneNow, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withLaneHireLocks, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
 import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
 import { questionBodyAbsPath } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
@@ -864,33 +864,15 @@ async function withResumeHireAdmission(ctx, lane, fn) {
     }
     if (!await ctx.laneHireGrantsEnabled(lane.company))
         return fn();
-    return withHireGrantAdmission(hqRoot, lane.senior.id, ({ parent, children, parentGrant, availableChildGrant }) => {
+    return withHireGrantAdmission(hqRoot, lane.senior.id, (snapshot) => {
         const current = readLane(hqRoot, lane.lane_id);
         // A different resume already reactivated this lane; it occupies the slot
         // in the shared snapshot and is not a second hire.
         if (!isTerminalLaneState(current.state))
             return fn();
-        if (isTerminalLaneState(parent.state)) {
-            throw new LanesError("hire_grant_senior_inactive", `Senior lane ${parent.lane_id} is ${parent.state} and cannot resume child lanes`, { senior_lane_id: parent.lane_id, state: parent.state });
-        }
-        if (children.length >= (parent.hire_grant ?? 0)) {
-            throw hireGrantCapacityError(parent, children);
-        }
-        const requestedGrant = current.hire_grant ?? 0;
-        if (requestedGrant > availableChildGrant) {
-            throw new LanesError("hire_grant_carve_exceeded", `Senior lane ${parent.lane_id} has ${availableChildGrant} unassigned hire grant remaining, but terminal child ${current.lane_id} needs ${requestedGrant} to resume. Ask its senior for more: write an ask envelope with the desired total grant and why; the senior runs hq lanes grant ${parent.lane_id} --hire <n>.`, {
-                senior_lane_id: parent.lane_id,
-                parent_grant: parentGrant,
-                alive_children: children.map((child) => child.lane_id),
-                assigned_child_grants: assignedChildHireGrants(children),
-                requested_hire_grant: requestedGrant,
-                available_hire_grant: availableChildGrant,
-                ask_guidance: {
-                    envelope: "decision=ask; include the desired total grant and the reason",
-                    senior_command: `hq lanes grant ${parent.lane_id} --hire <n>`,
-                },
-            });
-        }
+        const refusal = terminalChildResumeHireGrantError(current, snapshot);
+        if (refusal !== null)
+            throw refusal;
         return fn();
     });
 }
@@ -2469,6 +2451,11 @@ async function runCreate(ctx, opts) {
     const profileEffort = profileDefaultsApply ? profile?.meta.effort : undefined;
     const profileAccount = profileDefaultsApply ? profile?.meta.account : undefined;
     const profileAccounts = profileDefaultsApply ? profile?.meta.accounts : undefined;
+    const keepAlive = opts.keepAlive === true ||
+        (profileDefaultsApply && profile?.meta.keep_alive === true);
+    if (keepAlive && !providerSupportsSessionResume(provider)) {
+        throw new LanesError("keep_alive_provider_unsupported", `Provider ${provider} cannot resume recorded sessions, so keep-alive is unavailable`, { provider });
+    }
     const briefAbs = resolveCallerPath(ctx.callerCwd(), briefFile);
     if (!ctx.existsSync(briefAbs)) {
         throw new LanesError("brief_not_found", `Brief file not found: ${briefAbs}`, {
@@ -2927,6 +2914,7 @@ async function runCreate(ctx, opts) {
                     worker_profile_ignored: ignoredWorkerProfileFields(provider),
                 }
                 : {}),
+            keep_alive: keepAlive,
             provider,
             account: pinnedAccount,
             ...(accountSelection !== undefined ? { account_selection: accountSelection } : {}),
@@ -3382,6 +3370,7 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options) {
                 model: options.model,
                 effort: options.effort,
                 worker: options.worker,
+                keepAlive: options.keepAlive,
                 hire: options.hire,
                 grantContext,
                 compact: options.compact,
@@ -4508,6 +4497,13 @@ async function runShow(ctx, laneId) {
         effort_source: lane.effort_source ?? null,
         terminal_reason: lane.terminal_reason ?? null,
         terminal_details: lane.terminal_details ?? null,
+        keep_alive_state: {
+            enabled: lane.keep_alive === true,
+            consecutive_auto_resumes: lane.keep_alive_resume_count ?? 0,
+            last_auto_resume_at: lane.keep_alive_last_resume_at ?? null,
+            next_eligible_at: lane.keep_alive_next_eligible_at ?? null,
+            exhausted_at: lane.keep_alive_exhausted_at ?? null,
+        },
         last_message_at: lane.last_message_at ?? null,
         last_compaction: lane.last_compaction
             ? { ...lane.last_compaction, after: compactionAfterUsage(storedLane) }
@@ -4922,6 +4918,9 @@ function applyResumeProfileAndEffort(current, next, input) {
         next.worker_profile_hash = profile.contentHash;
         next.worker_profile_ignored = ignoredWorkerProfileFields(current.provider);
         next.worker_policy_delivery = undefined;
+        if (profile.meta.keep_alive !== undefined) {
+            next.keep_alive = profile.meta.keep_alive;
+        }
         if (next.model_source !== "cli") {
             if (profile.meta.provider === current.provider && profile.meta.model !== undefined) {
                 next.model = profile.meta.model;
@@ -4937,6 +4936,8 @@ function applyResumeProfileAndEffort(current, next, input) {
         next.effort = input.effort.effort;
         next.effort_source = input.effort.source;
     }
+    if (input.keepAlive !== undefined)
+        next.keep_alive = input.keepAlive;
 }
 function recordResumeSetup(ctx, lane, input) {
     if (input.cliModel !== undefined) {
@@ -4958,6 +4959,7 @@ function recordResumeSetup(ctx, lane, input) {
     }
     if (input.profile === undefined &&
         input.effort === undefined &&
+        input.keepAlive === undefined &&
         input.cliModel === undefined &&
         input.meshCompany === undefined)
         return lane;
@@ -4980,6 +4982,23 @@ function recordResumeSetup(ctx, lane, input) {
         return next;
     });
 }
+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 resetKeepAliveProgress(lane) {
+    if (!hasKeepAliveProgress(lane))
+        return 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,
+    };
+}
 /** Resolve an explicit resume override or newly attached profile like create does. */
 function resolveResumeEffort(ctx, lane, input) {
     if (input.cliEffort === undefined && input.profile === undefined)
@@ -5575,7 +5594,7 @@ async function runMessage(ctx, laneId, opts) {
     }
     // Every accepted message moves the compaction reference forward.
     let next = casUpdateLane(hqRoot, laneId, (current) => ({
-        ...current,
+        ...resetKeepAliveProgress(current),
         last_message_at: at,
     }));
     if (projectId !== lane.project_id || storyId !== lane.story_id) {
@@ -5913,6 +5932,9 @@ async function runResume(ctx, laneId, opts) {
     const resumeProfile = opts.worker !== undefined
         ? resolveResumeProfile(ctx, lane, opts.worker)
         : undefined;
+    const keepAlive = opts.keepAlive === true
+        ? true
+        : resumeProfile?.profile.meta.keep_alive;
     const keepCurrentAccount = opts.account !== undefined && accountRequestKeepsCurrentLane(lane, opts.account);
     if (keepCurrentAccount)
         assertCurrentResumeAccountAvailable(ctx, lane);
@@ -5970,6 +5992,7 @@ async function runResume(ctx, laneId, opts) {
     lane = recordResumeSetup(ctx, lane, {
         ...(move === null && resumeProfile !== undefined ? { profile: resumeProfile } : {}),
         ...(move === null && resumeEffort !== undefined ? { effort: resumeEffort } : {}),
+        ...(keepAlive !== undefined ? { keepAlive } : {}),
         ...(move === null && keepCurrentAccount && opts.model !== undefined ? { cliModel: opts.model } : {}),
         ...(requestedMeshCompany !== undefined
             ? { meshCompany: requestedMeshCompany, threadId: meshThreadId }
@@ -6065,7 +6088,7 @@ async function runResume(ctx, laneId, opts) {
     if (text !== undefined) {
         // An operator text moves the compaction reference forward, as a message does.
         next = casUpdateLane(hqRoot, laneId, (current) => ({
-            ...current,
+            ...resetKeepAliveProgress(current),
             last_message_at: at,
         }));
     }
@@ -6100,6 +6123,9 @@ async function runResume(ctx, laneId, opts) {
             };
         });
     }
+    if (text === undefined && hasKeepAliveProgress(next)) {
+        next = casUpdateLane(hqRoot, laneId, (current) => resetKeepAliveProgress(current));
+    }
     printJson({
         ok: true,
         action: "resume",
@@ -8309,6 +8335,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--effort <level>", "Effort level; claude: low|medium|high|xhigh|max, codex: minimal|low|medium|high|xhigh|max|ultra, grok: low|medium|high|xhigh")
         .option("--senior <ref>", "session:<id> | lane:<id> | user")
         .option("--hire-grant <n>", "Maximum alive direct child lanes assigned to this lane; set by its senior")
+        .option("--keep-alive", "Automatically resume done lead lanes while their story remains open")
         .option("--timeout <secs>", "Deadline in seconds (warns, does not kill)")
         .option("--priority <n>", "Queue priority; higher runs first", "1")
         .option("--outpost <id>", "Run on this Outpost instead of the local host")
@@ -8546,6 +8573,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--model <id>", "Model for the moved lane (with --account only)")
         .option("--effort <level>", "Reasoning effort for the resumed provider turn")
         .option("--worker <profile>", "Attach a personal worker profile for the resumed turn")
+        .option("--keep-alive", "Automatically resume done lead lanes while their story remains open")
         .option("--mesh-company <slug>", "Attach Work Mesh attribution after verifying company membership")
         .option("--no-compact", "Skip the resume-time compaction check for this resume")
         .action(wrap(async (laneId, opts) => {

package/dist/lib/lanes/admission.js

@@ -137,6 +137,12 @@ export function hasActivePendingResume(lane, nowMs) {
         return false;
     if (lane.state === "queued" && pending.trigger === "answered_questions")
         return false;
+    if (lane.state === "queued" &&
+        lane.keep_alive === true &&
+        pending.trigger === "resume" &&
+        pending.resumed_from === "done" &&
+        lane.keep_alive_last_resume_at === pending.at)
+        return false;
     const reservedAt = Date.parse(pending.at);
     const ageMs = nowMs - reservedAt;
     return Number.isFinite(reservedAt) && ageMs >= 0 && ageMs < ADMISSION_RESERVATION_GRACE_MS;

package/dist/lib/lanes/hire-grants.d.ts

@@ -1,4 +1,5 @@
 import { type LaneRecord } from "./types.js";
+import { LanesError } from "./errors.js";
 export declare const LANE_HIRE_GRANTS_FLAG = "lanes.hire-grants";
 export type LaneHireGrantRow = Pick<LaneRecord, "lane_id" | "state" | "senior" | "hire_grant">;
 export declare function aliveDirectChildren<T extends LaneHireGrantRow>(lanes: readonly T[], parentLaneId: string): T[];
@@ -9,6 +10,9 @@ export interface HireGrantAdmissionSnapshot {
     parentGrant: number;
     availableChildGrant: number;
 }
+/** Shared refusal logic for resuming a terminal lane under an active senior. */
+export declare function terminalChildResumeHireGrantError(current: LaneRecord, snapshot: HireGrantAdmissionSnapshot): LanesError | null;
+export declare function hireGrantCapacityError(parent: LaneRecord, children: readonly LaneRecord[]): LanesError;
 /** Keep the occupancy snapshot and the resulting lane write in one parent-lock scope. */
 export declare function withHireGrantAdmission<T>(hqRoot: string, parentLaneId: string, fn: (snapshot: HireGrantAdmissionSnapshot) => T): T;
 export interface HireGrantBackfillRow {

package/dist/lib/lanes/hire-grants.js

@@ -10,6 +10,68 @@ export function aliveDirectChildren(lanes, parentLaneId) {
 export function assignedChildHireGrants(children, exceptLaneId) {
     return children.reduce((sum, child) => child.lane_id === exceptLaneId ? sum : sum + (child.hire_grant ?? 0), 0);
 }
+/** Shared refusal logic for resuming a terminal lane under an active senior. */
+export function terminalChildResumeHireGrantError(current, snapshot) {
+    if (!isTerminalLaneState(current.state))
+        return null;
+    const { parent, children, parentGrant, availableChildGrant } = snapshot;
+    if (isTerminalLaneState(parent.state)) {
+        return new LanesError("hire_grant_senior_inactive", `Senior lane ${parent.lane_id} is ${parent.state} and cannot resume child lanes`, { senior_lane_id: parent.lane_id, state: parent.state });
+    }
+    if (children.length >= parentGrant)
+        return hireGrantCapacityError(parent, children);
+    const requestedGrant = current.hire_grant ?? 0;
+    if (requestedGrant > availableChildGrant) {
+        return new LanesError("hire_grant_carve_exceeded", `Senior lane ${parent.lane_id} has ${availableChildGrant} unassigned hire grant remaining, but terminal child ${current.lane_id} needs ${requestedGrant} to resume. Ask its senior for more: write an ask envelope with the desired total grant and why; the senior runs hq lanes grant ${parent.lane_id} --hire <n>.`, {
+            senior_lane_id: parent.lane_id,
+            parent_grant: parentGrant,
+            alive_children: children.map((child) => child.lane_id),
+            assigned_child_grants: assignedChildHireGrants(children),
+            requested_hire_grant: requestedGrant,
+            available_hire_grant: availableChildGrant,
+            ask_guidance: {
+                envelope: "decision=ask; include the desired total grant and the reason",
+                senior_command: `hq lanes grant ${parent.lane_id} --hire <n>`,
+            },
+        });
+    }
+    return null;
+}
+export function hireGrantCapacityError(parent, children) {
+    const grant = parent.hire_grant ?? 0;
+    const grantor = (parent.senior.kind === "lane" || parent.senior.kind === "session") &&
+        parent.senior.id
+        ? { kind: parent.senior.kind, id: parent.senior.id }
+        : null;
+    const grantorReason = grantor
+        ? undefined
+        : parent.senior.kind === "user"
+            ? "senior_is_user"
+            : "parent_senior_missing_id";
+    const capacity = children.length === grant
+        ? `is at its hire grant (${children.length} of ${grant} alive children)`
+        : `has exhausted its hire grant (${children.length} alive children; grant ${grant})`;
+    const grantCommand = `hq lanes grant ${parent.lane_id} --hire <n>`;
+    const authorityGuidance = grantor
+        ? `Its senior ${grantor.kind} ${grantor.id} can raise it with: ${grantCommand}`
+        : parent.senior.kind === "user"
+            ? `Its senior is the user and can raise it with: ${grantCommand}`
+            : `No senior is recorded, so an operator must resolve ownership before running: ${grantCommand}`;
+    const message = `Lane ${parent.lane_id} ${capacity}. ${authorityGuidance}`;
+    return new LanesError("hire_grant_exhausted", message, {
+        senior_lane_id: parent.lane_id,
+        parent_grant: grant,
+        alive_children: children.map((child) => child.lane_id),
+        alive_child_count: children.length,
+        grantor,
+        ...(grantorReason ? { grantor_reason: grantorReason } : {}),
+        message,
+        ask_guidance: {
+            envelope: "decision=ask; include the desired total grant and the reason",
+            senior_command: grantCommand,
+        },
+    });
+}
 /** Keep the occupancy snapshot and the resulting lane write in one parent-lock scope. */
 export function withHireGrantAdmission(hqRoot, parentLaneId, fn) {
     return withLaneHireLocks(hqRoot, [parentLaneId], () => {

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

@@ -3,7 +3,7 @@
  */
 export { AccountResolutionError, LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesConfigError, LanesError, WorkerResolutionError, isLaneVersionConflict, isLanesError, } from "./errors.js";
 export { MAX_LANE_DEPTH } from "./constants.js";
-export { assignedChildHireGrants, aliveDirectChildren, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, withHireGrantAdmission } from "./hire-grants.js";
+export { assignedChildHireGrants, aliveDirectChildren, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./hire-grants.js";
 export type { HireGrantBackfillRow } from "./hire-grants.js";
 export { compareLaneQueueOrder, hasActiveAdmissionReservation, hasActivePendingResume, hasEarlierEligibleQueuedLane, laneOccupiesRunningSlot, laneAdmissionCapReason, laneRunsOnHost, withAllLaneAdmissionLocks, withLaneAdmissionLock, } from "./admission.js";
 export type { AdmissionCapReason, AdmissionHost } from "./admission.js";

package/dist/lib/lanes/index.js

@@ -3,7 +3,7 @@
  */
 export { AccountResolutionError, LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesConfigError, LanesError, WorkerResolutionError, isLaneVersionConflict, isLanesError, } from "./errors.js";
 export { MAX_LANE_DEPTH } from "./constants.js";
-export { assignedChildHireGrants, aliveDirectChildren, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, withHireGrantAdmission } from "./hire-grants.js";
+export { assignedChildHireGrants, aliveDirectChildren, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./hire-grants.js";
 export { compareLaneQueueOrder, hasActiveAdmissionReservation, hasActivePendingResume, hasEarlierEligibleQueuedLane, laneOccupiesRunningSlot, laneAdmissionCapReason, laneRunsOnHost, withAllLaneAdmissionLocks, withLaneAdmissionLock, } from "./admission.js";
 export { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } from "./host-capacity.js";
 export { CONFIG_SCHEMA_VERSION, ENVELOPE_DECISIONS, ENVELOPE_SCHEMA_VERSION, HISTORY_CAP, HOST_KINDS, LANE_PROVIDERS, LANE_SCHEMA_VERSION, LANE_STORY_STATUSES, LANE_STATES, LIVENESS_STATES, QUESTION_BODY_STORES, QUESTION_SCHEMA_VERSION, QUESTION_STATUSES, QUEUED_REASONS, RAISED_VIA, ROUTING_REASONS, SENIOR_KINDS, STORY_STATUSES, TERMINAL_LANE_STATES, isEnvelopeDecision, isHostKind, isLaneProvider, isLaneState, isLivenessState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseLaneEnvelope, parseLaneProvider, parseLaneState, parseLivenessState, parseMajorSchema, parseQuestionStatus, parseSeniorKind, } from "./types.js";

package/dist/lib/lanes/keep-alive.d.ts

@@ -0,0 +1,8 @@
+export declare const LEAD_LANE_KEEP_ALIVE_FLAG = "lanes.lead-keep-alive";
+export declare const LEAD_LANE_KEEP_ALIVE_DEFAULT_ENABLED = false;
+export declare const LEAD_LANE_KEEP_ALIVE_MAX_RESUMES = 24;
+export declare const LEAD_LANE_KEEP_ALIVE_BASE_BACKOFF_MS: number;
+export declare const LEAD_LANE_KEEP_ALIVE_MAX_BACKOFF_MS: number;
+export declare const LEAD_LANE_KEEP_ALIVE_RESUME_TEXT = "Automatic keep-alive resume: your last turn ended with decision done and story_complete false. Continue the open work from where you stopped. End with done only when story_complete is true; if you are waiting, use hq lanes ask or stay in the loop.";
+export declare function leadLaneKeepAliveBackoffMs(attempt: number): number;
+//# sourceMappingURL=keep-alive.d.ts.map

package/dist/lib/lanes/keep-alive.js

@@ -0,0 +1,14 @@
+export const LEAD_LANE_KEEP_ALIVE_FLAG = "lanes.lead-keep-alive";
+export const LEAD_LANE_KEEP_ALIVE_DEFAULT_ENABLED = false;
+export const LEAD_LANE_KEEP_ALIVE_MAX_RESUMES = 24;
+export const LEAD_LANE_KEEP_ALIVE_BASE_BACKOFF_MS = 5 * 60 * 1000;
+export const LEAD_LANE_KEEP_ALIVE_MAX_BACKOFF_MS = 60 * 60 * 1000;
+export const LEAD_LANE_KEEP_ALIVE_RESUME_TEXT = "Automatic keep-alive resume: your last turn ended with decision done and story_complete false. Continue the open work from where you stopped. End with done only when story_complete is true; if you are waiting, use hq lanes ask or stay in the loop.";
+export function leadLaneKeepAliveBackoffMs(attempt) {
+    if (!Number.isSafeInteger(attempt) || attempt < 1) {
+        throw new RangeError("keep-alive attempt must be a positive safe integer");
+    }
+    const exponential = LEAD_LANE_KEEP_ALIVE_BASE_BACKOFF_MS * 2 ** (attempt - 1);
+    return Math.min(exponential, LEAD_LANE_KEEP_ALIVE_MAX_BACKOFF_MS);
+}
+//# sourceMappingURL=keep-alive.js.map

package/dist/lib/lanes/outpost-dispatch.d.ts

@@ -37,6 +37,7 @@ export interface OutpostLaneCommand {
     model?: string;
     effort?: string;
     worker?: string;
+    keepAlive?: boolean;
     hire?: string;
     grantContext?: string;
     compact?: boolean;

package/dist/lib/lanes/outpost-dispatch.js

@@ -154,6 +154,8 @@ export function buildOutpostLaneCommand(input) {
         if (value !== undefined)
             args.push(flag, value);
     }
+    if (input.action === "resume" && input.keepAlive === true)
+        args.push("--keep-alive");
     if (input.compact === false)
         args.push("--no-compact");
     return withRemoteHqDir(joinCommandParts(args));

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

@@ -17,6 +17,7 @@ export interface WorkerProfileMeta {
     max_concurrent?: number;
     source?: string;
     accounts?: string[];
+    keep_alive?: boolean;
 }
 export interface WorkerProfile {
     id: string;

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

@@ -14,18 +14,22 @@ 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. */
@@ -792,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 {
@@ -1322,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" &&

package/dist/lib/lanes/store.js

@@ -402,6 +402,31 @@ export function parseLaneRecord(raw, filePath) {
             value: raw.hire_grant,
         });
     }
+    if (raw.keep_alive !== undefined && typeof raw.keep_alive !== "boolean") {
+        throw new LaneSchemaError("keep_alive must be a boolean", {
+            path: filePath,
+            field: "keep_alive",
+            value: raw.keep_alive,
+        });
+    }
+    if (raw.keep_alive_resume_count !== undefined &&
+        (typeof raw.keep_alive_resume_count !== "number" ||
+            !Number.isSafeInteger(raw.keep_alive_resume_count) ||
+            raw.keep_alive_resume_count < 0 || raw.keep_alive_resume_count > 24)) {
+        throw new LaneSchemaError("keep_alive_resume_count must be an integer from 0 through 24", {
+            path: filePath,
+            field: "keep_alive_resume_count",
+            value: raw.keep_alive_resume_count,
+        });
+    }
+    for (const field of [
+        "keep_alive_last_resume_at",
+        "keep_alive_next_eligible_at",
+        "keep_alive_exhausted_at",
+    ]) {
+        if (raw[field] !== undefined)
+            requireTimestamp(raw[field], field, filePath);
+    }
     requireString(raw.project_id, "project_id");
     if (typeof raw.story_id !== "string" ||
         (raw.story_id.trim() === "" && raw.no_story_reason === undefined)) {

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

@@ -354,6 +354,16 @@ export interface LaneRecord {
     worker_pack?: string;
     /** Personal worker profile id applied to every spawn. */
     worker_profile?: string;
+    /** Whether this lead lane should resume completed turns while its story is open. */
+    keep_alive?: boolean;
+    /** Consecutive automatic keep-alive resumes since the last human reset. */
+    keep_alive_resume_count?: number;
+    /** Time the most recent automatic keep-alive resume was queued. */
+    keep_alive_last_resume_at?: string;
+    /** Earliest time the next consecutive automatic resume may be queued. */
+    keep_alive_next_eligible_at?: string;
+    /** Time the automatic resume cap was reached for this run of the story. */
+    keep_alive_exhausted_at?: string;
     /** Maximum number of direct child lanes this lane may keep alive; old records default to 0. */
     hire_grant?: number;
     /** Content hash of the profile last applied to this lane. */

package/dist/lib/lanes/types.js

@@ -224,6 +224,7 @@ export const LANE_FIELD_WRITERS = {
     pickup_validation_pending: ["creator", "command", "spawn", "reconcile"],
     pickup_validation_pending_since: ["creator", "command", "spawn", "reconcile"],
     priority: ["command"], worker: ["creator", "command"], worker_path: ["creator", "command"], worker_pack: ["creator", "command"], worker_profile: ["creator", "command"], worker_profile_hash: ["creator", "command", "spawn"], worker_profile_ignored: ["creator", "command", "spawn"], worker_policy_delivery: ["command", "spawn"],
+    keep_alive: ["creator", "command"], keep_alive_resume_count: ["command", "reconcile"], keep_alive_last_resume_at: ["command", "reconcile"], keep_alive_next_eligible_at: ["command", "reconcile"], keep_alive_exhausted_at: ["command", "reconcile"],
     provider: ["creator"], account: ["creator", "spawn", "command", "watcher", "reconcile"], account_selection: ["creator", "command"], admission_accounts: ["creator", "command"], account_history: ["command", "spawn", "watcher", "reconcile"], pending_resume: ["command", "spawn", "watcher", "reconcile"], placement_default: ["creator"], host: ["creator", "command"], origin_host: ["creator"], origin_host_source: ["creator"],
     version: ["creator"], created_at: ["creator"], updated_at: ["creator"], attribution_history: ["command"],
     last_envelope: ["watcher", "reconcile"], model: ["creator", "spawn", "command"], model_source: ["creator", "spawn", "command"], effort: ["creator", "spawn", "command"], effort_source: ["creator", "spawn", "command"], fast_mode: ["spawn"],

package/package.json

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