@indigoai-us/hq-cli 5.312.2-beta.0 → 5.314.0

package/dist/lib/scan-packages/index.js

@@ -3,7 +3,6 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as yaml from 'js-yaml';
 import { contributionLinks } from '../../utils/pack-contributions.js';
-import { CONTRIBUTION_TABLE } from '../../utils/contribution-table.js';
 function isDirectory(target) { try {
     return fs.statSync(target).isDirectory();
 }
@@ -18,7 +17,7 @@ catch {
     return false;
 } }
 function normalized(relative) { return relative.replaceAll(path.sep, '/'); }
-export function readContributes(manifest) {
+function readContributes(manifest) {
     // This deliberately mirrors the staging script's shallow awk grammar rather
     // than accepting YAML forms the legacy ABI never recognized (notably a
     // non-empty inline list). Mapping remains single-sourced in
@@ -141,61 +140,19 @@ function workerIdClashes(hqRoot, source) {
     }
     return undefined;
 }
-/**
- * What a symlink's target resolves to: `present`, `absent`, or the errno of a
- * lookup that answered neither. Only ENOENT (nothing there) and ENOTDIR (a
- * path component is not a directory, so the target cannot exist) mean absent.
- * EACCES, ELOOP and friends mean the question went unanswered, which is not a
- * licence to destroy what the link points at.
- */
-function targetLookup(target) {
-    try {
-        fs.statSync(target);
-        return 'present';
-    }
-    catch (error) {
-        const code = error.code;
-        return code === 'ENOENT' || code === 'ENOTDIR' ? 'absent' : code ?? 'unknown error';
-    }
-}
 function ensureSymlink(link, info, warn) {
     if (!existsOrSymlink(link.src)) {
         warn(`payload missing: ${link.src} (declared but not shipped)`);
         return;
     }
-    const relativeSrc = path.relative(path.dirname(link.dst), link.src);
     fs.mkdirSync(path.dirname(link.dst), { recursive: true });
     try {
         const stat = fs.lstatSync(link.dst);
         if (stat.isSymbolicLink()) {
             const existing = fs.readlinkSync(link.dst);
-            // Correct form is relative to the host directory so a tree can move
-            // between machines. An absolute match (this host, pre-relative installer)
-            // is ours and converges. A dangling leftover from another HQ root is
-            // not host content and is rewritten the same way.
-            if (existing === relativeSrc)
-                return;
-            if (existing === link.src) {
-                fs.rmSync(link.dst, { force: true });
-                fs.symlinkSync(relativeSrc, link.dst);
-                info(`relinked ${link.dst} -> ${relativeSrc} (was ${existing})`);
-                return;
-            }
-            // Only a lookup that specifically says "not there" earns a relink.
-            // fs.existsSync also answers false for EACCES, which would read content
-            // this user merely cannot traverse as absent and delete the link to it.
-            const lookup = targetLookup(link.dst);
-            if (lookup === 'absent') {
-                fs.rmSync(link.dst, { force: true });
-                fs.symlinkSync(relativeSrc, link.dst);
-                info(`relinked ${link.dst} -> ${relativeSrc} (was ${existing}, which does not exist here)`);
-                return;
-            }
-            if (lookup !== 'present') {
-                warn(`collision: ${link.dst} points at ${existing}, which could not be checked (${lookup}) — leaving it alone`);
+            if (existing === link.src)
                 return;
-            }
-            warn(`collision: ${link.dst} already points at ${existing} (wanted ${relativeSrc}) — skipping`);
+            warn(`collision: ${link.dst} already points at ${existing} (wanted ${link.src}) — skipping`);
             return;
         }
         warn(`collision: ${link.dst} exists as regular file/dir — host content wins, skipping`);
@@ -205,104 +162,8 @@ function ensureSymlink(link, info, warn) {
         if (error.code !== 'ENOENT')
             throw error;
     }
-    fs.symlinkSync(relativeSrc, link.dst);
-    info(`linked ${link.dst} -> ${relativeSrc}`);
-}
-/**
- * The link text, when `entry` is a symlink whose target is definitively not
- * there; `undefined` for anything else — a real file or directory, a link that
- * resolves, or a lookup that failed for a reason other than absence.
- */
-function danglingLinkTarget(entry) {
-    let link;
-    try {
-        if (!fs.lstatSync(entry).isSymbolicLink())
-            return undefined;
-        link = fs.readlinkSync(entry);
-    }
-    catch {
-        return undefined;
-    }
-    return targetLookup(entry) === 'absent' ? link : undefined;
-}
-/** Host directories the table routes symlinks into, HQ-root relative. */
-function symlinkHostRoots() {
-    const roots = new Set();
-    for (const row of Object.values(CONTRIBUTION_TABLE)) {
-        if (row.wire === 'symlink')
-            roots.add(row.host);
-    }
-    return [...roots].sort();
-}
-/**
- * Remove host symlinks that point into `core/packages/` at a payload that is
- * no longer there.
- *
- * Wiring only ever adds. A contribution a pack stops shipping, or a pack whose
- * directory is itself a link into a deleted worktree, leaves its host links
- * pointing at nothing, and nothing removed them — so they accumulated and
- * warned on every run forever.
- *
- * Scoped three ways so this only reaps what the pack system wired:
- *   - only inside the host roots the contribution table declares,
- *   - only symlinks whose target resolves inside `core/packages/`,
- *   - only when the lookup specifically says the target is absent. EACCES and
- *     friends mean the question went unanswered, which is not a licence to
- *     delete (same discipline as the relink path).
- *
- * A symlinked directory is classified, never descended into: a Dirent reports
- * it as a symlink rather than a directory, so the walk cannot wander out of
- * the host roots through one.
- */
-function reapOrphanedLinks(hqRoot, info, warn) {
-    const packagesRoot = path.join(hqRoot, 'core/packages') + path.sep;
-    for (const hostRelative of symlinkHostRoots()) {
-        const stack = [path.join(hqRoot, hostRelative)];
-        while (stack.length > 0) {
-            const current = stack.pop();
-            let entries;
-            try {
-                entries = fs.readdirSync(current, { withFileTypes: true });
-            }
-            catch {
-                continue;
-            }
-            entries.sort((left, right) => (left.name < right.name ? -1 : left.name > right.name ? 1 : 0));
-            for (const entry of entries) {
-                const absolute = path.join(current, entry.name);
-                if (entry.isDirectory()) {
-                    stack.push(absolute);
-                    continue;
-                }
-                if (!entry.isSymbolicLink())
-                    continue;
-                let target;
-                try {
-                    target = fs.readlinkSync(absolute);
-                }
-                catch {
-                    continue;
-                }
-                const resolved = path.resolve(path.dirname(absolute), target);
-                if (!resolved.startsWith(packagesRoot))
-                    continue;
-                const lookup = targetLookup(absolute);
-                if (lookup === 'present')
-                    continue;
-                if (lookup !== 'absent') {
-                    warn(`${absolute} points into core/packages at ${resolved}, which could not be checked (${lookup}) — leaving it alone`);
-                    continue;
-                }
-                try {
-                    fs.rmSync(absolute, { force: true });
-                    info(`unwired ${absolute} (its pack payload ${resolved} is gone)`);
-                }
-                catch (error) {
-                    warn(`could not unwire ${absolute} (${error.message})`);
-                }
-            }
-        }
-    }
+    fs.symlinkSync(link.src, link.dst);
+    info(`linked ${link.dst} -> ${link.src}`);
 }
 /** Wire installed pack contributions into their table-declared host locations. */
 export function scanPackages(hqRoot, options = {}) {
@@ -313,9 +174,6 @@ export function scanPackages(hqRoot, options = {}) {
     const warn = (message) => warnSink(`  [warn] ${message}`);
     const packages = path.join(hqRoot, 'core/packages');
     if (!isDirectory(packages)) {
-        // Still sweep: a packages directory that is gone entirely is exactly when
-        // every link into it is an orphan.
-        reapOrphanedLinks(hqRoot, info, warn);
         info('[scan-packages] no core/packages/ dir; nothing to wire');
         return { status: 0 };
     }
@@ -332,24 +190,7 @@ export function scanPackages(hqRoot, options = {}) {
         for (const name of packageNames) {
             const packDir = path.join(packages, name);
             const manifest = path.join(packDir, 'package.yaml');
-            if (!isDirectory(packDir)) {
-                // A dangling entry in core/packages/ is not a pack and cannot become
-                // one — typically an install from a worktree that was later removed.
-                // Only a symlink to nothing qualifies: a real directory holds real
-                // files whatever its manifest situation, and is left alone.
-                const danglingTarget = danglingLinkTarget(packDir);
-                if (danglingTarget !== undefined) {
-                    try {
-                        fs.rmSync(packDir, { force: true });
-                        info(`[scan-packages] removed ${name}: its payload is gone (was a link to ${danglingTarget})`);
-                    }
-                    catch (error) {
-                        warn(`could not remove the dangling pack entry ${packDir} (${error.message})`);
-                    }
-                }
-                continue;
-            }
-            if (!fs.existsSync(manifest))
+            if (!isDirectory(packDir) || !fs.existsSync(manifest))
                 continue;
             any = true;
             info(`[scan-packages] wiring ${name}`);
@@ -370,9 +211,6 @@ export function scanPackages(hqRoot, options = {}) {
         warnSink(`[scan-packages] error: ${error.message}`);
         return { status: 1 };
     }
-    // After wiring, so anything just created or repointed is present and only
-    // genuine orphans are left to reap.
-    reapOrphanedLinks(hqRoot, info, warn);
     if (!any)
         info('[scan-packages] no hq-pack manifests found in core/packages');
     return { status: 0 };

package/dist/lib/search-index/background.d.ts

@@ -1,8 +1,7 @@
 import { type StdioOptions } from 'node:child_process';
 import { type QmdProcessResult, type RunQmdOptions } from './index.js';
-import { type LoadGateDependencies } from './load-gate.js';
 export type BackgroundResult = {
-    state: 'skipped-agent' | 'skipped' | 'quiet' | 'busy' | 'deferred' | 'completed' | 'update-failed' | 'terminated';
+    state: 'skipped-agent' | 'skipped' | 'quiet' | 'busy' | 'completed' | 'update-failed' | 'terminated';
 } | {
     state: 'launched';
     pid: number;
@@ -16,8 +15,6 @@ export type BackgroundDependencies = {
     isProcessAlive: (pid: number) => boolean;
     resolveQmdBin: () => string;
     reconcileCollections: (hqRoot: string) => unknown;
-    /** Apply the per-document size cap to qmd's config before the update reads anything. */
-    applyIndexSizeLimit: (hqRoot: string) => unknown;
     runQmd: (args: string[], options?: RunQmdOptions) => QmdProcessResult;
     spawnWorker: (options: {
         logPath: string;
@@ -28,9 +25,6 @@ export type BackgroundDependencies = {
     /** Test seams for signal delivery; production uses the real process. */
     processEvents?: Pick<NodeJS.Process, 'once'>;
     exit?: (code: number) => void;
-    /** Test seams for the host load gate consulted immediately before qmd embed. */
-    loadGateDependencies?: LoadGateDependencies;
-    writeStderr?: (text: string) => void;
 };
 export type BackgroundStatus = {
     lock: 'held' | 'stale' | 'free';
@@ -47,7 +41,6 @@ export type SpawnWorkerIo = {
     closeSync: (fd: number) => void;
     spawn: (command: string, args: string[], options: {
         detached: boolean;
-        windowsHide: boolean;
         stdio: StdioOptions;
     }) => {
         pid?: number;

package/dist/lib/search-index/background.js

@@ -3,9 +3,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { Sentry } from '../../sentry.js';
 import { reconcileCollections as defaultReconcileCollections, resolveQmdBin as defaultResolveQmdBin, runQmd as defaultRunQmd, } from './index.js';
-import { applyIndexSizeLimit as defaultApplyIndexSizeLimit } from './max-doc-bytes.js';
-import { acquireEmbedLock as acquireLock, installEmbedLockCleanup, lockPath, lockRoot, lockState, releaseEmbedLock as releaseLock, } from './embed-lock.js';
-import { LoadGateConfigurationError, checkEmbedLoad, defaultLoadGateDependencies, recordSuccessfulEmbed, } from './load-gate.js';
+const LOCK_NAME = 'qmd-reindex-bg.lock';
 const COMPLETE_NAME = 'qmd-reindex-bg.completed';
 function errnoInfo(error) {
     const e = error;
@@ -92,7 +90,6 @@ export function defaultSpawnWorker({ logPath, fallbackLogPath }, io = defaultSpa
         : ['ignore', opened.fd, opened.fd];
     const child = io.spawn(process.execPath, [entry, 'index', 'background', '--worker', ...logArgs], {
         detached: true,
-        windowsHide: true,
         stdio,
     });
     if (opened.fd !== null)
@@ -122,10 +119,8 @@ export function defaultBackgroundDependencies(hqRoot) {
         isProcessAlive: alive,
         resolveQmdBin: defaultResolveQmdBin,
         reconcileCollections: defaultReconcileCollections,
-        applyIndexSizeLimit: defaultApplyIndexSizeLimit,
         runQmd: defaultRunQmd,
         spawnWorker: defaultSpawnWorker,
-        writeStderr: (text) => process.stderr.write(text),
     };
 }
 /** Match the shell forwarder's hosted-agent markers before looking up qmd. */
@@ -148,6 +143,12 @@ export function isHostedAgent(env = process.env) {
         || fs.existsSync('/etc/systemd/system/hq-agent-qmd-index.service')
         || fs.existsSync('/var/lib/hq-agent');
 }
+function lockRoot(home) {
+    return path.join(home, '.hq', 'locks');
+}
+function lockPath(home) {
+    return path.join(lockRoot(home), LOCK_NAME);
+}
 function completionPath(home) {
     return path.join(lockRoot(home), COMPLETE_NAME);
 }
@@ -162,6 +163,16 @@ function parseFields(file) {
         return undefined;
     }
 }
+function readOwner(directory) {
+    const fields = parseFields(path.join(directory, 'owner'));
+    if (!fields || !/^\d+$/.test(fields.pid ?? '') || !/^\d+$/.test(fields.ts ?? '') || !/^[A-Za-z0-9._-]+$/.test(fields.nonce ?? ''))
+        return undefined;
+    return { pid: Number(fields.pid), ts: Number(fields.ts), nonce: fields.nonce };
+}
+function graceSeconds(dependencies) {
+    const value = dependencies.env.QMD_HANDOFF_LOCK_GRACE_SEC;
+    return value && /^\d+$/.test(value) ? Number(value) : 5;
+}
 function dedupeSeconds(dependencies) {
     const value = dependencies.env.QMD_HANDOFF_DEDUPE_SEC;
     return value && /^\d+$/.test(value) ? Number(value) : 90;
@@ -184,7 +195,187 @@ function writeCompletion(home, dependencies) {
         // Completion is a best-effort dedupe hint, never a worker failure.
     }
 }
+function isOwnerlessLockWithinGrace(directory, dependencies) {
+    try {
+        const age = Math.max(0, dependencies.now() - Math.floor(fs.statSync(directory).mtimeMs / 1_000));
+        return age < graceSeconds(dependencies);
+    }
+    catch {
+        return true;
+    }
+}
+function lockState(directory, dependencies) {
+    if (!fs.existsSync(directory))
+        return 'free';
+    const owner = readOwner(directory);
+    if (owner)
+        return dependencies.isProcessAlive(owner.pid) ? 'held' : 'stale';
+    return isOwnerlessLockWithinGrace(directory, dependencies) ? 'held' : 'stale';
+}
+function generation(directory) {
+    const owner = readOwner(directory);
+    if (owner)
+        return owner.nonce;
+    if (!fs.existsSync(directory))
+        return undefined;
+    return 'empty';
+}
+function removeDirectoryIfEmpty(directory) {
+    try {
+        fs.rmdirSync(directory);
+    }
+    catch { /* another claimant owns it, or it is already gone */ }
+}
+function claimWithinGrace(directory, dependencies) {
+    try {
+        const age = Math.max(0, dependencies.now() - Math.floor(fs.statSync(directory).mtimeMs / 1_000));
+        return age < Math.max(5, graceSeconds(dependencies));
+    }
+    catch {
+        return true;
+    }
+}
+function acquireClaim(home, observedGeneration, dependencies) {
+    const claim = path.join(lockRoot(home), `qmd-reindex-bg.claim.${observedGeneration}`);
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        try {
+            fs.mkdirSync(claim);
+        }
+        catch {
+            if (attempt === 1 || !recoverAbandonedClaim(claim, dependencies))
+                return undefined;
+            continue;
+        }
+        const claimant = path.join(claim, `c.${dependencies.pid}.${dependencies.random()}`);
+        try {
+            fs.mkdirSync(claimant);
+            // Test-only deterministic failure inject (unset in production) — shell
+            // parity with the script's claimant write_owner_record injection.
+            if (dependencies.env.QMD_FORCE_CLAIMANT_WRITE_FAIL)
+                throw new Error('forced claimant write failure');
+            fs.writeFileSync(path.join(claimant, 'owner'), `pid=${dependencies.pid}\nts=${dependencies.now()}\n`);
+            return { claim, claimant };
+        }
+        catch {
+            fs.rmSync(claimant, { recursive: true, force: true });
+            removeDirectoryIfEmpty(claim);
+            return undefined;
+        }
+    }
+    return undefined;
+}
+/**
+ * Reclaim only exact dead claimant names, then remove the claim directory if
+ * empty. This mirrors the shell's no-fixed-path-reclaim rule: a peer that has
+ * recreated claim.G with a new marker makes rmdir fail and wins the race.
+ */
+function recoverAbandonedClaim(claim, dependencies) {
+    let entries;
+    try {
+        entries = fs.readdirSync(claim, { withFileTypes: true });
+    }
+    catch {
+        return true;
+    }
+    for (const entry of entries.filter((entry) => entry.name.startsWith('c.'))) {
+        const marker = path.join(claim, entry.name);
+        const fields = parseFields(path.join(marker, 'owner'));
+        const pid = fields && /^\d+$/.test(fields.pid ?? '') ? Number(fields.pid) : undefined;
+        if (pid !== undefined && dependencies.isProcessAlive(pid))
+            return false;
+        if (pid === undefined && claimWithinGrace(claim, dependencies))
+            return false;
+        const abandoned = `${claim}.stale-claim.${dependencies.pid}.${dependencies.random()}`;
+        try {
+            fs.renameSync(marker, abandoned);
+            fs.rmSync(abandoned, { recursive: true, force: true });
+        }
+        catch {
+            return false;
+        }
+    }
+    if (entries.length === 0 && claimWithinGrace(claim, dependencies))
+        return false;
+    removeDirectoryIfEmpty(claim);
+    return !fs.existsSync(claim);
+}
+function createAndPublishLock(home, dependencies) {
+    const directory = lockPath(home);
+    try {
+        fs.mkdirSync(directory);
+    }
+    catch {
+        return false;
+    }
+    const marker = path.join(directory, `acq.${dependencies.pid}.${dependencies.random()}`);
+    try {
+        fs.mkdirSync(marker);
+    }
+    catch {
+        removeDirectoryIfEmpty(directory);
+        return false;
+    }
+    const nonce = `${dependencies.pid}.${dependencies.random()}`;
+    const ownerFile = path.join(directory, 'owner');
+    const temporary = path.join(directory, `.owner.tmp.${dependencies.pid}.${dependencies.random()}`);
+    try {
+        // Test-only deterministic failure inject (unset in production) — shell
+        // parity: the script's write_owner_record honored the same variable.
+        if (dependencies.env.QMD_FORCE_OWNER_WRITE_FAIL)
+            throw new Error('forced owner write failure');
+        fs.writeFileSync(temporary, `pid=${dependencies.pid}\nts=${dependencies.now()}\nnonce=${nonce}\n`);
+        fs.renameSync(temporary, ownerFile);
+        dependencies.afterOwnerPublish?.(ownerFile);
+        const verified = readOwner(directory);
+        if (!verified || verified.pid !== dependencies.pid || verified.nonce !== nonce)
+            throw new Error('owner publish verification failed');
+        fs.rmSync(marker, { recursive: true, force: true });
+        return true;
+    }
+    catch {
+        // The marker identifies only the directory this process created.  Do not
+        // recursively remove the fixed lock path after a failed publication.
+        fs.rmSync(marker, { recursive: true, force: true });
+        removeDirectoryIfEmpty(directory);
+        return false;
+    }
+}
+function claimAndReclaim(home, dependencies) {
+    const directory = lockPath(home);
+    const observedGeneration = generation(directory);
+    if (!observedGeneration || lockState(directory, dependencies) !== 'stale')
+        return false;
+    const acquired = acquireClaim(home, observedGeneration, dependencies);
+    if (!acquired)
+        return false;
+    try {
+        // Generation fencing: only move exactly the stale generation we observed.
+        if (generation(directory) !== observedGeneration || lockState(directory, dependencies) !== 'stale')
+            return false;
+        const abandoned = `${directory}.stale.${dependencies.pid}.${dependencies.random()}`;
+        fs.renameSync(directory, abandoned);
+        fs.rmSync(abandoned, { recursive: true, force: true });
+        return createAndPublishLock(home, dependencies);
+    }
+    catch {
+        return false;
+    }
+    finally {
+        fs.rmSync(acquired.claimant, { recursive: true, force: true });
+        removeDirectoryIfEmpty(acquired.claim);
+    }
+}
+function acquireLock(home, dependencies) {
+    fs.mkdirSync(lockRoot(home), { recursive: true });
+    return createAndPublishLock(home, dependencies) || claimAndReclaim(home, dependencies);
+}
+function releaseLock(home, dependencies) {
+    const directory = lockPath(home);
+    if (readOwner(directory)?.pid === dependencies.pid)
+        fs.rmSync(directory, { recursive: true, force: true });
+}
 export function installWorkerCleanup(cleanup, processEvents = process, exit = () => undefined) {
+    processEvents.once('exit', cleanup);
     // Unlike Bash, Node cannot turn a SIGKILL or an already-defaulted signal into
     // catchable cleanup. SIGINT/SIGTERM/SIGHUP are registered here (the shell
     // worker trapped `INT TERM HUP`; a detached worker's controlling terminal
@@ -192,7 +383,9 @@ export function installWorkerCleanup(cleanup, processEvents = process, exit = ()
     // process without releasing the lock) and the CLI's normal process exit then
     // runs the same idempotent owner release. Exiting prevents a synchronous
     // pipeline from continuing after it has released ownership.
-    installEmbedLockCleanup(cleanup, processEvents, exit);
+    processEvents.once('SIGINT', () => { cleanup(); exit(0); });
+    processEvents.once('SIGTERM', () => { cleanup(); exit(0); });
+    processEvents.once('SIGHUP', () => { cleanup(); exit(0); });
 }
 function workerLogPath(env) {
     return env.QMD_REINDEX_LOG
@@ -227,21 +420,6 @@ function capWorkerLog(logPath, env) {
 function stepOutput(result) {
     return `${result.stdout ?? ''}${result.stderr ?? ''}`;
 }
-/**
- * One worker-log line summarising the size cap, so an operator reading the log
- * can see WHY a file stopped being indexed. Shaped defensively because the
- * dependency is typed `unknown` at the seam.
- */
-function sizeLimitOutput(result) {
-    const r = result;
-    if (typeof r?.maxBytes !== 'number')
-        return '';
-    if (r.maxBytes === 0)
-        return '[qmd-reindex-bg] size cap disabled\n';
-    const collections = r.collections ?? [];
-    const files = collections.reduce((total, collection) => total + collection.ignored.length, 0);
-    return `[qmd-reindex-bg] size cap ${r.maxBytes}B — ${files} file(s) skipped across ${collections.length} collection(s)\n`;
-}
 function errorOutput(error) {
     const e = error;
     return `${e.stdout ?? ''}${e.stderr ?? ''}` || (e.message ?? '');
@@ -322,17 +500,6 @@ export async function runBackgroundWorker(dependencies) {
             // The shell worker has no collection-registration step. Keep this #306
             // integration best-effort so it cannot suppress a later index update.
         }
-        // The size cap rewrites qmd's ignore lists, so it MUST land before the
-        // update below — an oversized file is skipped at glob time or not at all.
-        // Best-effort for the same reason as reconciliation: a capping failure must
-        // not suppress an otherwise healthy index update.
-        try {
-            const capped = dependencies.applyIndexSizeLimit(dependencies.hqRoot);
-            appendWorkerLog(logPath, sizeLimitOutput(capped));
-        }
-        catch (error) {
-            appendWorkerLog(logPath, errorOutput(error));
-        }
         if (await signalWindow())
             return { state: 'terminated' };
         try {
@@ -353,30 +520,8 @@ export async function runBackgroundWorker(dependencies) {
         }
         if (await signalWindow())
             return { state: 'terminated' };
-        const loadGateDependencies = dependencies.loadGateDependencies ?? defaultLoadGateDependencies(dependencies.env);
-        let loadDecision;
-        try {
-            loadDecision = checkEmbedLoad(home, loadGateDependencies);
-        }
-        catch (error) {
-            if (error instanceof LoadGateConfigurationError) {
-                (dependencies.writeStderr ?? ((text) => process.stderr.write(text)))(`hq: ${error.message}\n`);
-                cleanup();
-                return { state: 'deferred' };
-            }
-            throw error;
-        }
-        if (loadDecision.action === 'skip') {
-            (dependencies.writeStderr ?? ((text) => process.stderr.write(text)))(loadDecision.notice);
-            writeCompletion(home, dependencies);
-            cleanup();
-            return { state: 'deferred' };
-        }
-        if (loadDecision.forced)
-            (dependencies.writeStderr ?? ((text) => process.stderr.write(text)))(loadDecision.notice);
         try {
             appendWorkerLog(logPath, stepOutput(dependencies.runQmd(['embed'], { cwd: dependencies.hqRoot })));
-            recordSuccessfulEmbed(home, loadGateDependencies);
         }
         catch (error) {
             appendWorkerLog(logPath, errorOutput(error)); // a completed embed attempt still permits the stamp

package/dist/lib/search-index/index.d.ts

@@ -11,7 +11,6 @@ export type QmdProcessResult = {
      */
     signal?: NodeJS.Signals | string | null;
 };
-export type QmdUpdateEntryPath = 'index-sync';
 export type QmdProcessRunner = (bin: string, args: string[], options: {
     cwd?: string;
     env?: NodeJS.ProcessEnv;
@@ -114,10 +113,6 @@ export declare class QmdExitError extends Error {
     readonly stdout: string;
     readonly stderr: string;
     name: string;
-    /** Safe route labels for telemetry; raw qmd streams remain local to the error. */
-    entryPath?: QmdUpdateEntryPath;
-    /** Present only when the invoked executable is the bundled qmd. */
-    qmdVersion?: string;
     constructor(message: string, args: string[], status: number | null, stdout: string, stderr: string);
 }
 export declare class QmdCollectionMissingError extends QmdExitError {
@@ -380,7 +375,6 @@ export declare function lastQmdStoreEnsureOutcome(): QmdStoreEnsureOutcome | und
  * An upstream-contract test pins this rule to the INSTALLED qmd so a bump that
  * changes it turns CI red instead of silently restoring the noise.
  */
-export declare function resolveQmdHome(env?: NodeJS.ProcessEnv): string;
 export declare function resolveQmdStoreDir(env?: NodeJS.ProcessEnv, cwd?: string): string;
 export type EnsureQmdStoreDirOptions = {
     /**
@@ -512,8 +506,6 @@ export type ResolveQmdInvocationOptions = {
 export declare function resolveQmdInvocation(options?: ResolveQmdInvocationOptions): QmdInvocation;
 export type RunQmdOptions = {
     bin?: string;
-    /** Source of an update failure, used only for bounded Sentry tags. */
-    entryPath?: QmdUpdateEntryPath;
     cwd?: string;
     env?: NodeJS.ProcessEnv;
     runner?: QmdProcessRunner;
@@ -544,14 +536,10 @@ export declare function deriveCollections(hqRoot: string): SearchCollection[];
 export type ReconcileCollectionsOptions = {
     bin?: string;
     runner?: QmdProcessRunner;
-    /** Test seam for the default-off collection-path repair rollout. */
-    repairPathDrift?: boolean;
 };
 /**
  * Register expected collections that qmd does not yet know about, returning the
  * collections this call actually created (a `collection add` that exited 0).
- * When the default-off hq-flags rollout is enabled, it also replaces a registered
- * collection whose path matches a known prior HQ-managed layout.
  *
  * A same-name idempotent duplicate — qmd already owns the exact requested name
  * in its YAML config (`Collection '<name>' already exists.`), while the