@indigoai-us/hq-cli 5.345.178 → 5.345.180

package/dist/lib/mesh/live/daemon/work-subscribe.js

@@ -1,6 +1,8 @@
 /**
  * Contract-2 subscriber for the personal work topic.
  * Owns live-cache.json writes. Presence publish stays on PresenceClient.
+ * On a person (prs_) account it also subscribes to the owner DM topic and
+ * keeps the content-free owner-inbox-push.json counter.
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -10,6 +12,7 @@ import { presignIotWssUrl } from "./presign.js";
 import { applyProjectViewPush, parseProjectViewPush } from "./live-cache.js";
 import { backoffDelayMs, RECONNECT_MIN_DELAY_MS } from "./presence.js";
 import { AGENT_INBOX_PUSH_STATE_BASENAME, SYNC_WAKE_STATE_BASENAME } from "../paths.js";
+import { clearOwnerInboxPushState, parseOwnerDoorbell, readOwnerInboxPushState, writeOwnerInboxPushState, } from "./owner-inbox-push.js";
 export { AGENT_INBOX_PUSH_STATE_BASENAME, SYNC_WAKE_STATE_BASENAME } from "../paths.js";
 const INBOX_PUSH_HEARTBEAT_MS = 5_000;
 const SYNC_WAKE_KEYS = new Set(["v", "type", "vault", "head", "rootId"]);
@@ -57,6 +60,13 @@ function readVaultSequences(raw) {
     }
     return vaults;
 }
+const OWNER_SEEN_EVENT_LIMIT = 500;
+/**
+ * Owner DM subscribe retries per connection. The owner signal is best-effort:
+ * after this many failures it stays off until the next broker reconnect, and
+ * the work topic keeps running.
+ */
+export const OWNER_SUBSCRIBE_MAX_RETRIES = 6;
 function readWakeSequence(meshRoot, basename, label, onInfo) {
     const target = path.join(meshRoot, basename);
     try {
@@ -163,6 +173,39 @@ export async function startWorkCacheSubscriber(opts) {
     let syncWakeSequence = syncWakeState.sequence;
     const syncWakeVaults = { ...syncWakeState.vaults };
     const syncStateWritable = syncWakeState.writable;
+    let ownerSubscribed = false;
+    let ownerUid;
+    // Carry the owner counter forward across restarts. The file holds counts
+    // and timestamps only.
+    const priorOwnerState = readOwnerInboxPushState(opts.meshRoot, opts.onInfo);
+    let ownerKnown = priorOwnerState !== null;
+    let ownerState = {
+        connected: false,
+        heartbeatAtMs: priorOwnerState?.heartbeatAtMs ?? 0,
+        count: priorOwnerState?.count ?? 0,
+        ...(priorOwnerState?.lastAt ? { lastAt: priorOwnerState.lastAt } : {}),
+        ...(priorOwnerState?.lastType ? { lastType: priorOwnerState.lastType } : {}),
+    };
+    const seenOwnerEventIds = new Set();
+    let ownerRetryTimer = null;
+    let ownerRetryAttempt = 0;
+    // Each distinct owner subscribe failure is logged once per daemon lifetime.
+    const ownerFailuresLogged = new Set();
+    let ownerGiveUpLogged = false;
+    const clearOwnerRetry = () => {
+        if (ownerRetryTimer !== null)
+            timers.clearTimeout(ownerRetryTimer);
+        ownerRetryTimer = null;
+    };
+    const reportOwnerSubscribeFailure = (err) => {
+        // Log the error name only; the message can carry the topic and its uid.
+        const key = `${err.name}:${err.message}`;
+        if (ownerFailuresLogged.has(key))
+            return;
+        ownerFailuresLogged.add(key);
+        opts.onInfo?.(`owner inbox push subscribe failed (${err.name}); retrying with backoff, ` +
+            `up to ${OWNER_SUBSCRIBE_MAX_RETRIES} times per connection`);
+    };
     const clearInboxHeartbeat = () => {
         if (heartbeatTimer !== null)
             timers.clearTimeout(heartbeatTimer);
@@ -199,30 +242,79 @@ export async function startWorkCacheSubscriber(opts) {
     const persistSyncState = (connected, durable = true) => syncStateWritable
         ? persistState(SYNC_WAKE_STATE_BASENAME, "sync wake", connected, syncWakeSequence, undefined, durable, syncWakeVaults)
         : undefined;
+    const persistOwnerState = (connected) => {
+        if (!ownerKnown)
+            return;
+        ownerState = {
+            ...ownerState,
+            connected,
+            heartbeatAtMs: now().getTime(),
+        };
+        if (connected && ownerUid)
+            ownerState.principalUid = ownerUid;
+        else
+            delete ownerState.principalUid;
+        try {
+            writeOwnerInboxPushState(opts.meshRoot, ownerState);
+        }
+        catch (error) {
+            const name = error instanceof Error ? error.name : "UnknownError";
+            opts.onInfo?.(`owner inbox push state write failed (${name})`);
+        }
+    };
     const scheduleInboxHeartbeat = () => {
-        if (stopped || (!inboxSubscribed && !syncSubscribed))
+        if (stopped || (!inboxSubscribed && !syncSubscribed && !ownerSubscribed))
             return;
         clearInboxHeartbeat();
         heartbeatTimer = timers.setTimeout(() => {
             heartbeatTimer = null;
-            if (!stopped && (inboxSubscribed || syncSubscribed)) {
+            if (!stopped && (inboxSubscribed || syncSubscribed || ownerSubscribed)) {
                 if (inboxSubscribed)
                     persistInboxState(true, false);
                 if (syncSubscribed)
                     persistSyncState(true, false);
+                if (ownerSubscribed)
+                    persistOwnerState(true);
                 scheduleInboxHeartbeat();
             }
         }, INBOX_PUSH_HEARTBEAT_MS);
     };
+    const bumpOwnerCount = (type) => {
+        ownerState = {
+            ...ownerState,
+            count: ownerState.count + 1,
+            lastAt: now().toISOString(),
+            lastType: type,
+        };
+        persistOwnerState(true);
+    };
+    const rememberOwnerEvent = (eventId) => {
+        if (!eventId)
+            return true;
+        if (seenOwnerEventIds.has(eventId))
+            return false;
+        seenOwnerEventIds.add(eventId);
+        if (seenOwnerEventIds.size > OWNER_SEEN_EVENT_LIMIT) {
+            const oldest = seenOwnerEventIds.values().next().value;
+            if (oldest !== undefined)
+                seenOwnerEventIds.delete(oldest);
+        }
+        return true;
+    };
     const connect = async () => {
         if (stopped)
             return;
         inboxSubscribed = false;
         syncSubscribed = false;
         actorUid = undefined;
+        ownerSubscribed = false;
+        ownerUid = undefined;
+        ownerRetryAttempt = 0;
+        clearOwnerRetry();
         clearInboxHeartbeat();
         persistInboxState(false);
         persistSyncState(false);
+        persistOwnerState(false);
         const gen = ++generation;
         let bundle;
         try {
@@ -241,7 +333,25 @@ export async function startWorkCacheSubscriber(opts) {
             : undefined;
         const syncTopic = syncStateWritable ? `hq/${bundle.actorUid}/sync` : undefined;
         actorUid = inboxTopic || syncTopic ? bundle.actorUid : undefined;
-        if (!topic && !inboxTopic && !syncTopic) {
+        const ownerTopic = bundle.actorUid.startsWith("prs_") &&
+            bundle.topics.dm === `hq/${bundle.actorUid}/dm`
+            ? bundle.topics.dm
+            : undefined;
+        const ownerActorUid = ownerTopic ? bundle.actorUid : undefined;
+        ownerUid = ownerActorUid;
+        if (!ownerTopic && ownerKnown) {
+            // Not a person account (or no owner DM topic): drop a file left by an
+            // earlier person login so push-status reports off rather than stale.
+            try {
+                clearOwnerInboxPushState(opts.meshRoot);
+                ownerKnown = false;
+            }
+            catch (error) {
+                const name = error instanceof Error ? error.name : "UnknownError";
+                opts.onInfo?.(`owner inbox push state clear failed (${name})`);
+            }
+        }
+        if (!topic && !inboxTopic && !syncTopic && !ownerTopic) {
             opts.onInfo?.("work cache subscribe skipped: credentials have no supported topic");
             return;
         }
@@ -257,6 +367,8 @@ export async function startWorkCacheSubscriber(opts) {
             if (stopped || gen !== generation)
                 return;
             reconnectLogged = false;
+            // The owner DM topic is best-effort and is not counted here: its failure
+            // retries on its own and never ends the connection.
             let pendingSubscriptions = Number(Boolean(topic)) + Number(Boolean(inboxTopic)) +
                 Number(Boolean(syncTopic));
             let subscriptionFailed = false;
@@ -282,6 +394,46 @@ export async function startWorkCacheSubscriber(opts) {
                 if (pendingSubscriptions === 0)
                     attempt = 0;
             };
+            if (pendingSubscriptions === 0)
+                attempt = 0;
+            const subscribeOwner = () => {
+                if (!ownerTopic)
+                    return;
+                next.subscribe(ownerTopic, { qos: 1 }, (err) => {
+                    if (stopped || gen !== generation)
+                        return;
+                    if (err) {
+                        ownerSubscribed = false;
+                        ownerUid = undefined;
+                        persistOwnerState(false);
+                        reportOwnerSubscribeFailure(err);
+                        if (ownerRetryAttempt >= OWNER_SUBSCRIBE_MAX_RETRIES) {
+                            if (!ownerGiveUpLogged) {
+                                ownerGiveUpLogged = true;
+                                opts.onInfo?.(`owner inbox push subscribe gave up after ${OWNER_SUBSCRIBE_MAX_RETRIES} retries; ` +
+                                    "owner push stays off until the next reconnect");
+                            }
+                            return;
+                        }
+                        const delay = backoffDelayMs(ownerRetryAttempt, 1000, 60_000, random, 0, RECONNECT_MIN_DELAY_MS);
+                        ownerRetryAttempt += 1;
+                        clearOwnerRetry();
+                        ownerRetryTimer = timers.setTimeout(() => {
+                            ownerRetryTimer = null;
+                            if (stopped || gen !== generation)
+                                return;
+                            subscribeOwner();
+                        }, delay);
+                        return;
+                    }
+                    ownerRetryAttempt = 0;
+                    ownerSubscribed = true;
+                    ownerKnown = true;
+                    ownerUid = ownerActorUid;
+                    persistOwnerState(true);
+                    scheduleInboxHeartbeat();
+                });
+            };
             if (topic) {
                 next.subscribe(topic, { qos: 1 }, (err) => finishSubscription(err));
             }
@@ -320,6 +472,7 @@ export async function startWorkCacheSubscriber(opts) {
                     finishSubscription();
                 });
             }
+            subscribeOwner();
         });
         next.on("message", (_topic, payload) => {
             if (stopped || gen !== generation)
@@ -344,6 +497,48 @@ export async function startWorkCacheSubscriber(opts) {
                 persistSyncState(true);
                 return;
             }
+            if (ownerTopic && _topic === ownerTopic) {
+                if (!ownerSubscribed)
+                    return;
+                // Read only type, channelId and eventId. Message text, poster name
+                // and email are never stored, logged or forwarded.
+                const doorbell = parseOwnerDoorbell(payload);
+                if (!doorbell)
+                    return;
+                if (doorbell.channelId) {
+                    const scope = opts.ownerChannelScope;
+                    if (!scope)
+                        return;
+                    if (doorbell.eventId && seenOwnerEventIds.has(doorbell.eventId))
+                        return;
+                    const channelId = doorbell.channelId;
+                    void scope
+                        .isInScope(channelId)
+                        .catch((error) => {
+                        const name = error instanceof Error ? error.name : "UnknownError";
+                        opts.onInfo?.(`owner channel scope check failed (${name})`);
+                        return false;
+                    })
+                        .then((inScope) => {
+                        if (!inScope || stopped || gen !== generation || !ownerSubscribed)
+                            return;
+                        // Record the event only once it counts, so a redelivery after a
+                        // failed or out-of-scope check is evaluated again.
+                        if (!rememberOwnerEvent(doorbell.eventId))
+                            return;
+                        bumpOwnerCount(doorbell.type);
+                    });
+                    return;
+                }
+                // A channel event must name its channel; without one its company is
+                // unknown, so it is dropped.
+                if (doorbell.type === "channel")
+                    return;
+                if (!rememberOwnerEvent(doorbell.eventId))
+                    return;
+                bumpOwnerCount(doorbell.type);
+                return;
+            }
             if (_topic !== topic)
                 return;
             const push = parseProjectViewPush(payload);
@@ -360,9 +555,13 @@ export async function startWorkCacheSubscriber(opts) {
             inboxSubscribed = false;
             syncSubscribed = false;
             actorUid = undefined;
+            ownerSubscribed = false;
+            ownerUid = undefined;
+            clearOwnerRetry();
             clearInboxHeartbeat();
             persistInboxState(false);
             persistSyncState(false);
+            persistOwnerState(false);
             opts.onInfo?.("work cache mqtt error");
             schedule();
             try {
@@ -378,9 +577,13 @@ export async function startWorkCacheSubscriber(opts) {
             inboxSubscribed = false;
             syncSubscribed = false;
             actorUid = undefined;
+            ownerSubscribed = false;
+            ownerUid = undefined;
+            clearOwnerRetry();
             clearInboxHeartbeat();
             persistInboxState(false);
             persistSyncState(false);
+            persistOwnerState(false);
             schedule();
         });
     };
@@ -408,12 +611,16 @@ export async function startWorkCacheSubscriber(opts) {
             generation += 1;
             if (timer !== null)
                 timers.clearTimeout(timer);
+            clearOwnerRetry();
             clearInboxHeartbeat();
             inboxSubscribed = false;
             syncSubscribed = false;
             actorUid = undefined;
+            ownerSubscribed = false;
+            ownerUid = undefined;
             persistInboxState(false);
             persistSyncState(false);
+            persistOwnerState(false);
             const current = client;
             client = null;
             if (!current)

package/dist/lib/mesh/live/paths.d.ts

@@ -5,6 +5,8 @@
 /** Content-free sequence file written by the mesh MQTT inbox subscriber. */
 export declare const AGENT_INBOX_PUSH_STATE_BASENAME = "agent-inbox-push.json";
 export declare const SYNC_WAKE_STATE_BASENAME = "sync-wake.json";
+/** Content-free counter file written by the mesh MQTT owner DM subscriber. */
+export declare const OWNER_INBOX_PUSH_STATE_BASENAME = "owner-inbox-push.json";
 export declare function workMeshRoot(home?: string, env?: NodeJS.ProcessEnv): string;
 export declare function workMeshSpoolPath(root?: string): string;
 export declare function workMeshHeldPath(root?: string): string;

package/dist/lib/mesh/live/paths.js

@@ -8,6 +8,8 @@ const WORK_MESH_DIRNAME = "work-mesh";
 /** Content-free sequence file written by the mesh MQTT inbox subscriber. */
 export const AGENT_INBOX_PUSH_STATE_BASENAME = "agent-inbox-push.json";
 export const SYNC_WAKE_STATE_BASENAME = "sync-wake.json";
+/** Content-free counter file written by the mesh MQTT owner DM subscriber. */
+export const OWNER_INBOX_PUSH_STATE_BASENAME = "owner-inbox-push.json";
 export function workMeshRoot(home = os.homedir(), env = process.env) {
     const override = env.HQ_WORK_MESH_ROOT?.trim();
     if (override)

package/dist/lib/sync-core/flag.d.ts

@@ -1,5 +1,5 @@
 import { type FlagClientOptions, type FlagResolution } from "@indigoai-us/hq-flags-client";
-export declare const SYNC_RUST_ENGINE_ROLLOUT_FLAG = "sync.rust-engine-rollout";
+export declare const SYNC_RUST_ENGINE_ROLLOUT_FLAG = "sync.rust-engine-rollout-v2";
 export interface RolloutFlagClient {
     ready(): Promise<void>;
     explain(flagKey: string, options?: {

package/dist/lib/sync-core/flag.js

@@ -1,6 +1,6 @@
 import { createFlagClient, readLocalOverride } from "@indigoai-us/hq-flags-client";
 import { resolveFlagRegistryEndpoint } from "../flag-registry-endpoint.js";
-export const SYNC_RUST_ENGINE_ROLLOUT_FLAG = "sync.rust-engine-rollout";
+export const SYNC_RUST_ENGINE_ROLLOUT_FLAG = "sync.rust-engine-rollout-v2";
 const READ_TIMEOUT_MS = 5_000;
 export class RolloutFlagReadError extends Error {
 }

package/dist/lib/sync-core/reconcile.d.ts

@@ -26,6 +26,6 @@ export interface SyncCoreReconcileResult {
     kept: string[];
     warnings: string[];
 }
-export declare function companyFullHold(vault: SyncCoreVault, release: string): string | undefined;
+export declare function fullModeHold(vault: SyncCoreVault, release: string): string | undefined;
 export declare function reconcileSyncCore(deps: SyncCoreReconcileDeps): Promise<SyncCoreReconcileResult>;
 //# sourceMappingURL=reconcile.d.ts.map

package/dist/lib/sync-core/reconcile.js

@@ -3,17 +3,18 @@ import * as path from "node:path";
 import { readCompaniesManifestMap } from "../work-context/repo-remote.js";
 import { readVaultSyncSwitches, writeVaultSyncSwitches } from "../vault-sync-switches.js";
 import { clearEngineStatus, engineFirstCycle, isSyncCoreVaultUid, removeEngineOwnership, syncCoreEngineHome, writeEngineHome, } from "./engine-home.js";
-import { SYNC_CORE_COMPANY_FULL_RELEASE, SYNC_CORE_RELEASE, companyFullModeAllowed, installedSyncCoreRelease, syncCoreBinaryPath, } from "./release.js";
+import { SYNC_CORE_FULL_RELEASE, SYNC_CORE_RELEASE, fullModeAllowed, installedSyncCoreRelease, syncCoreBinaryPath, } from "./release.js";
 import { readSyncCoreSkips } from "./skip.js";
+import { SYNC_RUST_ENGINE_ROLLOUT_FLAG } from "./flag.js";
 import { readSyncCoreRolloutState, syncCoreRolloutStatePath, writeSyncCoreRolloutState, } from "./rollout-state.js";
 function message(error) {
     return error instanceof Error ? error.message : String(error);
 }
-export function companyFullHold(vault, release) {
-    if (vault.kind !== "company" || companyFullModeAllowed(release))
+export function fullModeHold(vault, release) {
+    if (fullModeAllowed(release))
         return undefined;
-    const needed = SYNC_CORE_COMPANY_FULL_RELEASE ? `engine release ${SYNC_CORE_COMPANY_FULL_RELEASE} or later` : "an engine release cleared for company vaults";
-    return `company vaults move to the new sync engine with ${needed} (${release} installed); staying on the current sync`;
+    const needed = SYNC_CORE_FULL_RELEASE ? `engine release ${SYNC_CORE_FULL_RELEASE} or later` : "an engine release cleared for full sync";
+    return `${vault.kind} vaults move to the new sync engine with ${needed} (${release} installed); staying on the current sync`;
 }
 function localCompanies(hqRoot, memberships) {
     const manifest = readCompaniesManifestMap(hqRoot) ?? {};
@@ -78,7 +79,7 @@ export async function reconcileSyncCore(deps) {
             on = await deps.readRolloutFlag(company.uid);
         }
         catch (error) {
-            on = previousByUid.has(company.uid);
+            on = previous?.rolloutFlagKey === SYNC_RUST_ENGINE_ROLLOUT_FLAG && previousByUid.has(company.uid);
             warnings.push(`${message(error)}; keeping ${company.slug} ${on ? "on the new engine" : "on the current sync"}`);
         }
         if (on) {
@@ -132,7 +133,7 @@ export async function reconcileSyncCore(deps) {
     const held = [];
     const engineRelease = installedRelease ?? release;
     for (let i = desired.length - 1; i >= 0; i -= 1) {
-        const reason = companyFullHold(desired[i], engineRelease);
+        const reason = fullModeHold(desired[i], engineRelease);
         if (!reason)
             continue;
         held.unshift({ uid: desired[i].uid, reason });
@@ -200,6 +201,7 @@ export async function reconcileSyncCore(deps) {
     }
     const state = {
         version: 1,
+        rolloutFlagKey: SYNC_RUST_ENGINE_ROLLOUT_FLAG,
         readAt: at,
         release: installedRelease ?? release,
         binaryPath,

package/dist/lib/sync-core/release.d.ts

@@ -1,7 +1,7 @@
-export declare const SYNC_CORE_RELEASE = "v0.1.21";
-export declare const SYNC_CORE_COMPANY_FULL_RELEASE: string | null;
+export declare const SYNC_CORE_RELEASE = "v0.1.23";
+export declare const SYNC_CORE_FULL_RELEASE: string | null;
 export declare function compareSyncCoreReleases(a: string, b: string): number;
-export declare function companyFullModeAllowed(release: string): boolean;
+export declare function fullModeAllowed(release: string): boolean;
 export declare const SYNC_CORE_DOWNLOAD_BASE = "https://indigoai-public.s3.amazonaws.com/hq-sync-core";
 export declare const SYNC_CORE_DOWNLOAD_BASE_ENV = "HQ_SYNC_CORE_DOWNLOAD_BASE";
 export declare function syncCoreBinaryPath(home?: string): string;

package/dist/lib/sync-core/release.js

@@ -3,8 +3,8 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { execFileSync } from "node:child_process";
-export const SYNC_CORE_RELEASE = "v0.1.21";
-export const SYNC_CORE_COMPANY_FULL_RELEASE = "v0.1.21";
+export const SYNC_CORE_RELEASE = "v0.1.23";
+export const SYNC_CORE_FULL_RELEASE = "v0.1.23";
 export function compareSyncCoreReleases(a, b) {
     const parse = (release) => release.replace(/^v/, "").split(".").map((part) => Number.parseInt(part, 10) || 0);
     const [x, y] = [parse(a), parse(b)];
@@ -15,8 +15,8 @@ export function compareSyncCoreReleases(a, b) {
     }
     return 0;
 }
-export function companyFullModeAllowed(release) {
-    return SYNC_CORE_COMPANY_FULL_RELEASE !== null && compareSyncCoreReleases(release, SYNC_CORE_COMPANY_FULL_RELEASE) >= 0;
+export function fullModeAllowed(release) {
+    return SYNC_CORE_FULL_RELEASE !== null && compareSyncCoreReleases(release, SYNC_CORE_FULL_RELEASE) >= 0;
 }
 export const SYNC_CORE_DOWNLOAD_BASE = "https://indigoai-public.s3.amazonaws.com/hq-sync-core";
 export const SYNC_CORE_DOWNLOAD_BASE_ENV = "HQ_SYNC_CORE_DOWNLOAD_BASE";

package/dist/lib/sync-core/rollout-state.d.ts

@@ -11,6 +11,7 @@ export interface RolloutVault {
 }
 export interface SyncCoreRolloutState {
     version: 1;
+    rolloutFlagKey?: string;
     readAt: string;
     release: string;
     binaryPath: string;

package/dist/lib/sync-core/rollout-state.js

@@ -100,6 +100,7 @@ export function readSyncCoreRolloutState(home) {
         return null;
     return {
         version: 1,
+        ...(typeof obj.rolloutFlagKey === "string" ? { rolloutFlagKey: obj.rolloutFlagKey } : {}),
         readAt: obj.readAt,
         release: obj.release,
         binaryPath: obj.binaryPath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.345.178",
+  "version": "5.345.180",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {
@@ -52,7 +52,7 @@
     "@aws-sdk/client-iot-data-plane": "^3.1096.0",
     "@aws-sdk/client-s3": "^3.1049.0",
     "@aws-sdk/dsql-signer": "^3.1146.0",
-    "@indigoai-us/hq-cloud": "6.18.104",
+    "@indigoai-us/hq-cloud": "6.18.105",
     "@indigoai-us/hq-flags-client": "^0.1.2",
     "@modelcontextprotocol/sdk": "1.29.0",
     "@sentry/node": "^10.49.0",
@@ -114,11 +114,11 @@
     "*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}": "eslint --cache --no-error-on-unmatched-pattern"
   },
   "optionalDependencies": {
-    "@indigoai-us/hq-hook-win32-x64": "5.345.178",
-    "@indigoai-us/hq-hook-win32-arm64": "5.345.178",
-    "@indigoai-us/hq-hook-darwin-x64": "5.345.178",
-    "@indigoai-us/hq-hook-darwin-arm64": "5.345.178",
-    "@indigoai-us/hq-hook-linux-x64": "5.345.178",
-    "@indigoai-us/hq-hook-linux-arm64": "5.345.178"
+    "@indigoai-us/hq-hook-win32-x64": "5.345.180",
+    "@indigoai-us/hq-hook-win32-arm64": "5.345.180",
+    "@indigoai-us/hq-hook-darwin-x64": "5.345.180",
+    "@indigoai-us/hq-hook-darwin-arm64": "5.345.180",
+    "@indigoai-us/hq-hook-linux-x64": "5.345.180",
+    "@indigoai-us/hq-hook-linux-arm64": "5.345.180"
   }
 }