@indigoai-us/hq-cli 5.345.114 → 5.345.115

package/CHANGELOG.md

@@ -2,7 +2,17 @@
 
 ## [Unreleased]
 
+## [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 checkpoint` now runs its background sibling under a supervisor that
+  stops it after 30 minutes and kills any process it left behind, and the
+  sibling prompt forbids unbounded searches over the workspace folder.
+
 ## [5.345.114] — 2026-10-13
+- The native `hq core` utilities no longer include bundled shell fallbacks. Published E2E now probes each command directly.
+
 - `hq capacity login <provider> --account <id>` signs a registered account
   in again into its existing home. The account id, home, and Keychain item
   stay the same. `--account default` (or the id registered at `~/.claude`)

package/assets/scaffold/core/scripts/hq-delegate-send.sh

@@ -45,11 +45,15 @@ command -v jq >/dev/null 2>&1 || die "jq is required but not installed"
 # jq.exe on MSYS may use CRT text mode unless --binary is supported.
 case "${OSTYPE:-}:${MSYSTEM:-}" in
   msys*:*|*:MINGW*)
+    _hq_jq_binary_supported=""
     jq() {
       local stdout_file stderr_file status binary_supported
       stdout_file="$(mktemp)" || return $?
       stderr_file="$(mktemp)" || { status=$?; rm -f "$stdout_file"; return "$status"; }
-      if command jq --binary -n 'null' >/dev/null 2>&1; then binary_supported=1; else binary_supported=0; fi
+      if [[ -z "$_hq_jq_binary_supported" ]]; then
+        if command jq --binary -n 'null' >/dev/null 2>&1; then _hq_jq_binary_supported=1; else _hq_jq_binary_supported=0; fi
+      fi
+      binary_supported=$_hq_jq_binary_supported
       if [[ "$binary_supported" == 1 ]]; then
         if command jq --binary "$@" >"$stdout_file" 2>"$stderr_file"; then status=0; else status=$?; fi
         command cat "$stdout_file"

package/dist/commands/bot-jobs.d.ts

@@ -14,7 +14,6 @@
  * The routes are self-only per agent, so every call uses the BOT's own machine
  * identity — the same credential path its turns use — not the owner's session.
  */
-import { execFileSync } from "node:child_process";
 import type { Command } from "commander";
 import { BotApi, type BotJobRecord, type CreateJobInput } from "../lib/bot/api.js";
 import { type BotConfig, type BotKind } from "../lib/bot/config.js";
@@ -55,18 +54,9 @@ export interface ParsedSchedule {
     /** Plain words for the schedule, when the helper supplied them. */
     human?: string;
 }
-export declare function scheduleHelperPath(hqRoot: string): string;
-/**
- * Plain English → cron, using HQ's OWN helper (`core/scripts/jobs-schedule-parse.sh`)
- * so `hq bot jobs --every` and the `/schedule` command agree on what "every
- * weekday morning" means. When the helper is not in this HQ root, the caller is
- * told to pass `--cron` instead rather than getting a second, divergent parser.
- */
+/** Plain English → cron, using the same native parser as `hq core`. */
 export declare function parseScheduleText(text: string, opts: {
-    hqRoot: string;
     timezone: string;
-    exec?: typeof execFileSync;
-    exists?: (p: string) => boolean;
 }): ParsedSchedule;
 /** The create body the cloud expects, with the client-side limits enforced first. */
 export declare function buildCreateJobBody(input: {

package/dist/commands/bot-jobs.js

@@ -15,14 +15,12 @@
  * identity — the same credential path its turns use — not the owner's session.
  */
 import chalk from "chalk";
-import { execFileSync } from "node:child_process";
-import * as fs from "node:fs";
-import * as path from "node:path";
 import { localJobsClient } from "../lib/bot/local-jobs.js";
 import { BotApiError } from "../lib/bot/api.js";
 import { effectiveBotKind } from "../lib/bot/config.js";
 import { isQuietJobContext, JOB_RUN_OPTIONS_CONTEXT_KEY } from "../lib/bot/job-run.js";
 import { BOT_JOB_QUIET_OPTION_FLAG, botJobQuietOptionEnabled } from "../lib/bot/job-quiet-flag.js";
+import { runScheduleParse } from "./core-jobs-schedule.js";
 // ─── Schedule translation ────────────────────────────────────────────────────
 /** Mirrors hq-pro-agents `MIN_RECURRING_INTERVAL_SECONDS`. */
 export const MIN_RECURRING_INTERVAL_SECONDS = 5 * 60;
@@ -190,43 +188,24 @@ export function assertScheduleWithinFloor(expr) {
         refuse(`recurring jobs may not fire more often than every ${MIN_RECURRING_INTERVAL_SECONDS / 60} minutes`);
     }
 }
-export function scheduleHelperPath(hqRoot) {
-    return path.join(hqRoot, "core", "scripts", "jobs-schedule-parse.sh");
-}
-/**
- * Plain English → cron, using HQ's OWN helper (`core/scripts/jobs-schedule-parse.sh`)
- * so `hq bot jobs --every` and the `/schedule` command agree on what "every
- * weekday morning" means. When the helper is not in this HQ root, the caller is
- * told to pass `--cron` instead rather than getting a second, divergent parser.
- */
+/** Plain English → cron, using the same native parser as `hq core`. */
 export function parseScheduleText(text, opts) {
-    const helper = scheduleHelperPath(opts.hqRoot);
-    const exists = opts.exists ?? ((p) => fs.existsSync(p));
-    if (!exists(helper)) {
-        refuse(`I can't turn "${text}" into a schedule: HQ's schedule helper is not in this HQ folder ` +
-            `(${helper}). Pass the schedule directly instead, for example --cron "0 9 * * 1-5".`);
-    }
-    const exec = opts.exec ?? execFileSync;
-    let raw;
-    try {
-        raw = String(exec("bash", [helper, "--tz", opts.timezone, text], { encoding: "utf8" })).trim();
-    }
-    catch (err) {
-        const out = err.stdout;
-        raw = typeof out === "string" ? out.trim() : "";
-        if (!raw) {
-            refuse(`I couldn't work out a schedule from "${text}". Pass --cron "<expression>" instead.`);
-        }
-    }
+    let raw = "";
+    let stderr = "";
+    const status = runScheduleParse(["--tz", opts.timezone, text], {
+        stdout: (value) => { raw += value; },
+        stderr: (value) => { stderr += value; },
+    });
     let parsed;
     try {
-        parsed = JSON.parse(raw);
+        parsed = JSON.parse(raw.trim());
     }
     catch {
         refuse(`I couldn't work out a schedule from "${text}". Pass --cron "<expression>" instead.`);
     }
-    if (!parsed.ok || !parsed.cron) {
-        refuse(`I couldn't work out a schedule from "${text}"${parsed.error ? ` (${parsed.error})` : ""}. Pass --cron "<expression>" instead.`);
+    if (status !== 0 || !parsed.ok || !parsed.cron) {
+        const reason = parsed.error || stderr.trim();
+        refuse(`I couldn't work out a schedule from "${text}"${reason ? ` (${reason})` : ""}. Pass --cron "<expression>" instead.`);
     }
     return {
         cron: parsed.cron,
@@ -418,7 +397,7 @@ export async function runBotJobs(nameArg, opts, deps) {
         const timezone = opts.tz?.trim() || (deps.timezone ?? machineTimezone)();
         const parse = deps.parseSchedule ?? parseScheduleText;
         const schedule = opts.every
-            ? parse(opts.every, { hqRoot: config.hqRoot, timezone })
+            ? parse(opts.every, { timezone })
             : { cron: opts.cron, timezone };
         const body = buildCreateJobBody({ prompt: opts.add, cron: schedule.cron, timezone: schedule.timezone, quiet: opts.quiet });
         const api = await jobsApi();

package/dist/commands/core-audit-log-native.js

@@ -249,7 +249,7 @@ export function runAuditLog(args, deps) {
 }
 export function registerCoreAuditLogNative(core) {
     registerNativeUtility(core, {
-        name: "audit-log", asset: AUDIT_LOG_ASSET, root: "live", summary: "Append, query, or summarize the HQ audit log",
+        name: "audit-log", root: "live", summary: "Append, query, or summarize the HQ audit log",
         resolveRoot: (_cwd, hqRoot) => resolveLiveRoot({ hqRoot }),
         run: (args, context) => runAuditLog(args, context),
     });

package/dist/commands/core-checkpoint-native.d.ts

@@ -8,6 +8,12 @@
  */
 import * as fs from "node:fs";
 import { Command } from "commander";
+/**
+ * Wall-clock cap on one sibling run. The supervisor kills the sibling and its
+ * descendants at this point. It stays under the lock TTL so a capped run
+ * always releases the queue before the lock would be presumed abandoned.
+ */
+export declare const SIBLING_MAX_RUNTIME_MS: number;
 type Backend = "claude" | "codex" | "grok" | "none";
 type SpawnableBackend = Exclude<Backend, "none">;
 /**
@@ -70,6 +76,27 @@ export declare function autoBackendPreference(preferGrok?: boolean): SpawnableBa
  */
 export declare function companyPrefersGrok(liveRoot: string, companySlug: string | null | undefined): Promise<boolean>;
 export declare function siblingArgs(backend: SpawnableBackend, prompt: string): string[];
+/**
+ * Supervisor for a detached sibling on POSIX. It forks the backend, records
+ * the backend's descendant tree every 2 seconds, kills that tree after the
+ * wall-clock cap, and on exit terminates any recorded descendant that was
+ * reparented to init. Without it, a shell command the agent started (an
+ * unbounded `find workspace` was the observed case) kept running after the
+ * agent exited, with PID 1 as its parent.
+ */
+export declare const SIBLING_SUPERVISOR_SCRIPT: string;
+/**
+ * The command that launches a sibling: the backend wrapped in the supervisor
+ * on POSIX hosts with perl, the bare backend otherwise.
+ */
+export declare function siblingLaunch(backend: SpawnableBackend, args: string[], options?: {
+    platform?: NodeJS.Platform;
+    perlPath?: string | null;
+    maxRuntimeMs?: number;
+}): {
+    command: string;
+    args: string[];
+};
 /** Attach the native checkpoint command to the hidden `hq core` group. */
 export declare function registerCoreCheckpointCommand(core: Command, preResolvedHqRoot?: string): void;
 export {};

package/dist/commands/core-checkpoint-native.js

@@ -63,6 +63,12 @@ const FALLBACK_BACKEND_ORDER = ["claude", "codex", "grok"];
 const BACKEND_PROBE_TIMEOUT_MS = 10_000;
 /** A sibling still holding the lock after this long is treated as abandoned. */
 const SIBLING_LOCK_TTL_MS = 60 * 60 * 1000;
+/**
+ * Wall-clock cap on one sibling run. The supervisor kills the sibling and its
+ * descendants at this point. It stays under the lock TTL so a capped run
+ * always releases the queue before the lock would be presumed abandoned.
+ */
+export const SIBLING_MAX_RUNTIME_MS = 30 * 60 * 1000;
 /** Newest-wins cap so a wedged sibling cannot grow an unbounded queue. */
 const MAX_PENDING_PAYLOADS = 50;
 class CheckpointUsageError extends Error {
@@ -115,6 +121,11 @@ HQ install. Your parent session's state is in <payloadPath>. Work
 quietly and do not ask questions; if something is ambiguous, record it in the
 report instead of guessing.
 
+0. SEARCH BOUNDS: never run find, grep -r, rg, ls -R, or du over workspace/,
+   the HQ root, or repos/. workspace/worktrees holds hundreds of full checkouts
+   with node_modules, and an unbounded walk there runs for many minutes. Read
+   the exact paths named here or in the payload. If you must search, name one
+   narrow directory and use -maxdepth 3, pruning worktrees and node_modules.
 1. Read the payload. If it lists a transcript path that exists, read its tail (~400 lines)
    both for session context and to extract additional reusable learnings/insights
    the parent did not pass explicitly. Never quote secrets
@@ -156,6 +167,8 @@ report instead of guessing.
    workspace/insights/.
 4. Close an active session journal fail-soft with
    bash .claude/skills/_shared/journal.sh close "<project_dir>" "<one-line synthesis>".
+   Locate the journal only with bash .claude/skills/_shared/journal.sh path or
+   the payload; if neither names one, skip this step. Do not search for it.
    Write a legacy checkpoint JSON under workspace/checkpoints/<id>.json with
    id, created_at, summary, files, and next_steps for backward compatibility.
 5. Update workspace/threads/recent.md and regenerate
@@ -888,6 +901,76 @@ export function siblingArgs(backend, prompt) {
             ];
     }
 }
+/**
+ * Supervisor for a detached sibling on POSIX. It forks the backend, records
+ * the backend's descendant tree every 2 seconds, kills that tree after the
+ * wall-clock cap, and on exit terminates any recorded descendant that was
+ * reparented to init. Without it, a shell command the agent started (an
+ * unbounded `find workspace` was the observed case) kept running after the
+ * agent exited, with PID 1 as its parent.
+ */
+export const SIBLING_SUPERVISOR_SCRIPT = [
+    "use strict; use warnings; use POSIX qw(:sys_wait_h);",
+    "my $secs = shift @ARGV;",
+    'my $pid = fork(); die "checkpoint sibling: fork failed\\n" unless defined $pid;',
+    "if ($pid == 0) { exec { $ARGV[0] } @ARGV; exit 127; }",
+    "my %seen;",
+    "sub tree {",
+    "  my %kids;",
+    "  for (qx{ps -axo pid=,ppid=}) { my ($p, $pp) = split ' '; push @{$kids{$pp}}, $p if defined $pp; }",
+    "  my @out; my @q = ($pid);",
+    "  while (@q) { my $x = shift @q; for my $c (@{$kids{$x} || []}) { push @out, $c; push @q, $c; } }",
+    "  return @out;",
+    "}",
+    "my $deadline = time + $secs; my $rc = 0;",
+    "while (1) {",
+    "  my $w = waitpid($pid, WNOHANG);",
+    "  if ($w == $pid) { $rc = $?; last; }",
+    "  $seen{$_} = 1 for tree();",
+    "  if (time >= $deadline) {",
+    "    my @d = tree(); $seen{$_} = 1 for @d;",
+    '    print STDERR "checkpoint sibling: killed after $secs s wall-clock limit\\n";',
+    "    kill 'TERM', @d, $pid; sleep 2;",
+    "    kill 'KILL', grep { kill 0, $_ } (tree(), @d, $pid);",
+    "    waitpid($pid, 0); $rc = 124 << 8; last;",
+    "  }",
+    "  sleep 2;",
+    "}",
+    "for my $p (keys %seen) {",
+    "  my $pp = qx{ps -o ppid= -p $p 2>/dev/null}; $pp =~ s/\\s//g;",
+    "  kill 'TERM', $p if $pp eq '1';",
+    "}",
+    "exit(($rc & 127) ? 128 + ($rc & 127) : ($rc >> 8));",
+].join("\n");
+/**
+ * The command that launches a sibling: the backend wrapped in the supervisor
+ * on POSIX hosts with perl, the bare backend otherwise.
+ */
+export function siblingLaunch(backend, args, options = {}) {
+    const platform = options.platform ?? process.platform;
+    if (platform === "win32")
+        return { command: backend, args };
+    const perlPath = options.perlPath === undefined ? findPerl() : options.perlPath;
+    if (!perlPath)
+        return { command: backend, args };
+    const seconds = Math.max(1, Math.ceil((options.maxRuntimeMs ?? SIBLING_MAX_RUNTIME_MS) / 1000));
+    return {
+        command: perlPath,
+        args: ["-e", SIBLING_SUPERVISOR_SCRIPT, String(seconds), backend, ...args],
+    };
+}
+function findPerl() {
+    for (const candidate of ["/usr/bin/perl", "/bin/perl", "/opt/homebrew/bin/perl", "/usr/local/bin/perl"]) {
+        try {
+            if (fs.statSync(candidate).isFile())
+                return candidate;
+        }
+        catch {
+            // Try the next candidate.
+        }
+    }
+    return null;
+}
 function siblingPayload(input, threadPath, backend) {
     return {
         backend,
@@ -1047,10 +1130,10 @@ async function startSibling(liveRoot, input, threadPath, backend) {
     fs.writeFileSync(path.join(runDir, "prompt.md"), prompt);
     const logPath = path.join(runDir, "run.log");
     const logFd = fs.openSync(logPath, "a");
-    const args = siblingArgs(backend, prompt);
+    const launch = siblingLaunch(backend, siblingArgs(backend, prompt));
     let child;
     try {
-        child = spawn(backend, args, {
+        child = spawn(launch.command, launch.args, {
             detached: true,
             windowsHide: true,
             cwd: liveRoot,

package/dist/commands/core-dm-bind-native.js

@@ -672,7 +672,7 @@ export async function runDmBind(args, deps) {
 }
 export function registerCoreDmBindNative(core) {
     registerNativeUtility(core, {
-        name: "dm-bind", asset: DM_BIND_ASSET, root: "live", summary: "Bind this session to one HQ DM channel",
+        name: "dm-bind", root: "live", summary: "Bind this session to one HQ DM channel",
         resolveRoot: (_cwd, hqRoot) => resolveLiveRoot({ hqRoot }),
         run: (args, context) => runDmBind(args, createDmBindDeps(context.root, context.cwd, context.env, context.now)),
     });

package/dist/commands/core-git-pack-extension-check-native.js

@@ -178,7 +178,7 @@ export function runGitPackExtensionCheck(args, deps) {
 }
 export function registerCoreGitPackExtensionCheckNative(core) {
     registerNativeUtility(core, {
-        name: "git-pack-extension-check", asset: GIT_PACK_EXTENSION_CHECK_ASSET, root: "cwd", summary: "Find or repair extensionless Git pack files",
+        name: "git-pack-extension-check", root: "cwd", summary: "Find or repair extensionless Git pack files",
         resolveRoot: (cwd) => cwd,
         run: (args, context) => runGitPackExtensionCheck(args, {
             cwd: context.cwd,

package/dist/commands/core-job-native-utils.d.ts

@@ -1,6 +1,6 @@
 import type { Command } from "commander";
 /** Preserve raw argv (including the option terminator) through Commander. */
 export declare function rawJobArgumentsForCommand(command: Command, fallback: string[], raw?: string[]): string[];
-/** Shared gated registration path for each leaf in the singular job group. */
-export declare function registerCoreJobLeaf(group: Command, core: Command, name: string, asset: string, summary: string, run: (args: string[], hqRoot: string) => number, canUseLiveRoot: (args: string[]) => boolean, valueOptions: readonly string[], booleanOptions?: readonly string[]): void;
+/** Shared registration path for each leaf in the singular job group. */
+export declare function registerCoreJobLeaf(group: Command, core: Command, name: string, summary: string, run: (args: string[], hqRoot: string) => number, canUseLiveRoot: (args: string[]) => boolean, valueOptions: readonly string[], booleanOptions?: readonly string[]): void;
 //# sourceMappingURL=core-job-native-utils.d.ts.map

package/dist/commands/core-job-native-utils.js

@@ -1,7 +1,5 @@
 import { resolveLiveRoot } from "../utils/hq-roots.js";
-import { runBundledScript } from "../utils/run-bundled-script.js";
 import { describeCoreCommand } from "./core-command-catalog.js";
-import { coreNativeJobsEnabled } from "./core-native-jobs-flag.js";
 /** Preserve raw argv (including the option terminator) through Commander. */
 export function rawJobArgumentsForCommand(command, fallback, raw = process.argv) {
     const names = [];
@@ -19,8 +17,8 @@ export function rawJobArgumentsForCommand(command, fallback, raw = process.argv)
     }
     return start >= 0 ? raw.slice(start) : (command.args.length ? command.args : fallback);
 }
-/** Shared gated registration path for each leaf in the singular job group. */
-export function registerCoreJobLeaf(group, core, name, asset, summary, run, canUseLiveRoot, valueOptions, booleanOptions = []) {
+/** Shared registration path for each leaf in the singular job group. */
+export function registerCoreJobLeaf(group, core, name, summary, run, canUseLiveRoot, valueOptions, booleanOptions = []) {
     const command = group.command(name)
         .description(summary)
         .helpOption(false)
@@ -33,17 +31,11 @@ export function registerCoreJobLeaf(group, core, name, asset, summary, run, canU
         const hqRoot = canUseLiveRoot(argv)
             ? resolveLiveRoot({ hqRoot: leafRootOverride(argv, valueOptions, booleanOptions) ?? groupHqRoot })
             : groupHqRoot ?? "";
-        if (!await coreNativeJobsEnabled()) {
-            const result = runBundledScript({ asset, args: argv, cwd: process.cwd(), hqRoot: hqRoot || undefined });
-            if (result.code !== 0)
-                process.exit(result.code);
-            return;
-        }
         const result = run(argv, hqRoot);
         if (result !== 0)
             process.exit(result);
     });
-    describeCoreCommand(command, { execution: "native", asset, root: "live" });
+    describeCoreCommand(command, { execution: "native", root: "live" });
 }
 /**
  * Find a leaf --hq-root without resolving anything until the leaf parser has

package/dist/commands/core-job-notify-native.js

@@ -5,7 +5,6 @@ import { spawnSync } from "node:child_process";
 import { load } from "js-yaml";
 import { serializeJqJson } from "../lib/core-utils/jq-json-serializer.js";
 import { registerCoreJobLeaf } from "./core-job-native-utils.js";
-const ASSET = "core/scripts/hq-job-notify.sh";
 const USAGE = [
     "hq-job-notify.sh — dm-only remediation alerts for Outpost scheduled jobs (US-006).",
     "",
@@ -351,7 +350,7 @@ export function runJobNotify(argv, options = {}) {
     return 0;
 }
 export function registerCoreJobNotifyNativeCommand(group, core) {
-    registerCoreJobLeaf(group, core, "notify", ASSET, "Send a scheduled-job status alert to its owner", (argv, hqRoot) => runJobNotify(argv, { hqRoot }), canUseLiveRootForArguments, [
+    registerCoreJobLeaf(group, core, "notify", "Send a scheduled-job status alert to its owner", (argv, hqRoot) => runJobNotify(argv, { hqRoot }), canUseLiveRootForArguments, [
         "--hq-root", "--job-id", "--job-name", "--outcome", "--summary", "--duration", "--log-path",
         "--failure-class", "--next-action", "--owner", "--notify",
     ]);

package/dist/commands/core-job-probe-native.d.ts

@@ -1,7 +1,6 @@
 import type { Command } from "commander";
-export declare const JOB_PROBE_ASSET = "core/scripts/hq-job-probe.sh";
 export declare function displayJobFile(value: string, platform?: NodeJS.Platform): string;
-export declare function displayShellPath(value: string, platform?: NodeJS.Platform): string;
+export declare function displayShellRegistryError(value: string, platform?: NodeJS.Platform): string;
 export declare const JOB_PROBE_USAGE: string;
 export type Checks = {
     runtime: string;
@@ -32,7 +31,7 @@ export type ProbeDeps = {
     isDirectory: (file: string) => boolean;
     realpath: (file: string) => string | undefined;
     readText: (file: string) => string;
-    writeState: (file: string, body: string, mode: number) => void;
+    writeState: (file: string, body: string, mode: number, lineEnding?: "\n" | "\r\n") => void;
     writeStderr: (line: string) => void;
     listSecrets: (company?: string) => Promise<{
         code: number;

package/dist/commands/core-job-probe-native.js

@@ -5,23 +5,18 @@ import * as path from "node:path";
 import { load, JSON_SCHEMA } from "js-yaml";
 import { serializeJqJson } from "../lib/core-utils/jq-json-serializer.js";
 import { resolveLiveRoot } from "../utils/hq-roots.js";
-import { runBundledScript } from "../utils/run-bundled-script.js";
 import { describeCoreCommand } from "./core-command-catalog.js";
-import { coreNativeJobsEnabled } from "./core-native-jobs-flag.js";
 import { resolveWindowsExecutable } from "../lib/bot/runtime/windows.js";
 import { planResolvedCommandSpawn } from "../utils/windows-spawn.js";
-export const JOB_PROBE_ASSET = "core/scripts/hq-job-probe.sh";
 export function displayJobFile(value, platform = process.platform) {
     if (platform !== "win32")
         return value;
     return path.win32.resolve(value).replaceAll("\\", "/");
 }
-export function displayShellPath(value, platform = process.platform) {
+export function displayShellRegistryError(value, platform = process.platform) {
     if (platform !== "win32")
         return value;
-    const normalized = value.replaceAll("\\", "/");
-    const drivePath = /^([A-Za-z]):\/(.*)$/u.exec(normalized);
-    return drivePath ? `/${drivePath[1].toLowerCase()}/${drivePath[2]}` : normalized;
+    return value.replace(/([A-Za-z]):[\\/]/gu, (_match, drive) => `/${drive.toLowerCase()}/`).replaceAll("\\", "/");
 }
 export const JOB_PROBE_USAGE = [
     "hq-job-probe.sh — Outpost requirements probe → hq-pro jobs status (US-008).", "",
@@ -93,7 +88,7 @@ const realpath = (f) => { try {
 catch {
     return undefined;
 } };
-function writeState(file, body, mode) { fs.mkdirSync(path.dirname(file), { recursive: true }); fs.writeFileSync(file, `${body}\n`, { mode }); try {
+function writeState(file, body, mode, lineEnding = "\n") { fs.mkdirSync(path.dirname(file), { recursive: true }); fs.writeFileSync(file, `${body}${lineEnding}`, { mode }); try {
     fs.chmodSync(file, mode);
 }
 catch { /* legacy chmod is best-effort */ } }
@@ -286,7 +281,12 @@ function auth(runtime, d) {
     return (d.statSize(file) ?? 0) > 0 ? "ok" : "missing";
 }
 function writeAttempt(d, id, data) { d.writeState(path.join(d.env.HQ_JOB_PROBE_STATE_DIR || path.join(d.home, ".hq/jobs/probes"), id, "last-attempt.json"), compact(data), 0o600); }
-function writeCache(d, id, readiness, source) { d.writeState(path.join(d.env.HQ_JOB_STATUS_CACHE_DIR || path.join(d.home, ".hq/jobs/status-cache"), `${id}.json`), compact({ job_id: id, readiness, updated_at: isoNow(d), source }), 0o600); }
+function writeCache(d, id, readiness, source) {
+    // The bundled shell redirects the Windows jq.exe output to this file. The
+    // Windows runtime writes CRLF, so preserve those bytes in the native port.
+    const lineEnding = process.platform === "win32" ? "\r\n" : "\n";
+    d.writeState(path.join(d.env.HQ_JOB_STATUS_CACHE_DIR || path.join(d.home, ".hq/jobs/status-cache"), `${id}.json`), compact({ job_id: id, readiness, updated_at: isoNow(d), source }), 0o600, lineEnding);
+}
 function resolveCwd(root, cwd, d) {
     const canon = d.realpath(root) ?? path.resolve(root), candidate = path.resolve(root, cwd), file = d.realpath(candidate) ?? candidate;
     return { file, allowed: file === canon || file.startsWith(`${canon}${path.sep}`) };
@@ -338,13 +338,13 @@ async function probeFile(file, dry, d) {
     catch (e) {
         const rawStderr = legacyYamlParseDiagnostics(file, d);
         if (rawStderr)
-            throw new Fatal(`job missing id: ${displayShellPath(file)}`, 2, "hq-job-probe", rawStderr);
+            throw new Fatal(`job missing id: ${displayJobFile(file)}`, 2, "hq-job-probe", rawStderr);
         throw new Fatal(`invalid job YAML: ${file}${e instanceof Error ? `: ${e.message}` : ""}`);
     }
     const id = scalar(job.id), name = scalar(job.name), runtime = scalar(nested(job, "requirements", "runtime")) || scalar(job.runtime);
     const company = scalar(nested(job, "requirements", "company")), cwd = scalar(nested(job, "requirements", "cwd") ?? job.cwd);
     if (!id)
-        throw new Fatal(`job missing id: ${displayShellPath(file)}`);
+        throw new Fatal(`job missing id: ${displayJobFile(file)}`);
     if (!runtime)
         throw new Fatal(`job missing runtime: ${file}`);
     const at = isoNow(d), actions = [], authState = auth(runtime, d);
@@ -515,7 +515,7 @@ export async function runJobProbe(argv, injected) {
             return { code: 2, stdout: "", stderr: "hq-job-probe: --all does not take a job argument\n" };
         const files = allFiles(root);
         if (!files.length)
-            return { code: 2, stdout: "", stderr: `hq-job-probe: no job YAML found under personal/jobs or companies/*/jobs in ${displayShellPath(root)}\n` };
+            return { code: 2, stdout: "", stderr: `hq-job-probe: no job YAML found under personal/jobs or companies/*/jobs in ${displayJobFile(root)}\n` };
         let code = 0;
         try {
             for (const f of files) {
@@ -545,9 +545,7 @@ export async function runJobProbe(argv, injected) {
             // then emits the ordinary not-found error after the process substitution
             // closes. Preserve both stderr lines for byte parity.
             if (x instanceof Fatal && x.message.startsWith("duplicate job id '")) {
-                const shellMessage = process.platform === "win32"
-                    ? x.message.replace(/([A-Za-z]):[\\/]/gu, (_match, drive) => "/" + drive.toLowerCase() + "/").replaceAll("\\", "/")
-                    : x.message;
+                const shellMessage = displayShellRegistryError(x.message);
                 return { code: x.code, stdout: "", stderr: `${x.prefix}: ${shellMessage}\n${x.prefix}: job id not found in registry: ${opts.target}\n` };
             }
             return failure(x);
@@ -593,12 +591,6 @@ export function registerCoreJobProbeCommand(job) {
         const root = !forwarded.help && (!forwarded.hasRoot || Boolean(forwarded.root))
             ? resolveLiveRoot({ hqRoot: forwarded.hasRoot ? forwarded.root : core.opts().hqRoot })
             : undefined;
-        if (!await coreNativeJobsEnabled()) {
-            const r = runBundledScript({ asset: JOB_PROBE_ASSET, args: argv, cwd: process.cwd(), ...(root ? { hqRoot: root } : {}) });
-            if (r.code)
-                process.exit(r.code);
-            return;
-        }
         const r = await runJobProbe(argv, defaultProbeDeps(root ?? (process.env.HQ_ROOT || process.cwd())));
         if (r.stdout)
             process.stdout.write(r.stdout.endsWith("\n") ? r.stdout : `${r.stdout}\n`);
@@ -607,6 +599,6 @@ export function registerCoreJobProbeCommand(job) {
         if (r.code)
             process.exit(r.code);
     });
-    describeCoreCommand(command, { execution: "native", asset: JOB_PROBE_ASSET, root: "live" });
+    describeCoreCommand(command, { execution: "native", root: "live" });
 }
 //# sourceMappingURL=core-job-probe-native.js.map

package/dist/commands/core-job-remediate-native.js

@@ -4,7 +4,6 @@ import * as os from "node:os";
 import { spawnSync } from "node:child_process";
 import { serializeJqJson } from "../lib/core-utils/jq-json-serializer.js";
 import { registerCoreJobLeaf } from "./core-job-native-utils.js";
-const ASSET = "core/scripts/hq-job-remediate.sh";
 const USAGE = [
     "hq-job-remediate.sh — bounded self-remediation for Outpost scheduled jobs (US-006).",
     "",
@@ -367,7 +366,7 @@ export function runJobRemediate(argv, options = {}) {
     }
 }
 export function registerCoreJobRemediateNativeCommand(group, core) {
-    registerCoreJobLeaf(group, core, "remediate", ASSET, "Run bounded remediation for a scheduled-job failure", (argv, hqRoot) => runJobRemediate(argv, { hqRoot }), canUseLiveRootForArguments, [
+    registerCoreJobLeaf(group, core, "remediate", "Run bounded remediation for a scheduled-job failure", (argv, hqRoot) => runJobRemediate(argv, { hqRoot }), canUseLiveRootForArguments, [
         "--hq-root", "--failure-class", "--job-id", "--company",
     ], ["--dry-run"]);
 }