@indigoai-us/hq-cli 5.345.28 → 5.345.29

package/dist/commands/core-resolve-company-command.js

@@ -20,6 +20,7 @@ export function registerCoreResolveCompanyNativeCommand(core) {
                 args: operands,
                 cwd: root,
                 hqRoot: root,
+                env: { HQ_CALLER_CWD: process.cwd() },
             });
             if (code !== 0)
                 process.exit(code);

package/dist/commands/core-resolve-company-native.d.ts

@@ -10,7 +10,7 @@ type HqResult = {
     code: number;
     stdout: string;
 };
-type ResolveCompanyFs = Pick<typeof fs, "readFileSync" | "statSync" | "accessSync">;
+type ResolveCompanyFs = Pick<typeof fs, "readFileSync" | "statSync" | "lstatSync" | "accessSync">;
 export type ResolveCompanyDependencies = {
     cwd: string;
     hqRoot?: string;
@@ -18,7 +18,7 @@ export type ResolveCompanyDependencies = {
     fs?: ResolveCompanyFs;
     stdin?: string;
     stdinIsTty?: boolean;
-    spawnHq?: (args: string[], env: NodeJS.ProcessEnv, timeoutMs: number, cwd?: string) => Promise<HqResult>;
+    spawnHq?: (args: string[], env: NodeJS.ProcessEnv, timeoutMs: number, cwd?: string, command?: string) => Promise<HqResult>;
     pid?: number;
     random?: () => number;
 };

package/dist/commands/core-resolve-company-native.js

@@ -1,8 +1,9 @@
 /** Native port of resolve-company.sh. This module stays on the fast import path. */
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { awkCannotOpenFileDiagnostic } from "../lib/core-utils/awk-diagnostics.js";
+import { buildCmdExeSpawnPlan, isWindowsBatchFile } from "../utils/windows-spawn.js";
 export const RESOLVE_COMPANY_ASSET = "core/scripts/resolve-company.sh";
 export const RESOLVE_COMPANY_HELP = [
     "hq-core: public",
@@ -15,6 +16,13 @@ export const RESOLVE_COMPANY_HELP = [
     "Output: {\"company\":\"<slug>\",\"source\":\"prompt|session|device_default|none\"}",
     "Always exits 0 and never writes state.",
     "",
+    "Folder mode (--path <dir>): ask the repo-to-company registry through",
+    "`$HQ_CLI_BIN resolve-company --path <dir> --json` (HQ_CLI_BIN defaults to",
+    "`hq`). Sources: registry (linked folder), registry_miss (not linked), or",
+    "unavailable (CLI missing, failed, timed out, or returned bad output). A",
+    "registry answer is accepted only when it names a real companies/<slug>",
+    "directory. Folder mode never falls back to prompt, session, or device default.",
+    "",
     "set -uo pipefail",
     "",
     "ROOT=\"\"",
@@ -222,21 +230,49 @@ function validPreflight(text, slug, session, operation) {
         value.companySlug === slug &&
         typeof value.companyUid === "string" && value.companyUid.length > 0);
 }
-function commandOnPath(name, env) {
-    const pathValue = env.PATH ?? "";
-    for (const directory of pathValue.split(path.delimiter)) {
-        const candidate = path.join(directory || ".", name);
+function commandPath(name, env) {
+    const hasPathSeparator = name.includes("/") || name.includes("\\");
+    const pathKey = Object.keys(env).find((key) => key.toUpperCase() === "PATH");
+    const candidates = hasPathSeparator
+        ? [name]
+        : (pathKey ? env[pathKey] ?? "" : "").split(path.delimiter).flatMap((directory) => {
+            const base = path.join(directory || ".", name);
+            return process.platform === "win32" && !path.extname(name)
+                ? [`${base}.com`, `${base}.exe`, `${base}.bat`, `${base}.cmd`]
+                : [base];
+        });
+    for (const candidate of candidates) {
         try {
             fs.accessSync(candidate, fs.constants.X_OK);
-            return true;
+            return candidate;
         }
         catch {
             // `command -v` simply advances to the next PATH entry.
         }
     }
+    return undefined;
+}
+function commandOnPath(name, env) {
+    if (commandPath(name, env))
+        return true;
+    if (process.platform !== "win32" || name.includes("/") || name.includes("\\") || path.extname(name))
+        return false;
+    const pathKey = Object.keys(env).find((key) => key.toUpperCase() === "PATH");
+    for (const directory of (pathKey ? env[pathKey] ?? "" : "").split(path.delimiter)) {
+        try {
+            // Git Bash considers an executable extensionless script a command. Keep
+            // the presence check faithful to that shell contract; actual Windows
+            // process launch still selects a PATHEXT executable or batch shim.
+            fs.accessSync(path.join(directory || ".", name), fs.constants.X_OK);
+            return true;
+        }
+        catch {
+            // `command -v` advances through each PATH entry.
+        }
+    }
     return false;
 }
-function runHq(args, env, timeoutMs, cwd) {
+function runHq(args, env, timeoutMs, cwd, command = "hq") {
     return new Promise((resolve) => {
         let settled = false;
         let stdout = "";
@@ -247,7 +283,15 @@ function runHq(args, env, timeoutMs, cwd) {
             if (!child?.pid)
                 return;
             try {
-                process.kill(-child.pid, signal);
+                if (process.platform === "win32") {
+                    const taskkill = path.join(env.SystemRoot ?? env.WINDIR ?? "C:\\Windows", "System32", "taskkill.exe");
+                    const result = spawnSync(taskkill, ["/PID", String(child.pid), "/T", "/F"], { windowsHide: true });
+                    if (result.error || result.status !== 0)
+                        child.kill(signal);
+                }
+                else {
+                    process.kill(-child.pid, signal);
+                }
             }
             catch (error) {
                 if (errorCode(error) !== "ESRCH")
@@ -279,7 +323,24 @@ function runHq(args, env, timeoutMs, cwd) {
             }
         }, timeoutMs);
         try {
-            child = spawn("hq", args, { cwd, detached: true, stdio: ["ignore", "pipe", "ignore"], env });
+            const resolved = commandPath(command, env);
+            if (!resolved) {
+                finish({ code: 127, stdout });
+                return;
+            }
+            let executable = resolved;
+            let executableArgs = args;
+            let windowsVerbatimArguments;
+            if (process.platform === "win32" && isWindowsBatchFile(resolved)) {
+                const plan = buildCmdExeSpawnPlan(resolved, args, env);
+                executable = plan.cmd;
+                executableArgs = plan.args;
+                windowsVerbatimArguments = plan.windowsVerbatimArguments;
+            }
+            child = spawn(executable, executableArgs, {
+                cwd, detached: process.platform !== "win32", stdio: ["ignore", "pipe", "ignore"], env,
+                windowsVerbatimArguments,
+            });
         }
         catch {
             finish({ code: 127, stdout });
@@ -301,6 +362,8 @@ function parseArgs(args) {
     let root = "";
     let prompt = "";
     let havePrompt = false;
+    let folder = "";
+    let haveFolder = false;
     for (let index = 0; index < args.length;) {
         const arg = args[index];
         if (arg === "--root") {
@@ -312,14 +375,84 @@ function parseArgs(args) {
             havePrompt = true;
             index += Math.min(2, args.length - index);
         }
+        else if (arg === "--path") {
+            folder = args[index + 1] ?? "";
+            haveFolder = true;
+            index += Math.min(2, args.length - index);
+        }
         else if (arg === "--help" || arg === "-h") {
-            return { root, prompt, havePrompt, help: true };
+            return { root, prompt, havePrompt, folder, haveFolder, help: true };
         }
         else {
             index += 1;
         }
     }
-    return { root, prompt, havePrompt, help: false };
+    return { root, prompt, havePrompt, folder, haveFolder, help: false };
+}
+function unavailable(reason) {
+    return {
+        ...output("", "unavailable"),
+        stderr: Buffer.from(`resolve-company: WARNING company registry unavailable (${reason}); binding personal, not guessing a company\n`),
+    };
+}
+async function resolveFolder(folder, root, cwd, env, fileSystem, invoke) {
+    if (!folder)
+        return unavailable("empty --path");
+    const cli = env.HQ_CLI_BIN || "hq";
+    if (!commandPath(cli, env))
+        return unavailable(`'${cli}' not found`);
+    if (!commandPath("jq", env))
+        return unavailable("jq not found");
+    // The registry command is the contract boundary. Calling it preserves its
+    // own hq-anywhere gate and avoids importing the full command graph here.
+    const hqEnv = {
+        ...EMPTY_ENV,
+        ...env,
+        HQ_NO_UPDATE_CHECK: "1",
+        HQ_RESOLVE_TIMEOUT_MS: env.HQ_RESOLVE_TIMEOUT_MS || "5000",
+    };
+    const parsedTimeout = Number(hqEnv.HQ_RESOLVE_TIMEOUT_MS);
+    const timeoutMs = parsedTimeout || 2_000;
+    const response = await invoke(["resolve-company", "--path", folder, "--json"], hqEnv, timeoutMs, cwd, cli);
+    const value = record(parseJson(response.stdout));
+    if (response.code !== 0 && !(response.code === 1 && value?.company === null)) {
+        return unavailable(`'${cli} resolve-company' exited ${response.code}`);
+    }
+    if (!value)
+        return unavailable(`'${cli} resolve-company' returned unreadable output`);
+    if (value.company === null || value.company === undefined)
+        return output("", "registry_miss");
+    if (typeof value.company !== "string")
+        return unavailable(`'${cli} resolve-company' returned unreadable output`);
+    // jq -r plus command substitution removes trailing newlines before the
+    // shell validates the returned slug.
+    const slug = value.company.replace(/\n+$/, "");
+    if (!slug || slug === "personal" || slug.startsWith("_") || !/^[A-Za-z0-9_-]+$/.test(slug)) {
+        return unavailable(`registry returned invalid company '${slug}'`);
+    }
+    const companyPath = path.join(root, "companies", slug);
+    let isDirectory = false;
+    let isSymlink = false;
+    try {
+        isDirectory = fileSystem.statSync(companyPath).isDirectory();
+    }
+    catch (error) {
+        const code = errorCode(error);
+        if (code !== "ENOENT" && code !== "ENOTDIR" && code !== "EACCES" && code !== "ELOOP")
+            throw error;
+    }
+    try {
+        isSymlink = fileSystem.lstatSync(companyPath).isSymbolicLink();
+    }
+    catch (error) {
+        const code = errorCode(error);
+        if (code !== "ENOENT" && code !== "ENOTDIR" && code !== "EACCES" && code !== "ELOOP")
+            throw error;
+    }
+    if (!isDirectory || isSymlink) {
+        return unavailable(`registry company '${slug}' has no companies/${slug} directory in ${root}`);
+    }
+    return output(slug, "registry");
 }
 async function readStdin() {
     const chunks = [];
@@ -333,11 +466,14 @@ export async function resolveCompany(args, dependencies) {
     const parsed = parseArgs(args);
     if (parsed.help)
         return { code: 0, stdout: Buffer.from(RESOLVE_COMPANY_HELP), stderr: Buffer.alloc(0) };
+    const root = parsed.root || dependencies.hqRoot || env.HQ_ROOT || env.CLAUDE_PROJECT_DIR || dependencies.cwd;
+    if (parsed.haveFolder) {
+        return await resolveFolder(parsed.folder, root, dependencies.cwd, env, fileSystem, dependencies.spawnHq ?? runHq);
+    }
     let prompt = parsed.prompt;
     if (!parsed.havePrompt && dependencies.stdinIsTty !== true) {
         prompt = dependencies.stdin ?? await readStdin();
     }
-    const root = parsed.root || dependencies.hqRoot || env.HQ_ROOT || env.CLAUDE_PROJECT_DIR || dependencies.cwd;
     const manifest = path.join(root, "companies/manifest.yaml");
     if (!isFile(manifest, fileSystem))
         return output("", "none");
@@ -393,6 +529,7 @@ export async function resolveCompany(args, dependencies) {
 export async function runResolveCompanyFast(args, stdin, cwd, hqRoot, _commandName, _hqRootArg, stdinReader = readStdin) {
     const parsed = parseArgs(args);
     const actualStdin = parsed.havePrompt || process.stdin.isTTY === true
+        || parsed.haveFolder
         ? stdin
         : stdin || await stdinReader();
     const result = await resolveCompany(args, {

package/dist/fast-scaffold.js

@@ -184,6 +184,16 @@ export const FAST_SCAFFOLD_SCRIPTS = [
         shellHqRoot: "live",
         readsStdin: true,
     },
+    {
+        name: "checkpoint",
+        kind: "native",
+        modulePath: "./commands/core-checkpoint-fast.js",
+        exportName: "runCheckpointFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-session",
+        fallbackToCommandGraph: true,
+        root: "live",
+    },
     {
         name: "hq-session",
         kind: "native",

package/package.json

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