@indigoai-us/hq-cli 5.313.0 → 5.314.0

package/dist/index.js

@@ -2,14 +2,18 @@
 // MUST be first: guard the Node version before any dependency that needs a
 // Node 20+ API (e.g. util.styleText) or a newer native ABI is evaluated.
 import "./node-preflight.js";
-import "./node-network-compat-fast.js";
-import { isVersionRequest, wantsLabelledVersionReport } from "./version-request.js";
+import "./node-network-compat.js";
+import { CLI_VERSION } from "./cli-version.js";
 // Dependency-light: a pure parser + table, no command graph. Safe to load on
 // every path (including --version) without reintroducing the heavy startup.
-import { isFastCoreRequest, parseFastCore, parseSecretsEnvFastRequest, } from "./fast-scaffold.js";
+import { isFastCoreRequest } from "./commands/scaffold-fast.js";
 // Also dependency-light: registers a process-level rejection boundary; its only
 // heavy import (main.js) is lazy and reached only when a rejection fires.
 import { installProcessRejectionBoundary } from "./unhandled-rejection-boundary.js";
+function isVersionRequest(argv) {
+    const args = argv.slice(2);
+    return args.length === 1 && (args[0] === "--version" || args[0] === "-V" || args[0] === "-v");
+}
 // Install BEFORE any dispatch so a floated rejection on ANY path (the command
 // graph or the fast-core forwarder) becomes a non-zero exit. @sentry/node's
 // onUnhandledRejection integration defaults to 'warn' — it captures but does
@@ -18,66 +22,12 @@ import { installProcessRejectionBoundary } from "./unhandled-rejection-boundary.
 // so runCli's finally still finalizes release health and flushes Sentry.
 installProcessRejectionBoundary();
 if (isVersionRequest(process.argv)) {
-    // Bare `--version` is the CLI semver only (the contract field updaters
-    // compare). `hq version` and `--json` print the labelled HQ/CLI report.
-    // Lazy so this path still skips the command graph.
-    if (wantsLabelledVersionReport(process.argv)) {
-        void import("./lib/flag-registry.js").then(({ kickFlagRegistryReadiness }) => {
-            kickFlagRegistryReadiness();
-            return import("./utils/version-report.js").then(({ runVersionCommand }) => runVersionCommand(process.argv));
-        });
-    }
-    else {
-        // Keep the benchmarked updater fast route limited to the installed semver.
-        // Registry checks and flag resolution belong to the regular command path.
-        void import("./cli-version.js").then(({ CLI_VERSION }) => {
-            process.stdout.write(`${CLI_VERSION}\n`);
-        });
-    }
-}
-else if (parseFastCore(process.argv)?.entry.kind === "native" &&
-    (process.env.HQ_FLAG_HQ_CORE_NATIVE_FAST_ROUTE === "true" ||
-        process.env.HQ_FLAG_HQ_CORE_NATIVE_FAST_ROUTE === "1")) {
-    // An explicit enabled override has already decided the global gate. Skip the
-    // snapshot reader import on hot native plumbing paths; runFastCore still
-    // checks the command-family flag before choosing native or shell rollback.
-    void import("./fast-core.js").then(({ runFastCore }) => runFastCore(process.argv));
-}
-else if (parseFastCore(process.argv)?.entry.kind === "native") {
-    // Native routes are default-off. Resolve the company-scoped persisted flag
-    // without loading the command graph; a miss or stale snapshot takes the
-    // existing full-graph route.
-    void import("./native-fast-route.js").then(async ({ nativeFastRouteEnabled }) => {
-        if (await nativeFastRouteEnabled(process.argv)) {
-            const { runFastCore } = await import("./fast-core.js");
-            await runFastCore(process.argv);
-        }
-        else {
-            const { runCli } = await import("./main.js");
-            await runCli();
-        }
-    });
-}
-else if (parseSecretsEnvFastRequest(process.argv)) {
-    const request = parseSecretsEnvFastRequest(process.argv);
-    void import("./secrets-env-fast-route.js").then(async (route) => {
-        await route.dispatchSecretsEnvFastRequest(request, {
-            isEnabled: () => route.secretsEnvFastRouteEnabled(request),
-            runFast: async () => {
-                const { runSecretsEnvFastPath } = await import("./secrets-env-fast-path.js");
-                return runSecretsEnvFastPath(request);
-            },
-            runCurrent: async () => {
-                const { runCli } = await import("./main.js");
-                await runCli();
-            },
-        });
-    });
+    process.stdout.write(`${CLI_VERSION}\n`);
 }
 else if (isFastCoreRequest(process.argv)) {
     // Hot relocated plumbing (`hq core hq-session`, `hq core checkpoint-stop-gate`)
     // dispatches straight to the bundled-script runner, so it never pays for the
-    // ~60-module command graph main.ts imports. See src/fast-scaffold.ts.
+    // ~60-module command graph main.ts imports. See src/commands/scaffold-fast.ts.
     void import("./fast-core.js").then(({ runFastCore }) => runFastCore(process.argv));
 }
 else {

package/dist/lazy-commands.d.ts

@@ -1,31 +1,55 @@
-import { Command } from "commander";
+/**
+ * Hot-command manifest for the entrypoint's lazy registration.
+ *
+ * main.ts used to import the entire ~60-module command graph at module scope,
+ * so every invocation paid for every command. That is fine for a human typing
+ * one command and ruinous for the calls automation makes in a loop: the
+ * hq-sentry agent fleet on an outpost runs `hq secrets` about 39 times a minute
+ * (each worker resolves credentials before every external command it executes),
+ * and each of those processes spent ~0.75 CPU-seconds importing commands it
+ * never ran — around half a core, continuously. Measured on Outpost 2
+ * (i-09424eff61920a4ac) 2026-09-05; see register-all.ts for the numbers.
+ *
+ * A command listed here registers ITSELF and nothing else. Anything not listed
+ * — `--help`, a bare `hq`, an unknown command, every other command — falls back
+ * to `registerAllCommands`, the complete unchanged graph. That fallback is what
+ * makes this safe to extend one command at a time: an entry is a performance
+ * opt-in, never a behaviour change, and a command that is absent here is simply
+ * as fast as it was before.
+ *
+ * This mirrors commands/scaffold-fast.ts, which does the same thing for the
+ * relocated `hq core …` scripts, and carries the same anti-drift discipline: a
+ * parity test registers each entry BOTH ways and asserts the resulting command
+ * shape is identical, so a manifest entry cannot silently diverge from the real
+ * registration.
+ *
+ * TO ADD A COMMAND: it must register exactly one top-level command, be
+ * registered onto `program` (not onto a subcommand group), and have no other
+ * module contributing subcommands to it. The parity test enforces the shape;
+ * these three conditions are what make the entry correct in the first place.
+ */
+import type { Command } from "commander";
 export type LazyCommand = {
-    /** Canonical top-level name; aliases resolve to this name. */
+    /** The top-level token this matches — `hq <name> …`. */
     name: string;
-    /** Registers every contributor for this root and no unrelated root. */
+    /** Registers this one command onto `program`, importing only its module. */
     register: (program: Command) => Promise<void>;
 };
 /**
- * One entry for every root, including groups that are assembled by several
- * registrar modules. The routing metadata itself is generated from the eager
- * command graph and checked in tests and the build.
+ * The hot paths, in descending order of how often automation calls them.
+ *
+ * `secrets` and `run` are the two commands HQ's own tooling puts on the inner
+ * loop: every fleet worker shells through one of them before each external
+ * command, which is exactly the shape that makes eager import expensive.
  */
 export declare const LAZY_COMMANDS: readonly LazyCommand[];
 /**
- * Keep the registration seam at register-all.js. Besides making one place own
- * the graph, this lets the torn-install recovery wrap failures while an update
- * replaces the installed tree between startup and command registration.
- */
-export declare function registerCommandRoot(program: Command, root: string): Promise<boolean>;
-/**
- * Register only generated root metadata. This is enough for root help and
- * Commander suggestions, without evaluating an implementation module.
- */
-export declare function registerCommandCatalog(program: Command): void;
-/**
- * Resolve the root requested by Commander argv. Root help, a bare invocation,
- * and unknown tokens deliberately return null so the lightweight catalog can
- * preserve the complete help and unknown-command recovery surfaces.
+ * Resolve `process.argv` to a manifest entry, or null to use the full graph.
+ *
+ * argv is `[node, hq, <name>, ...rest]`. `hq` declares no program-level options
+ * before the command name, so argv[2] is the command token when there is one;
+ * `--help`, `--version`, and a bare `hq` all fail the lookup and take the
+ * fallback, which is the intended behaviour — help must list every command.
  */
 export declare function findLazyCommand(argv: readonly string[]): LazyCommand | null;
 //# sourceMappingURL=lazy-commands.d.ts.map

package/dist/lazy-commands.js

@@ -1,70 +1,68 @@
-import { Command } from "commander";
-import { COMMAND_CATALOG } from "./command-catalog.generated.js";
-const commandCatalog = COMMAND_CATALOG;
 /**
- * One entry for every root, including groups that are assembled by several
- * registrar modules. The routing metadata itself is generated from the eager
- * command graph and checked in tests and the build.
+ * Hot-command manifest for the entrypoint's lazy registration.
+ *
+ * main.ts used to import the entire ~60-module command graph at module scope,
+ * so every invocation paid for every command. That is fine for a human typing
+ * one command and ruinous for the calls automation makes in a loop: the
+ * hq-sentry agent fleet on an outpost runs `hq secrets` about 39 times a minute
+ * (each worker resolves credentials before every external command it executes),
+ * and each of those processes spent ~0.75 CPU-seconds importing commands it
+ * never ran — around half a core, continuously. Measured on Outpost 2
+ * (i-09424eff61920a4ac) 2026-09-05; see register-all.ts for the numbers.
+ *
+ * A command listed here registers ITSELF and nothing else. Anything not listed
+ * — `--help`, a bare `hq`, an unknown command, every other command — falls back
+ * to `registerAllCommands`, the complete unchanged graph. That fallback is what
+ * makes this safe to extend one command at a time: an entry is a performance
+ * opt-in, never a behaviour change, and a command that is absent here is simply
+ * as fast as it was before.
+ *
+ * This mirrors commands/scaffold-fast.ts, which does the same thing for the
+ * relocated `hq core …` scripts, and carries the same anti-drift discipline: a
+ * parity test registers each entry BOTH ways and asserts the resulting command
+ * shape is identical, so a manifest entry cannot silently diverge from the real
+ * registration.
+ *
+ * TO ADD A COMMAND: it must register exactly one top-level command, be
+ * registered onto `program` (not onto a subcommand group), and have no other
+ * module contributing subcommands to it. The parity test enforces the shape;
+ * these three conditions are what make the entry correct in the first place.
  */
-export const LAZY_COMMANDS = commandCatalog.map((command) => ({
-    name: command.name,
-    register: async (program) => {
-        const registered = await registerCommandRoot(program, command.name);
-        if (!registered)
-            throw new Error(`No registration plan for '${command.name}'`);
-    },
-}));
-/**
- * Keep the registration seam at register-all.js. Besides making one place own
- * the graph, this lets the torn-install recovery wrap failures while an update
- * replaces the installed tree between startup and command registration.
- */
-export async function registerCommandRoot(program, root) {
-    const registration = await import("./register-all.js");
-    return registration.registerCommandRoot(program, root);
-}
-function commandDefinition(command) {
-    const stub = new Command(command.name)
-        .description(command.description);
-    for (const alias of command.aliases)
-        stub.alias(alias);
-    for (const argument of command.arguments) {
-        const name = `${argument.name}${argument.variadic ? "..." : ""}`;
-        stub.argument(argument.required ? `<${name}>` : `[${name}]`);
-    }
-    for (const option of command.options)
-        stub.option(option.flags, option.description);
-    if (command.hidden)
-        stub._hidden = true;
-    return stub;
-}
 /**
- * Register only generated root metadata. This is enough for root help and
- * Commander suggestions, without evaluating an implementation module.
+ * The hot paths, in descending order of how often automation calls them.
+ *
+ * `secrets` and `run` are the two commands HQ's own tooling puts on the inner
+ * loop: every fleet worker shells through one of them before each external
+ * command, which is exactly the shape that makes eager import expensive.
  */
-export function registerCommandCatalog(program) {
-    for (const command of commandCatalog)
-        program.addCommand(commandDefinition(command));
-}
-function commandForToken(token) {
-    return commandCatalog.find((candidate) => candidate.name === token || candidate.aliases.includes(token));
-}
+export const LAZY_COMMANDS = [
+    {
+        name: "secrets",
+        register: async (program) => {
+            const { registerSecretsCommand } = await import("./commands/secrets.js");
+            registerSecretsCommand(program);
+        },
+    },
+    {
+        name: "run",
+        register: async (program) => {
+            const { registerRunCommand } = await import("./commands/run.js");
+            registerRunCommand(program);
+        },
+    },
+];
 /**
- * Resolve the root requested by Commander argv. Root help, a bare invocation,
- * and unknown tokens deliberately return null so the lightweight catalog can
- * preserve the complete help and unknown-command recovery surfaces.
+ * Resolve `process.argv` to a manifest entry, or null to use the full graph.
+ *
+ * argv is `[node, hq, <name>, ...rest]`. `hq` declares no program-level options
+ * before the command name, so argv[2] is the command token when there is one;
+ * `--help`, `--version`, and a bare `hq` all fail the lookup and take the
+ * fallback, which is the intended behaviour — help must list every command.
  */
 export function findLazyCommand(argv) {
-    let commandIndex = 2;
-    while (argv[commandIndex] === "--verbose")
-        commandIndex += 1;
-    const first = argv[commandIndex];
-    const token = first === "help" ? argv[commandIndex + 1] : first;
-    if (typeof token !== "string" || token.startsWith("-"))
-        return null;
-    const command = commandForToken(token);
-    if (!command)
+    const name = argv[2];
+    if (typeof name !== "string")
         return null;
-    return LAZY_COMMANDS.find((candidate) => candidate.name === command.name) ?? null;
+    return LAZY_COMMANDS.find((candidate) => candidate.name === name) ?? null;
 }
 //# sourceMappingURL=lazy-commands.js.map

package/dist/lib/company-skill-wrapper.d.ts

@@ -1,5 +1,4 @@
 import * as fs from "node:fs";
-export declare function companySkillWrapperSentryTagsFor(error: unknown): Record<string, string> | undefined;
 export interface SurfaceCompanySkillInput {
     hqRoot: string;
     companySlug: string;

package/dist/lib/company-skill-wrapper.js

@@ -62,6 +62,20 @@ function symlinkTarget(linkPath) {
 function generatedMarkerPath(wrapperPath) {
     return path.join(path.dirname(wrapperPath), WRAPPER_MARKER_DIR, `${path.basename(wrapperPath)}.json`);
 }
+function hasBoundGeneratedMarker(wrapperPath, companySlug) {
+    try {
+        const marker = JSON.parse(fs.readFileSync(generatedMarkerPath(wrapperPath), "utf8"));
+        const wrapper = fs.lstatSync(wrapperPath);
+        return (marker.version === 2 &&
+            marker.companySlug === companySlug &&
+            marker.wrapperDev === wrapper.dev &&
+            marker.wrapperIno === wrapper.ino &&
+            marker.wrapperBirthtimeMs === wrapper.birthtimeMs);
+    }
+    catch {
+        return false;
+    }
+}
 function writeGeneratedMarker(wrapperPath, companySlug, skillSlug) {
     const markerPath = generatedMarkerPath(wrapperPath);
     try {
@@ -90,116 +104,21 @@ function removeGeneratedMarker(wrapperPath) {
         // never sufficient to surface content on its own.
     }
 }
-const COMPANY_SKILL_WRAPPER_DIAGNOSTICS = Symbol("company-skill-wrapper-diagnostics");
-function companySkillWrapperOwnershipError(wrapperPath, diagnostics) {
-    const error = new Error(`Cannot replace '${wrapperPath}' because it is not an HQ-generated skill wrapper.`);
-    Object.defineProperty(error, COMPANY_SKILL_WRAPPER_DIAGNOSTICS, {
-        value: diagnostics,
-    });
-    return error;
-}
-export function companySkillWrapperSentryTagsFor(error) {
-    if (!(error instanceof Error))
-        return undefined;
-    const diagnostics = error[COMPANY_SKILL_WRAPPER_DIAGNOSTICS];
-    if (!diagnostics)
-        return undefined;
-    return {
-        hq_cli_skill_wrapper_kind: diagnostics.kind,
-        hq_cli_skill_wrapper_bridge_state: diagnostics.bridgeState,
-        hq_cli_skill_wrapper_marker_state: diagnostics.markerState,
-        hq_cli_skill_wrapper_link_target: diagnostics.linkTarget,
-        hq_cli_skill_wrapper_platform: diagnostics.platform,
-        hq_cli_skill_wrapper_name_encoding: diagnostics.nameEncoding,
-    };
-}
-function inspectGeneratedNamespacedWrapper(wrapperPath, hqRoot, companySlug) {
+function isGeneratedNamespacedWrapper(wrapperPath, hqRoot, companySlug) {
     const companySkillsRoot = path.join(hqRoot, "companies", companySlug, "skills");
-    const wrapperEntry = lstat(wrapperPath);
-    if (wrapperEntry?.isSymbolicLink()) {
-        const target = symlinkTarget(wrapperPath);
-        const linkTarget = target === undefined
-            ? "unavailable"
-            : isWithin(companySkillsRoot, target)
-                ? "company_skills"
-                : "outside_company_skills";
-        return {
-            owned: linkTarget === "company_skills",
-            diagnostics: {
-                kind: "symlink",
-                bridgeState: "not_applicable",
-                markerState: "not_applicable",
-                linkTarget,
-            },
-        };
-    }
-    if (!wrapperEntry?.isDirectory()) {
-        return {
-            owned: false,
-            diagnostics: {
-                kind: wrapperEntry?.isFile() ? "file" : "other",
-                bridgeState: "not_applicable",
-                markerState: "not_applicable",
-                linkTarget: "not_applicable",
-            },
-        };
-    }
+    const wrapperTarget = symlinkTarget(wrapperPath);
+    if (wrapperTarget)
+        return isWithin(companySkillsRoot, wrapperTarget);
+    const wrapper = lstat(wrapperPath);
+    if (!wrapper?.isDirectory())
+        return false;
     const entries = fs.readdirSync(wrapperPath).filter((entry) => !entry.startsWith("."));
-    const liveBridgeCount = entries.reduce((count, entry) => {
-        const target = symlinkTarget(path.join(wrapperPath, entry));
-        return count + (target !== undefined && isWithin(companySkillsRoot, target) ? 1 : 0);
-    }, 0);
-    const bridgeState = entries.length === 0
-        ? "empty"
-        : liveBridgeCount === entries.length
-            ? "all_live"
-            : liveBridgeCount > 0
-                ? "partial"
-                : "none";
-    const markerState = generatedMarkerState(wrapperPath, companySlug);
-    return {
-        owned: bridgeState === "all_live" || markerState === "bound",
-        diagnostics: {
-            kind: "directory",
-            bridgeState,
-            markerState,
-            linkTarget: "not_applicable",
-        },
-    };
-}
-function isGeneratedNamespacedWrapper(wrapperPath, hqRoot, companySlug) {
-    return inspectGeneratedNamespacedWrapper(wrapperPath, hqRoot, companySlug).owned;
-}
-function generatedMarkerState(wrapperPath, companySlug) {
-    let markerContents;
-    try {
-        markerContents = fs.readFileSync(generatedMarkerPath(wrapperPath), "utf8");
-    }
-    catch (error) {
-        return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT"
-            ? "missing"
-            : "unavailable";
-    }
-    let marker;
-    try {
-        marker = JSON.parse(markerContents);
-    }
-    catch {
-        return "invalid";
-    }
-    try {
-        const wrapper = fs.lstatSync(wrapperPath);
-        return marker.version === 2 &&
-            marker.companySlug === companySlug &&
-            marker.wrapperDev === wrapper.dev &&
-            marker.wrapperIno === wrapper.ino &&
-            marker.wrapperBirthtimeMs === wrapper.birthtimeMs
-            ? "bound"
-            : "unbound";
-    }
-    catch {
-        return "unavailable";
-    }
+    const containsOnlyLiveBridges = (entries.length > 0 &&
+        entries.every((entry) => {
+            const target = symlinkTarget(path.join(wrapperPath, entry));
+            return target !== undefined && isWithin(companySkillsRoot, target);
+        }));
+    return containsOnlyLiveBridges || hasBoundGeneratedMarker(wrapperPath, companySlug);
 }
 function isGeneratedLegacyEntry(legacyPath, sourceDir, skillFile) {
     const target = symlinkTarget(legacyPath);
@@ -305,19 +224,8 @@ export function surfaceCompanySkill(input) {
         const backupPath = `${stagingPath}.previous`;
         let previousMoved = false;
         if (currentWrapper) {
-            const ownership = inspectGeneratedNamespacedWrapper(wrapperPath, input.hqRoot, input.companySlug);
-            if (!ownership.owned) {
-                const runtimePlatform = process.platform;
-                const platform = win32
-                    ? "win32"
-                    : runtimePlatform === "darwin" || runtimePlatform === "linux"
-                        ? runtimePlatform
-                        : "other";
-                throw companySkillWrapperOwnershipError(wrapperPath, {
-                    ...ownership.diagnostics,
-                    platform,
-                    nameEncoding: win32 ? "percent_encoded" : "literal",
-                });
+            if (!isGeneratedNamespacedWrapper(wrapperPath, input.hqRoot, input.companySlug)) {
+                throw new Error(`Cannot replace '${wrapperPath}' because it is not an HQ-generated skill wrapper.`);
             }
             renameEntry(wrapperPath, backupPath);
             previousMoved = true;

package/dist/lib/core-utils/codex-skill-bridge.d.ts

@@ -1,4 +1,4 @@
-type BridgeCommand = "status" | "install" | "doctor";
+export type BridgeCommand = "status" | "install" | "doctor";
 export type BridgeOptions = {
     command: BridgeCommand;
     hqRoot: string;
@@ -28,5 +28,4 @@ export declare function isHqRootLike(candidate: string): boolean;
 export declare function outputStyleSlug(name: string): string;
 /** Runs one bridge command; returns the process exit code. */
 export declare function runCodexSkillBridge(options: BridgeOptions, io: BridgeIo): number;
-export {};
 //# sourceMappingURL=codex-skill-bridge.d.ts.map

package/dist/lib/core-utils/qmd-reindex-after-sync.d.ts

@@ -1,8 +1,4 @@
-import { type EmbedLockDependencies } from "../search-index/embed-lock.js";
-import { type LoadGateDependencies } from "../search-index/load-gate.js";
-import { type UtilityIo } from "./common.js";
-export declare const QMD_REINDEX_STARTUP_WARNING_FLAG = "qmd.reindex-startup-warning";
-export declare const QMD_REINDEX_STARTUP_WARNING_FLAG_FALLBACK = false;
+import type { UtilityIo } from "./common.js";
 export type QmdReindexOptions = UtilityIo & {
     cwd?: string;
     /** Test seams; default to the real search-index implementations. */
@@ -14,15 +10,6 @@ export type QmdReindexOptions = UtilityIo & {
         bin: string;
         cwd: string;
     }) => unknown;
-    sizeLimit?: (hqRoot: string) => unknown;
-    /** Test seams for the lock shared by every hq-cli QMD writer. */
-    embedLockDependencies?: EmbedLockDependencies;
-    /** Test seams for the host load gate consulted while the embed lock is held. */
-    loadGateDependencies?: LoadGateDependencies;
-    /** Test seam for the hq-flags-gated warning on qmd native startup failures. */
-    startupFailureWarningsEnabled?: () => boolean;
-    /** Test seam for the default-off shared lock around the full reindex pass. */
-    singleFlightEnabled?: () => boolean;
 };
 export declare function qmdReindexAfterSync(args?: string[], options?: QmdReindexOptions): number;
 //# sourceMappingURL=qmd-reindex-after-sync.d.ts.map

package/dist/lib/core-utils/qmd-reindex-after-sync.js

@@ -7,24 +7,11 @@
  *
  * Contract preserved verbatim: a missing qmd or a non-HQ path is a silent
  * success (a sync must never fail because indexing could not run), the lexical
- * update normally runs, and embeddings rebuild only on `--embed`. An enabled
- * single-flight canary may skip a pass while another QMD writer owns the lock.
+ * update always runs, and embeddings rebuild only on `--embed`.
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { reconcileCollections, resolveQmdBin, resolveQmdHome, runQmd } from "../search-index/index.js";
-import { applyIndexSizeLimit } from "../search-index/max-doc-bytes.js";
-import { defaultEmbedLockDependencies, runWithEmbedLock, } from "../search-index/embed-lock.js";
-import { LoadGateConfigurationError, checkEmbedLoad, defaultLoadGateDependencies, recordSuccessfulEmbed, } from "../search-index/load-gate.js";
-import { resolveProcessFlagGate } from "../flag-registry.js";
-import { qmdReindexSingleFlightEnabled } from "../search-index/reindex-single-flight-flag.js";
-import { isQmdNativeBindingError, QMD_NATIVE_BINDING_REMEDY, } from "../../utils/qmd-native-binding-error.js";
-import { ioFor, line } from "./common.js";
-export const QMD_REINDEX_STARTUP_WARNING_FLAG = "qmd.reindex-startup-warning";
-export const QMD_REINDEX_STARTUP_WARNING_FLAG_FALLBACK = false;
-function qmdStartupFailureWarningsEnabled() {
-    return resolveProcessFlagGate(QMD_REINDEX_STARTUP_WARNING_FLAG, { fallback: QMD_REINDEX_STARTUP_WARNING_FLAG_FALLBACK }, () => QMD_REINDEX_STARTUP_WARNING_FLAG_FALLBACK);
-}
+import { reconcileCollections, resolveQmdBin, runQmd } from "../search-index/index.js";
 export function qmdReindexAfterSync(args = [], options = {}) {
     let hqRoot = "";
     let embed = false;
@@ -49,97 +36,26 @@ export function qmdReindexAfterSync(args = [], options = {}) {
         return 0;
     const reconcile = options.reconcile ?? ((root, opts) => reconcileCollections(root, opts));
     const run = options.run ?? ((argv, opts) => runQmd(argv, opts));
-    const sizeLimit = options.sizeLimit ?? ((root) => applyIndexSizeLimit(root));
-    const { stderr } = ioFor(options);
-    let startupFailureWarningShown = false;
-    const warnOnNativeStartupFailure = (error) => {
-        if (startupFailureWarningShown ||
-            !isQmdNativeBindingError(error) ||
-            !(options.startupFailureWarningsEnabled ?? qmdStartupFailureWarningsEnabled)())
-            return;
-        startupFailureWarningShown = true;
-        line(stderr, `hq: search index was not updated after sync; ${QMD_NATIVE_BINDING_REMEDY}`);
-    };
-    const updateIndex = () => {
-        // Every qmd interaction is best-effort: the shell suffixed each with `|| true`.
-        try {
-            reconcile(hqRoot, { bin });
-        }
-        catch {
-            /* registration is advisory; an update still helps */
-        }
-        // The cap has to land before the update: qmd decides what to read
-        // at glob time, so an ignore entry written afterwards saves nothing on this
-        // pass. This is the post-sync entry point, which reaches `qmd update` without
-        // going through `hq index sync` at all.
+    // Every qmd interaction is best-effort: the shell suffixed each with `|| true`.
+    try {
+        reconcile(hqRoot, { bin });
+    }
+    catch {
+        /* registration is advisory; an update still helps */
+    }
+    try {
+        run(["update"], { bin, cwd: hqRoot });
+    }
+    catch {
+        /* never fail a sync on index freshness */
+    }
+    if (embed) {
         try {
-            sizeLimit(hqRoot);
+            run(["embed"], { bin, cwd: hqRoot });
         }
         catch {
-            /* an uncapped index is worse than none, but still better than a failed sync */
-        }
-        try {
-            run(["update"], { bin, cwd: hqRoot });
-        }
-        catch (error) {
-            warnOnNativeStartupFailure(error);
-            /* never fail a sync on index freshness */
-        }
-    };
-    const runEmbed = (home, lockDependencies) => {
-        const loadGateDependencies = options.loadGateDependencies ?? defaultLoadGateDependencies(lockDependencies.env);
-        const decision = checkEmbedLoad(home, loadGateDependencies);
-        if (decision.action === "skip") {
-            line(stderr, decision.notice.trimEnd());
-            return "skipped";
-        }
-        if (decision.forced)
-            line(stderr, decision.notice.trimEnd());
-        run(["embed"], { bin, cwd: hqRoot });
-        recordSuccessfulEmbed(home, loadGateDependencies);
-        return undefined;
-    };
-    if ((options.singleFlightEnabled ?? qmdReindexSingleFlightEnabled)()) {
-        const lockDependencies = options.embedLockDependencies ?? defaultEmbedLockDependencies();
-        const home = resolveQmdHome(lockDependencies.env);
-        try {
-            const outcome = runWithEmbedLock(home, lockDependencies, () => {
-                updateIndex();
-                return embed ? runEmbed(home, lockDependencies) : undefined;
-            });
-            if (outcome === "busy") {
-                line(stderr, "hq: qmd reindex is already running; skipping this post-sync pass.");
-            }
-            if (outcome === "unavailable") {
-                line(stderr, "hq: cannot access the qmd reindex lock; skipping this post-sync pass.");
-            }
-        }
-        catch (error) {
-            if (error instanceof LoadGateConfigurationError)
-                line(stderr, `hq: ${error.message}`);
-            warnOnNativeStartupFailure(error);
             /* embeddings are deferred-cost and optional */
         }
-        return 0;
-    }
-    updateIndex();
-    if (!embed)
-        return 0;
-    const lockDependencies = options.embedLockDependencies ?? defaultEmbedLockDependencies();
-    const home = resolveQmdHome(lockDependencies.env);
-    try {
-        const outcome = runWithEmbedLock(home, lockDependencies, () => runEmbed(home, lockDependencies));
-        if (outcome === "busy") {
-            line(stderr, "hq: qmd embed is already running; skipping this pass.");
-        }
-        if (outcome === "unavailable")
-            line(stderr, "hq: cannot access the qmd embed lock; skipping this pass.");
-    }
-    catch (error) {
-        if (error instanceof LoadGateConfigurationError)
-            line(stderr, `hq: ${error.message}`);
-        warnOnNativeStartupFailure(error);
-        /* embeddings are deferred-cost and optional */
     }
     return 0;
 }