@indigoai-us/hq-cli 5.265.0 → 5.267.0

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## [Unreleased]
 
+## [5.267.0] — 2026-09-28
+
+- Company billing links opened by CLI plan-limit flows now carry cli_limit attribution into checkout telemetry.
+
+### Fixed
+
+- Local bots now read the idle inbox backoff flag with a 2 s budget. The
+  150 ms budget timed out from home networks, so bots kept polling every 2 s
+  even when the flag was on for them.
+
+## [5.266.0] — 2026-09-28
+
+### Added
+
+- `hq daemon run --host desktop` lets the HQ desktop app run the daemon as its
+  own child process. The daemon then runs sync even though the app is open, and
+  records the app as its host in `state.json`. Older per-service installers
+  such as `hq mesh daemon install` treat a hosted daemon as installed and hand
+  their service to it.
+
 ## [5.265.0] — 2026-09-28
 
 ### Added

package/dist/command-catalog.generated.d.ts

@@ -8978,6 +8978,9 @@ export declare const COMMAND_CATALOG: readonly [{
         }, {
             readonly flags: "--managed";
             readonly description: "Started by the OS unit, which starts the daemon again whenever it exits";
+        }, {
+            readonly flags: "--host <app>";
+            readonly description: "Run as a child of this app (only \"desktop\"), which has handed sync over to the daemon";
         }];
         readonly subcommands: readonly [];
     }, {

package/dist/command-catalog.generated.js

@@ -11611,6 +11611,10 @@ export const COMMAND_CATALOG = [
                     {
                         "flags": "--managed",
                         "description": "Started by the OS unit, which starts the daemon again whenever it exits"
+                    },
+                    {
+                        "flags": "--host <app>",
+                        "description": "Run as a child of this app (only \"desktop\"), which has handed sync over to the daemon"
                     }
                 ],
                 "subcommands": []

package/dist/commands/daemon.d.ts

@@ -15,6 +15,7 @@
  */
 import type { Command } from "commander";
 import { type LegacyUnit } from "../lib/daemon/legacy.js";
+import type { HostApp } from "../lib/daemon/supervisor.js";
 import type { RunCommand } from "../lib/service-manager/launchd.js";
 export interface DaemonCommandDeps {
     env: NodeJS.ProcessEnv;
@@ -46,6 +47,8 @@ export interface DaemonCommandDeps {
  * (HQ_ROOT, the tree around the current folder, the folder the installer or
  * menubar recorded, the well-known locations). Undefined when none resolves.
  */
+/** Validate `hq daemon run --host`; the desktop app is the only host. */
+export declare function parseDaemonHost(value: string | undefined): HostApp | undefined;
 export declare function resolveDaemonHqRoot(flag: string | undefined, where: {
     env: NodeJS.ProcessEnv;
     cwd: string;

package/dist/commands/daemon.js

@@ -36,6 +36,14 @@ class DaemonCommandError extends Error {
  * (HQ_ROOT, the tree around the current folder, the folder the installer or
  * menubar recorded, the well-known locations). Undefined when none resolves.
  */
+/** Validate `hq daemon run --host`; the desktop app is the only host. */
+export function parseDaemonHost(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === "desktop")
+        return value;
+    throw new Error(`--host must be "desktop" (got "${value}")`);
+}
 export function resolveDaemonHqRoot(flag, where) {
     if (flag)
         return path.resolve(flag);
@@ -574,13 +582,16 @@ export function registerDaemonCommand(program, over = {}) {
         .option("--foreground", "Also print the supervisor log to the terminal")
         .option("--daemon-dir <path>", "Use this folder instead of ~/.hq/daemon (how the Windows task passes HQ_DAEMON_DIR)")
         .option("--managed", "Started by the OS unit, which starts the daemon again whenever it exits")
+        .option("--host <app>", "Run as a child of this app (only \"desktop\"), which has handed sync over to the daemon")
         .action(wrap(async (d, opts) => {
+        const host = parseDaemonHost(opts.host);
         const { runDaemon } = await import("../lib/daemon/run.js");
         // Services inherit this environment, so they see the same folder.
         const env = opts.daemonDir ? { ...d.env, HQ_DAEMON_DIR: opts.daemonDir } : d.env;
         process.exitCode = await runDaemon({
             foreground: opts.foreground,
             managed: opts.managed,
+            host,
             home: d.home,
             env,
             nodeBinary: d.nodeBinary,

package/dist/lib/billing/plan-limit-upgrade-url.d.ts

@@ -6,8 +6,9 @@ export interface PlanLimitUpgradeUrlChoices {
     legacyUrl: string;
 }
 export declare function isPlanLimitUpgradeFallbackEnabled(): boolean;
-/** Resolve a server URL without changing legacy behavior while the flag is off. */
+/** Resolve and attribute the final selected company billing destination. */
 export declare function selectPlanLimitUpgradeUrl(companySlug: string | undefined, choices: PlanLimitUpgradeUrlChoices): string;
-/** Keep a caller's previous URL until the hq-flags rollout is enabled. */
+export declare function withCliLimitEntrySurface(value: string): string;
+/** Keep the existing destination and flag behavior while labeling company limit links. */
 export declare function planLimitUpgradeFallbackUrl(companySlug: string | undefined, previousFallbackUrl: string): string;
 //# sourceMappingURL=plan-limit-upgrade-url.d.ts.map

package/dist/lib/billing/plan-limit-upgrade-url.js

@@ -13,23 +13,62 @@ function companyBillingUrl(companySlug) {
         return null;
     const slug = companySlug?.trim();
     const route = slug
-        ? `/companies/${encodeURIComponent(slug)}/billing?upgrade=1`
+        ? `/companies/${encodeURIComponent(slug)}/billing?upgrade=1&entrySurface=cli_limit`
         : "/billing";
     return `${origin}${route}`;
 }
-/** Resolve a server URL without changing legacy behavior while the flag is off. */
+/** Resolve and attribute the final selected company billing destination. */
 export function selectPlanLimitUpgradeUrl(companySlug, choices) {
-    if (!isPlanLimitUpgradeFallbackEnabled())
-        return choices.legacyUrl;
-    const topLevelUrl = choices.topLevelUrl?.trim() || undefined;
-    const nestedUrl = choices.nestedUrl?.trim() || undefined;
-    const generatedUrl = companyBillingUrl(companySlug);
-    if (companySlug?.trim()) {
-        return generatedUrl ?? topLevelUrl ?? nestedUrl ?? choices.legacyUrl;
+    let selected;
+    if (!isPlanLimitUpgradeFallbackEnabled()) {
+        selected = choices.legacyUrl;
     }
-    return topLevelUrl ?? nestedUrl ?? generatedUrl ?? choices.legacyUrl;
+    else {
+        const topLevelUrl = choices.topLevelUrl?.trim() || undefined;
+        const nestedUrl = choices.nestedUrl?.trim() || undefined;
+        const generatedUrl = companyBillingUrl(companySlug);
+        if (companySlug?.trim()) {
+            selected = generatedUrl ?? topLevelUrl ?? nestedUrl ?? choices.legacyUrl;
+        }
+        else {
+            selected = topLevelUrl ?? nestedUrl ?? generatedUrl ?? choices.legacyUrl;
+        }
+    }
+    return withCliLimitEntrySurface(selected);
+}
+export function withCliLimitEntrySurface(value) {
+    try {
+        const url = new URL(value);
+        if (url.protocol !== "https:" || url.username || url.password)
+            return value;
+        const callbackUrl = url.searchParams.get("callbackUrl");
+        if (callbackUrl) {
+            const callback = new URL(callbackUrl, url.origin);
+            const parts = callback.pathname.split("/").filter(Boolean);
+            if (parts.length === 5 && parts[0] === "api" && parts[1] === "companies" &&
+                /^cmp_[A-Za-z0-9_-]+$/.test(parts[2]) && parts[3] === "billing" && parts[4] === "upgrade") {
+                callback.searchParams.set("entrySurface", "cli_limit");
+                const serializedCallback = /^[a-z][a-z0-9+.-]*:/i.test(callbackUrl)
+                    ? callback.toString()
+                    : callbackUrl.startsWith("//")
+                        ? `//${callback.host}${callback.pathname}${callback.search}${callback.hash}`
+                        : `${callback.pathname}${callback.search}${callback.hash}`;
+                url.searchParams.set("callbackUrl", serializedCallback);
+                return url.toString();
+            }
+        }
+        const parts = url.pathname.split("/").filter(Boolean);
+        if (parts.length === 3 && parts[0] === "companies" && parts[2] === "billing") {
+            url.searchParams.set("entrySurface", "cli_limit");
+            return url.toString();
+        }
+    }
+    catch {
+        return value;
+    }
+    return value;
 }
-/** Keep a caller's previous URL until the hq-flags rollout is enabled. */
+/** Keep the existing destination and flag behavior while labeling company limit links. */
 export function planLimitUpgradeFallbackUrl(companySlug, previousFallbackUrl) {
     return selectPlanLimitUpgradeUrl(companySlug, {
         legacyUrl: previousFallbackUrl,

package/dist/lib/bot/inbox-poll-backoff-flag.d.ts

@@ -2,7 +2,7 @@ import { type FlagClient, type FlagClientOptions } from "@indigoai-us/hq-flags-c
 import { type BotConfig } from "./config.js";
 export declare const INBOX_POLL_BACKOFF_FLAG = "agents.inbox-poll-backoff-local-cli";
 export declare const INBOX_POLL_BACKOFF_FLAG_FALLBACK = false;
-export declare const INBOX_POLL_BACKOFF_FLAG_TIMEOUT_MS = 150;
+export declare const INBOX_POLL_BACKOFF_FLAG_TIMEOUT_MS = 2000;
 export declare const INBOX_POLL_BACKOFF_FLAG_CACHE_MS: number;
 type InboxPollBackoffFlagClient = Pick<FlagClient, "ready" | "isEnabled" | "close">;
 export interface InboxPollBackoffFlagReaderDependencies {

package/dist/lib/bot/inbox-poll-backoff-flag.js

@@ -5,7 +5,10 @@ import { resolveFlagRegistryEndpoint } from "../flag-registry-endpoint.js";
 import { effectiveBotCompanies, effectiveBotKind } from "./config.js";
 export const INBOX_POLL_BACKOFF_FLAG = "agents.inbox-poll-backoff-local-cli";
 export const INBOX_POLL_BACKOFF_FLAG_FALLBACK = false;
-export const INBOX_POLL_BACKOFF_FLAG_TIMEOUT_MS = 150;
+// One read every three minutes on a fresh connection. From a home network the
+// TCP and TLS handshakes plus the resolve call take about 250-400 ms, so a
+// 150 ms budget timed out on every read and kept the gate off.
+export const INBOX_POLL_BACKOFF_FLAG_TIMEOUT_MS = 2_000;
 export const INBOX_POLL_BACKOFF_FLAG_CACHE_MS = 3 * 60_000;
 const COMPANY_UID_RE = /^cmp_[A-Za-z0-9]{3,128}$/;
 export function safeErrorClass(error) {

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

@@ -24,6 +24,8 @@ export declare function daemonRunsService(paths: DaemonPaths, service: ServiceNa
 export declare function askDaemonToStart(paths: DaemonPaths, unitId: string): void;
 /** Ask the running daemon to stop a unit and keep it down until it is started again. */
 export declare function askDaemonToStop(paths: DaemonPaths, unitId: string): void;
+/** A live daemon runs as the desktop app's child, which counts as installed even though no OS unit exists. */
+export declare function hostedDaemonRunning(paths: DaemonPaths, alive?: (pid: number) => boolean): boolean;
 export interface DaemonUnitHost {
     platform: NodeJS.Platform;
     home: string;

package/dist/lib/daemon/handoff.js

@@ -67,6 +67,15 @@ export function askDaemonToStart(paths, unitId) {
 export function askDaemonToStop(paths, unitId) {
     writeControlRequest(paths.requestsDir, { action: "stop", unit: unitId });
 }
+/** A live daemon runs as the desktop app's child, which counts as installed even though no OS unit exists. */
+export function hostedDaemonRunning(paths, alive = (pid) => isDaemonProcess(pid)) {
+    try {
+        return liveState(paths, alive)?.host === "desktop";
+    }
+    catch {
+        return false;
+    }
+}
 /** The `hq daemon` OS unit is installed on this machine (for this user, or as the box's system unit). */
 export function daemonUnitInstalled(host) {
     switch (host.platform) {
@@ -114,14 +123,14 @@ export function handOffInstall(opts) {
 /** handOffInstall for this machine and user, for the older install commands. */
 export function handOffInstallHere(services, env = process.env, opts = {}) {
     const home = os.homedir();
+    const paths = daemonPaths(home, env);
     const installed = daemonUnitInstalled({
         platform: process.platform,
         home,
         windowsTaskExists: (task) => spawnSync("schtasks.exe", ["/Query", "/TN", task], { encoding: "utf8", windowsHide: true }).status === 0,
-    });
+    }) || hostedDaemonRunning(paths);
     if (!installed)
         return null;
-    const paths = daemonPaths(home, env);
     const config = readDaemonConfig(paths.configPath);
     const machineType = detectMachineType(undefined, {
         platform: process.platform,

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

@@ -7,6 +7,8 @@
  */
 import { type UnitPlan } from "./catalog.js";
 import { type LegacyUnit } from "./legacy.js";
+import { type MachineType } from "./machine-type.js";
+import { type HostApp } from "./supervisor.js";
 export declare const LOG_ROTATE_BYTES: number;
 /** Exit code for "restart me": non-zero so every service manager relaunches (Windows tasks only restart on failure). */
 export declare const RESTART_EXIT_CODE = 75;
@@ -14,6 +16,8 @@ export interface RunDaemonOptions {
     foreground?: boolean;
     /** Started by the OS unit, which relaunches the daemon whenever it exits. */
     managed?: boolean;
+    /** The app that runs this daemon as its child (it relaunches the daemon on RESTART_EXIT_CODE when also managed). */
+    host?: HostApp;
     home?: string;
     env?: NodeJS.ProcessEnv;
     nodeBinary: string;
@@ -35,6 +39,21 @@ export declare function findUserBinary(name: string, env: NodeJS.ProcessEnv, hom
 export declare function cliSelfUpdatable(): boolean;
 /** The HQ desktop app process is running here (it runs its own sync). */
 export declare function desktopAppRunning(platform: NodeJS.Platform): boolean;
+/** A parent (the OS unit, or the app hosting the daemon) starts the daemon again after it exits with RESTART_EXIT_CODE. */
+export declare function restartsForParent(opts: {
+    managed?: boolean;
+    host?: HostApp;
+}): boolean;
+/**
+ * The desktop app runs sync itself, so the daemon's sync unit waits. When the
+ * app hosts the daemon it has handed sync over, and the daemon runs it.
+ */
+export declare function desktopAppManagesSync(opts: {
+    machineType: MachineType;
+    host?: HostApp;
+    legacy: readonly LegacyUnit[];
+    appRunning: () => boolean;
+}): boolean;
 /** Copy-and-truncate, so children appending with O_APPEND keep writing to the live file. */
 export declare function rotateLogs(logsDir: string, maxBytes?: number): number;
 /**

package/dist/lib/daemon/run.js

@@ -133,6 +133,19 @@ export function desktopAppRunning(platform) {
     const r = spawnSync("pgrep", ["-x", "hq-sync-menubar"], { encoding: "utf8" });
     return r.status === 0;
 }
+/** A parent (the OS unit, or the app hosting the daemon) starts the daemon again after it exits with RESTART_EXIT_CODE. */
+export function restartsForParent(opts) {
+    return opts.managed === true || opts.host !== undefined;
+}
+/**
+ * The desktop app runs sync itself, so the daemon's sync unit waits. When the
+ * app hosts the daemon it has handed sync over, and the daemon runs it.
+ */
+export function desktopAppManagesSync(opts) {
+    if (opts.machineType !== "desktop" || opts.host === "desktop")
+        return false;
+    return opts.legacy.some((u) => u.service === "sync" && !u.migratable) || opts.appRunning();
+}
 function jobsReconcileScript(hqRoot) {
     if (!hqRoot)
         return null;
@@ -231,7 +244,8 @@ export async function runDaemon(opts) {
         releaseDaemonLock(paths.lockPath);
         return 1;
     }
-    log("info", `starting hq daemon (pid ${process.pid}) as ${machineType} (${detected.detail})`);
+    const hostNote = opts.host ? `, hosted by the ${opts.host} app` : "";
+    log("info", `starting hq daemon (pid ${process.pid}) as ${machineType} (${detected.detail})${hostNote}`);
     if (!resolveSyncRunnerPath())
         log("warn", "the hq-cloud sync runner was not found in this CLI install; sync is unavailable");
     const updatable = cliSelfUpdatable();
@@ -270,8 +284,12 @@ export async function runDaemon(opts) {
             legacySyncEnv: readLegacySyncEnv(platform),
             signedIn: signedIn(env, home, log),
             kitConfigured: fs.existsSync(agentKitPaths(home, env).kitConfigPath),
-            desktopAppManagesSync: machineType === "desktop" &&
-                (legacy.some((u) => u.service === "sync" && !u.migratable) || desktopAppRunning(platform)),
+            desktopAppManagesSync: desktopAppManagesSync({
+                machineType,
+                host: opts.host,
+                legacy,
+                appRunning: () => desktopAppRunning(platform),
+            }),
             bots: listLocalBots(),
             legacyOwner: legacyOwnerLookup(legacy),
             cliSelfUpdatable: updatable,
@@ -312,6 +330,7 @@ export async function runDaemon(opts) {
     let restartDaemon = () => { };
     const supervisor = createSupervisor({
         machineType,
+        host: opts.host,
         pid: process.pid,
         plan,
         spawn: spawnUnit,
@@ -352,7 +371,7 @@ export async function runDaemon(opts) {
             });
         };
         restartDaemon = () => {
-            if (!opts.managed) {
+            if (!restartsForParent(opts)) {
                 log("warn", "a restart was requested, but no service manager would start this daemon again; restart it yourself");
                 return;
             }

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

@@ -50,16 +50,21 @@ export interface UnitState {
     nextRunAt?: number;
     lastResult?: "ok" | "failed";
 }
+/** An app that runs the daemon as its own child process instead of an OS unit. */
+export type HostApp = "desktop";
 export interface DaemonState {
     version: 1;
     pid: number;
     startedAt: number;
     updatedAt: number;
     machineType: MachineType;
+    /** Set when an app runs the daemon as its child; absent under the OS unit. */
+    host?: HostApp;
     units: UnitState[];
 }
 export interface SupervisorDeps {
     machineType: MachineType;
+    host?: HostApp;
     pid: number;
     plan: () => UnitPlan[];
     spawn: (unit: UnitPlan) => SupervisedChild;

package/dist/lib/daemon/supervisor.js

@@ -52,6 +52,7 @@ export function createSupervisor(deps) {
         startedAt,
         updatedAt: now(),
         machineType: deps.machineType,
+        ...(deps.host ? { host: deps.host } : {}),
         units: [...slots.values()].map((s) => ({ ...s.state })),
     });
     const emit = () => {

package/dist/utils/plan-gate-error.js

@@ -4,6 +4,7 @@
  * message instead of every command parsing and printing a server response.
  */
 import { renderPersonalPlanFeatureNotice } from "../lib/plan-limit-nag.js";
+import { withCliLimitEntrySurface } from "../lib/billing/plan-limit-upgrade-url.js";
 function planGateReason(code, details) {
     if (details.reason?.trim())
         return details.reason.trim();
@@ -27,11 +28,12 @@ function planGateReason(code, details) {
 /** One renderer for server-selected upgrade links across CLI plan refusals. */
 export function formatUpgradeRefusal(reason, upgradeUrl, options = {}) {
     const safeUrl = safeUpgradeUrl(upgradeUrl);
-    if (options.urlOnly && safeUrl)
-        return safeUrl;
-    if (!safeUrl)
+    const cliLimitUrl = safeUrl ? withCliLimitEntrySurface(safeUrl) : undefined;
+    if (options.urlOnly && cliLimitUrl)
+        return cliLimitUrl;
+    if (!cliLimitUrl)
         return reason;
-    return `${reason}\nUpgrade: ${safeUrl}`;
+    return `${reason}\nUpgrade: ${cliLimitUrl}`;
 }
 function safeUpgradeUrl(value) {
     if (typeof value !== "string" ||
@@ -94,6 +96,7 @@ export async function offerUpgradeLink(url, deps = {}) {
     const safeUrl = safeUpgradeUrl(url);
     if (!safeUrl)
         return false;
+    const cliLimitUrl = withCliLimitEntrySurface(safeUrl);
     if (!(deps.interactive ?? canOfferTeamUpgrade(deps.argv)))
         return false;
     let answer;
@@ -113,11 +116,11 @@ export async function offerUpgradeLink(url, deps = {}) {
     if (!/^y(?:es)?$/i.test(answer.trim()))
         return false;
     if (deps.openUrl) {
-        await deps.openUrl(safeUrl);
+        await deps.openUrl(cliLimitUrl);
     }
     else {
         const { default: open } = await import("open");
-        await open(safeUrl);
+        await open(cliLimitUrl);
     }
     return true;
 }

package/dist/utils/team-upgrade.js

@@ -26,6 +26,7 @@ export async function upgradeToTeam(opts = {}) {
         method: "POST",
         body: {
             companyUid,
+            entrySurface: "cli_limit",
             successUrl: CHECKOUT_SUCCESS_URL,
             cancelUrl: CHECKOUT_CANCEL_URL,
         },

package/package.json

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