@indigoai-us/hq-cli 5.341.1 → 5.341.3

package/dist/lib/daemon/windows-pipe-host.js

@@ -0,0 +1,218 @@
+import { spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { createInterface } from "node:readline";
+import { Duplex } from "node:stream";
+import { fileURLToPath } from "node:url";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { parseSddlDacl, sddlAccountToSid } from "../work-context/windows-acl.js";
+export const WINDOWS_PIPE_STARTUP_REFUSAL = "hqd is disabled on Windows because the default named-pipe ACL grants read access to Everyone and Anonymous accounts.";
+export function validateWindowsPipeAcl(report) {
+    if (!/^S-1-\d+(?:-\d+)+$/i.test(report.userSid))
+        throw new Error("Windows pipe ACL did not report a valid current user SID");
+    const aces = parseSddlDacl(report.sddl);
+    if (!aces || aces.length !== 1)
+        throw new Error("Windows pipe DACL is not user-only");
+    const [ace] = aces;
+    // Windows uses the LA SDDL alias for the local Administrator account. Its
+    // SID is machine-specific, so match it only when the OS-reported current
+    // user is that account (RID 500).
+    const sid = ace.account.toUpperCase() === "LA" && /^(?:S-1-5-21-\d+-\d+-\d+-)500$/i.test(report.userSid)
+        ? report.userSid.toUpperCase()
+        : sddlAccountToSid(ace.account);
+    const rights = ace.rights.toUpperCase();
+    const fullPipeControl = rights === "GA" || rights === "0X1F019F" || rights === "0X001F019F";
+    if (ace.type !== "A" || ace.flags !== "" || sid?.toUpperCase() !== report.userSid.toUpperCase() || !fullPipeControl) {
+        throw new Error("Windows pipe DACL is not user-only");
+    }
+    const daclPrefix = report.sddl.match(/(?:^|:)D:([A-Z_]*)\(/i)?.[1] ?? "";
+    if (!daclPrefix.includes("P"))
+        throw new Error("Windows pipe DACL is not protected from inherited ACEs");
+    return report;
+}
+function helperPath() {
+    return fileURLToPath(new URL("../../../assets/hqd/windows-pipe-host.ps1", import.meta.url));
+}
+function powershellPath() {
+    const root = process.env.SystemRoot ?? process.env.windir ?? "C:\\Windows";
+    const windowsPowerShell = path.join(root, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+    if (fs.existsSync(windowsPowerShell))
+        return windowsPowerShell;
+    const programFiles = process.env.ProgramW6432 ?? process.env.ProgramFiles ?? "C:\\Program Files";
+    const pwsh7 = path.join(programFiles, "PowerShell", "7", "pwsh.exe");
+    if (fs.existsSync(pwsh7))
+        return pwsh7;
+    throw new Error("Windows PowerShell 5.1 or PowerShell 7 is unavailable");
+}
+class WindowsPipeClient extends Duplex {
+    host;
+    connectionId;
+    constructor(host, connectionId) {
+        super({ decodeStrings: true, allowHalfOpen: false });
+        this.host = host;
+        this.connectionId = connectionId;
+    }
+    _read() { }
+    _write(chunk, _encoding, callback) {
+        this.host.write(this.connectionId, chunk, callback);
+    }
+    _final(callback) {
+        this.host.closeConnection(this.connectionId);
+        callback();
+    }
+    _destroy(err, callback) {
+        this.host.closeConnection(this.connectionId);
+        callback(err);
+    }
+    receive(data) {
+        this.push(data);
+    }
+    endFromHost() {
+        this.push(null);
+    }
+}
+class SpawnedWindowsPipeHost extends EventEmitter {
+    child;
+    clients = new Map();
+    lineReader;
+    closed = false;
+    closing = false;
+    constructor(pipePath) {
+        super();
+        const script = helperPath();
+        if (!fs.existsSync(script))
+            throw new Error(`Windows pipe helper is missing at ${script}`);
+        this.child = spawn(powershellPath(), ["-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File", script], {
+            windowsHide: true,
+            stdio: ["pipe", "pipe", "pipe"],
+            env: { ...process.env, HQD_PIPE_NAME: pipePath },
+        });
+        let stderr = "";
+        this.child.stderr?.setEncoding("utf8");
+        this.child.stderr?.on("data", (chunk) => {
+            stderr = `${stderr}${chunk}`.slice(-8_192);
+        });
+        this.lineReader = createInterface({ input: this.child.stdout, crlfDelay: Infinity });
+        this.lineReader.on("line", (line) => this.receiveLine(line));
+        this.child.once("error", (err) => this.emit("failure", err));
+        this.child.once("exit", (code, signal) => {
+            this.closed = true;
+            if (this.closing)
+                return;
+            const err = new Error(`Windows pipe helper exited (${signal ?? code})${stderr.trim() ? `: ${stderr.trim()}` : ""}`);
+            this.emit("failure", err);
+            for (const client of this.clients.values())
+                client.destroy(err);
+            this.clients.clear();
+        });
+    }
+    static async start(pipePath, timeoutMs = 15_000) {
+        const host = new SpawnedWindowsPipeHost(pipePath);
+        try {
+            const acl = await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => reject(new Error("Windows pipe helper did not verify its ACL before timeout")), timeoutMs);
+                const onReady = (report) => {
+                    clearTimeout(timeout);
+                    host.off("failure", onFailure);
+                    resolve(report);
+                };
+                const onFailure = (err) => {
+                    clearTimeout(timeout);
+                    host.off("ready", onReady);
+                    reject(err);
+                };
+                host.once("ready", onReady);
+                host.once("failure", onFailure);
+            });
+            try {
+                return { host, acl: validateWindowsPipeAcl(acl) };
+            }
+            catch (err) {
+                throw new Error(`Windows pipe helper reported DACL ${JSON.stringify(acl.sddl)} for ${acl.userSid}: ${err.message}`);
+            }
+        }
+        catch (err) {
+            await host.close();
+            throw err;
+        }
+    }
+    receiveLine(line) {
+        const [kind, rawId, rawData] = line.split("\t");
+        if (kind === "READY") {
+            try {
+                this.emit("ready", { userSid: rawId, sddl: Buffer.from(rawData ?? "", "base64").toString("utf8") });
+            }
+            catch (err) {
+                this.emit("failure", err instanceof Error ? err : new Error(String(err)));
+            }
+            return;
+        }
+        if (kind === "FATAL") {
+            this.emit("failure", new Error(Buffer.from(rawId ?? "", "base64").toString("utf8") || "Windows pipe helper failed"));
+            return;
+        }
+        if (kind === "REJECT") {
+            this.emit("rejectedRemoteClient", Buffer.from(rawId ?? "", "base64").toString("utf8"));
+            return;
+        }
+        const connectionId = Number(rawId);
+        if (!Number.isSafeInteger(connectionId))
+            return;
+        if (kind === "OPEN") {
+            const client = new WindowsPipeClient(this, connectionId);
+            this.clients.set(connectionId, client);
+            this.emit("connection", client);
+            return;
+        }
+        const client = this.clients.get(connectionId);
+        if (!client)
+            return;
+        if (kind === "DATA")
+            client.receive(Buffer.from(rawData ?? "", "base64"));
+        else if (kind === "CLOSE") {
+            client.endFromHost();
+            this.clients.delete(connectionId);
+        }
+    }
+    write(connectionId, data, callback) {
+        if (this.closed || !this.child.stdin?.writable) {
+            callback(new Error("Windows pipe helper is closed"));
+            return;
+        }
+        this.child.stdin.write(`WRITE\t${connectionId}\t${data.toString("base64")}\n`, "utf8", callback);
+    }
+    closeConnection(connectionId) {
+        if (!this.closed && this.child.stdin?.writable)
+            this.child.stdin.write(`CLOSE\t${connectionId}\n`);
+        this.clients.delete(connectionId);
+    }
+    startAccepting() {
+        if (!this.closed && this.child.stdin?.writable)
+            this.child.stdin.write("START\n");
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closing = true;
+        this.child.stdin?.end();
+        await new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.child.kill();
+                resolve();
+            }, 5_000);
+            this.child.once("exit", () => {
+                clearTimeout(timer);
+                resolve();
+            });
+        });
+    }
+}
+export async function startWindowsPipeHost(pipePath) {
+    const prefix = "\\\\.\\pipe\\";
+    const pipeName = pipePath.toLowerCase().startsWith(prefix.toLowerCase()) ? pipePath.slice(prefix.length) : pipePath;
+    if (!pipeName || pipeName.includes("\\") || pipeName.includes("/")) {
+        throw new Error("Windows hqd pipe path is not a local named-pipe name");
+    }
+    return SpawnedWindowsPipeHost.start(pipeName);
+}
+//# sourceMappingURL=windows-pipe-host.js.map

package/dist/lib/diagnostics.d.ts

@@ -0,0 +1,9 @@
+/**
+ * True when the person asked for diagnostics.
+ *
+ * Global `--verbose`, or `HQ_DEBUG` set to `1`, `true`, or `yes` (any case,
+ * surrounding spaces ignored). Callers pass `options.env` and `options.argv`
+ * when a command injects them; otherwise the process values are used.
+ */
+export declare function diagnosticsEnabled(env?: NodeJS.ProcessEnv, argv?: readonly string[]): boolean;
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/lib/diagnostics.js

@@ -0,0 +1,12 @@
+/**
+ * True when the person asked for diagnostics.
+ *
+ * Global `--verbose`, or `HQ_DEBUG` set to `1`, `true`, or `yes` (any case,
+ * surrounding spaces ignored). Callers pass `options.env` and `options.argv`
+ * when a command injects them; otherwise the process values are used.
+ */
+export function diagnosticsEnabled(env = process.env, argv = process.argv) {
+    const debug = env.HQ_DEBUG?.trim() ?? "";
+    return argv.includes("--verbose") || /^(1|true|yes)$/i.test(debug);
+}
+//# sourceMappingURL=diagnostics.js.map

package/dist/lib/doctor/checks/anywhere.d.ts

@@ -8,6 +8,7 @@
  * WARN or FAIL with a remediation command. When anywhere was never installed
  * on this machine the family reports a single NA line.
  */
+import { type HqdHealthResult } from "../../daemon/protocol.js";
 import type { CheckContext, CheckFamily, CheckResult } from "../types.js";
 export declare const ANYWHERE_FAMILY_ID = "anywhere";
 export declare const REMEDIATION: {
@@ -27,6 +28,10 @@ export interface AnywhereDeps {
     env?: NodeJS.ProcessEnv;
     /** Version hqd reports; rejects when the socket is unreachable. */
     ping?: () => Promise<string>;
+    /** Read-only hqd health op. Test seam; production queries the daemon socket. */
+    health?: (cwd: string) => Promise<HqdHealthResult>;
+    /** Test seam for the local runtime gate used to keep other checks out of a disabled runtime. */
+    runtimeEnabled?: () => boolean;
     /** The hq-cli version installed on this machine. Default: this CLI's version. */
     cliVersion?: string;
     serviceState?: () => DaemonServiceState;
@@ -34,5 +39,5 @@ export interface AnywhereDeps {
 }
 export declare function createAnywhereFamily(deps?: AnywhereDeps): CheckFamily;
 export declare const anywhereFamily: CheckFamily;
-export declare function runAnywhereChecks(_context: CheckContext, deps?: AnywhereDeps): Promise<CheckResult[]>;
+export declare function runAnywhereChecks(context: CheckContext, deps?: AnywhereDeps): Promise<CheckResult[]>;
 //# sourceMappingURL=anywhere.d.ts.map

package/dist/lib/doctor/checks/anywhere.js

@@ -18,11 +18,12 @@ import { HQ_MCP_SERVER_NAME, SKILL_LINK_PREFIX, claudeTargets } from "../../inst
 import { codexTargets } from "../../install/codex-targets.js";
 import { CHATGPT_MODE } from "../../install/chatgpt-targets.js";
 import { GROK_MODE } from "../../install/grok-targets.js";
-import { pingHqdVersion } from "../../daemon/convergence.js";
+import { HqdClientError, hqdRequest } from "../../daemon/protocol.js";
 import { daemonPresenceLabel, heartbeatFile, readHeartbeat } from "../../daemon/heartbeat.js";
 import { DAEMON_LAUNCHD_LABEL, DAEMON_SYSTEMD_UNIT, DAEMON_WINDOWS_TASK } from "../../daemon/install.js";
 import { hqdSocketPath } from "../../daemon/protocol.js";
 import { readRegistry, registryDir, registryFile } from "../../registry/registry.js";
+import { anywhereRuntimeEnabled } from "../../../commands/anywhere-runtime-flag.js";
 export const ANYWHERE_FAMILY_ID = "anywhere";
 export const REMEDIATION = {
     installClaude: "hq install --global --runtime claude",
@@ -38,9 +39,69 @@ export const anywhereFamily = createAnywhereFamily();
 function result(status, checkId, message, remediation, target) {
     return { status, checkId: `anywhere.${checkId}`, message, ...(remediation ? { remediation } : {}), ...(target ? { target } : {}) };
 }
-export async function runAnywhereChecks(_context, deps = {}) {
+export async function runAnywhereChecks(context, deps = {}) {
     const home = deps.home ?? os.homedir();
     const env = deps.env ?? process.env;
+    const socketPath = hqdSocketPath(home, env);
+    const cwd = context.cwd ?? process.cwd();
+    const runtimeEnabled = (deps.runtimeEnabled ?? anywhereRuntimeEnabled)();
+    let health;
+    let healthUnsupported = false;
+    try {
+        if (deps.health) {
+            health = await deps.health(cwd);
+        }
+        else if (deps.ping) {
+            const version = await deps.ping();
+            health = {
+                reachable: true,
+                version,
+                uptimeMs: null,
+                flag: { enabled: runtimeEnabled, lastSuccessfulReadAgeMs: null, heldThroughReadError: false },
+                resolution: { scope: "personal", company: null, fallbackReason: "no_match" },
+                socket: { path: socketPath, transport: process.platform === "win32" ? "windows_named_pipe" : "unix_socket", mode: null, ownerMatchesUser: null, userOnly: null },
+            };
+        }
+        else {
+            health = await hqdRequest("health", { cwd }, { socketPath });
+        }
+    }
+    catch (error) {
+        if (error instanceof HqdClientError && error.code === "unknown_op") {
+            try {
+                let version = null;
+                let uptimeMs = null;
+                if (deps.ping) {
+                    version = await deps.ping();
+                }
+                else {
+                    const ping = await hqdRequest("ping", {}, { socketPath });
+                    if (typeof ping.version === "string")
+                        version = ping.version;
+                    if (typeof ping.uptimeMs === "number")
+                        uptimeMs = ping.uptimeMs;
+                }
+                health = {
+                    reachable: true,
+                    version,
+                    uptimeMs,
+                    flag: { enabled: null, lastSuccessfulReadAgeMs: null, heldThroughReadError: false },
+                    resolution: { scope: "unknown", company: null, fallbackReason: null },
+                    socket: { path: socketPath, transport: process.platform === "win32" ? "windows_named_pipe" : "unix_socket", mode: null, ownerMatchesUser: null, userOnly: null },
+                };
+                healthUnsupported = true;
+            }
+            catch {
+                health = unreachableHealth(socketPath);
+            }
+        }
+        else {
+            health = unreachableHealth(socketPath);
+        }
+    }
+    const healthCheck = runtimeHealthCheck(health, healthUnsupported);
+    if (!runtimeEnabled)
+        return [healthCheck];
     const claude = claudeTargets(home);
     const codex = codexTargets(home);
     const installed = [claude.hqPointer, claude.stateFile, codex.stateFile].some((p) => fs.existsSync(p));
@@ -48,10 +109,10 @@ export async function runAnywhereChecks(_context, deps = {}) {
         result("WARN", "chatgpt-mode", `ChatGPT integration mode: ${CHATGPT_MODE}; host connector setup is managed in ChatGPT`, "hq install --global --runtime chatgpt"),
         result("WARN", "grok-mode", `Grok integration mode: ${GROK_MODE}; host connector setup is managed in Grok`, "hq install --global --runtime grok"),
     ];
+    const out = [healthCheck, ...remoteModes];
     if (!installed) {
-        return [...remoteModes, result("NA", "installed", "HQ local anywhere runtime is not installed on this machine", REMEDIATION.installClaude)];
+        return [...out, result("NA", "installed", "HQ local anywhere runtime is not installed on this machine", REMEDIATION.installClaude)];
     }
-    const out = [...remoteModes];
     const pluginInstall = readClaudePluginInstall(claude.stateFile);
     out.push(checkInstallMode(claude.stateFile));
     out.push(checkPointer(claude.hqPointer));
@@ -63,16 +124,11 @@ export async function runAnywhereChecks(_context, deps = {}) {
         out.push(result("FAIL", "daemon-installed", `daemon service is installed but not loaded (${service.detail})`, REMEDIATION.daemonRestart));
     else
         out.push(result("PASS", "daemon-installed", `daemon service is installed and loaded (${service.detail})`));
-    const socketPath = hqdSocketPath(home, env);
-    const ping = deps.ping ?? (() => pingHqdVersion(socketPath, 2_000));
-    let running = null;
-    try {
-        running = await ping();
+    const running = health.reachable ? health.version : null;
+    if (health.reachable)
         out.push(result("PASS", "socket", `hqd answered on ${socketPath}`, undefined, socketPath));
-    }
-    catch (err) {
-        out.push(result("FAIL", "socket", `hqd is not reachable: ${err instanceof Error ? err.message : String(err)}`, REMEDIATION.daemonInstall, socketPath));
-    }
+    else
+        out.push(result("FAIL", "socket", `hqd is not reachable on ${socketPath}`, REMEDIATION.daemonInstall, socketPath));
     const cliVersion = deps.cliVersion ?? CLI_VERSION;
     if (running === null)
         out.push(result("FAIL", "version", `cannot compare versions: hqd did not answer (hq-cli is ${cliVersion})`, REMEDIATION.daemonInstall));
@@ -96,6 +152,68 @@ export async function runAnywhereChecks(_context, deps = {}) {
         out.push(checkSkillLinks("codex", codex.skillsDir, REMEDIATION.installCodex));
     return out;
 }
+function unreachableHealth(socketPath) {
+    return {
+        reachable: false,
+        version: null,
+        uptimeMs: null,
+        flag: { enabled: null, lastSuccessfulReadAgeMs: null, heldThroughReadError: false },
+        resolution: { scope: "unknown", company: null, fallbackReason: null },
+        socket: { path: socketPath, transport: process.platform === "win32" ? "windows_named_pipe" : "unix_socket", mode: null, ownerMatchesUser: null, userOnly: null },
+    };
+}
+function runtimeHealthCheck(health, healthUnsupported = false) {
+    const { flag, resolution, socket } = health;
+    const age = flag.lastSuccessfulReadAgeMs === null
+        ? "unknown"
+        : `${new Intl.NumberFormat("en-US").format(flag.lastSuccessfulReadAgeMs)} ms`;
+    const flagLabel = flag.enabled === null ? "unknown" : flag.enabled ? "on" : "off";
+    const binding = resolution.scope === "company"
+        ? `company ${resolution.company}`
+        : resolution.scope === "personal"
+            ? `personal (fallback: ${resolution.fallbackReason ?? "unspecified"})`
+            : health.reachable && healthUnsupported
+                ? "unknown (resident daemon lacks the health operation)"
+                : "unknown (daemon unavailable)";
+    const socketSecurity = socket.transport === "windows_named_pipe"
+        ? "Windows named pipe (mode and owner are not reported)"
+        : `mode ${socket.mode ?? "unknown"}; owner matches current user: ${socket.ownerMatchesUser === null ? "unknown" : socket.ownerMatchesUser ? "yes" : "no"}; user-only: ${socket.userOnly === null ? "unknown" : socket.userOnly ? "yes" : "no"}`;
+    const unreachableMessage = socket.transport === "windows_named_pipe"
+        ? `hqd is not reachable on ${socket.path}; Windows daemon startup is refused because named-pipe ACLs are unsupported`
+        : `hqd is not reachable on ${socket.path}; version, uptime, flag state, and cwd binding are unavailable`;
+    const socketNotUserOnly = health.reachable && socket.transport === "unix_socket" && (socket.userOnly !== true || socket.ownerMatchesUser !== true);
+    const warningNotes = [
+        healthUnsupported ? "resident hqd does not support detailed health; restart hqd for full diagnostics" : null,
+        socketNotUserOnly ? "socket is not confirmed user-only" : null,
+    ].filter((note) => note !== null);
+    const message = health.reachable
+        ? `hqd reachable; version ${health.version ?? "unknown"}; uptime ${health.uptimeMs === null ? "unknown" : `${new Intl.NumberFormat("en-US").format(health.uptimeMs)} ms`}; runtime flag ${flagLabel}; last successful flag read ${age} ago; held through read error: ${flag.heldThroughReadError ? "yes" : "no"}; cwd binding ${binding}; socket ${socket.path}; ${socketSecurity}${warningNotes.length ? `; ${warningNotes.join("; ")}` : ""}`
+        : unreachableMessage;
+    const remediation = healthUnsupported || socketNotUserOnly ? REMEDIATION.daemonRestart : undefined;
+    return {
+        status: health.reachable && warningNotes.length === 0 ? "PASS" : "WARN",
+        checkId: "anywhere.runtime-health",
+        target: socket.path,
+        message,
+        ...(remediation ? { remediation } : {}),
+        details: {
+            reachable: health.reachable,
+            version: health.version,
+            uptimeMs: health.uptimeMs,
+            flagEnabled: flag.enabled,
+            lastSuccessfulFlagReadAgeMs: flag.lastSuccessfulReadAgeMs,
+            flagHeldThroughReadError: flag.heldThroughReadError,
+            resolvedScope: resolution.scope,
+            company: resolution.company,
+            fallbackReason: resolution.fallbackReason,
+            socketPath: socket.path,
+            socketTransport: socket.transport,
+            socketMode: socket.mode,
+            socketOwnerMatchesUser: socket.ownerMatchesUser,
+            socketUserOnly: socket.userOnly,
+        },
+    };
+}
 function checkInstallMode(file) {
     try {
         const state = JSON.parse(fs.readFileSync(file, 'utf8'));

package/dist/lib/doctor/json-output.d.ts

@@ -58,6 +58,8 @@ export interface DoctorJsonResult {
     target?: string;
     /** Human-readable explanation. */
     message: string;
+    /** Safe structured diagnostic fields, when a check provides them. */
+    details?: Record<string, unknown>;
     /** Remediation hint. Present only when the result carries one. */
     remediation?: string;
     /** Structured remediation (US-011). Present on actionable findings only. */

package/dist/lib/doctor/json-output.js

@@ -60,6 +60,7 @@ function toJsonResult(familyId, result, clientHealthReasonCodesEnabledCheckIds)
             : {}),
         ...(result.target !== undefined ? { target: result.target } : {}),
         message: result.message,
+        ...(result.details !== undefined ? { details: result.details } : {}),
         ...(result.remediation !== undefined
             ? { remediation: result.remediation }
             : {}),

package/dist/lib/doctor/registry.js

@@ -27,7 +27,6 @@ import { anywhereFamily } from "./checks/anywhere.js";
 import { scaffoldCliFloorFamily } from "./checks/scaffold-cli-floor.js";
 import { fixtureCoverageFamily } from "./fixtures/discover.js";
 import { checkClaudeWiring } from "./checks/claude-wiring.js";
-import { anywhereRuntimeEnabled } from "../../commands/anywhere-runtime-flag.js";
 /**
  * An ordered, id-keyed set of check families. Registration order is preserved
  * (Map iteration order), and re-registering an id replaces the family in place
@@ -266,8 +265,7 @@ export function createDefaultRegistry() {
     registry.register(botsFamily);
     // HQ anywhere (US-012): pointer, registry, hqd service/socket/version,
     // heartbeat, MCP registrations and skill links. NA when not installed.
-    if (anywhereRuntimeEnabled())
-        registry.register(anywhereFamily);
+    registry.register(anywhereFamily);
     return registry;
 }
 //# sourceMappingURL=registry.js.map

package/dist/lib/doctor/types.d.ts

@@ -35,6 +35,8 @@ export interface CheckResult {
     target?: string;
     /** Human-readable one-line explanation of the result. */
     message: string;
+    /** Safe structured fields for machine-readable results. */
+    details?: Record<string, unknown>;
     /** Optional remediation hint (a command or instruction). */
     remediation?: string;
 }
@@ -47,6 +49,8 @@ export interface CheckResult {
 export interface CheckContext {
     /** Absolute, resolved HQ tree root every check reads from. */
     hqRoot: string;
+    /** Original caller working directory, used only for company/personal binding diagnostics. */
+    cwd?: string;
     /**
      * The detected host platform (id, and optionally the evidence behind it).
      * Host-specific live checks — the US-006 runtime probe — key their

package/dist/utils/package-use-lease.d.ts

@@ -16,6 +16,10 @@ export declare function packageUseUpdateRequestPath(prefix: string, stateDirecto
 declare function waitForUpdateRequest(requestPath: string, timeoutMs: number): void;
 export declare function acquirePackageUseLease(prefix: string, hqVersion: string, stateDirectory?: string): PackageUseLease;
 export declare function acquireCurrentPackageUseLease(): PackageUseLease | null;
+/** True only when a valid update request belongs to a live updater process. */
+export declare function packageUseUpdatePending(prefix: string, stateDirectory?: string): boolean;
+/** True while the desktop updater owns the per-prefix update request. */
+export declare function currentPackageUseUpdatePending(): boolean;
 /** True while the desktop updater owns the per-prefix update request. */
 export declare function currentPackageUseUpdateRequested(): boolean;
 export declare const __test__: {

package/dist/utils/package-use-lease.js

@@ -197,6 +197,34 @@ export function acquireCurrentPackageUseLease() {
     }
     return acquirePackageUseLease(prefix, pkg.version);
 }
+/** True only when a valid update request belongs to a live updater process. */
+export function packageUseUpdatePending(prefix, stateDirectory) {
+    try {
+        waitForUpdateRequest(packageUseUpdateRequestPath(prefix, stateDirectory), 0);
+        return false;
+    }
+    catch (error) {
+        if (error instanceof PackageUseUpdatePendingError)
+            return true;
+        throw error;
+    }
+}
+/** True while the desktop updater owns the per-prefix update request. */
+export function currentPackageUseUpdatePending() {
+    const pkg = findCliPackage(path.dirname(fileURLToPath(import.meta.url)));
+    if (!pkg || isPnpmGlobal(pkg.root) || isBunGlobal(pkg.root))
+        return false;
+    const prefix = npmPrefix(pkg.root);
+    if (!prefix)
+        return false;
+    if (process.platform !== "win32") {
+        const parts = pkg.root.replace(/\\/g, "/").replace(/\/+$/, "").split("/").filter(Boolean);
+        const nodeModules = parts.lastIndexOf("node_modules");
+        if (nodeModules > 0 && parts[nodeModules - 1] !== "lib")
+            return false;
+    }
+    return packageUseUpdatePending(prefix);
+}
 /** True while the desktop updater owns the per-prefix update request. */
 export function currentPackageUseUpdateRequested() {
     const pkg = findCliPackage(path.dirname(fileURLToPath(import.meta.url)));

package/dist/utils/run-bundled-script.d.ts

@@ -51,6 +51,8 @@ export type RunBundledScriptOptions = {
     hqRoot?: string;
     /** Extra environment for the child, applied last. */
     env?: Record<string, string | undefined>;
+    /** Convert the script path for Git Bash when the script resolves sibling assets from BASH_SOURCE. */
+    msysScriptPath?: boolean;
     /** Capture stdout and stderr as bytes instead of inheriting those streams. */
     captureOutput?: boolean;
     /** Bytes supplied on stdin. With no value, stdin is inherited as before. */

package/dist/utils/run-bundled-script.js

@@ -44,6 +44,14 @@ export function interpreterFor(asset) {
     const ext = path.extname(asset).toLowerCase();
     return ext === ".mjs" || ext === ".js" || ext === ".cjs" ? "node" : "bash";
 }
+/** Git Bash expects drive paths in MSYS form when an interpreter arg is a script path. */
+function scriptPathForBash(script) {
+    if (process.platform !== "win32")
+        return script;
+    const normalized = script.replaceAll("\\", "/");
+    const drivePath = normalized.match(/^([A-Za-z]):\/(.*)$/);
+    return drivePath ? `/${drivePath[1].toLowerCase()}/${drivePath[2]}` : normalized;
+}
 function envValue(env, name) {
     const key = Object.keys(env).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
     return key ? env[key] : undefined;
@@ -176,7 +184,8 @@ export function runBundledScript(opts) {
             : inputDescriptor !== undefined
                 ? [stdinStdio, "inherit", "inherit"]
                 : "inherit";
-        result = spawnSync(executable, [script, ...(opts.args ?? [])], {
+        const scriptArg = interpreter === "bash" && opts.msysScriptPath ? scriptPathForBash(script) : script;
+        result = spawnSync(executable, [scriptArg, ...(opts.args ?? [])], {
             cwd: opts.cwd,
             env,
             stdio,

package/dist/utils/vault-api.js

@@ -95,20 +95,19 @@ function identityLookupTimeoutMs() {
 /**
  * Best-effort peek of a 2xx JSON body for plan-limit status (US-016).
  *
- * For ok JSON responses: read the body ONCE, record planLimits (best-effort),
- * and return a NEW Response built from the buffered body so callers can still
- * call .json()/.text()/.arrayBuffer(). Non-JSON and non-ok responses are
- * returned untouched (streamed binary downloads must never be buffered).
+ * For ok JSON responses: inspect a clone, record planLimits (best-effort),
+ * cancel the unused original tee branch, and return a NEW Response built from
+ * the buffered body so callers can still call .json()/.text()/.arrayBuffer().
+ * Non-JSON and non-ok responses are returned untouched (streamed binary
+ * downloads must never be buffered).
  *
  * On inspection errors, return the original response by default to preserve
  * existing behavior. Secret-load callers opt into rethrowing body read errors
  * so the load path can classify a broken stream for offline-cache fallback.
  *
- * Why not response.clone()? Cloning tees the undici body stream; when a
- * caller never consumes the original Response body (many commands only check
- * response.ok/status), the unused tee branch keeps the connection/handle
- * referenced and the process (or vitest worker / spawned CLI child) never
- * exits on Linux CI. Reading once + re-wrapping fully drains the stream.
+ * Cloning tees the undici body stream. Cancel the original branch after the
+ * clone has been read so callers can use the buffered replacement without an
+ * unread tee branch keeping the connection/handle referenced.
  */
 async function peekPlanLimitStatus(response, options = {}) {
     let bufferedBody;
@@ -123,8 +122,9 @@ async function peekPlanLimitStatus(response, options = {}) {
         if (!ct.includes('application/json') && !ct.includes('+json')) {
             return response;
         }
-        const buf = await response.arrayBuffer();
+        const buf = await response.clone().arrayBuffer();
         bufferedBody = buf;
+        await response.body?.cancel();
         try {
             const text = new TextDecoder().decode(buf);
             try {
@@ -147,8 +147,8 @@ async function peekPlanLimitStatus(response, options = {}) {
     }
     catch (err) {
         // Only secret-load callers need the body-read error for offline fallback.
-        // Other endpoints retain the best-effort peek behavior only while the
-        // original body is still readable.
+        // Other endpoints retain the best-effort peek behavior. Reading the clone
+        // leaves the original body available when inspection fails.
         if (bufferedBody !== undefined) {
             // Retry with safe metadata: statusText can itself make Response
             // construction throw after the original stream has already been drained.