@indigoai-us/hq-cli 5.345.2 → 5.345.4

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## [Unreleased]
 
+## [5.345.4] — 2026-10-05
+- Run a pinned or newer managed hq-cloud sync runner ahead of the staged sync bundle, so daemon sync no longer stays on the hq-cloud version bundled with the CLI after an update or pin (hq-cli#1547).
+- Avoid dispatching the global hook when the working directory is inside an HQ root.
+
+## [5.345.3] — 2026-10-05
+- Retry a blocker freshness lane-inbox fallback after a transient append failure.
+- Scope bundled-script stdin checks to changes in their workflow, build inputs, CLI sources, tests, or shell assets.
+- Always apply the lane low-disk preflight before starting or resuming workers.
+
 ## [5.345.2] — 2026-10-05
 - Build and version-check the hq-cloud sync-runner bundle, then validate and atomically stage it with the daemon child bootstrap before releasing the CLI package-use lease.
 - Defer MCP tool and prompt handler imports until a request needs them so `hq mcp serve` can answer initialize without waiting on the full handler modules.

package/dist/commands/lanes-message.js

@@ -13,7 +13,6 @@ import { artifactIdentityKeys, rollbackStorySwitchAttribution, storySwitchNotice
 import { laneRunDir, probePidRecord, readPidRecord, readProcStarttime, spawnLaneWorker } from "../lib/lanes/spawn.js";
 import { keepAliveExclusion, keepAliveSupersededBy, LANE_RUNNING_SUPERSEDED_MESSAGE_DELIVERY_FLAG, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds } from "../lib/lanes/keep-alive.js";
 import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
-import { lowDiskGuardEnabledForLane } from "../lib/lanes/disk-guard.js";
 import { resolveLaneCompany } from "../lib/lanes/lane-company.js";
 import { accountMoveSummary, accountRequestKeepsCurrentLane, assertCurrentResumeAccountAvailable, callerMatchesSessionSenior, recordedResumeEffort, resetKeepAliveProgress, resolveResumeEffort } from "./lanes-shared.js";
 export function parseMonitorLaneMessagePayload(input) {
@@ -782,7 +781,6 @@ export function createLaneMessageHandlers(deps) {
                             const admission = await assessLaneAdmission(ctx, lane, { queueAt: at });
                             if (admission.action === "refuse" && admission.error)
                                 throw admission.error;
-                            const guardEnabled = admission.action === "queue" ? false : await lowDiskGuardEnabledForLane(hqRoot, lane);
                             return withResumeHireAdmission(ctx, lane, () => {
                                 if (admission.action === "queue") {
                                     const sessionId = lane.provider_session_id;
@@ -826,7 +824,6 @@ export function createLaneMessageHandlers(deps) {
                                     return queued;
                                 }
                                 const started = spawnLaneWorker(hqRoot, lane, {
-                                    lowDiskGuardEnabled: guardEnabled,
                                     env: ctx.env,
                                     modelDeps: {
                                         readFileSync: ctx.readFileSync,

package/dist/commands/lanes-resume.js

@@ -7,7 +7,6 @@ import { assertNoSecretText } from "../lib/lanes/text-scan.js";
 import { laneStories, laneStory, storyWarning } from "../lib/lanes/stories.js";
 import { artifactIdentityKeys, rollbackStorySwitchAttribution, storySwitchNotice } from "../lib/lanes/story-switch.js";
 import { spawnLaneWorker } from "../lib/lanes/spawn.js";
-import { lowDiskGuardEnabledForLane } from "../lib/lanes/disk-guard.js";
 import { accountMoveSummary, accountRequestKeepsCurrentLane, assertCurrentResumeAccountAvailable, hasKeepAliveProgress, recordedResumeEffort, resetKeepAliveProgress, resolveResumeEffort } from "./lanes-shared.js";
 export function createLaneResumeHandlers(deps) {
     const { archiveResumeMessage, assertLaneRunsHereForAdmission, assertLaneRunsHereForOperatorMutation, assessLaneAdmission, automaticBalanceMoveHistoryReason, authorizeFailedResume, authorizeResumeProfileRepin, casUpdateLane, dispatchOutpostLaneCommand, laneIsHostedHere, laneWithRecoveredProviderSession, mintMessageId, persistClaudeAccountSelection, prepareAccountMove, printJson, recordResumeSetup, resolveResumeProfile, selectAutomaticClaudeResumeAccount, validateResumeProfileModel, withResumeHireAdmission } = deps;
@@ -448,7 +447,6 @@ export function createLaneResumeHandlers(deps) {
                     const admission = await assessLaneAdmission(ctx, lane, { queueAt: at });
                     if (admission.action === "refuse" && admission.error)
                         throw admission.error;
-                    const guardEnabled = admission.action === "queue" ? false : await lowDiskGuardEnabledForLane(hqRoot, lane);
                     return withResumeHireAdmission(ctx, lane, () => {
                         if (admission.action === "queue") {
                             const sessionId = lane.provider_session_id;
@@ -492,7 +490,6 @@ export function createLaneResumeHandlers(deps) {
                             });
                         }
                         const started = spawnLaneWorker(hqRoot, lane, {
-                            lowDiskGuardEnabled: guardEnabled,
                             env: ctx.env,
                             modelDeps: {
                                 readFileSync: ctx.readFileSync,

package/dist/commands/lanes.js

@@ -37,7 +37,7 @@ import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
 import { runResidentCommandWithPackageLease } from "../utils/resident-package-preload.js";
 import { readLanesFlagLocalOverride, readLanesRegistryFlag, readLanesRegistryFlagFailOff } from "../lib/lanes/registry-flag.js";
 import { LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_LIST_SKIP_REMOTE_REFRESH_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG, LANE_REUSE_REFRESHES_PROFILE_FLAG, } from "../lib/lanes/flag-keys.js";
-import { configuredCodexRolloutHomes, lowDiskGuardEnabledForLane, retainCodexRollouts } from "../lib/lanes/disk-guard.js";
+import { configuredCodexRolloutHomes, retainCodexRollouts } from "../lib/lanes/disk-guard.js";
 import { isControllerAliasOutpostId } from "../lib/lanes/admission-host.js";
 import { runLeadAutopilotPass } from "../lib/lanes/autopilot.js";
 import { syncOutpostLeadRegistries } from "../lib/lanes/autopilot-registry.js";
@@ -3735,7 +3735,6 @@ async function runCreate(ctx, opts) {
     let started = lane;
     if (admission.action === "start") {
         started = spawnLaneWorker(hqRoot, lane, {
-            lowDiskGuardEnabled: await lowDiskGuardEnabledForLane(hqRoot, lane),
             env: ctx.env,
             modelDeps: {
                 readFileSync: ctx.readFileSync,
@@ -4877,7 +4876,6 @@ async function runPickup(ctx, opts) {
         }
         try {
             return spawnLaneWorker(hqRoot, current, {
-                lowDiskGuardEnabled: await lowDiskGuardEnabledForLane(hqRoot, current),
                 env: ctx.env,
                 modelDeps: {
                     readFileSync: ctx.readFileSync,
@@ -6252,7 +6250,6 @@ async function runAdmit(ctx, laneId, opts) {
             return;
         }
         const started = spawnLaneWorker(hqRoot, lane, {
-            lowDiskGuardEnabled: await lowDiskGuardEnabledForLane(hqRoot, lane),
             env: ctx.env,
             modelDeps: {
                 readFileSync: ctx.readFileSync,

package/dist/lib/daemon/hq-cloud.d.ts

@@ -23,6 +23,11 @@ export type ManagedHqCloud = PickedHqCloud & {
 export declare function managedHqCloudDir(daemonRoot: string): string;
 /** The package folder inside the updater's install prefix. */
 export declare function managedHqCloudRoot(daemonRoot: string): string;
+/**
+ * True only when both versions are valid semver and `a` is older than `b`.
+ * Prereleases count, so 6.18.33-alpha.1 is older than 6.18.33.
+ */
+export declare function hqCloudVersionOlder(a: string, b: string): boolean;
 /**
  * `usable` says whether a copy has what the daemon runs; a newer managed copy
  * that fails it (an interrupted or damaged install) is passed over.

package/dist/lib/daemon/hq-cloud.js

@@ -10,6 +10,7 @@ import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import { createRequire } from "node:module";
 import * as path from "node:path";
+import { lt as semverLt, valid as validSemver } from "semver";
 import { readDaemonConfig } from "./config.js";
 import { buildSpawnPlan } from "../../utils/windows-spawn.js";
 export const HQ_CLOUD_PACKAGE = "@indigoai-us/hq-cloud";
@@ -31,6 +32,15 @@ function newer(a, b) {
     }
     return false;
 }
+/**
+ * True only when both versions are valid semver and `a` is older than `b`.
+ * Prereleases count, so 6.18.33-alpha.1 is older than 6.18.33.
+ */
+export function hqCloudVersionOlder(a, b) {
+    const va = validSemver(a.trim());
+    const vb = validSemver(b.trim());
+    return !!va && !!vb && semverLt(va, vb);
+}
 /**
  * `usable` says whether a copy has what the daemon runs; a newer managed copy
  * that fails it (an interrupted or damaged install) is passed over.

package/dist/lib/daemon/run.d.ts

@@ -59,7 +59,10 @@ export type SyncRunnerSource = {
     kind: "unavailable";
     runnerPath: null;
 };
-export declare function syncRunnerSourceForPlan(stagedRunnerPath: string | null, hqCloud: PickedHqCloud | null, legacyBundledRunnerPath?: string | null): SyncRunnerSource;
+export declare function syncRunnerSourceForPlan(stagedRunnerPath: string | null, hqCloud: PickedHqCloud | null, legacyBundledRunnerPath?: string | null, staged?: {
+    version: string | null;
+    pinnedVersion?: string | null;
+}): SyncRunnerSource;
 /** Whether every executable in the first service plan remains usable after the CLI package is replaced. */
 export declare function daemonPlanCanReleasePackageUseLease(plans: readonly UnitPlan[], replaceablePackageRoots: readonly string[], stagingFailed: boolean, hqBootstrapReady?: boolean): boolean;
 export declare function daemonHqChildCommand(nodeBinary: string, hqBinary: string, args: readonly string[], bootstrapPath: string | null, packagePrefix: string | null): [string, string[]];

package/dist/lib/daemon/run.js

@@ -37,7 +37,7 @@ import { startHqdServer } from "./server.js";
 import { heartbeatFile, startHeartbeat } from "./heartbeat.js";
 import { createProtocolTail, ensureProtocolFifo, openProtocolWriter } from "./protocol-tail.js";
 import { takeControlRequests } from "./requests.js";
-import { currentHqCloud, currentHqCloudAfterLeaseRelease, hqCloudRunners } from "./hq-cloud.js";
+import { currentHqCloud, currentHqCloudAfterLeaseRelease, hqCloudRunners, hqCloudVersionOlder } from "./hq-cloud.js";
 import { stageSyncRunnerBundle } from "./sync-runner-bundle.js";
 import { stageHqChildBootstrap } from "./hq-child-bootstrap-stage.js";
 import { runnerSessionName } from "./remote-control.js";
@@ -76,7 +76,21 @@ export function handoffForPackageUpdateRequest(requested, restartDaemon) {
 const LEGACY_PROBE_TTL_MS = 60_000;
 /** A flag read that has not answered by then counts as off. */
 const HANDOFF_FLAG_TIMEOUT_MS = 10_000;
-export function syncRunnerSourceForPlan(stagedRunnerPath, hqCloud, legacyBundledRunnerPath = null) {
+export function syncRunnerSourceForPlan(stagedRunnerPath, hqCloud, legacyBundledRunnerPath = null, staged = { version: null }) {
+    // A managed copy lives in the daemon directory, so it survives a CLI
+    // replacement. Before lease release pickHqCloud returns it only when it is
+    // pinned or newer than the bundled copy; after release it is the only
+    // eligible package, so it must not displace a newer staged bundle unless it
+    // is the pinned version. The staged bundle is built from the bundled copy and
+    // otherwise only stands in for that copy (hq-cli#1547).
+    const managedYieldsToStaged = stagedRunnerPath !== null &&
+        hqCloud?.source === "managed" &&
+        hqCloud.version !== staged.pinnedVersion &&
+        staged.version !== null &&
+        hqCloudVersionOlder(hqCloud.version, staged.version);
+    if (hqCloud?.source === "managed" && !managedYieldsToStaged) {
+        return { kind: "managed-full-package", runnerPath: path.join(hqCloud.root, "dist", "bin", "sync-runner.js") };
+    }
     if (stagedRunnerPath)
         return { kind: "staged-sync", runnerPath: stagedRunnerPath };
     if (!hqCloud) {
@@ -86,10 +100,7 @@ export function syncRunnerSourceForPlan(stagedRunnerPath, hqCloud, legacyBundled
     }
     // The caller has already selected a usable full package; preserve the
     // conventional path here, including in tests with virtual package roots.
-    const runnerPath = path.join(hqCloud.root, "dist", "bin", "sync-runner.js");
-    return hqCloud.source === "managed"
-        ? { kind: "managed-full-package", runnerPath }
-        : { kind: "bundled-full-package", runnerPath };
+    return { kind: "bundled-full-package", runnerPath: path.join(hqCloud.root, "dist", "bin", "sync-runner.js") };
 }
 function isPathWithin(root, candidate) {
     if (!root || !path.isAbsolute(candidate))
@@ -559,7 +570,7 @@ export async function runDaemon(opts) {
             legacySyncRunnerPath = resolveSyncRunnerPath();
             legacySyncRunnerPathChecked = true;
         }
-        const syncSource = syncRunnerSourceForPlan(staged?.runnerPath ?? null, hqCloud, packageUseLeaseReleased ? null : legacySyncRunnerPath);
+        const syncSource = syncRunnerSourceForPlan(staged?.runnerPath ?? null, hqCloud, packageUseLeaseReleased ? null : legacySyncRunnerPath, { version: staged?.metadata.version ?? null, pinnedVersion: config.hqCloudVersion ?? null });
         if (!syncSource.runnerPath && !warnedMissingSyncRunner) {
             warnedMissingSyncRunner = true;
             log("warn", "the hq-cloud sync runner was not found in this CLI install; sync is unavailable");

package/dist/lib/install/claude-targets.js

@@ -49,7 +49,7 @@ export function hqSkillsSource(hqRoot) {
 }
 /** The exact hook command registered for one event (absolute path, quoted). */
 export function hookCommand(hqRoot, event, target = 'master') {
-    const skipInsideRoot = `if [ -d "\${CLAUDE_PROJECT_DIR:-}" ] && [ "\${CLAUDE_PROJECT_DIR}" -ef ${shellQuote(hqRoot)} ]; then exit 0; fi; `;
+    const skipInsideRoot = `if [ -d "\${CLAUDE_PROJECT_DIR:-}" ] && [ "\${CLAUDE_PROJECT_DIR}" -ef ${shellQuote(hqRoot)} ]; then exit 0; fi; cwd=$(pwd -P 2>/dev/null || pwd); while [ -n "$cwd" ]; do if [ -f "$cwd/core/core.yaml" ] && [ -f "$cwd/companies/manifest.yaml" ]; then exit 0; fi; [ "$cwd" = / ] && break; cwd=\${cwd%/*}; [ -n "$cwd" ] || cwd=/; done; `;
     if (target === 'shim')
         return `${skipInsideRoot}exec /bin/sh ${shellQuote(shimPath(hqRoot))} ${shellQuote(event)} --runtime claude`;
     return `${skipInsideRoot}BASH_ENV=/dev/null exec bash ${shellQuote(masterHookPath(hqRoot))} ${shellQuote(event)}`;

package/dist/lib/lanes/disk-guard.d.ts

@@ -1,14 +1,13 @@
 import * as fs from "node:fs";
-import { type ReadLanesFlagOptions } from "./registry-flag.js";
-import type { LaneRecord, LanesConfig } from "./types.js";
-export declare const LOW_DISK_GUARD_FLAG = "lanes.low-disk-guard";
-export declare function lowDiskGuardEnabledForLane(hqRoot: string, lane: LaneRecord, readFlag?: (key: string, options: ReadLanesFlagOptions) => Promise<boolean>): Promise<boolean>;
+import type { LaneProvider, LanesConfig } from "./types.js";
 interface DiskStats {
     bsize: number;
     blocks: number;
     bavail: number;
 }
 export type StatFs = (target: string) => DiskStats;
+/** Resolve the enabled provider home a lane can use for its disk preflight. */
+export declare function laneDiskAccount(config: LanesConfig, provider: LaneProvider, preferredAccountId?: string): import("./types.js").AccountConfig | undefined;
 export interface DiskSpaceMeasurement {
     path: string;
     free_bytes: number;

package/dist/lib/lanes/disk-guard.js

@@ -3,17 +3,18 @@ import * as path from "node:path";
 import { createGzip } from "node:zlib";
 import { createReadStream, createWriteStream } from "node:fs";
 import { pipeline } from "node:stream/promises";
-import { readLanesRegistryFlag } from "./registry-flag.js";
-import { resolveLaneCompany } from "./lane-company.js";
 import { effectiveAccountHome } from "./account-home.js";
 import { lanesConfigPath } from "./config.js";
-export const LOW_DISK_GUARD_FLAG = "lanes.low-disk-guard";
 const DEFAULT_LOW_DISK_FREE_BYTES = 5 * 1024 ** 3;
 const DEFAULT_LOW_DISK_FRACTION = 0.02;
 const EXCLUDED_SESSION_FILES = new Set(["auth.json", ".credentials.json", "thread_history.sqlite"]);
-export async function lowDiskGuardEnabledForLane(hqRoot, lane, readFlag = readLanesRegistryFlag) {
-    const company = resolveLaneCompany(hqRoot, lane).company;
-    return readFlag(LOW_DISK_GUARD_FLAG, { company, companyUidSource: "resolved_lane_company" });
+/** Resolve the enabled provider home a lane can use for its disk preflight. */
+export function laneDiskAccount(config, provider, preferredAccountId) {
+    const accounts = config.providers[provider].accounts;
+    const preferred = preferredAccountId ? accounts[preferredAccountId] : undefined;
+    if (preferred?.enabled)
+        return preferred;
+    return Object.values(accounts).find((account) => account.enabled);
 }
 export function measureDiskSpace(target, statfs = (p) => fs.statfsSync(p), minFreeBytes = DEFAULT_LOW_DISK_FREE_BYTES) {
     const stats = statfs(target);

package/dist/lib/lanes/reconcile.js

@@ -23,7 +23,7 @@ import { appendCappedHistory, lanesStoreRoot, parseLaneRecord, parseQuestionReco
 import { applyThrottleDecision, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, sampleCpuBusyObservation, recordCpuBusyObservation, throttleStatePath, writeThrottleState, } from "./throttle.js";
 import { readLanesRegistryFlag, readLanesRegistryFlagFailOff } from "./registry-flag.js";
 import { LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_LEAD_ADMISSION_PRIORITY_FLAG } from "./flag-keys.js";
-import { checkLaneDiskSpace, configuredCodexRolloutHomes, lowDiskGuardEnabledForLane, retainCodexRollouts } from "./disk-guard.js";
+import { checkLaneDiskSpace, configuredCodexRolloutHomes, laneDiskAccount, retainCodexRollouts } from "./disk-guard.js";
 import { laneCompanyUidSource, resolveLaneCompany } from "./lane-company.js";
 import { appendDropboxMessage } from "./dropbox.js";
 import { DEFAULT_RUNAWAY_SEARCH_GUARD_CONFIG, listHostProcesses, runRunawayToolGuard, RUNAWAY_TOOL_GUARD_FLAG, } from "./runaway-tool-guard.js";
@@ -1452,31 +1452,27 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                     repairCandidate &&
                     repairCandidate.envelope === null &&
                     (!repairCandidate.missing || envelopeRepairMode(classified.provider) === "resume")) {
-                    if (await lowDiskGuardEnabledForLane(hqRoot, classified, deps.readRegistryFlag)) {
-                        const repairConfig = loadLanesConfig(hqRoot);
-                        const repairAccount = classified.account
-                            ? repairConfig.providers[classified.provider].accounts[classified.account]
-                            : undefined;
-                        if (!repairAccount) {
-                            throw new LanesError("low_disk_account_unavailable", `Cannot determine provider home for envelope repair of lane ${classified.lane_id}`, { lane_id: classified.lane_id });
-                        }
-                        const providerHome = effectiveAccountHome(repairAccount, deps.host.hostname).home;
-                        const free = checkLaneDiskSpace(hqRoot, providerHome, deps.spawnLaneDeps?.statfs, repairConfig.low_disk_min_free_bytes);
-                        if (free.low) {
-                            const measuredAt = now.toISOString();
-                            updateLane(hqRoot, classified.lane_id, classified.version, "reconcile", (current) => ({
-                                ...current,
-                                state: "queued",
-                                queued_reason: "low_disk",
-                                queued_details: { reason: "low_disk", hq_free_bytes: free.hq.free_bytes, provider_free_bytes: free.provider.free_bytes, measured_at: measuredAt },
-                                queued_at: current.queued_at ?? measuredAt,
-                                admission_reserved_at: undefined,
-                                terminal_reason: undefined,
-                                terminal_details: undefined,
-                            }));
-                            summary.skipped.push({ kind: "lane", id: classified.lane_id, why: `low_disk: hq=${free.hq.free_bytes} provider=${free.provider.free_bytes}` });
-                            continue;
-                        }
+                    const repairConfig = loadLanesConfig(hqRoot);
+                    const repairAccount = laneDiskAccount(repairConfig, classified.provider, classified.account);
+                    if (!repairAccount) {
+                        throw new LanesError("low_disk_account_unavailable", `Cannot determine provider home for envelope repair of lane ${classified.lane_id}`, { lane_id: classified.lane_id });
+                    }
+                    const providerHome = effectiveAccountHome(repairAccount, deps.host.hostname).home;
+                    const free = checkLaneDiskSpace(hqRoot, providerHome, deps.spawnLaneDeps?.statfs, repairConfig.low_disk_min_free_bytes);
+                    if (free.low) {
+                        const measuredAt = now.toISOString();
+                        updateLane(hqRoot, classified.lane_id, classified.version, "reconcile", (current) => ({
+                            ...current,
+                            state: "queued",
+                            queued_reason: "low_disk",
+                            queued_details: { reason: "low_disk", hq_free_bytes: free.hq.free_bytes, provider_free_bytes: free.provider.free_bytes, measured_at: measuredAt },
+                            queued_at: current.queued_at ?? measuredAt,
+                            admission_reserved_at: undefined,
+                            terminal_reason: undefined,
+                            terminal_details: undefined,
+                        }));
+                        summary.skipped.push({ kind: "lane", id: classified.lane_id, why: `low_disk: hq=${free.hq.free_bytes} provider=${free.provider.free_bytes}` });
+                        continue;
                     }
                     const spawnRepair = deps.spawnRepair ??
                         ((root, repairLane, input) => spawnEnvelopeRepair(root, repairLane, input, spawnDepsForHost(deps)));
@@ -1848,7 +1844,6 @@ async function admitQueued(hqRoot, lanes, summary, deps, now, onlyLaneIds, exclu
     const spawnFn = deps.spawn ??
         (async (root, lane) => spawnLaneWorker(root, lane, {
             ...spawnDepsForHost(deps),
-            lowDiskGuardEnabled: await lowDiskGuardEnabledForLane(root, lane, deps.readRegistryFlag),
         }));
     const running = lanes.filter((lane) => (lane.state === "running" ||
         hasFreshAdmissionReservation(lane, now.getTime()) ||
@@ -3292,7 +3287,6 @@ async function resumeAwaiting(hqRoot, lanes, questions, summary, deps, onlyLaneI
     }
     const spawnFn = deps.spawn ?? (async (root, lane) => spawnLaneWorker(root, lane, {
         ...spawnDepsForHost(deps),
-        lowDiskGuardEnabled: await lowDiskGuardEnabledForLane(root, lane, deps.readRegistryFlag),
     }));
     const nowMs = deps.now().getTime();
     const fallbackAnswerAt = new Date(nowMs).toISOString();

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

@@ -75,8 +75,6 @@ export interface SpawnLaneDeps {
     hostname?: string;
     /** The caller's host scope for admission checks; reconcile supplies its resolved host. */
     admissionHost?: AdmissionHost;
-    /** Resolved per-company by the async command/reconcile boundary. */
-    lowDiskGuardEnabled?: boolean;
     /** Injected statfs boundary; production uses node:fs.statfsSync. */
     statfs?: StatFs;
     /** Provider model catalog dependencies, shared with create in tests. */

package/dist/lib/lanes/spawn.js

@@ -36,7 +36,7 @@ import { MESSAGE_REPLAY_STATE_NAME } from "./message-replay.js";
 import { markAnsweredQuestionsDelivered } from "./questions.js";
 import { hasEarlierEligibleQueuedLane, laneAdmissionCapReason, withLaneAdmissionLock, } from "./admission.js";
 import { resolveAdmissionHost } from "./admission-host.js";
-import { checkLaneDiskSpace, lowDiskGuardEnabledForLane } from "./disk-guard.js";
+import { checkLaneDiskSpace, laneDiskAccount } from "./disk-guard.js";
 import { LANE_ENVELOPE_JSON_SCHEMA, ENVELOPE_INVALID_REASON, parseLaneProvider, } from "./types.js";
 export const LANES_RUNS_REL = path.join("workspace", "lanes-runs");
 /** Written by reconcile before a resume spawn; the worker prompt names this path. */
@@ -606,7 +606,6 @@ export async function retryLaneOnAlternateAccount(hqRoot, lane, reason, writer =
             return moved;
         return spawnLaneWorker(hqRoot, moved, {
             ...deps,
-            lowDiskGuardEnabled: deps.lowDiskGuardEnabled ?? await lowDiskGuardEnabledForLane(hqRoot, moved),
         });
     });
 }
@@ -1840,33 +1839,26 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         probe: modelDeps.probe ?? defaultProbe,
         env,
     };
-    if (deps.lowDiskGuardEnabled === true) {
-        const providerConfig = config.providers[existing.provider];
-        const diskAccount = (existing.account !== undefined ? providerConfig.accounts[existing.account] : undefined) ??
-            (providerConfig.default_account !== undefined
-                ? providerConfig.accounts[providerConfig.default_account]
-                : undefined) ??
-            Object.values(providerConfig.accounts).find((account) => account.enabled);
-        if (diskAccount !== undefined) {
-            const free = checkLaneDiskSpace(hqRoot, effectiveAccountHome(diskAccount, hostname).home, deps.statfs, config.low_disk_min_free_bytes);
-            if (free.low) {
-                const measuredAt = (deps.now ?? (() => new Date()))().toISOString();
-                return retryUpdateLane(hqRoot, lane.lane_id, "spawn", (current) => ({
-                    ...current,
-                    state: "queued",
-                    queued_reason: "low_disk",
-                    queued_details: {
-                        reason: "low_disk",
-                        hq_free_bytes: free.hq.free_bytes,
-                        provider_free_bytes: free.provider.free_bytes,
-                        measured_at: measuredAt,
-                    },
-                    queued_at: current.queued_at ?? measuredAt,
-                    admission_reserved_at: undefined,
-                    terminal_reason: undefined,
-                    terminal_details: undefined,
-                }));
-            }
+    const diskAccount = laneDiskAccount(config, existing.provider, existing.account);
+    if (diskAccount !== undefined) {
+        const free = checkLaneDiskSpace(hqRoot, effectiveAccountHome(diskAccount, hostname).home, deps.statfs, config.low_disk_min_free_bytes);
+        if (free.low) {
+            const measuredAt = (deps.now ?? (() => new Date()))().toISOString();
+            return retryUpdateLane(hqRoot, lane.lane_id, "spawn", (current) => ({
+                ...current,
+                state: "queued",
+                queued_reason: "low_disk",
+                queued_details: {
+                    reason: "low_disk",
+                    hq_free_bytes: free.hq.free_bytes,
+                    provider_free_bytes: free.provider.free_bytes,
+                    measured_at: measuredAt,
+                },
+                queued_at: current.queued_at ?? measuredAt,
+                admission_reserved_at: undefined,
+                terminal_reason: undefined,
+                terminal_details: undefined,
+            }));
         }
     }
     let selection;

package/dist/lib/lanes/watcher.js

@@ -863,6 +863,12 @@ async function settleBlockerFreshness(hqRoot, lane, manifestTurnId, at, deps, me
             retryUndeliverable = true;
             escalationText = `Blocker freshness escalation for ${current.lane_id}: these blockers remain stale after consecutive turns: ${staleLabels.join(", ")}. Status file: ${resolution.statusPath}.`;
         }
+        else if (failedFallback !== undefined) {
+            // If the senior inbox is still unavailable, retry the lane inbox fallback.
+            deliverFallback = true;
+            undeliverableReason = failedFallback.reason ?? prior?.undeliverable_reason ?? "The session senior inbox is unavailable";
+            escalationText = `Blocker freshness escalation for ${current.lane_id}: these blockers remain stale after consecutive turns: ${staleLabels.join(", ")}. Status file: ${resolution.statusPath}.`;
+        }
         else if (prior !== undefined && blockerFreshnessFingerprint(prior.stale_keys.map((key, index) => ({ key, label: prior.stale_labels[index] ?? "" }))) !== fingerprint) {
             escalatedFingerprint = undefined;
         }

package/package.json

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