@indigoai-us/hq-cli 5.311.4 → 5.312.1

package/dist/commands/core-eval-trigger-native.d.ts

@@ -0,0 +1,4 @@
+export { checkTriggerExpressions, evaluateTrigger } from "../utils/core-eval-trigger.js";
+export declare const EVAL_TRIGGER_ASSET = "core/scripts/eval-trigger.sh";
+export declare function runEvalTriggerFast(args: readonly string[], stdin: string, _cwd: string, _root: string | undefined): Promise<number>;
+//# sourceMappingURL=core-eval-trigger-native.d.ts.map

package/dist/commands/core-eval-trigger-native.js

@@ -0,0 +1,12 @@
+/** Native implementation of core/scripts/eval-trigger.sh. */
+import { checkTriggerExpressions, evaluateTrigger } from "../utils/core-eval-trigger.js";
+export { checkTriggerExpressions, evaluateTrigger } from "../utils/core-eval-trigger.js";
+export const EVAL_TRIGGER_ASSET = "core/scripts/eval-trigger.sh";
+export async function runEvalTriggerFast(args, stdin, _cwd, _root) {
+    if (args[0] === "--check") {
+        process.stdout.write(checkTriggerExpressions(stdin));
+        return 0;
+    }
+    return evaluateTrigger(args[0] ?? "", args[1] ?? "");
+}
+//# sourceMappingURL=core-eval-trigger-native.js.map

package/dist/commands/core-migrate-policy-triggers-native.d.ts

@@ -0,0 +1,21 @@
+import * as fs from "node:fs";
+export declare const MIGRATE_POLICY_TRIGGERS_ASSET = "core/scripts/migrate-policy-triggers.sh";
+export type MigratePolicyDependencies = {
+    root: string;
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    now: () => Date;
+    fs: typeof fs;
+    evaluatorExists?: () => boolean;
+    runFlock?: (lockFd: number, cwd: string, pathValue: string) => {
+        status: number | null;
+        error?: Error;
+    };
+};
+export declare function runMigratePolicyTriggers(args: readonly string[], deps: MigratePolicyDependencies): {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+export declare function runMigratePolicyTriggersFast(args: readonly string[], _stdin: string, cwd: string, root?: string): Promise<number>;
+//# sourceMappingURL=core-migrate-policy-triggers-native.d.ts.map

package/dist/commands/core-migrate-policy-triggers-native.js

@@ -0,0 +1,378 @@
+/** Native implementation of core/scripts/migrate-policy-triggers.sh. */
+import * as crypto from "node:crypto";
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluateTrigger } from "../utils/core-eval-trigger.js";
+export const MIGRATE_POLICY_TRIGGERS_ASSET = "core/scripts/migrate-policy-triggers.sh";
+const ON_LIVE = "[PreToolUse, PostToolUse, UserPromptSubmit, AssistantIntent]";
+const ON_START = "[SessionStart]";
+const TAG_STOP = new Set(("infrastructure consolidated ux safety hq hq-core hq-cli hq-packages " +
+    "hq-discipline basic-users knowledge-repos quiet-mode capabilities narration voice intent delight " +
+    "orchestration abstraction workflow deliverable routing anchor rulesets data-handling shell-injection " +
+    "promotion docs knowledge").split(/\s+/));
+function extractCompany(cwd) {
+    const match = cwd.match(/.*companies\/([^/]+).*/);
+    return match?.[1] ?? "";
+}
+function defaultDirs(deps) {
+    const dirs = [path.join(deps.root, "core/policies"), path.join(deps.root, "personal/policies")];
+    for (const entry of safeDirNames(deps.fs, path.join(deps.root, "personal/workers"))) {
+        const candidate = path.join(deps.root, "personal/workers", entry, "policies");
+        if (isDirectory(deps.fs, candidate))
+            dirs.push(candidate);
+    }
+    const logicalCwd = deps.env.CLAUDE_PROJECT_DIR || deps.cwd;
+    const company = deps.env.HQ_POLICY_COMPANY || extractCompany(logicalCwd);
+    if (company && company !== "." && company !== ".." && !company.includes("/")) {
+        const companyRoot = path.join(deps.root, "companies", company);
+        dirs.push(path.join(companyRoot, "policies"));
+        for (const entry of safeDirNames(deps.fs, path.join(companyRoot, "workers"))) {
+            const candidate = path.join(companyRoot, "workers", entry, "policies");
+            if (isDirectory(deps.fs, candidate))
+                dirs.push(candidate);
+        }
+    }
+    const repoMatch = logicalCwd.match(/.*repos\/(public|private)\/([^/]+).*/);
+    if (repoMatch)
+        dirs.push(path.join(deps.root, "repos", repoMatch[1], repoMatch[2], ".claude/policies"));
+    return dirs;
+}
+function safeDirNames(fileSystem, directory) {
+    try {
+        return fileSystem.readdirSync(directory).sort();
+    }
+    catch {
+        return [];
+    }
+}
+function isDirectory(fileSystem, value) {
+    try {
+        return fileSystem.statSync(value).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function executableInPath(name, env, fileSystem) {
+    for (const directory of (env.PATH ?? "").split(path.delimiter)) {
+        if (!directory)
+            continue;
+        try {
+            const stat = fileSystem.statSync(path.join(directory, name));
+            if (stat.isFile() && (stat.mode & 0o111) !== 0)
+                return true;
+        }
+        catch { /* continue through PATH */ }
+    }
+    return false;
+}
+function runNonblockingFlock(lockFd, cwd, pathValue) {
+    const stdio = [
+        "ignore", "ignore", "ignore", "ignore", "ignore", "ignore", "ignore", "ignore", "ignore", lockFd,
+    ];
+    const result = spawnSync("flock", ["-n", "9"], { cwd, env: { PATH: pathValue }, stdio });
+    return { status: result.status, error: result.error };
+}
+function frontmatterValue(content, key) {
+    let depth = 0;
+    for (const line of content.split("\n")) {
+        if (line === "---") {
+            depth += 1;
+            continue;
+        }
+        if (depth === 1 && line.startsWith(`${key}:`))
+            return line.replace(new RegExp(`^${key}:[\\t\\n\\v\\f\\r ]*`), "");
+    }
+    return "";
+}
+function triggerExpression(trigger) {
+    const t = trigger.toLowerCase();
+    if (t.includes("deploy"))
+        return "deploy";
+    if (["credential", "secret", "op://", "aws_profile", ".env"].some((needle) => t.includes(needle)))
+        return "secret || credential";
+    if (["git push", "gh pr merge", " push ", "push to"].some((needle) => t.includes(needle)))
+        return "git && push";
+    if (t.includes("commitment"))
+        return "";
+    if (t.includes("commit"))
+        return "git && commit";
+    if (t.includes("checkout"))
+        return "git && checkout";
+    if (t.includes("rebase"))
+        return "git && rebase";
+    if (t.includes("git stash") || t.includes(" stash "))
+        return "git && stash";
+    if (t.includes("gh pr") || t.includes("pull request") || t.includes("pr merge"))
+        return "pr";
+    if (t.includes("merge"))
+        return "git && merge";
+    if (["migration", "migrate", "schema", "prisma"].some((needle) => t.includes(needle)))
+        return "migrate || migration || schema";
+    if (["npm install", "pnpm ", "yarn ", " install ", "package install"].some((needle) => t.includes(needle)))
+        return "install";
+    if (t.includes("grep"))
+        return "grep";
+    if (t.includes("slack"))
+        return "slack";
+    if (t.includes("email"))
+        return "email";
+    if (t.includes(" git ") || t.startsWith("git ") || t.endsWith(" git"))
+        return "git";
+    return "";
+}
+function deriveWhen(trigger, rawTags, enforcementRaw) {
+    let enforcement = enforcementRaw.split("#", 1)[0].toLowerCase().replace(/[\s\t\n\r\v\f]/g, "");
+    enforcement = enforcement.replace(/^"/, "").replace(/"$/, "").replace(/^'/, "").replace(/'$/, "");
+    const triggerExpr = triggerExpression(trigger);
+    const terms = [];
+    const seen = new Set();
+    if (triggerExpr) {
+        const exprTokens = triggerExpr.match(/[a-z_][a-z0-9_./-]*/g) ?? [];
+        for (const token of exprTokens)
+            seen.add(token);
+        terms.push(triggerExpr.includes(" ") ? `( ${triggerExpr} )` : triggerExpr);
+    }
+    const withoutBrackets = rawTags.replace(/^\[/, "").replace(/\]$/, "");
+    const rawTagParts = withoutBrackets.split(",");
+    for (let index = 0; index < rawTagParts.length; index += 1) {
+        // tag_tokens pipes through `while read`; Bash drops the final tag when
+        // the source has no trailing comma/newline because that read returns EOF.
+        if (index === rawTagParts.length - 1 && !withoutBrackets.endsWith(","))
+            break;
+        const raw = rawTagParts[index];
+        const tag = raw.toLowerCase().replace(/^\s+|\s+$/g, "").replace(/^vendor:/, "");
+        if (!tag || TAG_STOP.has(tag) || seen.has(tag))
+            continue;
+        seen.add(tag);
+        terms.push(tag);
+    }
+    if (!terms.length)
+        return enforcement === "hard" ? { when: "always", on: ON_START } : null;
+    return { when: terms.join(" || "), on: ON_LIVE };
+}
+function writeAtomic(fileSystem, target, bytes) {
+    const temporary = path.join(path.dirname(target), `.migrate-policy-triggers.${process.pid}.${Math.random().toString(16).slice(2)}`);
+    try {
+        fileSystem.writeFileSync(temporary, bytes, { encoding: "utf8", mode: 0o600, flag: "wx" });
+        fileSystem.chmodSync(temporary, 0o600);
+        fileSystem.renameSync(temporary, target);
+        return true;
+    }
+    catch {
+        try {
+            fileSystem.unlinkSync(temporary);
+        }
+        catch { /* temporary did not survive */ }
+        return false;
+    }
+}
+function unreadablePolicyDiagnostic(filename, error) {
+    const code = error.code;
+    const message = code === "EACCES" || code === "EPERM" ? "Permission denied" : "No such file or directory";
+    const script = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../assets/scaffold/core/scripts/migrate-policy-triggers.sh");
+    const awk = `awk: fatal: cannot open file \`${filename}' for reading: ${message}\n`;
+    return `${script}: line 309: ${filename}: ${message}\n${awk.repeat(3)}`;
+}
+function shellGlobMd(fileSystem, directory) {
+    try {
+        return fileSystem.readdirSync(directory).filter((name) => !name.startsWith(".") && name.endsWith(".md"))
+            .sort().map((name) => path.join(directory, name)).filter((name) => {
+            try {
+                return fileSystem.statSync(name).isFile();
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+}
+export function runMigratePolicyTriggers(args, deps) {
+    let dryRun = false;
+    const explicitDirs = [];
+    for (const arg of args) {
+        if (arg === "--dry-run")
+            dryRun = true;
+        else
+            explicitDirs.push(arg);
+    }
+    const dirs = explicitDirs.length ? explicitDirs : defaultDirs(deps);
+    const fileSystem = deps.fs;
+    let stateDir = deps.env.HQ_MIGRATE_POLICY_TRIGGERS_STATE_DIR ?? "";
+    if (!stateDir) {
+        if (deps.env.XDG_STATE_HOME)
+            stateDir = path.join(deps.env.XDG_STATE_HOME, "hq-migrate-policy-triggers");
+        else if (deps.env.HOME)
+            stateDir = path.join(deps.env.HOME, ".local/state/hq-migrate-policy-triggers");
+    }
+    const cooldownText = deps.env.HQ_MIGRATE_POLICY_TRIGGERS_COOLDOWN_SECONDS || "3600";
+    const cooldown = /^-?\d+$/.test(cooldownText) ? Number(cooldownText) : 0;
+    const scope = Buffer.concat([Buffer.from(`${deps.root}\0`), ...dirs.map((dir) => Buffer.from(`${dir}\0`))]);
+    const scopeHash = crypto.createHash("sha256").update(scope).digest("hex");
+    const stamp = stateDir ? path.join(stateDir, scopeHash, "last-success") : "";
+    const lock = stateDir ? path.join(stateDir, scopeHash, "migrate.lock") : "";
+    let stateReady = false;
+    if (stateDir) {
+        try {
+            fileSystem.mkdirSync(path.dirname(stamp), { recursive: true });
+            stateReady = true;
+        }
+        catch {
+            stateReady = false;
+        }
+    }
+    let stderr = "";
+    let stdout = "";
+    const nowSeconds = () => Math.floor(deps.now().getTime() / 1000);
+    const bypass = dryRun || !stateReady || deps.env.HQ_MIGRATE_POLICY_TRIGGERS_FORCE === "1" || cooldown <= 0;
+    const cooldownBlocks = () => {
+        if (bypass)
+            return false;
+        try {
+            const last = fileSystem.readFileSync(stamp, "utf8");
+            if (!/^\d+$/.test(last)) {
+                stderr += `migrate-policy-triggers: cooldown stamp is unreadable; running\n`;
+                return false;
+            }
+            const age = nowSeconds() - Number(last);
+            if (age < 0) {
+                stderr += `migrate-policy-triggers: cooldown stamp is in the future; running\n`;
+                return false;
+            }
+            return age < cooldown;
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                return false;
+            stderr += `migrate-policy-triggers: cooldown stamp is unreadable; running\n`;
+            return false;
+        }
+    };
+    if (cooldownBlocks())
+        return { code: 0, stdout, stderr };
+    let lockFd;
+    if (stateReady && !dryRun && executableInPath("flock", deps.env, fileSystem)) {
+        try {
+            lockFd = fileSystem.openSync(lock, "w");
+        }
+        catch {
+            return { code: 0, stdout, stderr };
+        }
+        const lockResult = (deps.runFlock ?? runNonblockingFlock)(lockFd, deps.cwd, deps.env.PATH ?? "");
+        if (lockResult.error || lockResult.status !== 0) {
+            fileSystem.closeSync(lockFd);
+            return { code: 0, stdout, stderr };
+        }
+        if (cooldownBlocks()) {
+            fileSystem.closeSync(lockFd);
+            return { code: 0, stdout, stderr };
+        }
+    }
+    const evaluator = deps.evaluatorExists ?? (() => {
+        const evaluatorPath = path.join(deps.root, "core/scripts/eval-trigger.sh");
+        try {
+            return fileSystem.statSync(evaluatorPath).isFile();
+        }
+        catch {
+            return false;
+        }
+    });
+    let migrated = 0, untriggered = 0, unparseable = 0, skipped = 0, session = 0;
+    let errorCode = 0;
+    try {
+        for (const dir of dirs) {
+            if (!isDirectory(fileSystem, dir))
+                continue;
+            for (const filename of shellGlobMd(fileSystem, dir)) {
+                const name = path.basename(filename);
+                if (name === "example-policy.md" || name === "README.md")
+                    continue;
+                let original;
+                try {
+                    original = fileSystem.readFileSync(filename, "utf8");
+                }
+                catch (error) {
+                    stderr += unreadablePolicyDiagnostic(filename, error);
+                    untriggered += 1;
+                    continue;
+                }
+                if (original.split("\n").some((line) => line.startsWith("when:"))) {
+                    skipped += 1;
+                    continue;
+                }
+                const derived = deriveWhen(frontmatterValue(original, "trigger"), frontmatterValue(original, "tags"), frontmatterValue(original, "enforcement"));
+                if (!derived) {
+                    untriggered += 1;
+                    continue;
+                }
+                const evaluatorAvailable = evaluator();
+                const parsedStatus = evaluateTrigger(derived.when, "");
+                if (evaluatorAvailable && parsedStatus === 2) {
+                    unparseable += 1;
+                    stderr += `migrate-policy-triggers: refusing to write unparseable when: ${name} -> \`${derived.when}\`\n`;
+                    continue;
+                }
+                if (derived.on === ON_START)
+                    session += 1;
+                if (dryRun) {
+                    const line = `${name.padEnd(52)} when: ${derived.when.padEnd(44)} on: ${derived.on}\n`;
+                    stdout += line;
+                    migrated += 1;
+                    continue;
+                }
+                const anchor = original.split("\n").some((line) => line.startsWith("trigger:")) ? /^trigger:/ : /^id:/;
+                const lines = original.split("\n");
+                let inserted = false;
+                const rewritten = lines.flatMap((line) => {
+                    if (!inserted && anchor.test(line)) {
+                        inserted = true;
+                        return [line, `when: ${derived.when}`, `on: ${derived.on}`];
+                    }
+                    return [line];
+                }).join("\n");
+                // awk print adds a newline even when the source's last line had none.
+                if (!writeAtomic(fileSystem, filename, `${rewritten.endsWith("\n") ? rewritten.slice(0, -1) : rewritten}\n`)) {
+                    errorCode = 1;
+                    break;
+                }
+                migrated += 1;
+            }
+            if (errorCode)
+                break;
+        }
+        if (migrated > 0)
+            stderr += `migrate-policy-triggers: backfilled ${migrated} policy trigger(s) (${session} hard -> SessionStart, ${untriggered} non-hard triggerless left unchanged, ${unparseable} unparseable derivations skipped, ${skipped} already had when)\n`;
+        if (!dryRun && stateReady && !errorCode) {
+            const stampTmp = path.join(path.dirname(stamp), `.last-success.${process.pid}.${Math.random().toString(16).slice(2)}`);
+            try {
+                fileSystem.writeFileSync(stampTmp, `${nowSeconds()}\n`, { mode: 0o600, flag: "wx" });
+                fileSystem.renameSync(stampTmp, stamp);
+            }
+            catch {
+                try {
+                    fileSystem.unlinkSync(stampTmp);
+                }
+                catch { /* ignore stamp failure */ }
+            }
+        }
+    }
+    finally {
+        if (lockFd !== undefined)
+            fileSystem.closeSync(lockFd);
+    }
+    return { code: errorCode, stdout, stderr };
+}
+export async function runMigratePolicyTriggersFast(args, _stdin, cwd, root) {
+    const result = runMigratePolicyTriggers(args, { root: root ?? process.env.HQ_ROOT ?? cwd, cwd, env: process.env, now: () => new Date(), fs });
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    return result.code;
+}
+//# sourceMappingURL=core-migrate-policy-triggers-native.js.map

package/dist/commands/core-native-hook-helper-commands.d.ts

@@ -0,0 +1,4 @@
+/** Complete command-graph registrations for Wave 8 hook helper ports. */
+import type { Command } from "commander";
+export declare function registerCoreHookHelperNativeCommands(core: Command): void;
+//# sourceMappingURL=core-native-hook-helper-commands.d.ts.map

package/dist/commands/core-native-hook-helper-commands.js

@@ -0,0 +1,56 @@
+import { resolveLiveRoot } from "../utils/hq-roots.js";
+import { runBundledScript } from "../utils/run-bundled-script.js";
+import { describeCoreCommand } from "./core-command-catalog.js";
+import { coreNativeHookHelpersEnabled } from "./core-native-hook-helpers-flag.js";
+import { EVAL_TRIGGER_ASSET, runEvalTriggerFast } from "./core-eval-trigger-native.js";
+import { MIGRATE_POLICY_TRIGGERS_ASSET, runMigratePolicyTriggersFast } from "./core-migrate-policy-triggers-native.js";
+import { REGISTER_PROJECT_ASSET, runRegisterProjectFast } from "./core-register-project-native.js";
+import { WORK_MESH_LIVE_REBIND_ASSET, runWorkMeshLiveRebindFast } from "./core-work-mesh-live-rebind-native.js";
+const entries = [
+    { name: "eval-trigger", asset: EVAL_TRIGGER_ASSET, summary: "Evaluate policy trigger expressions", root: "cwd", shellCwd: "caller", shellRoot: "none", readsStdinFor: (args) => args[0] === "--check", run: runEvalTriggerFast },
+    { name: "migrate-policy-triggers", asset: MIGRATE_POLICY_TRIGGERS_ASSET, summary: "Backfill policy trigger frontmatter", root: "live", shellCwd: "caller", shellRoot: "live", readsStdin: false, run: runMigratePolicyTriggersFast },
+    { name: "register-project", asset: REGISTER_PROJECT_ASSET, summary: "Register a project with Work Mesh", root: "live", shellCwd: "caller", shellRoot: "live", readsStdin: false, run: runRegisterProjectFast },
+    { name: "work-mesh-live-rebind", asset: WORK_MESH_LIVE_REBIND_ASSET, summary: "Rebind a live Work Mesh session to its current project", root: "live", shellCwd: "caller", shellRoot: "live", readsStdin: false, run: runWorkMeshLiveRebindFast },
+];
+export function registerCoreHookHelperNativeCommands(core) {
+    for (const entry of entries) {
+        const command = core.command(entry.name)
+            .description(entry.summary)
+            .allowUnknownOption()
+            .allowExcessArguments()
+            .helpOption(false)
+            .argument("[args...]")
+            .action(async (args = [], _options, cmd) => {
+            const operands = cmd.args.length > 0 ? cmd.args : args;
+            const groupRoot = core.opts().hqRoot;
+            const root = entry.root === "live" ? resolveLiveRoot({ hqRoot: groupRoot }) : undefined;
+            if (!await coreNativeHookHelpersEnabled()) {
+                const result = runBundledScript({
+                    asset: entry.asset,
+                    args: operands,
+                    cwd: entry.shellCwd === "live" ? root ?? process.cwd() : process.cwd(),
+                    ...(entry.shellRoot === "live" ? { hqRoot: root } : {}),
+                    ...(entry.name === "migrate-policy-triggers"
+                        ? { env: { CLAUDE_PROJECT_DIR: process.env.CLAUDE_PROJECT_DIR || process.cwd() } }
+                        : {}),
+                });
+                if (result.code !== 0)
+                    process.exitCode = result.code;
+                return;
+            }
+            const readsStdin = entry.readsStdinFor?.(operands) ?? entry.readsStdin;
+            const stdin = readsStdin ? await readStdin() : "";
+            const code = await entry.run(operands, stdin, process.cwd(), root);
+            if (code !== 0)
+                process.exitCode = code;
+        });
+        describeCoreCommand(command, { execution: "native", asset: entry.asset, root: entry.root });
+    }
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(chunk);
+    return Buffer.concat(chunks).toString("utf8");
+}
+//# sourceMappingURL=core-native-hook-helper-commands.js.map

package/dist/commands/core-native-hook-helpers-flag.d.ts

@@ -0,0 +1,4 @@
+/** Default-off rollout gate for Wave 8 hook-time helper commands. */
+export declare const CORE_NATIVE_HOOK_HELPERS_FLAG = "core-native-hook-helpers";
+export declare function coreNativeHookHelpersEnabled(): Promise<boolean>;
+//# sourceMappingURL=core-native-hook-helpers-flag.d.ts.map

package/dist/commands/core-native-hook-helpers-flag.js

@@ -0,0 +1,7 @@
+/** Default-off rollout gate for Wave 8 hook-time helper commands. */
+export const CORE_NATIVE_HOOK_HELPERS_FLAG = "core-native-hook-helpers";
+export async function coreNativeHookHelpersEnabled() {
+    const { resolveProcessFlagGate } = await import("../lib/flag-registry.js");
+    return resolveProcessFlagGate(CORE_NATIVE_HOOK_HELPERS_FLAG, { fallback: false }, () => false);
+}
+//# sourceMappingURL=core-native-hook-helpers-flag.js.map

package/dist/commands/core-register-project-native.d.ts

@@ -0,0 +1,30 @@
+/** Native implementation of core/scripts/register-project.sh. */
+import * as fs from "node:fs";
+import { spawnSync } from "node:child_process";
+export declare const REGISTER_PROJECT_ASSET = "core/scripts/register-project.sh";
+export type RegisterProjectDeps = {
+    root: string;
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    fs: typeof fs;
+    now: () => Date;
+    runHq: (args: string[], options: {
+        cwd: string;
+        env: NodeJS.ProcessEnv;
+        capture: boolean;
+    }) => {
+        code: number;
+        stdout: string;
+        stderr: string;
+    };
+};
+export declare function createRegisterProjectHqRunner(spawn?: typeof spawnSync): RegisterProjectDeps["runHq"];
+type NativeResult = {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+export declare function runRegisterProject(args: readonly string[], deps: RegisterProjectDeps): NativeResult;
+export declare function runRegisterProjectFast(args: readonly string[], _stdin: string, cwd: string, root?: string): Promise<number>;
+export {};
+//# sourceMappingURL=core-register-project-native.d.ts.map