@indigoai-us/hq-cli 5.345.3 → 5.345.5

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [Unreleased]
 
+## [5.345.5] — 2026-10-05
+- `hq daemon sync status` now identifies the executing runner and derives its hq-cloud version from the owner status or runner package when needed.
+
+## [5.345.4] — 2026-10-05
+- Run a pinned or newer managed hq-cloud sync runner ahead of the staged sync bundle, so daemon sync no longer stays on the hq-cloud version bundled with the CLI after an update or pin (hq-cli#1547).
+- Avoid dispatching the global hook when the working directory is inside an HQ root.
+
 ## [5.345.3] — 2026-10-05
 - Retry a blocker freshness lane-inbox fallback after a transient append failure.
 - Scope bundled-script stdin checks to changes in their workflow, build inputs, CLI sources, tests, or shell assets.

package/dist/commands/daemon.js

@@ -16,7 +16,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { major as semverMajor, valid as validSemver } from "semver";
+import { compare as semverCompare, major as semverMajor, valid as validSemver } from "semver";
 import { DEFAULT_SERVICES, SERVICE_DESCRIPTIONS, enabledServices, hqCloudUnits } from "../lib/daemon/catalog.js";
 import { applyServiceToggle, effectiveSyncOwner, readDaemonConfig, writeDaemonConfig } from "../lib/daemon/config.js";
 import { daemonUnitInstalled } from "../lib/daemon/handoff.js";
@@ -24,13 +24,14 @@ import { adoptLegacyUnits, readAdoptedUnits, restoreLegacyUnits } from "../lib/d
 import { ROOT_REFUSAL, SYSTEM_UNIT_DIR, daemonRootRefusal, installDaemonUnit, installScopeFor, uninstallDaemonUnit, } from "../lib/daemon/install.js";
 import { describeLegacyUnit, findLegacyUnits } from "../lib/daemon/legacy.js";
 import { isDaemonProcess, runningDaemonPid } from "../lib/daemon/lock.js";
-import { bundledHqCloud } from "../lib/daemon/hq-cloud.js";
+import { bundledHqCloud, managedHqCloud, managedHqCloudRoot, readHqCloudCopy } from "../lib/daemon/hq-cloud.js";
 import { MACHINE_TYPE_MARKER_PATH, detectMachineType, homeFromPasswd, } from "../lib/daemon/machine-type.js";
 import { daemonPaths } from "../lib/daemon/paths.js";
 import { processCommandLine } from "../lib/daemon/lock.js";
 import { writeControlRequest } from "../lib/daemon/requests.js";
 import { runDaemonCall } from "../lib/daemon/command-call.js";
-import { isSyncRunnerCommandLine, readWatchRunnerOwnerStatus, watchRunnerOwnerStatusPath } from "../lib/daemon/sync-runner.js";
+import { isSyncRunnerCommandLine, readWatchRunnerOwnerStatus, syncRunnerPathFromCommandLine, watchRunnerOwnerStatusPath } from "../lib/daemon/sync-runner.js";
+import { stagedSyncRunnerVersion, syncRunnerBundleStageRoot } from "../lib/daemon/sync-runner-bundle.js";
 import { getSyncModeForCompany, setSyncMode } from "./sync-mode.js";
 import { requireAnywhereRuntime } from "./anywhere-runtime-flag.js";
 import { hqdRequest, hqdSocketPath, HqdClientError } from "../lib/daemon/protocol.js";
@@ -440,6 +441,38 @@ function daemonSyncModeClient(d) {
         return new VaultClient(buildVaultConfig(token));
     })();
 }
+function pathIsWithin(candidate, root, platform) {
+    const pathApi = platform === "win32" ? path.win32 : path;
+    const relative = pathApi.relative(pathApi.resolve(root), pathApi.resolve(candidate));
+    return relative === "" || (relative !== ".." && !relative.startsWith(".." + pathApi.sep) && !pathApi.isAbsolute(relative));
+}
+function syncRunnerSource(runnerPath, daemonRoot, platform) {
+    if (!runnerPath)
+        return "unknown";
+    if (pathIsWithin(runnerPath, syncRunnerBundleStageRoot(daemonRoot), platform))
+        return "staged-sync";
+    if (pathIsWithin(runnerPath, managedHqCloudRoot(daemonRoot), platform))
+        return "managed-full-package";
+    const bundled = bundledHqCloud();
+    if (bundled && pathIsWithin(runnerPath, bundled.root, platform))
+        return "bundled-full-package";
+    return "unknown";
+}
+function syncVersionMismatch(status) {
+    const running = status.hqCloudVersion;
+    if (!running)
+        return null;
+    if (status.pinnedHqCloudVersion && running !== status.pinnedHqCloudVersion) {
+        return "Sync runs hq-cloud " + running + ", while the configured pin expects " + status.pinnedHqCloudVersion + ". Run hq daemon restart sync after updating hq-cli to apply it.";
+    }
+    if (status.managedHqCloudVersion
+        && validSemver(status.managedHqCloudVersion)
+        && validSemver(running)
+        && semverCompare(status.managedHqCloudVersion, running) > 0) {
+        return "Sync runs hq-cloud " + running + ", while managed hq-cloud " + status.managedHqCloudVersion + " is newer. Run hq daemon restart sync after updating hq-cli to apply it.";
+    }
+    return null;
+}
 function daemonSyncStatus(d) {
     const host = currentHost(d);
     const { paths } = host;
@@ -461,22 +494,64 @@ function daemonSyncStatus(d) {
     const ownerCommandLine = ownerStatusCandidate
         ? processCommandLine(ownerStatusCandidate.pid, { platform: d.platform, run: d.run })
         : null;
-    const ownerStatus = ownerCommandLine && isSyncRunnerCommandLine(ownerCommandLine)
-        ? ownerStatusCandidate
+    const ownerRunnerPath = ownerCommandLine && isSyncRunnerCommandLine(ownerCommandLine)
+        ? syncRunnerPathFromCommandLine(ownerCommandLine)
         : null;
-    return {
+    const ownerStatus = ownerRunnerPath ? ownerStatusCandidate : null;
+    const unitCommandLine = ownerRunnerPath || !syncUnit?.pid
+        ? null
+        : processCommandLine(syncUnit.pid, { platform: d.platform, run: d.run });
+    const unitRunnerPath = unitCommandLine && isSyncRunnerCommandLine(unitCommandLine)
+        ? syncRunnerPathFromCommandLine(unitCommandLine)
+        : null;
+    const runnerPath = ownerRunnerPath ?? unitRunnerPath;
+    const runnerSource = syncRunnerSource(runnerPath, paths.root, d.platform);
+    const managedCopy = managedHqCloud(paths.root);
+    const managedVersion = managedCopy?.version ?? null;
+    let hqCloudVersion = ownerStatus?.version ?? null;
+    let hqCloudVersionSource = hqCloudVersion ? "owner-status" : "unknown";
+    if (!hqCloudVersion && runnerPath) {
+        try {
+            const copy = runnerSource === "staged-sync"
+                ? { root: "", version: stagedSyncRunnerVersion(runnerPath) }
+                : runnerSource === "managed-full-package"
+                    ? readHqCloudCopy(managedHqCloudRoot(paths.root))
+                    : runnerSource === "bundled-full-package"
+                        ? bundledHqCloud()
+                        : null;
+            if (copy) {
+                hqCloudVersion = copy.version;
+                hqCloudVersionSource = "runner-path";
+            }
+        }
+        catch {
+            d.err("Could not read sync runner version metadata; treating it as unavailable.");
+        }
+    }
+    // Compare the executing version, not the installed managed copy: the copy can be updated on disk while an older runner still runs.
+    const runnerMatchesPin = runnerSource === "managed-full-package" && config.hqCloudVersion && hqCloudVersion
+        ? hqCloudVersion === config.hqCloudVersion
+        : null;
+    const status = {
         running: syncUnit?.status === "running",
         paused: config.syncPaused === true,
         syncOwner: effectiveSyncOwner(config, host.detected.type),
         owner: ownerStatus?.owner ?? (syncUnit?.status === "running" ? "hq-daemon" : null),
         runnerPid: ownerStatus?.pid ?? syncUnit?.pid ?? null,
-        hqCloudVersion: ownerStatus?.version ?? null,
+        hqCloudVersion,
+        hqCloudVersionSource,
+        runnerMatchesPin,
+        runnerPath,
+        runnerSource,
+        managedHqCloudVersion: managedVersion,
+        pinnedHqCloudVersion: config.hqCloudVersion ?? null,
         lastHeartbeat: syncUnit?.lastHeartbeatAt ?? ownerStatus?.heartbeatAt ?? null,
         lastPassResult: syncUnit?.lastPassResult ?? null,
         unitStatus: syncUnit?.status ?? "not-running",
         reason: syncUnit?.reason ?? null,
         logPath: paths.unitLogPath("sync"),
     };
+    return status;
 }
 async function runDaemonSyncStatus(d, opts) {
     const status = daemonSyncStatus(d);
@@ -487,6 +562,15 @@ async function runDaemonSyncStatus(d, opts) {
     d.out(`Sync ${status.running ? "running" : status.unitStatus}${status.paused ? " (paused)" : ""}.`);
     d.out(`Configured sync owner: ${status.syncOwner}.`);
     d.out(`Owner: ${status.owner ?? "none"}; runner pid: ${status.runnerPid ?? "none"}; hq-cloud: ${status.hqCloudVersion ?? "unknown"}.`);
+    d.out(`Sync runner: ${status.runnerPath ?? "unknown"} (${status.runnerSource}); hq-cloud ${status.hqCloudVersion ?? "unknown"}.`);
+    d.out("Managed hq-cloud: " + (status.managedHqCloudVersion ?? "unknown") + "; pinned hq-cloud: " + (status.pinnedHqCloudVersion ?? "none") + ".");
+    if (status.runnerSource === "managed-full-package") {
+        const pinMatch = status.runnerMatchesPin === null ? "unknown" : status.runnerMatchesPin ? "yes" : "no";
+        d.out("Managed runner matches pin: " + pinMatch + ".");
+    }
+    const versionMismatch = syncVersionMismatch(status);
+    if (versionMismatch)
+        d.out(versionMismatch);
     if (status.reason)
         d.out(`Reason: ${status.reason}`);
     d.out(`Log: ${status.logPath}`);

package/dist/lib/daemon/hq-cloud.d.ts

@@ -23,6 +23,11 @@ export type ManagedHqCloud = PickedHqCloud & {
 export declare function managedHqCloudDir(daemonRoot: string): string;
 /** The package folder inside the updater's install prefix. */
 export declare function managedHqCloudRoot(daemonRoot: string): string;
+/**
+ * True only when both versions are valid semver and `a` is older than `b`.
+ * Prereleases count, so 6.18.33-alpha.1 is older than 6.18.33.
+ */
+export declare function hqCloudVersionOlder(a: string, b: string): boolean;
 /**
  * `usable` says whether a copy has what the daemon runs; a newer managed copy
  * that fails it (an interrupted or damaged install) is passed over.
@@ -55,6 +60,9 @@ export declare function hqCloudInstallCommand(prefix: string, version: string, p
     args: string[];
     shell: boolean;
 };
+export declare function readHqCloudCopy(root: string): HqCloudCopy | null;
+/** The hq-cloud copy installed in the daemon-owned managed package root. */
+export declare function managedHqCloud(daemonRoot: string): HqCloudCopy | null;
 /** The copy bundled with this CLI. */
 export declare function bundledHqCloud(): HqCloudCopy | null;
 /** The hq-cloud the daemon should run right now. */

package/dist/lib/daemon/hq-cloud.js

@@ -10,6 +10,7 @@ import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import { createRequire } from "node:module";
 import * as path from "node:path";
+import { lt as semverLt, valid as validSemver } from "semver";
 import { readDaemonConfig } from "./config.js";
 import { buildSpawnPlan } from "../../utils/windows-spawn.js";
 export const HQ_CLOUD_PACKAGE = "@indigoai-us/hq-cloud";
@@ -31,6 +32,15 @@ function newer(a, b) {
     }
     return false;
 }
+/**
+ * True only when both versions are valid semver and `a` is older than `b`.
+ * Prereleases count, so 6.18.33-alpha.1 is older than 6.18.33.
+ */
+export function hqCloudVersionOlder(a, b) {
+    const va = validSemver(a.trim());
+    const vb = validSemver(b.trim());
+    return !!va && !!vb && semverLt(va, vb);
+}
 /**
  * `usable` says whether a copy has what the daemon runs; a newer managed copy
  * that fails it (an interrupted or damaged install) is passed over.
@@ -108,7 +118,7 @@ export function hqCloudInstallCommand(prefix, version, platform = process.platfo
     const plan = buildSpawnPlan("npm", ["install", "--prefix", prefix, "--no-audit", "--no-fund", "--omit=dev", `${HQ_CLOUD_PACKAGE}@${version}`], platform);
     return { file: plan.cmd, args: plan.args, shell: plan.shell };
 }
-function readHqCloudCopy(root) {
+export function readHqCloudCopy(root) {
     try {
         const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
         return typeof pkg.version === "string" ? { root, version: pkg.version } : null;
@@ -117,6 +127,10 @@ function readHqCloudCopy(root) {
         return null;
     }
 }
+/** The hq-cloud copy installed in the daemon-owned managed package root. */
+export function managedHqCloud(daemonRoot) {
+    return readHqCloudCopy(managedHqCloudRoot(daemonRoot));
+}
 /** The copy bundled with this CLI. */
 export function bundledHqCloud() {
     try {
@@ -130,12 +144,12 @@ export function bundledHqCloud() {
 /** The hq-cloud the daemon should run right now. */
 export function currentHqCloud(daemonRoot) {
     const pinnedVersion = readDaemonConfig(path.join(daemonRoot, "config.json")).hqCloudVersion;
-    return pickHqCloud(bundledHqCloud(), readHqCloudCopy(managedHqCloudRoot(daemonRoot)), (copy) => hqCloudRunners(copy.root).syncRunner !== null, pinnedVersion);
+    return pickHqCloud(bundledHqCloud(), managedHqCloud(daemonRoot), (copy) => hqCloudRunners(copy.root).syncRunner !== null, pinnedVersion);
 }
 /** After the CLI package lease is released, only daemon-owned package files are eligible. */
 export function currentHqCloudAfterLeaseRelease(daemonRoot, expectedVersion) {
     const config = readDaemonConfig(path.join(daemonRoot, "config.json"));
-    const managed = readHqCloudCopy(managedHqCloudRoot(daemonRoot));
+    const managed = managedHqCloud(daemonRoot);
     if (!managed || !hqCloudRunners(managed.root).syncRunner)
         return null;
     if (config.hqCloudVersion && config.hqCloudVersion !== managed.version)

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

@@ -59,7 +59,10 @@ export type SyncRunnerSource = {
     kind: "unavailable";
     runnerPath: null;
 };
-export declare function syncRunnerSourceForPlan(stagedRunnerPath: string | null, hqCloud: PickedHqCloud | null, legacyBundledRunnerPath?: string | null): SyncRunnerSource;
+export declare function syncRunnerSourceForPlan(stagedRunnerPath: string | null, hqCloud: PickedHqCloud | null, legacyBundledRunnerPath?: string | null, staged?: {
+    version: string | null;
+    pinnedVersion?: string | null;
+}): SyncRunnerSource;
 /** Whether every executable in the first service plan remains usable after the CLI package is replaced. */
 export declare function daemonPlanCanReleasePackageUseLease(plans: readonly UnitPlan[], replaceablePackageRoots: readonly string[], stagingFailed: boolean, hqBootstrapReady?: boolean): boolean;
 export declare function daemonHqChildCommand(nodeBinary: string, hqBinary: string, args: readonly string[], bootstrapPath: string | null, packagePrefix: string | null): [string, string[]];

package/dist/lib/daemon/run.js

@@ -37,7 +37,7 @@ import { startHqdServer } from "./server.js";
 import { heartbeatFile, startHeartbeat } from "./heartbeat.js";
 import { createProtocolTail, ensureProtocolFifo, openProtocolWriter } from "./protocol-tail.js";
 import { takeControlRequests } from "./requests.js";
-import { currentHqCloud, currentHqCloudAfterLeaseRelease, hqCloudRunners } from "./hq-cloud.js";
+import { currentHqCloud, currentHqCloudAfterLeaseRelease, hqCloudRunners, hqCloudVersionOlder } from "./hq-cloud.js";
 import { stageSyncRunnerBundle } from "./sync-runner-bundle.js";
 import { stageHqChildBootstrap } from "./hq-child-bootstrap-stage.js";
 import { runnerSessionName } from "./remote-control.js";
@@ -76,7 +76,21 @@ export function handoffForPackageUpdateRequest(requested, restartDaemon) {
 const LEGACY_PROBE_TTL_MS = 60_000;
 /** A flag read that has not answered by then counts as off. */
 const HANDOFF_FLAG_TIMEOUT_MS = 10_000;
-export function syncRunnerSourceForPlan(stagedRunnerPath, hqCloud, legacyBundledRunnerPath = null) {
+export function syncRunnerSourceForPlan(stagedRunnerPath, hqCloud, legacyBundledRunnerPath = null, staged = { version: null }) {
+    // A managed copy lives in the daemon directory, so it survives a CLI
+    // replacement. Before lease release pickHqCloud returns it only when it is
+    // pinned or newer than the bundled copy; after release it is the only
+    // eligible package, so it must not displace a newer staged bundle unless it
+    // is the pinned version. The staged bundle is built from the bundled copy and
+    // otherwise only stands in for that copy (hq-cli#1547).
+    const managedYieldsToStaged = stagedRunnerPath !== null &&
+        hqCloud?.source === "managed" &&
+        hqCloud.version !== staged.pinnedVersion &&
+        staged.version !== null &&
+        hqCloudVersionOlder(hqCloud.version, staged.version);
+    if (hqCloud?.source === "managed" && !managedYieldsToStaged) {
+        return { kind: "managed-full-package", runnerPath: path.join(hqCloud.root, "dist", "bin", "sync-runner.js") };
+    }
     if (stagedRunnerPath)
         return { kind: "staged-sync", runnerPath: stagedRunnerPath };
     if (!hqCloud) {
@@ -86,10 +100,7 @@ export function syncRunnerSourceForPlan(stagedRunnerPath, hqCloud, legacyBundled
     }
     // The caller has already selected a usable full package; preserve the
     // conventional path here, including in tests with virtual package roots.
-    const runnerPath = path.join(hqCloud.root, "dist", "bin", "sync-runner.js");
-    return hqCloud.source === "managed"
-        ? { kind: "managed-full-package", runnerPath }
-        : { kind: "bundled-full-package", runnerPath };
+    return { kind: "bundled-full-package", runnerPath: path.join(hqCloud.root, "dist", "bin", "sync-runner.js") };
 }
 function isPathWithin(root, candidate) {
     if (!root || !path.isAbsolute(candidate))
@@ -559,7 +570,7 @@ export async function runDaemon(opts) {
             legacySyncRunnerPath = resolveSyncRunnerPath();
             legacySyncRunnerPathChecked = true;
         }
-        const syncSource = syncRunnerSourceForPlan(staged?.runnerPath ?? null, hqCloud, packageUseLeaseReleased ? null : legacySyncRunnerPath);
+        const syncSource = syncRunnerSourceForPlan(staged?.runnerPath ?? null, hqCloud, packageUseLeaseReleased ? null : legacySyncRunnerPath, { version: staged?.metadata.version ?? null, pinnedVersion: config.hqCloudVersion ?? null });
         if (!syncSource.runnerPath && !warnedMissingSyncRunner) {
             warnedMissingSyncRunner = true;
             log("warn", "the hq-cloud sync runner was not found in this CLI install; sync is unavailable");

package/dist/lib/daemon/sync-runner-bundle.d.ts

@@ -4,6 +4,8 @@ export declare const SYNC_RUNNER_BUNDLE_RUNNER_FILE = "bin/sync-runner.js";
 export declare const SYNC_RUNNER_BUNDLE_METADATA_FILE = "package.json";
 export declare const SYNC_RUNNER_BUNDLE_DIRECTORY = "hq-cloud-sync-runner";
 export declare const SYNC_RUNNER_BUNDLE_FORMAT_VERSION = 1;
+/** Root directory where validated sync-runner bundles are selected. */
+export declare function syncRunnerBundleStageRoot(daemonRoot: string): string;
 /** package.json contract that the hq-cli build step emits beside the bundled bin directory. */
 export interface SyncRunnerBundleMetadata {
     name: "hq-cli-daemon-sync-runner";
@@ -32,6 +34,8 @@ export interface StageSyncRunnerBundleOptions {
     copyFile?: typeof fs.copyFileSync;
     renameDirectory?: (from: string, to: string) => void;
 }
+/** Read the validated metadata version for a runner inside its staged bundle. */
+export declare function stagedSyncRunnerVersion(runnerPath: string): string;
 /**
  * Stage one validated runner bundle into an immutable daemon-owned directory.
  * Only a completed, fsynced directory is returned; temp siblings are ignored.

package/dist/lib/daemon/sync-runner-bundle.js

@@ -9,6 +9,10 @@ export const SYNC_RUNNER_BUNDLE_RUNNER_FILE = "bin/sync-runner.js";
 export const SYNC_RUNNER_BUNDLE_METADATA_FILE = "package.json";
 export const SYNC_RUNNER_BUNDLE_DIRECTORY = "hq-cloud-sync-runner";
 export const SYNC_RUNNER_BUNDLE_FORMAT_VERSION = 1;
+/** Root directory where validated sync-runner bundles are selected. */
+export function syncRunnerBundleStageRoot(daemonRoot) {
+    return path.join(daemonRoot, "bundles", "sync-runner");
+}
 export class SyncRunnerBundleStageError extends Error {
     code;
     constructor(code, message, options) {
@@ -55,6 +59,11 @@ function readMetadata(file) {
     }
     return metadata;
 }
+/** Read the validated metadata version for a runner inside its staged bundle. */
+export function stagedSyncRunnerVersion(runnerPath) {
+    const bundleDirectory = path.dirname(path.dirname(runnerPath));
+    return readMetadata(path.join(bundleDirectory, SYNC_RUNNER_BUNDLE_METADATA_FILE)).version;
+}
 function hqCloudRange() {
     const cliPackagePath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../package.json");
     try {
@@ -138,7 +147,7 @@ export function stageSyncRunnerBundle(options) {
     if (sha256(sourceRunner) !== metadata.bundleSha256) {
         fail("HASH_MISMATCH", "The sync-runner bundle sha256 does not match its sidecar");
     }
-    const stageRoot = path.join(options.daemonRoot, "bundles", "sync-runner");
+    const stageRoot = syncRunnerBundleStageRoot(options.daemonRoot);
     const selectedDirectory = path.join(stageRoot, stagedLeaf(metadata));
     const existing = readStaged(selectedDirectory, metadata, range);
     if (existing)

package/dist/lib/daemon/sync-runner.d.ts

@@ -44,6 +44,8 @@ export declare function watchRunnerOwnerStatusPath(hqRoot: string, home?: string
 export declare function readWatchRunnerOwnerStatus(statusPath: string): WatchRunnerOwnerStatus | null;
 /** Match a live process command line to the hq-cloud watch runner executable. */
 export declare function isSyncRunnerCommandLine(commandLine: string): boolean;
+/** Return the script path from a command line already verified as a sync runner. */
+export declare function syncRunnerPathFromCommandLine(commandLine: string): string | null;
 /** Return a clear wait reason when an unleased runner already targets this HQ root. */
 export declare function syncRunnerUnleasedBlockReason(hqRoot: string, processes: readonly SyncRunnerProcess[], ownerPid: number | null, platform?: NodeJS.Platform, daemonRunnerPids?: ReadonlySet<number>): string | undefined;
 /** Read complete process command lines so root matching can include trailing arguments. */

package/dist/lib/daemon/sync-runner.js

@@ -59,6 +59,14 @@ export function readWatchRunnerOwnerStatus(statusPath) {
 export function isSyncRunnerCommandLine(commandLine) {
     return SYNC_RUNNER_COMMAND.test(commandLine);
 }
+/** Return the script path from a command line already verified as a sync runner. */
+export function syncRunnerPathFromCommandLine(commandLine) {
+    if (!isSyncRunnerCommandLine(commandLine))
+        return null;
+    const args = commandLineArgs(commandLine);
+    return args.find((arg) => (path.isAbsolute(arg) || path.win32.isAbsolute(arg))
+        && /(?:^|[\\/])(?:sync-runner\.js|hq-sync-runner(?:\.(?:cmd|exe))?)$/i.test(arg)) ?? null;
+}
 function commandLineArgs(commandLine) {
     const args = [];
     let current = "";

package/dist/lib/install/claude-targets.js

@@ -49,7 +49,7 @@ export function hqSkillsSource(hqRoot) {
 }
 /** The exact hook command registered for one event (absolute path, quoted). */
 export function hookCommand(hqRoot, event, target = 'master') {
-    const skipInsideRoot = `if [ -d "\${CLAUDE_PROJECT_DIR:-}" ] && [ "\${CLAUDE_PROJECT_DIR}" -ef ${shellQuote(hqRoot)} ]; then exit 0; fi; `;
+    const skipInsideRoot = `if [ -d "\${CLAUDE_PROJECT_DIR:-}" ] && [ "\${CLAUDE_PROJECT_DIR}" -ef ${shellQuote(hqRoot)} ]; then exit 0; fi; cwd=$(pwd -P 2>/dev/null || pwd); while [ -n "$cwd" ]; do if [ -f "$cwd/core/core.yaml" ] && [ -f "$cwd/companies/manifest.yaml" ]; then exit 0; fi; [ "$cwd" = / ] && break; cwd=\${cwd%/*}; [ -n "$cwd" ] || cwd=/; done; `;
     if (target === 'shim')
         return `${skipInsideRoot}exec /bin/sh ${shellQuote(shimPath(hqRoot))} ${shellQuote(event)} --runtime claude`;
     return `${skipInsideRoot}BASH_ENV=/dev/null exec bash ${shellQuote(masterHookPath(hqRoot))} ${shellQuote(event)}`;

package/package.json

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