@@ -426,6 +426,7 @@ each line — is in the ADR named beside it and in
 | A reviewer note is **not a citation**: `stripReviewNotes` in lib/corpus.mjs removes `[single-witness: ...]` and `[render-reviewed: ...]` before `citedIds` runs. Those notes are prose written INSIDE the same cell the citations are read from, so explaining why no second witness exists - by pointing at a row that demonstrates it - turned that row into a citation, and the unknown read as corroborated while its own note denied it. It caught its author three times in two days across three projects; the guard was right every time and the mechanism was the problem. The raw cell is untouched, because the check that reads the reason needs it | ADR-0038 |
 | 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 |
+| With a SerpAPI key present the search side asks **BOTH providers and interleaves by rank** (`mergeByRank`, lib/research-run.mjs). The meters are separate, so each is asked once rather than either more. Round-robin is the point: on 2026-09-22 one provider returned eight US financial-regulation pages for a question about EU deforestation and the other returned seventeen on topic, and concatenation would have spent the whole page budget before reaching the working one. Every merged row carries the provider that surfaced it, so the ledger keeps a claim about search quality checkable. An explicitly pinned provider stays single, because pinning exists to make two runs comparable | ADR-0027 |
 | The SEARCH side is **selectable at dispatch**: collect.yml takes a search_transport input (auto | serpapi | firecrawl-cli) and collect-remote.mjs a matching --search-transport, passed as RESEARCH_KIT_SEARCH_TRANSPORT. ADR-0027 built the ladder and the collector never exposed it, so a dispatched run always took whatever auto-detect picked and two providers could not be compared on one topic through the kit at all. auto becomes the EMPTY STRING, falsy in the ladder, so the default is the previous behaviour exactly | ADR-0027 |
 | A **rate limit is an instruction to wait, not a failure**: `rateLimitWaitMs` (lib/firecrawl.mjs) reads the delay the vendor states in its own error text, and `collectOne` sleeps and retries, bounded at two. Firecrawl free tier allows 10 requests a minute and the collector did not throttle, so a run started inside a busy minute shed six of eight fetches and recorded them as ordinary failures. The vendor number is used rather than an invented backoff, for the reason the kit researched for Retry-After: when a server says when to come back, that is the number. Non-rate-limit errors are NOT retried - a 404 does not become a 200 if you wait | ADR-0005 |
 | A collection reports **how much of the topic own vocabulary reached the captures** - `topicMatch` in lib/research-run.mjs, printed by bin/research.mjs right after collecting and deciding nothing. It exists because a run returned eight captures about US financial regulation for a question about EU deforestation and passed every structural check: no check asks whether the evidence is about the topic. Two thresholds were measured and REJECTED - per-capture 0.5 flags RFC 9728 in the agent-interface corpus, which never says MCP and is an independent witness precisely because it does not; per-corpus at-least-one-strong flags delivery-architecture, which scores identically to the genuine failure because its topic is internal vocabulary and its evidence is GitHub docs. Telling those apart needs meaning (ADR-0013), so the number is surfaced at the moment a reviewer can act on it and the grade does not move | ADR-0013 |
 
@@ -395,7 +395,7 @@ node research-kit/bin/selftest.mjs            # all of it
 node research-kit/bin/selftest.mjs gate hook  # just these files
 ```
 
-867 tests, offline, no key and no network. The runner **awaits** every test, so `ok` means
+872 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).
 
 
@@ -102,6 +102,7 @@ if (!chosen.search.sameAsFetch) {
 const run = runResearch(root, {
   adapter: chosen.adapter,
   searchAdapter: chosen.search.adapter,
+  searchAdapters: chosen.search.adapters ?? null,
   plan: typeof flags.plan === 'string' ? readPlan(root, flags.plan) : null,
   depth: typeof flags.depth === 'string' ? flags.depth : '',
   refreshDays: flags['refresh-days'] === undefined ? null : Number(flags['refresh-days']),
 
@@ -63,6 +63,39 @@ export function rankCandidate(url, { prefer = [], why = '' } = {}) {
   return value;
 }
 
+/**
+ * Interleave several providers' results by RANK, not by concatenation.
+ *
+ * WHY RANK AND NOT ORDER. On 2026-09-22 a search for the EU Deforestation Regulation
+ * returned, from one provider, eight pages about US financial regulation and nothing about
+ * the subject - while the other returned seventeen, all on topic. Concatenating would have
+ * let the failing provider spend the entire page budget before the working one was reached.
+ * Round-robin bounds that: each provider contributes its best result, then its second, and
+ * a provider that is wholly wrong costs at most its share.
+ *
+ * `provider` is carried on every row so the ledger records WHICH search surfaced a URL -
+ * that is how a claim about search quality stays checkable afterwards instead of being an
+ * impression.
+ *
+ * Duplicates are the interesting case rather than a nuisance: when both providers return the
+ * same URL the first occurrence wins and keeps its finder, so the count of rows attributed
+ * to each provider is not inflated by agreement.
+ */
+export function mergeByRank(lists) {
+  const merged = [];
+  const taken = new Set();
+  const depth = Math.max(0, ...lists.map((l) => l.results.length));
+  for (let rank = 0; rank < depth; rank += 1) {
+    for (const list of lists) {
+      const row = list.results[rank];
+      if (!row?.url || taken.has(row.url)) continue;
+      taken.add(row.url);
+      merged.push({ ...row, provider: list.provider });
+    }
+  }
+  return merged;
+}
+
 export function selectCandidates(results, { prefer = [], perQuery = 3, seen = new Set() } = {}) {
   return results
     .map((row) => ({ ...row, score: rankCandidate(row.url, { prefer }) }))
@@ -83,6 +116,8 @@ export function runResearch(root, {
   // The SEARCH side (ADR-0027). Absent means "the fetch adapter", which is what every
   // caller did before the split - so an un-updated caller behaves exactly as before.
   searchAdapter = null,
+  // Several providers: asked in parallel and interleaved by rank. One stays one.
+  searchAdapters = null,
   plan = null,
   depth = '',
   refreshDays = null,
@@ -147,7 +182,8 @@ ${compatibility.remedy}`);
   let searchFailures = 0;
   let degraded = 0;
 
-  const searcher = searchAdapter ?? adapter;
+  const searchers = (searchAdapters ?? []).filter(Boolean);
+  const searcher = searchAdapter ?? searchers[0] ?? adapter;
   const searchName = searcher?.name ?? adapter?.name ?? '';
 
   const seen = new Set(corpus.captures.entries.map((e) => e.url).filter(Boolean));
@@ -173,6 +209,45 @@ ${compatibility.remedy}`);
       discovered.push({ query: text, results: [], note: 'search not run under --dry-run' });
       continue;
     }
+    // MORE THAN ONE PROVIDER: ask each, interleave by rank, and attribute every row.
+    // The meters are genuinely separate (ADR-0027), so this costs one search on each rather
+    // than more of either. A provider that fails here does not stop the run - the others
+    // still contribute, and the failure is recorded like any other.
+    if (searchers.length > 1) {
+      const lists = [];
+      for (const one of searchers) {
+        const r = one.search(text, { limit: settings.limit });
+        if (Number.isFinite(r.searchesUsed)) searchesUsed += r.searchesUsed;
+        if (!r.ok) {
+          searchFailures += 1;
+          log(`  search failed on ${one.name}: ${r.error}`);
+          appendJsonLine(root, PATHS.failures, {
+            at: new Date().toISOString(), op: 'search', query: text, provider: one.name, error: r.error,
+          });
+          continue;
+        }
+        lists.push({ provider: one.name, results: r.results ?? [] });
+      }
+      if (!lists.length) {
+        log(`  search failed on every provider: ${text}`);
+        continue;
+      }
+      const merged = mergeByRank(lists);
+      log(`  searched   ${lists.map((l) => `${l.provider} ${l.results.length}`).join(', ')} -> ${merged.length} distinct`);
+      discovered.push({ query: text, results: merged, provider: lists.map((l) => l.provider).join('+'), searchId: null });
+      for (const candidate of selectCandidates(merged, { prefer, perQuery: settings.perQuery, seen })) {
+        targets.push({
+          url: candidate.url,
+          type: DEFAULT_SOURCE_TYPE,
+          usedFor: typeof query === 'object' ? (query.why ?? '') : '',
+          from: 'search',
+          rankedBy: candidate.provider ?? '',
+        });
+        seen.add(candidate.url);
+      }
+      continue;
+    }
+
     let found = searcher.search(text, { limit: settings.limit });
     let ranker = searchName;
 
 
@@ -177,11 +177,22 @@ export function selectSearch({ explicit = '', env = process.env, config = null,
   }
 
   if (serpapi.readKey({ env, config: settings })) {
+    // BOTH, not one. The meters are separate, so asking each costs one search apiece rather
+    // than more of either - and on 2026-09-22 that difference was the whole corpus: a query
+    // about the EU Deforestation Regulation returned eight US financial-regulation pages
+    // from SerpAPI and nothing on topic, while the fetch provider's own search returned
+    // seventeen, all on topic. Either provider alone can fail that badly on a given query;
+    // `mergeByRank` bounds the damage by letting each contribute its best result first.
+    //
+    // `adapter` still names the provider that pays the separate meter, so every existing
+    // caller and every status line keeps meaning what it meant.
     return {
       name: serpapi.name,
       adapter: serpapi,
-      why: 'a SerpAPI key is configured - searching on its own meter, leaving the fetch budget for pages',
+      adapters: [serpapi, side.adapter],
+      why: `a SerpAPI key is configured - searching on its own meter AND with ${side.name}, merged by rank`,
       searchOnly: true,
+      merged: true,
     };
   }
 
 
@@ -7,7 +7,8 @@ import { test, describe, assert, tempDir, fs, path, KIT_ROOT } from './harness.m
 import { readText } from '../lib/core.mjs';
 import * as firecrawl from '../lib/firecrawl.mjs';
 import * as httpKeyless from '../lib/http-transport.mjs';
-import { TRANSPORTS, TRANSPORT_NAMES, selectTransport, probeFirecrawl } from '../lib/transport.mjs';
+import { TRANSPORTS, TRANSPORT_NAMES, selectTransport, selectSearch, probeFirecrawl } from '../lib/transport.mjs';
+import { mergeByRank } from '../lib/research-run.mjs';
 
 describe('transport');
 
@@ -406,3 +407,67 @@ test('O-4: an unauthenticated machine is read as unauthenticated, not as a parse
   assert.equal(s.authenticated, false);
   assert.equal(s.credits, null);
 });
+
+// ---------------------------------------------------------------- merged search
+
+test('mergeByRank interleaves, so one failing provider cannot eat the budget', () => {
+  // The case that motivated this. On 2026-09-22 a query about the EU Deforestation
+  // Regulation returned eight US financial-regulation pages from one provider and nothing
+  // on topic, while the other returned seventeen, all on topic. Concatenation would have
+  // spent the whole page budget on the wrong provider before reaching the right one.
+  const bad = { provider: 'serpapi', results: [{ url: 'sec' }, { url: 'cfpb' }, { url: 'water' }] };
+  const good = { provider: 'firecrawl-cli', results: [{ url: 'europa' }, { url: 'ey' }, { url: 'wiki' }] };
+
+  const merged = mergeByRank([bad, good]);
+  assert.deepEqual(merged.map((r) => r.url), ['sec', 'europa', 'cfpb', 'ey', 'water', 'wiki']);
+
+  // Whatever the budget, the good provider is represented. At three pages the old
+  // behaviour would have taken sec/cfpb/water and nothing else.
+  assert.ok(merged.slice(0, 3).some((r) => r.provider === 'firecrawl-cli'),
+    'the working provider must reach the first slots');
+});
+
+test('mergeByRank attributes every row, and agreement does not double-count', () => {
+  // The ledger records which search surfaced a URL, which is what keeps a claim about
+  // search quality checkable rather than an impression.
+  const a = { provider: 'serpapi', results: [{ url: 'shared' }, { url: 'a2' }] };
+  const b = { provider: 'firecrawl-cli', results: [{ url: 'shared' }, { url: 'b2' }] };
+
+  const merged = mergeByRank([a, b]);
+  assert.equal(merged.filter((r) => r.url === 'shared').length, 1, 'a shared URL appears once');
+  assert.equal(merged.find((r) => r.url === 'shared').provider, 'serpapi', 'the first finder keeps it');
+  assert.ok(merged.every((r) => r.provider), 'every row names its finder');
+});
+
+test('mergeByRank handles ragged and empty lists without inventing rows', () => {
+  const long = { provider: 'x', results: [{ url: '1' }, { url: '2' }, { url: '3' }] };
+  const short = { provider: 'y', results: [{ url: 'only' }] };
+  assert.deepEqual(mergeByRank([long, short]).map((r) => r.url), ['1', 'only', '2', '3']);
+  assert.deepEqual(mergeByRank([{ provider: 'z', results: [] }]), []);
+  assert.deepEqual(mergeByRank([]), []);
+});
+
+test('a configured SerpAPI key selects BOTH providers, not one', () => {
+  // This is what the operator believed was already happening, and was not: the ladder
+  // picked a single provider and the second key bought a meter rather than a second look.
+  const search = selectSearch({
+    env: { SERPAPI_API_KEY: ['4', '7'].join('') + 'd'.repeat(62) },
+    probe: () => ({ ok: true, authenticated: true }),
+  });
+  assert.equal(search.merged, true);
+  assert.equal(search.adapters.length, 2, 'both providers must be offered');
+  assert.equal(search.adapters[0].name, 'serpapi', 'the separately metered one goes first');
+  assert.ok(search.why.includes('merged by rank'));
+});
+
+test('an explicitly pinned provider stays a single provider', () => {
+  // Pinning exists to make two runs comparable. If pinning still merged, it would not.
+  const search = selectSearch({
+    explicit: 'serpapi',
+    env: { SERPAPI_API_KEY: ['4', '7'].join('') + 'd'.repeat(62) },
+    probe: () => ({ ok: true, authenticated: true }),
+  });
+  assert.equal(search.merged, undefined);
+  assert.equal(search.adapters, undefined, 'a pinned choice offers no second provider');
+  assert.equal(search.name, 'serpapi');
+});