@indigoai-us/hq-cli 5.292.0 → 5.293.0

package/dist/lib/lanes/reconcile.js

@@ -19,19 +19,19 @@ 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, spawnEnvelopeRepair, spawnLaneWorker, retryLaneOnAlternateAccount, } from "./spawn.js";
-import { appendCappedHistory, lanesStoreRoot, parseLaneRecord, parseQuestionRecord, readLane, readQuestion, updateLane, updateQuestion, } from "./store.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_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 { LEAD_LANE_KEEP_ALIVE_FLAG, LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG, 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, 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 { laneStories, storyStatusForEnvelope } from "./stories.js";
+import { activeLaneStories, laneStories, storyStatusForEnvelope } from "./stories.js";
 import { resolveManagerStatusGateForLane } from "./manager-status-gate.js";
 import { decideEnvelopeRepair, envelopeQuestionIds, routeProviderFailure } from "./watcher.js";
 import { PROVIDER_REJECTED_REASON, providerRejectionDetails, readProviderRejection, } from "./provider-rejection.js";
@@ -962,8 +962,9 @@ export async function runPassBody(hqRoot, deps) {
     const readRegistryFlag = deps.readRegistryFlag ?? readLanesRegistryFlag;
     const keepAliveFlagCompanies = new Map();
     for (const lane of lanes) {
-        if (!(lane.state === "done" || lane.state === "interrupted" || lane.state === "killed" || lane.state === "cancelled" || lane.state === "failed") ||
+        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" ||
@@ -985,6 +986,7 @@ export async function runPassBody(hqRoot, deps) {
         keepAliveFlagCompanies.set(key, company);
     }
     const keepAliveFlagByCompany = new Map();
+    const blockedResumeFlagByCompany = new Map();
     const supersessionLineageAwareByCompany = new Map();
     const env = deps.env ?? process.env;
     await Promise.all([...keepAliveFlagCompanies.entries()].map(async ([key, company]) => {
@@ -992,11 +994,19 @@ export async function runPassBody(hqRoot, deps) {
             company: company ?? undefined,
             env,
         };
-        const [keepAliveEnabled, lineageAware] = await Promise.all([
+        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] = 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),
         ]);
         keepAliveFlagByCompany.set(key, keepAliveEnabled);
+        blockedResumeFlagByCompany.set(key, blockedResumeEnabled);
         supersessionLineageAwareByCompany.set(key, lineageAware);
     }));
     const admissionThrottleDeps = startDeps.throttleDeps ?? defaultThrottleDeps(startDeps.env ?? process.env);
@@ -1016,7 +1026,7 @@ export async function runPassBody(hqRoot, deps) {
     await withAllLaneAdmissionLocks(hqRoot, async () => {
         const freshLanes = loadLaneRecords(hqRoot, summary);
         const freshQuestions = loadQuestionRecords(hqRoot, summary);
-        await resumeKeepAlive(hqRoot, freshLanes, freshQuestions, summary, admissionDeps, now, keepAliveFlagByCompany, supersessionLineageAwareByCompany);
+        await resumeKeepAlive(hqRoot, freshLanes, freshQuestions, summary, admissionDeps, now, keepAliveFlagByCompany, supersessionLineageAwareByCompany, blockedResumeFlagByCompany);
         const drainLanes = loadLaneRecords(hqRoot, summary);
         await admitQueued(hqRoot, drainLanes, summary, admissionDeps, now);
         await resumeAwaiting(hqRoot, drainLanes, freshQuestions, summary, admissionDeps);
@@ -1666,7 +1676,8 @@ function keepAliveProgressResetByHuman(lane) {
         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_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) &&
@@ -1779,7 +1790,169 @@ function latestEnvelopeMtimeMs(hqRoot, lane, ref) {
         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 resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCompany, supersessionLineageAwareByCompany) {
+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;
+    if (current.provider === "claude" && deps.prepareKeepAliveClaudeResume !== undefined) {
+        try {
+            const prepared = await deps.prepareKeepAliveClaudeResume(current);
+            current = prepared.lane;
+        }
+        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 });
+    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,
+        keep_alive_blocked_resume_streak: priorResumes + 1,
+        keep_alive_resume_count: (current.keep_alive_resume_count ?? 0) + 1,
+        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",
+            });
+        }
+    }
+}
+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) {
     const nowMs = now.getTime();
     const nowIso = now.toISOString();
     const config = loadLanesConfig(hqRoot);
@@ -1792,7 +1965,7 @@ async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, fla
         resolvedCompanyByLaneVersion.set(key, company);
         return company;
     };
-    const keepAliveEnabled = [...flagByCompany.values()].some((enabled) => enabled);
+    const keepAliveEnabled = [...flagByCompany.values()].some((enabled) => enabled) || [...blockedResumeFlagByCompany.values()].some(Boolean);
     let retiredLaneIds = null;
     if (keepAliveEnabled) {
         try {
@@ -1813,6 +1986,10 @@ async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, fla
                 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;

package/dist/lib/lanes/spawn.js

@@ -28,6 +28,7 @@ import { registryWorkerRecord } from "./registry-persona.js";
 import { resolveMachineIdentity, } from "./machine-identity.js";
 import { appendCappedHistory, listLaneIds, readLane, retryUpdateLane } from "./store.js";
 import { managerStatusGateHeartbeat } from "./manager-status-gate.js";
+import { LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT } from "./keep-alive.js";
 import { copySessionFiles, planSessionCopy } from "./move-account.js";
 import { ensureSessionHome } from "./session-relink.js";
 import { MESSAGE_REPLAY_STATE_NAME } from "./message-replay.js";
@@ -2133,6 +2134,9 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
                     : {}),
             };
         }
+        if (resume && pendingResume?.text !== LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT) {
+            next.keep_alive_blocked_resume_streak = 0;
+        }
         return next;
     });
     if (!claimed) {

package/dist/lib/lanes/store.js

@@ -481,6 +481,16 @@ export function parseLaneRecord(raw, filePath) {
             value: raw.keep_alive_resume_count,
         });
     }
+    if (raw.keep_alive_blocked_resume_streak !== undefined &&
+        (typeof raw.keep_alive_blocked_resume_streak !== "number" ||
+            !Number.isSafeInteger(raw.keep_alive_blocked_resume_streak) ||
+            raw.keep_alive_blocked_resume_streak < 0 || raw.keep_alive_blocked_resume_streak > 2)) {
+        throw new LaneSchemaError("keep_alive_blocked_resume_streak must be an integer from 0 through 2", {
+            path: filePath,
+            field: "keep_alive_blocked_resume_streak",
+            value: raw.keep_alive_blocked_resume_streak,
+        });
+    }
     for (const field of [
         "keep_alive_opted_in_at",
         "keep_alive_last_resume_at",
@@ -938,6 +948,12 @@ export function parseQuestionRecord(raw, filePath) {
     }
     requireString(raw.question_id, "question_id");
     requireString(raw.lane_id, "lane_id");
+    if (raw.priority !== undefined && raw.priority !== null && raw.priority !== "P0" && raw.priority !== "P1" && raw.priority !== "P2") {
+        throw new LaneSchemaError("priority must be P0, P1, or P2 when present", {
+            path: filePath,
+            value: raw.priority,
+        });
+    }
     requireInt(raw.version, "version");
     requireInt(raw.hop, "hop");
     parseOptionalCompanyField(raw, filePath);
@@ -964,7 +980,11 @@ export function parseQuestionRecord(raw, filePath) {
             value: delivered_at,
         });
     }
-    return { ...raw, delivered_at };
+    return {
+        ...raw,
+        delivered_at,
+        ...(raw.priority === null ? { priority: undefined } : {}),
+    };
 }
 /**
  * HQ Sync sibling-twin grammar from `@indigoai-us/hq-cloud` `buildConflictPath`:

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

@@ -400,6 +400,13 @@ export interface KrFreshnessState {
     /** Stable fingerprint of the last stalled KPI set, which is resumed once. */
     stalled_fingerprint?: string;
 }
+export interface KeepAliveBlockedHistoryEntry {
+    event: "keep_alive_blocked_grace" | "keep_alive_blocked_resumed" | "keep_alive_blocked_escalated";
+    at: string;
+    terminal_at: string;
+    resume_skipped_reason?: "open_question" | "blocked_grace";
+    resume_queued?: boolean;
+}
 export interface KrFreshnessHistoryEntry {
     event: "kr_stalled";
     turn_id: string;
@@ -411,7 +418,7 @@ export interface KrFreshnessHistoryEntry {
     resume_queued?: boolean;
     resume_skipped_reason?: "open_question" | "blocked" | "miss_limit" | "no_provider_session";
 }
-export type LaneGateHistoryEntry = ManagerStatusGateHistoryEntry | BlockerFreshnessHistoryEntry | KrFreshnessHistoryEntry;
+export type LaneGateHistoryEntry = ManagerStatusGateHistoryEntry | BlockerFreshnessHistoryEntry | KrFreshnessHistoryEntry | KeepAliveBlockedHistoryEntry;
 export interface LaneStory {
     project_id: string;
     story_id: string;
@@ -484,6 +491,8 @@ export interface LaneRecord {
     keep_alive_blocked_reason?: "not_opted_in" | "missing_opt_in_time" | "envelope_before_opt_in" | "interruption_before_opt_in" | "missing_interruption_time" | "retired" | "superseded" | "retired_list_invalid" | "terminal_state";
     /** Consecutive automatic keep-alive resumes since the last human reset. */
     keep_alive_resume_count?: number;
+    /** Blocked keep-alive resumes in the current blocked episode. */
+    keep_alive_blocked_resume_streak?: 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. */
@@ -782,12 +791,15 @@ export interface QuestionAnswer {
  * question is flagged for the operator; nothing answers it automatically.
  */
 export type QuestionKind = "continue";
+export type QuestionPriority = "P0" | "P1" | "P2";
 export interface QuestionRecord {
     schema_version: typeof QUESTION_SCHEMA_VERSION | string;
     question_id: string;
     lane_id: string;
     /** Set by the raiser when the options are only continue/stop. */
     question_kind?: QuestionKind;
+    /** Urgency selected by the lane author; absent on pre-priority records. */
+    priority?: QuestionPriority;
     /** `null` when the originating lane has no company. */
     company: LaneCompanyRef | null;
     project_id: string;

package/dist/lib/lanes/types.js

@@ -225,11 +225,11 @@ 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"], registry_worker: ["creator", "command", "spawn"], registry_worker_approval_history: ["command", "watcher", "reconcile"], worker_profile_repin_history: ["command"], worker_profile_ignored: ["creator", "command", "spawn"], worker_policy_delivery: ["command", "spawn"],
-    keep_alive: ["creator", "command"], keep_alive_standing: ["command"], keep_alive_opted_in_at: ["creator", "command"], keep_alive_blocked_reason: ["command", "reconcile"], 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"],
+    keep_alive: ["creator", "command"], keep_alive_standing: ["command"], keep_alive_opted_in_at: ["creator", "command"], keep_alive_blocked_reason: ["command", "reconcile"], keep_alive_resume_count: ["command", "reconcile"], keep_alive_blocked_resume_streak: ["reconcile", "spawn", "watcher"], 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"], failed_resume_history: ["command"], 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"], ended_at: ["reconcile"], envelope_summary: ["reconcile"], 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"],
-    last_message_at: ["command"], status_gate: ["spawn", "watcher"], status_gate_history: ["watcher"], blocker_freshness_state: ["watcher"], kr_freshness_state: ["watcher"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],
+    last_message_at: ["command"], status_gate: ["spawn", "watcher"], status_gate_history: ["watcher", "reconcile"], blocker_freshness_state: ["watcher"], kr_freshness_state: ["watcher"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],
     overdue: ["reconcile"], overdue_at: ["reconcile"], last_host_report_at: ["watcher", "spawn", "reconcile"], stalled: ["watcher"], stalled_at: ["watcher"], stalled_reason: ["watcher"],
     admitted_reason: ["command", "reconcile"], terminal_reason: ["command", "watcher", "spawn", "reconcile"], stop_history: ["command", "reconcile"], settings_history: ["command"], pending_settings: ["command", "spawn"], interrupted_at: ["command", "watcher", "reconcile"], terminal_details: ["command", "spawn", "watcher", "reconcile"],
     quota_reset_at: ["watcher", "reconcile"], model_quota_marker: ["watcher", "reconcile"], outpost_command_id: ["command"],

package/dist/lib/lanes/watcher.js

@@ -411,6 +411,8 @@ export function applyTerminalToLaneWithResult(hqRoot, laneId, classification, op
             }), current.registry_worker_approval_history ?? []);
         }
         if (envelope) {
+            if (envelope.decision !== "blocked")
+                next.keep_alive_blocked_resume_streak = 0;
             next.last_envelope = {
                 ref: envelopeRef,
                 decision: envelope.decision,
@@ -1536,7 +1538,7 @@ async function runWatcherLoopOwned(hqRoot, laneId, deps) {
                     updated = await settleKrFreshness(hqRoot, updated, manifest.turn_id, tick.emit.at, deps, logDecision);
                 }
                 const managerStatusFollowupQueued = manifest.turn_id !== undefined &&
-                    updated.status_gate_history?.some((entry) => entry.turn_id === manifest.turn_id &&
+                    updated.status_gate_history?.some((entry) => "turn_id" in entry && entry.turn_id === manifest.turn_id &&
                         ((entry.event === "status_missed" && entry.resume_queued === true) ||
                             (entry.event === "blocker_stale" && entry.resume_queued === true) ||
                             (entry.event === "kr_stalled" && entry.resume_queued === true))) === true;

package/dist/utils/self-update.d.ts

@@ -167,6 +167,13 @@ export interface SelfUpdateDeps {
      * aside for the whole install. Read only when an npm global install is due.
      */
     stagedSelfUpdate?: () => Promise<boolean>;
+    /**
+     * Runs installs through a copy of the installer's supervisor outside the
+     * package until disposed. Defaults to {@link detachUpdateSupervisor}.
+     */
+    detachSupervisor?: () => {
+        dispose(): void;
+    } | null;
 }
 /**
  * Startup path: the running CLI is behind npm `latest`, so update in place and

package/dist/utils/self-update.js

@@ -63,7 +63,7 @@ import * as path from "node:path";
 import semver from "semver";
 import chalk from "chalk";
 import { CLI_NAME, CLI_VERSION } from "../cli-version.js";
-import { buildBunInstallArgv, buildPnpmInstallArgv, buildPrefixedInstallArgv, buildSpawnPlan, checkUpdateConvergence, derivePnpmHome, isBunManagedPackageDir, isLocalDependencyInstall, isPnpmManagedPackageDir, isPrefixWritable, nonWritablePrefixNote, openInstallOutput, pnpmUpdateEnv, resolveRunningInstall, runUpdateCommand, runSupervisedUpdateCommand, } from "./version-gate.js";
+import { buildBunInstallArgv, buildPnpmInstallArgv, buildPrefixedInstallArgv, buildSpawnPlan, checkUpdateConvergence, derivePnpmHome, detachUpdateSupervisor, isBunManagedPackageDir, isLocalDependencyInstall, isPnpmManagedPackageDir, isPrefixWritable, nonWritablePrefixNote, openInstallOutput, pnpmUpdateEnv, resolveRunningInstall, runUpdateCommand, runSupervisedUpdateCommand, } from "./version-gate.js";
 import { canStageInstall, stagedNpmInstall } from "./staged-install.js";
 import { acquireUpdateLock as acquireSharedUpdateLock } from "./update-lock.js";
 import { markLatestIneffective } from "./version-check.js";
@@ -420,6 +420,9 @@ async function updateAndReexec(argv, flavor, known, deps) {
     if (!releaseLock)
         return { action: "skipped", latest };
     const renamePath = deps.renamePath ?? fs.renameSync;
+    // The in-place update moves the package aside, and the installer's
+    // supervisor ships inside it, so run the installer through a copy.
+    const supervisor = staged ? null : (deps.detachSupervisor ?? detachUpdateSupervisor)();
     // The staged install keeps the running package in place until the swap and
     // restores it itself, so it takes no snapshot.
     const installSnapshot = staged ? null : snapshotInstall(install, renamePath);
@@ -467,6 +470,7 @@ async function updateAndReexec(argv, flavor, known, deps) {
         throw error;
     }
     finally {
+        supervisor?.dispose();
         releaseLock();
     }
     if (!result.ok) {

package/dist/utils/version-gate.d.ts

@@ -284,6 +284,21 @@ export { buildSpawnPlan, quoteForWindowsShell };
  */
 export declare function inOwnProcessGroup<T extends object>(options: T): T;
 declare function updateTimeoutMs(env?: NodeJS.ProcessEnv): number;
+/** The supervisor script the next install runs under. */
+export declare function updateSupervisorPath(): string;
+export interface DetachedUpdateSupervisor {
+    path: string;
+    dispose(): void;
+}
+/**
+ * Copies the supervisor to a temp dir and runs installs through the copy until
+ * disposed. The in-place self-update moves the whole hq-cli package aside
+ * before it starts the installer, and the supervisor ships inside that package
+ * (5.290.0-5.292.0 failed every npm global self-update with MODULE_NOT_FOUND).
+ * The script needs only Node builtins, so the copy runs on its own. Returns
+ * null when the copy cannot be made; the caller then keeps the bundled path.
+ */
+export declare function detachUpdateSupervisor(): DetachedUpdateSupervisor | null;
 /**
  * Where an install's output goes — the other half of surviving a killed parent.
  *

package/dist/utils/version-gate.js

@@ -30,7 +30,7 @@
 import { spawnSync } from "node:child_process";
 import { installPathCompatibilityEnabled } from "../lib/install-path-compatibility-flag.js";
 import { buildSpawnPlan, quoteForWindowsShell } from "./windows-spawn.js";
-import { accessSync, closeSync, constants as fsConstants, existsSync, mkdtempSync, openSync, readdirSync, realpathSync, readFileSync, rmSync, } from "node:fs";
+import { accessSync, closeSync, constants as fsConstants, copyFileSync, existsSync, mkdtempSync, openSync, readdirSync, realpathSync, readFileSync, rmSync, } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -674,6 +674,50 @@ function updateTimeoutMs(env = process.env) {
  * compiled module for production and is directly runnable from source tests.
  */
 const UPDATE_COMMAND_SUPERVISOR = fileURLToPath(new URL("./update-command-supervisor.cjs", import.meta.url));
+/** Set while a self-update runs the installer through a copy of the supervisor. */
+let detachedSupervisor = null;
+/** The supervisor script the next install runs under. */
+export function updateSupervisorPath() {
+    return detachedSupervisor ?? UPDATE_COMMAND_SUPERVISOR;
+}
+/**
+ * Copies the supervisor to a temp dir and runs installs through the copy until
+ * disposed. The in-place self-update moves the whole hq-cli package aside
+ * before it starts the installer, and the supervisor ships inside that package
+ * (5.290.0-5.292.0 failed every npm global self-update with MODULE_NOT_FOUND).
+ * The script needs only Node builtins, so the copy runs on its own. Returns
+ * null when the copy cannot be made; the caller then keeps the bundled path.
+ */
+export function detachUpdateSupervisor() {
+    if (detachedSupervisor)
+        return null;
+    let dir;
+    try {
+        dir = mkdtempSync(path.join(os.tmpdir(), "hq-cli-update-supervisor-"));
+        const copy = path.join(dir, "update-command-supervisor.cjs");
+        copyFileSync(UPDATE_COMMAND_SUPERVISOR, copy);
+        detachedSupervisor = copy;
+        const tempDir = dir;
+        return {
+            path: copy,
+            dispose: () => {
+                if (detachedSupervisor === copy)
+                    detachedSupervisor = null;
+                try {
+                    rmSync(tempDir, { recursive: true, force: true });
+                }
+                catch {
+                    // Best-effort cleanup of a temp dir.
+                }
+            },
+        };
+    }
+    catch {
+        if (dir)
+            rmSync(dir, { recursive: true, force: true });
+        return null;
+    }
+}
 function readSupervisorSpawnError(errorMarker) {
     try {
         const value = JSON.parse(readFileSync(errorMarker, "utf-8"));
@@ -754,7 +798,7 @@ export function runSupervisedUpdateCommand(cmd, args, output, env) {
         // waits briefly, sends KILL to survivors, and waits for its direct child so
         // the completed result leaves no zombie behind.
         const result = spawnSync(process.execPath, [
-            UPDATE_COMMAND_SUPERVISOR,
+            updateSupervisorPath(),
             JSON.stringify({
                 cmd: plan.cmd,
                 args: plan.args,

package/package.json

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