@indigoai-us/hq-cli 5.345.11 → 5.345.12

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

@@ -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-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/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;

package/dist/lib/core-utils/worktree-resume.js

@@ -5,6 +5,7 @@ import * as path from "node:path";
 import { randomBytes } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import { serializeJqJson } from "./jq-json-serializer.js";
+import { shellDisplayPath } from "./shell-display-path.js";
 export const WORKTREE_GC_ASSET = "core/scripts/worktree-gc.sh";
 export const CLEAN_HANDOFF_ASSET = "core/scripts/clean-worktree-reconcile-handoff.sh";
 export const RESUME_LOCK_ASSET = "core/scripts/resume-thread-lock.sh";
@@ -13,6 +14,7 @@ const stdout = (io, value) => (io.stdout ?? ((v) => process.stdout.write(v)))(va
 const stderr = (io, value) => (io.stderr ?? ((v) => process.stderr.write(v)))(value);
 const envOf = (io) => io.env ?? process.env;
 const nowOf = (io) => (io.now ?? (() => new Date()))();
+const randomBytesOf = (io, size) => (io.randomBytes ?? randomBytes)(size);
 const stripTrailingNewlines = (value) => value.replace(/\n+$/u, "");
 function git(args, options = {}) {
     const childEnv = options.env;
@@ -61,6 +63,23 @@ function fileExists(file) {
         return false;
     }
 }
+function sameDirectory(left, right) {
+    try {
+        const a = fs.statSync(left), b = fs.statSync(right);
+        if (a.dev !== 0 && b.dev !== 0 && a.ino !== 0 && b.ino !== 0)
+            return a.dev === b.dev && a.ino === b.ino;
+    }
+    catch { /* compare canonical spellings below */ }
+    const canonical = (value) => path.resolve(value).replace(/^\\\\\?\\/u, "").replaceAll("/", "\\").toLowerCase();
+    return canonical(left) === canonical(right);
+}
+function shellJsonPath(value) {
+    const display = shellDisplayPath(value);
+    if (process.platform !== "win32")
+        return display;
+    const match = /^\/([a-z])\/(.*)$/u.exec(display);
+    return match?.[1] && match[2] !== undefined ? `${match[1].toUpperCase()}:/${match[2]}` : display;
+}
 function statMtime(file) {
     try {
         return Math.floor(fs.statSync(file).mtimeMs / 1000);
@@ -119,7 +138,10 @@ function sessionReferences(hqRoot, worktree) {
         path.join(hqRoot, "workspace/threads/handoff.json"),
         path.join(hqRoot, "workspace/locks"),
     ];
-    const needle = Buffer.from(worktree, "utf8");
+    // The shell receives the Git Bash spelling of this path. Session references
+    // written by shell hooks use that spelling too, while Node's win32 path is
+    // drive-letter based. Compare the representation the shell actually sees.
+    const needle = Buffer.from(shellDisplayPath(worktree), "utf8");
     const visit = (target) => {
         let info;
         try {
@@ -187,7 +209,16 @@ function duSizeKb(root) {
             return;
         if (info.isFile())
             seen.add(inode);
-        bytes += typeof info.blocks === "number" ? info.blocks * 512 : info.size;
+        // Windows Git Bash du counts file payloads in 1 KiB units. Node's Windows
+        // directory sizes include metadata that du does not count, so omit those
+        // directory entries and round file payloads as du -sk does.
+        bytes += process.platform === "win32" && info.isDirectory()
+            ? 0
+            : typeof info.blocks === "number" && !(process.platform === "win32" && info.blocks === 0)
+                ? info.blocks * 512
+                : process.platform === "win32"
+                    ? Math.max(1, Math.ceil(info.size / 1024)) * 1024
+                    : info.size;
         if (info.isDirectory()) {
             let children;
             try {
@@ -338,9 +369,9 @@ export function runWorktreeGc(args, hqRoot, io = {}) {
     const skip = (wt, repo, branch, isHqRoot, ageDays, sizeKb, reason) => {
         skipped++;
         if (reason === "remove-failed")
-            record({ path: wt, repo, branch, hq_root: isHqRoot, age_days: ageDays, size_kb: sizeKb, action: "skipped", reason });
+            record({ path: shellJsonPath(wt), repo: shellJsonPath(repo), branch, hq_root: isHqRoot, age_days: ageDays, size_kb: sizeKb, action: "skipped", reason });
         if (!json)
-            stdout(io, `  skip  [${reason}] ${wt}\n`);
+            stdout(io, `  skip  [${reason}] ${shellDisplayPath(wt)}\n`);
     };
     const runFetch = (repo) => {
         const timeoutName = executableOnPath("timeout", env) ? "timeout" : executableOnPath("gtimeout", env) ? "gtimeout" : undefined;
@@ -372,11 +403,7 @@ export function runWorktreeGc(args, hqRoot, io = {}) {
             skip(wt, "", "", false, null, null, "git-error");
             continue;
         }
-        let isHqRoot = false;
-        try {
-            isHqRoot = fs.realpathSync(mainRepo) === fs.realpathSync(hqRoot);
-        }
-        catch { /* both paths are already resolved by the core root resolver */ }
+        const isHqRoot = sameDirectory(mainRepo, hqRoot);
         const branchResult = gitText(["-C", wt, "symbolic-ref", "--short", "HEAD"]);
         const branch = branchResult.status === 0 ? commandOutput(branchResult) : "";
         const headResult = gitText(["-C", wt, "rev-parse", "HEAD"]);
@@ -401,7 +428,9 @@ export function runWorktreeGc(args, hqRoot, io = {}) {
             continue;
         }
         let createdEpoch = wtMtime;
-        const stampFile = path.join(metaDir, `${worktreeGcPathKey(wt)}.json`);
+        // worktree-gc.sh hashes the path as Bash/Git Bash spells it. On Windows a
+        // native path (C:\...) and the shell path (/c/...) have different keys.
+        const stampFile = path.join(metaDir, `${worktreeGcPathKey(shellDisplayPath(wt))}.json`);
         if (fileExists(stampFile)) {
             try {
                 const stamp = JSON.parse(fs.readFileSync(stampFile, "utf8"));
@@ -465,9 +494,9 @@ export function runWorktreeGc(args, hqRoot, io = {}) {
         if (!apply) {
             would++;
             reclaimedKb += sizeKb;
-            record({ path: wt, repo: mainRepo, branch, hq_root: isHqRoot, age_days: ageDays, size_kb: sizeKb, action: "would-remove", reason: "safe" });
+            record({ path: shellJsonPath(wt), repo: shellJsonPath(mainRepo), branch, hq_root: isHqRoot, age_days: ageDays, size_kb: sizeKb, action: "would-remove", reason: "safe" });
             if (!json)
-                stdout(io, `  DRY   would remove (${Math.floor(sizeKb / 1024)} MB, ${ageDays}d) ${wt}\n`);
+                stdout(io, `  DRY   would remove (${Math.floor(sizeKb / 1024)} MB, ${ageDays}d) ${shellDisplayPath(wt)}\n`);
             continue;
         }
         if (wtGit(mainRepo, isHqRoot, ["worktree", "remove", wt]).status !== 0) {
@@ -483,9 +512,9 @@ export function runWorktreeGc(args, hqRoot, io = {}) {
         catch { /* rm -f */ }
         removed++;
         reclaimedKb += sizeKb;
-        record({ path: wt, repo: mainRepo, branch, hq_root: isHqRoot, age_days: ageDays, size_kb: sizeKb, action: "removed", reason: "safe" });
+        record({ path: shellJsonPath(wt), repo: shellJsonPath(mainRepo), branch, hq_root: isHqRoot, age_days: ageDays, size_kb: sizeKb, action: "removed", reason: "safe" });
         if (!json)
-            stdout(io, `  GC    removed (${Math.floor(sizeKb / 1024)} MB, ${ageDays}d) ${wt}\n`);
+            stdout(io, `  GC    removed (${Math.floor(sizeKb / 1024)} MB, ${ageDays}d) ${shellDisplayPath(wt)}\n`);
     }
     const reclaimedGb = Number((reclaimedKb / 1024 / 1024).toFixed(2));
     if (json) {
@@ -554,18 +583,18 @@ export function runCleanWorktreeReconcileHandoff(args, io = {}) {
     }
     const rawRoot = args[0] ?? "";
     const branch = args[1] ?? "";
-    if (!rawRoot.startsWith("/")) {
+    if (!rawRoot.startsWith("/") && !(process.platform === "win32" && path.win32.isAbsolute(rawRoot))) {
         stderr(io, `ERROR: HQ root must be an absolute path\n`);
         cleanUsage(io);
         return 64;
     }
     if (!fileExists(rawRoot) || !fs.statSync(rawRoot).isDirectory()) {
-        return cleanGitError(io, `ERROR: HQ root is not a directory: ${rawRoot}`);
+        return cleanGitError(io, `ERROR: HQ root is not a directory: ${shellDisplayPath(rawRoot)}`);
     }
     const hqRoot = realPathOrResolved(rawRoot);
     const top = gitText(["-C", hqRoot, "rev-parse", "--show-toplevel"]);
     if (top.status !== 0)
-        return cleanGitError(io, `ERROR: HQ root is not a Git worktree: ${hqRoot}`);
+        return cleanGitError(io, `ERROR: HQ root is not a Git worktree: ${shellDisplayPath(hqRoot)}`);
     const topLevel = realPathOrResolved(commandOutput(top));
     if (topLevel !== hqRoot)
         return cleanGitError(io, `ERROR: supplied path is not the Git worktree root: ${hqRoot}`);
@@ -640,7 +669,7 @@ export function runCleanWorktreeReconcileHandoff(args, io = {}) {
         let movedFile = "";
         try {
             for (let attempt = 0; attempt < 10; attempt++) {
-                const candidate = path.join(destinationDir, `.clean-worktree-handoff.${randomBytes(4).toString("hex").slice(0, 6)}`);
+                const candidate = path.join(destinationDir, `.clean-worktree-handoff.${randomBytesOf(io, 4).toString("hex").slice(0, 6)}`);
                 try {
                     fs.writeFileSync(candidate, "", { flag: "wx", mode: 0o600 });
                     movedFile = candidate;
@@ -769,12 +798,12 @@ function lockState(threadId, relativeLockPath, lockDir, recordPath, staleSeconds
     }
     return locked(record.session_id, record.resumed_at, record.generation);
 }
-function writeLockRecord(lockDir, recordPath, threadId, sessionId, now) {
+function writeLockRecord(lockDir, recordPath, threadId, sessionId, now, io) {
     const epoch = Math.floor(now.getTime() / 1000);
     const timestamp = now.toISOString().replace(/\.\d{3}Z$/u, "Z");
     let temporary = "";
     for (let attempt = 0; attempt < 10; attempt++) {
-        const generation = `.current.${randomBytes(8).toString("base64url").slice(0, 6)}`;
+        const generation = `.current.${randomBytesOf(io, 8).toString("base64url").slice(0, 6)}`;
         const candidate = path.join(lockDir, generation);
         try {
             fs.writeFileSync(candidate, serializeJqJson({ version: 1, thread_id: threadId, session_id: sessionId, resumed_at: timestamp, resumed_epoch: epoch, generation }, "compact"), { flag: "wx", mode: 0o600 });
@@ -858,7 +887,7 @@ export function runResumeThreadLock(args, hqRoot, io = {}) {
     fs.mkdirSync(locksDir, { recursive: true });
     try {
         fs.mkdirSync(lockDir);
-        const generation = writeLockRecord(lockDir, recordPath, threadId, sessionId, now());
+        const generation = writeLockRecord(lockDir, recordPath, threadId, sessionId, now(), io);
         emit({ status: "acquired", thread_id: threadId, lock_path: relativeLockPath, session_id: sessionId, lock_generation: generation });
         return 0;
     }
@@ -915,7 +944,7 @@ export function runResumeThreadLock(args, hqRoot, io = {}) {
             emit(current);
             return 4;
         }
-        const generation = writeLockRecord(lockDir, recordPath, threadId, sessionId, now());
+        const generation = writeLockRecord(lockDir, recordPath, threadId, sessionId, now(), io);
         emit({ status: "acquired", thread_id: threadId, lock_path: relativeLockPath, session_id: sessionId, lock_generation: generation });
         return 0;
     }
@@ -1008,7 +1037,7 @@ async function drainResponseBody(response) {
 export async function runVerifyStoryDeliverables(args, hqRoot, io = {}) {
     const env = envOf(io);
     let prdPath = "", storyId = "", repo = "";
-    let json = false, strict = false, write = false;
+    let json = false, strict = false, write = false, repoExplicit = false;
     let evidenceJson = "[]", commitsJson = "[]";
     let offline = env.HQ_DELIVERABLES_OFFLINE ?? "0";
     for (let index = 0; index < args.length;) {
@@ -1021,8 +1050,10 @@ export async function runVerifyStoryDeliverables(args, hqRoot, io = {}) {
                 prdPath = value;
             else if (arg === "--story")
                 storyId = value;
-            else if (arg === "--repo")
+            else if (arg === "--repo") {
                 repo = value;
+                repoExplicit = true;
+            }
             else if (arg === "--evidence-json")
                 evidenceJson = value;
             else
@@ -1058,9 +1089,12 @@ export async function runVerifyStoryDeliverables(args, hqRoot, io = {}) {
         stderr(io, `usage: --prd <prd.json> --story <id> [--repo <path>]\n`);
         return 2;
     }
+    const displayedPrdPath = process.platform === "win32" && path.win32.isAbsolute(prdPath)
+        ? shellDisplayPath(prdPath)
+        : prdPath;
     const prdFilePath = path.resolve(hqRoot, prdPath);
     if (!isReadable(prdFilePath)) {
-        stderr(io, `verify-story-deliverables: cannot read ${prdPath}\n`);
+        stderr(io, `verify-story-deliverables: cannot read ${displayedPrdPath}\n`);
         return 2;
     }
     let prd;
@@ -1073,7 +1107,7 @@ export async function runVerifyStoryDeliverables(args, hqRoot, io = {}) {
     const userStories = Array.isArray(prd.userStories) ? prd.userStories : [];
     const story = userStories.find((item) => item && item.id === storyId);
     if (!story) {
-        stderr(io, `verify-story-deliverables: story ${storyId} not in ${prdPath}\n`);
+        stderr(io, `verify-story-deliverables: story ${storyId} not in ${displayedPrdPath}\n`);
         return 2;
     }
     if (!repo) {
@@ -1081,7 +1115,10 @@ export async function runVerifyStoryDeliverables(args, hqRoot, io = {}) {
             ? prd.metadata : {};
         repo = jqText(metadata.repoPath);
     }
-    if (repo && !repo.startsWith("/"))
+    // The shell sees Git Bash's /c/... spelling, which remains absolute. Native
+    // receives the corresponding Win32 C:\\... path; preserve that absolute
+    // location instead of prefixing HQ_ROOT and pointing at a nonexistent path.
+    if (repo && !repo.startsWith("/") && !(repoExplicit && path.win32.isAbsolute(repo)))
         repo = `${hqRoot}/${repo}`;
     const evidence = jsonDecode(evidenceJson);
     if (!jqArrayCheck(evidence)) {
@@ -1099,7 +1136,7 @@ export async function runVerifyStoryDeliverables(args, hqRoot, io = {}) {
         // deliverables are left to jq's normal processing behavior.
         const refsRaw = declaredRaw;
         if (!Array.isArray(refsRaw)) {
-            stderr(io, `verify-story-deliverables: story ${storyId} not in ${prdPath}\n`);
+            stderr(io, `verify-story-deliverables: story ${storyId} not in ${displayedPrdPath}\n`);
             return 2;
         }
     }
@@ -1138,11 +1175,11 @@ export async function runVerifyStoryDeliverables(args, hqRoot, io = {}) {
         else if (kind === "repo-path")
             ok = Boolean(repo) && fileExists(`${repo}/${value}`);
         else if (kind === "branch" && repo && fileExists(repo)) {
-            ok = git(["-C", repo, "show-ref", "--verify", "--quiet", `refs/heads/${value}`]).status === 0 ||
-                git(["-C", repo, "show-ref", "--verify", "--quiet", `refs/remotes/origin/${value}`]).status === 0;
+            ok = git(["-C", repo, "show-ref", "--verify", "--quiet", `refs/heads/${value}`], { env }).status === 0 ||
+                git(["-C", repo, "show-ref", "--verify", "--quiet", `refs/remotes/origin/${value}`], { env }).status === 0;
         }
         else if (kind === "commit" && repo && fileExists(repo)) {
-            ok = git(["-C", repo, "cat-file", "-e", `${value}^{commit}`]).status === 0;
+            ok = git(["-C", repo, "cat-file", "-e", `${value}^{commit}`], { env }).status === 0;
         }
         else if (kind === "url")
             ok = offline === "1" || await urlIsPresent(value);

package/dist/lib/daemon/catalog.d.ts

@@ -65,6 +65,16 @@ export interface UnitPlan {
     drainSignal?: "SIGUSR2";
     /** A new CLI version alone does not restart this unit; it restarts itself when idle. */
     keepAcrossCliUpdates?: true;
+    /**
+     * Scheduled units only: before each timed run the supervisor asks
+     * `SupervisorDeps.runGuard` whether there is work. `spawn` runs as usual,
+     * `idle` runs at most once per `idleIntervalSec`, `skip` does not run. A
+     * guard error, or no guard in the supervisor, runs as usual.
+     */
+    runGuard?: {
+        name: "lanes-reconcile";
+        idleIntervalSec: number;
+    };
 }
 export interface PlanContext {
     machineType: MachineType;

package/dist/lib/daemon/catalog.js

@@ -230,10 +230,18 @@ function planService(service, ctx) {
             return [
                 base(service, {
                     kind: "scheduled",
+                    // Polls every 15 s so keep-alive resumes are admitted on time (#1396).
+                    // Each pass is a fresh `hq` node process (~1.8 s CPU, ~200 MB RSS), so
+                    // desktops first check the lane store in-process
+                    // (lanes-reconcile-guard.ts) and fall back to the pre-#1396 60 s
+                    // cadence, or no run, when no lane can need the 15 s poll.
                     intervalSec: 15,
                     initialDelaySec: 30,
                     command: { type: "hq", args: ["lanes", "reconcile"] },
                     env: ctx.hqRoot ? { HQ_ROOT: ctx.hqRoot } : {},
+                    ...(ctx.machineType === "desktop"
+                        ? { runGuard: { name: "lanes-reconcile", idleIntervalSec: 60 } }
+                        : {}),
                     blocked: firstBlock([[!ctx.hqRoot, NO_HQ_ROOT]]),
                 }),
             ];

package/dist/lib/daemon/lanes-reconcile-guard.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Pre-spawn check for the desktop `lanes-reconcile` unit.
+ *
+ * Every reconcile pass is a fresh `hq` node process (~1.8 s CPU, ~200 MB RSS),
+ * so a 15-second poll costs about 12% of a core even when the lane store holds
+ * nothing to do. This check reads the lane store in-process (readdir + small
+ * JSON reads, no child process) and tells the supervisor how urgent the next
+ * pass is:
+ *
+ * - `spawn`: something the 15-second cadence exists for may be due — lane
+ *   admission, a running lane's heartbeat, or a keep-alive resume (#1396).
+ * - `idle`: only work that ran on the pre-#1396 60-second cadence remains
+ *   (terminal lanes, worker-profile resumes, question aging, Codex rollout
+ *   retention, lead-autopilot registry). The supervisor runs it at most once
+ *   per `idleIntervalSec`.
+ * - `skip`: the store holds no lane or question records, no lead registry and
+ *   no lanes config, so a reconcile pass has no input to act on.
+ *
+ * Any error reading the store returns `spawn` (fail open), as does any record
+ * this check does not understand.
+ *
+ * The paths below mirror `LANES_STORE_REL`, `LANE_RECORDS_DIR`,
+ * `QUESTION_RECORDS_DIR` (lanes/store.ts), `LANES_CONFIG_REL` (lanes/config.ts)
+ * and `LEAD_REGISTRY_REL` (lanes/autopilot-registry.ts). They are copied, not
+ * imported, so the daemon does not load the lanes modules; a test pins them to
+ * the originals.
+ */
+import type { UnitPlan } from "./catalog.js";
+export type LanesReconcileVerdict = "spawn" | "idle" | "skip";
+export declare const LANES_STORE_DIR: string;
+export declare const LANE_RECORDS_SUBDIR = "lanes";
+export declare const QUESTION_RECORDS_SUBDIR = "questions";
+export declare const LANES_CONFIG_FILE: string;
+export declare const LEAD_REGISTRY_FILE: string;
+export interface LanesReconcileGuardFs {
+    readdirSync: (dir: string) => string[];
+    readFileSync: (file: string, encoding: "utf8") => string;
+    existsSync: (file: string) => boolean;
+}
+export declare function lanesReconcileVerdict(hqRoot: string | undefined, fsDeps?: LanesReconcileGuardFs): LanesReconcileVerdict;
+/** The supervisor's `runGuard`: dispatches on the unit's declared guard. */
+export declare function daemonRunGuard(unit: Pick<UnitPlan, "runGuard" | "env">): LanesReconcileVerdict;
+//# sourceMappingURL=lanes-reconcile-guard.d.ts.map