@indigoai-us/hq-cloud 6.18.14-alpha.2 → 6.18.14

package/dist/qmd-reindex.test.js

@@ -14,7 +14,7 @@ import { describe, it, expect } from "vitest";
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
-import { reindexAfterSync, createQmdExec, looksCorrupt, resolveExecTimeoutMs, DEFAULT_QMD_EXEC_TIMEOUT_MS, parseIndexDirFromStatus, parseCollectionPathFromShow, pathsEquivalent, repairPathDriftEnabled, acquireDualReindexLocks, } from "./qmd-reindex.js";
+import { reindexAfterSync, looksCorrupt, resolveExecTimeoutMs, DEFAULT_QMD_EXEC_TIMEOUT_MS, parseIndexDirFromStatus, parseCollectionPathFromShow, pathsEquivalent, repairPathDriftEnabled, acquireDualReindexLocks, } from "./qmd-reindex.js";
 /** A lock acquirer that always succeeds — keeps command-sequence tests pure. */
 const noLock = () => ({ release() { } });
 /** Identity realpath so path-drift comparisons stay deterministic in fakes. */
@@ -22,7 +22,7 @@ const identityRealpath = (p) => path.resolve(p);
 /** Build a fake exec that returns status 0 for everything and logs calls. */
 function fakeExec(opts) {
     const calls = [];
-    const exec = async (args) => {
+    const exec = (args) => {
         calls.push(args);
         const override = opts?.resultFor?.(args);
         if (override)
@@ -48,9 +48,9 @@ function fakeExec(opts) {
     return { exec, calls };
 }
 describe("reindexAfterSync", () => {
-    it("no-ops when the path is not an HQ root", async () => {
+    it("no-ops when the path is not an HQ root", () => {
         const { exec, calls } = fakeExec();
-        const r = await reindexAfterSync("/tmp/not-hq", {
+        const r = reindexAfterSync("/tmp/not-hq", {
             exec,
             acquireReindexLock: noLock,
             existsSync: () => false, // core/core.yaml absent
@@ -58,9 +58,9 @@ describe("reindexAfterSync", () => {
         expect(r.qmdAvailable).toBe(false);
         expect(calls).toHaveLength(0);
     });
-    it("no-ops when qmd is unavailable (collection list errors)", async () => {
+    it("no-ops when qmd is unavailable (collection list errors)", () => {
         const { exec, calls } = fakeExec({ failOn: "collection" });
-        const r = await reindexAfterSync("/hq", {
+        const r = reindexAfterSync("/hq", {
             exec,
             acquireReindexLock: noLock,
             existsSync: () => true, // core.yaml present
@@ -69,9 +69,9 @@ describe("reindexAfterSync", () => {
         expect(r.updated).toBe(false);
         expect(calls).toEqual([["status"], ["collection", "list"]]);
     });
-    it("registers a missing company collection then runs an incremental update", async () => {
+    it("registers a missing company collection then runs an incremental update", () => {
         const { exec, calls } = fakeExec({ listStdout: "Collections (1):\n\nHQ (qmd://HQ/)\n" });
-        const r = await reindexAfterSync("/hq", {
+        const r = reindexAfterSync("/hq", {
             exec,
             acquireReindexLock: noLock,
             existsSync: () => true,
@@ -90,9 +90,9 @@ describe("reindexAfterSync", () => {
             ["update"],
         ]);
     });
-    it("skips collections that already exist at the desired path", async () => {
+    it("skips collections that already exist at the desired path", () => {
         const { exec, calls } = fakeExec({ listStdout: "acme (qmd://acme/)\n" });
-        const r = await reindexAfterSync("/hq", {
+        const r = reindexAfterSync("/hq", {
             exec,
             acquireReindexLock: noLock,
             existsSync: () => true,
@@ -109,7 +109,7 @@ describe("reindexAfterSync", () => {
             ["update"],
         ]);
     });
-    it("detects path drift without repairing when HQ_QMD_REPAIR_PATH_DRIFT is off", async () => {
+    it("detects path drift without repairing when HQ_QMD_REPAIR_PATH_DRIFT is off", () => {
         const drifted = path.join("/mirror", "knowledge-acme");
         const { exec, calls } = fakeExec({
             listStdout: "acme (qmd://acme/)\n",
@@ -120,7 +120,7 @@ describe("reindexAfterSync", () => {
                 }
                 : undefined,
         });
-        const r = await reindexAfterSync("/hq", {
+        const r = reindexAfterSync("/hq", {
             exec,
             acquireReindexLock: noLock,
             existsSync: () => true,
@@ -136,7 +136,7 @@ describe("reindexAfterSync", () => {
         // Detect-only must still allow embed (no repair this cycle).
         expect(r.embedded).toBe(true);
     });
-    it("repairs path drift when HQ_QMD_REPAIR_PATH_DRIFT=1 and skips embed", async () => {
+    it("repairs path drift when HQ_QMD_REPAIR_PATH_DRIFT=1 and skips embed", () => {
         const drifted = path.join("/mirror", "knowledge-acme");
         const desired = path.join("/hq", "companies", "acme", "knowledge");
         const { exec, calls } = fakeExec({
@@ -145,7 +145,7 @@ describe("reindexAfterSync", () => {
                 ? { status: 0, stdout: `Collection: acme\n  Path: ${drifted}\n` }
                 : undefined,
         });
-        const r = await reindexAfterSync("/hq", {
+        const r = reindexAfterSync("/hq", {
             exec,
             acquireReindexLock: noLock,
             existsSync: () => true,
@@ -168,7 +168,7 @@ describe("reindexAfterSync", () => {
             ["update"],
         ]);
     });
-    it("does not remove a drifted collection when desired path has no indexable markdown", async () => {
+    it("does not remove a drifted collection when desired path has no indexable markdown", () => {
         const drifted = path.join("/mirror", "knowledge-acme");
         const { exec, calls } = fakeExec({
             listStdout: "acme (qmd://acme/)\n",
@@ -177,7 +177,7 @@ describe("reindexAfterSync", () => {
                 : undefined,
         });
         // hasIndexableMarkdown false → skipped before show/repair (desired empty).
-        const r = await reindexAfterSync("/hq", {
+        const r = reindexAfterSync("/hq", {
             exec,
             acquireReindexLock: noLock,
             existsSync: () => true,
@@ -189,9 +189,9 @@ describe("reindexAfterSync", () => {
         expect(r.collectionsRepaired).toEqual([]);
         expect(calls.some((c) => c[1] === "remove")).toBe(false);
     });
-    it("skips company dirs with no indexable markdown", async () => {
+    it("skips company dirs with no indexable markdown", () => {
         const { exec, calls } = fakeExec({ listStdout: "" });
-        const r = await reindexAfterSync("/hq", {
+        const r = reindexAfterSync("/hq", {
             exec,
             acquireReindexLock: noLock,
             existsSync: () => true,
@@ -201,9 +201,9 @@ describe("reindexAfterSync", () => {
         expect(r.collectionsAdded).toEqual([]);
         expect(calls).toEqual([["status"], ["collection", "list"], ["update"]]);
     });
-    it("registers populated company projects with the shell name and mask", async () => {
+    it("registers populated company projects with the shell name and mask", () => {
         const { exec, calls } = fakeExec({ listStdout: "" });
-        const r = await reindexAfterSync("/hq", {
+        const r = reindexAfterSync("/hq", {
             exec,
             acquireReindexLock: noLock,
             existsSync: () => true,
@@ -228,10 +228,10 @@ describe("reindexAfterSync", () => {
             ["update"],
         ]);
     });
-    it("skips missing and empty company projects dirs", async () => {
+    it("skips missing and empty company projects dirs", () => {
         const { exec, calls } = fakeExec({ listStdout: "" });
         const emptyProjects = path.join("/hq", "companies", "empty", "projects");
-        const r = await reindexAfterSync("/hq", {
+        const r = reindexAfterSync("/hq", {
             exec,
             acquireReindexLock: noLock,
             existsSync: (p) => p !== path.join("/hq", "companies", "missing", "projects"),
@@ -242,10 +242,10 @@ describe("reindexAfterSync", () => {
         expect(r.collectionsAdded).toEqual([]);
         expect(calls).toEqual([["status"], ["collection", "list"], ["update"]]);
     });
-    it("registers populated personal knowledge with the shell name and mask", async () => {
+    it("registers populated personal knowledge with the shell name and mask", () => {
         const { exec, calls } = fakeExec({ listStdout: "" });
         const personalKnowledge = path.join("/hq", "personal", "knowledge");
-        const r = await reindexAfterSync("/hq", {
+        const r = reindexAfterSync("/hq", {
             exec,
             acquireReindexLock: noLock,
             existsSync: () => true,
@@ -269,9 +269,9 @@ describe("reindexAfterSync", () => {
             ["update"],
         ]);
     });
-    it("skips absent and empty personal knowledge", async () => {
+    it("skips absent and empty personal knowledge", () => {
         const absent = fakeExec({ listStdout: "" });
-        const absentResult = await reindexAfterSync("/hq", {
+        const absentResult = reindexAfterSync("/hq", {
             exec: absent.exec,
             acquireReindexLock: noLock,
             existsSync: (p) => p !== path.join("/hq", "personal", "knowledge"),
@@ -280,7 +280,7 @@ describe("reindexAfterSync", () => {
         expect(absentResult.collectionsAdded).toEqual([]);
         expect(absent.calls).toEqual([["status"], ["collection", "list"], ["update"]]);
         const empty = fakeExec({ listStdout: "" });
-        const emptyResult = await reindexAfterSync("/hq", {
+        const emptyResult = reindexAfterSync("/hq", {
             exec: empty.exec,
             acquireReindexLock: noLock,
             existsSync: () => true,
@@ -290,7 +290,7 @@ describe("reindexAfterSync", () => {
         expect(emptyResult.collectionsAdded).toEqual([]);
         expect(empty.calls).toEqual([["status"], ["collection", "list"], ["update"]]);
     });
-    it("does not add projects or personal knowledge a second time", async () => {
+    it("does not add projects or personal knowledge a second time", () => {
         let listCount = 0;
         const { exec, calls } = fakeExec({
             resultFor: (args) => {
@@ -314,15 +314,15 @@ describe("reindexAfterSync", () => {
             hasIndexableProjectContent: () => true,
             realpathSync: identityRealpath,
         };
-        expect((await reindexAfterSync("/hq", options)).collectionsAdded).toEqual([
+        expect(reindexAfterSync("/hq", options).collectionsAdded).toEqual([
             "acme",
             "acme-projects",
             "personal-knowledge",
         ]);
-        expect((await reindexAfterSync("/hq", options)).collectionsAdded).toEqual([]);
+        expect(reindexAfterSync("/hq", options).collectionsAdded).toEqual([]);
         expect(calls.filter((c) => c[0] === "collection" && c[1] === "add")).toHaveLength(3);
     });
-    it("emits the same collection-add commands as the shell for a fixture tree", async () => {
+    it("emits the same collection-add commands as the shell for a fixture tree", () => {
         const dir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-qmd-parity-"));
         try {
             const hq = path.join(dir, "hq");
@@ -340,7 +340,7 @@ describe("reindexAfterSync", () => {
             fs.writeFileSync(path.join(acmeProjects, "prd.json"), "{}\n");
             fs.writeFileSync(path.join(personalKnowledge, "note.md"), "# personal\n");
             const { exec, calls } = fakeExec({ listStdout: "" });
-            await reindexAfterSync(hq, { exec, acquireReindexLock: noLock });
+            reindexAfterSync(hq, { exec, acquireReindexLock: noLock });
             expect(calls.filter((c) => c[0] === "collection" && c[1] === "add")).toEqual([
                 ["collection", "add", acmeKnowledge, "--name", "acme", "--mask", "**/*.md"],
                 [
@@ -367,9 +367,9 @@ describe("reindexAfterSync", () => {
             fs.rmSync(dir, { recursive: true, force: true });
         }
     });
-    it("skips qmd entirely when provided changed paths do not touch knowledge markdown", async () => {
+    it("skips qmd entirely when provided changed paths do not touch knowledge markdown", () => {
         const { exec, calls } = fakeExec({ listStdout: "" });
-        const r = await reindexAfterSync("/hq", {
+        const r = reindexAfterSync("/hq", {
             exec,
             acquireReindexLock: noLock,
             existsSync: () => true,
@@ -379,12 +379,12 @@ describe("reindexAfterSync", () => {
         expect(r.updated).toBe(false);
         expect(calls).toEqual([]);
     });
-    it("debounces dirty updates with a pending marker and flushes the final update later", async () => {
+    it("debounces dirty updates with a pending marker and flushes the final update later", () => {
         const dir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-qmd-debounce-"));
         try {
             const statePath = path.join(dir, "qmd-state.json");
             const { exec, calls } = fakeExec({ listStdout: "acme (qmd://acme/)\n" });
-            const first = await reindexAfterSync("/hq", {
+            const first = reindexAfterSync("/hq", {
                 exec,
                 acquireReindexLock: noLock,
                 existsSync: () => true,
@@ -403,7 +403,7 @@ describe("reindexAfterSync", () => {
                 ["collection", "list"],
                 ["collection", "show", "acme"],
             ]);
-            const second = await reindexAfterSync("/hq", {
+            const second = reindexAfterSync("/hq", {
                 exec,
                 acquireReindexLock: noLock,
                 existsSync: () => true,
@@ -427,9 +427,9 @@ describe("reindexAfterSync", () => {
             fs.rmSync(dir, { recursive: true, force: true });
         }
     });
-    it("runs embed only when embed:true", async () => {
+    it("runs embed only when embed:true", () => {
         const { exec, calls } = fakeExec({ listStdout: "" });
-        const r = await reindexAfterSync("/hq", {
+        const r = reindexAfterSync("/hq", {
             exec,
             acquireReindexLock: noLock,
             existsSync: () => true,
@@ -439,13 +439,13 @@ describe("reindexAfterSync", () => {
         expect(r.embedded).toBe(true);
         expect(calls).toEqual([["status"], ["collection", "list"], ["update"], ["embed"]]);
     });
-    it("never throws even if exec misbehaves", async () => {
-        const exec = async () => {
+    it("never throws even if exec misbehaves", () => {
+        const exec = () => {
             throw new Error("boom");
         };
-        await expect(reindexAfterSync("/hq", { exec, acquireReindexLock: noLock, existsSync: () => true })).resolves.toMatchObject({ qmdAvailable: false });
+        expect(() => reindexAfterSync("/hq", { exec, acquireReindexLock: noLock, existsSync: () => true })).not.toThrow();
     });
-    it("hasIndexableMarkdown finds a real .md and ignores INDEX.md", async () => {
+    it("hasIndexableMarkdown finds a real .md and ignores INDEX.md", () => {
         const dir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-qmd-test-"));
         try {
             const hq = path.join(dir, "hq");
@@ -456,7 +456,7 @@ describe("reindexAfterSync", () => {
             fs.writeFileSync(path.join(kdir, "INDEX.md"), "# index\n");
             fs.writeFileSync(path.join(kdir, "note.md"), "# real\n");
             const { exec, calls } = fakeExec({ listStdout: "" });
-            const r = await reindexAfterSync(hq, { exec, acquireReindexLock: noLock }); // real fs walk
+            const r = reindexAfterSync(hq, { exec, acquireReindexLock: noLock }); // real fs walk
             expect(r.collectionsAdded).toEqual(["acme"]);
             expect(calls.some((c) => c[0] === "collection" && c[1] === "add")).toBe(true);
         }
@@ -465,12 +465,12 @@ describe("reindexAfterSync", () => {
         }
     });
     // ── Corruption safety: lock serialization (feedback_b9a369ff) ──────────────
-    it("skips the cycle after status when another writer holds the lock", async () => {
+    it("skips the cycle after status when another writer holds the lock", () => {
         const dir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-qmd-lockbusy-"));
         try {
             const statePath = path.join(dir, "qmd-state.json");
             const { exec, calls } = fakeExec({ listStdout: "" });
-            const r = await reindexAfterSync("/hq", {
+            const r = reindexAfterSync("/hq", {
                 exec,
                 existsSync: () => true,
                 statePath,
@@ -489,14 +489,14 @@ describe("reindexAfterSync", () => {
             fs.rmSync(dir, { recursive: true, force: true });
         }
     });
-    it("always releases the lock, even when a qmd command throws after status", async () => {
+    it("always releases the lock, even when a qmd command throws after status", () => {
         let released = false;
-        const exec = async (args) => {
+        const exec = (args) => {
             if (args[0] === "status")
                 return { status: 0, stdout: "" };
             throw new Error("boom");
         };
-        await reindexAfterSync("/hq", {
+        reindexAfterSync("/hq", {
             exec,
             existsSync: () => true,
             acquireReindexLock: () => ({
@@ -508,7 +508,7 @@ describe("reindexAfterSync", () => {
         expect(released).toBe(true);
     });
     // ── Corruption safety: timeout-kill handling ───────────────────────────────
-    it("treats a timed-out update as not-done, marks dirty, and does NOT embed", async () => {
+    it("treats a timed-out update as not-done, marks dirty, and does NOT embed", () => {
         const dir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-qmd-timeout-"));
         try {
             const statePath = path.join(dir, "qmd-state.json");
@@ -516,7 +516,7 @@ describe("reindexAfterSync", () => {
                 listStdout: "",
                 resultFor: (args) => args[0] === "update" ? { status: null, timedOut: true } : undefined,
             });
-            const r = await reindexAfterSync("/hq", {
+            const r = reindexAfterSync("/hq", {
                 exec,
                 acquireReindexLock: noLock,
                 existsSync: () => true,
@@ -536,12 +536,12 @@ describe("reindexAfterSync", () => {
             fs.rmSync(dir, { recursive: true, force: true });
         }
     });
-    it("treats a timed-out embed as not-embedded and marks dirty", async () => {
+    it("treats a timed-out embed as not-embedded and marks dirty", () => {
         const { exec } = fakeExec({
             listStdout: "",
             resultFor: (args) => args[0] === "embed" ? { status: null, timedOut: true } : undefined,
         });
-        const r = await reindexAfterSync("/hq", {
+        const r = reindexAfterSync("/hq", {
             exec,
             acquireReindexLock: noLock,
             existsSync: () => true,
@@ -554,7 +554,7 @@ describe("reindexAfterSync", () => {
         expect(r.pendingDirty).toBe(true);
     });
     // ── Corruption safety: SQLITE_CORRUPT detection + quarantine ────────────────
-    it("quarantines the resolved index dir when update reports SQLITE_CORRUPT", async () => {
+    it("quarantines the resolved index dir when update reports SQLITE_CORRUPT", () => {
         const dir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-qmd-corrupt-"));
         try {
             const statePath = path.join(dir, "qmd-state.json");
@@ -571,7 +571,7 @@ describe("reindexAfterSync", () => {
                     ? { status: 1, stderr: "SqliteError: database disk image is malformed (SQLITE_CORRUPT)" }
                     : undefined,
             });
-            const r = await reindexAfterSync("/hq", {
+            const r = reindexAfterSync("/hq", {
                 exec,
                 acquireReindexLock: noLock,
                 existsSync: () => true,
@@ -593,14 +593,14 @@ describe("reindexAfterSync", () => {
             fs.rmSync(dir, { recursive: true, force: true });
         }
     });
-    it("reports quarantine failure when corruption is detected but nothing moves", async () => {
+    it("reports quarantine failure when corruption is detected but nothing moves", () => {
         const quarantined = [];
         const { exec, calls } = fakeExec({
             resultFor: (args) => args[0] === "collection" && args[1] === "list"
                 ? { status: 0, stdout: "database disk image is malformed" }
                 : undefined,
         });
-        const r = await reindexAfterSync("/hq", {
+        const r = reindexAfterSync("/hq", {
             exec,
             acquireReindexLock: noLock,
             existsSync: () => true,
@@ -615,7 +615,7 @@ describe("reindexAfterSync", () => {
         expect(calls).toEqual([["status"], ["collection", "list"]]);
         expect(quarantined).toEqual([path.join("/hq", ".qmd")]);
     });
-    it("quarantines when embed reports SQLITE_CORRUPT", async () => {
+    it("quarantines when embed reports SQLITE_CORRUPT", () => {
         const quarantined = [];
         const { exec, calls } = fakeExec({
             listStdout: "",
@@ -623,7 +623,7 @@ describe("reindexAfterSync", () => {
                 ? { status: 1, stderr: "code SQLITE_CORRUPT at store.js:1546" }
                 : undefined,
         });
-        const r = await reindexAfterSync("/hq", {
+        const r = reindexAfterSync("/hq", {
             exec,
             acquireReindexLock: noLock,
             existsSync: () => true,
@@ -642,7 +642,7 @@ describe("reindexAfterSync", () => {
 });
 // ── The default reindex lock (real filesystem) ───────────────────────────────
 describe("default reindex lock", () => {
-    it("holds the lock for the duration of the cycle and releases it after", async () => {
+    it("holds the lock for the duration of the cycle and releases it after", () => {
         const dir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-qmd-lock-"));
         try {
             const hq = path.join(dir, "hq");
@@ -654,7 +654,7 @@ describe("default reindex lock", () => {
             const lockPath = path.join(hq, ".qmd", ".reindex.lock");
             let reAcquireBlockedWhileHeld = false;
             const { exec } = fakeExec({ listStdout: "" });
-            const observingExec = async (args) => {
+            const observingExec = (args) => {
                 if (args[0] === "update") {
                     try {
                         fs.closeSync(fs.openSync(lockPath, "wx"));
@@ -665,9 +665,9 @@ describe("default reindex lock", () => {
                             err.code === "EEXIST";
                     }
                 }
-                return await exec(args);
+                return exec(args);
             };
-            const r = await reindexAfterSync(hq, { exec: observingExec });
+            const r = reindexAfterSync(hq, { exec: observingExec });
             expect(r.updated).toBe(true);
             expect(reAcquireBlockedWhileHeld).toBe(true);
             expect(fs.existsSync(lockPath)).toBe(false);
@@ -676,7 +676,7 @@ describe("default reindex lock", () => {
             fs.rmSync(dir, { recursive: true, force: true });
         }
     });
-    it("reclaims a lock held by a dead PID (stale takeover)", async () => {
+    it("reclaims a lock held by a dead PID (stale takeover)", () => {
         const dir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-qmd-lock-stale-"));
         try {
             const hq = path.join(dir, "hq");
@@ -689,7 +689,7 @@ describe("default reindex lock", () => {
             fs.mkdirSync(path.dirname(lockPath), { recursive: true });
             fs.writeFileSync(lockPath, JSON.stringify({ pid: 2147483646, startedAt: "2000-01-01T00:00:00.000Z", command: "dead" }));
             const { exec, calls } = fakeExec({ listStdout: "" });
-            const r = await reindexAfterSync(hq, { exec });
+            const r = reindexAfterSync(hq, { exec });
             expect(r.updated).toBe(true);
             expect(r.lockBusy).toBe(false);
             expect(calls.some((c) => c[0] === "update")).toBe(true);
@@ -700,7 +700,7 @@ describe("default reindex lock", () => {
     });
 });
 describe("acquireDualReindexLocks", () => {
-    it("dedupes identical paths so a process cannot lock itself out", async () => {
+    it("dedupes identical paths so a process cannot lock itself out", () => {
         let acquires = 0;
         const acquire = () => {
             acquires++;
@@ -712,7 +712,7 @@ describe("acquireDualReindexLocks", () => {
         expect(locks).toHaveLength(1);
         expect(acquires).toBe(1);
     });
-    it("releases the first lock when the second is busy", async () => {
+    it("releases the first lock when the second is busy", () => {
         const released = [];
         let n = 0;
         const acquire = (lockPath) => {
@@ -736,79 +736,46 @@ describe("acquireDualReindexLocks", () => {
 });
 // ── Pure helpers ─────────────────────────────────────────────────────────────
 describe("resolveExecTimeoutMs", () => {
-    it("defaults to a generous bound, not the old 120s that killed writes", async () => {
+    it("defaults to a generous bound, not the old 120s that killed writes", () => {
         expect(resolveExecTimeoutMs({})).toBe(DEFAULT_QMD_EXEC_TIMEOUT_MS);
         expect(DEFAULT_QMD_EXEC_TIMEOUT_MS).toBeGreaterThan(120_000);
     });
-    it("honors a valid HQ_QMD_EXEC_TIMEOUT_MS override", async () => {
+    it("honors a valid HQ_QMD_EXEC_TIMEOUT_MS override", () => {
         expect(resolveExecTimeoutMs({ HQ_QMD_EXEC_TIMEOUT_MS: "300000" })).toBe(300_000);
     });
-    it("ignores an invalid override", async () => {
+    it("ignores an invalid override", () => {
         expect(resolveExecTimeoutMs({ HQ_QMD_EXEC_TIMEOUT_MS: "nope" })).toBe(DEFAULT_QMD_EXEC_TIMEOUT_MS);
         expect(resolveExecTimeoutMs({ HQ_QMD_EXEC_TIMEOUT_MS: "-5" })).toBe(DEFAULT_QMD_EXEC_TIMEOUT_MS);
         expect(resolveExecTimeoutMs({ HQ_QMD_EXEC_TIMEOUT_MS: "0" })).toBe(DEFAULT_QMD_EXEC_TIMEOUT_MS);
     });
 });
-describe("createQmdExec", () => {
-    it("captures output and sends SIGINT when the configured timeout expires", async () => {
-        const exec = createQmdExec({
-            command: process.execPath,
-            timeoutMs: 250,
-            sigintGraceMs: 100,
-        });
-        const result = await exec([
-            "-e",
-            "process.on('SIGINT', () => { process.stdout.write('sigint'); process.exit(0); }); setInterval(() => {}, 1000);",
-        ]);
-        expect(result).toMatchObject({ status: 0, timedOut: true });
-        expect(result.stdout).toContain("sigint");
-    });
-    it("sends SIGINT to an in-flight child on shutdown and escalates after the grace period", async () => {
-        const controller = new AbortController();
-        const exec = createQmdExec({
-            command: process.execPath,
-            timeoutMs: 10_000,
-            sigintGraceMs: 50,
-        });
-        const resultPromise = exec([
-            "-e",
-            "process.on('SIGINT', () => process.stdout.write('sigint')); setInterval(() => {}, 1000);",
-        ], { signal: controller.signal });
-        const abortTimer = setTimeout(() => controller.abort(), 250);
-        const result = await resultPromise;
-        clearTimeout(abortTimer);
-        expect(result.timedOut).toBe(false);
-        expect(result.stdout).toContain("sigint");
-        expect(result.status).toBeNull();
-    });
-});
 describe("looksCorrupt", () => {
-    it("matches the SQLITE_CORRUPT signature on stdout or stderr", async () => {
+    it("matches the SQLITE_CORRUPT signature on stdout or stderr", () => {
         expect(looksCorrupt({ stderr: "SqliteError: ... code SQLITE_CORRUPT" })).toBe(true);
         expect(looksCorrupt({ stdout: "database disk image is malformed" })).toBe(true);
         expect(looksCorrupt({ stdout: "Database disk image IS MALFORMED" })).toBe(true);
     });
-    it("does not match clean output", async () => {
+    it("does not match clean output", () => {
         expect(looksCorrupt({ stdout: "Updated 688 documents", stderr: "" })).toBe(false);
         expect(looksCorrupt({})).toBe(false);
     });
 });
 describe("parseIndexDirFromStatus / parseCollectionPathFromShow", () => {
-    it("parses Index file path into its directory", async () => {
+    it("parses Index file path into its directory", () => {
         expect(parseIndexDirFromStatus("Index: C:/Users/me/.cache/qmd/index.sqlite\nSize: 1.3 GB\n")).toBe(path.dirname("C:/Users/me/.cache/qmd/index.sqlite"));
     });
-    it("returns null when Index line is missing", async () => {
+    it("returns null when Index line is missing", () => {
         expect(parseIndexDirFromStatus("Collections: 2\n")).toBeNull();
     });
-    it("parses Path from collection show", async () => {
+    it("parses Path from collection show", () => {
         expect(parseCollectionPathFromShow("Collection: indigo\n  Path: /hq/companies/indigo/knowledge\n")).toBe("/hq/companies/indigo/knowledge");
     });
 });
 describe("pathsEquivalent / repairPathDriftEnabled", () => {
-    it("treats case and trailing separators as equal", async () => {
+    it("treats case and trailing separators as equal", () => {
         expect(pathsEquivalent("/HQ/Companies/Acme/knowledge/", "/hq/companies/acme/knowledge", (p) => p)).toBe(true);
     });
-    it("enables repair only for 1/true/yes", async () => {
+    it("enables repair only for 1/true/yes", () => {
         expect(repairPathDriftEnabled({})).toBe(false);
         expect(repairPathDriftEnabled({ HQ_QMD_REPAIR_PATH_DRIFT: "1" })).toBe(true);
         expect(repairPathDriftEnabled({ HQ_QMD_REPAIR_PATH_DRIFT: "true" })).toBe(true);