@indigoai-us/hq-cli 5.294.0 → 5.295.0

package/dist/lib/lanes/spawn.js

@@ -354,12 +354,13 @@ function archivedResumeMessageText(hqRoot, laneId, messageId) {
 }
 function pendingResumeForRetry(hqRoot, lane, sessionId, at) {
     const last = lane.last_resume;
+    const keepAlive = last?.keep_alive === true ? { keep_alive: true } : {};
     if (last === undefined || last.session_id !== sessionId) {
-        return { session_id: sessionId, trigger: "resume", resumed_from: "interrupted", at };
+        return { session_id: sessionId, trigger: "resume", resumed_from: "interrupted", at, ...keepAlive };
     }
     const compact = last.compact === undefined ? {} : { compact: last.compact };
     if (last.trigger === "answered_questions") {
-        return { session_id: sessionId, trigger: "answered_questions", at, ...compact };
+        return { session_id: sessionId, trigger: "answered_questions", at, ...compact, ...keepAlive };
     }
     if (last.trigger === "message") {
         if (last.message_id === undefined) {
@@ -376,6 +377,7 @@ function pendingResumeForRetry(hqRoot, lane, sessionId, at) {
             message_id: last.message_id,
             at,
             ...compact,
+            ...keepAlive,
         };
     }
     return {
@@ -386,6 +388,7 @@ function pendingResumeForRetry(hqRoot, lane, sessionId, at) {
         ...(last.message_id !== undefined ? { message_id: last.message_id } : {}),
         at,
         ...compact,
+        ...keepAlive,
     };
 }
 /** Change account only after a provider/runtime account failure, then re-admit. */
@@ -1112,6 +1115,8 @@ export function envelopeRepairPrompt(input) {
             `Missing expected envelope file: ${input.envelopePath}`,
             "The previous envelope is stale and must not be reused or copied into this run's result.",
             "Printing an envelope in the conversation or writing it to last-message.txt is not enough; write the JSON object directly to the expected file.",
+            "If the task is unfinished, write decision: done, story_complete: false, and set story_status and story_complete_reason to describe the work that remains. The repair turn itself is never a reason for blocked.",
+            "This repair turn only writes the missing envelope; do not resume the task.",
             "Schema:",
             JSON.stringify(LANE_ENVELOPE_JSON_SCHEMA, null, 2),
             `Write the corrected JSON object to ${input.envelopePath}, overwriting it. ` +
@@ -2000,9 +2005,16 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     // Claim running before spawning. Two callers that both observe queued must
     // not both start processes; the CAS loser returns without spawn.
     const nowIso = (deps.now ?? (() => new Date()))().toISOString();
-    const statusGateHeartbeat = deps.managerStatusGateEnabled === true
-        ? managerStatusGateHeartbeat(hqRoot, existing, laneTurnId, nowIso)
-        : undefined;
+    let statusGateHeartbeat;
+    try {
+        statusGateHeartbeat = managerStatusGateHeartbeat(hqRoot, existing, laneTurnId, nowIso);
+    }
+    catch (err) {
+        const code = err instanceof LanesError ? err.error : "manager_status_gate_unavailable";
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`hq lanes: manager status gate disabled for ${lane.lane_id}: ${code}: ${message}\n`);
+        statusGateHeartbeat = undefined;
+    }
     let claimed = false;
     const claimedRecord = retryUpdateLane(hqRoot, lane.lane_id, "spawn", (current) => {
         claimed = false;
@@ -2102,6 +2114,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
                 at: nowIso,
                 account: resolved.id,
                 trigger: pendingResume.trigger,
+                ...(pendingResume.keep_alive === true ? { keep_alive: true } : {}),
                 ...(pendingResume.message_id !== undefined ? { message_id: pendingResume.message_id } : {}),
                 ...(pendingResume.monitor_event === true ? { monitor_event: true } : {}),
                 ...(pendingResume.resumed_from !== undefined ? { resumed_from: pendingResume.resumed_from } : {}),

package/dist/lib/lanes/store.js

@@ -751,6 +751,28 @@ export function parseLaneRecord(raw, filePath) {
             path: filePath,
         });
     }
+    if (raw.keep_alive_history !== undefined) {
+        if (!Array.isArray(raw.keep_alive_history) || raw.keep_alive_history.length > HISTORY_CAP) {
+            throw new LaneSchemaError(`keep_alive_history must be an array capped at ${HISTORY_CAP} entries`, {
+                path: filePath,
+                field: "keep_alive_history",
+            });
+        }
+        for (const [index, value] of raw.keep_alive_history.entries()) {
+            const field = `keep_alive_history[${index}]`;
+            if (!isPlainObject(value) ||
+                Object.keys(value).some((key) => !["at", "resumed_from", "account"].includes(key)) ||
+                (value.resumed_from !== "done" && value.resumed_from !== "interrupted" && value.resumed_from !== "blocked") ||
+                (value.account !== null && typeof value.account !== "string")) {
+                throw new LaneSchemaError(`${field} must be a keep-alive resume history entry`, {
+                    path: filePath,
+                    field,
+                    value,
+                });
+            }
+            requireTimestamp(value.at, `${field}.at`, filePath);
+        }
+    }
     if (raw.stop_history !== undefined) {
         if (!Array.isArray(raw.stop_history)) {
             throw new LaneSchemaError("stop_history must be an array when present", {

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

@@ -407,6 +407,11 @@ export interface KeepAliveBlockedHistoryEntry {
     resume_skipped_reason?: "open_question" | "blocked_grace";
     resume_queued?: boolean;
 }
+export interface KeepAliveResumeHistoryEntry {
+    at: string;
+    resumed_from: "done" | "interrupted" | "blocked";
+    account: string | null;
+}
 export interface KrFreshnessHistoryEntry {
     event: "kr_stalled";
     turn_id: string;
@@ -418,7 +423,13 @@ export interface KrFreshnessHistoryEntry {
     resume_queued?: boolean;
     resume_skipped_reason?: "open_question" | "blocked" | "miss_limit" | "no_provider_session";
 }
-export type LaneGateHistoryEntry = ManagerStatusGateHistoryEntry | BlockerFreshnessHistoryEntry | KrFreshnessHistoryEntry | KeepAliveBlockedHistoryEntry;
+export interface EnvelopeRepairContinueHistoryEntry {
+    event: "envelope_repair_continued";
+    at: string;
+    envelope_ref: string;
+    session_id: string;
+}
+export type LaneGateHistoryEntry = ManagerStatusGateHistoryEntry | BlockerFreshnessHistoryEntry | KrFreshnessHistoryEntry | EnvelopeRepairContinueHistoryEntry | KeepAliveBlockedHistoryEntry;
 export interface LaneStory {
     project_id: string;
     story_id: string;
@@ -491,6 +502,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;
+    /** Bounded audit trail of automatic keep-alive resumes; human resets never clear it. */
+    keep_alive_history?: KeepAliveResumeHistoryEntry[];
     /** 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. */
@@ -700,6 +713,8 @@ export interface PendingResume {
     /** Fresh answered-question launches need no previous session id. */
     session_id?: string;
     trigger: "answered_questions" | "message" | "resume";
+    /** True when this queued resume was initiated automatically by keep-alive. */
+    keep_alive?: true;
     resumed_from?: "interrupted" | "done" | "blocked" | "failed";
     from_failed?: true;
     /** Senior that authorized a failed-lane resume, rechecked at the claim CAS. */
@@ -727,6 +742,8 @@ export interface LaneResumeRecord {
     /** Account the resumed run was bound to. */
     account?: string;
     trigger: "answered_questions" | "message" | "resume";
+    /** True when this was an automatic keep-alive resume. */
+    keep_alive?: true;
     message_id?: string;
     monitor_event?: true;
     /**

package/dist/lib/lanes/types.js

@@ -225,7 +225,7 @@ export const LANE_FIELD_WRITERS = {
     pickup_validation_pending: ["creator", "command", "spawn", "reconcile"],
     pickup_validation_pending_since: ["creator", "command", "spawn", "reconcile"],
     priority: ["command"], worker: ["creator", "command"], worker_path: ["creator", "command"], worker_pack: ["creator", "command"], worker_profile: ["creator", "command"], worker_profile_hash: ["creator", "command", "spawn"], 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_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"],
+    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_history: ["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"],

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

@@ -41,6 +41,7 @@ import { type EnvelopeRepairSpawnInput, type SpawnLaneDeps } from "./spawn.js";
 /** Spec §5.7: no signal for 20 minutes while the process is still alive. */
 export declare const SILENCE_MS: number;
 export declare const WATCHER_POLL_MS = 5000;
+export declare const ENVELOPE_REPAIR_CONTINUE_TEXT = "continue the task; the previous turn ended without an envelope.";
 /** Synced last_host_report_at cadence. Reconcile dead-host TTL is 20 minutes. */
 export declare const WATCHER_HEARTBEAT_MS: number;
 /**
@@ -49,7 +50,7 @@ export declare const WATCHER_HEARTBEAT_MS: number;
  * once the file would exceed this, the oldest complete lines are dropped.
  */
 export declare const WATCHER_OUT_MAX_BYTES: number;
-export declare const WATCHER_DECISION_EVENTS: readonly ["liveness_transition", "silence_deadline", "envelope_observed", "envelope_invalid", "envelope_repair", "classification", "terminal_write", "message_recovery", "message_recovery_failed", "message_undeliverable", "mesh_event", "mesh_event_failed"];
+export declare const WATCHER_DECISION_EVENTS: readonly ["liveness_transition", "silence_deadline", "envelope_observed", "envelope_invalid", "envelope_repair", "envelope_repair_continue", "classification", "terminal_write", "message_recovery", "message_recovery_failed", "message_undeliverable", "mesh_event", "mesh_event_failed"];
 /** Terminal reason when the envelope failed to parse after the repair turn (spec §4). */
 export { ENVELOPE_INVALID_REASON };
 export type WatcherDecisionEvent = (typeof WATCHER_DECISION_EVENTS)[number];
@@ -232,11 +233,11 @@ export interface WatcherLoopDeps {
     /** Deliver a lane-senior escalation through the normal lane-message router. */
     deliverLaneSeniorMessage?: (seniorLaneId: string, text: string) => Promise<void>;
     /** Test seam; production reads the company-scoped hq-flags row. */
-    readManagerStatusGateFlag?: typeof readLanesRegistryFlag;
-    /** Test seam; production reads the company-scoped hq-flags row. */
     readBlockerFreshnessFlag?: typeof readLanesRegistryFlag;
     /** Test seam; production reads the company-scoped hq-flags row. */
     readKrFreshnessFlag?: typeof readLanesRegistryFlag;
+    /** Test seam; production reads the company-scoped hq-flags row. */
+    readEnvelopeRepairContinueFlag?: typeof readLanesRegistryFlag;
 }
 /**
  * Wrap one mesh call. A failed emit is logged as `mesh_event_failed` with

package/dist/lib/lanes/watcher.js

@@ -37,7 +37,7 @@ import { LanesError } from "./errors.js";
 import { questionRecordRefusalCode, raiseEnvelopeQuestions, resolveQuestionCompanyWithFallback, } from "./questions.js";
 import { isTerminalLaneState, ENVELOPE_INVALID_REASON, parseLaneEnvelope, STORY_STATUSES, LANE_PROVIDERS, } from "./types.js";
 import { laneStories, storyStatusForEnvelope } from "./stories.js";
-import { appendCappedHistory, readLane, retryUpdateLane, withLaneHireLocks } from "./store.js";
+import { appendCappedHistory, listQuestionIds, readLane, readQuestion, retryUpdateLane, withLaneHireLocks } from "./store.js";
 import { enforceRegistryApprovalGate } from "./approval-gate.js";
 import { readWorkerRunResult } from "./delivery.js";
 import { applyDefaultQuotaHold, quotaSignalFromFields, readQuotaSignal, recordAccountQuota, } from "./quota.js";
@@ -51,13 +51,15 @@ import { readLanesRegistryFlag } from "./registry-flag.js";
 import { laneCompanyUidSource, resolveLaneCompany } from "./lane-company.js";
 import { blockerFreshnessFingerprint, resolveBlockerFreshnessForLane, } from "./blocker-freshness.js";
 import { krFreshnessFingerprint, resolveKrFreshnessForLane, } from "./kr-freshness.js";
-import { MANAGER_STATUS_GATE_FLAG, managerStatusWasWritten, readStatusSnapshot, resolveManagerStatusTarget, managerStatusGateEnabledForLane, } from "./manager-status-gate.js";
+import { managerStatusWasWritten, readStatusSnapshot, resolveManagerStatusTarget, } from "./manager-status-gate.js";
 import { queueLaneTerminalResume, queueManagerStatusGateResume } from "./keep-alive.js";
+import { LANE_ENVELOPE_REPAIR_CONTINUE_FLAG } from "./flag-keys.js";
 import { monitorSessionDir } from "../monitor.js";
 import { laneRunDir, missingPidProbe, probePidRecord, readPidRecord, readProcStarttime, readSpawnManifest, envelopeRepairMode, spawnEnvelopeRepair, writePidRecord, retryLaneOnAlternateAccount, } from "./spawn.js";
 /** Spec §5.7: no signal for 20 minutes while the process is still alive. */
 export const SILENCE_MS = 20 * 60 * 1000;
 export const WATCHER_POLL_MS = 5_000;
+export const ENVELOPE_REPAIR_CONTINUE_TEXT = "continue the task; the previous turn ended without an envelope.";
 /** Synced last_host_report_at cadence. Reconcile dead-host TTL is 20 minutes. */
 export const WATCHER_HEARTBEAT_MS = 60 * 1000;
 /**
@@ -72,6 +74,7 @@ export const WATCHER_DECISION_EVENTS = [
     "envelope_observed",
     "envelope_invalid",
     "envelope_repair",
+    "envelope_repair_continue",
     "classification",
     "terminal_write",
     "message_recovery",
@@ -659,26 +662,9 @@ export function missingExpectedEnvelopeFile(hqRoot, laneId, envelopePath) {
     };
 }
 async function settleManagerStatusGate(hqRoot, lane, manifestTurnId, at, deps, logDecision) {
-    const readFlag = deps.readManagerStatusGateFlag ?? readLanesRegistryFlag;
-    let enabled = false;
-    try {
-        const resolution = resolveLaneCompany(hqRoot, lane);
-        const company = resolution.company ?? undefined;
-        enabled = await readFlag(MANAGER_STATUS_GATE_FLAG, {
-            company,
-            ...(company ? {
-                companyUidSource: laneCompanyUidSource(resolution.source),
-            } : {}),
-        });
-    }
-    catch (err) {
-        process.stderr.write(`hq lanes watcher: manager status gate flag read failed for ${lane.lane_id}: ${err instanceof Error ? err.message : String(err)}\n`);
-        logDecision({ event: "status_gate_flag_failed", at, error: err instanceof Error ? err.name : "UnknownError" });
-    }
-    if (!enabled)
-        return lane;
     let target;
     try {
+        resolveLaneCompany(hqRoot, lane);
         target = resolveManagerStatusTarget(hqRoot, lane);
     }
     catch (err) {
@@ -725,8 +711,8 @@ async function settleManagerStatusGate(hqRoot, lane, manifestTurnId, at, deps, l
             turn_id: gate.turn_id,
             path: gate.status_path,
             consecutive_misses: updated.status_gate?.consecutive_misses ?? 0,
-            resume_queued: miss.resume_queued === true,
-            resume_skipped_reason: miss.resume_skipped_reason,
+            resume_queued: "resume_queued" in miss && miss.resume_queued === true,
+            resume_skipped_reason: "resume_skipped_reason" in miss ? miss.resume_skipped_reason : undefined,
             state: updated.state,
         });
     }
@@ -1058,6 +1044,92 @@ function claimWatcherLoop(hqRoot, laneId, deps) {
         });
     };
 }
+async function maybeContinueAfterMissingEnvelopeRepair(hqRoot, lane, envelope, envelopeRef, at, deps, logDecision) {
+    const repair = lane.envelope_repair;
+    const missingRepair = repair?.attempted === true &&
+        repair.succeeded === true &&
+        repair.envelope_ref === envelopeRef &&
+        repair.first_error.startsWith("Missing expected envelope file:");
+    if (!missingRepair || envelope === null || envelopeRef === undefined) {
+        if (envelope?.decision === "blocked")
+            logDecision({ event: "envelope_repair_continue", at, outcome: "skipped", reason: "not_a_successful_missing_repair", missing_repair: missingRepair, envelope_ref: envelopeRef, repair_ref: repair?.envelope_ref, first_error: repair?.first_error, succeeded: repair?.succeeded });
+        return lane;
+    }
+    const incompleteDone = envelope.decision === "done" && envelope.story_complete === false;
+    const repairInstructionBlock = envelope.decision === "blocked" &&
+        (envelope.questions?.length ?? 0) === 0 &&
+        /(?:not to resume|do not resume|don't resume)(?: the)? task/i.test(envelope.blocked_reason ?? "");
+    if (!incompleteDone && !repairInstructionBlock) {
+        if (envelope.decision === "blocked")
+            logDecision({ event: "envelope_repair_continue", at, outcome: "skipped", reason: "blocked_reason_not_repair_instruction", blocked_reason: envelope.blocked_reason });
+        return lane;
+    }
+    if (lane.last_resume?.text === ENVELOPE_REPAIR_CONTINUE_TEXT) {
+        logDecision({ event: "envelope_repair_continue", at, outcome: "skipped", reason: "continue_already_used" });
+        return lane;
+    }
+    let pendingQuestion = false;
+    try {
+        for (const id of listQuestionIds(hqRoot)) {
+            const question = readQuestion(hqRoot, id);
+            if (question.lane_id === lane.lane_id && question.status === "pending") {
+                pendingQuestion = true;
+                break;
+            }
+        }
+    }
+    catch (error) {
+        logDecision({ event: "envelope_repair_continue", at, outcome: "skipped", reason: "question_check_failed", error: error instanceof Error ? error.message : String(error) });
+        return lane;
+    }
+    if (pendingQuestion) {
+        logDecision({ event: "envelope_repair_continue", at, outcome: "skipped", reason: "pending_question" });
+        return lane;
+    }
+    const readFlag = deps.readEnvelopeRepairContinueFlag ?? readLanesRegistryFlag;
+    let enabled = false;
+    try {
+        const resolution = resolveLaneCompany(hqRoot, lane);
+        const company = resolution.company ?? undefined;
+        enabled = await readFlag(LANE_ENVELOPE_REPAIR_CONTINUE_FLAG, {
+            company,
+            ...(company ? { companyUidSource: laneCompanyUidSource(resolution.source) } : {}),
+        });
+    }
+    catch (error) {
+        logDecision({ event: "envelope_repair_continue", at, outcome: "skipped", reason: "flag_read_failed", error: error instanceof Error ? error.message : String(error) });
+        return lane;
+    }
+    if (!enabled)
+        return lane;
+    const queued = retryUpdateLane(hqRoot, lane.lane_id, "watcher", (current) => {
+        if (current.version !== lane.version ||
+            (current.state !== "done" && current.state !== "blocked") ||
+            current.last_envelope?.ref !== envelopeRef ||
+            current.envelope_repair?.attempted !== true ||
+            current.envelope_repair.succeeded !== true ||
+            current.envelope_repair.envelope_ref !== envelopeRef ||
+            current.envelope_repair.first_error !== repair.first_error ||
+            current.last_resume?.text === ENVELOPE_REPAIR_CONTINUE_TEXT)
+            return current;
+        const result = queueLaneTerminalResume(current, at, ENVELOPE_REPAIR_CONTINUE_TEXT, { allowBlockedResume: true });
+        if (!result.resumeQueued || result.lane.pending_resume?.session_id === undefined)
+            return current;
+        return {
+            ...result.lane,
+            status_gate_history: appendCappedHistory(current.status_gate_history ?? [], {
+                event: "envelope_repair_continued",
+                at,
+                envelope_ref: envelopeRef,
+                session_id: result.lane.pending_resume.session_id,
+            }),
+        };
+    });
+    if (queued.state === "queued" && queued.pending_resume?.text === ENVELOPE_REPAIR_CONTINUE_TEXT) {
+        logDecision({ event: "envelope_repair_continue", at, outcome: "queued", envelope_ref: envelopeRef, session_id: queued.pending_resume.session_id });
+    }
+    return queued;
+}
 /** Detached and synchronous classifiers share one process-identity claim. */
 export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
     const release = claimWatcherLoop(hqRoot, laneId, deps);
@@ -1144,17 +1216,10 @@ async function runWatcherLoopOwned(hqRoot, laneId, deps) {
     }
     const progressIntervalMs = deps.progressEventMinIntervalMs ?? readProgressIntervalMs(hqRoot, readLaneSoft(hqRoot, laneId));
     const spawnRepair = deps.spawnRepair ?? spawnEnvelopeRepair;
-    const retryAccount = deps.retryAccount ?? (async (root, lane, reason) => {
-        const managerStatusGateEnabled = await managerStatusGateEnabledForLane(root, lane, {
-            env: deps.retrySpawnDeps?.env,
-            readFlag: deps.readManagerStatusGateFlag,
-        });
-        return retryLaneOnAlternateAccount(root, lane, reason, "watcher", {
-            ...deps.retrySpawnDeps,
-            managerStatusGateEnabled,
-            admissionHost: (deps.resolveAdmissionHost ?? resolveProcessAdmissionHost)(),
-        });
-    });
+    const retryAccount = deps.retryAccount ?? ((root, lane, reason) => retryLaneOnAlternateAccount(root, lane, reason, "watcher", {
+        ...deps.retrySpawnDeps,
+        admissionHost: (deps.resolveAdmissionHost ?? resolveProcessAdmissionHost)(),
+    }));
     let lastSignalMs = now();
     let lastSeenMtime = 0;
     let lastAlive = null;
@@ -1542,7 +1607,10 @@ async function runWatcherLoopOwned(hqRoot, laneId, deps) {
                         ((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;
-                if (terminalWrite.changed && deps.recoverQueuedMessages && !managerStatusFollowupQueued) {
+                if (terminalWrite.changed && !managerStatusFollowupQueued) {
+                    updated = await maybeContinueAfterMissingEnvelopeRepair(hqRoot, updated, effectiveEnvelope ?? null, latest?.ref, tick.emit.at, deps, logDecision);
+                }
+                if (terminalWrite.changed && deps.recoverQueuedMessages && !managerStatusFollowupQueued && updated.state !== "queued") {
                     try {
                         if (dropboxInboxHasMessages(hqRoot, laneId)) {
                             await deps.recoverQueuedMessages(updated);

package/dist/lib/mesh/live/daemon/run.js

@@ -701,13 +701,30 @@ export async function runMeshDaemon(deps = {}) {
             if (!fs.existsSync(spoolPath)) {
                 fs.writeFileSync(spoolPath, "", { mode: 0o600 });
             }
-            watcher = fs.watch(path.dirname(spoolPath), { persistent: true }, (_event, filename) => {
+            const spoolWatcher = fs.watch(path.dirname(spoolPath), { persistent: true }, (_event, filename) => {
                 if (stopped)
                     return;
                 if (shouldFlushOnSpoolDirEvent(filename)) {
                     scheduleDebouncedFlush();
                 }
             });
+            watcher = spoolWatcher;
+            spoolWatcher.on("error", (err) => {
+                // fs.watch can fail asynchronously after returning a watcher. Without
+                // an error listener Node treats EMFILE as an uncaught exception; the
+                // periodic flush below already provides a polling fallback.
+                if (watcher === spoolWatcher)
+                    watcher = null;
+                try {
+                    spoolWatcher.close();
+                }
+                catch (closeError) {
+                    const closeMessage = closeError instanceof Error ? closeError.message : String(closeError);
+                    log(dir, `fs.watch close failed after watcher error: ${closeMessage.slice(0, 120)}`);
+                }
+                const msg = err instanceof Error ? err.message : String(err);
+                log(dir, `fs.watch error; continuing interval flush: ${msg.slice(0, 120)}`);
+            });
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);

package/dist/utils/cognito-session.d.ts

@@ -237,6 +237,12 @@ export declare function withMachineTokenStateDir<T>(fn: () => Promise<T>, opts?:
     home?: string;
     env?: NodeJS.ProcessEnv;
 }): Promise<T>;
+/**
+ * Ensure the current machine identity has a valid session and return only the
+ * access/ID token pair needed by supported machine-session handoff scripts.
+ * The machine state directory is isolated from the person's session cache.
+ */
+export declare function ensureMachineSessionTokens(): Promise<Pick<CognitoTokens, "accessToken" | "idToken" | "expiresAt">>;
 /**
  * True when a person-token refresh failed with a definitive Cognito auth
  * rejection (refresh token invalid/revoked). Transient network/5xx/timeouts

package/dist/utils/cognito-session.js

@@ -840,6 +840,15 @@ function withTokenStateDirSection(fn) {
 async function ensureMachineTokens() {
     return withMachineTokenStateDir(() => getValidMachineTokens(DEFAULT_COGNITO));
 }
+/**
+ * Ensure the current machine identity has a valid session and return only the
+ * access/ID token pair needed by supported machine-session handoff scripts.
+ * The machine state directory is isolated from the person's session cache.
+ */
+export async function ensureMachineSessionTokens() {
+    const tokens = await ensureMachineTokensMaybeFallback({ tokenSource: "machine" });
+    return { accessToken: tokens.accessToken, idToken: tokens.idToken, expiresAt: tokens.expiresAt };
+}
 /**
  * Mint machine tokens (daemon state dir cache). Logs once when the fresh-box
  * default-creds fallback is what selected the machine path.

package/dist/utils/self-update.js

@@ -62,6 +62,8 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import semver from "semver";
 import chalk from "chalk";
+import { Sentry } from "../sentry.js";
+import { isCliTelemetryDisabled } from "./cli-telemetry.js";
 import { CLI_NAME, CLI_VERSION } from "../cli-version.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";
@@ -499,6 +501,7 @@ async function updateAndReexec(argv, flavor, known, deps) {
             console.error(chalk.dim(`  Or repair the install: hq rescue`));
         }
         console.error(chalk.dim(`  Continuing the ${flavor.noun} on ${current}.`));
+        await captureSelfUpdateOutcome("update-failed", current, latestValid, install.manager, result.code, env, flavor.noun === "rescue");
         return { action: "update-failed", latest };
     }
     if (installSnapshot)
@@ -521,6 +524,7 @@ async function updateAndReexec(argv, flavor, known, deps) {
     if (converged === false) {
         (deps.markIneffective ?? markLatestIneffective)(latest);
         console.error(chalk.dim(`  Continuing the ${flavor.noun} on ${current}.`));
+        await captureSelfUpdateOutcome("update-ineffective", current, latestValid, install.manager, undefined, env, flavor.noun === "rescue");
         return { action: "update-ineffective", latest };
     }
     // A resident mesh daemon keeps the old JS loaded after a global install.
@@ -550,6 +554,33 @@ async function updateAndReexec(argv, flavor, known, deps) {
     console.error(chalk.dim(`✓ hq-cli updated to ${latest}.`));
     return { action: "reexec", reexecStatus: status, latest };
 }
+const SELF_UPDATE_ERROR_CLASSES = new Set(["MODULE_NOT_FOUND", "EACCES", "EEXIST"]);
+async function captureSelfUpdateOutcome(action, fromVersion, targetVersion, installFlavor, code, env, flushBeforeExit) {
+    if (isCliTelemetryDisabled(env))
+        return;
+    const error = new Error(action === "update-failed" ? "Self-update failed" : "Self-update ineffective");
+    // This event needs no stack: frames would expose the machine's install path.
+    error.stack = undefined;
+    Sentry.captureException(error, {
+        fingerprint: ["self-update", action],
+        tags: {
+            from_version: fromVersion,
+            target_version: targetVersion,
+            install_flavor: installFlavor,
+            error_class: code && SELF_UPDATE_ERROR_CLASSES.has(code) ? code : "other",
+        },
+    });
+    if (flushBeforeExit) {
+        try {
+            if (!(await Sentry.flush(500))) {
+                console.error(chalk.dim("hq: Sentry flush timed out after self-update."));
+            }
+        }
+        catch {
+            console.error(chalk.dim("hq: Sentry flush failed after self-update."));
+        }
+    }
+}
 async function readStagedSelfUpdateFlag(deps, env) {
     try {
         if (deps.stagedSelfUpdate)

package/dist/utils/version-gate.js

@@ -706,13 +706,32 @@ export function detachUpdateSupervisor() {
                 try {
                     rmSync(tempDir, { recursive: true, force: true });
                 }
-                catch {
-                    // Best-effort cleanup of a temp dir.
+                catch (error) {
+                    const failureClass = error &&
+                        typeof error === "object" &&
+                        "code" in error &&
+                        typeof error.code === "string" &&
+                        /^[A-Z0-9_]{1,32}$/.test(error.code)
+                        ? error.code
+                        : error instanceof Error
+                            ? "Error"
+                            : "UnknownError";
+                    console.error(chalk.yellow(`Could not remove update supervisor temp dir (${failureClass}).`));
                 }
             },
         };
     }
-    catch {
+    catch (error) {
+        const failureClass = error &&
+            typeof error === "object" &&
+            "code" in error &&
+            typeof error.code === "string" &&
+            /^[A-Z0-9_]{1,32}$/.test(error.code)
+            ? error.code
+            : error instanceof Error
+                ? "Error"
+                : "UnknownError";
+        console.error(chalk.yellow(`Could not copy update supervisor (${failureClass}).`));
         if (dir)
             rmSync(dir, { recursive: true, force: true });
         return null;

package/package.json

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

package/dist/fast-lanes-list-route.d.ts

@@ -1,8 +0,0 @@
-export interface FastLanesListRouteDeps {
-    flagEnabled: (flagKey: string, env: NodeJS.ProcessEnv) => Promise<boolean>;
-    runFastList: () => Promise<void>;
-    runPlacementList: () => Promise<void>;
-}
-/** Returns false unless this exact list form is safely enabled in the local flag snapshot. */
-export declare function runFastLanesListRequest(argv: readonly string[], env?: NodeJS.ProcessEnv, deps?: FastLanesListRouteDeps): Promise<boolean>;
-//# sourceMappingURL=fast-lanes-list-route.d.ts.map

package/dist/fast-lanes-list-route.js

@@ -1,32 +0,0 @@
-import { isFastCachedLanesListRequest } from "./fast-scaffold.js";
-import { fastFlagEnabled } from "./native-fast-route.js";
-import { registerOutpostLaneSnapshotRefreshChild } from "./lib/lanes/outpost-snapshot-refresh.js";
-import { LANE_OUTPOST_SNAPSHOT_CACHE_FLAG } from "./lib/lanes/outpost-hire-cache.js";
-import { LANE_OUTPOST_LOAD_BALANCING_FLAG } from "./lib/lanes/flag-keys.js";
-/** Returns false unless this exact list form is safely enabled in the local flag snapshot. */
-export async function runFastLanesListRequest(argv, env = process.env, deps = {
-    flagEnabled: fastFlagEnabled,
-    runFastList: async () => {
-        const { runFastCachedLanesList } = await import("./fast-lanes-list.js");
-        await runFastCachedLanesList();
-    },
-    runPlacementList: async () => {
-        const { runFastCachedLanesListFromEntrypoint } = await import("./commands/lanes.js");
-        await runFastCachedLanesListFromEntrypoint();
-    },
-}) {
-    registerOutpostLaneSnapshotRefreshChild(env);
-    if (!isFastCachedLanesListRequest(argv))
-        return false;
-    if (env.HQ_INTERNAL_LANES_REFRESH_REMOTE_SNAPSHOT === "1")
-        return false;
-    if (!await deps.flagEnabled(LANE_OUTPOST_SNAPSHOT_CACHE_FLAG, env))
-        return false;
-    const lanePlacementEnabled = await deps.flagEnabled(LANE_OUTPOST_LOAD_BALANCING_FLAG, env);
-    if (lanePlacementEnabled)
-        await deps.runPlacementList();
-    else
-        await deps.runFastList();
-    return true;
-}
-//# sourceMappingURL=fast-lanes-list-route.js.map

package/dist/fast-lanes-list.d.ts

@@ -1,3 +0,0 @@
-/** Lightweight implementation for the exact cache-first `lanes list --json` entrypoint. */
-export declare function runFastCachedLanesList(): Promise<void>;
-//# sourceMappingURL=fast-lanes-list.d.ts.map