@indigoai-us/hq-cli 5.345.8 → 5.345.10

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [Unreleased]
 
+## [5.345.10] — 2026-10-05
+- Keep a healthy recorded Claude account for lane messages when every worker-profile-pinned account is unavailable.
+
+## [5.345.9] — 2026-10-05
+- Lane messages to exited sessions now queue durably when provider admission is busy, so delivery succeeds and reconcile can resume them later.
+- Keep the current sync runner until an hq-cloud version matching the configured pin is available.
+
 ## [5.345.8] — 2026-10-05
 - Prioritize due lead keep-alive retries and honor due next-check times ahead of later backoff deadlines behind an hq-flags gate.
 - Drain bot turns before replacing a running bot after a daemon plan change.

package/dist/commands/lanes-message.js

@@ -754,6 +754,59 @@ export function createLaneMessageHandlers(deps) {
                     ...(keepCurrentAccount && opts.model !== undefined ? { cliModel: opts.model } : {}),
                 });
             }
+            const queueResumeMessage = (queuedReason, archiveBeforeWrite) => {
+                const sessionId = lane.provider_session_id;
+                if (!sessionId) {
+                    throw new LanesError("no_provider_session", `Lane ${laneId} has no provider session id to queue this message`, {
+                        lane_id: laneId,
+                        provider: lane.provider,
+                    });
+                }
+                if (archiveBeforeWrite)
+                    archiveResumeMessage(hqRoot, laneId, dropboxMessage);
+                const queued = casUpdateLane(hqRoot, laneId, (current) => {
+                    if (current.version !== lane.version ||
+                        current.state !== lane.state ||
+                        current.provider_session_id !== sessionId) {
+                        throw new LanesError("lane_admission_conflict", `Lane ${laneId} changed while its message was queued`, {
+                            lane_id: laneId,
+                            prepared_version: lane.version,
+                            version: current.version,
+                            state: current.state,
+                        });
+                    }
+                    return {
+                        ...current,
+                        state: "queued",
+                        queued_reason: queuedReason,
+                        queued_details: undefined,
+                        queued_at: at,
+                        admission_reserved_at: undefined,
+                        pending_resume: {
+                            session_id: sessionId,
+                            trigger: messageHistoryTrigger,
+                            caller: ctx.env.HQ_LANE_ID?.trim() || "user",
+                            text: deliveryText,
+                            ...(isMonitorEvent ? { monitor_event: true } : {}),
+                            message_id: messageId,
+                            compact: opts.compact !== false,
+                            at,
+                        },
+                    };
+                });
+                queuedOnAdmission = true;
+                storySwitchDeliveryStarted = true;
+                deps.onLaneMessageQueued?.(laneId, "admission");
+                if (!archiveBeforeWrite) {
+                    try {
+                        archiveResumeMessage(hqRoot, laneId, dropboxMessage);
+                    }
+                    catch (archiveError) {
+                        process.stderr.write(`Could not write the resume message audit copy for ${laneId}: ${archiveError instanceof Error ? archiveError.message : String(archiveError)}\n`);
+                    }
+                }
+                return queued;
+            };
             let questionCancellation = null;
             if (move?.queued || queuedOnQuotaHold) {
                 // Parked at the target's cap: reconcile resumes the session there.
@@ -777,84 +830,56 @@ export function createLaneMessageHandlers(deps) {
                         // Exited worker with a recorded session: queue the message when capacity
                         // is occupied, otherwise start its next turn under the shared admission lock.
                         assertLaneRunsHereForAdmission(ctx, lane);
-                        return withLaneAdmissionLock(hqRoot, lane.provider, async () => {
-                            const admission = await assessLaneAdmission(ctx, lane, { queueAt: at });
-                            if (admission.action === "refuse" && admission.error)
-                                throw admission.error;
-                            return withResumeHireAdmission(ctx, lane, () => {
-                                if (admission.action === "queue") {
-                                    const sessionId = lane.provider_session_id;
-                                    if (!sessionId) {
-                                        throw new LanesError("no_provider_session", `Lane ${laneId} has no provider session id to queue this message resume`, {
-                                            lane_id: laneId,
-                                            provider: lane.provider,
-                                        });
+                        try {
+                            return await withLaneAdmissionLock(hqRoot, lane.provider, async () => {
+                                const admission = await assessLaneAdmission(ctx, lane, { queueAt: at });
+                                if (admission.action === "refuse" && admission.error)
+                                    throw admission.error;
+                                return withResumeHireAdmission(ctx, lane, () => {
+                                    if (admission.action === "queue") {
+                                        return queueResumeMessage(admission.reason ?? "throttle", true);
                                     }
-                                    archiveResumeMessage(hqRoot, laneId, dropboxMessage);
-                                    queuedOnAdmission = true;
-                                    const queued = casUpdateLane(hqRoot, laneId, (current) => {
-                                        if (current.version !== lane.version || current.state !== lane.state) {
-                                            throw new LanesError("lane_admission_conflict", `Lane ${laneId} changed while message admission was checked`, {
-                                                lane_id: laneId,
-                                                prepared_version: lane.version,
-                                                version: current.version,
-                                                state: current.state,
-                                            });
-                                        }
-                                        return {
-                                            ...current,
-                                            state: "queued",
-                                            queued_reason: admission.reason ?? "throttle",
-                                            queued_details: undefined,
-                                            queued_at: at,
-                                            pending_resume: {
-                                                session_id: sessionId,
-                                                trigger: messageHistoryTrigger,
-                                                caller: ctx.env.HQ_LANE_ID?.trim() || "user",
-                                                text: deliveryText,
-                                                ...(isMonitorEvent ? { monitor_event: true } : {}),
-                                                message_id: messageId,
-                                                compact: opts.compact !== false,
-                                                at,
-                                            },
-                                        };
+                                    const started = spawnLaneWorker(hqRoot, lane, {
+                                        env: ctx.env,
+                                        modelDeps: {
+                                            readFileSync: ctx.readFileSync,
+                                            probe: ctx.probeProvider,
+                                            env: ctx.env,
+                                        },
+                                        existsSync: ctx.existsSync,
+                                        spawnProcess: ctx.spawnProcess,
+                                        proveDetached: ctx.proveDetached,
+                                        killProcess: ctx.killProcess,
+                                        now: ctx.now,
+                                        resolveMachineIdentity: ctx.resolveMachineIdentity,
+                                        runCompaction: ctx.runCompaction,
+                                        locateTranscript: ctx.locateTranscript,
+                                    }, {
+                                        trigger: {
+                                            kind: "message",
+                                            text: deliveryText,
+                                            message_id: messageId,
+                                            ...(isMonitorEvent ? { monitor_event: true } : {}),
+                                            ...(isSystemNotice ? { system_notice: true } : {}),
+                                        },
+                                        compact: opts.compact !== false,
+                                        effort: resumeEffort ?? recordedResumeEffort(lane),
                                     });
                                     storySwitchDeliveryStarted = true;
-                                    deps.onLaneMessageQueued?.(laneId, "admission");
-                                    return queued;
-                                }
-                                const started = spawnLaneWorker(hqRoot, lane, {
-                                    env: ctx.env,
-                                    modelDeps: {
-                                        readFileSync: ctx.readFileSync,
-                                        probe: ctx.probeProvider,
-                                        env: ctx.env,
-                                    },
-                                    existsSync: ctx.existsSync,
-                                    spawnProcess: ctx.spawnProcess,
-                                    proveDetached: ctx.proveDetached,
-                                    killProcess: ctx.killProcess,
-                                    now: ctx.now,
-                                    resolveMachineIdentity: ctx.resolveMachineIdentity,
-                                    runCompaction: ctx.runCompaction,
-                                    locateTranscript: ctx.locateTranscript,
-                                }, {
-                                    trigger: {
-                                        kind: "message",
-                                        text: deliveryText,
-                                        message_id: messageId,
-                                        ...(isMonitorEvent ? { monitor_event: true } : {}),
-                                        ...(isSystemNotice ? { system_notice: true } : {}),
-                                    },
-                                    compact: opts.compact !== false,
-                                    effort: resumeEffort ?? recordedResumeEffort(lane),
-                                });
-                                storySwitchDeliveryStarted = true;
-                                deps.onLaneWorkerStarted?.(laneId, "message");
-                                archiveResumeMessage(hqRoot, laneId, dropboxMessage);
-                                return started;
-                            }, hireGrantContext);
-                        }, ctx.sleep);
+                                    deps.onLaneWorkerStarted?.(laneId, "message");
+                                    archiveResumeMessage(hqRoot, laneId, dropboxMessage);
+                                    return started;
+                                }, hireGrantContext);
+                            }, ctx.sleep);
+                        }
+                        catch (error) {
+                            const expectedLockPath = path.join(hqRoot, "workspace", "lanes-runs", ".admission-locks", `${lane.provider}-provider.lock`);
+                            if (!(error instanceof LanesError) ||
+                                error.error !== "store_lock_timeout" ||
+                                error.details.path !== expectedLockPath)
+                                throw error;
+                            return queueResumeMessage(undefined, false);
+                        }
                     },
                 }, mechanism);
                 if (dispatched.mechanism === "resume")

package/dist/commands/lanes.js

@@ -6791,18 +6791,62 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile, opti
         (model === undefined || currentConfig.model === undefined || currentConfig.model === model ||
             lane.account === recordedModelAccount))
         return undefined;
-    const selected = selectClaudeAccount({
+    const selectionInput = {
         hosts: balanceHosts.snapshots,
         targetHost: lane.host,
         config,
         quotaState: loadQuotaState(hqRoot),
         recentUsageEnabled: await readClaudeAccountBalanceSignalsEnabled(ctx, lane.company ?? undefined),
         now: ctx.now(),
-        ...(!repairUnavailableAccount && allowedAccounts !== undefined ? { allowedAccounts } : {}),
         ...(model !== undefined ? { model } : {}),
         ...(recordedModelAccount !== undefined ? { recordedModelAccount } : {}),
         unavailableHosts: balanceHosts.unavailableHosts,
-    });
+    };
+    let selected;
+    let profilePinUnavailable = false;
+    try {
+        selected = selectClaudeAccount({
+            ...selectionInput,
+            ...(!repairUnavailableAccount && allowedAccounts !== undefined ? { allowedAccounts } : {}),
+        });
+    }
+    catch (err) {
+        const accountReasons = err instanceof LanesError &&
+            err.error === "claude_account_balance_no_eligible_account" &&
+            Array.isArray(err.details.account_reasons)
+            ? err.details.account_reasons.filter((reason) => reason !== null && typeof reason === "object" && !Array.isArray(reason))
+            : [];
+        const unavailablePinReasons = new Set(["disabled", "home_missing", "not_logged_in", "model_mismatch", "quota_held"]);
+        const everyProfileAccountUnavailable = profilePin !== undefined && profilePin.length > 0 &&
+            profilePin.every((account) => accountReasons.some((reason) => reason.account === account && typeof reason.reason === "string" && unavailablePinReasons.has(reason.reason)));
+        if (!everyProfileAccountUnavailable || lane.account === undefined ||
+            (lane.admission_accounts !== undefined && !lane.admission_accounts.includes(lane.account)))
+            throw err;
+        const recordedSelection = selectClaudeAccount({
+            ...selectionInput,
+            allowedAccounts: [lane.account],
+        });
+        selected = {
+            ...recordedSelection,
+            considered: recordedSelection.considered.map((entry) => {
+                const pinnedReason = profilePin.includes(entry.account)
+                    ? accountReasons.find((reason) => reason.account === entry.account)?.reason
+                    : undefined;
+                return typeof pinnedReason === "string"
+                    ? { ...entry, eligible: false, ineligible_reason: pinnedReason }
+                    : entry;
+            }),
+            skipped_accounts: [
+                ...recordedSelection.skipped_accounts.filter((entry) => !profilePin.includes(entry.account)),
+                ...profilePin.map((account) => ({
+                    account,
+                    host: lane.host,
+                    reason: String(accountReasons.find((entry) => entry.account === account)?.reason),
+                })),
+            ],
+        };
+        profilePinUnavailable = true;
+    }
     const historyReason = lane.account === undefined
         ? "load_balance"
         : currentConfig?.enabled !== true
@@ -6815,7 +6859,11 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile, opti
                         ? "usage_limit"
                         : "load_balance";
     return {
-        selection: { ...selected, selected_at: ctx.now().toISOString() },
+        selection: {
+            ...selected,
+            ...(profilePinUnavailable ? { reason: "profile_pin_unavailable" } : {}),
+            selected_at: ctx.now().toISOString(),
+        },
         historyReason,
         ...(preservedModel !== undefined ? { preservedModel } : {}),
     };

package/dist/lib/bot/coding-tool-activity.d.ts

@@ -45,7 +45,7 @@ export interface ActivityThreshold {
  * at least `minDistinctDays` calendar days, within the last `windowDays` days.
  */
 export declare const SIGNIFICANT_CODING_TOOL_ACTIVITY: Readonly<ActivityThreshold>;
-export interface ToolActivity {
+interface ToolActivity {
     /** Is the desktop app installed? */
     installed: boolean;
     /** App sessions used within the window (0 when the app is not installed). */
@@ -79,15 +79,8 @@ export interface DetectCodingToolActivityInput {
     extraHqRoots?: string[];
     threshold?: ActivityThreshold;
 }
-/** The desktop apps, by bundle id, and the bundle names they ship under. */
-export declare const DESKTOP_APPS: Readonly<Record<CodingTool, {
-    bundleId: string;
-    bundles: readonly string[];
-}>>;
 /** `originator` the Codex app writes into its sessions' first line. */
 export declare const CODEX_APP_ORIGINATOR = "Codex Desktop";
-/** Claude Code's project folder name for a working directory. */
-export declare function claudeProjectDirName(cwd: string): string;
 /**
  * Is `bundleId` this Info.plist's CFBundleIdentifier? An XML plist is read by
  * key. A binary plist has no readable key/value pairing, so it matches when the
@@ -139,4 +132,5 @@ export declare function pickCodingTool(claude: {
 }, threshold?: ActivityThreshold): CodingTool | null;
 /** Look for the Claude and Codex desktop apps and their recent sessions, and pick one to offer, if any. */
 export declare function detectCodingToolActivity(input: DetectCodingToolActivityInput): CodingToolActivity;
+export {};
 //# sourceMappingURL=coding-tool-activity.d.ts.map

package/dist/lib/bot/coding-tool-activity.js

@@ -48,7 +48,7 @@ export const SIGNIFICANT_CODING_TOOL_ACTIVITY = Object.freeze({
     minDistinctDays: 3,
 });
 /** The desktop apps, by bundle id, and the bundle names they ship under. */
-export const DESKTOP_APPS = Object.freeze({
+const DESKTOP_APPS = Object.freeze({
     claude: { bundleId: "com.anthropic.claudefordesktop", bundles: ["Claude.app"] },
     codex: { bundleId: "com.openai.codex", bundles: ["ChatGPT.app", "Codex.app"] },
 });
@@ -65,10 +65,6 @@ const DAY_MS = 24 * 60 * 60 * 1000;
  * many days older than the window, so a resumed session is still counted.
  */
 const CODEX_FOLDER_MARGIN_DAYS = 31;
-/** Claude Code's project folder name for a working directory. */
-export function claudeProjectDirName(cwd) {
-    return path.resolve(cwd).replace(/[^a-zA-Z0-9]/g, "-");
-}
 function codexHome(home, env) {
     const override = env.CODEX_HOME?.trim();
     return override ? override : path.join(home, ".codex");

package/dist/lib/bot/setup-tool-offer.d.ts

@@ -26,10 +26,6 @@ import type { CodingTool } from "./coding-tool-activity.js";
 export declare const KEEP_GOING_HERE_REPLY = "Keep going here";
 /** The hq-block kind the desktop app draws as the two-button card. */
 export declare const CONTINUE_IN_TOOL_BLOCK_KIND = "continueInTool";
-/** The desktop apps' product names. */
-export declare const CODING_TOOL_NAMES: Readonly<Record<CodingTool, string>>;
-/** The offer's one line. */
-export declare function setupToolOfferLine(tool: CodingTool): string;
 /**
  * The opening of the app's welcome, kept when the offer replaces it: its
  * first sentence (who the bot is and what setup covers). The rest of the

package/dist/lib/bot/setup-tool-offer.js

@@ -26,12 +26,12 @@ export const KEEP_GOING_HERE_REPLY = "Keep going here";
 /** The hq-block kind the desktop app draws as the two-button card. */
 export const CONTINUE_IN_TOOL_BLOCK_KIND = "continueInTool";
 /** The desktop apps' product names. */
-export const CODING_TOOL_NAMES = Object.freeze({
+const CODING_TOOL_NAMES = Object.freeze({
     claude: "Claude",
     codex: "Codex",
 });
 /** The offer's one line. */
-export function setupToolOfferLine(tool) {
+function setupToolOfferLine(tool) {
     return `Looks like you use the ${CODING_TOOL_NAMES[tool]} app. Want to continue setup there?`;
 }
 /**

package/dist/lib/checkpoint-ontology/tree.d.ts

@@ -25,7 +25,6 @@ export interface EntityIndex {
     /** Files under `ontology/entities/` that fail validation. Never written. */
     invalid: Set<string>;
 }
-export declare function emptyIndex(): EntityIndex;
 /** Add one parsed entity to the index (also used for entities created mid-run). */
 export declare function indexEntity(index: EntityIndex, entity: IndexedEntity): void;
 /** Record that the entity at `rel` answers to `alias`. */

package/dist/lib/checkpoint-ontology/tree.js

@@ -18,7 +18,7 @@ function add(map, key, value) {
     }
     set.add(value);
 }
-export function emptyIndex() {
+function emptyIndex() {
     return {
         byRel: new Map(),
         canonical: new Map(),

package/dist/lib/core-utils/qmd-reindex-after-sync.d.ts

@@ -1,8 +1,6 @@
 import { type EmbedLockDependencies } from "../search-index/embed-lock.js";
 import { type LoadGateDependencies } from "../search-index/load-gate.js";
 import { type UtilityIo } from "./common.js";
-export declare const QMD_REINDEX_STARTUP_WARNING_FLAG = "qmd.reindex-startup-warning";
-export declare const QMD_REINDEX_STARTUP_WARNING_FLAG_FALLBACK = false;
 export type QmdReindexOptions = UtilityIo & {
     cwd?: string;
     /** Test seams; default to the real search-index implementations. */

package/dist/lib/core-utils/qmd-reindex-after-sync.js

@@ -20,8 +20,8 @@ import { resolveProcessFlagGate } from "../flag-registry.js";
 import { qmdReindexSingleFlightEnabled } from "../search-index/reindex-single-flight-flag.js";
 import { isQmdNativeBindingError, QMD_NATIVE_BINDING_REMEDY, } from "../../utils/qmd-native-binding-error.js";
 import { ioFor, line } from "./common.js";
-export const QMD_REINDEX_STARTUP_WARNING_FLAG = "qmd.reindex-startup-warning";
-export const QMD_REINDEX_STARTUP_WARNING_FLAG_FALLBACK = false;
+const QMD_REINDEX_STARTUP_WARNING_FLAG = "qmd.reindex-startup-warning";
+const QMD_REINDEX_STARTUP_WARNING_FLAG_FALLBACK = false;
 function qmdStartupFailureWarningsEnabled() {
     return resolveProcessFlagGate(QMD_REINDEX_STARTUP_WARNING_FLAG, { fallback: QMD_REINDEX_STARTUP_WARNING_FLAG_FALLBACK }, () => QMD_REINDEX_STARTUP_WARNING_FLAG_FALLBACK);
 }

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

@@ -7,8 +7,6 @@
  * on disk. Policy hq-self-updater-must-verify-convergence-after-install: the
  * caller reports a mismatch as a failure; it is never swallowed.
  */
-export declare const CONVERGENCE_TIMEOUT_MS = 10000;
-export declare const CONVERGENCE_POLL_MS = 500;
 export interface ConvergenceResult {
     converged: boolean;
     expected: string;

package/dist/lib/daemon/convergence.js

@@ -9,8 +9,8 @@
  */
 import { spawnSync } from "node:child_process";
 import { hqdRequest } from "./protocol.js";
-export const CONVERGENCE_TIMEOUT_MS = 10_000;
-export const CONVERGENCE_POLL_MS = 500;
+const CONVERGENCE_TIMEOUT_MS = 10_000;
+const CONVERGENCE_POLL_MS = 500;
 /** Ping hqd over its socket and return the version it reports. */
 export async function pingHqdVersion(socketPath, timeoutMs = 2_000) {
     const result = (await hqdRequest("ping", {}, { socketPath, timeoutMs }));

package/dist/lib/daemon/flag-monitor.d.ts

@@ -1,5 +1,3 @@
-export declare const HQ_ANYWHERE_FLAG_REFRESH_INTERVAL_MS = 30000;
-export declare const HQ_ANYWHERE_FLAG_MAX_STALENESS_MS = 60000;
 export interface BoundedDaemonFlagMonitorOptions {
     read: () => Promise<boolean>;
     now?: () => number;

package/dist/lib/daemon/flag-monitor.js

@@ -1,6 +1,6 @@
 import { performance } from "node:perf_hooks";
-export const HQ_ANYWHERE_FLAG_REFRESH_INTERVAL_MS = 30_000;
-export const HQ_ANYWHERE_FLAG_MAX_STALENESS_MS = 60_000;
+const HQ_ANYWHERE_FLAG_REFRESH_INTERVAL_MS = 30_000;
+const HQ_ANYWHERE_FLAG_MAX_STALENESS_MS = 60_000;
 /**
  * Refreshes a long-running daemon's flag independently of incoming requests.
  * A failed read keeps the last successful decision only until its 60s age limit.

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

@@ -5,9 +5,7 @@
  * from a stale one offline. A device with no beat for 5 minutes is
  * "daemon stale".
  */
-export declare const HEARTBEAT_INTERVAL_MS = 60000;
 export declare const HEARTBEAT_STALE_MS: number;
-export declare const HEARTBEAT_FILE = "hqd-heartbeat.json";
 export declare const DAEMON_STALE_LABEL = "daemon stale";
 export interface HeartbeatState {
     at: string;
@@ -16,8 +14,6 @@ export interface HeartbeatState {
     device: string;
 }
 export declare function heartbeatFile(home?: string, env?: NodeJS.ProcessEnv): string;
-/** Mesh session id for this device's daemon; only characters the spool accepts. */
-export declare function heartbeatSessionId(hostname?: string): string;
 export declare function readHeartbeat(file: string): HeartbeatState | null;
 /** Presence label for a device given its last beat: "daemon stale" after 5 minutes of silence. */
 export declare function daemonPresenceLabel(state: HeartbeatState | null, now?: Date): "daemon live" | typeof DAEMON_STALE_LABEL;

package/dist/lib/daemon/heartbeat.js

@@ -8,16 +8,16 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-export const HEARTBEAT_INTERVAL_MS = 60_000;
+const HEARTBEAT_INTERVAL_MS = 60_000;
 export const HEARTBEAT_STALE_MS = 5 * 60_000;
-export const HEARTBEAT_FILE = "hqd-heartbeat.json";
+const HEARTBEAT_FILE = "hqd-heartbeat.json";
 export const DAEMON_STALE_LABEL = "daemon stale";
 export function heartbeatFile(home = os.homedir(), env = process.env) {
     const dir = env.HQ_REGISTRY_DIR?.trim() ? path.resolve(env.HQ_REGISTRY_DIR.trim()) : path.join(home, ".hq");
     return path.join(dir, HEARTBEAT_FILE);
 }
 /** Mesh session id for this device's daemon; only characters the spool accepts. */
-export function heartbeatSessionId(hostname = os.hostname()) {
+function heartbeatSessionId(hostname = os.hostname()) {
     return `hqd-${hostname.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").slice(0, 48) || "device"}`;
 }
 export function readHeartbeat(file) {

package/dist/lib/daemon/legacy-sync-env.d.ts

@@ -4,7 +4,6 @@
  * sync limits. This module is deliberately tolerant: a bad or missing drop-in
  * must never stop daemon planning.
  */
-export declare const LEGACY_SYNC_DROPIN_DIR = "/etc/systemd/system/outpost-sync.service.d";
 /** Read simple KEY=VALUE and quoted "KEY=VALUE" Environment directives. */
 export declare function readLegacySyncEnv(platform: NodeJS.Platform, directory?: string): Record<string, string>;
 //# sourceMappingURL=legacy-sync-env.d.ts.map

package/dist/lib/daemon/legacy-sync-env.js

@@ -6,7 +6,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-export const LEGACY_SYNC_DROPIN_DIR = "/etc/systemd/system/outpost-sync.service.d";
+const LEGACY_SYNC_DROPIN_DIR = "/etc/systemd/system/outpost-sync.service.d";
 function assignments(text, into) {
     let inService = false;
     for (const rawLine of text.split(/\r?\n/)) {

package/dist/lib/daemon/ops/memory.d.ts

@@ -2,12 +2,10 @@
  * memory.get / memory.put ops (hq-anywhere US-009): session-scoped notes
  * persisted at workspace/sessions/<sid>/hqd-memory.json under HQ_ROOT.
  */
-export declare const MEMORY_FILE = "hqd-memory.json";
 export declare class MemoryOpError extends Error {
     readonly code: string;
     constructor(code: string, message: string);
 }
-export declare function memoryPath(hqRoot: string, sessionId: string): string;
 export declare function memoryPut(hqRoot: string, sessionId: string, key: string, value: unknown, now?: Date): {
     key: string;
     updatedAt: string;

package/dist/lib/daemon/ops/memory.js

@@ -5,7 +5,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 const SESSION_RE = /^[A-Za-z0-9._-]+$/;
-export const MEMORY_FILE = "hqd-memory.json";
+const MEMORY_FILE = "hqd-memory.json";
 const MAX_VALUE_BYTES = 256 * 1024;
 export class MemoryOpError extends Error {
     code;
@@ -15,7 +15,7 @@ export class MemoryOpError extends Error {
         this.name = "MemoryOpError";
     }
 }
-export function memoryPath(hqRoot, sessionId) {
+function memoryPath(hqRoot, sessionId) {
     if (!SESSION_RE.test(sessionId) || sessionId === "." || sessionId === "..") {
         throw new MemoryOpError("bad_args", "sessionId may only contain letters, digits, '.', '_' and '-'");
     }

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

@@ -62,7 +62,7 @@ export type SyncRunnerSource = {
 export declare function syncRunnerSourceForPlan(stagedRunnerPath: string | null, hqCloud: PickedHqCloud | null, legacyBundledRunnerPath?: string | null, staged?: {
     version: string | null;
     pinnedVersion?: string | null;
-}): SyncRunnerSource;
+}, currentSyncRunnerSource?: SyncRunnerSource | 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

@@ -76,13 +76,20 @@ 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, staged = { version: null }) {
+export function syncRunnerSourceForPlan(stagedRunnerPath, hqCloud, legacyBundledRunnerPath = null, staged = { version: null }, currentSyncRunnerSource = 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 pin = staged.pinnedVersion;
+    const hasRunnerAtOrAbovePin = pin != null &&
+        ((staged.version !== null && !hqCloudVersionOlder(staged.version, pin)) ||
+            (hqCloud !== null && !hqCloudVersionOlder(hqCloud.version, pin)));
+    if (pin && !hasRunnerAtOrAbovePin && currentSyncRunnerSource?.runnerPath) {
+        return currentSyncRunnerSource;
+    }
     const managedYieldsToStaged = stagedRunnerPath !== null &&
         hqCloud?.source === "managed" &&
         hqCloud.version !== staged.pinnedVersion &&
@@ -373,6 +380,7 @@ export async function runDaemon(opts) {
     let hqChildBootstrapStageFailed = false;
     let legacySyncRunnerPathChecked = false;
     let legacySyncRunnerPath = null;
+    let lastPlannedSyncRunnerSource = null;
     let packageUseLeaseReleased = false;
     let hqCloudVersionBeforeRelease = null;
     let startupPlanOpen = true;
@@ -570,7 +578,8 @@ export async function runDaemon(opts) {
             legacySyncRunnerPath = resolveSyncRunnerPath();
             legacySyncRunnerPathChecked = true;
         }
-        const syncSource = syncRunnerSourceForPlan(staged?.runnerPath ?? null, hqCloud, packageUseLeaseReleased ? null : legacySyncRunnerPath, { version: staged?.metadata.version ?? null, pinnedVersion: config.hqCloudVersion ?? null });
+        const syncSource = syncRunnerSourceForPlan(staged?.runnerPath ?? null, hqCloud, packageUseLeaseReleased ? null : legacySyncRunnerPath, { version: staged?.metadata.version ?? null, pinnedVersion: config.hqCloudVersion ?? null }, lastPlannedSyncRunnerSource);
+        lastPlannedSyncRunnerSource = syncSource.runnerPath ? syncSource : 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/daemon/supervisor.d.ts

@@ -26,7 +26,6 @@ import type { MachineType } from "./machine-type.js";
 import type { ControlRequest } from "./requests.js";
 import { syncPassResult } from "./sync-runner.js";
 export declare const STOP_ESCALATION_MS = 10000;
-export declare const CLI_UPDATE_SYNC_IDLE_MAX_MS: number;
 export declare const CLI_UPDATE_SYNC_IDLE_KILL_GRACE_MS = 60000;
 /** After a handoff, how long a replaced unit must stay up before the next one is replaced. */
 export declare const HANDOFF_STAGGER_MS = 15000;

package/dist/lib/daemon/supervisor.js

@@ -27,7 +27,7 @@ const BACKOFF_BASE_MS = 1_000;
 const BACKOFF_MAX_MS = 60_000;
 const HEALTHY_RUN_MS = 60_000;
 export const STOP_ESCALATION_MS = 10_000;
-export const CLI_UPDATE_SYNC_IDLE_MAX_MS = 10 * 60_000;
+const CLI_UPDATE_SYNC_IDLE_MAX_MS = 10 * 60_000;
 export const CLI_UPDATE_SYNC_IDLE_KILL_GRACE_MS = 60_000;
 const MESH_OWNER_RECHECK_MS = 15_000;
 const MESH_OWNER_LOG_INTERVAL_MS = 10 * 60_000;

package/dist/lib/daemon/sync-runner-bundle.d.ts

@@ -3,7 +3,7 @@ import * as fs from "node:fs";
 export declare const SYNC_RUNNER_BUNDLE_RUNNER_FILE = "bin/sync-runner.js";
 export declare const SYNC_RUNNER_BUNDLE_METADATA_FILE = "package.json";
 export declare const SYNC_RUNNER_BUNDLE_DIRECTORY = "hq-cloud-sync-runner";
-export declare const SYNC_RUNNER_BUNDLE_FORMAT_VERSION = 1;
+declare const SYNC_RUNNER_BUNDLE_FORMAT_VERSION = 1;
 /** Root directory where validated sync-runner bundles are selected. */
 export declare function syncRunnerBundleStageRoot(daemonRoot: string): string;
 /** package.json contract that the hq-cli build step emits beside the bundled bin directory. */
@@ -41,4 +41,5 @@ export declare function stagedSyncRunnerVersion(runnerPath: string): string;
  * Only a completed, fsynced directory is returned; temp siblings are ignored.
  */
 export declare function stageSyncRunnerBundle(options: StageSyncRunnerBundleOptions): StagedSyncRunnerBundle;
+export {};
 //# sourceMappingURL=sync-runner-bundle.d.ts.map