@indigoai-us/hq-cli 5.345.115 → 5.345.117

package/CHANGELOG.md

@@ -2,9 +2,15 @@
 
 ## [Unreleased]
 
+## [5.345.117] — 2026-10-13
+- `hq lanes monitor-check` answers a session that owns no active lane from the lane-record directory alone, without loading the command graph. The Claude Stop hook runs it after every turn in every session; per-call CPU drops from about 545 ms to about 60 ms. Sessions with an active lane, corrupt records, or conflict sidecars still use the full command.
+
+## [5.345.116] — 2026-10-13
+
 ## [5.345.115] — 2026-10-13
 - The bundled delegate-send shell now caches the Git Bash `jq --binary` capability probe for one invocation instead of starting `jq.exe` before every jq operation.
 - Remove the bundled scheduled jobs shell copies and route scheduled job units, probes, validation, notifications, and reconciliation through native HQ core commands. Fixed shell-output fixtures retain differential coverage for all 238 cases, and the published E2E matrix now runs native-only probes for these commands.
+- `hq core scan-packages` no longer refuses to wire a pack worker because a worker with the same id sits inside a tenant's `repos/` checkout. Its id-collision check now skips the directories the worker registry skips (tenant `repos/`, `_template`, `_overrides`), so pack workers such as `qa-tester` link again.
 
 - `hq core checkpoint` now runs its background sibling under a supervisor that
   stops it after 30 minutes and kills any process it left behind, and the

package/dist/index.js

@@ -13,6 +13,7 @@ import { CLI_COMMAND_HELP_CATALOG_FLAG } from "./lib/cli-flag-keys.js";
 import { installProcessRejectionBoundary } from "./unhandled-rejection-boundary.js";
 import { installFastPathStreamErrorHandlers } from "./utils/fast-stream-errors.js";
 import { fileURLToPath } from "node:url";
+import { parseMonitorCheckFastRequest } from "./lanes-monitor-check-argv.js";
 import { createRequire } from "node:module";
 function cygpathMixedPath(value) {
     // Require only a Node builtin: the package supports Node releases before
@@ -143,6 +144,16 @@ async function runNativeFastRouteWithRecovery(parsed) {
         await runMainWithInstallTreeRecovery();
     }
 }
+async function runMonitorCheckFastWithRecovery(request) {
+    const loaded = await recoverFastImport(() => import("./lanes-monitor-check-fast.js"));
+    if (loaded.reexecStatus !== undefined) {
+        process.exitCode = loaded.reexecStatus;
+        return;
+    }
+    if (loaded.module?.runMonitorCheckFast(request))
+        return;
+    await runMainWithInstallTreeRecovery();
+}
 function dispatchCliEntry() {
     if (process.platform === "win32" && coreCommandHasPathOperands(process.argv)) {
         // Keep cygpath off non-Windows and non-path command routes.
@@ -181,6 +192,12 @@ function dispatchCliEntry() {
             await runMainWithInstallTreeRecovery();
         });
     }
+    else if (parseMonitorCheckFastRequest(process.argv)) {
+        // The Stop hook runs this every turn in every session. Answer the common
+        // no-active-lane case from the lane-record directory alone; anything the
+        // fast route cannot prove falls back to the full command graph.
+        void runMonitorCheckFastWithRecovery(parseMonitorCheckFastRequest(process.argv));
+    }
     else if (parsedFastCore?.entry.kind === "native" &&
         (process.env.HQ_FLAG_HQ_CORE_NATIVE_FAST_ROUTE === "true" ||
             process.env.HQ_FLAG_HQ_CORE_NATIVE_FAST_ROUTE === "1")) {

package/dist/lanes-monitor-check-argv.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Dependency-free argv matcher for the `hq lanes monitor-check` fast route.
+ * Imported statically by src/index.ts, so it must not import anything.
+ */
+export interface MonitorCheckFastRequest {
+    sessionId: string;
+    engine?: string;
+    json: boolean;
+}
+/** Exactly `hq lanes monitor-check --session <id> [--engine <e>] [--json]`. */
+export declare function parseMonitorCheckFastRequest(argv: readonly string[]): MonitorCheckFastRequest | null;
+//# sourceMappingURL=lanes-monitor-check-argv.d.ts.map

package/dist/lanes-monitor-check-argv.js

@@ -0,0 +1,54 @@
+/**
+ * Dependency-free argv matcher for the `hq lanes monitor-check` fast route.
+ * Imported statically by src/index.ts, so it must not import anything.
+ */
+const SAFE_SESSION_ID = /^[A-Za-z0-9._:-]{1,200}$/u;
+/** Exactly `hq lanes monitor-check --session <id> [--engine <e>] [--json]`. */
+export function parseMonitorCheckFastRequest(argv) {
+    if (argv[2] !== "lanes" || argv[3] !== "monitor-check")
+        return null;
+    let sessionId;
+    let engine;
+    let json = false;
+    const args = argv.slice(4);
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        let name = arg;
+        let value;
+        const eq = arg.indexOf("=");
+        if (arg.startsWith("--") && eq > 0) {
+            name = arg.slice(0, eq);
+            value = arg.slice(eq + 1);
+        }
+        if (name === "--json" && value === undefined) {
+            if (json)
+                return null;
+            json = true;
+        }
+        else if (name === "--session" || name === "--engine") {
+            if (value === undefined) {
+                value = args[++i];
+                if (value === undefined || value.startsWith("-"))
+                    return null;
+            }
+            if (name === "--session") {
+                if (sessionId !== undefined)
+                    return null;
+                sessionId = value;
+            }
+            else {
+                if (engine !== undefined)
+                    return null;
+                engine = value;
+            }
+        }
+        else {
+            return null;
+        }
+    }
+    const trimmed = sessionId?.trim();
+    if (!trimmed || !SAFE_SESSION_ID.test(trimmed))
+        return null;
+    return { sessionId: trimmed, engine, json };
+}
+//# sourceMappingURL=lanes-monitor-check-argv.js.map

package/dist/lanes-monitor-check-fast.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Startup fast route for `hq lanes monitor-check`.
+ *
+ * The Claude Stop hook (`lanes-senior-monitor-stop-gate.sh`) runs this command
+ * at the end of every assistant turn in every HQ session, and the
+ * SessionStart/UserPromptSubmit shim runs it too. Through the full command
+ * graph each call cost ~0.6-0.9 s of CPU, almost all of it module loading
+ * (Commander graph, Sentry, undici, the flag-registry worker). With several
+ * sessions open that kept one core busy continuously.
+ *
+ * Nearly every call is for a session that owns no active lane, so the answer
+ * is an empty result that needs only the lane-record directory. This module
+ * answers that case with `fs` alone. It returns `false` (caller falls back to
+ * the full command) whenever the answer could differ from the full path:
+ * unusual argv, an unresolvable root, an unreadable store, a conflict sidecar,
+ * a record that does not parse, or any record that may name this session as an
+ * active senior. The Monitor evidence scan never runs here.
+ */
+import type { MonitorCheckFastRequest } from "./lanes-monitor-check-argv.js";
+export { parseMonitorCheckFastRequest } from "./lanes-monitor-check-argv.js";
+export type { MonitorCheckFastRequest } from "./lanes-monitor-check-argv.js";
+export interface MonitorCheckFastDeps {
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+    readdirSync?: (dir: string) => string[];
+    readFileSync?: (file: string) => string;
+    write?: (text: string) => void;
+}
+export interface MonitorCheckFastResult {
+    ok: true;
+    action: "monitor-check";
+    session_id: string;
+    engine: string;
+    active_lane_ids: string[];
+    covered_lane_ids: string[];
+    uncovered_lane_ids: string[];
+    skipped?: "engine_has_no_claude_monitor";
+}
+/**
+ * Compute the result without the command graph, or `null` when the full
+ * command must decide. Exposed for tests that count filesystem calls.
+ */
+export declare function computeMonitorCheckFast(request: MonitorCheckFastRequest, deps?: MonitorCheckFastDeps): MonitorCheckFastResult | null;
+/** Returns true when the fast route answered; false means run the full CLI. */
+export declare function runMonitorCheckFast(request: MonitorCheckFastRequest, deps?: MonitorCheckFastDeps): boolean;
+//# sourceMappingURL=lanes-monitor-check-fast.d.ts.map

package/dist/lanes-monitor-check-fast.js

@@ -0,0 +1,121 @@
+/**
+ * Startup fast route for `hq lanes monitor-check`.
+ *
+ * The Claude Stop hook (`lanes-senior-monitor-stop-gate.sh`) runs this command
+ * at the end of every assistant turn in every HQ session, and the
+ * SessionStart/UserPromptSubmit shim runs it too. Through the full command
+ * graph each call cost ~0.6-0.9 s of CPU, almost all of it module loading
+ * (Commander graph, Sentry, undici, the flag-registry worker). With several
+ * sessions open that kept one core busy continuously.
+ *
+ * Nearly every call is for a session that owns no active lane, so the answer
+ * is an empty result that needs only the lane-record directory. This module
+ * answers that case with `fs` alone. It returns `false` (caller falls back to
+ * the full command) whenever the answer could differ from the full path:
+ * unusual argv, an unresolvable root, an unreadable store, a conflict sidecar,
+ * a record that does not parse, or any record that may name this session as an
+ * active senior. The Monitor evidence scan never runs here.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { resolveLiveRoot } from "./utils/hq-roots-core.js";
+export { parseMonitorCheckFastRequest } from "./lanes-monitor-check-argv.js";
+const ENGINES = new Set(["claude", "codex", "grok"]);
+const ACTIVE_STATES = new Set(["running", "queued", "awaiting_input", "blocked"]);
+/**
+ * Compute the result without the command graph, or `null` when the full
+ * command must decide. Exposed for tests that count filesystem calls.
+ */
+export function computeMonitorCheckFast(request, deps = {}) {
+    const env = deps.env ?? process.env;
+    const readdirSync = deps.readdirSync ?? ((dir) => fs.readdirSync(dir));
+    const readFileSync = deps.readFileSync ?? ((file) => fs.readFileSync(file, "utf8"));
+    const engine = request.engine?.trim().toLowerCase() ||
+        env.HQ_LANE_ENGINE?.trim().toLowerCase() ||
+        env.HQ_CONDUCT_ENGINE?.trim().toLowerCase() ||
+        "claude";
+    if (!ENGINES.has(engine))
+        return null;
+    let root;
+    try {
+        root = resolveLiveRoot({ env, cwd: deps.cwd });
+    }
+    catch {
+        return null;
+    }
+    const laneDir = path.join(root, "workspace", "lanes", "lanes");
+    let names;
+    try {
+        names = readdirSync(laneDir);
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            return null;
+        names = [];
+    }
+    const needle = JSON.stringify(request.sessionId);
+    const activeLaneIds = [];
+    for (const name of names) {
+        if (typeof name !== "string" || name.startsWith("."))
+            continue;
+        // Sidecars are merged by the full reader; let it decide.
+        if (name.includes(".conflict-"))
+            return null;
+        if (!name.endsWith(".json"))
+            continue;
+        let text;
+        let record;
+        try {
+            text = readFileSync(path.join(laneDir, name));
+            record = JSON.parse(text);
+        }
+        catch {
+            return null;
+        }
+        if (!record || typeof record !== "object" || Array.isArray(record))
+            return null;
+        // A record that never mentions the session id cannot belong to it.
+        if (!text.includes(needle))
+            continue;
+        const lane = record;
+        const senior = lane.senior;
+        if (!senior ||
+            typeof senior !== "object" ||
+            typeof senior.kind !== "string" ||
+            typeof senior.id !== "string" ||
+            typeof lane.state !== "string" ||
+            typeof lane.lane_id !== "string") {
+            return null;
+        }
+        if (senior.kind === "session" && senior.id === request.sessionId && ACTIVE_STATES.has(lane.state)) {
+            // Claude needs the Monitor evidence reader; leave it to the full path.
+            if (engine === "claude")
+                return null;
+            activeLaneIds.push(lane.lane_id);
+        }
+    }
+    const result = {
+        ok: true,
+        action: "monitor-check",
+        session_id: request.sessionId,
+        engine,
+        active_lane_ids: activeLaneIds,
+        covered_lane_ids: [],
+        uncovered_lane_ids: [],
+    };
+    if (engine !== "claude")
+        result.skipped = "engine_has_no_claude_monitor";
+    return result;
+}
+/** Returns true when the fast route answered; false means run the full CLI. */
+export function runMonitorCheckFast(request, deps = {}) {
+    const result = computeMonitorCheckFast(request, deps);
+    if (!result)
+        return false;
+    if (request.json) {
+        const write = deps.write ?? ((text) => process.stdout.write(text));
+        write(`${JSON.stringify(result, null, 2)}\n`);
+    }
+    return true;
+}
+//# sourceMappingURL=lanes-monitor-check-fast.js.map

package/dist/lib/scan-packages/index.js

@@ -4,6 +4,7 @@ import * as path from 'node:path';
 import * as yaml from 'js-yaml';
 import { contributionLinks } from '../../utils/pack-contribution-links.js';
 import { CONTRIBUTION_TABLE } from '../../utils/contribution-table.js';
+import { isExcludedWorkerDirectory } from '../workers-registry/index.js';
 function isDirectory(target) { try {
     return fs.statSync(target).isDirectory();
 }
@@ -75,6 +76,11 @@ function workerId(file) {
 function allWorkerYamlFiles(root, relative) {
     const output = [];
     const walk = (next, seen) => {
+        // Prune exactly what the worker registry prunes (tenant repos/ checkouts,
+        // _template, _overrides). A worker.yaml the registry never indexes cannot
+        // collide with a pack worker, and walking source checkouts is slow.
+        if (isExcludedWorkerDirectory(next))
+            return;
         const absolute = path.join(root, next);
         if (!isDirectory(absolute))
             return;

package/dist/lib/workers-registry/index.d.ts

@@ -9,6 +9,22 @@ export interface GenerateWorkersRegistryResult {
     written: boolean;
     quarantined: number;
 }
+/**
+ * Worker roots hold two kinds of `worker.yaml` that must never reach the
+ * registry.
+ *
+ * The `_template` company and any `_overrides` directory are scaffolding —
+ * copies kept so a new tenant or a pack override can be stamped out from them.
+ *
+ * A checkout nested under a tenant's `repos/` is a source repository that tenant
+ * happens to keep inside HQ, and when that repository is HQ itself, its own
+ * `core/workers` and template trees are full of worker.yaml files. Indexing them
+ * treats product source as deployed workers: they claim ids real workers already
+ * own, and because duplicates resolve by path order — a tenant path sorts before
+ * both `core` and `personal` — the checkout wins. The operator's actual worker
+ * then silently vanishes from the registry every skill reads.
+ */
+export declare function isExcludedWorkerDirectory(relativeDirectory: string): boolean;
 /**
  * Generate core/workers/registry.yaml from worker.yaml files. Invalid workers
  * are quarantined but do not prevent all valid workers from being registered.

package/dist/lib/workers-registry/index.js

@@ -158,7 +158,7 @@ function withoutTimestamp(content) {
  * both `core` and `personal` — the checkout wins. The operator's actual worker
  * then silently vanishes from the registry every skill reads.
  */
-function isExcludedWorkerDirectory(relativeDirectory) {
+export function isExcludedWorkerDirectory(relativeDirectory) {
     const normalized = relativeDirectory.replaceAll('\\', '/');
     const [root, tenant, nested] = normalized.split('/');
     if (root !== 'companies')

package/package.json

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