@indigoai-us/hq-cli 5.294.0 → 5.296.0

package/dist/lib/lanes/watcher.js

@@ -36,8 +36,8 @@ import * as path from "node:path";
 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 { laneStories, terminalEnvelopeStoryStatus } from "./stories.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",
@@ -420,27 +423,25 @@ export function applyTerminalToLaneWithResult(hqRoot, laneId, classification, op
                 artifacts: envelope.artifacts,
                 ...(envelope.blocked_reason !== undefined ? { blocked_reason: envelope.blocked_reason } : {}),
             };
-            next.story_status = envelope.story_status;
-            next.story_complete = envelope.story_complete;
-            next.story_complete_reason = envelope.story_complete_reason;
-            const currentProject = current.project_id;
-            const currentStory = current.story_id;
-            const storyStatus = envelope.decision === "blocked"
-                ? "blocked"
-                : envelope.decision === "done"
-                    ? "review"
-                    : storyStatusForEnvelope(envelope.story_status);
-            const updatedStories = laneStories(current).map((story) => story.project_id === currentProject && story.story_id === currentStory
-                ? {
-                    ...story,
-                    status: storyStatus,
-                    updated_at: at,
-                    ...(envelope.decision === "blocked"
-                        ? { blocked_reason: envelope.blocked_reason ?? "" }
-                        : { blocked_reason: undefined }),
-                }
-                : story);
-            next.stories = updatedStories;
+            const storyStatus = terminalEnvelopeStoryStatus(current, envelope.decision, envelope.story_status);
+            if (storyStatus !== undefined) {
+                next.story_status = envelope.story_status;
+                next.story_complete = envelope.story_complete;
+                next.story_complete_reason = envelope.story_complete_reason;
+                const currentProject = current.project_id;
+                const currentStory = current.story_id;
+                const updatedStories = laneStories(current).map((story) => story.project_id === currentProject && story.story_id === currentStory
+                    ? {
+                        ...story,
+                        status: storyStatus,
+                        updated_at: at,
+                        ...(envelope.decision === "blocked"
+                            ? { blocked_reason: envelope.blocked_reason ?? "" }
+                            : { blocked_reason: undefined }),
+                    }
+                    : story);
+                next.stories = updatedStories;
+            }
         }
         return next;
     });
@@ -659,26 +660,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 +709,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 +1042,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 +1214,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 +1605,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/run/env-graph-guard.d.ts

@@ -1,5 +1,5 @@
 /** The varlock version hq-cli is pinned to (package.json `dependencies`). */
-export declare const VARLOCK_PINNED_VERSION = "1.0.0";
+export declare const VARLOCK_PINNED_VERSION = "1.21.1";
 /** A schema/plugin source varlock could not finish loading. */
 interface GuardDataSource {
     readonly isValid: boolean;
@@ -68,7 +68,7 @@ export declare function assertEnvGraphLoaded(graph: LoadedEnvGraph): void;
  * rejection into a thrown EnvResolutionError instead of hanging on the promise
  * that never settles.
  *
- * varlock@1.0.0's resolveEnvValues dispatches its per-item resolver un-awaited
+ * varlock's resolveEnvValues dispatches its per-item resolver un-awaited
  * and with a dead `_reject`, so a throw inside it becomes a process-level
  * unhandled rejection AND leaves the returned promise permanently pending. We
  * race the resolve against a scoped `unhandledRejection` listener: whichever

package/dist/run/env-graph-guard.js

@@ -34,7 +34,7 @@
 // actionable `hq: …` line WITHOUT a Sentry capture (see isVarlockEnvError).
 import { claimRejection, releaseRejection, } from "../unhandled-rejection-boundary.js";
 /** The varlock version hq-cli is pinned to (package.json `dependencies`). */
-export const VARLOCK_PINNED_VERSION = "1.0.0";
+export const VARLOCK_PINNED_VERSION = "1.21.1";
 /**
  * A schema/entry file could not be loaded, so the env graph never finished
  * processing. Carries an actionable, file-naming message; classified by
@@ -114,7 +114,7 @@ export function assertEnvGraphLoaded(graph) {
  * rejection into a thrown EnvResolutionError instead of hanging on the promise
  * that never settles.
  *
- * varlock@1.0.0's resolveEnvValues dispatches its per-item resolver un-awaited
+ * varlock's resolveEnvValues dispatches its per-item resolver un-awaited
  * and with a dead `_reject`, so a throw inside it becomes a process-level
  * unhandled rejection AND leaves the returned promise permanently pending. We
  * race the resolve against a scoped `unhandledRejection` listener: whichever
@@ -143,6 +143,9 @@ export async function resolveEnvValuesOrThrow(graph) {
     });
     process.prependOnceListener("unhandledRejection", onRejection);
     try {
+        // Preserve current varlock's direct rejection unchanged. The race only
+        // turns a floated rejection (the 1.0.0 behavior) into a typed error rather
+        // than leaving the caller waiting on a promise that never settles.
         await Promise.race([graph.resolveEnvValues(), rejection]);
     }
     finally {

package/dist/run/hq-plugin.js

@@ -23,8 +23,9 @@ export function installHqPlugin(graph /* EnvGraph */, opts) {
         errorsByName: new Map(),
         loadedSecretsByName: new Map(),
     };
-    // varlock@1.0.0's plugin-lib.js omits the Resolver export (d.ts/JS mismatch);
-    // extract it at runtime from any already-registered built-in resolver's prototype.
+    // In varlock@1.21.1, Resolver remains declared in plugin-lib's .d.mts but
+    // is not exported from its runtime module. Derive the runtime base class from
+    // a built-in resolver registered on the graph; the shape test pins this API.
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let RuntimeResolver;
     try {
@@ -39,8 +40,8 @@ export function installHqPlugin(graph /* EnvGraph */, opts) {
         RuntimeResolver = proto;
     }
     catch (e) {
-        throw new Error('varlock Resolver base class extraction failed — the varlock@1.0.0 d.ts/JS mismatch ' +
-            'may have been resolved; switch to `import { Resolver } from "varlock/plugin-lib"`. ' +
+        throw new Error('varlock Resolver base class extraction failed — varlock@1.21.1 still declares ' +
+            'Resolver in plugin-lib types without exporting it at runtime. ' +
             `Underlying: ${e instanceof Error ? e.message : String(e)}`);
     }
     // HqResolver is declared INSIDE installHqPlugin so its static def.resolve
@@ -96,7 +97,7 @@ export function installHqPlugin(graph /* EnvGraph */, opts) {
             }
         }
     }
-    // varlock@1.0.0's env-spec parser rejects dots in decorator names ([a-zA-Z0-9_] only),
+    // Varlock's env-spec parser rejects dots in decorator names ([a-zA-Z0-9_] only),
     // so `@hq.company` is not valid syntax. We register as `@hqCompany` (camelCase) instead.
     // Schema files must use `# @hqCompany("slug")` followed by a blank line so the parser
     // treats it as a file-level root decorator rather than an item decorator for the next var.

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.296.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {
@@ -58,7 +58,7 @@
     "semver": "^7.6.3",
     "simple-git": "^3.27.0",
     "smol-toml": "1.6.1",
-    "varlock": "1.0.0"
+    "varlock": "1.21.1"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",

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