@indigoai-us/hq-cli 5.345.151 → 5.345.153

package/dist/lib/workers-registry/index.js

@@ -59,7 +59,13 @@ function workerYamlFiles(root, relativeRoot) {
             return;
         }
         entries.sort((left, right) => (left.name < right.name ? -1 : left.name > right.name ? 1 : 0));
+        // A `.git` file (linked worktree) or folder (clone) below the scan root marks
+        // a separate checkout. Its worker.yaml files belong to that checkout, so the
+        // walk stops there. A checkout that is itself one worker keeps its own entry.
+        const isNestedCheckout = isNestedWorkerCheckout(relativeRoot, relative, entries.map((entry) => entry.name));
         for (const entry of entries) {
+            if (isNestedCheckout && entry.name !== 'worker.yaml')
+                continue;
             const childRelative = path.join(relative, entry.name);
             const child = path.join(root, childRelative);
             if (entry.name === 'worker.yaml' && (entry.isFile() || isFile(child))) {
@@ -162,12 +168,21 @@ function withoutTimestamp(content) {
  * (`.codex/worktrees/<name>/`) are the same trap in a different folder: a
  * nested HQ root under a company project. Those copies land in the registry as
  * `companies/<slug>/…/.claude/worktrees/…` or `.codex/worktrees/…` paths, so
- * `hq lanes create` then fails with `worker_tenancy_unresolved`.
+ * `hq lanes create` then fails with `worker_tenancy_unresolved`. HQ's own
+ * `workspace/worktrees/<name>/` is the same shape.
+ *
+ * `node_modules` and `.git` never hold workers and are large, so they are
+ * skipped wherever they appear. Any other checkout (a directory holding `.git`)
+ * is caught by the walk itself, because only the filesystem can tell.
  */
 export function isExcludedWorkerDirectory(relativeDirectory) {
     const normalized = relativeDirectory.replaceAll('\\', '/');
     if (/(?:^|\/)\.(?:claude|codex)\/worktrees(?:\/|$)/.test(normalized))
         return true;
+    if (/(?:^|\/)workspace\/worktrees(?:\/|$)/.test(normalized))
+        return true;
+    if (/(?:^|\/)(?:node_modules|\.git)(?:\/|$)/.test(normalized))
+        return true;
     const [root, tenant, nested] = normalized.split('/');
     if (root !== 'companies')
         return /(?:^|\/)_overrides(?:\/|$)/.test(normalized);
@@ -177,6 +192,29 @@ export function isExcludedWorkerDirectory(relativeDirectory) {
         return true;
     return /(?:^|\/)_overrides(?:\/|$)/.test(normalized);
 }
+/**
+ * Directories that may be git repositories without being a nested checkout.
+ *
+ * An operator can keep a whole tenant (`companies/<slug>`) or a tenant's
+ * `workers` folder in its own repository. Treating either as a checkout would
+ * drop every real worker in that tenant.
+ */
+function isCheckoutBoundaryExempt(relativeDirectory) {
+    const parts = relativeDirectory.replaceAll('\\', '/').split('/');
+    if (parts[0] !== 'companies')
+        return false;
+    return parts.length === 2 || (parts.length === 3 && parts[2] === 'workers');
+}
+/**
+ * True when `relativeDirectory`, found while walking `scanRoot`, is a separate
+ * git checkout (its listing `names` holds `.git`). The caller may still take a
+ * `worker.yaml` directly inside it, but must not descend any further.
+ */
+export function isNestedWorkerCheckout(scanRoot, relativeDirectory, names) {
+    return relativeDirectory !== scanRoot
+        && !isCheckoutBoundaryExempt(relativeDirectory)
+        && names.includes('.git');
+}
 /**
  * Every exclusion is a property of the directory holding the `worker.yaml`, so
  * the file rule is the directory rule applied to its parent. Deriving it keeps

package/dist/utils/cognito-session.d.ts

@@ -294,7 +294,10 @@ export declare function buildVaultConfig(authToken: string): VaultServiceConfig;
  * means no valid session could be ensured non-interactively; the caller gets a
  * reason string and can decide what to do next. Never opens a browser.
  */
-type MachineRefreshOptions = Pick<EnsureCognitoTokenOptions, "tokenSource"> & MachineTokenValidityOptions;
+type MachineRefreshOptions = Pick<EnsureCognitoTokenOptions, "tokenSource"> & MachineTokenValidityOptions & {
+    /** Refresh the person session even when the cached token is still valid. */
+    force?: boolean;
+};
 export declare function refreshCachedSession(options?: MachineRefreshOptions): Promise<{
     refreshed: boolean;
     reason?: string;

package/dist/utils/cognito-session.js

@@ -1158,6 +1158,15 @@ export function buildVaultConfig(authToken) {
         clientInfo: CLI_CLIENT_INFO,
     };
 }
+/** Person sessions renew below this many seconds of validity by default. */
+const PERSON_REFRESH_DEFAULT_SECONDS = 120;
+/** Person tokens last one hour; a caller minimum above this would always refresh. */
+const MAX_PERSON_MIN_VALIDITY_SECONDS = 1800;
+function personRefreshThresholdSeconds(minValiditySeconds) {
+    if (minValiditySeconds === undefined)
+        return PERSON_REFRESH_DEFAULT_SECONDS;
+    return Math.max(PERSON_REFRESH_DEFAULT_SECONDS, Math.min(minValiditySeconds, MAX_PERSON_MIN_VALIDITY_SECONDS));
+}
 export async function refreshCachedSession(options = {}) {
     if (wantsMachineCognitoTokens(options))
         return refreshCachedSessionUnserialized(options);
@@ -1198,7 +1207,8 @@ async function refreshCachedSessionUnserialized(options) {
         }
         return { refreshed: false, reason: "no cached session" };
     }
-    if (!isExpiring(cached, 120)) {
+    if (!options.force &&
+        !isExpiring(cached, personRefreshThresholdSeconds(options.minValiditySeconds))) {
         return { refreshed: true };
     }
     try {

package/dist/utils/hook-trust.d.ts

@@ -26,6 +26,20 @@ export interface HookTrustDependencies {
      * our read and our commit — which no other seam can reach.
      */
     readConfigText?: (file: string) => string;
+    /**
+     * Reads the HQ `.codex` hook files exactly as the installed core release
+     * ships them. Used only by the post-rescue re-trust; see
+     * {@link retrustCodexHooksAfterRescue}.
+     */
+    loadShippedCodexHooks?: (hqRoot: string) => Promise<ShippedCodexHookFiles>;
+}
+/**
+ * The text of the hook files in core's `.codex/` layer at the release a rescue
+ * installed. A file the release does not ship is left out.
+ */
+export interface ShippedCodexHookFiles {
+    'config.toml'?: string;
+    'hooks.json'?: string;
 }
 /** Per-call knobs the `hq reindex` orchestration passes down. */
 export interface HookTrustOptions {
@@ -62,6 +76,19 @@ export declare function planCodexLaunch(executable: string, args: readonly strin
 export declare function createCodexAppServerClient(cwd: string, executable?: string, args?: string[]): Promise<CodexRpcClient>;
 /** Trust only hooks declared by this HQ root's project `.codex/` layer. */
 export declare function trustCodexProjectHooks(hqRoot: string, deps?: HookTrustDependencies): Promise<RuntimeHookTrustResult>;
+/**
+ * Re-trust the Codex hooks HQ core ships after `hq rescue` re-lays core.
+ *
+ * Codex trusts a hook by the hash of its current command, so an update that
+ * changes a hook command leaves Codex skipping it as untrusted until the next
+ * trust pass. Rescue runs that pass itself, for core-shipped hooks only: a
+ * hook in `<hqRoot>/.codex/` is trusted only when its entry matches the
+ * shipped copy of its file (see {@link coreShippedHooks}), so a hand-added
+ * entry is never trusted. Unlike `hq reindex`, rescue does not re-enable a
+ * shipped hook the user turned off. Already trusted hooks are left as they
+ * are, and a machine without Codex is skipped without starting anything.
+ */
+export declare function retrustCodexHooksAfterRescue(hqRoot: string, deps?: HookTrustDependencies, codexInstalled?: () => boolean): Promise<RuntimeHookTrustResult>;
 /**
  * Trust the user-scope hooks `hq install --global --runtime codex` registered
  * in ~/.codex/hooks.json, named by their Codex keys (`<file>:<event>:<group>:<hook>`).

package/dist/utils/hook-trust.js

@@ -3,12 +3,14 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import * as readline from 'node:readline';
+import { parse as parseToml } from 'smol-toml';
 // `~/.claude.json` is Claude Code's live user-global state file, so the write
 // reuses the hardened MCP-registration primitives (advisory lock held across
 // read->merge->write, backup before the first byte, temp+fsync+rename commit)
 // rather than a bare readFile/writeFile pair.
 import { acquireLock, atomicReplace, backupConfig, realpathOrSelf, releaseLock, restoreFromBackup, } from '../commands/mcp-registration.js';
 import { findExecutableOnPath } from './resolve-executable.js';
+import { loadShippedCodexHookFiles } from './shipped-codex-hooks.js';
 import { planResolvedCommandSpawn } from './windows-spawn.js';
 /**
  * The home directory every runtime's config is resolved under.
@@ -84,6 +86,98 @@ function hqProjectHooks(hqRoot, hooks) {
         !hook.isManaged &&
         isWithin(path.resolve(hook.sourcePath), codexLayer));
 }
+/** Codex's snake_case spelling of a hook event name (`PreToolUse` -> `pre_tool_use`). */
+function snakeEvent(event) {
+    return event.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase();
+}
+/** Stable JSON for comparing two parsed hook entries regardless of key order. */
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    const object = asObject(value);
+    if (object) {
+        return `{${Object.keys(object)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${canonicalJson(object[key])}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(value) ?? 'null';
+}
+/**
+ * Every hook entry in a Codex hooks file (TOML or JSON), keyed by the
+ * `<snake_event>:<group>:<hook>` suffix Codex appends to the file path to form
+ * a hook key. Unparseable text yields undefined.
+ */
+function codexHookEntries(text, toml) {
+    const entries = new Map();
+    let doc;
+    try {
+        doc = toml ? parseToml(text) : JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+    const hooks = asObject(asObject(doc)?.hooks);
+    for (const [event, groups] of Object.entries(hooks ?? {})) {
+        if (!Array.isArray(groups))
+            continue;
+        groups.forEach((group, g) => {
+            const handlers = asObject(group)?.hooks;
+            if (!Array.isArray(handlers))
+                return;
+            handlers.forEach((handler, h) => {
+                entries.set(`${snakeEvent(event)}:${g}:${h}`, canonicalJson(handler));
+            });
+        });
+    }
+    return entries;
+}
+/**
+ * The HQ project hooks that ship in core: those whose entry in
+ * `<hqRoot>/.codex/config.toml` or `.codex/hooks.json` is identical, at the
+ * same position, to the entry in the shipped copy of that file. A hand-added
+ * entry, or a shipped entry the user edited, matches nothing and is left out.
+ * When an HQ hook comes from a file the release does not ship, or whose
+ * shipped copy does not parse, nothing can be compared and the pass fails.
+ */
+function coreShippedHooks(hqRoot, hooks, shipped) {
+    const codexLayer = path.resolve(hqRoot, '.codex');
+    const local = new Map();
+    const selected = [];
+    for (const hook of hqProjectHooks(hqRoot, hooks)) {
+        const sourcePath = path.resolve(hook.sourcePath);
+        const file = path.relative(codexLayer, sourcePath);
+        if (file !== 'config.toml' && file !== 'hooks.json')
+            continue;
+        const prefix = `${hook.sourcePath}:`;
+        if (!hook.key.startsWith(prefix))
+            continue;
+        const toml = file.endsWith('.toml');
+        const shippedText = shipped[file];
+        if (shippedText === undefined)
+            return { fail: `the installed core release does not ship .codex/${file}` };
+        const theirs = codexHookEntries(shippedText, toml);
+        if (!theirs)
+            return { fail: `the shipped .codex/${file} is not valid ${toml ? 'TOML' : 'JSON'}` };
+        let mine = local.get(file);
+        if (!mine) {
+            let text;
+            try {
+                text = fs.readFileSync(sourcePath, 'utf8');
+            }
+            catch {
+                text = undefined;
+            }
+            mine = (text === undefined ? undefined : codexHookEntries(text, toml)) ?? new Map();
+            local.set(file, mine);
+        }
+        const position = hook.key.slice(prefix.length);
+        const entry = mine.get(position);
+        if (entry !== undefined && entry === theirs.get(position))
+            selected.push(hook);
+    }
+    return selected.length === 0 ? { skip: 'no core-shipped HQ hooks discovered' } : { hooks: selected };
+}
 /**
  * How to launch Codex. npm installs Codex on Windows as a `codex.cmd` shim,
  * which `spawn('codex')` cannot find (ENOENT) and Node refuses to run without a
@@ -203,6 +297,7 @@ export async function createCodexAppServerClient(cwd, executable = 'codex', args
 const DEFAULT_DEPS = {
     createCodexClient: createCodexAppServerClient,
     homeDir: defaultHomeDir,
+    loadShippedCodexHooks: (hqRoot) => loadShippedCodexHookFiles(hqRoot),
 };
 /** Trust only hooks declared by this HQ root's project `.codex/` layer. */
 export async function trustCodexProjectHooks(hqRoot, deps = DEFAULT_DEPS) {
@@ -216,6 +311,46 @@ export async function trustCodexProjectHooks(hqRoot, deps = DEFAULT_DEPS) {
             : { hooks: projectHooks };
     });
 }
+/** Whether a Codex CLI is on PATH (PATHEXT-expanded on Windows). */
+function codexOnPath() {
+    return findExecutableOnPath('codex') !== undefined;
+}
+/**
+ * Re-trust the Codex hooks HQ core ships after `hq rescue` re-lays core.
+ *
+ * Codex trusts a hook by the hash of its current command, so an update that
+ * changes a hook command leaves Codex skipping it as untrusted until the next
+ * trust pass. Rescue runs that pass itself, for core-shipped hooks only: a
+ * hook in `<hqRoot>/.codex/` is trusted only when its entry matches the
+ * shipped copy of its file (see {@link coreShippedHooks}), so a hand-added
+ * entry is never trusted. Unlike `hq reindex`, rescue does not re-enable a
+ * shipped hook the user turned off. Already trusted hooks are left as they
+ * are, and a machine without Codex is skipped without starting anything.
+ */
+export async function retrustCodexHooksAfterRescue(hqRoot, deps = DEFAULT_DEPS, codexInstalled = codexOnPath) {
+    if (!codexInstalled()) {
+        return { runtime: 'codex', status: 'skipped', trusted: 0, reason: 'Codex CLI not installed' };
+    }
+    if (!fs.existsSync(path.join(hqRoot, '.codex'))) {
+        return { runtime: 'codex', status: 'skipped', trusted: 0, reason: 'project .codex layer absent' };
+    }
+    if (!deps.loadShippedCodexHooks) {
+        return { runtime: 'codex', status: 'failed', trusted: 0, reason: 'no source for the shipped Codex hooks' };
+    }
+    let shipped;
+    try {
+        shipped = await deps.loadShippedCodexHooks(hqRoot);
+    }
+    catch (error) {
+        return {
+            runtime: 'codex',
+            status: 'failed',
+            trusted: 0,
+            reason: `could not read the shipped Codex hooks: ${errorMessage(error)}`,
+        };
+    }
+    return trustCodexHooks(hqRoot, deps, (hooks) => coreShippedHooks(hqRoot, hooks, shipped), { enableDisabled: false });
+}
 /**
  * Trust the user-scope hooks `hq install --global --runtime codex` registered
  * in ~/.codex/hooks.json, named by their Codex keys (`<file>:<event>:<group>:<hook>`).
@@ -234,8 +369,12 @@ export async function trustCodexUserHooks(cwd, keys, deps = DEFAULT_DEPS) {
         return { hooks: keys.map((key) => byKey.get(key)) };
     });
 }
-/** List hooks for `cwd`, trust and enable the selected ones, then verify. */
-async function trustCodexHooks(cwd, deps, select) {
+/**
+ * List hooks for `cwd`, trust the selected ones, then verify. By default a
+ * selected hook the user disabled is also re-enabled; `enableDisabled: false`
+ * keeps each hook's enabled state as it is.
+ */
+async function trustCodexHooks(cwd, deps, select, { enableDisabled = true } = {}) {
     let client;
     try {
         client = await deps.createCodexClient(cwd);
@@ -256,17 +395,20 @@ async function trustCodexHooks(cwd, deps, select) {
             return { runtime: 'codex', status: 'failed', trusted: 0, reason: selection.fail };
         }
         const selected = selection.hooks;
-        // Converge every selected HQ hook to trusted AND enabled. A hook that is
-        // already trusted but was toggled off would otherwise silently stay
-        // disabled forever; reindex and install are the convergence points.
-        const pending = selected.filter((hook) => hook.trustStatus === 'untrusted' || hook.trustStatus === 'modified' || !hook.enabled);
+        // Converge every selected HQ hook to trusted AND (unless the caller opted
+        // out) enabled. A hook that is already trusted but was toggled off would
+        // otherwise silently stay disabled forever; reindex and install are the
+        // convergence points. Rescue opts out and only refreshes trust.
+        const pending = selected.filter((hook) => hook.trustStatus === 'untrusted' ||
+            hook.trustStatus === 'modified' ||
+            (enableDisabled && !hook.enabled));
         if (pending.length === 0) {
             return { runtime: 'codex', status: 'unchanged', trusted: 0 };
         }
         const state = Object.fromEntries(pending.map((hook) => [
             hook.key,
             {
-                enabled: true,
+                enabled: enableDisabled ? true : hook.enabled,
                 trusted_hash: hook.currentHash,
             },
         ]));
@@ -279,7 +421,7 @@ async function trustCodexHooks(cwd, deps, select) {
         const stillPending = pending
             .filter((hook) => {
             const after = verifiedByKey.get(hook.key);
-            return after?.trustStatus !== 'trusted' || after.enabled !== true;
+            return after?.trustStatus !== 'trusted' || after.enabled !== (enableDisabled || hook.enabled);
         })
             .map((hook) => hook.key);
         if (verified.errors.length > 0 || stillPending.length > 0) {

package/dist/utils/shipped-codex-hooks.d.ts

@@ -0,0 +1,17 @@
+import type { ShippedCodexHookFiles } from './hook-trust.js';
+/** The only repos rescue installs core from: the default and `--staging`. */
+export declare const PROD_SOURCE = "indigoai-us/hq-core";
+export declare const STAGING_SOURCE = "indigoai-us/hq-core-staging";
+/** Resolve a GitHub token: prefer `gh auth token`, fall back to env. */
+export declare function resolveGhToken(): string | undefined;
+/**
+ * The upstream repo and commit the last rescue installed, from `core/core.yaml`.
+ * Only the HQ core repos are accepted.
+ */
+export declare function readCoreSyncStamp(hqRoot: string): {
+    source: string;
+    sha: string;
+};
+/** The shipped `.codex/config.toml` and `.codex/hooks.json` for this HQ root's installed core. */
+export declare function loadShippedCodexHookFiles(hqRoot: string, token?: string | undefined, fetchImpl?: typeof fetch): Promise<ShippedCodexHookFiles>;
+//# sourceMappingURL=shipped-codex-hooks.d.ts.map

package/dist/utils/shipped-codex-hooks.js

@@ -0,0 +1,86 @@
+/**
+ * Reads the Codex hook files HQ core ships, at the exact commit a rescue
+ * installed, so the post-rescue re-trust can tell core-shipped hook entries
+ * from ones a user added by hand.
+ *
+ * The commit comes from the sync stamp rescue writes to `core/core.yaml`
+ * (`replaced_from_source.source` + `last_sync_sha`); the files come from the
+ * GitHub contents API for that repo and commit.
+ */
+import { spawnSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'js-yaml';
+/** The only repos rescue installs core from: the default and `--staging`. */
+export const PROD_SOURCE = 'indigoai-us/hq-core';
+export const STAGING_SOURCE = 'indigoai-us/hq-core-staging';
+const CORE_SOURCES = [PROD_SOURCE, STAGING_SOURCE];
+/** Resolve a GitHub token: prefer `gh auth token`, fall back to env. */
+export function resolveGhToken() {
+    try {
+        const res = spawnSync('gh', ['auth', 'token'], { encoding: 'utf8' });
+        if (res.status === 0) {
+            const tok = res.stdout.trim();
+            if (tok)
+                return tok;
+        }
+    }
+    catch {
+        // gh not installed — fall through to env.
+    }
+    return process.env.GH_TOKEN || process.env.GITHUB_TOKEN || undefined;
+}
+/**
+ * The upstream repo and commit the last rescue installed, from `core/core.yaml`.
+ * Only the HQ core repos are accepted.
+ */
+export function readCoreSyncStamp(hqRoot) {
+    const file = path.join(hqRoot, 'core', 'core.yaml');
+    const doc = yaml.load(fs.readFileSync(file, 'utf8'));
+    const stamp = doc?.replaced_from_source;
+    const source = stamp?.source;
+    const sha = stamp?.last_sync_sha;
+    if (typeof source !== 'string' || !/^[\w.-]+\/[\w.-]+$/.test(source)) {
+        throw new Error('core/core.yaml has no replaced_from_source.source repo');
+    }
+    // Anyone who can edit core.yaml could otherwise point the comparison (and
+    // the GitHub token) at a repo of their own and make a foreign hook "shipped".
+    if (!CORE_SOURCES.includes(source)) {
+        throw new Error(`core/core.yaml names ${source}, which is not an HQ core repo (${CORE_SOURCES.join(' or ')})`);
+    }
+    if (typeof sha !== 'string' || !/^[0-9a-f]{40}$/.test(sha)) {
+        throw new Error('core/core.yaml has no replaced_from_source.last_sync_sha commit');
+    }
+    return { source, sha };
+}
+// Same bound as rescue's own GitHub requests.
+const GITHUB_REQUEST_TIMEOUT_MS = 30_000;
+/** One file's raw text at `sha`, or undefined when the commit has no such file. */
+async function fetchRawFile(repo, sha, file, token, fetchImpl) {
+    const headers = {
+        Accept: 'application/vnd.github.raw',
+        'User-Agent': 'hq-cli-rescue',
+        'X-GitHub-Api-Version': '2022-11-28',
+    };
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    const url = `https://api.github.com/repos/${repo}/contents/${file}?ref=${sha}`;
+    const response = await fetchImpl(url, { headers, signal: AbortSignal.timeout(GITHUB_REQUEST_TIMEOUT_MS) });
+    if (response.status === 404)
+        return undefined;
+    if (!response.ok)
+        throw new Error(`GitHub contents ${file}@${sha.slice(0, 12)} for ${repo}: HTTP ${response.status}`);
+    return response.text();
+}
+/** The shipped `.codex/config.toml` and `.codex/hooks.json` for this HQ root's installed core. */
+export async function loadShippedCodexHookFiles(hqRoot, token = resolveGhToken(), fetchImpl = fetch) {
+    const { source, sha } = readCoreSyncStamp(hqRoot);
+    const shipped = {};
+    for (const name of ['config.toml', 'hooks.json']) {
+        const text = await fetchRawFile(source, sha, `.codex/${name}`, token, fetchImpl);
+        if (text !== undefined)
+            shipped[name] = text;
+    }
+    return shipped;
+}
+//# sourceMappingURL=shipped-codex-hooks.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.345.151",
+  "version": "5.345.153",
   "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.90",
+    "@indigoai-us/hq-cloud": "~6.18.91",
     "@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.151",
-    "@indigoai-us/hq-hook-win32-arm64": "5.345.151",
-    "@indigoai-us/hq-hook-darwin-x64": "5.345.151",
-    "@indigoai-us/hq-hook-darwin-arm64": "5.345.151",
-    "@indigoai-us/hq-hook-linux-x64": "5.345.151",
-    "@indigoai-us/hq-hook-linux-arm64": "5.345.151"
+    "@indigoai-us/hq-hook-win32-x64": "5.345.153",
+    "@indigoai-us/hq-hook-win32-arm64": "5.345.153",
+    "@indigoai-us/hq-hook-darwin-x64": "5.345.153",
+    "@indigoai-us/hq-hook-darwin-arm64": "5.345.153",
+    "@indigoai-us/hq-hook-linux-x64": "5.345.153",
+    "@indigoai-us/hq-hook-linux-arm64": "5.345.153"
   }
 }