@indigoai-us/hq-cli 5.345.4 → 5.345.5

package/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## [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.

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

@@ -60,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

@@ -118,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;
@@ -127,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 {
@@ -140,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/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/package.json

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