@@ -422,6 +422,7 @@ each line — is in the ADR named beside it and in
 | **No dispatch input reaches a shell**: `${{ inputs.x }}` inside a `run:` block is substitution *before* the shell parses, so inputs arrive through `env:` and then an argv array. Enforced across **every** workflow, not only the newest | [ADR-0033](adr/0033-the-collector-refuses-rather-than-degrades.md), ADR-0020 |
 | The collector's spend gate is a **protected environment whose existence is proven**, because GitHub silently creates an *unprotected* one when a workflow names a missing environment; a missing credential **refuses** rather than falling back to a keyless route | ADR-0033 |
 | A claim's **support is weighed, not just checked**: `corroboration` reports whether a closed unknown rests on one reading, several readings of one source, a **republished copy of one document across hosts** (`mirror`, via `lib/similarity.mjs`), or genuinely distinct documents — it never fails a corpus on its own, because single-sourcing is often the right answer. Rows are **deduped by id first**: `citedIds` returns every `E-##` mention, so prose naming one row twice used to produce it twice, and once grouping folded the duplicate it reported a "republished copy" about a row that was merely mentioned twice | [ADR-0036](adr/0036-the-gate-can-see-single-sourcing.md) |
+| `corroboration` **reports the closest pair it measured** on an `independent` verdict, and does not act on it. The threshold has two measured blind spots, and containment - the obvious repair for the second - ranks a genuinely different pair (0.506) ABOVE a real mirror (0.380) over 2404 pairs, so trying harder would report second sources as copies. The number informs a reviewer; the grade does not move | ADR-0036 |
 | A finding a reviewer has **considered and overruled** is recorded, not repeated forever: `[single-witness: …]` in an unknown's Evidence cell and `[render-reviewed: …]` in an evidence row's Finding cell turn a true-but-permanent warning into a pass **that prints the reason**. A reason under 30 characters is named (`single-witness-unreasoned`) rather than obeyed, and a note left on an unknown that has since been corroborated is reported (`single-witness-stale`) so the acknowledgement cannot rot. The render note lives on the ROW because `verifyLedger` hashes the whole capture file — a capture is evidence and stays byte-immutable, a judgement about it is corpus prose | [ADR-0038](adr/0038-a-judgement-the-gate-can-read.md) |
 | The collector lock is exclusive **on a local filesystem, and not promised on a network one**: Node states "the exclusive flag might not work with network file systems", a condition ADR-0020 never carried. Measured 2026-09-22 - 24 racers, 1 winner, 23 EEXIST on win32 - so the guarantee holds where it was tested and nothing detects where it is standing. Evidence: `docs/decisions/2026-09-22-wx-lock/` | ADR-0020 |
 | An entrypoint **refuses a flag it does not know** rather than ignoring it: `refuseUnknownFlags` in `lib/core.mjs`, called immediately after `parseFlags` in all eleven bins. `parseFlags` knows no flag names by design, so an entrypoint that skips the check gets silence — the flag is parsed, never read, and the command proceeds to its default. On 2026-09-22 that default was **a real collection**: `research.mjs --totally-made-up-flag` spent 26 credits against this repository's corpus, and `audit.mjs` wrote twelve files. The same survey found a dead `--max-scrapes` in two workflows, where the page bound people believed it set was really `plan.maxScrapes` — real in `collect.yml`, and **absent** in `live-collection.yml`, whose `max_pages` was validated and then ignored | ADR-0020 |
 
@@ -262,6 +262,53 @@ dilution pushes such pairs down. The threshold was chosen from a 14× gap; this
 the observed gap to about 1.6×. That is not a failure and it is not a reason to move the line
 on one data point — it is the note that the line is now known to have traffic near it.
 
+## A second blind spot, and why the obvious repair was rejected, 2026-09-22
+
+Using the kit on an unrelated question surfaced a mirror the check does not catch.
+`node.readthedocs.io` is an unofficial copy of the Node.js documentation and scored **0.054**
+against `nodejs.org` — nowhere near the 0.25 line. Both pages carry the same caveat in drifted
+wording ("might not" against "may or may not work with network file systems"), so they are one
+document at two vintages, exactly the case this check exists for.
+
+**The cause is the metric, not the number.** Jaccard is `|A n B| / |A u B|`, which is symmetric:
+a 29 KB snapshot inside a 465 KB current page scores low however completely it is contained,
+because the union is dominated by everything the live page has since grown.
+
+### Containment was measured and is worse
+
+The textbook repair is containment, `|A n B| / min(|A|,|B|)` — "what fraction of the smaller
+document is in the larger". Measured over **2404 pairs** in this repository, cross-host only,
+since the mirror rule never fires within a host:
+
+| pair | Jaccard | containment |
+|---|---|---|
+| `node.readthedocs.io` × `nodejs.org` — a real mirror | 0.054 | **0.380** |
+| `modelcontextprotocol.io` × its own `GOVERNANCE.md` — genuinely different | 0.136 | **0.506** |
+
+**The genuine pair outranks the mirror.** Any threshold catching the mirror at 0.380 also flags a
+legitimate second source at 0.506 — and the remedy a reviewer reaches for on a `mirror` finding
+is to drop one of the rows. A check that tried harder here would delete real corroboration.
+
+So the repair is refused, and refused on measurement rather than on taste.
+
+### What ships instead: the number, not a verdict
+
+`independent` now reports the closest pair among the rows it counted —
+`rests on 3 distinct documents across 3 hosts; closest pair 0.16`. The grade is unchanged.
+
+Across this repository the reported values run 0.00 to 0.16, and the single 0.16 is the
+`modelcontextprotocol.io`/`GOVERNANCE.md` pair that had to be checked by hand. A reviewer
+seeing 0.16 is pointed at the one pair worth a look; a reviewer seeing 0.00 is not. That is
+the honest limit of a mechanical check: it can say how close two documents came, and it cannot
+say whether that closeness means anything.
+
+### An accounting error found in passing
+
+`similarity.test.mjs` used `node:test` while every other file uses the shared harness, so its
+**ten tests ran and were never counted** — the suite reported 845 while executing 855. The file
+is converted to the harness. The count guard exists because "a stale count is the first claim a
+reader checks"; a count that silently omits a whole file is the same failure from the inside.
+
 ## What this ADR does not claim
 
 That two hosts make a claim true. Two vendors can repeat one another, and a specification
 
@@ -395,7 +395,7 @@ node research-kit/bin/selftest.mjs            # all of it
 node research-kit/bin/selftest.mjs gate hook  # just these files
 ```
 
-845 tests, offline, no key and no network. The runner **awaits** every test, so `ok` means
+855 tests, offline, no key and no network. The runner **awaits** every test, so `ok` means
 the assertions settled (ADR-0021), and each test is raced against a watchdog
 (`RESEARCH_KIT_TEST_TIMEOUT`, default 60s).
 
 
@@ -9,7 +9,7 @@
 
 import { hostOf, PATHS, resolve, exists, ageInDays } from './core.mjs';
 import { captureOf, traceOf, citedIds } from './corpus.mjs';
-import { documentGroups } from './similarity.mjs';
+import { documentGroups, closestPair } from './similarity.mjs';
 import { coverageOfUniversals } from './dimensions.mjs';
 import { verifyLedger } from './provenance.mjs';
 
@@ -635,7 +635,8 @@ function corroboration(corpus) {
         // Several hosts is where the host heuristic used to stop and say `independent`. A
         // mirror passes that test while carrying LESS than either genuine page, so the rows
         // are grouped into distinct DOCUMENTS before the hosts are counted again.
-        const groups = documentGroups(rows.map((row) => corpus.captures.sketches?.get(captureOf(corpus, row)?.file) ?? null));
+        const sketches = rows.map((row) => corpus.captures.sketches?.get(captureOf(corpus, row)?.file) ?? null);
+        const groups = documentGroups(sketches);
         if (groups.length === 1) {
           shape = { rule: 'mirror', detail: `cites ${rows.length} rows across ${hosts.size} hosts but they are the same document - a republished copy is one witness, and the copy may be the stale one` };
         } else {
@@ -646,11 +647,18 @@ function corroboration(corpus) {
             shape = { rule: 'one-voice', detail: `cites ${rows.length} rows across ${hosts.size} hosts, but after grouping republished copies only ${[...distinctHosts][0]} remains - one voice` };
           } else {
             const mirrored = rows.length - groups.length;
+            const closest = closestPair(sketches);
             shape = {
               corroborated: true,
               rule: 'independent',
+              // The closest pair is REPORTED, never acted on. The threshold has two measured
+              // blind spots and containment - the obvious repair - ranks a genuinely
+              // different pair above a real mirror, so trying harder would report second
+              // sources as copies. A number a reviewer can act on beats a verdict that
+              // pretends to more certainty than the measurement supports.
               detail: `rests on ${groups.length} distinct documents across ${distinctHosts.size} hosts`
-                + (mirrored ? ` (${mirrored} of ${rows.length} rows are republished copies and were not counted twice)` : ''),
+                + (mirrored ? ` (${mirrored} of ${rows.length} rows are republished copies and were not counted twice)` : '')
+                + (closest === null ? '' : `; closest pair ${closest.toFixed(2)}`),
             };
           }
         }
 
@@ -101,6 +101,36 @@ export function isMirror(a, b) {
   return score === null ? false : score >= MIRROR_THRESHOLD;
 }
 
+/**
+ * The closest any two of these sketches came, or `null` if fewer than two are judgeable.
+ *
+ * WHY THIS IS REPORTED RATHER THAN ACTED ON. The threshold has two measured blind spots and
+ * neither is closable with a better number:
+ *
+ *   - a stale mirror of a page that has since GROWN scores low, because the shared text is
+ *     diluted by everything the current page gained (`node.readthedocs.io` vs `nodejs.org`,
+ *     0.054 at a 6.4x size ratio);
+ *   - and CONTAINMENT, the obvious repair for that, ranks a genuinely different pair ABOVE
+ *     that mirror (0.506 for `modelcontextprotocol.io` vs its own `GOVERNANCE.md`, against
+ *     0.380 for the mirror). Measured over 2404 pairs on 2026-09-22.
+ *
+ * So a check that tried harder here would start reporting real second sources as copies,
+ * and the remedy a reviewer would reach for - dropping one - is the opposite of what the
+ * corpus needs. The number is surfaced instead: `independent (closest pair 0.38)` invites a
+ * look, `closest pair 0.00` does not, and neither changes the verdict.
+ */
+export function closestPair(sketches) {
+  let best = null;
+  for (let i = 0; i < sketches.length; i += 1) {
+    for (let j = i + 1; j < sketches.length; j += 1) {
+      const score = similarity(sketches[i], sketches[j]);
+      if (score === null) continue;
+      if (best === null || score > best) best = score;
+    }
+  }
+  return best;
+}
+
 /**
  * Group rows into distinct DOCUMENTS. Each group is a set of indices whose sketches are
  * near-duplicates of one another.
 
@@ -10,18 +10,17 @@
 // used to grade `independent` and now grade `mirror` - is proven at the check level, in
 // checks.test.mjs, which is where the old behaviour actually existed.
 
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { test, describe, assert, fs, path } from './harness.mjs';
 
 import { parseCapture } from '../lib/corpus.mjs';
 import {
-  sketch, similarity, shingles, documentGroups, isMirror,
+  sketch, similarity, shingles, documentGroups, isMirror, closestPair,
   MIRROR_THRESHOLD, MIN_SHINGLES,
 } from '../lib/similarity.mjs';
 
+describe('similarity');
+
 const here = path.dirname(fileURLToPath(import.meta.url));
 const repo = path.resolve(here, '..', '..');
 const seaRaw = path.join(repo, 'docs', 'decisions', '2026-09-21-sea-assets', 'research', 'raw');
@@ -106,3 +105,35 @@ test('unjudgeable rows each stand alone rather than merging', () => {
   // Two nulls must not become one group: "I cannot tell" is not "they are the same".
   assert.equal(documentGroups([null, null]).length, 2);
 });
+
+// ---------------------------------------------------------------- closestPair
+
+test('closestPair reports the tightest pair, and null when nothing is judgeable', () => {
+  const canonical = sketch(body(seaRaw, '-nodejs-'));
+  const mirrored = sketch(body(seaRaw, 'epac'));
+  const other = sketch(body(seaRaw, 'bundling'));
+
+  // The mirror is the tightest pair present, so it is what gets reported.
+  const three = closestPair([canonical, mirrored, other]);
+  assert.ok(three > 0.35 && three <= 1, `expected the mirror to dominate, got ${three}`);
+  assert.equal(closestPair([canonical, mirrored]), similarity(canonical, mirrored));
+
+  assert.equal(closestPair([]), null, 'nothing to compare is null, not 0');
+  assert.equal(closestPair([canonical]), null, 'one document has no pair');
+  assert.equal(closestPair([null, null]), null, 'unjudgeable pairs report null, never 0');
+});
+
+test('closestPair is REPORTED, not acted on - the verdict does not move with it', () => {
+  // The measured reason, recorded so nobody "fixes" this into a blocking rule later:
+  // containment - the obvious repair for a size-mismatched mirror - ranks a genuinely
+  // different pair (0.506) ABOVE a real mirror (0.380). A check that tried harder would
+  // report real second sources as copies, and the remedy a reviewer reaches for is to drop
+  // one. So the number informs and the grade is unchanged.
+  const canonical = sketch(body(seaRaw, '-nodejs-'));
+  const other = sketch(body(seaRaw, 'bundling'));
+  const score = closestPair([canonical, other]);
+  assert.ok(score !== null);
+  assert.ok(score < MIRROR_THRESHOLD, 'this pair must remain below the mirror line');
+  // Two distinct documents stay two distinct documents whatever the number says.
+  assert.equal(documentGroups([canonical, other]).length, 2);
+});