@indigoai-us/hq-cli 5.345.10 → 5.345.12

package/dist/commands/core-pin-fast.js

@@ -0,0 +1,15 @@
+/** Isolated fast-entry adapter for the native pin utility. */
+import { runPin } from "./core-pin-native.js";
+export function runPinFast(args, _stdin, _cwd, hqRoot) {
+    const result = runPin([...args], {
+        root: hqRoot ?? process.env.HQ_ROOT ?? process.cwd(),
+        env: process.env,
+        now: () => new Date(),
+    });
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    return result.code;
+}
+//# sourceMappingURL=core-pin-fast.js.map

package/dist/commands/core-rebuild-index-fast.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Run a standard rebuild with the same renderer used by the full command.
+ * Argument forms that need Commander error formatting remain on the full graph.
+ */
+export declare function runRebuildIndexFast(args: readonly string[], _stdin: string, _cwd: string, hqRoot: string | undefined): Promise<number | undefined>;
+//# sourceMappingURL=core-rebuild-index-fast.d.ts.map

package/dist/commands/core-rebuild-index-fast.js

@@ -0,0 +1,39 @@
+/** Isolated fast-entry adapter for rebuild-index native renderers. */
+import { CompanyIndexUserError, renderIndexTarget } from "../lib/index-render/index.js";
+const targets = new Set([
+    "all", "companies", "company-knowledge", "orchestrator", "projects",
+    "public-knowledge", "reports", "social-drafts", "threads", "workers",
+]);
+/**
+ * Run a standard rebuild with the same renderer used by the full command.
+ * Argument forms that need Commander error formatting remain on the full graph.
+ */
+export async function runRebuildIndexFast(args, _stdin, _cwd, hqRoot) {
+    const [target, ...rest] = args;
+    if (!target || !targets.has(target) || rest.length > 0 || !hqRoot)
+        return undefined;
+    const logs = [];
+    const flushLogs = () => {
+        for (const message of logs)
+            process.stderr.write(`${message}\n`);
+    };
+    try {
+        const refused = [];
+        renderIndexTarget(target, {
+            root: hqRoot,
+            log: (message) => logs.push(message),
+            refused,
+        });
+        if (refused.length > 0)
+            return undefined;
+        flushLogs();
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof CompanyIndexUserError)
+            return undefined;
+        flushLogs();
+        throw error;
+    }
+}
+//# sourceMappingURL=core-rebuild-index-fast.js.map

package/dist/commands/core-register-project-native.js

@@ -5,14 +5,18 @@ import * as path from "node:path";
 import { spawnSync } from "node:child_process";
 import { serializeJqJson } from "../lib/core-utils/jq-json-serializer.js";
 import { resolveBundledAsset } from "../utils/hq-roots-core.js";
+import { buildSpawnPlan } from "../utils/windows-spawn.js";
 export const REGISTER_PROJECT_ASSET = "core/scripts/register-project.sh";
 const USAGE = "usage: register-project.sh <company> <project> | --audit <company> | --backfill <company> --only-active [--yes] | --retry-pending <company>";
 const MIN_HQ_CLI = "5.139.0";
 export function createRegisterProjectHqRunner(spawn = spawnSync) {
     return (args, options) => {
-        const result = spawn("hq", args, {
+        const plan = buildSpawnPlan("hq", args);
+        const { cmd, args: spawnArgs, ...spawnOptions } = plan;
+        const result = spawn(cmd, spawnArgs, {
             cwd: options.cwd,
             env: options.env,
+            ...spawnOptions,
             encoding: "utf8",
             // Shell hq children inherit fd 0 even when their output is captured or discarded.
             stdio: options.capture ? ["inherit", "pipe", "pipe"] : ["inherit", "ignore", "ignore"],
@@ -130,7 +134,12 @@ function ensureOne(company, project, deps) {
         catch { /* legacy jq/write errors remain a failed registration */ }
         return errorResult(`hq-cli ${MIN_HQ_CLI} or newer is required; ${company}/${project} stays local until then`);
     }
-    const ensure = deps.runHq(["mesh", "project", "ensure", project, "--company", company, "--stories-file", prd, "--json"], {
+    // The shell builds this argument from its raw HQ_ROOT plus POSIX separators.
+    // On Git Bash that preserves a Win32 drive prefix and appends `/companies/...`.
+    const hqPrd = process.platform === "win32"
+        ? `${deps.root.replace(/[\\/]+$/u, "")}/companies/${company}/projects/${project}/prd.json`
+        : prd;
+    const ensure = deps.runHq(["mesh", "project", "ensure", project, "--company", company, "--stories-file", hqPrd, "--json"], {
         cwd: deps.cwd, env: deps.env, capture: true,
     });
     if (ensure.code !== 0)

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

@@ -28,7 +28,16 @@ function epoch(value, parseDate) {
     }
     return parseDate(value);
 }
+function nativePath(value) {
+    if (process.platform === "win32") {
+        const gitBashPath = /^\/([A-Za-z])\/(.*)$/u.exec(value);
+        if (gitBashPath)
+            return `${gitBashPath[1]}:\\${gitBashPath[2].replaceAll("/", "\\")}`;
+    }
+    return value;
+}
 function pathAbs(value, cwd, f) {
+    value = nativePath(value);
     if (value.startsWith("/"))
         return value;
     const parent = path.dirname(value);
@@ -40,8 +49,29 @@ function pathAbs(value, cwd, f) {
         return value;
     }
 }
+function shellAbsolutePath(value) {
+    if (process.platform !== "win32")
+        return value;
+    // The shell companion stores drive paths with forward slashes. The shared
+    // shellDisplayPath helper emits Git Bash mount paths for command output, but
+    // that is not the registry's persisted path format.
+    if (/^\/[A-Za-z]\//u.test(value))
+        return value;
+    return path.win32.resolve(nativePath(value)).replaceAll("\\", "/");
+}
+function shellScope(value) {
+    return value.startsWith("worktree:") ? `worktree:${shellAbsolutePath(value.slice("worktree:".length))}` : value;
+}
 function worktreeScopeCovers(target, scope) {
     const rawRoot = scope.slice("worktree:".length);
+    if (process.platform === "win32") {
+        const canonical = (value) => {
+            return path.win32.normalize(nativePath(value).replaceAll("/", "\\")).replace(/[\\/]+$/u, "").toLowerCase();
+        };
+        const canonicalTarget = canonical(target);
+        const canonicalRoot = canonical(rawRoot);
+        return canonicalTarget === canonicalRoot || canonicalTarget.startsWith(`${canonicalRoot}\\`);
+    }
     const trimmedRoot = rawRoot.replace(/\/+$/, "");
     const root = trimmedRoot === "" && rawRoot.startsWith("/") ? "/" : trimmedRoot;
     if (root === "/")
@@ -135,7 +165,10 @@ export function runRepoRunRegistry(args, deps) {
                                 f.rmSync(lockDir, { recursive: true, force: true });
                             }
                             catch {
-                                throw new Error(`ERROR: could not remove stale registry lock: ${lockDir}`);
+                                const displayLock = process.platform === "win32"
+                                    ? `${root.replace(/[\\/]+$/u, "")}/workspace/orchestrator/active-runs.json.lock`
+                                    : lockDir;
+                                throw new Error(`ERROR: could not remove stale registry lock: ${displayLock}`);
                             }
                             continue;
                         }
@@ -157,6 +190,10 @@ export function runRepoRunRegistry(args, deps) {
         const value = Number(raw);
         if (!Number.isFinite(value))
             return false;
+        // Git Bash's kill -0 -1 probes all signalable processes and succeeds on
+        // Windows; Node's process.kill does not accept the same sentinel there.
+        if (process.platform === "win32" && value === -1)
+            return true;
         try {
             return deps.isPidAlive ? deps.isPidAlive(value) : (process.kill(value, 0), true);
         }
@@ -207,7 +244,7 @@ export function runRepoRunRegistry(args, deps) {
         catch { /* keep resolved path */ }
         while (dir !== "/" && dir) {
             if (f.existsSync(path.join(dir, ".git")))
-                return dir;
+                return process.platform === "win32" ? shellAbsolutePath(dir) : dir;
             const parent = path.dirname(dir);
             if (parent === dir)
                 break;
@@ -256,7 +293,8 @@ export function runRepoRunRegistry(args, deps) {
             let runId = valueAfter(rest, "--run-id"), runPid = valueAfter(rest, "--pid"), sessionId = valueAfter(rest, "--session-id"), command = valueAfter(rest, "--command"), project = valueAfter(rest, "--project"), repo = valueAfter(rest, "--repo"), scope = valueAfter(rest, "--scope"), host = valueAfter(rest, "--host");
             if (!runPid || !command || !repo || !scope)
                 return die("register requires --pid --command --repo --scope");
-            repo = pathAbs(repo, deps.cwd, f);
+            repo = shellAbsolutePath(pathAbs(repo, deps.cwd, f));
+            scope = shellScope(scope);
             if (!runId)
                 runId = `${command.replaceAll("/", "-")}-${Math.floor(now().getTime() / 1000)}-${project || "none"}-${runPid}`;
             if (!host)
@@ -357,7 +395,12 @@ export function runRepoRunRegistry(args, deps) {
             const owners = runs.filter((run) => covers(run) && String(run?.pid) !== myPid && run?.session_id !== mySession);
             if (!owners.length)
                 return output();
-            const lines = owners.map((run) => `run_id=${run?.run_id} pid=${run?.pid} command=${run?.command} project=${run?.project} scope=${run?.scope} repo=${run?.repo_path} started=${run?.started_at} heartbeat=${run?.heartbeat_at}`).join("\n") + "\n";
+            const lines = owners.map((run) => {
+                // This diagnostic interpolates the stored fields directly in Bash.
+                // Keep their original spelling (including a trailing slash) rather
+                // than canonicalizing paths only on the native side.
+                return `run_id=${run?.run_id} pid=${run?.pid} command=${run?.command} project=${run?.project} scope=${run?.scope} repo=${run?.repo_path} started=${run?.started_at} heartbeat=${run?.heartbeat_at}`;
+            }).join("\n") + "\n";
             return output(2, "", lines);
         }
         return die(`unknown subcommand: ${sub}`);

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

@@ -10,6 +10,6 @@ export type SessionJournalOperationResult = {
 /** 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;
 export {};
 //# sourceMappingURL=core-session-journal-native.d.ts.map

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

@@ -23,7 +23,7 @@ const counterKey = (value) => {
         key = "unscoped";
     return key.length > 96 ? key.slice(0, 96) : key;
 };
-const slugify = (value) => value.toLowerCase()
+const slugify = (input) => (process.platform === "win32" ? input.replaceAll("\n", "-") : input).toLowerCase()
     .split("\n")
     .map((line) => line.replace(/[^a-z0-9]+/g, "-").replace(/^-+/, "").replace(/-+$/, "").slice(0, 40))
     .join("\n");
@@ -92,7 +92,7 @@ function processIsAlive(pid) {
 function acquireJournalWriteLock(dir) {
     const lock = path.join(dir, ".session-journal-write.lock");
     const ownerFile = path.join(lock, "pid");
-    const deadline = Date.now() + 5_000;
+    const deadline = Date.now() + (process.platform === "win32" ? 30_000 : 5_000);
     while (Date.now() < deadline) {
         try {
             fs.mkdirSync(lock);
@@ -243,8 +243,8 @@ export function runSessionJournalOperation(args, _stdin, cwd, hqRoot, dependenci
     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 = {}) {
-    const result = runSessionJournalOperation(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;

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

@@ -252,7 +252,8 @@ export function runSessionProjectFast(argv, stdin, cwd, root, dependencies = {})
     function acquireProjectWriteLock(prdPath) {
         const lock = `${prdPath}.write-lock`;
         const ownerFile = path.join(lock, "pid");
-        const deadline = Date.now() + 5_000;
+        // Git Bash and Node process startup can stretch Windows lock contention beyond the short POSIX window.
+        const deadline = Date.now() + (process.platform === "win32" ? 30_000 : 5_000);
         while (Date.now() < deadline) {
             try {
                 fs.mkdirSync(lock);

package/dist/commands/core-share-suggestion-state-native.js

@@ -1,6 +1,7 @@
 /** Native port of share-suggestion-state.sh; kept dependency-light for hooks. */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { shellDisplayPath } from "../lib/core-utils/shell-display-path.js";
 import { isByteOrientedLocale } from "../lib/core-utils/byte-oriented-locale.js";
 export const SHARE_SUGGESTION_STATE_ASSET = "core/scripts/share-suggestion-state.sh";
 const isObj = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -170,10 +171,13 @@ export function runShareSuggestionState(args, stdin, deps) {
             }
             catch { /* locate the first existing non-directory parent when present */ }
         }
+        const displayBlockedPath = platform === "win32"
+            ? shellDisplayPath(blockedPath)
+            : blockedPath;
         const reason = code === "ENOTDIR" ? "Not a directory" : code === "EACCES" || code === "EPERM" ? "Permission denied" : code === "EEXIST" ? "File exists" : (error instanceof Error ? error.message : String(error));
         const mkdirError = platform === "darwin"
-            ? `mkdir: ${blockedPath}: ${reason}\n`
-            : `mkdir: cannot create directory ‘${blockedPath}’: ${reason}\n`;
+            ? `mkdir: ${displayBlockedPath}: ${reason}\n`
+            : `mkdir: cannot create directory ‘${displayBlockedPath}’: ${reason}\n`;
         return failFromShellMain(`${mkdirError}share-suggestion-state: unable to create state directory\n`);
     }
     const sessionUnits = platform === "darwin" && !isByteOrientedLocale(env, platform)

package/dist/commands/core-work-mesh-live-rebind-native.js

@@ -4,6 +4,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { generateUlid } from "../lib/mesh/live/ulid.js";
 import { formatSpoolLine } from "../lib/mesh/live/format-spool-line.js";
+import { shellDisplayPath } from "../lib/core-utils/shell-display-path.js";
 export const WORK_MESH_LIVE_REBIND_ASSET = "core/scripts/work-mesh-live-rebind.sh";
 const WORK_MESH_LIVE_REBIND_LIBRARY_ASSET = "core/scripts/lib/work-mesh-live-rebind.sh";
 const USAGE = "usage: work-mesh-live-rebind.sh --session <sid> ...\n";
@@ -118,7 +119,7 @@ function enqueueLifecycle(kind, sid, harness, adapter, company, project, task, d
         at: `${now.toISOString().slice(0, 19)}.000Z`,
         seq,
         cwd: deps.env.PWD ?? "",
-        hqRoot: deps.env.HQ_ROOT ?? deps.root,
+        hqRoot: shellDisplayPath(deps.env.HQ_ROOT ?? deps.root),
     };
     if (company)
         event.companySlug = company;
@@ -247,7 +248,9 @@ export function runWorkMeshLiveRebind(args, deps) {
                     : cause?.code === "ENOSPC" ? "No space left on device"
                         : "Input/output error";
         const script = path.join(deps.root, WORK_MESH_LIVE_REBIND_LIBRARY_ASSET);
-        return { code: 1, stdout: "", stderr: `${script}: line 34: ${error.target}: ${message}\n` };
+        const scriptPath = shellDisplayPath(script);
+        const targetPath = shellDisplayPath(error.target);
+        return { code: 1, stdout: "", stderr: `${scriptPath}: line 34: ${targetPath}: ${message}\n` };
     }
 }
 export async function runWorkMeshLiveRebindFast(args, _stdin, cwd, root) {

package/dist/commands/core-worker-lint-fast.d.ts

@@ -0,0 +1,2 @@
+export declare function runWorkerSkillLintFast(args: readonly string[], _stdin: string, cwd: string): number;
+//# sourceMappingURL=core-worker-lint-fast.d.ts.map

package/dist/commands/core-worker-lint-fast.js

@@ -0,0 +1,11 @@
+/** Isolated fast-entry adapter for native worker-skill linting. */
+import { runWorkerSkillLint } from "./core-worker-lint-native.js";
+export function runWorkerSkillLintFast(args, _stdin, cwd) {
+    const result = runWorkerSkillLint([...args], { cwd });
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    return result.code;
+}
+//# sourceMappingURL=core-worker-lint-fast.js.map

package/dist/commands/core.js

@@ -631,12 +631,15 @@ export function registerCoreCommands(program) {
         }
     });
     describeCoreCommand(rebuildCommand, {
-        entries: REBUILD_INDEX_TARGETS.map((entry) => ({
-            name: `rebuild-index ${entry.target}`,
-            execution: "native",
-            asset: entry.asset,
-            root: "live",
-        })),
+        entries: [
+            { name: "rebuild-index", execution: "native", root: "live" },
+            ...REBUILD_INDEX_TARGETS.map((entry) => ({
+                name: `rebuild-index ${entry.target}`,
+                execution: "native",
+                asset: entry.asset,
+                root: "live",
+            })),
+        ],
     });
     for (const entry of SCAFFOLD_COMMANDS) {
         const command = core

package/dist/fast-scaffold.js

@@ -11,6 +11,55 @@
  */
 /** The relocated scripts that qualify for the entrypoint fast path. */
 export const FAST_SCAFFOLD_SCRIPTS = [
+    ...["notify", "probe", "remediate", "run"].map((name) => ({
+        name: `job ${name}`,
+        kind: "native",
+        modulePath: `./commands/core-job-${name}-fast.js`,
+        exportName: name === "notify" ? "runJobNotifyFast"
+            : name === "probe" ? "runJobProbeFast"
+                : name === "remediate" ? "runJobRemediateFast"
+                    : "runJobFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-jobs",
+        asset: `core/scripts/hq-job-${name}.sh`,
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+        requiresNodeNetworkCompatibility: name === "probe" || name === "run",
+    })),
+    {
+        name: "pin",
+        kind: "native",
+        modulePath: "./commands/core-pin-fast.js",
+        exportName: "runPinFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-utilities",
+        asset: "core/scripts/hq-pin.sh",
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    },
+    {
+        name: "worker lint",
+        kind: "native",
+        modulePath: "./commands/core-worker-lint-fast.js",
+        exportName: "runWorkerSkillLintFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-worker-skills",
+        asset: "core/scripts/lint-shared-worker-skills.sh",
+        root: "cwd",
+        shellCwd: "caller",
+        shellHqRoot: "none",
+    },
+    {
+        name: "rebuild-index",
+        kind: "native",
+        modulePath: "./commands/core-rebuild-index-fast.js",
+        exportName: "runRebuildIndexFast",
+        flagKey: "hq-core-native-fast-route",
+        root: "live",
+        fallbackToCommandGraph: true,
+    },
     {
         name: "checkpoint-stop-gate",
         kind: "native",

package/dist/lib/checkpoint-ontology/merge-copies.d.ts

@@ -63,8 +63,8 @@ export declare const MERGE_LISTED_PAIRS_FLAG = "checkpoint.ontology.merge-listed
  * carry the copy's `external_ids` and `web_domains` to the survivor.
  */
 export declare const MERGE_REWRITE_REFS_FLAG = "checkpoint.ontology.merge-rewrite-refs";
-export type CopySkipReason = "no_original" | "original_invalid" | "identity_differs" | "not_in_duplicate_group" | "group_size" | "type_differs" | "names_differ" | "numbered_copy" | "not_listed" | "listed_conflict";
-export type PairKind = "numbered" | "variants" | "listed";
+type CopySkipReason = "no_original" | "original_invalid" | "identity_differs" | "not_in_duplicate_group" | "group_size" | "type_differs" | "names_differ" | "numbered_copy" | "not_listed" | "listed_conflict";
+type PairKind = "numbered" | "variants" | "listed";
 export interface CopySkip {
     copy: string;
     reason: CopySkipReason;
@@ -93,7 +93,7 @@ export interface ListedPair {
     /** Provider -> resolution, applied only when `rewriteRefs` is on and the ids conflict. */
     resolve_external_ids?: Record<string, ExternalIdResolution>;
 }
-export interface CopyPlan extends CopyPair {
+interface CopyPlan extends CopyPair {
     add_aliases: string[];
     /** Copy names the original lacks that another entity already holds, so they do not move. */
     dropped_aliases: string[];
@@ -196,4 +196,5 @@ export declare function findListedPairs(index: EntityIndex, only: ListedPair[]):
  * local copy files only.
  */
 export declare function mergeCopies(options: MergeCopiesOptions): Promise<MergeCopiesReport>;
+export {};
 //# sourceMappingURL=merge-copies.d.ts.map

package/dist/lib/core-utils/worktree-resume.d.ts

@@ -9,6 +9,7 @@ export type CoreIo = {
     env?: NodeJS.ProcessEnv;
     cwd?: string;
     now?: () => Date;
+    randomBytes?: (size: number) => Buffer;
 };
 export declare function worktreeGcPathKey(value: string): string;
 export declare function runWorktreeGc(args: readonly string[], hqRoot: string, io?: CoreIo): number;