@remnic/core 10.0.0 → 10.0.2

package/src/qmd-mcp-cancel.test.ts

@@ -0,0 +1,408 @@
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import test from "node:test";
+
+import { abortError } from "./abort-error.js";
+import { QmdDaemonSession } from "./qmd-daemon-session.js";
+import { createInflightJoiner, rankDocumentsUntilAbortParallel } from "./qmd-mcp-cancel.js";
+import { QmdClient } from "./qmd.js";
+import type { CommandChildProcess } from "./runtime/child-process.js";
+import type { QmdSearchResult } from "./types.js";
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+test("in-flight joiner runs identical work once", async () => {
+  const joiner = createInflightJoiner<string>();
+  let runs = 0;
+  const run = () => {
+    runs += 1;
+    return delay(20).then(() => "shared");
+  };
+  const [a, b] = await Promise.all([joiner.join("same", undefined, run), joiner.join("same", undefined, run)]);
+  assert.equal(a, "shared");
+  assert.equal(b, "shared");
+  assert.equal(runs, 1);
+});
+
+test("aborting one of two waiters does not cancel the shared call", async () => {
+  const joiner = createInflightJoiner<string>();
+  let runs = 0;
+  let sharedAborted = false;
+  const run = (signal: AbortSignal) => {
+    runs += 1;
+    signal.addEventListener("abort", () => {
+      sharedAborted = true;
+    });
+    return delay(30).then(() => "kept");
+  };
+  const ac = new AbortController();
+  const leaving = joiner.join("same", ac.signal, run);
+  const staying = joiner.join("same", undefined, run);
+  await delay(5);
+  ac.abort();
+  await assert.rejects(leaving, (err: Error) => err.name === "AbortError");
+  assert.equal(await staying, "kept");
+  assert.equal(runs, 1);
+  assert.equal(sharedAborted, false);
+});
+
+test("aborting the only waiter aborts the shared signal", async () => {
+  const joiner = createInflightJoiner<string>();
+  let shared: AbortSignal | undefined;
+  const run = (signal: AbortSignal) => {
+    shared = signal;
+    return new Promise<string>((_resolve, reject) => {
+      signal.addEventListener("abort", () => reject(abortError("run aborted")));
+    });
+  };
+  const ac = new AbortController();
+  const pending = joiner.join("only", ac.signal, run);
+  await delay(5);
+  ac.abort();
+  await assert.rejects(pending, (err: Error) => err.name === "AbortError");
+  assert.equal(shared?.aborted, true);
+});
+
+test("a pre-aborted signal does not start work", async () => {
+  const joiner = createInflightJoiner<string>();
+  let runs = 0;
+  const ac = new AbortController();
+  ac.abort();
+  await assert.rejects(
+    joiner.join("pre", ac.signal, async () => {
+      runs += 1;
+      return "no";
+    }),
+    (err: Error) => err.name === "AbortError"
+  );
+  assert.equal(runs, 0);
+});
+
+test("rank loop stops between documents and the next batch is not charged the remainder", async () => {
+  const ac = new AbortController();
+  let calls = 0;
+  const abandoned = rankDocumentsUntilAbortParallel(5, 1, ac.signal, async () => {
+    calls += 1;
+    await delay(40);
+    return 1;
+  });
+  await delay(50);
+  ac.abort();
+  const stoppedAt = Date.now();
+  await assert.rejects(abandoned, (err: Error) => err.name === "AbortError");
+  const stopMs = Date.now() - stoppedAt;
+  assert.ok(calls < 5, `cancelled rerank still scored ${calls} documents`);
+  assert.ok(stopMs < 120, `worker kept scoring for ${stopMs}ms after abort`);
+
+  const followStarted = Date.now();
+  const scores = await rankDocumentsUntilAbortParallel(5, 1, undefined, async (index) => {
+    await delay(5);
+    return index;
+  });
+  const followMs = Date.now() - followStarted;
+  assert.deepEqual(scores, [0, 1, 2, 3, 4]);
+  assert.ok(followMs < 150, `following batch took ${followMs}ms`);
+});
+
+type Reply = (payload: unknown) => void;
+
+function createScriptedChild(onLine: (line: string, reply: Reply) => void): CommandChildProcess {
+  const stdout = new EventEmitter();
+  const stderr = new EventEmitter();
+  const child = new EventEmitter() as EventEmitter & {
+    killed: boolean;
+    pid: number;
+    stdin: {
+      destroyed: boolean;
+      write: (chunk: string, cb?: (err?: Error | null) => void) => boolean;
+      on: (event: string, listener: (...args: unknown[]) => void) => unknown;
+    };
+    stdout: EventEmitter;
+    stderr: EventEmitter;
+    kill: (signal?: string) => boolean;
+  };
+  const reply: Reply = (payload) => {
+    stdout.emit("data", Buffer.from(`${JSON.stringify(payload)}\n`));
+  };
+  child.killed = false;
+  child.pid = 4242;
+  child.stdout = stdout;
+  child.stderr = stderr;
+  child.stdin = {
+    destroyed: false,
+    on() {
+      return child.stdin;
+    },
+    write(chunk, cb) {
+      queueMicrotask(() => {
+        for (const line of String(chunk).split("\n")) {
+          if (line.trim()) onLine(line, reply);
+        }
+      });
+      cb?.(null);
+      return true;
+    },
+  };
+  child.kill = () => {
+    child.killed = true;
+    child.emit("close", 0);
+    return true;
+  };
+  return child as unknown as CommandChildProcess;
+}
+
+function scriptedQueryServer(lines: string[]) {
+  let held: number | null = null;
+  const queue: number[] = [];
+  const holdTimers = new Map<number, ReturnType<typeof setTimeout>>();
+
+  const serveNext = (reply: Reply) => {
+    if (held !== null || queue.length === 0) return;
+    const id = queue.shift();
+    if (id === undefined) return;
+    held = id;
+    const timer = setTimeout(() => {
+      if (held !== id) return;
+      reply({
+        jsonrpc: "2.0",
+        id,
+        result: { structuredContent: { results: [] } },
+      });
+      held = null;
+      serveNext(reply);
+    }, 2_000);
+    holdTimers.set(id, timer);
+  };
+
+  return (line: string, reply: Reply) => {
+    lines.push(line);
+    const msg = JSON.parse(line) as {
+      id?: number;
+      method?: string;
+      params?: { requestId?: number };
+    };
+    if (msg.method === "initialize" && msg.id !== undefined) {
+      reply({
+        jsonrpc: "2.0",
+        id: msg.id,
+        result: {
+          protocolVersion: "2024-11-05",
+          capabilities: {},
+          serverInfo: { name: "fake-qmd", version: "2.5.3" },
+        },
+      });
+      return;
+    }
+    if (msg.method === "notifications/cancelled") {
+      const requestId = msg.params?.requestId;
+      if (requestId !== undefined && held === requestId) {
+        const timer = holdTimers.get(requestId);
+        if (timer) clearTimeout(timer);
+        setTimeout(() => {
+          if (held === requestId) held = null;
+          const next = queue.shift();
+          if (next !== undefined) {
+            reply({
+              jsonrpc: "2.0",
+              id: next,
+              result: { structuredContent: { results: [{ docid: "next" }] } },
+            });
+          }
+        }, 40);
+      }
+      return;
+    }
+    if (msg.method === "tools/call" && msg.id !== undefined) {
+      queue.push(msg.id);
+      serveNext(reply);
+    }
+  };
+}
+
+function parsedLines(lines: string[]): Array<Record<string, unknown>> {
+  return lines.map((line) => JSON.parse(line) as Record<string, unknown>);
+}
+
+async function startedSession(lines: string[]): Promise<QmdDaemonSession> {
+  const session = new QmdDaemonSession("qmd", {}, undefined, () => createScriptedChild(scriptedQueryServer(lines)));
+  assert.equal(await session.start(), true);
+  return session;
+}
+
+test("an aborted tool call cancels the worker and the next call is not stuck behind it", async () => {
+  const lines: string[] = [];
+  const session = await startedSession(lines);
+  const ac = new AbortController();
+  const first = session.callTool("query", { query: "abandoned" }, 30_000, ac.signal);
+  await delay(15);
+  ac.abort();
+  await assert.rejects(first, (err: Error) => err.name === "AbortError");
+
+  const firstTool = parsedLines(lines).find((msg) => msg.method === "tools/call");
+  const cancel = parsedLines(lines).find((msg) => msg.method === "notifications/cancelled");
+  assert.ok(firstTool);
+  assert.ok(cancel);
+  const params = cancel?.params as { requestId?: number; reason?: string };
+  assert.equal(params.requestId, firstTool?.id);
+  assert.equal(params.reason, "client aborted");
+
+  const started = Date.now();
+  const second = await session.callTool("query", { query: "next" }, 30_000);
+  const elapsed = Date.now() - started;
+  assert.ok(elapsed < 400, `following call took ${elapsed}ms; it queued behind the abandoned rerank`);
+  const structured = (second as { structuredContent?: { results?: Array<{ docid?: string }> } }).structuredContent;
+  assert.equal(structured?.results?.[0]?.docid, "next");
+  await session.close();
+});
+
+test("a timed-out tool call cancels the worker and the next call is not stuck behind it", async () => {
+  const lines: string[] = [];
+  const session = await startedSession(lines);
+  await assert.rejects(session.callTool("query", { query: "slow" }, 80), /timed out/);
+
+  const firstTool = parsedLines(lines).find((msg) => msg.method === "tools/call");
+  const cancel = parsedLines(lines).find((msg) => msg.method === "notifications/cancelled");
+  const params = cancel?.params as { requestId?: number; reason?: string };
+  assert.equal(params?.requestId, firstTool?.id);
+  assert.match(String(params?.reason), /timed out/);
+
+  const started = Date.now();
+  await session.callTool("query", { query: "next" }, 30_000);
+  const elapsed = Date.now() - started;
+  assert.ok(elapsed < 400, `following call took ${elapsed}ms; it queued behind the timed-out rerank`);
+  await session.close();
+});
+
+type SearchInternals = {
+  available: boolean;
+  daemonAvailable: boolean;
+  maybeProbeDaemon: () => Promise<void>;
+  searchViaDaemon: (
+    query: string,
+    collection: string | undefined,
+    maxResults: number,
+    options: unknown,
+    signal?: AbortSignal
+  ) => Promise<QmdSearchResult[] | null>;
+};
+
+function daemonClient(): { client: QmdClient; internals: SearchInternals } {
+  const client = new QmdClient("memories", 5, { daemonRecheckIntervalMs: 60_000 });
+  const internals = client as unknown as SearchInternals;
+  internals.maybeProbeDaemon = async () => {
+    internals.available = true;
+    internals.daemonAvailable = true;
+  };
+  return { client, internals };
+}
+
+const hit = (docid: string): QmdSearchResult => ({
+  docid,
+  path: "memory.md",
+  snippet: "",
+  score: 1,
+  transport: "daemon",
+});
+
+test("identical search() calls share one daemon query until the last waiter aborts", async () => {
+  const { client, internals } = daemonClient();
+  let calls = 0;
+  let shared: AbortSignal | undefined;
+  let release: (value: QmdSearchResult[]) => void = () => {};
+  internals.searchViaDaemon = (_query, _collection, _maxResults, _options, signal) => {
+    calls += 1;
+    shared = signal;
+    return new Promise((resolve) => {
+      release = resolve;
+    });
+  };
+
+  const query = "joiner-share-recall-plan";
+  const first = client.search(query, "memories", 5);
+  const second = client.search(query, "memories", 5);
+  await delay(10);
+  assert.equal(calls, 1);
+
+  const ac = new AbortController();
+  const leaving = client.search(query, "memories", 5, undefined, { signal: ac.signal });
+  await delay(5);
+  assert.equal(calls, 1);
+  ac.abort();
+  await assert.rejects(leaving, (err: Error) => err.name === "AbortError");
+  assert.equal(shared?.aborted, false);
+
+  release([hit("kept")]);
+  const [a, b] = await Promise.all([first, second]);
+  assert.equal(a[0]?.docid, "kept");
+  assert.equal(b[0]?.docid, "kept");
+});
+
+test("the only in-flight search() abort cancels the shared daemon call", async () => {
+  const { client, internals } = daemonClient();
+  let calls = 0;
+  let shared: AbortSignal | undefined;
+  internals.searchViaDaemon = (_query, _collection, _maxResults, _options, signal) => {
+    calls += 1;
+    shared = signal;
+    return new Promise((_resolve, reject) => {
+      signal?.addEventListener("abort", () => reject(abortError("daemon aborted")));
+    });
+  };
+
+  const ac = new AbortController();
+  const pending = client.search("joiner-sole-abort", "memories", 5, undefined, { signal: ac.signal });
+  await delay(10);
+  assert.equal(calls, 1);
+  ac.abort();
+  await assert.rejects(pending, (err: Error) => err.name === "AbortError");
+  assert.equal(shared?.aborted, true);
+
+  const pre = new AbortController();
+  pre.abort();
+  await assert.rejects(
+    client.search("joiner-pre-aborted", "memories", 5, undefined, { signal: pre.signal }),
+    (err: Error) => err.name === "AbortError"
+  );
+  assert.equal(calls, 1);
+});
+
+test("a caller joining after the last waiter aborted starts a fresh call", async () => {
+  const joiner = createInflightJoiner<string>();
+  let runs = 0;
+  const run = (signal: AbortSignal) => {
+    runs += 1;
+    const id = runs;
+    return new Promise<string>((resolve, reject) => {
+      // The aborted call settles late, so its slot is still in the map when the
+      // second caller joins.
+      signal.addEventListener("abort", () => setTimeout(() => reject(abortError("run aborted")), 40));
+      setTimeout(() => resolve(`run${id}`), 80);
+    });
+  };
+  const ac = new AbortController();
+  const first = joiner.join("same", ac.signal, run);
+  await delay(5);
+  ac.abort();
+  await assert.rejects(first, (err: Error) => err.name === "AbortError");
+  assert.equal(await joiner.join("same", undefined, run), "run2");
+  assert.equal(runs, 2);
+});
+
+test("blank stdout lines are skipped and later replies still parse", async () => {
+  const lines: string[] = [];
+  let child: { stdout: EventEmitter } | undefined;
+  const session = new QmdDaemonSession("qmd", {}, undefined, () => {
+    const created = createScriptedChild(scriptedQueryServer(lines));
+    child = created as unknown as { stdout: EventEmitter };
+    return created;
+  });
+  assert.equal(await session.start(), true);
+  child?.stdout.emit("data", Buffer.from("\n   \n\r\n"));
+  const reply = (await session.callTool("query", { query: "after-blank" }, 30_000)) as {
+    structuredContent?: { results?: unknown[] };
+  };
+  assert.deepEqual(reply.structuredContent?.results, []);
+  await session.close();
+});

package/src/qmd-mcp-cancel.ts

@@ -0,0 +1,130 @@
+import { abortError } from "./abort-error.js";
+
+/**
+ * One in-flight daemon search shared by identical callers.
+ * The shared signal aborts only when every waiter has aborted, which is
+ * what tells the QMD process to stop. One caller giving up must not cancel
+ * a sibling that still wants the result.
+ */
+export type InflightJoiner<T> = {
+  join(key: string, signal: AbortSignal | undefined, run: (signal: AbortSignal) => Promise<T>): Promise<T>;
+};
+
+type InflightSlot<T> = {
+  controller: AbortController;
+  refs: number;
+  promise: Promise<T>;
+};
+
+export function createInflightJoiner<T>(): InflightJoiner<T> {
+  const slots = new Map<string, InflightSlot<T>>();
+
+  return {
+    join(key, signal, run) {
+      if (signal?.aborted) {
+        return Promise.reject(abortError("QMD inflight search aborted"));
+      }
+      let slot = slots.get(key);
+      // A slot whose last waiter already aborted is doomed; its promise settles
+      // late. Never hand it to a new caller.
+      if (slot?.controller.signal.aborted) slot = undefined;
+      if (!slot) {
+        const controller = new AbortController();
+        const created: InflightSlot<T> = {
+          controller,
+          refs: 0,
+          promise: Promise.resolve() as Promise<T>,
+        };
+        slots.set(key, created);
+        created.promise = new Promise<T>((resolve, reject) => {
+          try {
+            resolve(run(controller.signal));
+          } catch (err) {
+            reject(err);
+          }
+        }).finally(() => {
+          if (slots.get(key) === created) slots.delete(key);
+        });
+        // A cancel with no remaining waiter rejects this promise after the
+        // waiter has already settled. Swallow that so it is not unhandled.
+        created.promise.catch(() => {});
+        slot = created;
+      }
+      return attachWaiter(slot, signal);
+    },
+  };
+}
+
+function attachWaiter<T>(slot: InflightSlot<T>, signal?: AbortSignal): Promise<T> {
+  if (signal?.aborted) {
+    return Promise.reject(abortError("QMD inflight search aborted"));
+  }
+  slot.refs += 1;
+  let settled = false;
+
+  return new Promise<T>((resolve, reject) => {
+    const finish = (abortShared: boolean, settle: () => void) => {
+      if (settled) return;
+      settled = true;
+      if (onAbort) signal?.removeEventListener("abort", onAbort);
+      slot.refs -= 1;
+      if (slot.refs < 0) slot.refs = 0;
+      if (abortShared && slot.refs === 0) {
+        slot.controller.abort();
+      }
+      settle();
+    };
+    const onAbort = () => {
+      finish(true, () => reject(abortError("QMD inflight search aborted")));
+    };
+    if (signal) {
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (signal.aborted) {
+        onAbort();
+        return;
+      }
+    }
+    slot.promise.then(
+      (value) => finish(false, () => resolve(value)),
+      (err) => finish(false, () => reject(err))
+    );
+  });
+}
+
+/**
+ * Score documents on a shared cursor and stop between documents when
+ * `signal` aborts. In-flight `rankIndex` calls finish; later indexes
+ * are not started. A cancelled batch throws and does not return scores.
+ *
+ * `docs/patches/qmd-2.8.3-mcp-cancel.patch` uses the same loop inside
+ * QMD's reranker. `rank()` and `rankAll()` share one evaluate path, so
+ * a document that finishes has the same score either way.
+ */
+export async function rankDocumentsUntilAbortParallel<T>(
+  count: number,
+  parallelism: number,
+  signal: AbortSignal | undefined,
+  rankIndex: (index: number) => Promise<T>
+): Promise<T[]> {
+  if (signal?.aborted) {
+    throw abortError("qmd rerank aborted");
+  }
+  if (count <= 0) return [];
+  const scores = new Array<T>(count);
+  let cursor = 0;
+  const workers = Math.max(1, Math.min(Math.floor(parallelism) || 1, count));
+  await Promise.all(
+    Array.from({ length: workers }, async () => {
+      while (true) {
+        if (signal?.aborted) return;
+        const index = cursor++;
+        if (index >= count) return;
+        scores[index] = await rankIndex(index);
+      }
+    })
+  );
+  if (signal?.aborted) {
+    throw abortError("qmd rerank aborted");
+  }
+  return scores;
+}

package/src/qmd-preflight.ts

@@ -29,7 +29,7 @@ export const QMD_PROBE_TIMEOUT_MS = 8_000;
 // Length == number of retries after the initial attempt. Issue #1841.
 export const QMD_PROBE_RETRY_BACKOFF_MS = [300, 800];
 
-export const QMD_SUPPORTED_VERSION = "2.5.3";
+export const QMD_SUPPORTED_VERSION = "2.8.3";
 
 /**
  * Classify a `qmd --version` probe failure so the preflight can distinguish a
@@ -148,6 +148,15 @@ export function shouldAutoUpgradeQmd(
   return compareQmdVersions(installed, supported) < 0;
 }
 
+/** First QMD release that needs the pinned, patched build (docs/qmd-2.8.3.md); stock npm lacks the patches. */
+const QMD_PATCHED_BUILD_MIN: QmdVersionTuple = [2, 8, 3];
+
+/** False when `npm install -g @tobilu/qmd@<supported>` would install stock QMD instead of the patched build. */
+export function autoUpgradeInstallsStockPackage(supportedVersion: string): boolean {
+  const supported = parseQmdVersion(supportedVersion);
+  return supported !== null && compareQmdVersions(supported, QMD_PATCHED_BUILD_MIN) < 0;
+}
+
 export function getQmdPostInstallProbeTargets(
   qmdPath: string,
   qmdPathSource: "configured" | "auto-path" | "auto-fallback"

package/src/qmd-rank-compare.test.ts

@@ -0,0 +1,100 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { compareRankedLists, compareDirectories, compareRerankOff, formatComparison, spearman } from "../../../scripts/recall-qmd-compare.mjs";
+
+const row = (docid: string) => ({ docid, score: 1 });
+
+test("identical rankings match on top-1, overlap, and correlation", () => {
+  const ranked = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"].map(row);
+  const compared = compareRankedLists(ranked, ranked);
+  assert.equal(compared.top1Match, true);
+  assert.equal(compared.top10Overlap, 10);
+  assert.ok(Math.abs((compared.spearman ?? NaN) - 1) < 1e-9);
+});
+
+test("a swap keeps top-1 and reports the rank correlation", () => {
+  const before = ["a", "b", "c"].map(row);
+  const after = ["a", "c", "b"].map(row);
+  const compared = compareRankedLists(before, after);
+  assert.equal(compared.top1Match, true);
+  assert.equal(compared.top10Overlap, 3);
+  assert.ok(Math.abs((compared.spearman ?? NaN) - 0.5) < 1e-9);
+});
+
+test("disjoint top-10 lists do not match and correlation is negative", () => {
+  const before = ["a", "b", "c"].map(row);
+  const after = ["d", "e", "f"].map(row);
+  const compared = compareRankedLists(before, after);
+  assert.equal(compared.top1Match, false);
+  assert.equal(compared.top10Overlap, 0);
+  assert.ok((compared.spearman ?? 0) < 0);
+});
+
+test("spearman is 1 for tied constant ranks and -1 for a reversal", () => {
+  assert.equal(spearman([1, 1, 1], [4, 4, 4]), 1);
+  assert.ok(Math.abs((spearman([1, 2, 3], [3, 2, 1]) ?? NaN) + 1) < 1e-9);
+});
+
+test("an empty ranking against a non-empty one is not perfect correlation", () => {
+  const compared = compareRankedLists([], ["a", "b", "c"].map(row));
+  assert.equal(compared.top10Overlap, 0);
+  assert.equal(compared.spearman, null);
+  assert.equal(spearman([11, 11], [1, 2]), null);
+  assert.equal(spearman([1], [1]), 1);
+  assert.equal(spearman([1], [11]), null);
+});
+
+function resultFile(dir: string, name: string, docids: string[]): void {
+  writeFileSync(join(dir, name), JSON.stringify({ results: docids.map(row) }));
+}
+
+test("a missing or unreadable counterpart is reported, not dropped", () => {
+  const before = mkdtempSync(join(tmpdir(), "qmd-cmp-b-"));
+  const after = mkdtempSync(join(tmpdir(), "qmd-cmp-a-"));
+  resultFile(before, "q1.json", ["a", "b"]);
+  resultFile(before, "q2.json", ["a", "b"]);
+  resultFile(before, "q3.json", ["a", "b"]);
+  resultFile(after, "q1.json", ["a", "b"]);
+  writeFileSync(join(after, "q3.json"), "{not json");
+  const rows = compareDirectories(before, after);
+  assert.deepEqual(rows.filter((r) => r.missing).map((r) => r.name), ["q2.json", "q3.json"]);
+  assert.match(formatComparison(rows), /summary queries=3 compared=1 missing=2 empty_side=0/);
+});
+
+test("rerank-off reports a daemon file with no norerank twin instead of throwing", () => {
+  const dir = mkdtempSync(join(tmpdir(), "qmd-cmp-r-"));
+  resultFile(dir, "q1-daemon.json", ["a", "b"]);
+  resultFile(dir, "q1-norerank.json", ["a", "b"]);
+  resultFile(dir, "q2-daemon.json", ["a", "b"]);
+  const rows = compareRerankOff(dir);
+  assert.equal(rows.length, 2);
+  assert.equal(rows.filter((r) => r.missing).length, 1);
+});
+
+test("files present on only one side, an invalid results field, and a one-sided empty ranking are all reported", () => {
+  const before = mkdtempSync(join(tmpdir(), "qmd-cmp-b2-"));
+  const after = mkdtempSync(join(tmpdir(), "qmd-cmp-a2-"));
+  resultFile(before, "q1.json", ["a", "b"]);
+  writeFileSync(join(after, "q1.json"), "{}");
+  resultFile(after, "q2.json", ["a"]);
+  resultFile(before, "q3.json", ["a", "b"]);
+  resultFile(after, "q3.json", []);
+  const rows = compareDirectories(before, after);
+  assert.deepEqual(rows.map((r) => r.name), ["q1.json", "q2.json", "q3.json"]);
+  assert.deepEqual(rows.map((r) => Boolean(r.missing)), [true, true, false]);
+  assert.equal(rows[2]?.oneSidedEmpty, true);
+  assert.match(formatComparison(rows), /missing=2 empty_side=1/);
+  // an empty before dir with captures only in after must not look clean
+  const emptyBefore = mkdtempSync(join(tmpdir(), "qmd-cmp-b3-"));
+  assert.equal(compareDirectories(emptyBefore, after).every((r) => r.missing), true);
+});
+
+test("rerank-off reports a norerank capture that has no daemon twin", () => {
+  const dir = mkdtempSync(join(tmpdir(), "qmd-cmp-r2-"));
+  resultFile(dir, "q1-norerank.json", ["a", "b"]);
+  const rows = compareRerankOff(dir);
+  assert.deepEqual(rows.map((r) => [r.name, Boolean(r.missing)]), [["q1-daemon.json", true]]);
+});