@indigoai-us/hq-cli 5.345.150 → 5.345.151

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [5.345.151] — 2026-10-20
+- `hq lanes link _deliver` no longer hands a conductor message to a subagent. Subagent hook events share the root session id, so a subagent tool call used to claim the message and the root session never saw it. Child payloads, including Grok child sessions (`subagent_type`) and Codex child threads, now get nothing and the message stays queued until the root session's next tool call or stop. SubagentStop no longer delivers. A parent session id alone does not mark a child, so resumed, forked, or launcher-spawned Grok roots still receive their messages.
+- If you leave out `--company`, `hq meetings invite <url>` now uses your only active company. If you belong to several companies, it lists them and asks you to pick one. The command used to send the invite as Personal instead. Personal can never record, so you saw the HQ Workforce upgrade prompt even when your company already had meeting recording.
+- `hq sync push`, `pull` and `now` honour the HQ app's Settings > Sync switches on this computer. A command aimed at a vault whose sync is off (the personal vault, one company vault, or every vault with "Turn off all cloud sync") prints `Sync is off for <vault>` with how to turn it back on, and exits 3 without signing in or touching the vault. The target is the `--company` value, else `activeCompany` or `companySlug` in `.hq/config.json`; a `cmp_*` uid is matched through `companies/manifest.yaml`, and an unmatched uid is refused while any company vault is off. `--creds-from-stdin` is checked once stdin is read. With `--json`, the refusal is a `{"type":"skipped","reason":"sync_off"}` line on stderr. `--all` skips the off vaults and syncs the rest. The `hq daemon` background sync skips off vaults the same way and stays stopped while all cloud sync is off; a switch change restarts it once the current sync pass finishes. A settings file that cannot be read prints a warning (and logs one in the daemon) instead of silently syncing everything. `/handoff` still finishes locally and logs a skipped push as skipped.
+- If you already had the HQ app's personal-files switch off (`personalSyncEnabled: false`) or a company's sync off (`workspaceSyncEnabled.<slug>: false`), `hq sync` now refuses those vaults too. That includes the `/handoff` personal publish, the `/startwork` and `/resumework` prefetch, and `/delegate` for those vaults. Turn the vault back on in HQ Settings > Sync to sync it from the command line again.
+
 ## [5.345.150] — 2026-10-19
 - The bundled sync engine now uses hq-cloud 6.18.90, which brings two fixes.
 - Owners and admins can now destroy one of a company's Outposts with

package/dist/commands/cloud-off-gate.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Sync switch gate for the manual `hq sync push|pull|now` commands
+ * (usage-only-pricing US-016).
+ *
+ * The desktop app's Settings > Sync section has one switch per vault plus one
+ * "Turn off all cloud sync" switch (see `../lib/vault-sync-switches.ts`). The
+ * switches affect only this computer. The app gates its own sync paths, but
+ * skills and scripts call these CLI commands directly (`/handoff`, the
+ * `/startwork` and `/resumework` prefetch, `/delegate`, job remediation). This
+ * gate makes those calls honour the same switches: a command aimed at an off
+ * vault refuses, and an `--all` run skips the off vaults while the rest sync.
+ *
+ * How the target vault is found, before any login or network call:
+ * - `--personal`, or a `prs_*` uid, is the personal vault;
+ * - `--company <ref>`, else the active company in `<hq-root>/.hq/config.json`
+ *   (`activeCompany ?? companySlug`, the same order hq-cloud's resolver uses);
+ * - a `cmp_*` uid is mapped to its slug through `companies/manifest.yaml`
+ *   (`cloud_uid`). A uid that cannot be mapped while any company vault is off
+ *   is refused (fail closed): the gate cannot prove it is not an off vault.
+ * - `--creds-from-stdin`: the target is the parsed EntityContext, checked
+ *   after stdin is read (`refusalForEntity`) and still before any transfer.
+ *
+ * The daemon's own `syncPaused` is not read here: it pauses background sync
+ * only (`hq daemon sync pause`, the tray pause), and a manual push while
+ * background sync is paused is expected to run.
+ */
+import { readVaultSyncSwitches, vaultSkipEnv, type VaultSyncSwitches } from "../lib/vault-sync-switches.js";
+export { readVaultSyncSwitches, vaultSkipEnv, type VaultSyncSwitches };
+/**
+ * Exit code for "skipped because sync is off". Distinct from 1 (sync failed)
+ * so a caller can tell the two apart; every non-zero exit still means "nothing
+ * was synced", which is what `/delegate` and job remediation need to see.
+ */
+export declare const CLOUD_OFF_EXIT_CODE = 3;
+export type GatedSyncCommand = "push" | "pull" | "now";
+/** True when "Turn off all cloud sync" is on. Never throws. */
+export declare function isCloudOff(home?: string): boolean;
+/** True when `company` (a slug) is a company vault whose switch is off. */
+export declare function isCompanyVaultOff(switches: VaultSyncSwitches, company: string): boolean;
+/**
+ * The refusal text when every vault is off. The first line keeps the phrase
+ * "refused immediately": `handoff-sync-prefetch` (shell and native) reports
+ * `skipped` rather than `error:<code>` when the pull log contains it, so
+ * released HQ versions treat this exit as skipped with no script change.
+ */
+export declare function cloudOffMessage(command: GatedSyncCommand): string;
+/** The refusal text when the one vault a command targets is off. */
+export declare function vaultOffMessage(command: GatedSyncCommand, vaultName: string): string;
+/** The refusal text when a company uid cannot be mapped while some vault is off. */
+export declare function unresolvedVaultMessage(command: GatedSyncCommand, ref: string): string;
+/** Which vaults a `push|pull|now` invocation targets. */
+export interface SyncSelection {
+    all?: boolean;
+    /** `true` for `--personal`; `false` is `--no-personal` (only meaningful with `--all`). */
+    personal?: boolean;
+    company?: string;
+    /** Used to find the active company and the uid-to-slug manifest. */
+    hqRoot?: string;
+    /** `--creds-from-stdin`: the target is checked after stdin is parsed. */
+    credsFromStdin?: boolean;
+}
+/** What an `--all` run must leave out. */
+export interface VaultSkips {
+    skipPersonal: boolean;
+    skipCompanies: ReadonlySet<string>;
+}
+/** A refusal: the text, and the vault it names (for JSON output). */
+export interface VaultRefusal {
+    message: string;
+    vault: string;
+}
+/** The vault a company reference or entity uid names. */
+export type ResolvedVault = {
+    kind: "personal";
+} | {
+    kind: "company";
+    slug: string;
+} | {
+    kind: "unknown";
+    ref: string;
+};
+/**
+ * Active company from `<hqRoot>/.hq/config.json`, best effort. Uses
+ * `activeCompany ?? companySlug`, the order hq-cloud's `resolveActiveCompany`
+ * uses, so a config with only `companySlug` is still gated.
+ */
+export declare function readActiveCompanyRef(hqRoot: string | undefined): string | undefined;
+/** Map a slug, `cmp_*` uid or `prs_*` uid to the vault it names. */
+export declare function resolveVaultRef(ref: string, hqRoot: string | undefined): ResolvedVault;
+/**
+ * The refusal for `selection`, or null when it may run. `--all` never
+ * refuses for one vault: it skips the off vaults (see {@link vaultSkips}).
+ * With `--creds-from-stdin` and no `--company`, the target is unknown until
+ * stdin is parsed; {@link refusalForEntity} checks it then.
+ */
+export declare function refusalFor(command: GatedSyncCommand, selection: SyncSelection, switches: VaultSyncSwitches): VaultRefusal | null;
+/**
+ * The refusal for a pre-vended EntityContext read from stdin. A `prs_*` uid
+ * is the personal vault; otherwise the slug (or the uid, through the
+ * manifest) names the company.
+ */
+export declare function refusalForEntity(command: GatedSyncCommand, entity: {
+    uid?: unknown;
+    slug?: unknown;
+}, hqRoot: string | undefined, switches: VaultSyncSwitches): VaultRefusal | null;
+/** The vaults an `--all` run leaves out. */
+export declare function vaultSkips(selection: SyncSelection, switches: VaultSyncSwitches): VaultSkips;
+/** Thrown after stdin is parsed when its target vault is off. */
+export declare class VaultSyncOffError extends Error {
+    readonly refusal: VaultRefusal;
+    constructor(refusal: VaultRefusal);
+}
+export interface CloudOffGateDeps {
+    home?: string;
+    writeErr?: (text: string) => void;
+    exit?: (code: number) => never;
+    /** `--json`: stderr is a JSON Lines stream, so write events, not prose. */
+    json?: boolean;
+}
+/** Write a refusal: plain text, or one JSON Lines event in `--json` mode. */
+export declare function writeVaultRefusal(refusal: VaultRefusal, deps?: Pick<CloudOffGateDeps, "writeErr" | "json">): void;
+/**
+ * Print the refusal and exit {@link CLOUD_OFF_EXIT_CODE} when `selection`
+ * targets an off vault (or every vault is off); otherwise return what an
+ * `--all` run must skip. Runs before any login, lock or network work, and
+ * outside the client-health report, so a refusal is not counted as a failed
+ * sync. Warns when the settings file is unreadable.
+ */
+export declare function refuseSyncForOffVaults(command: GatedSyncCommand, selection: SyncSelection, deps?: CloudOffGateDeps): VaultSkips;
+/**
+ * `--creds-from-stdin` check: throw {@link VaultSyncOffError} when the parsed
+ * EntityContext targets an off vault. The caller writes it and exits 3.
+ */
+export declare function assertEntityVaultSyncAllowed(command: GatedSyncCommand, entity: {
+    uid?: unknown;
+    slug?: unknown;
+}, hqRoot: string | undefined, home?: string): void;
+//# sourceMappingURL=cloud-off-gate.d.ts.map

package/dist/commands/cloud-off-gate.js

@@ -0,0 +1,234 @@
+/**
+ * Sync switch gate for the manual `hq sync push|pull|now` commands
+ * (usage-only-pricing US-016).
+ *
+ * The desktop app's Settings > Sync section has one switch per vault plus one
+ * "Turn off all cloud sync" switch (see `../lib/vault-sync-switches.ts`). The
+ * switches affect only this computer. The app gates its own sync paths, but
+ * skills and scripts call these CLI commands directly (`/handoff`, the
+ * `/startwork` and `/resumework` prefetch, `/delegate`, job remediation). This
+ * gate makes those calls honour the same switches: a command aimed at an off
+ * vault refuses, and an `--all` run skips the off vaults while the rest sync.
+ *
+ * How the target vault is found, before any login or network call:
+ * - `--personal`, or a `prs_*` uid, is the personal vault;
+ * - `--company <ref>`, else the active company in `<hq-root>/.hq/config.json`
+ *   (`activeCompany ?? companySlug`, the same order hq-cloud's resolver uses);
+ * - a `cmp_*` uid is mapped to its slug through `companies/manifest.yaml`
+ *   (`cloud_uid`). A uid that cannot be mapped while any company vault is off
+ *   is refused (fail closed): the gate cannot prove it is not an off vault.
+ * - `--creds-from-stdin`: the target is the parsed EntityContext, checked
+ *   after stdin is read (`refusalForEntity`) and still before any transfer.
+ *
+ * The daemon's own `syncPaused` is not read here: it pauses background sync
+ * only (`hq daemon sync pause`, the tray pause), and a manual push while
+ * background sync is paused is expected to run.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { readCompaniesManifestMap } from "../lib/work-context/repo-remote.js";
+import { readVaultSyncSwitches, unreadableSwitchesWarning, vaultSkipEnv, } from "../lib/vault-sync-switches.js";
+export { readVaultSyncSwitches, vaultSkipEnv };
+/**
+ * Exit code for "skipped because sync is off". Distinct from 1 (sync failed)
+ * so a caller can tell the two apart; every non-zero exit still means "nothing
+ * was synced", which is what `/delegate` and job remediation need to see.
+ */
+export const CLOUD_OFF_EXIT_CODE = 3;
+/** True when "Turn off all cloud sync" is on. Never throws. */
+export function isCloudOff(home) {
+    return readVaultSyncSwitches(home).allOff;
+}
+/** True when `company` (a slug) is a company vault whose switch is off. */
+export function isCompanyVaultOff(switches, company) {
+    return switches.offCompanies.has(company.trim().toLowerCase());
+}
+const HOW_TO_TURN_ON = "To turn it back on, open HQ and go to Settings > Sync.";
+const NOTHING_MOVED = "Nothing was uploaded or downloaded. Your local files are unchanged.";
+/**
+ * The refusal text when every vault is off. The first line keeps the phrase
+ * "refused immediately": `handoff-sync-prefetch` (shell and native) reports
+ * `skipped` rather than `error:<code>` when the pull log contains it, so
+ * released HQ versions treat this exit as skipped with no script change.
+ */
+export function cloudOffMessage(command) {
+    return [
+        `Cloud sync is off for every vault on this computer, so \`hq sync ${command}\` was refused immediately.`,
+        NOTHING_MOVED,
+        HOW_TO_TURN_ON,
+    ].join("\n");
+}
+/** The refusal text when the one vault a command targets is off. */
+export function vaultOffMessage(command, vaultName) {
+    return [
+        `Sync is off for ${vaultName} on this computer, so \`hq sync ${command}\` was refused immediately.`,
+        NOTHING_MOVED,
+        HOW_TO_TURN_ON,
+    ].join("\n");
+}
+/** The refusal text when a company uid cannot be mapped while some vault is off. */
+export function unresolvedVaultMessage(command, ref) {
+    return [
+        `Sync is off for one or more company vaults on this computer, and \`hq sync ${command}\` could not tell which vault ${ref} is, so it was refused immediately.`,
+        NOTHING_MOVED,
+        `Run it with --company <slug>, or turn the vaults back on in HQ Settings > Sync.`,
+    ].join("\n");
+}
+const COMPANY_UID = /^cmp_/i;
+const PERSON_UID = /^prs_/i;
+/**
+ * Active company from `<hqRoot>/.hq/config.json`, best effort. Uses
+ * `activeCompany ?? companySlug`, the order hq-cloud's `resolveActiveCompany`
+ * uses, so a config with only `companySlug` is still gated.
+ */
+export function readActiveCompanyRef(hqRoot) {
+    if (!hqRoot)
+        return undefined;
+    try {
+        const cfg = JSON.parse(fs.readFileSync(path.join(hqRoot, ".hq", "config.json"), "utf8"));
+        for (const value of [cfg?.activeCompany, cfg?.companySlug]) {
+            if (typeof value === "string" && value.trim())
+                return value.trim();
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Map a slug, `cmp_*` uid or `prs_*` uid to the vault it names. */
+export function resolveVaultRef(ref, hqRoot) {
+    const trimmed = ref.trim();
+    if (PERSON_UID.test(trimmed))
+        return { kind: "personal" };
+    if (!COMPANY_UID.test(trimmed))
+        return { kind: "company", slug: trimmed };
+    const manifest = hqRoot ? readCompaniesManifestMap(hqRoot) : null;
+    for (const [slug, entry] of Object.entries(manifest ?? {})) {
+        const uid = entry?.cloud_uid;
+        if (typeof uid === "string" && uid.toLowerCase() === trimmed.toLowerCase()) {
+            return { kind: "company", slug };
+        }
+    }
+    return { kind: "unknown", ref: trimmed };
+}
+function refusalForVault(command, vault, switches) {
+    switch (vault.kind) {
+        case "personal":
+            return switches.personalOff
+                ? { message: vaultOffMessage(command, "your personal vault"), vault: "personal" }
+                : null;
+        case "company":
+            return isCompanyVaultOff(switches, vault.slug)
+                ? { message: vaultOffMessage(command, vault.slug), vault: vault.slug }
+                : null;
+        case "unknown":
+            // Fail closed: with any company vault off, an unmapped uid may be it.
+            return switches.offCompanies.size > 0
+                ? { message: unresolvedVaultMessage(command, vault.ref), vault: vault.ref }
+                : null;
+    }
+}
+/**
+ * The refusal for `selection`, or null when it may run. `--all` never
+ * refuses for one vault: it skips the off vaults (see {@link vaultSkips}).
+ * With `--creds-from-stdin` and no `--company`, the target is unknown until
+ * stdin is parsed; {@link refusalForEntity} checks it then.
+ */
+export function refusalFor(command, selection, switches) {
+    if (switches.allOff)
+        return { message: cloudOffMessage(command), vault: "all" };
+    if (selection.all)
+        return null;
+    if (selection.personal === true) {
+        return refusalForVault(command, { kind: "personal" }, switches);
+    }
+    const ref = selection.company ?? (selection.credsFromStdin ? undefined : readActiveCompanyRef(selection.hqRoot));
+    if (!ref)
+        return null;
+    return refusalForVault(command, resolveVaultRef(ref, selection.hqRoot), switches);
+}
+/**
+ * The refusal for a pre-vended EntityContext read from stdin. A `prs_*` uid
+ * is the personal vault; otherwise the slug (or the uid, through the
+ * manifest) names the company.
+ */
+export function refusalForEntity(command, entity, hqRoot, switches) {
+    if (switches.allOff)
+        return { message: cloudOffMessage(command), vault: "all" };
+    const uid = typeof entity.uid === "string" ? entity.uid : "";
+    const slug = typeof entity.slug === "string" ? entity.slug : "";
+    if (PERSON_UID.test(uid))
+        return refusalForVault(command, { kind: "personal" }, switches);
+    if (slug.trim())
+        return refusalForVault(command, { kind: "company", slug }, switches);
+    if (uid.trim())
+        return refusalForVault(command, resolveVaultRef(uid, hqRoot), switches);
+    return null;
+}
+/** The vaults an `--all` run leaves out. */
+export function vaultSkips(selection, switches) {
+    return {
+        skipPersonal: selection.personal === false || switches.personalOff,
+        skipCompanies: switches.offCompanies,
+    };
+}
+/** Thrown after stdin is parsed when its target vault is off. */
+export class VaultSyncOffError extends Error {
+    refusal;
+    constructor(refusal) {
+        super(refusal.message);
+        this.refusal = refusal;
+        this.name = "VaultSyncOffError";
+    }
+}
+/** Write a refusal: plain text, or one JSON Lines event in `--json` mode. */
+export function writeVaultRefusal(refusal, deps = {}) {
+    const writeErr = deps.writeErr ?? ((text) => process.stderr.write(text));
+    if (deps.json) {
+        writeErr(`${JSON.stringify({
+            type: "skipped",
+            reason: "sync_off",
+            vault: refusal.vault,
+            exitCode: CLOUD_OFF_EXIT_CODE,
+            message: refusal.message,
+        })}\n`);
+    }
+    else {
+        writeErr(`${refusal.message}\n`);
+    }
+}
+function warnIfUnreadable(switches, deps) {
+    if (!switches.unreadable)
+        return;
+    const writeErr = deps.writeErr ?? ((text) => process.stderr.write(text));
+    const message = unreadableSwitchesWarning(switches.unreadable);
+    writeErr(deps.json ? `${JSON.stringify({ type: "warning", message })}\n` : `${message}\n`);
+}
+/**
+ * Print the refusal and exit {@link CLOUD_OFF_EXIT_CODE} when `selection`
+ * targets an off vault (or every vault is off); otherwise return what an
+ * `--all` run must skip. Runs before any login, lock or network work, and
+ * outside the client-health report, so a refusal is not counted as a failed
+ * sync. Warns when the settings file is unreadable.
+ */
+export function refuseSyncForOffVaults(command, selection, deps = {}) {
+    const switches = readVaultSyncSwitches(deps.home);
+    warnIfUnreadable(switches, deps);
+    const refusal = refusalFor(command, selection, switches);
+    if (refusal) {
+        writeVaultRefusal(refusal, deps);
+        (deps.exit ?? ((code) => process.exit(code)))(CLOUD_OFF_EXIT_CODE);
+    }
+    return vaultSkips(selection, switches);
+}
+/**
+ * `--creds-from-stdin` check: throw {@link VaultSyncOffError} when the parsed
+ * EntityContext targets an off vault. The caller writes it and exits 3.
+ */
+export function assertEntityVaultSyncAllowed(command, entity, hqRoot, home) {
+    const refusal = refusalForEntity(command, entity, hqRoot, readVaultSyncSwitches(home));
+    if (refusal)
+        throw new VaultSyncOffError(refusal);
+}
+//# sourceMappingURL=cloud-off-gate.js.map

package/dist/commands/cloud.d.ts

@@ -196,6 +196,11 @@ export interface PullAllOptions {
      * personal vault from the run without touching the rest of the plan.
      */
     skipPersonal?: boolean;
+    /**
+     * Lowercased company slugs (or uids) to leave out: vaults whose sync is off
+     * on this computer (desktop Settings > Sync, US-016).
+     */
+    skipCompanies?: ReadonlySet<string>;
     /**
      * Forward `--force-scope-shrink` to each company leg: when a scope shrink
      * would un-track locally-modified files, proceed anyway (dirty files KEPT on
@@ -263,6 +268,8 @@ export interface PushAllOptions {
      * `hq sync push --all --no-personal`.
      */
     skipPersonal?: boolean;
+    /** Lowercased company slugs (or uids) to leave out (US-016). */
+    skipCompanies?: ReadonlySet<string>;
 }
 export interface PushAllRow {
     slug: string;

package/dist/commands/cloud.js

@@ -28,6 +28,7 @@ import { maybeShowCliInviteNudge } from "../lib/cli-invite-nudge.js";
 import { createPlanLimitRefusalTracker, describeRefusedCount, describeRefusedFiles, mergePlanLimitRefusals, renderPlanLimitRefusalLines, trackingProgressRecorder, } from "../lib/billing/plan-limit-refusals.js";
 import { formatPlanGateError, planGateErrorFromVaultError, } from "../utils/plan-gate-error.js";
 import { personalTargetedPushPathsEnabled } from "./personal-targeted-push-flag.js";
+import { CLOUD_OFF_EXIT_CODE, VaultSyncOffError, assertEntityVaultSyncAllowed, refuseSyncForOffVaults, writeVaultRefusal, } from "./cloud-off-gate.js";
 import { resolveExplicitPersonalPushPaths } from "./personal-targeted-push-paths.js";
 /**
  * Terminal-failure signal for the sync fanout runners. The runners
@@ -295,6 +296,12 @@ function narrowNudgeExceedsSize(hqRoot, ref) {
     const threshold = resolveNarrowHintMinBytes({ hqRoot });
     return companyFolderExceedsThreshold(companyDir, threshold);
 }
+/** True when a membership's vault is switched off on this computer (US-016). */
+function isSkippedCompany(skip, slug, companyUid) {
+    if (!skip || skip.size === 0)
+        return false;
+    return skip.has(slug.toLowerCase()) || skip.has(companyUid.toLowerCase());
+}
 export async function pullAll(options, deps) {
     const memberships = await deps.vaultClient.listMyMemberships();
     const persons = await deps.vaultClient.listPersonEntities();
@@ -311,6 +318,8 @@ export async function pullAll(options, deps) {
         catch {
             // Best-effort — keep UID as the row label rather than aborting the run.
         }
+        if (isSkippedCompany(options.skipCompanies, slug, m.companyUid))
+            continue;
         plan.push({
             slug,
             companyUid: m.companyUid,
@@ -464,6 +473,8 @@ export async function pushAll(options, deps) {
         catch {
             // Best-effort — keep UID as the row label.
         }
+        if (isSkippedCompany(options.skipCompanies, slug, m.companyUid))
+            continue;
         plan.push({
             slug,
             companyUid: m.companyUid,
@@ -804,6 +815,13 @@ export function registerCloudCommands(program) {
         "a toggle, and so CLI users can opt out one-off. Ignored outside " +
         "`--all`.")
         .action(async (paths, options) => {
+        const skips = refuseSyncForOffVaults("push", {
+            all: options.all,
+            personal: options.personal,
+            company: options.company,
+            hqRoot: options.hqRoot,
+            credsFromStdin: options.credsFromStdin,
+        }, { json: options.json === true });
         try {
             configureSyncLockTimeout(options.lockTimeout);
             assertSingleSelector(options, "push");
@@ -833,7 +851,7 @@ export function registerCloudCommands(program) {
             // `--all` the flag has no effect (logged above as part of the
             // option's help text).
             await withSyncHealthReport(async () => {
-                const refused = await runPushAll(options.hqRoot, options.message, options.onConflict, options.personal === false);
+                const refused = await runPushAll(options.hqRoot, options.message, options.onConflict, skips.skipPersonal, skips.skipCompanies);
                 // A plan-limit refusal is not a sync failure, but the push did
                 // not upload everything it was asked to: exit non-zero.
                 if (refused)
@@ -891,6 +909,9 @@ export function registerCloudCommands(program) {
                 catch (e) {
                     throw new Error(`--creds-from-stdin: failed to parse stdin as JSON: ${e instanceof Error ? e.message : String(e)}`);
                 }
+                // Sync switches (US-016): with no --company the target is only
+                // known now. Check it before any login or transfer.
+                assertEntityVaultSyncAllowed("push", entityContext, options.hqRoot);
                 // Upload creds are pre-vended in entityContext, but prefix filtering
                 // still needs vault-service membership/grant resolution.
                 const accessToken = await ensureSyncCognitoToken();
@@ -1085,6 +1106,11 @@ export function registerCloudCommands(program) {
             }
         }
         catch (err) {
+            if (err instanceof VaultSyncOffError) {
+                // Not a sync failure: the target vault is switched off.
+                writeVaultRefusal(err.refusal, { json: jsonMode });
+                process.exit(CLOUD_OFF_EXIT_CODE);
+            }
             if (syncHealth)
                 await syncHealth.failed();
             const message = formatSyncFailure(err);
@@ -1128,6 +1154,12 @@ export function registerCloudCommands(program) {
         "disk and only un-tracked from sync; clean out-of-scope files are " +
         "quarantined under .hq/scope-quarantine/ (recoverable).")
         .action(async (options) => {
+        const skips = refuseSyncForOffVaults("pull", {
+            all: options.all,
+            personal: options.personal,
+            company: options.company,
+            hqRoot: options.hqRoot,
+        });
         try {
             configureSyncLockTimeout(options.lockTimeout);
             assertSingleSelector(options, "pull");
@@ -1140,7 +1172,7 @@ export function registerCloudCommands(program) {
             // `options.personal === false` is Commander's auto-negation of
             // `--personal`; in `--all` mode that means "drop the personal
             // leg from the fanout" (see `--no-personal` option above).
-            await withSyncHealthReport(() => runPullAll(options.hqRoot, options.onConflict, options.modeAll === true, options.personal === false, options.forceScopeShrink === true));
+            await withSyncHealthReport(() => runPullAll(options.hqRoot, options.onConflict, options.modeAll === true, skips.skipPersonal, options.forceScopeShrink === true, skips.skipCompanies));
             return;
         }
         if (options.personal) {
@@ -1352,6 +1384,12 @@ export function registerCloudCommands(program) {
         "anyway. Dirty files are KEPT on disk (only un-tracked); clean " +
         "out-of-scope files are quarantined under .hq/scope-quarantine/.")
         .action(async (options) => {
+        const skips = refuseSyncForOffVaults("now", {
+            all: options.all,
+            personal: options.personal,
+            company: options.company,
+            hqRoot: options.hqRoot,
+        });
         try {
             configureSyncLockTimeout(options.lockTimeout);
             assertSingleSelector(options, "now");
@@ -1360,7 +1398,7 @@ export function registerCloudCommands(program) {
                 // of `--personal`; in `--all` mode that means "drop the
                 // personal leg from both legs of the bidirectional fanout"
                 // (see `--no-personal` option above).
-                await withSyncHealthReport(() => runNowAll(options.hqRoot, options.message, options.onConflict, options.modeAll === true, options.personal === false, options.forceScopeShrink === true));
+                await withSyncHealthReport(() => runNowAll(options.hqRoot, options.message, options.onConflict, options.modeAll === true, skips.skipPersonal, options.forceScopeShrink === true, skips.skipCompanies));
                 return;
             }
             await withSyncHealthReport(() => runNowSingle(options.hqRoot, options.company, options.personal === true, options.message, options.onConflict, options.modeAll === true, options.forceScopeShrink === true));
@@ -1446,13 +1484,19 @@ export async function runSyncDoctorReconcileConflicts(hqRoot, yes) {
         console.log(chalk.dim("  Re-run with --yes to apply the plan above."));
     }
 }
-async function runPullAll(hqRoot, onConflict, modeAllOverride, skipPersonal, forceScopeShrink) {
+/** Banner lines for the vaults an `--all` run leaves out. */
+function logVaultSkips(skipPersonal, skipCompanies) {
+    if (skipPersonal)
+        console.log(`  Personal: skipped (sync is off for it, or --no-personal)`);
+    if (skipCompanies && skipCompanies.size > 0) {
+        console.log(`  Skipped:  ${[...skipCompanies].sort().join(", ")} (sync is off on this computer)`);
+    }
+}
+async function runPullAll(hqRoot, onConflict, modeAllOverride, skipPersonal, forceScopeShrink, skipCompanies) {
     console.log(chalk.bold("\nHQ Sync — Pull (all)"));
     console.log(`  HQ root:  ${hqRoot}`);
     console.log(`  Strategy: ${onConflict ?? "(interactive)"}`);
-    if (skipPersonal) {
-        console.log(`  Personal: skipped (--no-personal)`);
-    }
+    logVaultSkips(skipPersonal, skipCompanies);
     console.log("");
     let result;
     try {
@@ -1480,6 +1524,7 @@ async function runPullAll(hqRoot, onConflict, modeAllOverride, skipPersonal, for
             ...(modeAllOverride ? { modeAllOverride: true } : {}),
             ...(skipPersonal ? { skipPersonal: true } : {}),
             ...(forceScopeShrink ? { forceScopeShrink: true } : {}),
+            ...(skipCompanies && skipCompanies.size > 0 ? { skipCompanies } : {}),
         }, {
             vaultClient: adapter,
             // DEV-1768: resolve each company's REAL pull scope (mode + prefixSet)
@@ -1587,13 +1632,11 @@ export async function runPullPersonal(hqRoot, onConflict) {
  * limit refused across every target (null when none were), so the caller can
  * refuse to report success; hard failures still throw {@link SyncExitError}.
  */
-async function runPushAll(hqRoot, message, onConflict, skipPersonal) {
+async function runPushAll(hqRoot, message, onConflict, skipPersonal, skipCompanies) {
     console.log(chalk.bold("\nHQ Sync — Push (all)"));
     console.log(`  HQ root:  ${hqRoot}`);
     console.log(`  Strategy: ${onConflict ?? "(interactive)"}`);
-    if (skipPersonal) {
-        console.log(`  Personal: skipped (--no-personal)`);
-    }
+    logVaultSkips(skipPersonal, skipCompanies);
     console.log("");
     let result;
     try {
@@ -1618,6 +1661,7 @@ async function runPushAll(hqRoot, message, onConflict, skipPersonal) {
             ...(onConflict ? { onConflict } : {}),
             ...(message ? { message } : {}),
             ...(skipPersonal ? { skipPersonal: true } : {}),
+            ...(skipCompanies && skipCompanies.size > 0 ? { skipCompanies } : {}),
         }, {
             vaultClient: adapter,
             resolveScope: (companyUid, slug) => resolvePullScope(realClient, companyUid, slug, hqRoot),
@@ -1998,24 +2042,22 @@ async function runNowSingle(hqRoot, company, personal, message, onConflict, mode
         throw new SyncExitError(1);
     }
 }
-async function runNowAll(hqRoot, message, onConflict, modeAllOverride, skipPersonal, forceScopeShrink) {
+async function runNowAll(hqRoot, message, onConflict, modeAllOverride, skipPersonal, forceScopeShrink, skipCompanies) {
     console.log(chalk.bold("\nHQ Sync — Now (all)"));
     console.log(`  HQ root:  ${hqRoot}`);
     console.log(`  Strategy: ${onConflict ?? "(interactive)"}`);
-    if (skipPersonal) {
-        console.log(`  Personal: skipped (--no-personal)`);
-    }
+    logVaultSkips(skipPersonal, skipCompanies);
     console.log("");
     // Push first (matches runner), then pull. Re-uses the per-leg orchestrators
     // so the per-target rendering, error isolation, and exit codes are
     // identical to running `push --all` then `pull --all` back-to-back.
     console.log(chalk.dim("→ push --all"));
-    const refused = await runPushAll(hqRoot, message, onConflict, skipPersonal);
+    const refused = await runPushAll(hqRoot, message, onConflict, skipPersonal, skipCompanies);
     console.log(chalk.dim("\n→ pull --all"));
     // US-011: forward --mode-all so the strict refusal applies to the
     // pull leg (push doesn't need a narrow-hint — the narrow ritual is
     // pull-side).
-    await runPullAll(hqRoot, onConflict, modeAllOverride, skipPersonal, forceScopeShrink);
+    await runPullAll(hqRoot, onConflict, modeAllOverride, skipPersonal, forceScopeShrink, skipCompanies);
     if (refused) {
         // A refused push does not stop the pull, but the run must not end looking
         // like a clean sync. Its per-target details were printed above.

package/dist/commands/core-handoff.js

@@ -13,6 +13,7 @@ import { defaultBackgroundDependencies, runBackgroundLauncher, } from "../lib/se
 import { resolveLiveRoot } from "../utils/hq-roots.js";
 import { runBundledScript } from "../utils/run-bundled-script.js";
 import { describeCoreCommand } from "./core-command-catalog.js";
+import { CLOUD_OFF_EXIT_CODE } from "./cloud-off-gate.js";
 import { shellDisplayPath } from "../lib/core-utils/shell-display-path.js";
 import { fingerprintTrailerArgs, offlineFingerprint } from "../lib/fingerprint/offline.js";
 import { compactJson, isRecord, jqTruthy, prettyJson, runHandoffOpenSteps, shellDate, } from "./core-handoff-open-steps.js";
@@ -1057,7 +1058,11 @@ export function runHandoffPostWorker(args, context) {
                 stdout: typeof pushed.stdout === "string" ? pushed.stdout : "",
                 stderr: typeof pushed.stderr === "string" ? pushed.stderr : "",
             });
-            log(pushed.status === 0 ? `workspace-sync: pushed companies/${company}/workspace` : `workspace-sync: failed companies/${company}/workspace`);
+            log(pushed.status === 0
+                ? `workspace-sync: pushed companies/${company}/workspace`
+                : pushed.status === CLOUD_OFF_EXIT_CODE
+                    ? `workspace-sync: skipped (sync is off) companies/${company}/workspace`
+                    : `workspace-sync: failed companies/${company}/workspace`);
         }
     }
     else if (threadFile && fs.existsSync(threadFile))

package/dist/commands/meetings.js

@@ -658,9 +658,13 @@ export function registerMeetingsCommand(program) {
         try {
             const token = await ensureCognitoToken();
             const companySlug = meetings.opts().company;
-            const query = {};
-            if (companySlug)
-                query.companyId = await getCompanyUid(token, companySlug);
+            // Always name a company. With no companyId the backend files the bot
+            // under Personal, which can never record, so an entitled user would
+            // get the HQ Workforce upgrade prompt. Without --company this uses the
+            // caller's only active company, or asks them to pick one.
+            const query = {
+                companyId: await getCompanyUid(token, companySlug),
+            };
             const res = await vaultApiFetch({
                 token,
                 method: "POST",

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

@@ -13,6 +13,7 @@ import type { MachineType } from "./machine-type.js";
 import type { SyncOwner } from "./config.js";
 import type { RemoteControlPoolsConfig } from "./remote-control-pools.js";
 import { type SyncRunnerProcess } from "./sync-runner.js";
+import { type VaultSyncSwitches } from "../vault-sync-switches.js";
 export declare const SERVICE_NAMES: readonly ["sync", "mesh", "heartbeat", "inbox", "bots", "remote-control", "codex-remote-control", "session-host", "lanes-reconcile", "search-index", "jobs-reconcile", "updater", "housekeeping"];
 export type ServiceName = (typeof SERVICE_NAMES)[number];
 export declare function isServiceName(value: unknown): value is ServiceName;
@@ -103,6 +104,12 @@ export interface PlanContext {
     instantSyncEnabled?: boolean;
     /** Keep the local sync runner stopped until the operator resumes it. */
     syncPaused: boolean;
+    /**
+     * The desktop app's Settings > Sync switches on this computer (US-016).
+     * Off vaults are skipped by the runner; all off keeps the unit stopped.
+     * Absent means every vault is on.
+     */
+    vaultSync?: VaultSyncSwitches;
     /** Persisted/effective owner selected for this machine. */
     syncOwner: SyncOwner;
     /** A legacy desktop app or sync unit is still managing sync. */

package/dist/lib/daemon/catalog.js

@@ -10,6 +10,7 @@
  * them instead of silently dropping them.
  */
 import { SYNC_RUNNER_OWNER, syncRunnerUnleasedBlockReason } from "./sync-runner.js";
+import { vaultSkipEnv } from "../vault-sync-switches.js";
 export const SERVICE_NAMES = [
     "sync",
     "mesh",
@@ -142,7 +143,11 @@ function planService(service, ctx) {
                         SYNC_RUNNER_OWNER,
                     ],
                 },
-                env: { ...ctx.legacySyncEnv, HQ_SYNC_PASS_REQUEST_DIR: ctx.syncPassRequestsDir },
+                env: {
+                    ...ctx.legacySyncEnv,
+                    ...(ctx.vaultSync ? vaultSkipEnv(ctx.vaultSync) : {}),
+                    HQ_SYNC_PASS_REQUEST_DIR: ctx.syncPassRequestsDir,
+                },
                 heartbeatTimeoutMs: ctx.syncHeartbeatTimeoutMs,
             });
             let ownerBlock;
@@ -160,6 +165,10 @@ function planService(service, ctx) {
             }
             unit.blocked = firstBlock([
                 [ctx.syncPaused, "sync is paused (run `hq daemon sync resume`)"],
+                [
+                    ctx.vaultSync?.allOff === true,
+                    "cloud sync is off for every vault on this computer (turn it back on in HQ Settings > Sync)",
+                ],
                 [!ctx.hqRoot, NO_HQ_ROOT],
                 [!ctx.signedIn, NOT_SIGNED_IN],
                 [!!ownerBlock, ownerBlock ?? ""],

package/dist/lib/daemon/run.js

@@ -32,6 +32,7 @@ import { DAEMON_CHILD_BOOTSTRAP_HANDOFF_WATCH_FLAG, DAEMON_LANES_RECONCILE_FILE_
 import { createLanesReconcileWatcher } from "./lanes-reconcile-watcher.js";
 import { findLegacyUnits, legacyMeshUnitsToRetire, legacyOwnerLookup } from "./legacy.js";
 import { readLegacySyncEnv } from "./legacy-sync-env.js";
+import { readVaultSyncSwitches, unreadableSwitchesWarning } from "../vault-sync-switches.js";
 import { acquireDaemonLock, isProcessAlive, processCommandLine, releaseDaemonLock } from "./lock.js";
 import { retireLegacyMeshUnits } from "./migrate.js";
 import { daemonDir as meshDaemonDir, daemonPidPath as meshDaemonPidPath } from "../mesh/live/daemon/paths.js";
@@ -581,6 +582,8 @@ export async function runDaemon(opts) {
         finishSuccession(succession, tracker.records(), log);
     /** Service processes this daemon spawned, so a handoff can let go of them. */
     const spawned = new Set();
+    /** Last unreadable-settings warning logged, so it is logged once per change. */
+    let lastVaultSyncWarning;
     const updatable = cliSelfUpdatable();
     const hostName = os.hostname().split(".")[0] || "hq-host";
     let legacyCache = null;
@@ -949,6 +952,16 @@ export async function runDaemon(opts) {
             signedIn: isSignedIn,
             kitConfigured: fs.existsSync(agentKitPaths(home, env).kitConfigPath),
             syncPaused: config.syncPaused === true,
+            vaultSync: (() => {
+                const switches = readVaultSyncSwitches(home);
+                // Log once per change, not every reconcile.
+                if (switches.unreadable !== lastVaultSyncWarning) {
+                    if (switches.unreadable)
+                        log("warn", unreadableSwitchesWarning(switches.unreadable));
+                    lastVaultSyncWarning = switches.unreadable;
+                }
+                return switches;
+            })(),
             syncOwner,
             desktopAppManagesSync: appManagesSync,
             syncRunnerProcesses,

package/dist/lib/lanes/links.js

@@ -267,28 +267,44 @@ function hookMessage(root, pointer) {
         throw new LaneLinkError("link_pointer_invalid", "Child link pointer has no child name");
     return { inbox: queueDir(root, pointer.link, pointer.name), role: "child", child: pointer.name };
 }
+// Same markers as core's conduct-lanes-link-deliver.sh. A parent session id
+// alone is not one: resumed, forked, or launcher-spawned Grok roots carry it,
+// and Grok marks its real children with subagent_type.
+function isChildHookPayload(payload) {
+    const nonEmpty = (...keys) => keys.some((key) => typeof payload[key] === "string" && payload[key].length > 0);
+    if (["agent_id", "agentId"].some((key) => payload[key] !== undefined && payload[key] !== null && payload[key] !== ""))
+        return true;
+    if (nonEmpty("parent_thread_id", "parentThreadId", "agent_transcript_path", "agentTranscriptPath", "subagent_type", "subagentType"))
+        return true;
+    const transcript = payload.transcript_path ?? payload.transcriptPath;
+    return typeof transcript === "string" && /[/\\]subagents[/\\][^/\\]+\.jsonl$/.test(transcript);
+}
 export async function runLaneLink(subcommand, options) {
     const now = options.now ?? (() => new Date());
     const env = options.env ?? process.env;
     const root = options.hqRoot;
     let sid = "";
+    let childContext = false;
     if (subcommand === "_deliver") {
-        sid = (() => {
-            let payload = {};
-            try {
-                payload = JSON.parse(options.input ?? "{}");
-            }
-            catch { /* malformed hooks are inert */ }
-            const value = payload.session_id ?? payload.sessionId;
-            return typeof value === "string" && safeId(value) ? value : "";
-        })();
+        let payload = {};
+        try {
+            const parsed = JSON.parse(options.input ?? "{}");
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+                payload = parsed;
+        }
+        catch { /* malformed hooks are inert */ }
+        const value = payload.session_id ?? payload.sessionId;
+        sid = typeof value === "string" && safeId(value) ? value : "";
+        childContext = isChildHookPayload(payload);
     }
     const requireSid = () => sid || (sid = resolveLinkSessionId(root, options.sessionId, env));
     const links = rootDir(root);
     if (subcommand === "_deliver") {
-        if (!sid || !["PostToolUse", "Stop", "SubagentStop"].includes(options.event ?? ""))
+        // Subagent hook events carry the parent's session_id. Delivering there would
+        // drain the root's queue into the subagent, so leave the message queued.
+        if (!sid || childContext || !["PostToolUse", "Stop"].includes(options.event ?? ""))
             return {};
-        if (["Stop", "SubagentStop"].includes(options.event ?? "") && env.HQ_STOP_DECISION_DELIVERABLE === "0")
+        if (options.event === "Stop" && env.HQ_STOP_DECISION_DELIVERABLE === "0")
             return {};
         const pointer = readPointer(root, sid);
         if (!pointer)

package/dist/lib/vault-sync-switches.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The HQ app's Settings > Sync switches on this computer (usage-only-pricing
+ * US-016), read from the desktop settings file (`menubar.json` in the HQ state
+ * directory):
+ *
+ * - `cloudPaused: true` turns sync off for every vault;
+ * - `personalSyncEnabled: false` turns the personal vault off;
+ * - `workspaceSyncEnabled: { "<slug>": false }` turns one company vault off.
+ *
+ * Dependency-free on purpose (node:fs/os/path only): the `hq daemon` planner
+ * reads it every reconcile.
+ *
+ * A missing file, a missing key, or a value of the wrong type means on, so
+ * CLI-only installs and agent boxes keep syncing. A file that exists but
+ * cannot be read or parsed also means on, and is reported through
+ * `unreadable` so callers can warn instead of turning sync back on silently.
+ */
+export interface VaultSyncSwitches {
+    /** "Turn off all cloud sync" is on. */
+    allOff: boolean;
+    /** The personal vault's switch is off. */
+    personalOff: boolean;
+    /** Lowercased slugs of company vaults whose switch is off. */
+    offCompanies: ReadonlySet<string>;
+    /**
+     * Set when the settings file exists but could not be read or parsed. Every
+     * switch then reads as on; callers should warn.
+     */
+    unreadable?: string;
+}
+export declare function vaultSyncSettingsPath(home?: string): string;
+/** Read every switch. Never throws. */
+export declare function readVaultSyncSwitches(home?: string): VaultSyncSwitches;
+/** The warning printed when the settings file is unreadable. */
+export declare function unreadableSwitchesWarning(reason: string): string;
+/**
+ * Environment for an hq-cloud sync runner so it skips off vaults
+ * (`HQ_SYNC_SKIP_COMPANIES`, `HQ_SYNC_SKIP_PERSONAL`). Empty when all are on.
+ */
+export declare function vaultSkipEnv(switches: VaultSyncSwitches): Record<string, string>;
+//# sourceMappingURL=vault-sync-switches.d.ts.map

package/dist/lib/vault-sync-switches.js

@@ -0,0 +1,86 @@
+/**
+ * The HQ app's Settings > Sync switches on this computer (usage-only-pricing
+ * US-016), read from the desktop settings file (`menubar.json` in the HQ state
+ * directory):
+ *
+ * - `cloudPaused: true` turns sync off for every vault;
+ * - `personalSyncEnabled: false` turns the personal vault off;
+ * - `workspaceSyncEnabled: { "<slug>": false }` turns one company vault off.
+ *
+ * Dependency-free on purpose (node:fs/os/path only): the `hq daemon` planner
+ * reads it every reconcile.
+ *
+ * A missing file, a missing key, or a value of the wrong type means on, so
+ * CLI-only installs and agent boxes keep syncing. A file that exists but
+ * cannot be read or parsed also means on, and is reported through
+ * `unreadable` so callers can warn instead of turning sync back on silently.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+export function vaultSyncSettingsPath(home = os.homedir()) {
+    return path.join(home, ".hq", "menubar.json");
+}
+function allOn(unreadable) {
+    return {
+        allOff: false,
+        personalOff: false,
+        offCompanies: new Set(),
+        ...(unreadable ? { unreadable } : {}),
+    };
+}
+/** Read every switch. Never throws. */
+export function readVaultSyncSwitches(home = os.homedir()) {
+    const file = vaultSyncSettingsPath(home);
+    let text;
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch (err) {
+        if (err?.code === "ENOENT")
+            return allOn();
+        return allOn(`could not read ${file}`);
+    }
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch {
+        return allOn(`${file} is not valid JSON`);
+    }
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        return allOn(`${file} is not a JSON object`);
+    }
+    const prefs = raw;
+    const offCompanies = new Set();
+    const map = prefs.workspaceSyncEnabled;
+    if (typeof map === "object" && map !== null && !Array.isArray(map)) {
+        for (const [slug, enabled] of Object.entries(map)) {
+            if (enabled === false && slug.trim())
+                offCompanies.add(slug.trim().toLowerCase());
+        }
+    }
+    return {
+        allOff: prefs.cloudPaused === true,
+        personalOff: prefs.personalSyncEnabled === false,
+        offCompanies,
+    };
+}
+/** The warning printed when the settings file is unreadable. */
+export function unreadableSwitchesWarning(reason) {
+    return `Warning: ${reason}, so HQ cannot tell which vaults have sync turned off on this computer. Every vault will sync. Fix or remove the file, or set the switches again in HQ Settings > Sync.`;
+}
+/**
+ * Environment for an hq-cloud sync runner so it skips off vaults
+ * (`HQ_SYNC_SKIP_COMPANIES`, `HQ_SYNC_SKIP_PERSONAL`). Empty when all are on.
+ */
+export function vaultSkipEnv(switches) {
+    const env = {};
+    if (switches.offCompanies.size > 0) {
+        env.HQ_SYNC_SKIP_COMPANIES = [...switches.offCompanies].sort().join(",");
+    }
+    if (switches.personalOff)
+        env.HQ_SYNC_SKIP_PERSONAL = "1";
+    return env;
+}
+//# sourceMappingURL=vault-sync-switches.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.345.150",
+  "version": "5.345.151",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {
@@ -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.150",
-    "@indigoai-us/hq-hook-win32-arm64": "5.345.150",
-    "@indigoai-us/hq-hook-darwin-x64": "5.345.150",
-    "@indigoai-us/hq-hook-darwin-arm64": "5.345.150",
-    "@indigoai-us/hq-hook-linux-x64": "5.345.150",
-    "@indigoai-us/hq-hook-linux-arm64": "5.345.150"
+    "@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"
   }
 }