@indigoai-us/hq-cli 5.320.0 → 5.321.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [5.321.0] — 2026-10-02
+
+- Project catalog cache keys include their source directory, and runtime-probe tests isolate the host CLI and scope checks to hooks.
+
+- Fixed intermittent timeouts in the concurrent journal parity test.
+- Fix repo-run-registry so an unremovable stale lock exits with a clear error instead of retrying forever.
+- Added the default-off `hq core hook-batch journal-due` command for one-process PostToolUse journal counter reads.
+
 ## [5.320.0] — 2026-10-02
 - Write session-journal titles as escaped YAML strings so free-form titles remain parseable.
 - Added a default-off hq-flags gate that lets lane list pollers skip remote owner refreshes to reduce poll latency.

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

@@ -96,7 +96,9 @@ _try_lock() {
         mtime="$(portable_stat_mtime "$LOCK_DIR" 2>/dev/null || echo 0)"
         age=$(( $(date +%s) - mtime ))
         if [[ $age -gt 60 ]]; then
-          rm -rf "$LOCK_DIR" 2>/dev/null || true
+          if ! rm -rf "$LOCK_DIR" 2>/dev/null; then
+            _die "could not remove stale registry lock: $LOCK_DIR"
+          fi
           continue
         fi
       fi

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

@@ -5971,6 +5971,30 @@ export declare const COMMAND_CATALOG: readonly [{
         }];
         readonly options: readonly [];
         readonly subcommands: readonly [];
+    }, {
+        readonly name: "hook-batch";
+        readonly description: "Batch PostToolUse hook helper calls";
+        readonly aliases: readonly [];
+        readonly hidden: false;
+        readonly usage: "[options] [command]";
+        readonly arguments: readonly [];
+        readonly options: readonly [];
+        readonly subcommands: readonly [{
+            readonly name: "journal-due";
+            readonly description: "Resolve the journal path, increment the tool counter, and return its value";
+            readonly aliases: readonly [];
+            readonly hidden: false;
+            readonly usage: "[options]";
+            readonly arguments: readonly [];
+            readonly options: readonly [{
+                readonly flags: "--session <key>";
+                readonly description: "Session key used by the journal counter";
+            }, {
+                readonly flags: "--reset";
+                readonly description: "Reset the tool counter before incrementing it";
+            }];
+            readonly subcommands: readonly [];
+        }];
     }, {
         readonly name: "session-journal";
         readonly description: "Write and read session journal entries";

package/dist/command-catalog.generated.js

@@ -7681,6 +7681,36 @@ export const COMMAND_CATALOG = [
                 "options": [],
                 "subcommands": []
             },
+            {
+                "name": "hook-batch",
+                "description": "Batch PostToolUse hook helper calls",
+                "aliases": [],
+                "hidden": false,
+                "usage": "[options] [command]",
+                "arguments": [],
+                "options": [],
+                "subcommands": [
+                    {
+                        "name": "journal-due",
+                        "description": "Resolve the journal path, increment the tool counter, and return its value",
+                        "aliases": [],
+                        "hidden": false,
+                        "usage": "[options]",
+                        "arguments": [],
+                        "options": [
+                            {
+                                "flags": "--session <key>",
+                                "description": "Session key used by the journal counter"
+                            },
+                            {
+                                "flags": "--reset",
+                                "description": "Reset the tool counter before incrementing it"
+                            }
+                        ],
+                        "subcommands": []
+                    }
+                ]
+            },
             {
                 "name": "session-journal",
                 "description": "Write and read session journal entries",

package/dist/commands/core-hook-batch-command.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "commander";
+export declare function registerCoreHookBatchCommand(core: Command): void;
+//# sourceMappingURL=core-hook-batch-command.d.ts.map

package/dist/commands/core-hook-batch-command.js

@@ -0,0 +1,27 @@
+import { resolveLiveRoot } from "../utils/hq-roots.js";
+import { describeCoreCommand } from "./core-command-catalog.js";
+import { CORE_HOOK_BATCH_HELP, runCoreHookBatchFast } from "./core-hook-batch-native.js";
+import { coreHookBatchEnabled } from "./core-hook-batch-flag.js";
+export function registerCoreHookBatchCommand(core) {
+    const group = core.command("hook-batch")
+        .description("Batch PostToolUse hook helper calls");
+    const journalDue = group.command("journal-due")
+        .description("Resolve the journal path, increment the tool counter, and return its value")
+        .requiredOption("--session <key>", "Session key used by the journal counter")
+        .option("--reset", "Reset the tool counter before incrementing it")
+        .addHelpText("after", `\n${CORE_HOOK_BATCH_HELP}`)
+        .action(async (options) => {
+        if (!await coreHookBatchEnabled()) {
+            process.stderr.write("hook-batch: journal-due requires the core-hook-batch flag\n");
+            process.exitCode = 1;
+            return;
+        }
+        const root = resolveLiveRoot({ hqRoot: core.opts().hqRoot });
+        const args = ["--session", options.session, ...(options.reset ? ["--reset"] : [])];
+        const code = runCoreHookBatchFast(args, "", process.cwd(), root);
+        if (code !== 0)
+            process.exitCode = code;
+    });
+    describeCoreCommand(journalDue, { execution: "native", root: "live" });
+}
+//# sourceMappingURL=core-hook-batch-command.js.map

package/dist/commands/core-hook-batch-flag.d.ts

@@ -0,0 +1,4 @@
+/** Default-off gate for the batched PostToolUse helper command. */
+export declare const CORE_HOOK_BATCH_FLAG = "core-hook-batch";
+export declare function coreHookBatchEnabled(): Promise<boolean>;
+//# sourceMappingURL=core-hook-batch-flag.d.ts.map

package/dist/commands/core-hook-batch-flag.js

@@ -0,0 +1,7 @@
+/** Default-off gate for the batched PostToolUse helper command. */
+export const CORE_HOOK_BATCH_FLAG = "core-hook-batch";
+export async function coreHookBatchEnabled() {
+    const { resolveProcessFlagGate } = await import("../lib/flag-registry.js");
+    return resolveProcessFlagGate(CORE_HOOK_BATCH_FLAG, { fallback: false }, () => false);
+}
+//# sourceMappingURL=core-hook-batch-flag.js.map

package/dist/commands/core-hook-batch-native.d.ts

@@ -0,0 +1,10 @@
+import { type SessionJournalOperationResult } from "./core-session-journal-native.js";
+import type { SessionHelperRuntimeOverrides } from "./core-session-helper-runtime.js";
+export declare const CORE_HOOK_BATCH_HELP = "Usage: hq core hook-batch journal-due --session <key> [--reset]\n\nRuns session-journal dir-path, tool-counter increment, and tool-counter read\ninside one process. With --reset, tool-counter reset runs before increment.\n\nOutput framing: one ASCII line per helper call, in execution order:\n  HQHB1|<step>|<exit-code>|<stdout-base64>|<stderr-base64>\nThe delimiter is |; the final newline ends each record. Base64 preserves each\nhelper stream byte-for-byte. In Bash, read each field and decode a stream with\nbase64 --decode (GNU) or base64 -D (BSD); jq is not needed. A helper's code 0\ndoes not imply empty output, and empty streams have empty base64 fields.\n";
+type BatchResult = SessionJournalOperationResult;
+/** Build the no-jq frame over the same in-process operation used by session-journal. */
+export declare function runCoreHookBatch(args: readonly string[], stdin: string, cwd: string, hqRoot: string | undefined, dependencies?: SessionHelperRuntimeOverrides): BatchResult;
+/** Fast-route entrypoint; the encoded records are the only top-level output. */
+export declare function runCoreHookBatchFast(args: readonly string[], stdin: string, cwd: string, hqRoot: string | undefined): number | undefined;
+export {};
+//# sourceMappingURL=core-hook-batch-native.d.ts.map

package/dist/commands/core-hook-batch-native.js

@@ -0,0 +1,85 @@
+import { runSessionJournalOperation } from "./core-session-journal-native.js";
+export const CORE_HOOK_BATCH_HELP = `Usage: hq core hook-batch journal-due --session <key> [--reset]
+
+Runs session-journal dir-path, tool-counter increment, and tool-counter read
+inside one process. With --reset, tool-counter reset runs before increment.
+
+Output framing: one ASCII line per helper call, in execution order:
+  HQHB1|<step>|<exit-code>|<stdout-base64>|<stderr-base64>
+The delimiter is |; the final newline ends each record. Base64 preserves each
+helper stream byte-for-byte. In Bash, read each field and decode a stream with
+base64 --decode (GNU) or base64 -D (BSD); jq is not needed. A helper's code 0
+does not imply empty output, and empty streams have empty base64 fields.
+`;
+function usageError() {
+    return { code: 1, stdout: Buffer.alloc(0), stderr: Buffer.from(CORE_HOOK_BATCH_HELP) };
+}
+function frame(name, result) {
+    const line = [
+        "HQHB1",
+        name,
+        String(result.code),
+        result.stdout.toString("base64"),
+        result.stderr.toString("base64"),
+    ].join("|");
+    return Buffer.from(`${line}\n`, "ascii");
+}
+function parseArgs(args) {
+    if (args.includes("--help") || args.includes("-h"))
+        return "help";
+    let session;
+    let reset = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--session") {
+            const value = args[index + 1];
+            if (!value || value.startsWith("--"))
+                return undefined;
+            session = value;
+            index += 1;
+        }
+        else if (arg === "--reset") {
+            reset = true;
+        }
+        else {
+            return undefined;
+        }
+    }
+    if (!session)
+        return undefined;
+    return { session, reset };
+}
+function runParsedCoreHookBatch(parsed, stdin, cwd, hqRoot, dependencies) {
+    const sessionArgs = ["--session", parsed.session];
+    const steps = [
+        { name: "dir-path", args: ["dir-path"] },
+        ...(parsed.reset ? [{ name: "reset", args: ["tool-counter", "reset", ...sessionArgs] }] : []),
+        { name: "increment", args: ["tool-counter", "increment", ...sessionArgs] },
+        { name: "read", args: ["tool-counter", "read", ...sessionArgs] },
+    ];
+    const records = steps.map((step) => {
+        const result = runSessionJournalOperation(step.args, stdin, cwd, hqRoot, dependencies);
+        return frame(step.name, result);
+    });
+    return { code: 0, stdout: Buffer.concat(records), stderr: Buffer.alloc(0) };
+}
+/** Build the no-jq frame over the same in-process operation used by session-journal. */
+export function runCoreHookBatch(args, stdin, cwd, hqRoot, dependencies = {}) {
+    const parsed = parseArgs(args);
+    if (parsed === "help")
+        return { code: 0, stdout: Buffer.from(CORE_HOOK_BATCH_HELP), stderr: Buffer.alloc(0) };
+    if (!parsed)
+        return usageError();
+    return runParsedCoreHookBatch(parsed, stdin, cwd, hqRoot, dependencies);
+}
+/** Fast-route entrypoint; the encoded records are the only top-level output. */
+export function runCoreHookBatchFast(args, stdin, cwd, hqRoot) {
+    const parsed = parseArgs(args);
+    if (!parsed || parsed === "help")
+        return undefined;
+    const result = runParsedCoreHookBatch(parsed, stdin, cwd, hqRoot, {});
+    process.stdout.write(result.stdout);
+    process.stderr.write(result.stderr);
+    return result.code;
+}
+//# sourceMappingURL=core-hook-batch-native.js.map

package/dist/commands/core-repo-run-registry-native.js

@@ -131,7 +131,12 @@ export function runRepoRunRegistry(args, deps) {
                         catch { /* shell falls back to epoch zero when stat fails */ }
                         const age = Math.floor(now().getTime() / 1000) - Math.floor(mtimeMs / 1000);
                         if (age > 60) {
-                            f.rmSync(lockDir, { recursive: true, force: true });
+                            try {
+                                f.rmSync(lockDir, { recursive: true, force: true });
+                            }
+                            catch {
+                                throw new Error(`ERROR: could not remove stale registry lock: ${lockDir}`);
+                            }
                             continue;
                         }
                     }

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

@@ -1,4 +1,11 @@
 import { type SessionHelperRuntimeOverrides } from "./core-session-helper-runtime.js";
+export type SessionJournalOperationResult = {
+    code: number;
+    stdout: Buffer;
+    stderr: Buffer;
+};
+/** Execute one native helper call while retaining its two output byte streams. */
+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 declare function runSessionJournalFast(args: readonly string[], stdin: string, cwd: string, hqRoot: string | undefined, dependencies?: SessionHelperRuntimeOverrides): number;
 //# sourceMappingURL=core-session-journal-native.d.ts.map

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

@@ -1,6 +1,7 @@
 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.js";
 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]
@@ -94,7 +95,7 @@ function acquireJournalWriteLock(dir) {
             try {
                 fs.writeFileSync(ownerFile, `${process.pid}\n`, { flag: "wx" });
             }
-            catch (error) {
+            catch {
                 fs.rmSync(lock, { recursive: true, force: true });
                 return undefined;
             }
@@ -178,7 +179,7 @@ function options(args, valueFlags) {
     }
     return values;
 }
-function runToolCounter(root, action, sessionArg, env, now) {
+function runToolCounter(root, action, sessionArg, env, now, writers) {
     const rawKey = sessionArg || env.HQ_JOURNAL_SESSION || env.HQ_HOOK_SESSION_ID || "";
     const key = counterKey(rawKey);
     const dir = journalDir(root, now().toISOString().slice(0, 10));
@@ -188,31 +189,60 @@ function runToolCounter(root, action, sessionArg, env, now) {
     catch { /* legacy mkdir failure is ignored */ }
     const counter = path.join(dir, `.tool-count-${key}`);
     const lock = `${counter}.lock`;
+    const reportDirectoryWriteFailure = (error, line) => {
+        const code = error.code;
+        if (code !== "EISDIR")
+            return;
+        const asset = resolveBundledAsset("core/scripts/session-journal.sh");
+        writers.stderr(`${asset}: line ${line}: ${counter}: Is a directory\n`);
+    };
     if (action === "increment") {
         withCounterLock(lock, () => {
             try {
                 fs.writeFileSync(counter, `${readCounter(counter) + 1}\n`);
             }
-            catch { /* fail soft */ }
+            catch (error) {
+                reportDirectoryWriteFailure(error, 312);
+            }
         });
     }
     else if (action === "read") {
-        process.stdout.write(`${readCounter(counter)}\n`);
+        writers.stdout(`${readCounter(counter)}\n`);
     }
     else if (action === "reset") {
         withCounterLock(lock, () => {
             try {
                 fs.writeFileSync(counter, "0\n");
             }
-            catch { /* fail soft */ }
+            catch (error) {
+                reportDirectoryWriteFailure(error, 320);
+            }
         });
     }
     else {
-        warning("tool-counter: subcommand required (increment|read|reset)");
+        writers.stderr("session-journal: tool-counter: subcommand required (increment|read|reset)\n");
     }
 }
+/** Execute one native helper call while retaining its two output byte streams. */
+export function runSessionJournalOperation(args, _stdin, cwd, hqRoot, dependencies = {}) {
+    const stdout = [];
+    const stderr = [];
+    const writers = {
+        stdout: (chunk) => stdout.push(Buffer.from(chunk)),
+        stderr: (chunk) => stderr.push(Buffer.from(chunk)),
+    };
+    const code = executeSessionJournal(args, cwd, hqRoot, dependencies, writers);
+    return { code, stdout: Buffer.concat(stdout), stderr: Buffer.concat(stderr) };
+}
 /** Native implementation of the fail-soft session journal helper. */
-export function runSessionJournalFast(args, _stdin, cwd, hqRoot, dependencies = {}) {
+export function runSessionJournalFast(args, stdin, cwd, hqRoot, dependencies = {}) {
+    const result = runSessionJournalOperation(args, stdin, cwd, hqRoot, dependencies);
+    process.stdout.write(result.stdout);
+    process.stderr.write(result.stderr);
+    return result.code;
+}
+function executeSessionJournal(args, cwd, hqRoot, dependencies, writers) {
+    const warning = (message) => { writers.stderr(`session-journal: ${message}\n`); };
     const runtime = resolveSessionHelperRuntime(dependencies);
     const today = () => runtime.now().toISOString().slice(0, 10);
     const nowIso = () => runtime.now().toISOString().replace(/\.\d{3}Z$/, "Z");
@@ -296,8 +326,8 @@ export function runSessionJournalFast(args, _stdin, cwd, hqRoot, dependencies =
         finally {
             releaseJournalWriteLock(writeLock);
         }
-        runToolCounter(root, "reset", counterKey(session || runtime.env.HQ_JOURNAL_SESSION || runtime.env.HQ_HOOK_SESSION_ID || ""), runtime.env, runtime.now);
-        process.stdout.write(`${output}\n`);
+        runToolCounter(root, "reset", counterKey(session || runtime.env.HQ_JOURNAL_SESSION || runtime.env.HQ_HOOK_SESSION_ID || ""), runtime.env, runtime.now, writers);
+        writers.stdout(`${output}\n`);
         return 0;
     }
     if (command === "list" || command === "read" || command === "index-path" || command === "dir-path") {
@@ -306,19 +336,19 @@ export function runSessionJournalFast(args, _stdin, cwd, hqRoot, dependencies =
         const date = options(afterSequence, ["--date"]).get("--date") || today();
         const dir = journalDir(root, date);
         if (command === "dir-path") {
-            process.stdout.write(dir);
+            writers.stdout(dir);
             return 0;
         }
         if (command === "index-path") {
-            process.stdout.write(`${dir}/INDEX.md\n`);
+            writers.stdout(`${dir}/INDEX.md\n`);
             return 0;
         }
         if (command === "list") {
             const index = path.join(dir, "INDEX.md");
             if (hasFile(index))
-                process.stdout.write(fs.readFileSync(index));
+                writers.stdout(fs.readFileSync(index));
             else
-                process.stdout.write(`(no journal for ${date})\n`);
+                writers.stdout(`(no journal for ${date})\n`);
             return 0;
         }
         if (!sequence) {
@@ -339,7 +369,7 @@ export function runSessionJournalFast(args, _stdin, cwd, hqRoot, dependencies =
             }
         })();
         if (match)
-            process.stdout.write(fs.readFileSync(path.join(dir, match)));
+            writers.stdout(fs.readFileSync(path.join(dir, match)));
         else
             warning(`read: no entry ${normalized} for ${date}`);
         return 0;
@@ -347,10 +377,10 @@ export function runSessionJournalFast(args, _stdin, cwd, hqRoot, dependencies =
     if (command === "tool-counter") {
         const action = rest[0] ?? "";
         const session = options(rest.slice(1), ["--session"]).get("--session") ?? "";
-        runToolCounter(root, action, session, runtime.env, runtime.now);
+        runToolCounter(root, action, session, runtime.env, runtime.now, writers);
         return 0;
     }
-    process.stderr.write(USAGE);
+    writers.stderr(USAGE);
     return 1;
 }
 //# sourceMappingURL=core-session-journal-native.js.map

package/dist/commands/core.js

@@ -47,6 +47,7 @@ import { registerCoreRefreshVaultAccessNative } from "./core-refresh-vault-acces
 import { registerCoreWorkMeshBindTrustedNative } from "./core-work-mesh-bind-trusted-native.js";
 import { registerCoreHookHelperNativeCommands } from "./core-native-hook-helper-commands.js";
 import { registerCoreHookStateHelpers } from "./core-hook-state-helpers-native.js";
+import { registerCoreHookBatchCommand } from "./core-hook-batch-command.js";
 import { resolveLiveRoot } from "../utils/hq-roots.js";
 import { interpreterFor, runBundledScript } from "../utils/run-bundled-script.js";
 import { CompanyIndexUserError, renderIndexTarget } from "../lib/index-render/index.js";
@@ -397,6 +398,7 @@ export function registerCoreCommands(program) {
     registerCoreWorkMeshBindTrustedNative(core);
     registerCoreHookHelperNativeCommands(core);
     registerCoreHookStateHelpers(core);
+    registerCoreHookBatchCommand(core);
     const sessionHelperCommands = [
         {
             name: "session-journal", asset: "core/scripts/session-journal.sh", root: "live",

package/dist/fast-core.js

@@ -35,6 +35,11 @@ export async function runFastCore(argv) {
         const envOverride = localBooleanFlagOverride(entry.familyFlagKey, process.env);
         familyEnabled = envOverride ?? await (await import("./native-fast-route.js")).fastFlagEnabled(entry.familyFlagKey, process.env, { numericEnvironmentOverride: false });
     }
+    if (entry.kind === "native" && entry.fallbackToCommandGraph && !familyEnabled) {
+        const { runCli } = await import("./main.js");
+        await runCli();
+        return;
+    }
     const useShell = entry.kind === "native" && Boolean(entry.familyFlagKey) && !familyEnabled;
     const worktreeScopeFixEnabled = entry.name === "repo-run-registry"
         ? await (await import("./native-fast-route.js")).fastFlagEnabled(CORE_RRR_WORKTREE_SCOPE_FIX_FLAG, process.env, { numericEnvironmentOverride: false })
@@ -74,6 +79,14 @@ export async function runFastCore(argv) {
         const readsStdin = entry.readsStdinFor?.(parsed.args) ?? entry.readsStdin ?? false;
         const stdin = readsStdin ? await readStdinIfPiped(process.stdin) : "";
         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) {
+                throw new Error(`Native fast handler ${entry.exportName} requested an unavailable command-graph fallback`);
+            }
+            const { runCli } = await import("./main.js");
+            await runCli();
+            return;
+        }
         // Let Node drain handler output before terminating. The timeout guard's
         // stderr message must survive the native route's process boundary.
         process.exitCode = code;

package/dist/fast-scaffold.d.ts

@@ -32,6 +32,8 @@ export type FastScaffoldScript = {
     familyFlagKey?: string;
     /** Shell rollback companion used while the family gate is off. */
     asset?: string;
+    /** Return to the Commander graph when this new route has no shell companion. */
+    fallbackToCommandGraph?: boolean;
     /** Root context used by the native handler. */
     root?: "live" | "cwd" | "passthrough";
     /** Cwd used for a shell rollback companion. Defaults to the caller cwd. */

package/dist/fast-scaffold.js

@@ -217,6 +217,16 @@ export const FAST_SCAFFOLD_SCRIPTS = [
         shellHqRoot: "live",
         ...(name === "session-project" ? { readsStdin: true, readsStdinFor: (args) => args[0] === "ingest-plan" } : {}),
     })),
+    {
+        name: "hook-batch journal-due",
+        kind: "native",
+        modulePath: "./commands/core-hook-batch-native.js",
+        exportName: "runCoreHookBatchFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-hook-batch",
+        root: "live",
+        fallbackToCommandGraph: true,
+    },
     ...[
         { name: "eval-trigger", modulePath: "./commands/core-eval-trigger-native.js", exportName: "runEvalTriggerFast", asset: "core/scripts/eval-trigger.sh", root: "cwd", shellCwd: "caller", shellHqRoot: "none", readsStdinFor: (args) => args[0] === "--check" },
         { name: "migrate-policy-triggers", modulePath: "./commands/core-migrate-policy-triggers-native.js", exportName: "runMigratePolicyTriggersFast", asset: "core/scripts/migrate-policy-triggers.sh", root: "live", shellCwd: "caller", shellHqRoot: "live" },

package/dist/lib/work-context/bind-best.d.ts

@@ -41,7 +41,7 @@ export declare function discoverProjects(input: {
     env?: NodeJS.ProcessEnv;
     home?: string;
 }): CatalogProject[];
-/** discoverProjects memoized by directory mtime. A cache hit does not rescan. */
+/** discoverProjects memoized by source directory and mtime. A hit does not rescan. */
 export declare function discoverProjectsCached(input: Parameters<typeof discoverProjects>[0], nowMs?: number): CatalogProject[];
 export declare function refineProjectBinding(input: {
     hint?: string;

package/dist/lib/work-context/bind-best.js

@@ -215,14 +215,14 @@ function catalogStamp(input) {
         if (!dir)
             return "0";
         try {
-            return String(fs.statSync(dir).mtimeMs);
+            return `${dir}:${fs.statSync(dir).mtimeMs}`;
         }
         catch {
-            return "0";
+            return `${dir}:0`;
         }
     }).join("|");
 }
-/** discoverProjects memoized by directory mtime. A cache hit does not rescan. */
+/** discoverProjects memoized by source directory and mtime. A hit does not rescan. */
 export function discoverProjectsCached(input, nowMs = Date.now()) {
     const key = `${input.hqRoot ?? ""}|${input.companySlug ?? ""}|${input.companyUid ?? ""}|${input.home ?? ""}|${catalogStamp(input)}`;
     if (catalogCache && catalogCache.key === key && nowMs - catalogCache.at < CATALOG_CACHE_TTL_MS) {

package/package.json

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