@indigoai-us/hq-cli 5.293.0 → 5.295.0

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/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/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/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.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.293.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