@indigoai-us/hq-cli 5.292.0 → 5.294.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.d.ts

@@ -7,6 +7,7 @@
  * compare-and-set on `version`. Histories are capped at 50 at the append site.
  */
 import * as fs from "node:fs";
+import { type OutpostIdentity } from "./admission-host.js";
 import { type AttributionHistoryEntry, type LaneRecord, type LaneWriter, type QuestionRecord, type RoutingHistoryEntry, type SeniorHistoryEntry } from "./types.js";
 export declare const LANES_STORE_REL: string;
 export declare const LANE_RECORDS_DIR = "lanes";
@@ -15,6 +16,7 @@ export declare const PENDING_INDEX_DIR: string;
 export interface StoreDeps {
     now: () => Date;
     hostname: () => string;
+    outpostIdentity: () => OutpostIdentity;
     mkdirSync: typeof fs.mkdirSync;
     readFileSync: typeof fs.readFileSync;
     writeFileSync: typeof fs.writeFileSync;

package/dist/lib/lanes/store.js

@@ -14,6 +14,7 @@ import semver from "semver";
 import { CLI_VERSION } from "../../cli-version.js";
 import { generateUlid } from "../mesh/live/ulid.js";
 import { resolveLanesHqRoot } from "./hq-root.js";
+import { readOutpostIdentity } from "./admission-host.js";
 import { LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesError, isLaneVersionConflict, } from "./errors.js";
 import { HISTORY_CAP, HOST_KINDS, LANE_STORY_STATUSES, LANE_SCHEMA_VERSION, QUESTION_SCHEMA_VERSION, SENIOR_KINDS, isHostKind, isLaneProvider, isQueuedReason, isLaneState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseMajorSchema, REQUIRED_LANE_RECORD_FIELDS, LANE_FIELD_WRITERS, LANE_WRITERS, } from "./types.js";
 import { laneStories } from "./stories.js";
@@ -29,6 +30,7 @@ function defaultStoreDeps() {
     return {
         now: () => new Date(),
         hostname: () => os.hostname(),
+        outpostIdentity: () => readOutpostIdentity(),
         mkdirSync: fs.mkdirSync.bind(fs),
         readFileSync: fs.readFileSync.bind(fs),
         writeFileSync: fs.writeFileSync.bind(fs),
@@ -481,6 +483,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 +950,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 +982,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`:
@@ -1218,9 +1240,36 @@ export function readAllLanes(hqRoot, deps = defaultStoreDeps()) {
         ...deps,
         conflictSidecarPathsFor: (recordPath) => sidecarsByRecord.get(path.basename(recordPath)) ?? [],
     };
-    return laneIds
-        .map((laneId) => readLane(hqRoot, laneId, indexedDeps))
-        .sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at) ||
+    const records = [];
+    for (const laneId of laneIds) {
+        try {
+            records.push(readLane(hqRoot, laneId, indexedDeps));
+        }
+        catch (err) {
+            if (!(err instanceof LaneSchemaError))
+                throw err;
+            const filePath = laneRecordPath(hqRoot, laneId);
+            const raw = readJsonFile(filePath, indexedDeps);
+            const host = raw !== null && typeof raw === "object" && !Array.isArray(raw)
+                ? raw.host
+                : undefined;
+            const hostRecord = host !== null && typeof host === "object" && !Array.isArray(host)
+                ? host
+                : undefined;
+            const outpostId = hostRecord?.kind === "outpost" &&
+                typeof hostRecord.id === "string" && hostRecord.id.trim() !== ""
+                ? hostRecord.id
+                : undefined;
+            const identity = indexedDeps.outpostIdentity();
+            const isRemoteMirror = outpostId !== undefined && (identity.kind === "not_outpost" ||
+                (identity.kind === "id" && identity.id !== outpostId));
+            if (!isRemoteMirror)
+                throw err;
+            const field = typeof err.details.field === "string" ? err.details.field : "unknown_field";
+            process.stderr.write(`lanes store: skipping malformed mirrored lane ${laneId} field ${field}: ${err.message}\n`);
+        }
+    }
+    return records.sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at) ||
         a.lane_id.localeCompare(b.lane_id));
 }
 export function tryReadQuestion(hqRoot, questionId, deps = defaultStoreDeps()) {

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/native-fast-route.d.ts

@@ -1,5 +1,7 @@
 /** Default-off flag check for native entrypoint routes. */
 export declare function nativeFastRouteEnabled(argv: readonly string[], env?: NodeJS.ProcessEnv): Promise<boolean>;
 /** Reads a default-off fast-route gate from its local override or fresh snapshot. */
-export declare function fastFlagEnabled(flagKey: string, env?: NodeJS.ProcessEnv): Promise<boolean>;
+export declare function fastFlagEnabled(flagKey: string, env?: NodeJS.ProcessEnv, options?: {
+    numericEnvironmentOverride?: boolean;
+}): Promise<boolean>;
 //# sourceMappingURL=native-fast-route.d.ts.map

package/dist/native-fast-route.js

@@ -8,8 +8,8 @@ export async function nativeFastRouteEnabled(argv, env = process.env) {
     return fastFlagEnabled(parsed.entry.flagKey, env);
 }
 /** Reads a default-off fast-route gate from its local override or fresh snapshot. */
-export async function fastFlagEnabled(flagKey, env = process.env) {
-    const override = nativeRouteOverride(flagKey, env);
+export async function fastFlagEnabled(flagKey, env = process.env, options = {}) {
+    const override = nativeRouteOverride(flagKey, env, options.numericEnvironmentOverride !== false);
     if (override !== null)
         return override;
     try {
@@ -29,15 +29,17 @@ export async function fastFlagEnabled(flagKey, env = process.env) {
     }
 }
 /** The route's documented CLI override also accepts the conventional 1/0. */
-function nativeRouteOverride(flagKey, env) {
+function nativeRouteOverride(flagKey, env, numericEnvironmentOverride) {
     const override = readLocalOverride(flagKey, env);
     if (override !== null)
         return override;
-    const raw = env[localOverrideEnvVar(flagKey)];
-    if (raw === "1")
-        return true;
-    if (raw === "0")
-        return false;
+    if (numericEnvironmentOverride) {
+        const raw = env[localOverrideEnvVar(flagKey)];
+        if (raw === "1")
+            return true;
+        if (raw === "0")
+            return false;
+    }
     return null;
 }
 //# sourceMappingURL=native-fast-route.js.map

package/dist/utils/contribution-table.d.ts

@@ -99,5 +99,5 @@ export declare const CONTRIBUTION_KEYS: ContributionKey[];
  */
 export declare function payloadFor(key: ContributionKey, item: string): string;
 /** Keys whose contributions are wired by a host symlink (skip `merge` rows). */
-export declare const SYMLINK_KEYS: ("workers" | "mcp" | "commands" | "hooks" | "skills" | "policies" | "knowledge" | "scripts")[];
+export declare const SYMLINK_KEYS: ("workers" | "mcp" | "commands" | "skills" | "knowledge" | "hooks" | "policies" | "scripts")[];
 //# sourceMappingURL=contribution-table.d.ts.map

package/dist/utils/fast-stream-errors.d.ts

@@ -0,0 +1,12 @@
+type ErrorEventStream = {
+    on: (event: "error", listener: (err: unknown) => void) => unknown;
+};
+export type FastStreamErrorDependencies = {
+    stdout: ErrorEventStream;
+    stderr: ErrorEventStream;
+    exit: (code: number) => void;
+};
+/** Match the full CLI's clean handling when a pipe consumer closes early. */
+export declare function installFastPathStreamErrorHandlers(deps?: FastStreamErrorDependencies): void;
+export {};
+//# sourceMappingURL=fast-stream-errors.d.ts.map

package/dist/utils/fast-stream-errors.js

@@ -0,0 +1,18 @@
+import { isEpipe } from "./epipe.js";
+/** Match the full CLI's clean handling when a pipe consumer closes early. */
+export function installFastPathStreamErrorHandlers(deps = {
+    stdout: process.stdout,
+    stderr: process.stderr,
+    exit: (code) => process.exit(code),
+}) {
+    const handle = (err) => {
+        if (isEpipe(err)) {
+            deps.exit(0);
+            return;
+        }
+        throw err;
+    };
+    deps.stdout.on("error", handle);
+    deps.stderr.on("error", handle);
+}
+//# sourceMappingURL=fast-stream-errors.js.map

package/dist/utils/scaffold-fast-import-guard.d.ts

@@ -1,3 +1,3 @@
-export declare function forbiddenFastPathModules(loadedModules: readonly string[], distDirectory: string): string[];
-export declare function assertFastPathStaysCommandGraphFree(loadedModules: readonly string[], distDirectory: string): void;
+export declare function forbiddenFastPathModules(loadedModules: readonly string[], distDirectory: string, allowedCommandModules?: readonly string[]): string[];
+export declare function assertFastPathStaysCommandGraphFree(loadedModules: readonly string[], distDirectory: string, allowedCommandModules?: readonly string[]): void;
 //# sourceMappingURL=scaffold-fast-import-guard.d.ts.map

package/dist/utils/scaffold-fast-import-guard.js

@@ -1,11 +1,12 @@
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-export function forbiddenFastPathModules(loadedModules, distDirectory) {
+export function forbiddenFastPathModules(loadedModules, distDirectory, allowedCommandModules = []) {
     const dist = path.resolve(distDirectory);
     const main = path.join(dist, "main.js");
     const commands = `${path.join(dist, "commands")}${path.sep}`;
     const flagRegistry = path.join(dist, "lib", "flag-registry.js");
     const coreCommand = path.join(dist, "commands", "core.js");
+    const allowedCommands = new Set(allowedCommandModules.map((module) => path.resolve(module)));
     return [...new Set(loadedModules.map((loaded) => {
             if (loaded.startsWith("file:")) {
                 try {
@@ -22,10 +23,12 @@ export function forbiddenFastPathModules(loadedModules, distDirectory) {
         path.resolve(loaded) === flagRegistry ||
         path.resolve(loaded) === coreCommand ||
         path.resolve(loaded).includes(`${path.sep}node_modules${path.sep}@sentry${path.sep}node${path.sep}`))
+        .filter((loaded) => !allowedCommands.has(path.resolve(loaded)) ||
+        path.resolve(loaded) === main || path.resolve(loaded) === coreCommand)
         .sort();
 }
-export function assertFastPathStaysCommandGraphFree(loadedModules, distDirectory) {
-    const forbidden = forbiddenFastPathModules(loadedModules, distDirectory);
+export function assertFastPathStaysCommandGraphFree(loadedModules, distDirectory, allowedCommandModules = []) {
+    const forbidden = forbiddenFastPathModules(loadedModules, distDirectory, allowedCommandModules);
     if (forbidden.length > 0) {
         throw new Error(`fast core loaded forbidden command modules:\n${forbidden.join("\n")}`);
     }

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