@indigoai-us/hq-cli 5.345.59 → 5.345.60

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## [Unreleased]
 
+## [5.345.60] — 2026-10-09
+- The daemon now keeps an `hqd.enabled` marker beside the hqd socket while HQ Anywhere is enabled for this person and removes it when the gate turns off. The hq-core hook shim fails closed only where that marker or the socket exists, so machines without HQ Anywhere are no longer blocked, and a stopped daemon on an HQ Anywhere machine still blocks company writes. The marker is published before HQ Anywhere revocation is lifted and withdrawn after it is set. It is written only into a private, non-symlinked socket directory and never through a pre-existing symlink or FIFO. If it cannot be written safely, revocation stays in place. A failed gate lookup or a daemon shutdown leaves the marker as it was.
+
+- Improved the Windows grant command parity check by avoiding a redundant jq wrapper process while retaining exact output checks.
+
 ## [5.345.59] — 2026-10-09
 - Keep conduct-mode SessionStart injection out of unattended sessions unless `HQ_AUTO_CONDUCT` explicitly forces it on.
 - Back off the external agent-kit inbox poller from 15 seconds to 30 seconds after repeated empty polls, reset to 15 seconds when a message is mirrored, and stop promptly on SIGTERM or SIGINT with a 10-second deadline for stalled shutdowns. The default-on `agents.inbox-poll-backoff-agent-kit` hq-flags kill switch preserves the regular cadence when disabled; installed services retain a configured `HQ_FLAGS_API_URL`.

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

@@ -29,8 +29,15 @@ export interface DaemonLockConflictOutcome {
 export declare function daemonLockConflictOutcome(lock: DaemonLockResult, anywhereEnabled: boolean): DaemonLockConflictOutcome | null;
 /** hqd is available on every platform while Anywhere is enabled; its listener fails closed if setup is unsafe. */
 export declare function shouldStartHqd(anywhereEnabled: boolean): boolean;
-/** Resolve the supervisor's runtime-access decision and reflect it in the local wrapper marker. */
-export declare function refreshHqdRuntimeDecision(readDecision: () => Promise<boolean>, home: string, env: NodeJS.ProcessEnv, onMarkerError?: (error: unknown) => void): Promise<boolean>;
+/**
+ * Resolve the supervisor's runtime-access decision and reflect it in the local
+ * markers: the wrapper revocation marker and the hook shims' hqd enabled marker.
+ * Turning on publishes the enabled marker before lifting revocation, and turning
+ * off revokes before withdrawing it, so no hook ever sees revocation lifted while
+ * the shim would stay inert. If the enabled marker cannot be published,
+ * revocation stays in place.
+ */
+export declare function refreshHqdRuntimeDecision(readDecision: () => Promise<boolean>, home: string, env: NodeJS.ProcessEnv, onMarkerError?: (error: unknown) => void, syncEnabledMarker?: (enabled: boolean) => void): Promise<boolean>;
 /** Route an updater request through the daemon's existing graceful handoff. */
 export declare function handoffForPackageUpdateRequest(requested: boolean, restartDaemon: () => void): void;
 export interface RunDaemonOptions {

package/dist/lib/daemon/run.js

@@ -35,7 +35,7 @@ import { daemonRootRefusal } from "./install.js";
 import { detectMachineType } from "./machine-type.js";
 import { appendPrivate, daemonPaths, ensurePrivateDir, openPrivateAppend } from "./paths.js";
 import { hqdSocketPath } from "./protocol.js";
-import { startHqdServer } from "./server.js";
+import { startHqdServer, syncHqdEnabledMarker } from "./server.js";
 import { startHqdRuntimeListener } from "./anywhere-listener.js";
 import { heartbeatFile, startHeartbeat } from "./heartbeat.js";
 import { createProtocolTail, ensureProtocolFifo, openProtocolWriter } from "./protocol-tail.js";
@@ -94,15 +94,39 @@ export function daemonLockConflictOutcome(lock, anywhereEnabled) {
 export function shouldStartHqd(anywhereEnabled) {
     return anywhereEnabled;
 }
-/** Resolve the supervisor's runtime-access decision and reflect it in the local wrapper marker. */
-export async function refreshHqdRuntimeDecision(readDecision, home, env, onMarkerError = () => { }) {
+/**
+ * Resolve the supervisor's runtime-access decision and reflect it in the local
+ * markers: the wrapper revocation marker and the hook shims' hqd enabled marker.
+ * Turning on publishes the enabled marker before lifting revocation, and turning
+ * off revokes before withdrawing it, so no hook ever sees revocation lifted while
+ * the shim would stay inert. If the enabled marker cannot be published,
+ * revocation stays in place.
+ */
+export async function refreshHqdRuntimeDecision(readDecision, home, env, onMarkerError = () => { }, syncEnabledMarker = () => { }) {
     const enabled = await readDecision();
+    if (enabled) {
+        try {
+            syncEnabledMarker(true);
+        }
+        catch (error) {
+            onMarkerError(error);
+            return enabled;
+        }
+    }
     try {
         updateAnywhereRuntimeRevocationMarker(enabled, home, env);
     }
     catch (error) {
         onMarkerError(error);
     }
+    if (!enabled) {
+        try {
+            syncEnabledMarker(false);
+        }
+        catch (error) {
+            onMarkerError(error);
+        }
+    }
     return enabled;
 }
 /** Route an updater request through the daemon's existing graceful handoff. */
@@ -915,7 +939,7 @@ export async function runDaemon(opts) {
                 await refreshFlagRegistrySnapshot(5_000);
             },
             readSetting: readPersonSetting,
-        })), home, env, () => log("warn", "hqd runtime revocation marker update failed")),
+        })), home, env, (error) => log("warn", `hqd runtime marker update failed: ${error.message ?? String(error)}`), (enabled) => syncHqdEnabledMarker(hqdSocketPath(home, env), enabled)),
         startServer: async () => {
             const startConfig = readDaemonConfig(paths.configPath);
             return startHqdServer({

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

@@ -68,5 +68,16 @@ export declare function createResolver(registryPath: string, options?: {
     readRegistry?: typeof readRegistry;
     readCompaniesManifest?: typeof readCompaniesManifestMap;
 }): (cwd: string) => ResolveResult;
+/** Marker beside the hqd socket; hook shims fail closed only where it (or the socket) exists. */
+export declare const HQD_ENABLED_MARKER = "hqd.enabled";
+/**
+ * Keep `<socket dir>/hqd.enabled` in step with the hqd gate. The POSIX hook
+ * shim reads it to tell "hqd should answer" from "hqd is not set up here".
+ * The directory gets the same trust checks as the socket itself, and the
+ * marker is opened without following symlinks or blocking on a FIFO, so a
+ * pre-planted entry is refused instead of written through. Throws when the
+ * marker cannot be published safely. Windows named pipes have no marker.
+ */
+export declare function syncHqdEnabledMarker(socketPath: string, enabled: boolean): void;
 export declare function startHqdServer(opts: HqdServerOptions): Promise<HqdServer>;
 //# sourceMappingURL=server.d.ts.map

package/dist/lib/daemon/server.js

@@ -305,6 +305,57 @@ function prepareSocketDirectory(directory, lstat, uid) {
         throw new Error(`${directory}: newly created socket directory mode is not 0700 after chmod`);
     }
 }
+/** Marker beside the hqd socket; hook shims fail closed only where it (or the socket) exists. */
+export const HQD_ENABLED_MARKER = "hqd.enabled";
+/**
+ * Keep `<socket dir>/hqd.enabled` in step with the hqd gate. The POSIX hook
+ * shim reads it to tell "hqd should answer" from "hqd is not set up here".
+ * The directory gets the same trust checks as the socket itself, and the
+ * marker is opened without following symlinks or blocking on a FIFO, so a
+ * pre-planted entry is refused instead of written through. Throws when the
+ * marker cannot be published safely. Windows named pipes have no marker.
+ */
+export function syncHqdEnabledMarker(socketPath, enabled) {
+    if (socketPath.startsWith("\\\\.\\pipe\\"))
+        return;
+    const directory = path.dirname(path.resolve(socketPath));
+    const marker = path.join(directory, HQD_ENABLED_MARKER);
+    const lstat = (candidate) => fs.lstatSync(candidate);
+    const uid = process.getuid?.();
+    if (uid === undefined)
+        throw new Error(`${directory}: cannot verify current uid for the hqd enabled marker`);
+    if (!enabled) {
+        assertTrustedSocketPathComponents(directory, lstat, uid);
+        try {
+            fs.unlinkSync(marker);
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+        }
+        return;
+    }
+    prepareSocketDirectory(directory, lstat, uid);
+    const { O_WRONLY, O_CREAT, O_NOFOLLOW, O_NONBLOCK } = fs.constants;
+    let fd;
+    try {
+        fd = fs.openSync(marker, O_WRONLY | O_CREAT | O_NOFOLLOW | O_NONBLOCK, 0o600);
+    }
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        throw new Error(`${marker}: cannot open hqd enabled marker safely: ${detail}`);
+    }
+    try {
+        const stat = fs.fstatSync(fd);
+        if (!stat.isFile())
+            throw new Error(`${marker}: existing path is not a regular file`);
+        if (stat.uid !== uid)
+            throw new Error(`${marker}: existing marker is not owned by the current uid`);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
 function verifyUserOnlySocket(socketPath, lstat, uid) {
     assertTrustedSocketPathComponents(path.dirname(socketPath), lstat, uid);
     const before = socketLstatOrMissing(socketPath, lstat);

package/package.json

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