@indigoai-us/hq-cli 5.337.0 → 5.339.0

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [Unreleased]
 
+## [5.339.0] — 2026-10-03
+- Reduce cold-start imports for the `checkpoint-stop-gate` and `session-journal` native fast routes.
+
+## [5.338.0] — 2026-10-03
+- Preserve policy-trigger mutual exclusion without `flock` and honor configured stale-run thresholds without `yq`.
+- Add a manual macOS VM parity workflow for checking HQ CLI behavior in Tart.
+
 ## [5.337.0] — 2026-10-03
 - QMD index updates now share the cross-process writer lock and skip bounded SQLite contention so a later sync can catch up.
 - Self-update now checks the Windows npm prefix that stores command shims, so an unwritable prefix is detected before npm runs.

package/assets/scaffold/core/scripts/migrate-policy-triggers.sh

@@ -124,8 +124,61 @@ fi
 COOLDOWN_SECONDS="${HQ_MIGRATE_POLICY_TRIGGERS_COOLDOWN_SECONDS:-3600}"
 STAMP=""
 LOCK=""
+LOCK_FALLBACK_DIR=""
+LOCK_FALLBACK_HELD=0
+LOCK_FALLBACK_OWNER=""
+LOCK_FALLBACK_STALE_SECONDS=86400
 STATE_READY=0
 
+release_fallback_lock() {
+  [ "$LOCK_FALLBACK_HELD" = "1" ] || return 0
+  [ "$(cat "$LOCK_FALLBACK_DIR/owner" 2>/dev/null)" = "$LOCK_FALLBACK_OWNER" ] || return 0
+  rm -f "$LOCK_FALLBACK_DIR/owner" 2>/dev/null || return 0
+  rmdir "$LOCK_FALLBACK_DIR" 2>/dev/null || true
+}
+
+fallback_lock_is_stale() {
+  local lock_dir="$1" modified now age
+  modified="$(stat -c '%Y' "$lock_dir" 2>/dev/null || stat -f '%m' "$lock_dir" 2>/dev/null)"
+  case "$modified" in ''|*[!0-9]*) return 1 ;; esac
+  now="$(date -u '+%s')"
+  age=$((now - modified))
+  [ "$age" -ge "$LOCK_FALLBACK_STALE_SECONDS" ]
+}
+
+reclaim_stale_fallback_lock() {
+  local stale_dir="${LOCK_FALLBACK_DIR}.stale.$$.$RANDOM" owner_present=0 owner_value=""
+  restore_stale_dir() {
+    # Never let mv place the quarantined directory inside a replacement lock.
+    # A new holder may have created the path after our rename-aside.
+    if [ -e "$LOCK_FALLBACK_DIR" ] || [ -L "$LOCK_FALLBACK_DIR" ]; then return 1; fi
+    mv "$stale_dir" "$LOCK_FALLBACK_DIR" 2>/dev/null
+  }
+  [ -d "$LOCK_FALLBACK_DIR" ] || return 1
+  fallback_lock_is_stale "$LOCK_FALLBACK_DIR" || return 1
+  # Rename the observed lock aside atomically. Recheck the moved directory so
+  # a stale decision is never used to remove a replacement lock at the path.
+  mv "$LOCK_FALLBACK_DIR" "$stale_dir" 2>/dev/null || return 1
+  if fallback_lock_is_stale "$stale_dir"; then
+    if [ -e "$stale_dir/owner" ]; then
+      owner_present=1
+      owner_value="$(cat "$stale_dir/owner" 2>/dev/null)"
+      rm -f "$stale_dir/owner" 2>/dev/null || {
+        restore_stale_dir || true
+        return 1
+      }
+    fi
+    if rmdir "$stale_dir" 2>/dev/null; then
+      return 0
+    fi
+    if [ "$owner_present" = "1" ]; then
+      (set -o noclobber; printf '%s\n' "$owner_value" >"$stale_dir/owner") 2>/dev/null || true
+    fi
+  fi
+  restore_stale_dir || true
+  return 1
+}
+
 # Hash the resolved scope rather than using a shared per-root stamp: the
 # default scan deliberately includes tenant-specific directories.
 scope_key() {
@@ -192,12 +245,34 @@ fi
 # A scope-local advisory lock prevents concurrent SessionStart hooks from both
 # observing the same absent/stale stamp. Recheck after acquiring it because a
 # prior holder may have completed while this invocation waited to acquire it.
-if [ "$STATE_READY" = "1" ] && [ "$DRY" != "1" ] && command -v flock >/dev/null 2>&1; then
-  if ! exec 9>"$LOCK"; then
-    exit 0
-  fi
-  if ! flock -n 9; then # command -v flock checked above
-    exit 0
+if [ "$STATE_READY" = "1" ] && [ "$DRY" != "1" ]; then
+  if command -v flock >/dev/null 2>&1; then
+    if ! exec 9>"$LOCK"; then
+      exit 0
+    fi
+    if ! flock -n 9; then
+      exit 0
+    fi
+  else
+    # Atomic directory creation preserves mutual exclusion on stock macOS,
+    # which does not ship util-linux flock. An abandoned directory is only
+    # reclaimed after a 24-hour age threshold, well above this bounded scan.
+    LOCK_FALLBACK_DIR="${LOCK}.d"
+    if ! mkdir "$LOCK_FALLBACK_DIR" 2>/dev/null; then
+      if reclaim_stale_fallback_lock; then
+        mkdir "$LOCK_FALLBACK_DIR" 2>/dev/null || exit 0
+      else
+        exit 0
+      fi
+    fi
+    LOCK_FALLBACK_HELD=1
+    LOCK_FALLBACK_OWNER="$$:$RANDOM:$(date -u '+%s')"
+    if ! printf '%s\n' "$LOCK_FALLBACK_OWNER" >"$LOCK_FALLBACK_DIR/owner"; then
+      rmdir "$LOCK_FALLBACK_DIR" 2>/dev/null || true
+      LOCK_FALLBACK_HELD=0
+      exit 0
+    fi
+    trap release_fallback_lock EXIT
   fi
   if cooldown_blocks_run; then
     exit 0

package/assets/scaffold/core/scripts/repo-run-registry.sh

@@ -127,10 +127,32 @@ _is_pid_alive() {
 }
 
 _stale_minutes() {
-  if [[ -f "$ORCH_YAML" ]] && command -v yq >/dev/null 2>&1; then
-    local v
-    v=$(yq eval '.repo_coordination.stale_heartbeat_minutes // 15' "$ORCH_YAML" 2>/dev/null)
-    [[ -n "$v" && "$v" != "null" ]] && { echo "$v"; return; }
+  if [[ -f "$ORCH_YAML" ]]; then
+    if command -v yq >/dev/null 2>&1; then
+      local v
+      v=$(yq eval '.repo_coordination.stale_heartbeat_minutes // 15' "$ORCH_YAML" 2>/dev/null)
+      [[ -n "$v" && "$v" != "null" ]] && { echo "$v"; return; }
+    else
+      # Parse the one scalar this helper needs when yq is unavailable. Do not
+      # silently replace a configured timeout with the 15-minute default.
+      awk '
+        /^repo_coordination:[[:space:]]*(#.*)?$/ { in_repo=1; next }
+        in_repo && /^[^[:space:]#]/ { exit }
+        in_repo && /^[[:space:]]+stale_heartbeat_minutes:[[:space:]]*/ {
+          sub(/^[[:space:]]+stale_heartbeat_minutes:[[:space:]]*/, "")
+          sub(/[[:space:]]+#.*$/, "")
+          gsub(/^[[:space:]]+|[[:space:]]+$/, "")
+          gsub(/^["\047]|["\047]$/, "")
+          if ($0 == "" || $0 == "null" || $0 == "~") print 15
+          else if ($0 ~ /^[0-9]+$/) print $0
+          else print 15
+          found=1
+          exit
+        }
+        END { if (!found) print 15 }
+      ' "$ORCH_YAML"
+      return
+    fi
   fi
   echo 15
 }

package/dist/commands/core-migrate-policy-triggers-native.js

@@ -7,6 +7,7 @@ import { fileURLToPath } from "node:url";
 import { evaluateTrigger } from "../utils/core-eval-trigger.js";
 import { awkCannotOpenFileDiagnostic } from "../lib/core-utils/awk-diagnostics.js";
 export const MIGRATE_POLICY_TRIGGERS_ASSET = "core/scripts/migrate-policy-triggers.sh";
+const FALLBACK_LOCK_STALE_SECONDS = 24 * 60 * 60;
 const ON_LIVE = "[PreToolUse, PostToolUse, UserPromptSubmit, AssistantIntent]";
 const ON_START = "[SessionStart]";
 const TAG_STOP = new Set(("infrastructure consolidated ux safety hq hq-core hq-cli hq-packages " +
@@ -173,7 +174,7 @@ function unreadablePolicyDiagnostic(filename, error, pathValue) {
     const message = code === "EACCES" || code === "EPERM" ? "Permission denied" : "No such file or directory";
     const script = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../assets/scaffold/core/scripts/migrate-policy-triggers.sh");
     const awk = awkCannotOpenFileDiagnostic(filename, message, 1, process.platform, pathValue);
-    return `${script}: line 314: ${filename}: ${message}\n${awk.repeat(3)}`;
+    return `${script}: line 389: ${filename}: ${message}\n${awk.repeat(3)}`;
 }
 function shellGlobMd(fileSystem, directory) {
     try {
@@ -255,20 +256,141 @@ export function runMigratePolicyTriggers(args, deps) {
     if (cooldownBlocks())
         return { code: 0, stdout, stderr };
     let lockFd;
-    if (stateReady && !dryRun && executableInPath("flock", deps.env, fileSystem)) {
+    let fallbackLockDir;
+    let fallbackLockOwner;
+    const releaseFallbackLock = () => {
+        if (!fallbackLockDir)
+            return;
         try {
-            lockFd = fileSystem.openSync(lock, "w");
+            if (fileSystem.readFileSync(path.join(fallbackLockDir, "owner"), "utf8").trim() === fallbackLockOwner) {
+                fileSystem.unlinkSync(path.join(fallbackLockDir, "owner"));
+                fileSystem.rmdirSync(fallbackLockDir);
+            }
+        }
+        catch { /* preserve the lock if ownership cannot be confirmed */ }
+        fallbackLockDir = undefined;
+    };
+    const reclaimStaleFallbackLock = (directory) => {
+        const restoreQuarantined = (staleDirectory) => {
+            try {
+                fileSystem.lstatSync(directory);
+                return;
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    return;
+            }
+            try {
+                fileSystem.renameSync(staleDirectory, directory);
+            }
+            catch { /* preserve the quarantine if restoration fails */ }
+        };
+        const age = (candidate) => {
+            try {
+                return Math.floor(deps.now().getTime() / 1000) - Math.floor(fileSystem.statSync(candidate).mtimeMs / 1000);
+            }
+            catch {
+                return undefined;
+            }
+        };
+        if ((age(directory) ?? -1) < FALLBACK_LOCK_STALE_SECONDS)
+            return false;
+        const staleDirectory = `${directory}.stale.${process.pid}.${Math.random().toString(16).slice(2)}`;
+        try {
+            fileSystem.renameSync(directory, staleDirectory);
         }
         catch {
-            return { code: 0, stdout, stderr };
+            return false;
         }
-        const lockResult = (deps.runFlock ?? runNonblockingFlock)(lockFd, deps.cwd, deps.env.PATH ?? "");
-        if (lockResult.error || lockResult.status !== 0) {
-            fileSystem.closeSync(lockFd);
-            return { code: 0, stdout, stderr };
+        const staleAge = age(staleDirectory);
+        if (staleAge !== undefined && staleAge >= FALLBACK_LOCK_STALE_SECONDS) {
+            let ownerBytes;
+            try {
+                ownerBytes = fileSystem.readFileSync(path.join(staleDirectory, "owner"), "utf8");
+            }
+            catch (error) {
+                if (error.code !== "ENOENT") {
+                    restoreQuarantined(staleDirectory);
+                    return false;
+                }
+            }
+            if (ownerBytes !== undefined) {
+                try {
+                    fileSystem.unlinkSync(path.join(staleDirectory, "owner"));
+                }
+                catch {
+                    restoreQuarantined(staleDirectory);
+                    return false;
+                }
+            }
+            try {
+                fileSystem.rmdirSync(staleDirectory);
+                return true;
+            }
+            catch {
+                if (ownerBytes !== undefined) {
+                    try {
+                        fileSystem.writeFileSync(path.join(staleDirectory, "owner"), ownerBytes, { encoding: "utf8", mode: 0o600, flag: "wx" });
+                    }
+                    catch { /* keep the quarantined directory rather than overwrite a changed marker */ }
+                }
+                restoreQuarantined(staleDirectory);
+                return false;
+            }
+        }
+        restoreQuarantined(staleDirectory);
+        return false;
+    };
+    if (stateReady && !dryRun) {
+        if (executableInPath("flock", deps.env, fileSystem)) {
+            try {
+                lockFd = fileSystem.openSync(lock, "w");
+            }
+            catch {
+                return { code: 0, stdout, stderr };
+            }
+            const lockResult = (deps.runFlock ?? runNonblockingFlock)(lockFd, deps.cwd, deps.env.PATH ?? "");
+            if (lockResult.error || lockResult.status !== 0) {
+                fileSystem.closeSync(lockFd);
+                return { code: 0, stdout, stderr };
+            }
+        }
+        else {
+            fallbackLockDir = `${lock}.d`;
+            try {
+                fileSystem.mkdirSync(fallbackLockDir);
+            }
+            catch {
+                if (!reclaimStaleFallbackLock(fallbackLockDir)) {
+                    fallbackLockDir = undefined;
+                    return { code: 0, stdout, stderr };
+                }
+                try {
+                    fileSystem.mkdirSync(fallbackLockDir);
+                }
+                catch {
+                    fallbackLockDir = undefined;
+                    return { code: 0, stdout, stderr };
+                }
+            }
+            fallbackLockOwner = `${process.pid}:${Math.random().toString(36).slice(2)}:${nowSeconds()}`;
+            try {
+                fileSystem.writeFileSync(path.join(fallbackLockDir, "owner"), `${fallbackLockOwner}\n`, { encoding: "utf8", mode: 0o600, flag: "wx" });
+            }
+            catch {
+                try {
+                    fileSystem.rmdirSync(fallbackLockDir);
+                }
+                catch { /* preserve a lock if cleanup is unsafe */ }
+                fallbackLockDir = undefined;
+                fallbackLockOwner = undefined;
+                return { code: 0, stdout, stderr };
+            }
         }
         if (cooldownBlocks()) {
-            fileSystem.closeSync(lockFd);
+            if (lockFd !== undefined)
+                fileSystem.closeSync(lockFd);
+            releaseFallbackLock();
             return { code: 0, stdout, stderr };
         }
     }
@@ -363,6 +485,7 @@ export function runMigratePolicyTriggers(args, deps) {
     finally {
         if (lockFd !== undefined)
             fileSystem.closeSync(lockFd);
+        releaseFallbackLock();
     }
     return { code: errorCode, stdout, stderr };
 }

package/dist/commands/core-session-journal-native.d.ts

@@ -1,4 +1,7 @@
-import { type SessionHelperRuntimeOverrides } from "./core-session-helper-runtime.js";
+type SessionHelperRuntimeOverrides = {
+    env?: NodeJS.ProcessEnv;
+    now?: () => Date;
+};
 export type SessionJournalOperationResult = {
     code: number;
     stdout: Buffer;
@@ -8,4 +11,5 @@ export type SessionJournalOperationResult = {
 export declare function runSessionJournalOperation(args: readonly string[], _stdin: string, cwd: string, hqRoot: string | undefined, dependencies?: SessionHelperRuntimeOverrides): SessionJournalOperationResult;
 /** Native implementation of the fail-soft session journal helper. */
 export declare function runSessionJournalFast(args: readonly string[], stdin: string, cwd: string, hqRoot: string | undefined, dependencies?: SessionHelperRuntimeOverrides): number;
+export {};
 //# sourceMappingURL=core-session-journal-native.d.ts.map

package/dist/commands/core-session-journal-native.js

@@ -1,7 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { resolveSessionHelperRuntime } from "./core-session-helper-runtime.js";
-import { resolveBundledAsset } from "../utils/hq-roots-core.js";
+import { fileURLToPath } from "node:url";
 const USAGE = `session-journal.sh: usage:
   session-journal.sh write "<title>" [--files f1,f2,...] [--body-file PATH] [--session KEY]
   session-journal.sh list [--date YYYY-MM-DD]
@@ -56,6 +55,7 @@ function yamlDoubleQuoted(value) {
 }
 const warning = (message) => { process.stderr.write(`session-journal: ${message}\n`); };
 const journalDir = (root, date) => path.join(root, "workspace/threads/journal", date);
+const sessionJournalAsset = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../assets/scaffold/core/scripts/session-journal.sh");
 const hasFile = (file) => {
     try {
         return fs.statSync(file).isFile();
@@ -190,11 +190,13 @@ function runToolCounter(root, action, sessionArg, env, now, writers) {
     const counter = path.join(dir, `.tool-count-${key}`);
     const lock = `${counter}.lock`;
     const reportDirectoryWriteFailure = (error, line) => {
-        const code = error.code;
-        if (code !== "EISDIR")
+        if (error.code !== "EISDIR")
             return;
-        const asset = resolveBundledAsset("core/scripts/session-journal.sh");
-        writers.stderr(`${asset}: line ${line}: ${counter}: Is a directory\n`);
+        if (!fs.existsSync(sessionJournalAsset)) {
+            throw new Error("Bundled asset is missing from the installed package: assets/scaffold/core/scripts/session-journal.sh\n" +
+                "This is a packaging fault — the file exists in source but was not published.");
+        }
+        writers.stderr(`${sessionJournalAsset}: line ${line}: ${counter}: Is a directory\n`);
     };
     if (action === "increment") {
         withCounterLock(lock, () => {
@@ -243,7 +245,10 @@ export function runSessionJournalFast(args, stdin, cwd, hqRoot, dependencies = {
 }
 function executeSessionJournal(args, cwd, hqRoot, dependencies, writers) {
     const warning = (message) => { writers.stderr(`session-journal: ${message}\n`); };
-    const runtime = resolveSessionHelperRuntime(dependencies);
+    const runtime = {
+        env: dependencies.env ?? process.env,
+        now: dependencies.now ?? (() => new Date()),
+    };
     const today = () => runtime.now().toISOString().slice(0, 10);
     const nowIso = () => runtime.now().toISOString().replace(/\.\d{3}Z$/, "Z");
     const nowHhmm = () => runtime.now().toISOString().slice(11, 16) + "Z";

package/dist/fast-core.d.ts

@@ -14,4 +14,10 @@ export declare function readStdinIfPiped(stream: NodeJS.ReadStream): Promise<str
  * doing anything.
  */
 export declare function runFastCore(argv: readonly string[], parsed?: ReturnType<typeof parseFastCore>): Promise<void>;
+/**
+ * Resolve valid explicit roots for the two measured hook routes without loading
+ * the general root resolver. Anything uncertain falls through to that resolver,
+ * which retains its diagnostics and cwd-discovery behavior.
+ */
+export declare function resolveExplicitFastLiveRoot(hqRootArg: string | undefined, env: NodeJS.ProcessEnv): string | undefined;
 //# sourceMappingURL=fast-core.d.ts.map

package/dist/fast-core.js

@@ -6,7 +6,14 @@
  * entries use the bundled-script runner; native entries import their one handler
  * module. The registration in `core.ts` remains the complete fallback path.
  */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
 import { parseFastCore } from "./fast-scaffold.js";
+const FAST_ROUTE_PROFILE_TOKEN = "hq-fast-route";
+function wantsFastRouteProfile(env) {
+    return env.NODE_DEBUG === FAST_ROUTE_PROFILE_TOKEN;
+}
 export async function readStdinIfPiped(stream) {
     if (stream.isTTY)
         return "";
@@ -23,6 +30,14 @@ export async function readStdinIfPiped(stream) {
 export async function runFastCore(argv, parsed = parseFastCore(argv)) {
     if (!parsed)
         return;
+    const profile = wantsFastRouteProfile(process.env);
+    const profileStart = profile ? process.hrtime.bigint() : undefined;
+    let familyFlagMs = 0;
+    let rootResolutionMs = 0;
+    let handlerImportMs = 0;
+    let stdinReadMs = 0;
+    const profileMark = () => profile ? process.hrtime.bigint() : undefined;
+    const profileElapsed = (start, end) => start === undefined || end === undefined ? 0 : Number(end - start) / 1_000_000;
     const entry = parsed.entry;
     // The full graph's process gate accepts textual true/false overrides. It ignores
     // numeric env values, so preserve that behavior for family flags here too.
@@ -36,6 +51,7 @@ export async function runFastCore(argv, parsed = parseFastCore(argv)) {
         await runCli();
         return;
     }
+    familyFlagMs = profileElapsed(profileStart, profileMark());
     const useShell = entry.kind === "native" && Boolean(entry.familyFlagKey) && !familyEnabled;
     let worktreeScopeFixEnabled;
     if (entry.name === "repo-run-registry") {
@@ -53,21 +69,32 @@ export async function runFastCore(argv, parsed = parseFastCore(argv)) {
     // fail-soft behavior; newly routed commands fall back to the full graph so
     // its expected-user-error formatting remains authoritative.
     let hqRoot;
+    const rootResolutionStartedAt = profileMark();
     if (shouldInjectRoot) {
-        const { resolveLiveRoot } = await import("./utils/hq-roots-core.js");
-        try {
-            hqRoot = resolveLiveRoot(parsed.hqRootArg ? { hqRoot: parsed.hqRootArg } : {});
+        const shortcutRoot = entry.name === "checkpoint-stop-gate" || entry.name === "session-journal"
+            ? resolveExplicitFastLiveRoot(parsed.hqRootArg, process.env)
+            : undefined;
+        if (shortcutRoot !== undefined) {
+            hqRoot = shortcutRoot;
         }
-        catch {
-            if (entry.kind === "native") {
-                const { runCli } = await import("./main.js");
-                await runCli();
-                return;
+        else {
+            const { resolveLiveRoot } = await import("./utils/hq-roots-core.js");
+            try {
+                hqRoot = resolveLiveRoot(parsed.hqRootArg ? { hqRoot: parsed.hqRootArg } : {});
+            }
+            catch {
+                if (entry.kind === "native") {
+                    const { runCli } = await import("./main.js");
+                    await runCli();
+                    return;
+                }
+                hqRoot = undefined;
             }
-            hqRoot = undefined;
         }
     }
+    rootResolutionMs = profileElapsed(rootResolutionStartedAt, profileMark());
     if (entry.kind === "native" && !useShell) {
+        const handlerImportStartedAt = profileMark();
         const { installFastPathStreamErrorHandlers } = await import("./utils/fast-stream-errors.js");
         installFastPathStreamErrorHandlers();
         const handlerModule = await import(entry.modulePath);
@@ -75,8 +102,21 @@ export async function runFastCore(argv, parsed = parseFastCore(argv)) {
         if (typeof handler !== "function") {
             throw new Error(`Native fast handler ${entry.exportName} was not exported`);
         }
+        handlerImportMs = profileElapsed(handlerImportStartedAt, profileMark());
+        const stdinStartedAt = profileMark();
         const readsStdin = entry.readsStdinFor?.(parsed.args) ?? entry.readsStdin ?? false;
         const stdin = readsStdin ? await readStdinIfPiped(process.stdin) : "";
+        stdinReadMs = profileElapsed(stdinStartedAt, profileMark());
+        if (profile && profileStart !== undefined) {
+            process.stderr.write(`HQ_FAST_ROUTE_PROFILE ${JSON.stringify({
+                command: entry.name,
+                pre_handler_ms: profileElapsed(profileStart, profileMark()),
+                family_flag_ms: familyFlagMs,
+                root_resolution_ms: rootResolutionMs,
+                handler_import_ms: handlerImportMs,
+                stdin_read_ms: stdinReadMs,
+            })}\n`);
+        }
         const code = await handler(parsed.args, stdin, process.cwd(), hqRoot, entry.name.split(" ").at(-1) ?? entry.name, parsed.hqRootArg, worktreeScopeFixEnabled);
         if (code === undefined) {
             if (!entry.fallbackToCommandGraph) {
@@ -120,6 +160,29 @@ export async function runFastCore(argv, parsed = parseFastCore(argv)) {
     // Propagate verbatim: these scripts use their exit code as their interface.
     process.exit(code);
 }
+/**
+ * Resolve valid explicit roots for the two measured hook routes without loading
+ * the general root resolver. Anything uncertain falls through to that resolver,
+ * which retains its diagnostics and cwd-discovery behavior.
+ */
+export function resolveExplicitFastLiveRoot(hqRootArg, env) {
+    const candidate = hqRootArg || env.HQ_ROOT || env.CLAUDE_PROJECT_DIR;
+    if (!candidate)
+        return undefined;
+    try {
+        const resolved = fs.realpathSync(candidate);
+        const packageRoot = fs.realpathSync(path.resolve(path.dirname(fileURLToPath(import.meta.url)), ".."));
+        const relative = path.relative(packageRoot, resolved);
+        if (relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative)))
+            return undefined;
+        if (!fs.existsSync(resolved) || !fs.statSync(resolved).isDirectory())
+            return undefined;
+        return resolved;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Match hq-flags-client's literal true/false env override without loading its module. */
 function localBooleanFlagOverride(flagKey, env) {
     const envKey = `HQ_FLAG_${flagKey.replace(/[.-]/g, "_").toUpperCase()}`;

package/package.json

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