@indigoai-us/hq-cli 5.314.0 → 5.316.0

package/dist/fast-core.js

@@ -1,47 +1,114 @@
 /**
- * Fast-path dispatcher for relocated scaffold scripts.
+ * Fast-path dispatcher for selected core commands.
  *
  * Reached from the entrypoint BEFORE `main.ts` (and its heavy command graph) is
- * ever imported, so a hot `hq core hq-session` / `hq core checkpoint-stop-gate`
- * dispatches in roughly node's own startup time. It imports only the light root
- * resolver and the bundled-script runner. The slower commander registration in
- * `core.ts` remains the complete path for any invocation this does not match.
+ * ever imported, so hot hook commands avoid the full commander graph. Shell
+ * entries use the bundled-script runner; native entries import their one handler
+ * module. The registration in `core.ts` remains the complete fallback path.
  */
 import { resolveLiveRoot } from "./utils/hq-roots.js";
 import { runBundledScript } from "./utils/run-bundled-script.js";
-import { parseFastCore } from "./commands/scaffold-fast.js";
+import { parseFastCore } from "./fast-scaffold.js";
+export async function readStdinIfPiped(stream) {
+    if (stream.isTTY)
+        return "";
+    const chunks = [];
+    for await (const chunk of stream)
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    return Buffer.concat(chunks).toString("utf8");
+}
 /**
- * Run the fast-path scaffold script named in `argv` and exit with its code.
+ * Run the fast-path core command named in `argv` and exit with its code.
  * Only call when {@link isFastCoreRequest} is true; a non-match returns without
  * doing anything.
  */
-export function runFastCore(argv) {
+export async function runFastCore(argv) {
     const parsed = parseFastCore(argv);
     if (!parsed)
         return;
-    // `root: "live"` — resolve the live HQ root and run the script in it, exactly
-    // as core.ts's runEntry does. Fail soft: if no root can be resolved, run the
-    // script anyway with the inherited environment (the hook already carries
-    // CLAUDE_PROJECT_DIR, and each script has its own root fallback) rather than
-    // crashing a Stop hook on a resolution error.
+    const entry = parsed.entry;
+    // The full graph's process gate accepts textual true/false overrides. It ignores
+    // numeric env values, so preserve that behavior for family flags here too.
+    let familyEnabled = true;
+    if (entry.kind === "native" && entry.familyFlagKey) {
+        const envOverride = localBooleanFlagOverride(entry.familyFlagKey, process.env);
+        familyEnabled = envOverride ?? await (await import("./native-fast-route.js")).fastFlagEnabled(entry.familyFlagKey, process.env, { numericEnvironmentOverride: false });
+    }
+    const useShell = entry.kind === "native" && Boolean(entry.familyFlagKey) && !familyEnabled;
+    const shouldInjectRoot = useShell
+        ? entry.shellHqRoot === "live" || (entry.shellHqRoot === "reconcile-default" &&
+            !parsed.args.includes("--hq-root") && !parsed.args.includes("--help") && !parsed.args.includes("-h"))
+        : entry.kind === "shell"
+            ? true
+            : entry.root === "live";
+    // `root: "live"` — resolve the live HQ root using the same resolver as the
+    // full command graph. Existing shell fast entries keep their historical
+    // fail-soft behavior; newly routed commands fall back to the full graph so
+    // its expected-user-error formatting remains authoritative.
     let hqRoot;
-    try {
-        hqRoot = resolveLiveRoot(parsed.hqRootArg ? { hqRoot: parsed.hqRootArg } : {});
+    if (shouldInjectRoot) {
+        try {
+            hqRoot = resolveLiveRoot(parsed.hqRootArg ? { hqRoot: parsed.hqRootArg } : {});
+        }
+        catch {
+            if (entry.kind === "native") {
+                const { runCli } = await import("./main.js");
+                await runCli();
+                return;
+            }
+            hqRoot = undefined;
+        }
     }
-    catch {
-        hqRoot = undefined;
+    if (entry.kind === "native" && !useShell) {
+        const { installFastPathStreamErrorHandlers } = await import("./utils/fast-stream-errors.js");
+        installFastPathStreamErrorHandlers();
+        const handlerModule = await import(entry.modulePath);
+        const handler = handlerModule[entry.exportName];
+        if (typeof handler !== "function") {
+            throw new Error(`Native fast handler ${entry.exportName} was not exported`);
+        }
+        const readsStdin = entry.readsStdinFor?.(parsed.args) ?? entry.readsStdin ?? false;
+        const stdin = readsStdin ? await readStdinIfPiped(process.stdin) : "";
+        const code = await handler(parsed.args, stdin, process.cwd(), hqRoot, entry.name.split(" ").at(-1) ?? entry.name, parsed.hqRootArg);
+        // Let Node drain handler output before terminating. The timeout guard's
+        // stderr message must survive the native route's process boundary.
+        process.exitCode = code;
+        return;
     }
-    // Keep the CHILD in the caller's cwd, unlike the generic "live" dispatch. The
-    // relocated scripts read their data tree from the injected root, not cwd, and
-    // hq-session's Work Mesh registration serializes $PWD — so changing directory
-    // to the HQ root would mislabel a bind made from inside a project/worktree.
+    const asset = entry.asset;
+    if (!asset)
+        throw new Error(`Fast route ${entry.name} has no shell companion`);
+    // Some historical registrations run from the live root, others preserve the
+    // caller cwd and only inject HQ_ROOT. Keep those choices explicit per entry.
+    const cwd = entry.kind === "native" && entry.shellCwd === "live"
+        ? hqRoot ?? process.cwd()
+        : process.cwd();
+    const injectRoot = entry.kind === "shell" || entry.kind === "native" &&
+        (entry.shellHqRoot === "live" || entry.shellHqRoot === "reconcile-default" && shouldInjectRoot);
+    const childEnv = {
+        ...(entry.name === "hq-session" ? { HQ_HQ_SESSION_NO_CLI: "1" } : {}),
+        ...(entry.name === "migrate-policy-triggers"
+            ? { CLAUDE_PROJECT_DIR: process.env.CLAUDE_PROJECT_DIR || process.cwd() }
+            : {}),
+    };
     const { code } = runBundledScript({
-        asset: parsed.asset,
+        asset,
         args: parsed.args,
-        cwd: process.cwd(),
-        hqRoot,
+        cwd,
+        ...(injectRoot ? { hqRoot } : {}),
+        ...(Object.keys(childEnv).length ? { env: childEnv } : {}),
     });
     // Propagate verbatim: these scripts use their exit code as their interface.
     process.exit(code);
 }
+/** Match hq-flags-client's literal true/false env override without loading its module. */
+function localBooleanFlagOverride(flagKey, env) {
+    const envKey = `HQ_FLAG_${flagKey.replace(/[.-]/g, "_").toUpperCase()}`;
+    const value = env[envKey];
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    return null;
+}
 //# sourceMappingURL=fast-core.js.map

package/dist/fast-scaffold.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Fast-path manifest for selected core commands, kept deliberately
+ * dependency-light.
+ *
+ * `main.ts` eagerly imports the CLI's entire (~60-module) command graph, so any
+ * command routed through it pays seconds of startup — fine for a human typing a
+ * command, ruinous for the hot plumbing this hosts: `hq core hq-session` is
+ * called several times per skill/hook, and `hq core checkpoint-stop-gate` runs
+ * on every turn's Stop. The entrypoint routes eligible commands before loading
+ * the graph, and this module holds the parser + table that routing needs.
+ */
+export type FastScaffoldScript = {
+    /** Direct subcommand name — `hq core <name>`. */
+    name: string;
+    kind: "shell";
+    /** Path under `assets/scaffold/`, e.g. `core/scripts/foo.sh`. */
+    asset: string;
+    root?: "live";
+    /** Whether the bundled fast-route module closure needs Node's network timeout patch. */
+    requiresNodeNetworkCompatibility?: boolean;
+} | {
+    /** Command path, joined with spaces, e.g. `policy frontmatter`. */
+    name: string;
+    kind: "native";
+    /** Relative ESM module specifier, resolved from fast-core.js. */
+    modulePath: string;
+    /** Named export which accepts the native fast-handler contract. */
+    exportName: string;
+    /** Existing default-off gate for the whole fast route. */
+    flagKey: string;
+    /** Existing family gate that chooses this native handler or its shell companion. */
+    familyFlagKey?: string;
+    /** Shell rollback companion used while the family gate is off. */
+    asset?: string;
+    /** Root context used by the native handler. */
+    root?: "live" | "cwd" | "passthrough";
+    /** Cwd used for a shell rollback companion. Defaults to the caller cwd. */
+    shellCwd?: "caller" | "live";
+    /** Root injection behavior for a shell rollback companion. */
+    shellHqRoot?: "none" | "live" | "reconcile-default";
+    /** Whether this handler consumes stdin. Shell companions inherit stdin directly. */
+    readsStdin?: boolean;
+    /** Per-invocation stdin policy for handlers whose shell reads conditionally. */
+    readsStdinFor?: (args: readonly string[]) => boolean;
+    /** Whether the bundled fast-route module closure needs Node's network timeout patch. */
+    requiresNodeNetworkCompatibility?: boolean;
+};
+/** The relocated scripts that qualify for the entrypoint fast path. */
+export declare const FAST_SCAFFOLD_SCRIPTS: readonly FastScaffoldScript[];
+export type ParsedFastCore = {
+    /** The manifest entry to run. */
+    entry: FastScaffoldScript;
+    /** `--hq-root <path>` value, if the caller passed the group option. */
+    hqRootArg?: string;
+    /** Everything after the command name, passed to the script verbatim. */
+    args: string[];
+};
+export type ParsedSecretsEnvFastRequest = {
+    options: {
+        only: string[];
+        script?: string;
+        scriptId?: string;
+    };
+    scope: {
+        company?: string;
+        personal?: boolean;
+    };
+};
+/**
+ * Parse the small, non-ambiguous `hq secrets env` surface for the gated entry
+ * fast path. Anything this parser does not understand stays with Commander in
+ * the full CLI, which remains the source of truth for help and errors.
+ */
+export declare function parseSecretsEnvFastRequest(argv: readonly string[]): ParsedSecretsEnvFastRequest | null;
+/**
+ * Parse `hq core [--hq-root <path>] <name> [args...]` when `<name>` is a
+ * fast-path script. Returns null for anything else so the caller defers to the
+ * full CLI. Mirrors the `core` group's single `--hq-root` option (both the
+ * `--hq-root <path>` and `--hq-root=<path>` forms) and its `root: "live"`
+ * binding; every remaining token is passed through untouched, exactly as the
+ * commander registration does with allowUnknownOption + a variadic argument.
+ */
+export declare function parseFastCore(argv: readonly string[]): ParsedFastCore | null;
+/** Whether this invocation is a fast-path scaffold dispatch. */
+export declare function isFastCoreRequest(argv: readonly string[]): boolean;
+//# sourceMappingURL=fast-scaffold.d.ts.map

package/dist/fast-scaffold.js

@@ -0,0 +1,381 @@
+/**
+ * Fast-path manifest for selected core commands, kept deliberately
+ * dependency-light.
+ *
+ * `main.ts` eagerly imports the CLI's entire (~60-module) command graph, so any
+ * command routed through it pays seconds of startup — fine for a human typing a
+ * command, ruinous for the hot plumbing this hosts: `hq core hq-session` is
+ * called several times per skill/hook, and `hq core checkpoint-stop-gate` runs
+ * on every turn's Stop. The entrypoint routes eligible commands before loading
+ * the graph, and this module holds the parser + table that routing needs.
+ */
+/** The relocated scripts that qualify for the entrypoint fast path. */
+export const FAST_SCAFFOLD_SCRIPTS = [
+    {
+        name: "checkpoint-stop-gate",
+        kind: "native",
+        modulePath: "./commands/core-checkpoint-stop-gate-native.js",
+        exportName: "runCheckpointStopGateFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-session",
+        asset: "core/scripts/checkpoint-stop-gate.sh",
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+        readsStdin: true,
+    },
+    {
+        name: "hq-session",
+        kind: "native",
+        modulePath: "./commands/core-hq-session-native.js",
+        exportName: "runHqSessionFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-session",
+        asset: "core/scripts/hq-session.sh",
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    },
+    {
+        name: "timeout-guard",
+        kind: "native",
+        modulePath: "./lib/core-utils/timeout-guard-native.js",
+        exportName: "runTimeoutGuardFast",
+        flagKey: "hq-core-native-fast-route",
+        root: "cwd",
+        readsStdin: true,
+    },
+    {
+        name: "policy frontmatter",
+        kind: "native",
+        modulePath: "./commands/core-policy.js",
+        exportName: "runPolicyFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-policy",
+        asset: "core/scripts/read-policy-frontmatter.sh",
+        root: "cwd",
+        shellCwd: "caller",
+        shellHqRoot: "none",
+    },
+    {
+        name: "policy age-report",
+        kind: "native",
+        modulePath: "./commands/core-policy.js",
+        exportName: "runPolicyFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-policy",
+        asset: "core/scripts/policy-age-report.sh",
+        root: "live",
+        shellCwd: "caller",
+        shellHqRoot: "live",
+    },
+    {
+        name: "policy retire",
+        kind: "native",
+        modulePath: "./commands/core-policy.js",
+        exportName: "runPolicyFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-policy",
+        asset: "core/scripts/policy-retire.sh",
+        root: "live",
+        shellCwd: "caller",
+        shellHqRoot: "live",
+    },
+    {
+        name: "knowledge-prefs",
+        kind: "native",
+        modulePath: "./commands/core-knowledge-prefs.js",
+        exportName: "runKnowledgePrefsFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-policy",
+        asset: "core/scripts/knowledge-prefs.sh",
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    },
+    ...["finalize", "post", "open-steps"].map((name) => ({
+        name: `handoff ${name}`,
+        kind: "native",
+        modulePath: name === "open-steps"
+            ? "./commands/core-handoff-open-steps.js"
+            : "./commands/core-handoff-fast.js",
+        exportName: name === "open-steps" ? "runHandoffOpenStepsFast" : "runHandoffFastEntry",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-handoff",
+        asset: `core/scripts/handoff-${name === "open-steps" ? "open-steps" : name}.sh`,
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    })),
+    {
+        name: "worktree-gc",
+        kind: "native",
+        modulePath: "./lib/core-utils/worktree-resume.js",
+        exportName: "runWorktreeResumeFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-handoff",
+        asset: "core/scripts/worktree-gc.sh",
+        requiresNodeNetworkCompatibility: true,
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    },
+    {
+        name: "clean-worktree-reconcile-handoff",
+        kind: "native",
+        modulePath: "./lib/core-utils/worktree-resume.js",
+        exportName: "runWorktreeResumeFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-handoff",
+        asset: "core/scripts/clean-worktree-reconcile-handoff.sh",
+        requiresNodeNetworkCompatibility: true,
+        root: "cwd",
+        shellCwd: "caller",
+        shellHqRoot: "none",
+    },
+    {
+        name: "resume-thread-lock",
+        kind: "native",
+        modulePath: "./lib/core-utils/worktree-resume.js",
+        exportName: "runWorktreeResumeFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-handoff",
+        asset: "core/scripts/resume-thread-lock.sh",
+        requiresNodeNetworkCompatibility: true,
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    },
+    {
+        name: "verify-story-deliverables",
+        kind: "native",
+        modulePath: "./lib/core-utils/worktree-resume.js",
+        exportName: "runWorktreeResumeFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-handoff",
+        asset: "core/scripts/verify-story-deliverables.sh",
+        requiresNodeNetworkCompatibility: true,
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    },
+    ...["schedule-parse", "validate", "reconcile"].map((name) => ({
+        name: `jobs ${name}`,
+        kind: "native",
+        modulePath: "./commands/core-jobs-native.js",
+        exportName: "runJobsFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-jobs",
+        asset: `core/scripts/${name === "reconcile" ? "outpost-jobs-reconcile" : `jobs-${name}`}.sh`,
+        requiresNodeNetworkCompatibility: true,
+        root: name === "reconcile" ? "passthrough" : "cwd",
+        shellCwd: "caller",
+        shellHqRoot: name === "reconcile" ? "reconcile-default" : "none",
+    })),
+    ...["share-suggestion-state", "repo-run-registry", "detect-stale-review-base"].map((name) => ({
+        name,
+        kind: "native",
+        modulePath: "./commands/core-hook-state-helpers-native.js",
+        exportName: name === "share-suggestion-state"
+            ? "runShareSuggestionStateFast"
+            : name === "repo-run-registry"
+                ? "runRepoRunRegistryFast"
+                : "runDetectStaleReviewBaseFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-hook-helpers",
+        asset: `core/scripts/${name}.sh`,
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+        ...(name === "share-suggestion-state" ? { readsStdin: true } : {}),
+    })),
+    {
+        name: "resolve-company",
+        kind: "native",
+        modulePath: "./commands/core-resolve-company-native.js",
+        exportName: "runResolveCompanyFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-utilities",
+        asset: "core/scripts/resolve-company.sh",
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    },
+    ...[
+        { name: "eval-trigger", modulePath: "./commands/core-eval-trigger-native.js", exportName: "runEvalTriggerFast", asset: "core/scripts/eval-trigger.sh", root: "cwd", shellCwd: "caller", shellHqRoot: "none", readsStdinFor: (args) => args[0] === "--check" },
+        { name: "migrate-policy-triggers", modulePath: "./commands/core-migrate-policy-triggers-native.js", exportName: "runMigratePolicyTriggersFast", asset: "core/scripts/migrate-policy-triggers.sh", root: "live", shellCwd: "caller", shellHqRoot: "live" },
+        { name: "register-project", modulePath: "./commands/core-register-project-native.js", exportName: "runRegisterProjectFast", asset: "core/scripts/register-project.sh", root: "live", shellCwd: "caller", shellHqRoot: "live" },
+        { name: "work-mesh-live-rebind", modulePath: "./commands/core-work-mesh-live-rebind-native.js", exportName: "runWorkMeshLiveRebindFast", asset: "core/scripts/work-mesh-live-rebind.sh", root: "live", shellCwd: "caller", shellHqRoot: "live" },
+    ].map((entry) => ({
+        ...entry,
+        kind: "native",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-hook-helpers",
+    })),
+    ...["resolve", "pickup", "repo", "secrets", "transfer"].map((name) => ({
+        name: `delegate ${name}`,
+        kind: "native",
+        modulePath: "./commands/core-delegate.js",
+        exportName: "runDelegateFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-delegate",
+        asset: `core/scripts/hq-delegate-${name}.sh`,
+        root: name === "pickup" ? "cwd" : "live",
+        shellCwd: name === "pickup" ? "caller" : "live",
+        shellHqRoot: name === "pickup" ? "none" : "live",
+    })),
+    ...["bundle", "grant", "publish", "send", "verify"].map((name) => ({
+        name: `delegate ${name}`,
+        kind: "native",
+        modulePath: "./commands/core-delegate-w1b.js",
+        exportName: "runDelegateW1bFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-delegate",
+        asset: `core/scripts/hq-delegate-${name}.sh`,
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    })),
+    ...["audience-grant", "brief", "candidate", "garden", "source-worklist", "source-yaml-validate"].map((name) => ({
+        name: `ontology ${name}`,
+        kind: "native",
+        modulePath: "./commands/core-ontology-native.js",
+        exportName: "runOntologyNativeFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-ontology",
+        asset: `core/scripts/${name === "audience-grant" ? "ontology-audience-grant" : name === "source-worklist" ? "ontology-source-worklist" : name === "source-yaml-validate" ? "source-yaml-validate" : `ontology-${name}`}.${name === "brief" || name === "garden" ? "mjs" : "sh"}`,
+        root: name === "source-yaml-validate" ? "cwd" : "live",
+        shellCwd: "caller",
+        shellHqRoot: name === "source-yaml-validate" ? "none" : "live",
+    })),
+];
+/**
+ * Parse the small, non-ambiguous `hq secrets env` surface for the gated entry
+ * fast path. Anything this parser does not understand stays with Commander in
+ * the full CLI, which remains the source of truth for help and errors.
+ */
+export function parseSecretsEnvFastRequest(argv) {
+    if (argv[2] !== "secrets")
+        return null;
+    let index = 3;
+    const scope = {};
+    let hasCompanyScope = false;
+    let hasPersonalScope = false;
+    while (index < argv.length && argv[index] !== "env") {
+        const arg = argv[index];
+        if (arg === "--company") {
+            const value = argv[index + 1];
+            if (!value || value.startsWith("-") || hasPersonalScope)
+                return null;
+            hasCompanyScope = true;
+            scope.company = value;
+            index += 2;
+            continue;
+        }
+        if (arg?.startsWith("--company=")) {
+            const value = arg.slice("--company=".length);
+            if (!value || hasPersonalScope)
+                return null;
+            hasCompanyScope = true;
+            scope.company = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--personal") {
+            if (hasCompanyScope)
+                return null;
+            hasPersonalScope = true;
+            scope.personal = true;
+            index += 1;
+            continue;
+        }
+        return null;
+    }
+    if (argv[index] !== "env")
+        return null;
+    index += 1;
+    const options = { only: [] };
+    let hasOnly = false;
+    while (index < argv.length) {
+        const arg = argv[index];
+        if (arg === "-h" || arg === "--help" || arg === "--")
+            return null;
+        let option;
+        let value;
+        if (arg === "--only" || arg === "--script" || arg === "--script-id") {
+            option = arg;
+            value = argv[index + 1];
+            if (value === undefined || value.startsWith("-"))
+                return null;
+            index += 2;
+        }
+        else if (arg?.startsWith("--only=")) {
+            option = "--only";
+            value = arg.slice("--only=".length);
+            index += 1;
+        }
+        else if (arg?.startsWith("--script=")) {
+            option = "--script";
+            value = arg.slice("--script=".length);
+            index += 1;
+        }
+        else if (arg?.startsWith("--script-id=")) {
+            option = "--script-id";
+            value = arg.slice("--script-id=".length);
+            index += 1;
+        }
+        else {
+            return null;
+        }
+        if (option === "--only") {
+            hasOnly = true;
+            options.only.push(...(value ?? "").split(",").map((key) => key.trim()).filter(Boolean));
+        }
+        else if (option === "--script") {
+            options.script = value;
+        }
+        else if (option === "--script-id") {
+            options.scriptId = value;
+        }
+    }
+    return hasOnly ? { options, scope } : null;
+}
+/**
+ * Parse `hq core [--hq-root <path>] <name> [args...]` when `<name>` is a
+ * fast-path script. Returns null for anything else so the caller defers to the
+ * full CLI. Mirrors the `core` group's single `--hq-root` option (both the
+ * `--hq-root <path>` and `--hq-root=<path>` forms) and its `root: "live"`
+ * binding; every remaining token is passed through untouched, exactly as the
+ * commander registration does with allowUnknownOption + a variadic argument.
+ */
+export function parseFastCore(argv) {
+    // argv is process.argv: [node, hq, core, ...rest].
+    if (argv[2] !== "core")
+        return null;
+    let i = 3;
+    let hqRootArg;
+    const head = argv[i];
+    if (head === "--hq-root") {
+        const value = argv[i + 1];
+        if (typeof value !== "string")
+            return null;
+        hqRootArg = value;
+        i += 2;
+    }
+    else if (typeof head === "string" && head.startsWith("--hq-root=")) {
+        hqRootArg = head.slice("--hq-root=".length);
+        i += 1;
+    }
+    const commandArgs = argv.slice(i);
+    const entry = [...FAST_SCAFFOLD_SCRIPTS]
+        .sort((left, right) => right.name.split(" ").length - left.name.split(" ").length)
+        .find((candidate) => candidate.name.split(" ").every((part, index) => commandArgs[index] === part));
+    if (!entry)
+        return null;
+    return { entry, hqRootArg, args: argv.slice(i + entry.name.split(" ").length) };
+}
+/** Whether this invocation is a fast-path scaffold dispatch. */
+export function isFastCoreRequest(argv) {
+    return parseFastCore(argv) !== null;
+}
+//# sourceMappingURL=fast-scaffold.js.map

package/dist/index.d.ts

@@ -1,11 +1,10 @@
 #!/usr/bin/env node
 import "./node-preflight.js";
-import "./node-network-compat.js";
-import { isFastCoreRequest } from "./commands/scaffold-fast.js";
-declare function isVersionRequest(argv: readonly string[]): boolean;
+import "./node-network-compat-fast.js";
+import { isVersionRequest } from "./version-request.js";
+import { isFastCoreRequest } from "./fast-scaffold.js";
 export declare const __test__: {
     isVersionRequest: typeof isVersionRequest;
     isFastCoreRequest: typeof isFastCoreRequest;
 };
-export {};
 //# sourceMappingURL=index.d.ts.map