@indigoai-us/hq-cli 5.179.1 → 5.181.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [5.181.0] — 2026-09-24
+
+### Changed
+
+- `hq daemon` runs the session host from the hq-cloud copy it keeps up to date (hq-cloud's `hq-outpost-session-host`, when that copy has it), the same way it already runs sync and the outpost heartbeat, and restarts it after an hq-cloud update. Session-host fixes, such as starting on an Outpost that signs in with machine credentials, now reach boxes without an hq CLI release.
+
+## [5.180.0] — 2026-09-24
+
 ## [5.179.1] — 2026-09-24
 
 ### Added
@@ -13,6 +21,11 @@
   person's inbox while the answer they need still reaches them. `hq dm inbox`
   and `hq dm thread` mark agent-audience messages with an `[agent]` tag.
 
+### Fixed
+
+- Windows checkpoint stamps now use atomic replacement and bounded retries for
+  transient filesystem errors, so a brief lock does not abort the checkpoint.
+
 ## [5.179.0] — 2026-09-24
 
 ### Fixed

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

@@ -48,7 +48,11 @@ export type WriteStampsOptions = {
      * permission errno so the HqStateWriteError conversion can be proven without a
      * real unwritable path.
      */
-    fs?: Pick<typeof fs, "mkdirSync" | "writeFileSync">;
+    fs?: Pick<typeof fs, "mkdirSync" | "writeFileSync" | "renameSync" | "unlinkSync">;
+    /** Runtime seam for proving the Windows-only atomic path without host assumptions. */
+    platform?: NodeJS.Platform;
+    /** Synchronous delay seam for the bounded Windows lock retry. */
+    waitForRetry?: (delayMs: number) => void;
 };
 export declare function writeStamps(liveRoot: string, sessionId: string | undefined, options?: WriteStampsOptions): string[];
 /**

package/dist/commands/core-checkpoint.js

@@ -8,11 +8,13 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { randomUUID } from "node:crypto";
 import { execFileSync, spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { resolveLiveRoot } from "../utils/hq-roots.js";
 import { peekIdToken } from "../utils/id-token.js";
 import { toHqStateWriteError } from "../utils/hq-state-write-error.js";
+import { checkpointStampWriteErrorFor, isCheckpointStampWriteError, } from "../utils/checkpoint-stamp-write-error.js";
 const DEFAULT_TRIGGER = "stop-gate";
 const BACKENDS = new Set(["auto", "claude", "codex", "grok", "none"]);
 // Pinned by operator directive 2026-09-15; change defaults here deliberately.
@@ -408,14 +410,65 @@ function writeHqState(targetPath, operation, perform) {
         perform();
     }
     catch (error) {
+        if (isCheckpointStampWriteError(error))
+            throw error;
         const typed = toHqStateWriteError(error, targetPath, operation);
         if (typed)
             throw typed;
         throw error;
     }
 }
+const WINDOWS_CHECKPOINT_WRITE_RETRY_CODES = new Set(["EBUSY", "EPERM", "UNKNOWN"]);
+const WINDOWS_CHECKPOINT_WRITE_RETRY_DELAYS_MS = [25, 50, 100];
+function waitForCheckpointWriteRetry(delayMs) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)), 0, 0, delayMs);
+}
+function removeCheckpointStampTemp(tempPath, fsImpl, waitForRetry) {
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            fsImpl.unlinkSync(tempPath);
+            return;
+        }
+        catch (error) {
+            const code = error?.code;
+            if (code === "ENOENT")
+                return;
+            if (typeof code === "string" &&
+                WINDOWS_CHECKPOINT_WRITE_RETRY_CODES.has(code) &&
+                attempt < WINDOWS_CHECKPOINT_WRITE_RETRY_DELAYS_MS.length) {
+                waitForRetry(WINDOWS_CHECKPOINT_WRITE_RETRY_DELAYS_MS[attempt]);
+                continue;
+            }
+            throw checkpointStampWriteErrorFor(error, "unlink") ?? error;
+        }
+    }
+}
+function writeCheckpointStampAtomically(targetPath, contents, fsImpl, waitForRetry) {
+    for (let attempt = 0;; attempt += 1) {
+        const tempPath = path.join(path.dirname(targetPath), `.hq-checkpoint-stamp.tmp.${process.pid}.${randomUUID()}`);
+        let failedOperation = "open";
+        try {
+            fsImpl.writeFileSync(tempPath, contents, { flag: "wx" });
+            failedOperation = "rename";
+            fsImpl.renameSync(tempPath, targetPath);
+            return;
+        }
+        catch (error) {
+            removeCheckpointStampTemp(tempPath, fsImpl, waitForRetry);
+            const code = error?.code;
+            if (typeof code !== "string" ||
+                !WINDOWS_CHECKPOINT_WRITE_RETRY_CODES.has(code) ||
+                attempt >= WINDOWS_CHECKPOINT_WRITE_RETRY_DELAYS_MS.length) {
+                throw checkpointStampWriteErrorFor(error, failedOperation) ?? error;
+            }
+            waitForRetry(WINDOWS_CHECKPOINT_WRITE_RETRY_DELAYS_MS[attempt]);
+        }
+    }
+}
 export function writeStamps(liveRoot, sessionId, options = {}) {
     const fsImpl = options.fs ?? fs;
+    const platform = options.platform ?? process.platform;
+    const waitForRetry = options.waitForRetry ?? waitForCheckpointWriteRetry;
     const stateDir = path.join(liveRoot, "workspace", "orchestrator", "hook-state");
     writeHqState(stateDir, "create the checkpoint state directory", () => fsImpl.mkdirSync(stateDir, { recursive: true }));
     const sessionKey = sessionId
@@ -427,7 +480,9 @@ export function writeStamps(liveRoot, sessionId, options = {}) {
         path.join(stateDir, `checkpoint-cli-last-${sessionKey}`),
     ];
     for (const stampPath of stampPaths) {
-        writeHqState(stampPath, "write its checkpoint state file", () => fsImpl.writeFileSync(stampPath, timestamp));
+        writeHqState(stampPath, "write its checkpoint state file", () => platform === "win32"
+            ? writeCheckpointStampAtomically(stampPath, timestamp, fsImpl, waitForRetry)
+            : fsImpl.writeFileSync(stampPath, timestamp));
     }
     return stampPaths;
 }

package/dist/commands/daemon.js

@@ -432,7 +432,7 @@ async function runServiceSelfUpdate(d) {
         updateCli: cliSelfUpdatable() ? () => daemonSelfUpdate({ env }) : null,
         tools: TOOL_NAMES.map((name) => hostToolUpdater(name, env, d.home)),
         updateHqCloud: async () => updateManagedHqCloud(paths.root, env),
-        hqCloudUnits: hqCloudUnits(detected.type),
+        hqCloudUnits: hqCloudUnits(detected.type, enabledServices(detected.type, readDaemonConfig(paths.configPath))),
         requestDaemonRestart: () => writeControlRequest(paths.requestsDir, { action: "restart-daemon" }),
         requestRestart: (unit) => writeControlRequest(paths.requestsDir, { action: "restart", unit }),
         log: d.out,

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

@@ -64,6 +64,8 @@ export interface PlanContext {
     syncRunnerPath: string | null;
     /** hq-cloud's `hq-outpost-heartbeat` bin, when the hq-cloud in use has one. */
     heartbeatRunnerPath: string | null;
+    /** hq-cloud's `hq-outpost-session-host` bin, when the hq-cloud in use has one. */
+    sessionHostRunnerPath: string | null;
     signedIn: boolean;
     /** ~/.hq-agent/kit.json exists. */
     kitConfigured: boolean;
@@ -89,11 +91,12 @@ export interface PlanContext {
     codexRunnerScript: string | null;
 }
 /**
- * The units that run hq-cloud's code on a machine type, restarted after the
- * updater installs a new hq-cloud. Only outposts and self-hosted machines run
- * the outpost heartbeat; agent machines run the agent kit's own.
+ * The units that run hq-cloud's code on this host, restarted after the updater
+ * installs a new hq-cloud. Only outposts and self-hosted machines run the
+ * outpost heartbeat (agent machines run the agent kit's own); the session host
+ * is included wherever it is enabled.
  */
-export declare function hqCloudUnits(machineType: MachineType): ServiceName[];
+export declare function hqCloudUnits(machineType: MachineType, enabled: readonly ServiceName[]): ServiceName[];
 /** Written by outpost provisioning; the daemon runs it rather than re-implementing Codex login and relay setup. */
 export declare const CODEX_RUNNER_SCRIPT = "/usr/local/bin/outpost-codex-runner.sh";
 /** The outpost's Claude runner script, read for the session name it uses. */

package/dist/lib/daemon/catalog.js

@@ -97,12 +97,18 @@ function firstBlock(checks) {
     return hit ? { state: "waiting", reason: hit[1] } : undefined;
 }
 /**
- * The units that run hq-cloud's code on a machine type, restarted after the
- * updater installs a new hq-cloud. Only outposts and self-hosted machines run
- * the outpost heartbeat; agent machines run the agent kit's own.
+ * The units that run hq-cloud's code on this host, restarted after the updater
+ * installs a new hq-cloud. Only outposts and self-hosted machines run the
+ * outpost heartbeat (agent machines run the agent kit's own); the session host
+ * is included wherever it is enabled.
  */
-export function hqCloudUnits(machineType) {
-    return machineType === "outpost" || machineType === "self-hosted" ? ["sync", "heartbeat"] : ["sync"];
+export function hqCloudUnits(machineType, enabled) {
+    const units = ["sync"];
+    if (machineType === "outpost" || machineType === "self-hosted")
+        units.push("heartbeat");
+    if (enabled.includes("session-host"))
+        units.push("session-host");
+    return units;
 }
 /** Written by outpost provisioning; the daemon runs it rather than re-implementing Codex login and relay setup. */
 export const CODEX_RUNNER_SCRIPT = "/usr/local/bin/outpost-codex-runner.sh";
@@ -181,7 +187,10 @@ function planService(service, ctx) {
         case "session-host":
             return [
                 base(service, {
-                    command: { type: "hq", args: ["outposts", "session-host"] },
+                    // hq-cloud's own session host picks up hq-cloud updates without a CLI release.
+                    command: ctx.sessionHostRunnerPath
+                        ? { type: "node", script: ctx.sessionHostRunnerPath, args: [] }
+                        : { type: "hq", args: ["outposts", "session-host"] },
                     env: ctx.hqRoot ? { HQ_ROOT: ctx.hqRoot } : {},
                     blocked: firstBlock([[!ctx.signedIn, NOT_SIGNED_IN]]),
                 }),

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

@@ -1,5 +1,5 @@
 /**
- * Which hq-cloud the daemon runs sync and the outpost heartbeat from.
+ * Which hq-cloud the daemon runs sync, the outpost heartbeat and the session host from.
  *
  * The hq CLI ships with a copy of hq-cloud, but hq-cloud releases more often
  * than the CLI. The updater keeps a newer copy of the same major version in
@@ -27,6 +27,8 @@ export interface HqCloudRunners {
     syncRunner: string | null;
     /** `hq-outpost-heartbeat`, which older hq-cloud releases do not have. */
     heartbeat: string | null;
+    /** `hq-outpost-session-host`, which older hq-cloud releases do not have. */
+    sessionHost: string | null;
 }
 export declare function hqCloudRunners(root: string, exists?: (p: string) => boolean): HqCloudRunners;
 /** Install the newest release of the bundled major version, never older than the bundled copy. */

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

@@ -1,5 +1,5 @@
 /**
- * Which hq-cloud the daemon runs sync and the outpost heartbeat from.
+ * Which hq-cloud the daemon runs sync, the outpost heartbeat and the session host from.
  *
  * The hq CLI ships with a copy of hq-cloud, but hq-cloud releases more often
  * than the CLI. The updater keeps a newer copy of the same major version in
@@ -48,7 +48,11 @@ export function hqCloudRunners(root, exists = fs.existsSync) {
         const p = path.join(root, "dist", "bin", name);
         return exists(p) ? p : null;
     };
-    return { syncRunner: bin("sync-runner.js"), heartbeat: bin("outpost-heartbeat.js") };
+    return {
+        syncRunner: bin("sync-runner.js"),
+        heartbeat: bin("outpost-heartbeat.js"),
+        sessionHost: bin("outpost-session-host.js"),
+    };
 }
 /** Install the newest release of the bundled major version, never older than the bundled copy. */
 export function hqCloudInstallCommand(prefix, bundledVersion, platform = process.platform) {

package/dist/lib/daemon/run.js

@@ -249,7 +249,7 @@ export async function runDaemon(opts) {
         const hqRoot = configured && fs.existsSync(configured) ? configured : undefined;
         // Re-picked every reconcile, so a newer hq-cloud from the updater is used as soon as it lands.
         const hqCloud = currentHqCloud(paths.root);
-        const runners = hqCloud ? hqCloudRunners(hqCloud.root) : { syncRunner: null, heartbeat: null };
+        const runners = hqCloud ? hqCloudRunners(hqCloud.root) : { syncRunner: null, heartbeat: null, sessionHost: null };
         return planUnits(enabledServices(machineType, config), {
             machineType,
             platform,
@@ -257,6 +257,7 @@ export async function runDaemon(opts) {
             hqRoot,
             syncRunnerPath: runners.syncRunner,
             heartbeatRunnerPath: runners.heartbeat,
+            sessionHostRunnerPath: runners.sessionHost,
             signedIn: signedIn(env, home, log),
             kitConfigured: fs.existsSync(agentKitPaths(home, env).kitConfigPath),
             desktopAppManagesSync: machineType === "desktop" &&

package/dist/main.js

@@ -25,6 +25,7 @@ import { qmdQueryDocumentMessage } from "./utils/qmd-query-document-error.js";
 import { qmdModelDownloadMessage } from "./utils/qmd-model-download-error.js";
 import { qmdWorkdirMissingMessage } from "./utils/qmd-workdir-missing-error.js";
 import { hqStateWriteErrorMessage } from "./utils/hq-state-write-error.js";
+import { checkpointStampWriteCaptureContext, checkpointStampWriteMessage, } from "./utils/checkpoint-stamp-write-error.js";
 import { incompleteInstallMessage, incompleteInstallCaptureContext, } from "./utils/incomplete-install-error.js";
 import { isExpectedUserError } from "./utils/expected-cli-error.js";
 import { isVarlockEnvError } from "./run/env-graph-guard.js";
@@ -734,6 +735,8 @@ export async function handleTopLevelError(err, deps = defaultTopLevelErrorDepend
         // caller-owned conditions. Keep them at error level and attach bounded,
         // installation-independent context so OneDrive/antivirus/path-length
         // hypotheses can be separated without creating one issue per host path.
+        const checkpointStampContext = checkpointStampWriteCaptureContext(err);
+        const checkpointStampMessage = checkpointStampWriteMessage(err);
         const fsContext = filesystemErrorCaptureContext(err);
         const fsMsg = fsContext ? filesystemErrorMessage(err) : null;
         if (qmdMsg) {
@@ -781,6 +784,10 @@ export async function handleTopLevelError(err, deps = defaultTopLevelErrorDepend
         else if (transportMsg) {
             deps.stderr.write(`hq: ${transportMsg}\n`);
         }
+        else if (checkpointStampContext && checkpointStampMessage) {
+            deps.sentry.captureException(err, checkpointStampContext);
+            deps.stderr.write(`hq: ${checkpointStampMessage}\n`);
+        }
         else if (fsMsg && fsContext) {
             deps.sentry.captureException(err, fsContext);
             deps.stderr.write(`hq: ${fsMsg}\n`);

package/dist/utils/checkpoint-stamp-write-error.d.ts

@@ -0,0 +1,28 @@
+export type CheckpointStampFsOperation = "open" | "write" | "rename" | "unlink";
+type CheckpointStampErrnoCode = "EBUSY" | "EPERM" | "UNKNOWN";
+type CheckpointStampWriteDiagnostics = {
+    fs_op: CheckpointStampFsOperation;
+    target_kind: "checkpoint_stamp";
+    errno_code: CheckpointStampErrnoCode;
+    platform: "win32";
+};
+export type CheckpointStampWriteCaptureContext = {
+    fingerprint: ["fs-write-failed", "checkpoint_stamp", CheckpointStampErrnoCode];
+    tags: CheckpointStampWriteDiagnostics;
+};
+export declare class CheckpointStampWriteError extends Error {
+    name: string;
+    readonly code: CheckpointStampErrnoCode;
+    readonly syscall: CheckpointStampFsOperation;
+    readonly checkpointStampWriteDiagnostics: CheckpointStampWriteDiagnostics;
+    constructor(diagnostics: CheckpointStampWriteDiagnostics, originalStack?: string);
+}
+/** Wrap only the captured Windows lock/error classes, keeping the original frames and dropping paths. */
+export declare function checkpointStampWriteErrorFor(error: unknown, fallbackOperation: CheckpointStampFsOperation): CheckpointStampWriteError | null;
+export declare function isCheckpointStampWriteError(error: unknown): boolean;
+/** Value-free report context for the Windows checkpoint stamp write boundary. */
+export declare function checkpointStampWriteCaptureContext(error: unknown): CheckpointStampWriteCaptureContext | null;
+/** User-facing text stays actionable without including the HQ or home path. */
+export declare function checkpointStampWriteMessage(error: unknown): string | null;
+export {};
+//# sourceMappingURL=checkpoint-stamp-write-error.d.ts.map

package/dist/utils/checkpoint-stamp-write-error.js

@@ -0,0 +1,99 @@
+const CHECKPOINT_STAMP_ERRNO_CODES = new Set([
+    "EBUSY",
+    "EPERM",
+    "UNKNOWN",
+]);
+const CHECKPOINT_STAMP_FS_OPERATIONS = new Set([
+    "open",
+    "write",
+    "rename",
+    "unlink",
+]);
+function errorLike(value) {
+    return value !== null && typeof value === "object" ? value : null;
+}
+function isCheckpointStampErrnoCode(value) {
+    return typeof value === "string" && CHECKPOINT_STAMP_ERRNO_CODES.has(value);
+}
+function isCheckpointStampFsOperation(value) {
+    return (typeof value === "string" &&
+        CHECKPOINT_STAMP_FS_OPERATIONS.has(value));
+}
+export class CheckpointStampWriteError extends Error {
+    name = "CheckpointStampWriteError";
+    code;
+    syscall;
+    checkpointStampWriteDiagnostics;
+    constructor(diagnostics, originalStack) {
+        super(`checkpoint stamp write failed during ${diagnostics.fs_op} (${diagnostics.errno_code})`);
+        this.code = diagnostics.errno_code;
+        this.syscall = diagnostics.fs_op;
+        this.checkpointStampWriteDiagnostics = diagnostics;
+        if (originalStack) {
+            const frames = originalStack.split("\n").slice(1);
+            if (frames.length > 0)
+                this.stack = `${this.name}: ${this.message}\n${frames.join("\n")}`;
+        }
+    }
+}
+/** Wrap only the captured Windows lock/error classes, keeping the original frames and dropping paths. */
+export function checkpointStampWriteErrorFor(error, fallbackOperation) {
+    const record = errorLike(error);
+    if (!record || !isCheckpointStampErrnoCode(record.code))
+        return null;
+    const fsOperation = isCheckpointStampFsOperation(record.syscall)
+        ? record.syscall
+        : fallbackOperation;
+    const diagnostics = {
+        fs_op: fsOperation,
+        target_kind: "checkpoint_stamp",
+        errno_code: record.code,
+        platform: "win32",
+    };
+    return new CheckpointStampWriteError(diagnostics, error instanceof Error ? error.stack : undefined);
+}
+function diagnosticsFor(error) {
+    const record = errorLike(error);
+    if (!record || record.name !== "CheckpointStampWriteError")
+        return null;
+    const diagnostics = error
+        .checkpointStampWriteDiagnostics;
+    if (diagnostics === null || typeof diagnostics !== "object")
+        return null;
+    const candidate = diagnostics;
+    if (!isCheckpointStampFsOperation(candidate.fs_op) ||
+        candidate.target_kind !== "checkpoint_stamp" ||
+        !isCheckpointStampErrnoCode(candidate.errno_code) ||
+        candidate.platform !== "win32") {
+        return null;
+    }
+    return {
+        fs_op: candidate.fs_op,
+        target_kind: "checkpoint_stamp",
+        errno_code: candidate.errno_code,
+        platform: "win32",
+    };
+}
+export function isCheckpointStampWriteError(error) {
+    return diagnosticsFor(error) !== null;
+}
+/** Value-free report context for the Windows checkpoint stamp write boundary. */
+export function checkpointStampWriteCaptureContext(error) {
+    const tags = diagnosticsFor(error);
+    if (!tags)
+        return null;
+    return {
+        // This is a grouping key. Keep it independent of installation paths.
+        fingerprint: ["fs-write-failed", tags.target_kind, tags.errno_code],
+        tags,
+    };
+}
+/** User-facing text stays actionable without including the HQ or home path. */
+export function checkpointStampWriteMessage(error) {
+    const diagnostics = diagnosticsFor(error);
+    if (!diagnostics)
+        return null;
+    return (`hq could not write a checkpoint state file (${diagnostics.errno_code} during ${diagnostics.fs_op}). ` +
+        "Check the checkpoint state folder and retry.");
+}
+//# sourceMappingURL=checkpoint-stamp-write-error.js.map

package/package.json

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