@indigoai-us/hq-cli 5.345.23 → 5.345.25

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [5.345.25] — 2026-10-06
+- Route qmd post-sync indexing and ontology README drift through isolated fast handlers; cover all rebuild-index targets in fast-route parity and benchmarks.
+
+- Keep native register-project and ontology source-worklist commands aligned with staging behavior for Board identifiers, DM participant audiences, and transient ACL retries.
+
+## [5.345.24] — 2026-10-06
+- Keep native core ontology, delegate-secret, share-suggestion-state, and trusted-bind behavior aligned with their scaffold scripts.
+
 ## [5.345.23] — 2026-10-06
 - Route eight additional isolated native core commands through the fast CLI entry.
 - hqd applies the runtime kill switch to new hook and MCP operations within the existing 60-second freshness bound. A local opt-out also disables the daemon, while a local opt-in cannot override an operator-off value.

package/assets/scaffold/core/scripts/ontology-garden.mjs

@@ -158,6 +158,12 @@ function listCandidates(dir) {
 
 function main() {
   const a = parseArgs(process.argv.slice(2));
+  const backrefThreshold = Number(process.env.HQ_ONTOLOGY_BACKREF_THRESHOLD || 50);
+  const backrefKeepInline = Number(process.env.HQ_ONTOLOGY_BACKREF_KEEP_INLINE || 25);
+  if (!(backrefThreshold > backrefKeepInline)) {
+    console.error(`ontology-garden: BACKREF_THRESHOLD (${backrefThreshold}) must be greater than BACKREF_KEEP_INLINE (${backrefKeepInline})`);
+    process.exit(1);
+  }
   const co = path.join(a.root, "companies", a.company);
   if (!fs.existsSync(co)) { console.error(`ontology-garden: no company ${a.company}`); process.exit(2); }
   const ont = path.join(co, "ontology"), sig = path.join(co, "signals");

package/assets/scaffold/core/scripts/ontology-source-worklist.sh

@@ -203,8 +203,18 @@ for f in "$D"/*.md; do
       # test/sources/inbound/slack-personal-dm.test.ts.
       [ -n "$aud" ] || aud="$(participant_ids "$f" resolved_participants | grep -E '@|^(prs|agt)_' | paste -sd, -)"
       if [ -z "$aud" ]; then
-        aud="$("$HQ" files --company "$co" acl "$rel" --json 2>/dev/null \
-          | jq -r '[.direct[]? | select(.granteeType=="person" or .granteeType=="email" or .granteeType=="agent") | select(.permission=="read" or .permission=="write" or .permission=="admin") | .granteeId] | unique | join(",")' 2>/dev/null)"
+        # A transient ACL or jq failure must not turn a source into a durable
+        # no-audience skip. Retry once, while treating valid empty ACL output as
+        # a completed lookup that needs no retry.
+        for attempt in 1 2; do
+          acl_output=""
+          if acl_output="$("$HQ" files --company "$co" acl "$rel" --json 2>/dev/null \
+            | jq -r '[.direct[]? | select(.granteeType=="person" or .granteeType=="email" or .granteeType=="agent") | select(.permission=="read" or .permission=="write" or .permission=="admin") | .granteeId] | unique | join(",")' 2>/dev/null)"; then
+            aud="$acl_output"
+            break
+          fi
+          aud=""
+        done
       fi ;;
   esac
   if [ -z "$aud" ]; then

package/dist/commands/core-delegate.d.ts

@@ -41,6 +41,7 @@ export declare function requireRecord(value: unknown, property: string): JsonRec
 export declare function moveFile(source: string, target: string): void;
 export declare function writeJsonAtomically(target: string, value: unknown, siblingTemp?: boolean): void;
 export declare function delegateDiagnosticPath(argument: string): string;
+export declare function scanSecretFiles(file: string): string[] | undefined;
 /** Fast-entry adapter; family gating and shell fallback happen before import. */
 export declare function runDelegateFast(args: readonly string[], _stdin: string, cwd: string, hqRoot: string | undefined, commandName: string): number;
 /** Register the Wave 1a delegate commands and preserve the shell rollback path. */

package/dist/commands/core-delegate.js

@@ -703,7 +703,7 @@ function runRepo(args, context) {
     writeOut(`${prefix} recorded branch state (pushed=${pushed}, dirty=${dirtyLines.length} files, accessVerified=${accessVerified})\n`);
     return 0;
 }
-function scanSecretFiles(file) {
+export function scanSecretFiles(file) {
     let schema;
     try {
         schema = fs.readFileSync(file, "utf8");
@@ -715,7 +715,7 @@ function scanSecretFiles(file) {
         throw error;
     }
     return [...new Set(schema.split(/\r?\n/)
-            .filter((line) => /^[A-Za-z_][A-Za-z0-9_]*=/.test(line))
+            .filter((line) => /^[A-Z][A-Z0-9_]*(\/[A-Z][A-Z0-9_]+)*=/.test(line))
             .map((line) => line.slice(0, line.indexOf("="))))].sort();
 }
 function isRegularFile(file) {

package/dist/commands/core-ontology-native.js

@@ -397,6 +397,52 @@ function writeGardenDoc(file, fm, body, dryRun) {
     fs.writeFileSync(`${file}.tmp`, lines.join("\n"));
     fs.renameSync(`${file}.tmp`, file);
 }
+const BACKREF_SUMMARY_MARKER = "<!-- backref-archive -->";
+function readGardenArchiveIndex(file) {
+    if (!fs.existsSync(file))
+        return { signalIds: [], unreadable: false, stderr: "" };
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed) && Array.isArray(parsed.signalIds)) {
+            return {
+                signalIds: (parsed.signalIds).filter((item) => typeof item === "string"),
+                unreadable: false,
+                stderr: "",
+            };
+        }
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        return { signalIds: [], unreadable: true, stderr: `ontology-garden: archive index unreadable at ${file}: ${detail}; skipping compaction\n` };
+    }
+    return { signalIds: [], unreadable: true, stderr: "" };
+}
+function compactGardenFactBody(body, slug, threshold, keepInline, archivedTotalBefore) {
+    const lines = body.split("\n").map((line) => line.trimEnd()).filter((line) => line.length > 0);
+    const isBackref = (line) => /^- \[[a-z_]+\] .+ \(signal [0-9a-f]{12}\)\s*$/.test(line);
+    const backrefLines = lines.filter(isBackref);
+    const other = lines.filter((line) => !isBackref(line) && !line.includes(BACKREF_SUMMARY_MARKER));
+    if (backrefLines.length <= threshold)
+        return { body, archivedLines: [], archivedIds: [], stamp: "", changed: false };
+    const archiveCount = backrefLines.length - keepInline;
+    const archivedLines = backrefLines.slice(0, archiveCount);
+    const inlineLines = backrefLines.slice(archiveCount);
+    const archivedIds = archivedLines.map((line) => line.match(/\(signal ([0-9a-f]{12})\)$/)?.[1]).filter((id) => Boolean(id));
+    const total = archivedTotalBefore + archivedLines.length;
+    const stamp = new Date().toISOString().slice(0, 7);
+    const summary = `- ${BACKREF_SUMMARY_MARKER} _${total} older mention${total === 1 ? "" : "s"} archived in [history](./${slug}.history/${stamp}.md)_`;
+    return { body: [summary, ...other, ...inlineLines].join("\n"), archivedLines, archivedIds, stamp, changed: true };
+}
+function appendGardenArchive(file, isoDate, lines, dryRun) {
+    if (dryRun)
+        return;
+    const batch = `\n<!-- archived ${isoDate} -->\n${lines.join("\n")}\n`;
+    const previous = fs.existsSync(file) ? fs.readFileSync(file, "utf8").replace(/\s+$/, "") : "";
+    const next = previous ? `${previous}\n${batch}` : `# Back-reference archive\n${batch}`;
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(`${file}.tmp`, next);
+    fs.renameSync(`${file}.tmp`, file);
+}
 const slugify = (value) => value.toLowerCase().normalize("NFKD").replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-+|-+$/g, "").slice(0, 80);
 const isoNow = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
 function listCandidates(directory) {
@@ -436,6 +482,11 @@ export function gardenCommand(args, defaultRoot) {
     }
     if (!company)
         return err(2, "usage: ontology-garden.mjs --company <co> [--hq-root <p>] [--dry-run] [--json]\n");
+    const threshold = Number(process.env.HQ_ONTOLOGY_BACKREF_THRESHOLD || 50);
+    const keepInline = Number(process.env.HQ_ONTOLOGY_BACKREF_KEEP_INLINE || 25);
+    if (!(threshold > keepInline)) {
+        return err(1, `ontology-garden: BACKREF_THRESHOLD (${threshold}) must be greater than BACKREF_KEEP_INLINE (${keepInline})\n`);
+    }
     const hqRoot = root || process.env.HQ_ROOT || defaultRoot;
     const companyDir = path.join(hqRoot, "companies", company);
     if (!fs.existsSync(companyDir))
@@ -445,6 +496,7 @@ export function gardenCommand(args, defaultRoot) {
     const report = { company, entities_created: 0, entities_updated: 0, signals_promoted: 0, facts_written: 0, rejected: 0, candidates_processed: 0, dry_run: dryRun };
     const rejected = [];
     const moves = [];
+    let stderr = "";
     const entities = new Map();
     const nameIndex = new Map();
     const entityDirectory = path.join(ontology, "entities");
@@ -563,8 +615,24 @@ export function gardenCommand(args, defaultRoot) {
                 const previous = fs.existsSync(factFile)
                     ? readGardenDoc(factFile)
                     : { fm: { entity: slug, type: entity.type, audience_key: key }, body: "" };
-                if (!previous.body.includes(`signal ${id.slice(0, 12)}`)) {
-                    writeGardenDoc(factFile, previous.fm, [previous.body, line].filter(Boolean).join("\n"), dryRun);
+                const indexFile = path.join(path.dirname(factFile), `${slug}.history`, "_index.json");
+                const archiveIndex = readGardenArchiveIndex(indexFile);
+                stderr += archiveIndex.stderr;
+                const signalId = id.slice(0, 12);
+                if (!previous.body.includes(`signal ${signalId}`) && !archiveIndex.signalIds.includes(signalId)) {
+                    let nextBody = [previous.body, line].filter(Boolean).join("\n");
+                    const compact = compactGardenFactBody(nextBody, slug, threshold, keepInline, archiveIndex.signalIds.length);
+                    if (compact.changed && !archiveIndex.unreadable) {
+                        const archiveFile = path.join(path.dirname(factFile), `${slug}.history`, `${compact.stamp}.md`);
+                        appendGardenArchive(archiveFile, new Date().toISOString().slice(0, 10), compact.archivedLines, dryRun);
+                        if (!dryRun) {
+                            const nextIndex = { version: 1, signalIds: [...archiveIndex.signalIds, ...compact.archivedIds] };
+                            fs.mkdirSync(path.dirname(indexFile), { recursive: true });
+                            fs.writeFileSync(indexFile, `${JSON.stringify(nextIndex)}\n`);
+                        }
+                        nextBody = compact.body;
+                    }
+                    writeGardenDoc(factFile, previous.fm, nextBody, dryRun);
                     report.facts_written += 1;
                 }
                 if (key === "company") {
@@ -598,9 +666,9 @@ export function gardenCommand(args, defaultRoot) {
             fs.writeFileSync(path.join(ontology, ".last-run"), `${Date.now()}\n`);
         }
     }
-    return ok(json
-        ? `${JSON.stringify(report)}\n`
-        : `garden ${company}: +${report.entities_created} entities, ~${report.entities_updated} updated, +${report.signals_promoted} signals, +${report.facts_written} facts, ${report.rejected} rejected, ${report.candidates_processed} candidates${dryRun ? " (dry run)" : ""}\n`);
+    return { code: 0, stdout: json
+            ? `${JSON.stringify(report)}\n`
+            : `garden ${company}: +${report.entities_created} entities, ~${report.entities_updated} updated, +${report.signals_promoted} signals, +${report.facts_written} facts, ${report.rejected} rejected, ${report.candidates_processed} candidates${dryRun ? " (dry run)" : ""}\n`, stderr };
 }
 export function audienceGrant(args, root) {
     let company = "";
@@ -763,6 +831,77 @@ function itemList(file, field) {
     }
     return output;
 }
+function participantIds(file, field) {
+    if (!fs.existsSync(file))
+        return [];
+    const output = [];
+    let frontmatterLines = 0;
+    let inList = false;
+    let personUid = "";
+    let email = "";
+    const flush = () => {
+        if (personUid)
+            output.push(personUid);
+        else if (email)
+            output.push(email);
+        personUid = "";
+        email = "";
+    };
+    const setField = (line) => {
+        const person = line.match(/^person_uid:[\t ]*(.*)$/);
+        const mail = line.match(/^email:[\t ]*(.*)$/);
+        const value = (person?.[1] ?? mail?.[1] ?? "").replace(/["']/g, "").replace(/^[\t ]+|[\t ]+$/g, "");
+        if (person && value)
+            personUid = value;
+        if (mail && value)
+            email = value;
+    };
+    for (const rawLine of fs.readFileSync(file, "utf8").split("\n")) {
+        const line = rawLine.replace(/\r$/, "");
+        if (line === "---") {
+            frontmatterLines += 1;
+            if (frontmatterLines === 2) {
+                if (inList)
+                    flush();
+                break;
+            }
+            continue;
+        }
+        if (frontmatterLines !== 1)
+            continue;
+        if (line.startsWith(`${field}:`)) {
+            inList = true;
+            continue;
+        }
+        if (!inList)
+            continue;
+        if (/^[^\t -]/.test(line)) {
+            flush();
+            inList = false;
+            continue;
+        }
+        const dash = line.match(/^[\t ]*-[\t ]+(.*)$/);
+        if (dash) {
+            flush();
+            let value = dash[1];
+            if (value.startsWith("{")) {
+                value = value.replace(/[{}"']/g, "");
+                for (const fieldValue of value.split(",")) {
+                    const separator = fieldValue.indexOf(":");
+                    if (separator < 0)
+                        continue;
+                    setField(`${fieldValue.slice(0, separator).trim()}:${fieldValue.slice(separator + 1)}`);
+                }
+                flush();
+                continue;
+            }
+            setField(value);
+            continue;
+        }
+        setField(line.replace(/^[\t ]+/, ""));
+    }
+    return output;
+}
 export function worklistCommand(args, root) {
     let company = "";
     let channel = "";
@@ -944,22 +1083,33 @@ export function worklistCommand(args, root) {
             audience = itemList(file, "audience").join(",");
             if (!audience)
                 audience = itemList(file, "attendees").filter((value) => /@|^(prs|agt)_/.test(value)).join(",");
+            if (!audience)
+                audience = participantIds(file, "resolved_participants").filter((value) => /@|^(prs|agt)_/.test(value)).join(",");
             if (!audience) {
-                const acl = runHq(["files", "--company", company, "acl", relative, "--json"]);
-                try {
-                    const payload = JSON.parse(acl.stdout);
-                    const principals = (payload.direct ?? []).filter((value) => {
-                        if (!value || typeof value !== "object")
-                            return false;
-                        const row = value;
-                        return ["person", "email", "agent"].includes(String(row.granteeType))
-                            && ["read", "write", "admin"].includes(String(row.permission));
-                    }).map((value) => String(value.granteeId ?? "")).sort(byteSort);
-                    audience = [...new Set(principals)].join(",");
-                }
-                catch (parseError) {
-                    // jq emits no stdout or stderr for malformed ACL JSON in this pipeline.
-                    void parseError;
+                for (let attempt = 0; attempt < 2; attempt += 1) {
+                    const acl = runHq(["files", "--company", company, "acl", relative, "--json"]);
+                    if (acl.status !== 0)
+                        continue;
+                    try {
+                        const payload = JSON.parse(acl.stdout);
+                        const direct = payload && typeof payload === "object" && "direct" in payload
+                            ? payload.direct
+                            : undefined;
+                        if (!Array.isArray(direct))
+                            throw new Error("ACL direct grants are not an array");
+                        const principals = direct.filter((value) => {
+                            if (!value || typeof value !== "object")
+                                return false;
+                            const row = value;
+                            return ["person", "email", "agent"].includes(String(row.granteeType))
+                                && ["read", "write", "admin"].includes(String(row.permission));
+                        }).map((value) => String(value.granteeId ?? "")).sort(byteSort);
+                        audience = [...new Set(principals)].join(",");
+                        break;
+                    }
+                    catch {
+                        // The shell suppresses jq diagnostics and retries a failed ACL parse.
+                    }
                 }
             }
         }
@@ -972,7 +1122,9 @@ export function worklistCommand(args, root) {
         const key = shellSubstitution(audienceKey(audience).stdout);
         output.push(`${JSON.stringify({ file: relative, audience_key: key, audience: audience.split(",") })}\n`);
     }
-    return ok(output.join(""));
+    const stdout = output.join("");
+    // Git Bash captures jq.exe's record terminators as CRLF; preserve those bytes on Windows.
+    return ok(process.platform === "win32" ? stdout.replace(/\n/gu, "\r\n") : stdout);
 }
 export function registerCoreOntologyNativeCommands(ontology, rootFor) {
     const entries = [

package/dist/commands/core-ontology-readme-drift-fast.d.ts

@@ -0,0 +1,2 @@
+export declare function runOntologyReadmeDriftFast(args: readonly string[], _stdin: string, _cwd: string, hqRoot: string | undefined): number;
+//# sourceMappingURL=core-ontology-readme-drift-fast.d.ts.map

package/dist/commands/core-ontology-readme-drift-fast.js

@@ -0,0 +1,5 @@
+import { ontologyReadmeDrift } from "../lib/core-utils/ontology-readme-drift.js";
+export function runOntologyReadmeDriftFast(args, _stdin, _cwd, hqRoot) {
+    return ontologyReadmeDrift([...args], { root: hqRoot });
+}
+//# sourceMappingURL=core-ontology-readme-drift-fast.js.map

package/dist/commands/core-qmd-reindex-after-sync-fast.d.ts

@@ -0,0 +1,3 @@
+/** Fast adapter for the post-sync QMD entry point. Uses the same persisted flag snapshot as other native fast routes. */
+export declare function runQmdReindexAfterSyncFast(args: readonly string[], _stdin: string, cwd: string, _hqRoot?: string, _commandName?: string, hqRootArg?: string): Promise<number>;
+//# sourceMappingURL=core-qmd-reindex-after-sync-fast.d.ts.map

package/dist/commands/core-qmd-reindex-after-sync-fast.js

@@ -0,0 +1,26 @@
+import { QMD_REINDEX_STARTUP_WARNING_FLAG, qmdReindexAfterSync, } from "../lib/core-utils/qmd-reindex-after-sync.js";
+import { reconcileCollections } from "../lib/search-index/index.js";
+import { QMD_COLLECTION_PATH_REPAIR_FLAG } from "../lib/search-index/collection-path-repair-flag-constants.js";
+import { QMD_REINDEX_SINGLE_FLIGHT_FLAG } from "../lib/search-index/reindex-single-flight-flag-constants.js";
+import { fastFlagEnabled } from "../native-fast-route.js";
+/** Fast adapter for the post-sync QMD entry point. Uses the same persisted flag snapshot as other native fast routes. */
+export async function runQmdReindexAfterSyncFast(args, _stdin, cwd, _hqRoot, _commandName, hqRootArg) {
+    const [singleFlight, startupWarnings, repairCollectionPaths] = await Promise.all([
+        fastFlagEnabled(QMD_REINDEX_SINGLE_FLIGHT_FLAG, process.env, { numericEnvironmentOverride: false }),
+        fastFlagEnabled(QMD_REINDEX_STARTUP_WARNING_FLAG, process.env, { numericEnvironmentOverride: false }),
+        fastFlagEnabled(QMD_COLLECTION_PATH_REPAIR_FLAG, process.env, { numericEnvironmentOverride: false }),
+    ]);
+    // The full command adapter injects the explicit HQ root as the first positional
+    // argument when the caller supplies --hq-root. The fast route parses that
+    // global option before dispatch, so restore the same operand when the command
+    // did not receive its own path (help/unknown options and --embed-only calls).
+    const hasRootOperand = args.some((arg) => arg !== "--embed" && !arg.startsWith("--"));
+    const forwardedArgs = hasRootOperand ? [...args] : [hqRootArg ?? cwd, ...args];
+    return qmdReindexAfterSync(forwardedArgs, {
+        cwd,
+        singleFlightEnabled: () => singleFlight,
+        startupFailureWarningsEnabled: () => startupWarnings,
+        reconcile: (root, options) => reconcileCollections(root, { ...options, repairPathDrift: repairCollectionPaths }),
+    });
+}
+//# sourceMappingURL=core-qmd-reindex-after-sync-fast.js.map

package/dist/commands/core-register-project-native.js

@@ -7,7 +7,7 @@ import { serializeJqJson } from "../lib/core-utils/jq-json-serializer.js";
 import { resolveBundledAsset } from "../utils/hq-roots-core.js";
 import { buildSpawnPlan } from "../utils/windows-spawn.js";
 export const REGISTER_PROJECT_ASSET = "core/scripts/register-project.sh";
-const USAGE = "usage: register-project.sh <company> <project> | --audit <company> | --backfill <company> --only-active [--yes] | --retry-pending <company>";
+const USAGE = "usage: register-project.sh <company> <project> | --brainstorm <company> <board-project-id> | --audit <company> | --backfill <company> --only-active [--yes] | --retry-pending <company>";
 const MIN_HQ_CLI = "5.139.0";
 export function createRegisterProjectHqRunner(spawn = spawnSync) {
     return (args, options) => {
@@ -117,8 +117,20 @@ function projectRows(board) {
         return record;
     });
 }
-function matchesProject(row, id, rel) {
-    return row.id === id || row.prd_path === rel || row.mesh_project_id === id;
+function matchesProject(row, id, rel, meshProjectId = id) {
+    return row.id === id || row.prd_path === rel || row.mesh_project_id === id || row.id === meshProjectId || row.mesh_project_id === meshProjectId;
+}
+function meshProjectIdForPrd(company, project, deps) {
+    const rel = `companies/${company}/projects/${project}/prd.json`;
+    try {
+        const row = projectRows(boardData(company, boardPath(company, deps), deps)).find((item) => item.prd_path === rel || item.id === project);
+        const value = jqString(jqOr(asRecord(row)?.mesh_project_id, jqOr(asRecord(row)?.id, "")));
+        return value || project;
+    }
+    catch {
+        // The shell suppresses jq's board lookup error and falls back to the local id.
+        return project;
+    }
 }
 function atomicJqWrite(target, value, deps, initialize = false) {
     deps.fs.mkdirSync(path.dirname(target), { recursive: true });
@@ -167,12 +179,13 @@ function ensureOne(company, project, deps) {
         catch { /* legacy jq/write errors remain a failed registration */ }
         return errorResult(`hq-cli ${MIN_HQ_CLI} or newer is required; ${company}/${project} stays local until then`);
     }
+    const meshProject = meshProjectIdForPrd(company, project, deps);
     // The shell builds this argument from its raw HQ_ROOT plus POSIX separators.
     // On Git Bash that preserves a Win32 drive prefix and appends `/companies/...`.
     const hqPrd = process.platform === "win32"
         ? `${deps.root.replace(/[\\/]+$/u, "")}/companies/${company}/projects/${project}/prd.json`
         : prd;
-    const ensure = deps.runHq(["mesh", "project", "ensure", project, "--company", company, "--stories-file", hqPrd, "--json"], {
+    const ensure = deps.runHq(["mesh", "project", "ensure", meshProject, "--company", company, "--stories-file", hqPrd, "--json"], {
         cwd: deps.cwd, env: deps.env, capture: true,
     });
     if (ensure.code !== 0)
@@ -204,9 +217,9 @@ function ensureOne(company, project, deps) {
     const rows = projectRows(document);
     if (rows.some((row) => matchesProject(row, project, rel))) {
         document.projects = rows.map((row) => {
-            if (!matchesProject(row, project, rel))
+            if (!matchesProject(row, project, rel, meshProject))
                 return row;
-            const updated = { ...row, threadId: thread, channelId: channel, updated_at: now, prd_path: jqOr(row.prd_path, rel), mesh_project_id: project };
+            const updated = { ...row, threadId: thread, channelId: channel, updated_at: now, prd_path: jqOr(row.prd_path, rel), mesh_project_id: meshProject };
             delete updated.pending_registration;
             return updated;
         });
@@ -224,11 +237,62 @@ function ensureOne(company, project, deps) {
         return errorResult("registration incomplete: board.json write failed");
     }
     const written = boardData(company, board, deps);
-    const verified = projectRows(written).some((row) => matchesProject(row, project, rel) && row.threadId === thread && row.channelId === channel);
+    const verified = projectRows(written).some((row) => matchesProject(row, project, rel, meshProject) && row.mesh_project_id === meshProject && row.threadId === thread && row.channelId === channel);
     if (!verified)
         return errorResult(`registration incomplete: board.json entry for ${project} did not verify`);
     return { code: 0, stdout: `registered ${company}/${project} thread=${thread} channel=${channel}\n`, stderr: "" };
 }
+function registerBrainstorm(company, project, deps) {
+    if (!companyUid(company, deps))
+        return errorResult(`no company uid for ${company} (set HQ_COMPANY_UID, companies/${company}/.company-uid, or manifest cloud_uid)`);
+    const board = boardPath(company, deps);
+    if (!deps.fs.existsSync(board))
+        return errorResult(`registration incomplete: missing ${board}`);
+    const document = boardData(company, board, deps);
+    const row = projectRows(document).find((item) => item.id === project || item.mesh_project_id === project);
+    const title = jqString(jqOr(asRecord(row)?.title, ""));
+    const description = jqString(jqOr(asRecord(row)?.description, ""));
+    if (!title)
+        return errorResult(`registration incomplete: missing local Board project ${company}/${project}`);
+    const set = deps.runHq(["mesh", "project", "set", project, "--company", company, "--name", title, "--description", description, "--create", "--json"], {
+        cwd: deps.cwd, env: deps.env, capture: true,
+    });
+    if (set.code !== 0)
+        return errorResult(`registration incomplete: hq mesh project set failed for ${company}/${project}`);
+    let result;
+    try {
+        result = asRecord(JSON.parse(set.stdout));
+    }
+    catch {
+        return errorResult("registration incomplete: project set output missing threadId");
+    }
+    const registration = asRecord(result?.registration);
+    const thread = jqString(jqOr(registration?.threadId, jqOr(result?.threadId, "")));
+    if (!thread)
+        return errorResult("registration incomplete: project set output missing threadId");
+    const channel = jqString(jqOr(registration?.channelId, jqOr(result?.channelId, "")));
+    if (!channel)
+        return errorResult("registration incomplete: project set output missing channelId");
+    const now = timestamp(deps);
+    const rows = projectRows(document);
+    document.projects = rows.map((item) => item.id === project || item.mesh_project_id === project
+        ? { ...item, threadId: thread, channelId: channel, mesh_project_id: project, mesh_registration_prompt_state: "accepted", updated_at: now }
+        : item);
+    for (const updated of document.projects) {
+        if (updated.id === project || updated.mesh_project_id === project)
+            delete updated.pending_registration;
+    }
+    try {
+        atomicJqWrite(board, document, deps);
+    }
+    catch {
+        return errorResult("registration incomplete: local Board registration did not verify");
+    }
+    const verified = projectRows(boardData(company, board, deps)).some((item) => (item.id === project || item.mesh_project_id === project) && item.threadId === thread && item.channelId === channel);
+    if (!verified)
+        return errorResult("registration incomplete: local Board registration did not verify");
+    return { code: 0, stdout: `registered ${company}/${project} thread=${thread} channel=${channel}\n`, stderr: "" };
+}
 function audit(company, deps) {
     if (!company)
         return errorResult("usage: register-project.sh --audit <company>");
@@ -253,7 +317,10 @@ function audit(company, deps) {
                 stderr += `no company uid for ${company} (set HQ_COMPANY_UID, companies/${company}/.company-uid, or manifest cloud_uid)\n`;
                 return true;
             }
-            return !deps.fs.existsSync(path.join(deps.env.HOME || os.homedir(), ".hq/work-mesh/cache/projects", uid, `${project}.json`));
+            const cache = path.join(deps.env.HOME || os.homedir(), ".hq/work-mesh/cache/projects", uid);
+            const meshProject = meshProjectIdForPrd(company, project, deps);
+            return !deps.fs.existsSync(path.join(cache, `${meshProject}.json`))
+                && !deps.fs.existsSync(path.join(cache, `${project}.json`));
         }
         catch {
             return false;
@@ -360,6 +427,11 @@ function retryPending(company, deps) {
 export function runRegisterProject(args, deps) {
     try {
         const [mode, arg1, ...rest] = args;
+        if (mode === "--brainstorm") {
+            if (args.length !== 3)
+                return errorResult("usage: register-project.sh --brainstorm <company> <board-project-id>");
+            return registerBrainstorm(arg1 ?? "", rest[0] ?? "", deps);
+        }
         if (mode === "--audit")
             return audit(arg1 ?? "", deps);
         if (mode === "--backfill")

package/dist/commands/core-share-suggestion-state-native.js

@@ -209,8 +209,14 @@ export function runShareSuggestionState(args, stdin, deps) {
         try {
             return JSON.parse(f.readFileSync(file, "utf8"));
         }
-        catch {
-            return fallback;
+        catch (cause) {
+            const failure = new Error("share-suggestion-state JSON read failed");
+            failure.name = "ShareSuggestionStateReadError";
+            Object.assign(failure, {
+                shareSuggestionStateReadPath: file,
+                shareSuggestionStateCauseName: cause instanceof Error && cause.name ? cause.name : "Error",
+            });
+            throw failure;
         }
     };
     const writeJson = (file, value) => {
@@ -454,6 +460,17 @@ export function runShareSuggestionState(args, stdin, deps) {
         return { code: 0, stdout: "", stderr: "" };
     }
     catch (error) {
+        if (error instanceof Error && "shareSuggestionStateReadPath" in error) {
+            const failure = error;
+            const readPath = platform === "win32"
+                ? path.win32.resolve(failure.shareSuggestionStateReadPath).replaceAll("\\", "/")
+                : failure.shareSuggestionStateReadPath;
+            return {
+                code: 3,
+                stdout: "",
+                stderr: `share-suggestion-state: unable to read ${readPath} (${failure.shareSuggestionStateCauseName})\n`,
+            };
+        }
         const detail = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
         return { code: 0, stdout: "", stderr: `share-suggestion-state: internal error\n${detail}\n` };
     }

package/dist/commands/core-work-mesh-bind-trusted-native.d.ts

@@ -15,6 +15,7 @@ export type WorkMeshBindDeps = {
         stdout: string;
         stderr: string;
     };
+    daemonWarningEnabled: boolean;
     runHqSession: (root: string, args: string[], env: NodeJS.ProcessEnv) => {
         code: number;
         stdout: string;
@@ -25,8 +26,27 @@ export type WorkMeshBindDeps = {
     tmpDir: string;
     ulid: (now: Date) => string;
 };
-export declare const createWorkMeshBindDeps: (root: string, cwd: string, env: NodeJS.ProcessEnv, now: () => Date) => WorkMeshBindDeps;
+export declare const createWorkMeshBindDeps: (root: string, cwd: string, env: NodeJS.ProcessEnv, now: () => Date, daemonWarningEnabled?: boolean) => WorkMeshBindDeps;
+type DetachedSpawnOptions = {
+    cwd: string;
+    root: string;
+    env: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    existsSync?: (candidate: string) => boolean;
+    spawnProcess?: (command: string, args: string[], options: {
+        cwd: string;
+        env: NodeJS.ProcessEnv;
+        detached: boolean;
+        stdio: "ignore";
+        shell: boolean;
+        windowsVerbatimArguments?: boolean;
+    }) => {
+        unref: () => void;
+    };
+};
+export declare function spawnWorkMeshHqDetached(args: string[], options: DetachedSpawnOptions): void;
 export declare function resolveWorkMeshBindSessionId(root: string, env: NodeJS.ProcessEnv, fileSystem?: typeof fs): string;
 export declare function runWorkMeshBindTrusted(args: string[], deps: WorkMeshBindDeps): UtilityOutput;
 export declare function registerCoreWorkMeshBindTrustedNative(core: Command): void;
+export {};
 //# sourceMappingURL=core-work-mesh-bind-trusted-native.d.ts.map

package/dist/commands/core-work-mesh-bind-trusted-native.js

@@ -2,10 +2,13 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { spawn, spawnSync } from "node:child_process";
+import { resolveWindowsExecutable } from "../lib/bot/runtime/windows.js";
 import { generateUlid } from "../lib/mesh/live/ulid.js";
 import { resolveLiveRoot } from "../utils/hq-roots.js";
+import { planResolvedCommandSpawn } from "../utils/windows-spawn.js";
 import { registerNativeUtility } from "./core-native-utilities.js";
 export const WORK_MESH_BIND_TRUSTED_ASSET = "core/scripts/work-mesh-live-bind-trusted.sh";
+const WORK_MESH_DAEMON_WARNING_FLAG = "hooks.work-mesh-daemon-not-loaded-warning";
 export const WORK_MESH_BIND_TRUSTED_HELP = `hq-core: public
 US-011 — write session meta + reconcile with observation.trustedContext.
 No --trusted CLI flag in hq-cli; trusted bind is the observation field.
@@ -14,21 +17,61 @@ set -euo pipefail
 ROOT="\${HQ_ROOT:-\${CLAUDE_PROJECT_DIR:-}}"
 if [ -z "$ROOT" ]; then
 `;
-export const createWorkMeshBindDeps = (root, cwd, env, now) => ({
+export const createWorkMeshBindDeps = (root, cwd, env, now, daemonWarningEnabled = false) => ({
     root, cwd, env, now, fs, pid: process.pid, tmpDir: env.TMPDIR || "/tmp", ulid: (date) => generateUlid(date.getTime()),
+    daemonWarningEnabled: daemonWarningEnabled
+        && Boolean(env.HQ_FLAGS_API_URL?.trim())
+        && /^cmp_[A-Za-z0-9]{3,128}$/.test(env.HQ_COMPANY_UID?.trim() ?? ""),
     runHq: (args, childEnv) => {
-        const result = spawnSync("hq", args, { cwd, env: { ...childEnv, HQ_ROOT: root }, encoding: "utf8" });
+        const executable = "hq";
+        const resolvedExecutable = process.platform === "win32"
+            ? resolveWindowsExecutable(executable, childEnv, (candidate) => {
+                try {
+                    return fs.statSync(candidate).isFile();
+                }
+                catch {
+                    return false;
+                }
+            }, cwd) ?? executable
+            : executable;
+        const plan = planResolvedCommandSpawn(resolvedExecutable, args, childEnv);
+        const result = spawnSync(plan.cmd, plan.args, {
+            cwd,
+            env: { ...childEnv, HQ_ROOT: root },
+            encoding: "utf8",
+            shell: plan.shell,
+            ...(plan.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}),
+            timeout: 2_000,
+        });
         return { code: result.status ?? 127, stdout: result.stdout ?? "", stderr: result.stderr ?? (result.error ? `${result.error.message}\n` : "") };
     },
     runHqSession: (scriptRoot, args, childEnv) => {
         const result = spawnSync("bash", [path.join(scriptRoot, "core/scripts/hq-session.sh"), ...args], { cwd, env: childEnv, encoding: "utf8" });
         return { code: result.status ?? 127, stdout: result.stdout ?? "", stderr: result.stderr ?? (result.error ? `${result.error.message}\n` : "") };
     },
-    spawnHq: (args, childEnv) => {
-        const child = spawn("hq", args, { cwd, env: { ...childEnv, HQ_ROOT: root }, detached: true, stdio: "ignore" });
-        child.unref();
-    },
+    spawnHq: (args, childEnv) => spawnWorkMeshHqDetached(args, {
+        cwd,
+        root,
+        env: childEnv,
+    }),
 });
+export function spawnWorkMeshHqDetached(args, options) {
+    const platform = options.platform ?? process.platform;
+    const childEnv = { ...options.env, HQ_ROOT: options.root };
+    const executable = platform === "win32"
+        ? resolveWindowsExecutable("hq", childEnv, options.existsSync ?? fs.existsSync, options.cwd) ?? "hq"
+        : "hq";
+    const plan = planResolvedCommandSpawn(executable, args, childEnv, platform);
+    const child = (options.spawnProcess ?? spawn)(plan.cmd, plan.args, {
+        cwd: options.cwd,
+        env: childEnv,
+        detached: true,
+        stdio: "ignore",
+        shell: plan.shell,
+        ...(plan.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}),
+    });
+    child.unref();
+}
 export function resolveWorkMeshBindSessionId(root, env, fileSystem = fs) {
     for (const key of ["HQ_SESSION_ID", "CLAUDE_CODE_SESSION_ID", "CLAUDE_SESSION_ID", "CODEX_SESSION_ID", "CODEX_THREAD_ID"]) {
         const value = (env[key] ?? "").replace(/\s/g, "");
@@ -44,6 +87,16 @@ export function resolveWorkMeshBindSessionId(root, env, fileSystem = fs) {
     }
 }
 function hasExecutable(deps, command) {
+    if (process.platform === "win32") {
+        return Boolean(resolveWindowsExecutable(command, deps.env, (candidate) => {
+            try {
+                return deps.fs.statSync(candidate).isFile();
+            }
+            catch {
+                return false;
+            }
+        }, deps.cwd));
+    }
     for (const directory of (deps.env.PATH ?? "").split(path.delimiter)) {
         if (!directory)
             continue;
@@ -175,6 +228,21 @@ export function runWorkMeshBindTrusted(args, deps) {
     }
     if (deps.env.HQ_WORK_MESH_RECONCILE_STUB === "1")
         return { code: 0, stdout: output.join(""), stderr };
+    if (deps.daemonWarningEnabled && hasExecutable(deps, "hq")) {
+        const status = deps.runHq(["mesh", "daemon", "status", "--json"], { ...deps.env, HQ_NO_UPDATE_CHECK: "1" });
+        if (status.code === 0) {
+            try {
+                const parsed = JSON.parse(status.stdout);
+                if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                    const daemon = parsed;
+                    if (daemon.ok === true && daemon.running === false && typeof daemon.message === "string" && daemon.message.includes("installed (")) {
+                        stderr += "Work Mesh daemon is installed but not loaded; start it with: hq mesh daemon install\n";
+                    }
+                }
+            }
+            catch { /* the shell's jq test fails quiet on invalid status JSON */ }
+        }
+    }
     if (hasExecutable(deps, "hq") && deps.fs.existsSync(observationFile)) {
         deps.spawnHq(["mesh", "context", "reconcile", "--observation-file", observationFile, "--machine"], childEnv);
     }
@@ -184,7 +252,11 @@ export function registerCoreWorkMeshBindTrustedNative(core) {
     registerNativeUtility(core, {
         name: "work-mesh-bind-trusted", asset: WORK_MESH_BIND_TRUSTED_ASSET, root: "live", summary: "Bind trusted session context and reconcile it with Work Mesh",
         resolveRoot: (_cwd, hqRoot) => resolveLiveRoot({ hqRoot }),
-        run: (args, context) => runWorkMeshBindTrusted(args, createWorkMeshBindDeps(context.root, context.cwd, context.env, context.now)),
+        run: async (args, context) => {
+            const { fastFlagEnabled } = await import("../native-fast-route.js");
+            const daemonWarningEnabled = await fastFlagEnabled(WORK_MESH_DAEMON_WARNING_FLAG, context.env);
+            return runWorkMeshBindTrusted(args, createWorkMeshBindDeps(context.root, context.cwd, context.env, context.now, daemonWarningEnabled));
+        },
     });
 }
 //# sourceMappingURL=core-work-mesh-bind-trusted-native.js.map

package/dist/commands/core.js

@@ -63,7 +63,11 @@ import { tokenUsageReport } from "../lib/core-utils/token-usage-report.js";
 import { createWorktree } from "../lib/core-utils/worktree.js";
 import { runCodexSkillBridgeCommand } from "../lib/core-utils/codex-skill-bridge-entry.js";
 import { archiveOldThreads } from "../lib/core-utils/archive-old-threads.js";
-import { qmdReindexAfterSync } from "../lib/core-utils/qmd-reindex-after-sync.js";
+import { QMD_REINDEX_STARTUP_WARNING_FLAG, qmdReindexAfterSync } from "../lib/core-utils/qmd-reindex-after-sync.js";
+import { qmdReindexSingleFlightEnabled } from "../lib/search-index/reindex-single-flight-flag.js";
+import { qmdCollectionPathRepairEnabled } from "../lib/search-index/collection-path-repair-flag.js";
+import { reconcileCollections } from "../lib/search-index/index.js";
+import { resolveProcessFlagGate } from "../lib/flag-registry.js";
 import { softTimeoutCommand } from "../lib/core-utils/soft-timeout.js";
 import { timeoutGuardCommand } from "../lib/core-utils/timeout-guard.js";
 import { readSentryReportStdin, reportSentryEvent } from "../lib/core-utils/sentry-report.js";
@@ -87,7 +91,18 @@ export const NATIVE_UTILITY_COMMANDS = [
     { name: "worktree", asset: "core/scripts/worktree.sh", root: "live", summary: "Create a git worktree under workspace/worktrees/", run: (args, context) => createWorktree(args, { cwd: context.cwd, hqRoot: context.hqRoot }) },
     { name: "codex-skill-bridge", asset: "core/scripts/codex-skill-bridge.sh", root: "live", summary: "Install/inspect the Codex skill bridge", run: (args, context) => runCodexSkillBridgeCommand(args, { root: context.hqRoot ?? context.cwd }) },
     { name: "archive-old-threads", asset: "core/scripts/archive-old-threads.sh", root: "live", summary: "Archive aged session-thread files", run: (args, context) => archiveOldThreads(args, { hqRoot: context.hqRoot ?? context.cwd }) },
-    { name: "qmd-reindex-after-sync", asset: "core/scripts/qmd-reindex-after-sync.sh", root: "cwd", summary: "Refresh qmd collections after a sync", run: (args, context) => qmdReindexAfterSync(args, { cwd: context.cwd }) },
+    {
+        name: "qmd-reindex-after-sync",
+        asset: "core/scripts/qmd-reindex-after-sync.sh",
+        root: "cwd",
+        summary: "Refresh qmd collections after a sync",
+        run: (args, context) => qmdReindexAfterSync(args, {
+            cwd: context.cwd,
+            singleFlightEnabled: qmdReindexSingleFlightEnabled,
+            reconcile: (root, options) => reconcileCollections(root, { ...options, repairPathDrift: qmdCollectionPathRepairEnabled() }),
+            startupFailureWarningsEnabled: () => resolveProcessFlagGate(QMD_REINDEX_STARTUP_WARNING_FLAG, { fallback: false }, () => false),
+        }),
+    },
 ];
 export const NATIVE_SCAFFOLD_COMMANDS = [
     {

package/dist/commands/index-cmd.js

@@ -5,13 +5,14 @@ import { defaultEmbedLockDependencies, runWithEmbedLock, } from '../lib/search-i
 import { checkEmbedLoad, defaultLoadGateDependencies, recordSuccessfulEmbed, } from '../lib/search-index/load-gate.js';
 import { applyIndexSizeLimit } from '../lib/search-index/max-doc-bytes.js';
 import { qmdReindexSingleFlightEnabled } from '../lib/search-index/reindex-single-flight-flag.js';
+import { qmdCollectionPathRepairEnabled } from '../lib/search-index/collection-path-repair-flag.js';
 import { findHqRoot } from '../utils/manifest.js';
 import { QMD_NATIVE_BINDING_REMEDY, isQmdNativeBindingError, } from '../utils/qmd-native-binding-error.js';
 import { isQmdStoreMissingError, qmdStoreMissingMessage, } from '../utils/qmd-store-missing-error.js';
 import { isQmdStoreUnopenableError, qmdStoreUnopenableMessage, } from '../utils/qmd-store-unopenable-error.js';
 import { isQmdWorkdirMissingError, qmdWorkdirMissingMessage, } from '../utils/qmd-workdir-missing-error.js';
 const defaults = {
-    reconcileCollections,
+    reconcileCollections: (root) => reconcileCollections(root, { repairPathDrift: qmdCollectionPathRepairEnabled() }),
     applyIndexSizeLimit,
     deriveCollections,
     listRegisteredCollections,

package/dist/fast-scaffold.js

@@ -143,6 +143,25 @@ export const FAST_SCAFFOLD_SCRIPTS = [
         shellCwd: "caller",
         shellHqRoot: "none",
     },
+    {
+        name: "ontology-readme-drift",
+        kind: "native",
+        modulePath: "./commands/core-ontology-readme-drift-fast.js",
+        exportName: "runOntologyReadmeDriftFast",
+        flagKey: "hq-core-native-fast-route",
+        asset: "core/scripts/ontology-readme-drift.sh",
+        root: "live",
+    },
+    {
+        name: "qmd-reindex-after-sync",
+        kind: "native",
+        modulePath: "./commands/core-qmd-reindex-after-sync-fast.js",
+        exportName: "runQmdReindexAfterSyncFast",
+        flagKey: "hq-core-native-fast-route",
+        asset: "core/scripts/qmd-reindex-after-sync.sh",
+        root: "cwd",
+        requiresNodeNetworkCompatibility: true,
+    },
     {
         name: "rebuild-index",
         kind: "native",

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

@@ -1,6 +1,7 @@
 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 type QmdReindexOptions = UtilityIo & {
     cwd?: string;
     /** Test seams; default to the real search-index implementations. */

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

@@ -16,15 +16,9 @@ import { reconcileCollections, resolveQmdBin, resolveQmdHome, runQmd } from "../
 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";
-const QMD_REINDEX_STARTUP_WARNING_FLAG = "qmd.reindex-startup-warning";
-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);
-}
+export const QMD_REINDEX_STARTUP_WARNING_FLAG = "qmd.reindex-startup-warning";
 export function qmdReindexAfterSync(args = [], options = {}) {
     let hqRoot = "";
     let embed = false;
@@ -32,7 +26,7 @@ export function qmdReindexAfterSync(args = [], options = {}) {
         if (arg === "--embed")
             embed = true;
         else if (arg.startsWith("--"))
-            continue; // unknown flags are ignored, as in the shell
+            continue; // long options are ignored, matching the shell oracle
         else if (!hqRoot)
             hqRoot = arg;
     }
@@ -55,7 +49,7 @@ export function qmdReindexAfterSync(args = [], options = {}) {
     const warnOnNativeStartupFailure = (error) => {
         if (startupFailureWarningShown ||
             !isQmdNativeBindingError(error) ||
-            !(options.startupFailureWarningsEnabled ?? qmdStartupFailureWarningsEnabled)())
+            !(options.startupFailureWarningsEnabled ?? (() => false))())
             return;
         startupFailureWarningShown = true;
         line(stderr, `hq: search index was not updated after sync; ${QMD_NATIVE_BINDING_REMEDY}`);
@@ -99,7 +93,7 @@ export function qmdReindexAfterSync(args = [], options = {}) {
         recordSuccessfulEmbed(home, loadGateDependencies);
         return undefined;
     };
-    if ((options.singleFlightEnabled ?? qmdReindexSingleFlightEnabled)()) {
+    if ((options.singleFlightEnabled ?? (() => false))()) {
         const lockDependencies = options.embedLockDependencies ?? defaultEmbedLockDependencies();
         const home = resolveQmdHome(lockDependencies.env);
         try {

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

@@ -3,6 +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 { qmdCollectionPathRepairEnabled } from './collection-path-repair-flag.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';
@@ -121,7 +122,7 @@ export function defaultBackgroundDependencies(hqRoot) {
         random: () => Math.random().toString(36).slice(2),
         isProcessAlive: alive,
         resolveQmdBin: defaultResolveQmdBin,
-        reconcileCollections: defaultReconcileCollections,
+        reconcileCollections: (root) => defaultReconcileCollections(root, { repairPathDrift: qmdCollectionPathRepairEnabled() }),
         applyIndexSizeLimit: defaultApplyIndexSizeLimit,
         runQmd: defaultRunQmd,
         spawnWorker: defaultSpawnWorker,

package/dist/lib/search-index/collection-path-repair-flag-constants.d.ts

@@ -0,0 +1,2 @@
+export declare const QMD_COLLECTION_PATH_REPAIR_FLAG = "qmd.collection-path-repair";
+//# sourceMappingURL=collection-path-repair-flag-constants.d.ts.map

package/dist/lib/search-index/collection-path-repair-flag-constants.js

@@ -0,0 +1,2 @@
+export const QMD_COLLECTION_PATH_REPAIR_FLAG = 'qmd.collection-path-repair';
+//# sourceMappingURL=collection-path-repair-flag-constants.js.map

package/dist/lib/search-index/collection-path-repair-flag.d.ts

@@ -1,4 +1,4 @@
-export declare const QMD_COLLECTION_PATH_REPAIR_FLAG = "qmd.collection-path-repair";
+export { QMD_COLLECTION_PATH_REPAIR_FLAG } from './collection-path-repair-flag-constants.js';
 /** Keep collection-path repair off unless the hq-flags registry enables a canary. */
 export declare function qmdCollectionPathRepairEnabled(): boolean;
 //# sourceMappingURL=collection-path-repair-flag.d.ts.map

package/dist/lib/search-index/collection-path-repair-flag.js

@@ -1,5 +1,6 @@
 import { resolveProcessFlagGate } from '../flag-registry.js';
-export const QMD_COLLECTION_PATH_REPAIR_FLAG = 'qmd.collection-path-repair';
+import { QMD_COLLECTION_PATH_REPAIR_FLAG } from './collection-path-repair-flag-constants.js';
+export { QMD_COLLECTION_PATH_REPAIR_FLAG } from './collection-path-repair-flag-constants.js';
 /** Keep collection-path repair off unless the hq-flags registry enables a canary. */
 export function qmdCollectionPathRepairEnabled() {
     return resolveProcessFlagGate(QMD_COLLECTION_PATH_REPAIR_FLAG, { fallback: false }, () => false);

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

@@ -14,7 +14,6 @@ import { markExpectedUserError } from '../../utils/expected-cli-error.js';
 import { redactErrorText } from '../../utils/redact-error-text.js';
 import { planCommandSpawn } from '../../utils/windows-spawn.js';
 import { resolveQmdConfigPath } from './max-doc-bytes.js';
-import { qmdCollectionPathRepairEnabled } from './collection-path-repair-flag.js';
 /** The `path` implementation for a (possibly injected) platform. */
 function pathFor(platform) {
     return platform === 'win32' ? path.win32 : path.posix;
@@ -1472,7 +1471,7 @@ export function reconcileCollections(hqRoot, options = {}) {
     const runOptions = { bin: options.bin, runner: options.runner, cwd: hqRoot };
     const registered = listRegisteredCollections(hqRoot, runOptions);
     const expected = deriveCollections(hqRoot);
-    const repairPathDrift = options.repairPathDrift ?? qmdCollectionPathRepairEnabled();
+    const repairPathDrift = options.repairPathDrift ?? false;
     const configured = repairPathDrift ? configuredCollections(hqRoot) : new Map();
     const stale = repairPathDrift
         ? expected.filter((collection) => {

package/dist/lib/search-index/reindex-single-flight-flag-constants.d.ts

@@ -0,0 +1,3 @@
+export declare const QMD_REINDEX_SINGLE_FLIGHT_FLAG = "qmd.reindex-single-flight";
+export declare const QMD_REINDEX_SINGLE_FLIGHT_FLAG_FALLBACK = false;
+//# sourceMappingURL=reindex-single-flight-flag-constants.d.ts.map

package/dist/lib/search-index/reindex-single-flight-flag-constants.js

@@ -0,0 +1,3 @@
+export const QMD_REINDEX_SINGLE_FLIGHT_FLAG = "qmd.reindex-single-flight";
+export const QMD_REINDEX_SINGLE_FLIGHT_FLAG_FALLBACK = false;
+//# sourceMappingURL=reindex-single-flight-flag-constants.js.map

package/dist/lib/search-index/reindex-single-flight-flag.d.ts

@@ -1,5 +1,4 @@
-export declare const QMD_REINDEX_SINGLE_FLIGHT_FLAG = "qmd.reindex-single-flight";
-export declare const QMD_REINDEX_SINGLE_FLIGHT_FLAG_FALLBACK = false;
+export { QMD_REINDEX_SINGLE_FLIGHT_FLAG, QMD_REINDEX_SINGLE_FLIGHT_FLAG_FALLBACK } from "./reindex-single-flight-flag-constants.js";
 /** Keep whole update-to-embed passes single-flight only for explicitly enabled canaries. */
 export declare function qmdReindexSingleFlightEnabled(): boolean;
 //# sourceMappingURL=reindex-single-flight-flag.d.ts.map

package/dist/lib/search-index/reindex-single-flight-flag.js

@@ -1,6 +1,6 @@
 import { resolveProcessFlagGate } from "../flag-registry.js";
-export const QMD_REINDEX_SINGLE_FLIGHT_FLAG = "qmd.reindex-single-flight";
-export const QMD_REINDEX_SINGLE_FLIGHT_FLAG_FALLBACK = false;
+import { QMD_REINDEX_SINGLE_FLIGHT_FLAG, QMD_REINDEX_SINGLE_FLIGHT_FLAG_FALLBACK } from "./reindex-single-flight-flag-constants.js";
+export { QMD_REINDEX_SINGLE_FLIGHT_FLAG, QMD_REINDEX_SINGLE_FLIGHT_FLAG_FALLBACK } from "./reindex-single-flight-flag-constants.js";
 /** Keep whole update-to-embed passes single-flight only for explicitly enabled canaries. */
 export function qmdReindexSingleFlightEnabled() {
     return resolveProcessFlagGate(QMD_REINDEX_SINGLE_FLIGHT_FLAG, { fallback: QMD_REINDEX_SINGLE_FLIGHT_FLAG_FALLBACK }, () => QMD_REINDEX_SINGLE_FLIGHT_FLAG_FALLBACK);

package/package.json

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