@indigoai-us/hq-cli 5.291.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/scaffold-sibling-references.js

@@ -42,7 +42,7 @@ function shellLocationAliases(contents) {
         const scriptRoot = SCRIPT_ROOT_TOKENS.exec(value);
         if (scriptRoot) {
             const suffix = value.slice(scriptRoot.index + scriptRoot[0].length)
-                .match(/^\/([^"'`\s;|&)]+)/)?.[1] ?? ".";
+                .match(/^\/([^"'`\s;|&)}]+)/)?.[1] ?? ".";
             aliases.set(name, { kind: "asset", baseDirectory: path.posix.normalize(suffix) });
             continue;
         }
@@ -116,15 +116,15 @@ export function scanScaffoldSiblingReferences(scaffoldRoot) {
             (/\b(?:source|exec|bash|sh|node)\b/.test(line) || /^\s*\.\s+/.test(line)));
         for (const line of commandLines) {
             SCRIPT_ROOT_TOKENS.lastIndex = 0;
-            for (const match of line.matchAll(/(?:\$\{SCRIPT_DIR\}|\$SCRIPT_DIR)\/([^"'`\s;|&)]+)/g)) {
+            for (const match of line.matchAll(/(?:\$\{SCRIPT_DIR\}|\$SCRIPT_DIR)\/([^"'`\s;|&)}]+)/g)) {
                 recordRelative(sourceFile, match[1]);
             }
-            const dirnamePath = new RegExp(String.raw `\$\(\s*dirname\s+["']?${BASH_SOURCE_TOKEN}["']?\s*\)(\/[^"'\x60\s;|&)]+)`, "g");
+            const dirnamePath = new RegExp(String.raw `\$\(\s*dirname\s+["']?${BASH_SOURCE_TOKEN}["']?\s*\)(\/[^"'\x60\s;|&)}]+)`, "g");
             for (const match of line.matchAll(dirnamePath))
                 recordRelative(sourceFile, match[1]);
             for (const [alias, location] of aliases) {
                 const escapedAlias = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-                const aliasPath = new RegExp(String.raw `(?:\$\{${escapedAlias}\}|\$${escapedAlias})\/([^"'\x60\s;|&)]+)`, "g");
+                const aliasPath = new RegExp(String.raw `(?:\$\{${escapedAlias}\}|\$${escapedAlias})\/([^"'\x60\s;|&)}]+)`, "g");
                 for (const match of line.matchAll(aliasPath)) {
                     if (location.kind === "hq-root") {
                         const reference = match[0];

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

@@ -161,6 +161,19 @@ export interface SelfUpdateDeps {
     interactive?: boolean;
     /** Best-effort daemon kick after the CLI install converges (tests). */
     restartDaemon?: () => RestartDaemonResult | void;
+    /**
+     * Whether `cli.staged-self-update` is on: build the new version beside the
+     * running package and swap it in, instead of moving the running package
+     * 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,8 @@ 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";
 import { restartDaemonServiceIfInstalled } from "../lib/mesh/live/daemon/install.js";
@@ -414,12 +415,18 @@ async function updateAndReexec(argv, flavor, known, deps) {
         console.error(chalk.dim(`hq-cli ${latest} is available, but this copy is a local dependency (${install.packageRoot}) — update the project that owns it.`));
         return { action: "skipped", latest };
     }
+    const staged = canStageInstall(install) && (await readStagedSelfUpdateFlag(deps, env));
     const releaseLock = flavor.lock ? (deps.acquireLock ?? acquireUpdateLock)() : () => { };
     if (!releaseLock)
         return { action: "skipped", latest };
     const renamePath = deps.renamePath ?? fs.renameSync;
-    const installSnapshot = snapshotInstall(install, renamePath);
-    if (!installSnapshot) {
+    // 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);
+    if (!staged && !installSnapshot) {
         console.error(chalk.dim("  No backup could be made for this hq-cli install; proceeding without rollback protection."));
     }
     let result;
@@ -440,10 +447,15 @@ async function updateAndReexec(argv, flavor, known, deps) {
         // Forward env only when PNPM_HOME had to be injected, so the common path
         // spawns with the inherited environment and keeps the two-argument runner
         // call it has always made.
-        result =
-            updateEnv === undefined
-                ? runner(plan.cmd, plan.args)
-                : runner(plan.cmd, plan.args, updateEnv);
+        if (staged) {
+            result = stagedNpmInstall(install, latestValid, { run: runner, env, rename: renamePath });
+        }
+        else if (updateEnv === undefined) {
+            result = runner(plan.cmd, plan.args);
+        }
+        else {
+            result = runner(plan.cmd, plan.args, updateEnv);
+        }
         if (!result.ok && installSnapshot) {
             restoredAfterFailure = restoreInstall(installSnapshot, renamePath);
             if (restoredAfterFailure)
@@ -458,6 +470,7 @@ async function updateAndReexec(argv, flavor, known, deps) {
         throw error;
     }
     finally {
+        supervisor?.dispose();
         releaseLock();
     }
     if (!result.ok) {
@@ -537,6 +550,19 @@ async function updateAndReexec(argv, flavor, known, deps) {
     console.error(chalk.dim(`✓ hq-cli updated to ${latest}.`));
     return { action: "reexec", reexecStatus: status, latest };
 }
+async function readStagedSelfUpdateFlag(deps, env) {
+    try {
+        if (deps.stagedSelfUpdate)
+            return await deps.stagedSelfUpdate();
+        // Loaded here so the startup path pays for the flag client only when an
+        // update is actually due.
+        const { readDaemonFlag, STAGED_SELF_UPDATE_FLAG } = await import("../lib/daemon/flag.js");
+        return await readDaemonFlag(STAGED_SELF_UPDATE_FLAG, { env });
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Startup path: the running CLI is behind npm `latest`, so update in place and
  * re-run the user's command on the new version. `latest` is normally the cached

package/dist/utils/staged-install.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Staged npm self-update: install the new hq-cli beside the running package,
+ * check that it starts, then swap it in with two renames.
+ *
+ * The in-place update moves the live package aside for the whole
+ * `npm install -g`, so anything that starts `hq` during the install finds no
+ * CLI on disk ("hq: command not found", MODULE_NOT_FOUND; outposts primary and
+ * 2, 5.290.0 -> 5.291.0). Here the live package stays in place until the new
+ * one is complete and has answered `--version`.
+ *
+ * Only a plain npm global layout is staged: `<prefix>/lib/node_modules/<pkg>`
+ * as a real directory, with bin links in `<prefix>/bin`. pnpm, Bun, Windows
+ * and linked checkouts keep the in-place update.
+ */
+import * as fs from "node:fs";
+import { type RunningInstall, type UpdateResult } from "./version-gate.js";
+/** Set for the staging install; hq-cli's own postinstall skips itself on it. */
+export declare const STAGED_INSTALL_ENV = "HQ_STAGED_INSTALL";
+export interface StagedInstallDeps {
+    /** Runs the package manager. Defaults to {@link runUpdateCommand}. */
+    run?: (cmd: string, args: string[], env?: NodeJS.ProcessEnv) => UpdateResult;
+    env?: NodeJS.ProcessEnv;
+    /** The version the staged package's `hq --version` reports, or null. */
+    probeVersion?: (packageRoot: string) => string | null;
+    /** The package's postinstall, run from the live path after the swap. */
+    runPostinstall?: (packageRoot: string) => void;
+    rename?: typeof fs.renameSync;
+    /** Removes the staging and backup directories. */
+    remove?: (target: string) => void;
+    platform?: NodeJS.Platform;
+}
+export declare function canStageInstall(install: RunningInstall, platform?: NodeJS.Platform): boolean;
+export declare function stagedNpmInstall(install: RunningInstall, version: string, deps?: StagedInstallDeps): UpdateResult;
+//# sourceMappingURL=staged-install.d.ts.map