@indigoai-us/hq-cli 5.341.5 → 5.342.1

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [5.342.1] — 2026-10-04
+- `hq lanes` now continues envelope numbering beyond 999 and records unexpected reconcile admission failures as a distinct queued reason with error details.
+- Reconcile skips configured Codex homes absent on the current host and reports a note; other filesystem errors remain visible as store errors. `--dry-run` no longer compresses rollouts or advances the retention schedule.
+
+## [5.342.0] — 2026-10-04
+
+- Keep `hq integrations call` alive through slow provider calls with bounded async-job polling, safe idempotent retry guidance on timeout, and validation of terminal responses.
+
+- Let `hq sync now` skip unchanged server-owned cloud placeholders while keeping their warnings visible, so the sync can complete.
+
 ## [5.341.5] — 2026-10-04
 - Reconcile can close an eligible done-story worker with a legacy missing `interrupted_at` when a matching watcher classification proves the interruption age.
 - `hq doctor --verbose` now shows passing checks, including hqd runtime health details.

package/dist/commands/cloud.js

@@ -1751,6 +1751,7 @@ async function runNowSingle(hqRoot, company, personal, message, onConflict, mode
             hqRoot,
             progressRecorder: trackingProgressRecorder(planLimitTracker, pushProgressCompany),
             skipUnchanged: true,
+            serverOwnedPathPolicy: "skip",
             propagateDeletes: true,
             propagateDeletePolicy: resolveDeletePolicy(),
             ...(onConflict ? { onConflict } : {}),

package/dist/commands/integrations-core.d.ts

@@ -248,7 +248,7 @@ export declare function resolveConnection(token: string, companyUid: string, app
 }, recoveryOpts?: {
     allowSingleRevoked?: boolean;
 }): Promise<AdminConnection>;
-export declare function callGateway(token: string, params: Record<string, unknown>): Promise<GatewayMessage>;
+export declare function callGateway(token: string, params: Record<string, unknown>, idempotencyKey?: string): Promise<GatewayMessage>;
 /**
  * Gateway results arrive MCP-style: `{ content: [{ type: "text", text }] }`
  * where `text` is the provider's JSON. Unwrap to the inner payload; fall back

package/dist/commands/integrations-core.js

@@ -18,6 +18,8 @@ import { redactSensitiveUrls, redactUrlsInText } from "../utils/redact-url.js";
 import { connectionHealthNotice } from "../lib/integrations/health.js";
 import { bareProvider } from "../lib/integrations/provider-slug.js";
 export { bareProvider } from "../lib/integrations/provider-slug.js";
+const ASYNC_GATEWAY_POLL_INTERVAL_MS = 1_000;
+const ASYNC_GATEWAY_DEADLINE_MS = 4 * 60_000 + 30_000;
 export class IntegrationsCliError extends Error {
     /**
      * True when the error is the caller's request/state/permission (a client 4xx
@@ -397,7 +399,8 @@ export async function resolveConnection(token, companyUid, app, opts, recoveryOp
     }
     return selectConnection(connections, opts);
 }
-export async function callGateway(token, params) {
+export async function callGateway(token, params, idempotencyKey) {
+    const deadline = Date.now() + ASYNC_GATEWAY_DEADLINE_MS;
     const res = await vaultApiFetch({
         token,
         path: "/v1/integrations/mcp",
@@ -410,7 +413,23 @@ export async function callGateway(token, params) {
         },
     });
     const message = (await res.json().catch(() => null));
-    if (!res.ok || !message) {
+    let terminalMessage = message;
+    if (res.status === 202) {
+        const accepted = message;
+        const jobId = accepted && typeof accepted.jobId === "string" ? accepted.jobId : "";
+        if (accepted?.status !== "pending" || !/^imj_[A-Za-z0-9_-]+$/.test(jobId)) {
+            throw new IntegrationsCliError(`Integration gateway returned an invalid async job response (job id: ${jobId || "missing"}).`, { expected: false, status: 202 });
+        }
+        const companyUid = typeof params.companyUid === "string" ? params.companyUid : "";
+        if (!companyUid) {
+            throw new IntegrationsCliError(`Cannot poll integration job ${jobId}: the company id is missing.`, { expected: true });
+        }
+        if (!idempotencyKey) {
+            throw new IntegrationsCliError(`Integration gateway accepted async job ${jobId} without an idempotency key.`, { expected: false, status: 202 });
+        }
+        terminalMessage = await pollAsyncGatewayJob(token, companyUid, jobId, idempotencyKey, deadline);
+    }
+    if (res.status !== 202 && (!res.ok || !terminalMessage)) {
         raiseIfUnauthorized(res);
         raiseIfUpstreamUnavailable(res);
         // Carry the HTTP status so a reportable transport failure (e.g. a 501 that
@@ -420,7 +439,7 @@ export async function callGateway(token, params) {
         // `status`. This does not change the `expected` decision above.
         throw new IntegrationsCliError(`Integration gateway request failed (HTTP ${res.status}).`, { expected: isClientError(res.status), status: res.status });
     }
-    if (message.error) {
+    if (terminalMessage?.error) {
         // The gateway's error text is minted UPSTREAM (hq-pro, the integration
         // factory, and beyond it the third-party provider), so it is untrusted:
         // scrub credentials and bound the length here, at the throw site, because
@@ -429,16 +448,87 @@ export async function callGateway(token, params) {
         // The chain is idempotent, so the unexpected path scrubbing again is a
         // no-op. This preserves PR #298's user-visible diagnostic; it only makes
         // it safe on the newly-expected path.
-        throw new IntegrationsCliError(redactErrorText(message.error.message ?? "") ||
+        throw new IntegrationsCliError(redactErrorText(terminalMessage.error.message ?? "") ||
             "Integration gateway returned an error.", {
-            expected: isExpectedGatewayError(message.error.code),
+            expected: isExpectedGatewayError(terminalMessage.error.code),
             // Carry the protocol code to the capture site as a bounded grouping
             // discriminator (HQ-CLI collision, Sentry 7642756130). This does not
             // alter the `expected` decision above; it only labels the error.
-            ...(message.error.code !== undefined ? { rpcCode: message.error.code } : {}),
+            ...(terminalMessage.error.code !== undefined ? { rpcCode: terminalMessage.error.code } : {}),
         });
     }
-    return message;
+    return terminalMessage;
+}
+async function pollAsyncGatewayJob(token, companyUid, jobId, idempotencyKey, deadline) {
+    const jobPath = `/v1/integrations/mcp/jobs/${encodeURIComponent(jobId)}`;
+    while (Date.now() < deadline) {
+        const requestRemainingMs = deadline - Date.now();
+        if (requestRemainingMs <= 0)
+            break;
+        const controller = new AbortController();
+        const requestTimeout = setTimeout(() => controller.abort(), requestRemainingMs);
+        let res;
+        let poll;
+        try {
+            res = await vaultApiFetch({
+                token,
+                path: jobPath,
+                method: "GET",
+                query: { companyUid },
+                signal: controller.signal,
+            });
+            poll = (await res.json().catch(() => null));
+        }
+        catch (error) {
+            if (!controller.signal.aborted)
+                throw error;
+            break;
+        }
+        finally {
+            clearTimeout(requestTimeout);
+        }
+        if (!res.ok) {
+            raiseIfUnauthorized(res);
+            raiseIfUpstreamUnavailable(res);
+            if (res.status === 404) {
+                throw new IntegrationsCliError(`Integration job ${jobId} was not found or is no longer available.`, { expected: true, status: 404 });
+            }
+            throw new IntegrationsCliError(`Integration job ${jobId} polling failed (HTTP ${res.status}).`, { expected: isClientError(res.status), status: res.status });
+        }
+        if (!poll || typeof poll !== "object") {
+            throw new IntegrationsCliError(`Integration job ${jobId} returned an invalid poll response.`, { expected: true });
+        }
+        if (poll.status === "result" || poll.status === "error") {
+            const response = poll.response;
+            const isPlainObject = response !== null &&
+                typeof response === "object" &&
+                !Array.isArray(response) &&
+                (Object.getPrototypeOf(response) === Object.prototype || Object.getPrototypeOf(response) === null);
+            const responseRecord = isPlainObject ? response : undefined;
+            const hasResult = responseRecord ? Object.hasOwn(responseRecord, "result") : false;
+            const hasError = responseRecord ? Object.hasOwn(responseRecord, "error") : false;
+            const error = responseRecord?.error;
+            const validError = error !== null &&
+                typeof error === "object" &&
+                !Array.isArray(error) &&
+                (Object.getPrototypeOf(error) === Object.prototype || Object.getPrototypeOf(error) === null);
+            const hasJsonRpcOutcome = responseRecord?.jsonrpc === "2.0" &&
+                hasResult !== hasError &&
+                (!hasError || validError);
+            if (!hasJsonRpcOutcome) {
+                throw new IntegrationsCliError(`Integration job ${jobId} returned an invalid JSON-RPC response.`, { expected: false });
+            }
+            return response;
+        }
+        if (poll.status !== "pending") {
+            throw new IntegrationsCliError(`Integration job ${jobId} returned unknown status '${String(poll.status)}'.`, { expected: true });
+        }
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0)
+            break;
+        await new Promise((resolve) => setTimeout(resolve, Math.min(ASYNC_GATEWAY_POLL_INTERVAL_MS, remainingMs)));
+    }
+    throw new IntegrationsCliError(`Timed out waiting for integration job ${jobId}; the server job may still finish. To safely retry, rerun with --idempotency-key ${idempotencyKey}.`, { expected: true });
 }
 /**
  * Gateway results arrive MCP-style: `{ content: [{ type: "text", text }] }`

package/dist/commands/integrations.js

@@ -338,6 +338,7 @@ export function registerIntegrationsCommand(program) {
         const idempotencyKey = opts.idempotencyKey ?? `hq-cli-${randomUUID()}`;
         const message = await callGateway(token, {
             companyUid,
+            acceptAsync: true,
             name: `${prefix}.mcp.tools.call`,
             arguments: {
                 companyUid,
@@ -346,7 +347,7 @@ export function registerIntegrationsCommand(program) {
                 arguments: parsedArgs,
                 idempotencyKey,
             },
-        });
+        }, idempotencyKey);
         const payload = unwrapGatewayResult(message.result);
         const queued = queuedOutcome(payload);
         if (queued) {

package/dist/commands/lanes.js

@@ -5089,8 +5089,12 @@ async function runList(ctx, opts) {
                 ? {
                     state: "remote",
                     remote_state: lane.state,
-                    queued_reason: lane.queued_reason === "low_disk" ? lane.queued_reason : undefined,
-                    queued_details: lane.queued_reason === "low_disk" ? lane.queued_details : undefined,
+                    queued_reason: lane.queued_reason === "low_disk" || lane.queued_reason === "admit_failed"
+                        ? lane.queued_reason
+                        : undefined,
+                    queued_details: lane.queued_reason === "low_disk" || lane.queued_reason === "admit_failed"
+                        ? lane.queued_details
+                        : undefined,
                 }
                 : {}),
             overdue,
@@ -5142,7 +5146,9 @@ function formatLaneListHuman(lanes) {
             : "no story: " + (lane.no_story_reason ?? "reason not recorded");
         const queueLabel = (lane.state === "queued" || lane.remote_state === "queued") && lane.queued_reason === "low_disk"
             ? `  queued: low_disk (HQ ${lane.queued_details?.reason === "low_disk" ? lane.queued_details.hq_free_bytes : "?"} bytes; provider ${lane.queued_details?.reason === "low_disk" ? lane.queued_details.provider_free_bytes : "?"} bytes free)`
-            : "";
+            : (lane.state === "queued" || lane.remote_state === "queued") && lane.queued_reason === "admit_failed"
+                ? `  queued: admit_failed (${lane.queued_details?.reason === "admit_failed" ? `${lane.queued_details.error}: ${lane.queued_details.message}` : "details unavailable"})`
+                : "";
         return lane.lane_id + "  " + lane.state + "  " + lane.provider + "  " + lane.project_id +
             "  " + storyLabel + queueLabel;
     });
@@ -5199,9 +5205,11 @@ async function runStatus(ctx, opts) {
 async function runCapacity(ctx) {
     const hqRoot = ctx.hqRoot();
     const host = laneHostFromCtx(ctx);
+    const admissionHost = reconcileHostFromCtx(ctx);
+    const lanes = loadAllLanes(hqRoot);
     const snapshot = buildHostCapacitySnapshot({
         host,
-        lanes: loadAllLanes(hqRoot),
+        lanes,
         config: loadLanesConfig(hqRoot),
         existsSync: ctx.existsSync,
         probe: ctx.probeProvider,
@@ -5209,7 +5217,16 @@ async function runCapacity(ctx) {
         hostname: ctx.hostname(),
         now: ctx.now(),
     });
-    printJson(snapshot);
+    printJson({
+        ...snapshot,
+        queued_lanes: lanes
+            .filter((lane) => lane.state === "queued" && laneRunsHere(lane, admissionHost))
+            .map((lane) => ({
+            lane_id: lane.lane_id,
+            queued_reason: lane.queued_reason ?? null,
+            ...(lane.queued_details !== undefined ? { queued_details: lane.queued_details } : {}),
+        })),
+    });
 }
 async function runGcRollouts(ctx, opts) {
     const hqRoot = ctx.hqRoot();
@@ -5395,8 +5412,8 @@ async function runShow(ctx, laneId, hasPendingQuestionForLane, resolveLaneTarget
             ...storedLane,
             state: "remote",
             remote_state: storedLane.state,
-            queued_reason: storedLane.queued_reason === "low_disk" ? storedLane.queued_reason : undefined,
-            queued_details: storedLane.queued_reason === "low_disk" ? storedLane.queued_details : undefined,
+            queued_reason: storedLane.queued_reason,
+            queued_details: storedLane.queued_details,
         }
         : storedLane;
     const askDeliveryFailed = readJsonFile(askDeliveryFailedPath(hqRoot, laneId));

package/dist/lib/lanes/envelope-sequence.d.ts

@@ -0,0 +1,3 @@
+/** Numeric ordering for numbered lane envelope filenames, including 1000+. */
+export declare function compareEnvelopeNames(left: string, right: string): number;
+//# sourceMappingURL=envelope-sequence.d.ts.map

package/dist/lib/lanes/envelope-sequence.js

@@ -0,0 +1,13 @@
+/** Numeric ordering for numbered lane envelope filenames, including 1000+. */
+export function compareEnvelopeNames(left, right) {
+    const leftMatch = /^(\d+)\.json$/.exec(left);
+    const rightMatch = /^(\d+)\.json$/.exec(right);
+    if (leftMatch && rightMatch) {
+        const leftNumber = BigInt(leftMatch[1]);
+        const rightNumber = BigInt(rightMatch[1]);
+        if (leftNumber !== rightNumber)
+            return leftNumber < rightNumber ? -1 : 1;
+    }
+    return left.localeCompare(right);
+}
+//# sourceMappingURL=envelope-sequence.js.map

package/dist/lib/lanes/keep-alive-audit.d.ts

@@ -38,6 +38,15 @@ export interface KeepAliveAuditResult {
     errors: KeepAliveAuditError[];
     summary: KeepAliveAuditSummary;
 }
+export interface StopEnvelope {
+    name: string;
+    mtimeMs: number;
+    nextCheckAt?: string;
+}
+export declare function readStopEnvelopes(hqRoot: string, laneId: string): {
+    allMtimes: number[];
+    stops: StopEnvelope[];
+};
 export declare function buildKeepAliveAudit(input: {
     hqRoot: string;
     now: Date;

package/dist/lib/lanes/keep-alive-audit.js

@@ -3,6 +3,7 @@ import * as path from "node:path";
 import { LEAD_LANE_KEEP_ALIVE_BASE_BACKOFF_MS } from "./keep-alive.js";
 import { LanesError } from "./errors.js";
 import { laneRunDir } from "./spawn.js";
+import { compareEnvelopeNames } from "./envelope-sequence.js";
 import { listQuestionIds, readAllLanes, tryReadQuestion } from "./store.js";
 function readDoneClassifications(hqRoot, laneId) {
     const root = fs.realpathSync(hqRoot);
@@ -77,7 +78,7 @@ function withinRoot(root, candidate) {
     const relative = path.relative(root, candidate);
     return relative !== "" && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
 }
-function readStopEnvelopes(hqRoot, laneId) {
+export function readStopEnvelopes(hqRoot, laneId) {
     const root = fs.realpathSync(hqRoot);
     const envelopeDir = path.join(laneRunDir(root, laneId), "envelopes");
     if (!withinRoot(root, envelopeDir)) {
@@ -89,7 +90,7 @@ function readStopEnvelopes(hqRoot, laneId) {
         if (!withinRoot(root, realDir)) {
             throw new LanesError("keep_alive_audit_path_invalid", `Lane envelope directory escapes the HQ root for ${laneId}`, { lane_id: laneId });
         }
-        names = fs.readdirSync(realDir).filter((name) => /^\d+\.json$/.test(name)).sort();
+        names = fs.readdirSync(realDir).filter((name) => /^\d+\.json$/.test(name)).sort(compareEnvelopeNames);
     }
     catch (err) {
         if (err.code === "ENOENT")
@@ -118,11 +119,15 @@ function readStopEnvelopes(hqRoot, laneId) {
         if (raw.decision !== "done" || raw.story_complete !== false)
             continue;
         stops.push({
+            name,
             mtimeMs: stat.mtimeMs,
             ...(typeof raw.next_check_at === "string" ? { nextCheckAt: raw.next_check_at } : {}),
         });
     }
-    return { allMtimes: allMtimes.sort((a, b) => a - b), stops: stops.sort((a, b) => a.mtimeMs - b.mtimeMs) };
+    return {
+        allMtimes: allMtimes.sort((a, b) => a - b),
+        stops: stops.sort((a, b) => a.mtimeMs - b.mtimeMs),
+    };
 }
 function readKeepAliveResumeEvents(hqRoot, laneId) {
     const root = fs.realpathSync(hqRoot);

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

@@ -52,6 +52,7 @@ export interface ReconcileSummary {
     dead_host: ReconcileChange[];
     heartbeats: string[];
     skipped: ReconcileSkip[];
+    notes?: string[];
     keep_alive_blocked: Array<{
         id: string;
         reason: KeepAliveBlockedReason;

package/dist/lib/lanes/reconcile.js

@@ -18,7 +18,7 @@ import { AccountResolutionError, LanesError, isLaneVersionConflict } from "./err
 import { loadWorkerProfile } from "./profile.js";
 import { terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./grants.js";
 import { classifySessionLiveness, defaultLivenessDeps, loadLivenessIndex, readDaemonPresenceConnected, unindexedClaudeSessionLiveness, } from "./liveness.js";
-import { ANSWERED_QUESTIONS_FILE, armLaneWatcher, envelopeRepairMode, isPidRecordAlive, laneRunDir, readPidRecord, readProcStarttime, readSpawnManifest, markSpawnFailure, stopLaneProcesses, spawnEnvelopeRepair, spawnLaneWorker, retryLaneOnAlternateAccount, } from "./spawn.js";
+import { ANSWERED_QUESTIONS_FILE, armLaneWatcher, envelopeRepairMode, isPidRecordAlive, laneRunDir, nextEnvelopePath, readPidRecord, readProcStarttime, readSpawnManifest, markSpawnFailure, stopLaneProcesses, spawnEnvelopeRepair, spawnLaneWorker, retryLaneOnAlternateAccount, } from "./spawn.js";
 import { appendCappedHistory, lanesStoreRoot, parseLaneRecord, parseQuestionRecord, readLane, readQuestion, listQuestionIds, updateLane, updateQuestion, } from "./store.js";
 import { applyThrottleDecision, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, sampleCpuBusyObservation, recordCpuBusyObservation, throttleStatePath, writeThrottleState, } from "./throttle.js";
 import { readLanesRegistryFlag, readLanesRegistryFlagFailOff } from "./registry-flag.js";
@@ -87,6 +87,27 @@ function markDirty(summary, skip) {
     summary.ok = false;
     logSkip(skip);
 }
+function isMissingPathError(error) {
+    const code = error?.code;
+    return code === "ENOENT" || code === "ENOTDIR";
+}
+function recordMissingCodexHomeNote(summary, home) {
+    const note = `Codex rollout retention skipped home absent on this host: ${home}`;
+    summary.notes ??= [];
+    summary.notes.push(note);
+    process.stderr.write(`hq lanes reconcile: note: ${note}\n`);
+}
+function homeIsMissingAfterError(home, error) {
+    if (!isMissingPathError(error))
+        return false;
+    try {
+        fs.statSync(home);
+        return false;
+    }
+    catch (statError) {
+        return isMissingPathError(statError);
+    }
+}
 function terminalizeModelUnsupported(hqRoot, lane, err) {
     if (!(err instanceof LanesError) || err.error !== "model_unsupported")
         return;
@@ -940,14 +961,28 @@ export async function runPassBody(hqRoot, deps) {
                 companyRefs.set(company.uid ?? company.slug, company);
         }
         const readFlag = deps.readRegistryFlag ?? readLanesRegistryFlag;
-        const homes = configuredCodexRolloutHomes(hqRoot, config, deps.host.hostname);
+        const configuredHomes = configuredCodexRolloutHomes(hqRoot, config, deps.host.hostname);
         let retentionEnabled = false;
-        for (const company of homes.length > 0 ? companyRefs.values() : []) {
+        for (const company of configuredHomes.length > 0 ? companyRefs.values() : []) {
             retentionEnabled ||= await readFlag("lanes.codex-rollout-retention", { company });
             if (retentionEnabled)
                 break;
         }
         if (retentionEnabled) {
+            const presentHomes = [];
+            for (const home of configuredHomes) {
+                try {
+                    fs.statSync(home);
+                    presentHomes.push(home);
+                }
+                catch (err) {
+                    if (isMissingPathError(err)) {
+                        recordMissingCodexHomeNote(summary, home);
+                        continue;
+                    }
+                    throw err;
+                }
+            }
             const statePath = path.join(hqRoot, "workspace", "lanes-runs", `.rollout-retention-${deps.host.hostname.replaceAll(/[^a-zA-Z0-9_-]/g, "_")}.json`);
             let lastRunAt;
             try {
@@ -961,20 +996,38 @@ export async function runPassBody(hqRoot, deps) {
                 if (err.code !== "ENOENT")
                     throw err;
             }
-            const lowDisk = homes.some((home) => checkLaneDiskSpace(hqRoot, home, deps.spawnLaneDeps?.statfs, config.low_disk_min_free_bytes).low);
+            let lowDisk = false;
+            const retentionHomes = [];
+            for (const home of presentHomes) {
+                try {
+                    const disk = checkLaneDiskSpace(hqRoot, home, deps.spawnLaneDeps?.statfs, config.low_disk_min_free_bytes);
+                    lowDisk = lowDisk || disk.low;
+                    retentionHomes.push(home);
+                }
+                catch (err) {
+                    if (homeIsMissingAfterError(home, err)) {
+                        recordMissingCodexHomeNote(summary, home);
+                        continue;
+                    }
+                    throw err;
+                }
+            }
             if (lowDisk || lastRunAt === undefined || nowMs - lastRunAt >= 60 * 60 * 1000) {
                 const result = await retainCodexRollouts({
-                    homes,
+                    homes: retentionHomes,
                     lanes,
                     nowMs,
+                    dryRun: deps.dryRun,
                     compressAfterMs: config.codex_rollout_compress_after_hours * 60 * 60 * 1000,
                     deleteAfterMs: config.codex_rollout_delete_after_days * 24 * 60 * 60 * 1000,
                 });
                 summary.rollout_retention = result;
-                fs.mkdirSync(path.dirname(statePath), { recursive: true });
-                const tempPath = `${statePath}.${process.pid}.tmp`;
-                fs.writeFileSync(tempPath, `${JSON.stringify({ last_run_at: nowIso }, null, 2)}\n`, { flag: "wx" });
-                fs.renameSync(tempPath, statePath);
+                if (!deps.dryRun) {
+                    fs.mkdirSync(path.dirname(statePath), { recursive: true });
+                    const tempPath = `${statePath}.${process.pid}.tmp`;
+                    fs.writeFileSync(tempPath, `${JSON.stringify({ last_run_at: nowIso }, null, 2)}\n`, { flag: "wx" });
+                    fs.renameSync(tempPath, statePath);
+                }
             }
         }
     }
@@ -1848,6 +1901,9 @@ async function admitQueued(hqRoot, lanes, summary, deps, now, onlyLaneIds, exclu
         }
         try {
             if (deps.dryRun) {
+                // Spawn reserves an envelope path. Probe it without writing so a dry
+                // run does not promise admission when the run cannot start.
+                nextEnvelopePath(laneRunDir(hqRoot, lane.lane_id));
                 summary.admitted.push({
                     id: lane.lane_id,
                     from: "queued",
@@ -1907,6 +1963,18 @@ async function admitQueued(hqRoot, lanes, summary, deps, now, onlyLaneIds, exclu
                 }
             }
             terminalizeModelUnsupported(hqRoot, lane, err);
+            if (err instanceof LanesError && err.error !== "model_unsupported") {
+                const queueRecorded = deps.dryRun || casLaneIf(hqRoot, lane.lane_id, (current) => current.state === "queued", (current) => ({
+                    ...current,
+                    queued_reason: "admit_failed",
+                    queued_details: { reason: "admit_failed", error: err.error, message: err.message },
+                    admission_reserved_at: undefined,
+                }), false).changed;
+                if (queueRecorded) {
+                    summary.skipped.push({ kind: "lane", id: lane.lane_id, why: `admit_failed:${err.error}` });
+                    continue;
+                }
+            }
             markDirty(summary, {
                 kind: "lane",
                 id: lane.lane_id,

package/dist/lib/lanes/spawn.js

@@ -983,16 +983,21 @@ function proveDetachedViaPs(pid) {
 }
 export function nextEnvelopePath(runDir) {
     const dir = path.join(runDir, "envelopes");
+    let names = new Set();
+    try {
+        names = new Set(fs.readdirSync(dir));
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+    }
     let n = 1;
     while (true) {
         const name = `${String(n).padStart(3, "0")}.json`;
         const filePath = path.join(dir, name);
-        if (!fs.existsSync(filePath))
+        if (!names.has(name))
             return filePath;
         n += 1;
-        if (n > 999) {
-            throw new LanesError("envelope_sequence_exhausted", `No free envelope slot under ${dir}`, { dir });
-        }
     }
 }
 export function envelopeInstruction(envelopePath) {

package/dist/lib/lanes/store.js

@@ -623,6 +623,16 @@ export function parseLaneRecord(raw, filePath) {
             }
             requireTimestamp(detailsRecord.measured_at, "queued_details.measured_at", filePath);
         }
+        else if (detailsRecord.reason === "admit_failed") {
+            if (raw.state !== "queued" || raw.queued_reason !== "admit_failed" ||
+                typeof detailsRecord.error !== "string" || detailsRecord.error.trim() === "" ||
+                typeof detailsRecord.message !== "string" || detailsRecord.message.trim() === "") {
+                throw new LaneSchemaError("queued_details must describe a failed lane admission", {
+                    path: filePath,
+                    field: "queued_details",
+                });
+            }
+        }
         else {
             throw new LaneSchemaError("queued_details must describe a supported queue condition", {
                 path: filePath,

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

@@ -177,7 +177,7 @@ export declare const TERMINAL_LANE_STATES: readonly ["done", "failed", "interrup
 export type TerminalLaneState = (typeof TERMINAL_LANE_STATES)[number];
 export declare const LANE_PROVIDERS: readonly ["claude", "codex", "grok"];
 export type LaneProvider = (typeof LANE_PROVIDERS)[number];
-export declare const QUEUED_REASONS: readonly ["cap", "provider_cap", "account_cap", "profile_cap", "queue_position", "throttle", "provider_binary_missing", "account_retry", "worker_profile_changed", "low_disk"];
+export declare const QUEUED_REASONS: readonly ["cap", "provider_cap", "account_cap", "profile_cap", "queue_position", "throttle", "provider_binary_missing", "account_retry", "worker_profile_changed", "low_disk", "admit_failed"];
 export type QueuedReason = (typeof QUEUED_REASONS)[number];
 export type QueuedDetails = {
     reason: "worker_profile_changed";
@@ -193,6 +193,10 @@ export type QueuedDetails = {
     hq_free_bytes: number;
     provider_free_bytes: number;
     measured_at: string;
+} | {
+    reason: "admit_failed";
+    error: string;
+    message: string;
 };
 export declare function isQueuedReason(value: unknown): value is QueuedReason;
 export declare const HOST_KINDS: readonly ["local", "outpost"];

package/dist/lib/lanes/types.js

@@ -113,6 +113,7 @@ export const QUEUED_REASONS = [
     "account_retry",
     "worker_profile_changed",
     "low_disk",
+    "admit_failed",
 ];
 export function isQueuedReason(value) {
     return typeof value === "string" && QUEUED_REASONS.includes(value);

package/dist/lib/lanes/watcher.js

@@ -34,6 +34,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { LanesError } from "./errors.js";
+import { compareEnvelopeNames } from "./envelope-sequence.js";
 import { questionRecordRefusalCode, raiseEnvelopeQuestions, resolveQuestionCompanyWithFallback, } from "./questions.js";
 import { isTerminalLaneState, ENVELOPE_INVALID_REASON, parseLaneEnvelope, STORY_STATUSES, LANE_PROVIDERS, } from "./types.js";
 import { laneStories, terminalEnvelopeStoryStatus } from "./stories.js";
@@ -619,8 +620,8 @@ export function readLatestEnvelopeFile(hqRoot, laneId, minName) {
         names = fs
             .readdirSync(dir)
             .filter((name) => name.endsWith(".json"))
-            .filter((name) => minName === undefined || name >= minName)
-            .sort();
+            .filter((name) => minName === undefined || compareEnvelopeNames(name, minName) >= 0)
+            .sort(compareEnvelopeNames);
     }
     catch (err) {
         const code = err.code;

package/package.json

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