@indigoai-us/hq-cli 5.342.0 → 5.342.1

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## [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.

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.342.0",
+  "version": "5.342.1",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {