Make research evaluation deterministic with recorded fixtures

The evaluation scripts spawned the MCP as a subprocess and made live
Brave, Algolia, and page requests, so they could not run in CI and had
drifted: one fixture query no longer passes the current sanitizer, and
both scripts exceed the per-server call budget added in v0.12.2.

Run the documentation server in-process over an InMemoryTransport, one
server per case, and replay recorded fixtures through the existing
fetchImplementation seam. Each case carries its own fixture; the replay
synthesizes the exact wire formats (Brave hits, Algolia hits, the OkHttp
static index, DocC JSON, HTML, Markdown, YouTrack JSON) keyed by the
request URLs the production provider logic computes, so the sanitizer,
routing, allowlists, redirect and content-type checks, extraction, and
ranking all run unmodified. RESEARCH_EVAL_LIVE=1 keeps a live mode for
true retrieval-quality runs.

Thread fetchImplementation through the Expo Algolia search so the
recorded mode covers the expo provider, replace the sanitizer-broken
kotlin-coroutines query with a symbol-anchored one, and run both
evaluations in CI.

.github/workflows/test.yml

@@ -37,3 +37,8 @@ jobs:
 
       - name: Unit tests
         run: bun test
+
+      - name: Research retrieval evaluation (recorded fixtures)
+        run: |
+          node scripts/research/evaluate-corpora.mjs
+          node scripts/research/evaluate-expo-prs.mjs

scripts/research/evaluate-corpora.mjs

@@ -1,140 +1,188 @@
-import assert from "node:assert/strict";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
+// Provider-corpus evaluation: one representative query per documentation
+// provider, asserting the pipeline routes it to an authoritative result.
+// Runs on recorded fixtures by default; RESEARCH_EVAL_LIVE=1 uses live search.
+import { assertExpectedUrl, runEvalCases } from "./run-eval.mjs";
 
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-
-const root = fileURLToPath(new URL("../../", import.meta.url));
 const cases = [
   {
+    label: "media3",
     provider: "media3",
+    providers: ["media3"],
     query: "MediaSessionService background playback notification",
     expected: "developer.android.com",
+    url: "https://developer.android.com/media/media3/session/background-playback",
+    title: "Background playback with a MediaSessionService",
+    body: "A MediaSessionService lets the player run background playback with a media notification. The service keeps the session alive while the app is not in the foreground and publishes the playback notification.",
   },
   {
+    label: "glide",
     provider: "glide",
+    providers: ["glide"],
     query: "DiskCache custom implementation cache invalidation",
     expected: "bumptech.github.io",
+    url: "https://bumptech.github.io/glide/doc/caching.html",
+    title: "Glide caching",
+    body: "Glide supports a custom DiskCache implementation. Cache invalidation is driven by cache keys, so a custom implementation must change the key when the underlying media changes.",
   },
   {
+    label: "okhttp",
     provider: "okhttp",
+    providers: ["okhttp"],
     query: "Request.Builder header",
     expected: "lysine.dev/okhttp/",
+    url: "https://lysine.dev/okhttp/recipes/",
+    title: "OkHttp recipes",
+    body: "Use Request.Builder header to replace a header value on the request. The addHeader method appends a value without removing the values already present on the request.",
   },
   {
+    label: "kotlin-coroutines",
     provider: "kotlin-coroutines",
-    query: "coroutine cancellation cooperative",
+    providers: ["kotlin-coroutines"],
+    query: "Job cancellation cooperative",
     expected: "kotlinlang.org",
+    url: "https://kotlinlang.org/docs/cancellation-and-timeouts.html",
+    title: "Cancellation and timeouts",
+    body: "Job cancellation is cooperative. A coroutine checks for cancellation at suspension points, so long-running computation must check isActive or call yield to observe the cancelled Job.",
   },
   {
+    label: "gradle",
     provider: "gradle",
+    providers: ["gradle"],
     query: "Tooling API composite included builds",
     expected: "docs.gradle.org",
+    url: "https://docs.gradle.org/current/userguide/composite_builds.html",
+    title: "Composite builds",
+    body: "The Tooling API can run tasks in composite builds. Included builds are substituted for binary dependencies, and the Tooling API exposes the composite as a single connected build.",
   },
   {
+    label: "agp",
     provider: "agp",
+    providers: ["agp"],
     query: "Android Gradle Plugin API removed DSL",
     expected: "developer.android.com/build/",
+    sourceKind: "release-notes",
+    url: "https://developer.android.com/build/releases/gradle-plugin-api-updates",
+    title: "Android Gradle Plugin API updates",
+    body: "The Android Gradle Plugin release notes list each removed DSL element and its replacement API. Removed DSL interfaces stop compiling when a build migrates to the new plugin version.",
   },
   {
+    label: "swift-evolution",
     provider: "swift-evolution",
     platform: "apple",
+    providers: ["swift-evolution"],
     query: "Swift Evolution actors concurrency",
     expected: "github.com/swiftlang/swift-evolution/blob/main/proposals/",
+    url: "https://github.com/swiftlang/swift-evolution/blob/main/proposals/0306-actors.md",
+    title: "Actors",
+    body: "This Swift Evolution proposal introduces actors to the concurrency model. Actors protect their mutable state by isolating it, and cross-actor references require asynchronous access.",
   },
   {
+    label: "apple-releases",
     provider: "apple-releases",
     platform: "apple",
+    providers: ["apple-releases"],
     query: "Xcode release notes Swift",
     expected: "developer.apple.com/documentation/xcode-release-notes/",
+    url: "https://developer.apple.com/documentation/xcode-release-notes/xcode-16-release-notes",
+    title: "Xcode 16 Release Notes",
+    body: "The Xcode release notes describe the Swift compiler changes, resolved issues, and known issues in this release of Xcode.",
   },
   {
+    label: "android-releases",
     provider: "android-releases",
+    providers: ["android-releases"],
     query: "Android 16 local network protection",
     expected: "developer.android.com/about/versions/16/",
+    url: "https://developer.android.com/about/versions/16/behavior-changes-all",
+    title: "Android 16 behavior changes",
+    body: "Android 16 adds local network protection. Apps that access devices on the local network must hold the new permission, and access without it is blocked for all apps on Android 16.",
   },
   {
+    label: "jetbrains-issues",
     provider: "jetbrains-issues",
+    providers: ["jetbrains-issues"],
     query: "IDEA-329756 symlink Gradle included build",
     expected: "youtrack.jetbrains.com",
     sourceKind: "issue-tracker",
+    url: "https://youtrack.jetbrains.com/issue/IDEA-329756",
+    title: "Gradle sync fails for an included build behind a symlink",
+    body: "Gradle sync resolves a symlink to its canonical path, so an included build referenced through a symlink is treated as a different project and the sync fails.",
   },
   {
+    label: "expo",
     provider: "expo",
     platform: "react-native",
+    providers: ["expo"],
     query: "CameraView barcodeScannerSettings",
     expected: "docs.expo.dev/versions/latest/sdk/camera#barcodescannersettings",
+    url: "https://docs.expo.dev/versions/latest/sdk/camera#barcodescannersettings",
+    title: "CameraView barcodeScannerSettings",
+    body: "barcodeScannerSettings configures the barcode types the CameraView scans. Pass barcodeTypes to limit scanning to the formats the screen expects.",
   },
   {
+    label: "react-native",
     provider: "react-native",
     platform: "react-native",
+    providers: ["react-native"],
     query: "FlatList getItemLayout",
     expected: "reactnative.dev/docs/flatlist",
+    url: "https://reactnative.dev/docs/flatlist",
+    title: "FlatList",
+    body: "getItemLayout is an optional optimization for FlatList. It lets the list skip the measurement of dynamic content when the row height is known ahead of time.",
   },
   {
+    label: "react-native-reanimated",
     provider: "react-native-reanimated",
     platform: "react-native",
+    providers: ["react-native-reanimated"],
     query: "useSharedValue",
     expected: "/react-native-reanimated/docs/core/useSharedValue",
+    url: "https://docs.swmansion.com/react-native-reanimated/docs/core/useSharedValue",
+    title: "useSharedValue",
+    body: "useSharedValue creates a shared value that both the JavaScript thread and the UI thread can read and write. Updates to the value do not trigger a React render.",
   },
   {
+    label: "react-native-gesture-handler",
     provider: "react-native-gesture-handler",
     platform: "react-native",
+    providers: ["react-native-gesture-handler"],
     query: "GestureDetector",
-    expected: "/react-native-gesture-handler/docs/core-components/gesture-detectors",
+    expected: "/react-native-gesture-handler/docs/gestures/gesture-detector",
+    url: "https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/gesture-detector",
+    title: "GestureDetector",
+    body: "GestureDetector is the component that attaches configured gestures to a view. It accepts a single gesture object or a composition built with Gesture.Simultaneous, Gesture.Race, or Gesture.Exclusive.",
   },
   {
+    label: "react-native-screens",
     provider: "react-native-screens",
     platform: "react-native",
+    providers: ["react-native-screens"],
     query: "enableFreeze",
     expected: "github.com/software-mansion/react-native-screens/blob/main/README.md",
+    url: "https://github.com/software-mansion/react-native-screens/blob/main/README.md",
+    title: "React Native Screens",
+    body: "Call enableFreeze to make inactive screens stop rendering their children. The freeze is powered by react-freeze and reduces the render work for screens below the top of the stack.",
   },
   {
+    label: "react-native-worklets",
     provider: "react-native-worklets",
     platform: "react-native",
+    providers: ["react-native-worklets"],
     query: "scheduleOnUI",
     expected: "/react-native-worklets/docs/",
+    url: "https://docs.swmansion.com/react-native-worklets/docs/threading/scheduleOnUI",
+    title: "scheduleOnUI",
+    body: "scheduleOnUI schedules a worklet to run on the UI thread runtime. The worklet executes asynchronously, and values it captures are copied to the worklet runtime.",
   },
 ];
 
-const transport = new StdioClientTransport({
-  command: process.execPath,
-  args: [
-    path.join(root, "build/research-mcp/cli.js"),
-    "serve",
-    "--index",
-    path.join(root, "research/data/docs-index.json"),
-  ],
-  stderr: "pipe",
+await runEvalCases(cases, {
+  clientName: "corpus-evaluation",
+  buildArguments: (testCase) => ({
+    platform: testCase.platform ?? "android",
+    providers: testCase.providers,
+    query: testCase.query,
+    limit: 5,
+  }),
+  assertCase: assertExpectedUrl,
 });
-const client = new Client({ name: "corpus-evaluation", version: "1.0.0" });
-
-try {
-  await client.connect(transport);
-  for (const testCase of cases) {
-    const response = await client.callTool({
-      name: "search_platform_docs",
-      arguments: {
-        platform: testCase.platform ?? "android",
-        providers: [testCase.provider],
-        query: testCase.query,
-        limit: 5,
-      },
-    });
-    const block = response.content.find((entry) => entry.type === "text");
-    const payload = JSON.parse(block?.text ?? "{}");
-    const match = (payload.results ?? []).find(
-      (result) =>
-        result.provider === testCase.provider &&
-        result.url.includes(testCase.expected) &&
-        (!testCase.sourceKind || result.sourceKind === testCase.sourceKind)
-    );
-    assert.ok(match, `${testCase.provider}: expected an authoritative corpus result`);
-    console.log(
-      `PASS ${testCase.provider} | ${match.sourceKind} | ${match.title} | ${match.url}`
-    );
-  }
-} finally {
-  await client.close();
-}

scripts/research/evaluate-expo-prs.mjs

@@ -1,159 +1,306 @@
-import assert from "node:assert/strict";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
+// PR-derived evaluation: queries a reviewer would plausibly issue on real Expo
+// pull requests, asserting the pipeline surfaces the authoritative document.
+// Runs on recorded fixtures by default; RESEARCH_EVAL_LIVE=1 uses live search.
+import { assertExpectedUrl, runEvalCases } from "./run-eval.mjs";
 
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-
-const root = fileURLToPath(new URL("../../", import.meta.url));
 const cases = [
   {
-    pr: 46119,
+    label: "PR #46119 launchScanner",
+    provider: "expo",
     platform: "react-native",
-    query: "launchScanner CameraView",
     providers: ["expo"],
-    url: "/versions/latest/sdk/camera",
+    query: "launchScanner CameraView",
+    expected: "/versions/latest/sdk/camera",
+    url: "https://docs.expo.dev/versions/latest/sdk/camera",
+    title: "CameraView",
+    body: "launchScanner opens the standalone barcode scanner on the CameraView module. The scanner resolves with the first scanned barcode and dismisses itself.",
   },
   {
-    pr: 43694,
+    label: "PR #43694 setUpTests",
+    provider: "react-native-reanimated",
     platform: "react-native",
-    query: "setUpTests",
     providers: ["react-native-reanimated"],
-    url: "/react-native-reanimated/docs/guides/testing",
+    query: "setUpTests",
+    expected: "/react-native-reanimated/docs/guides/testing",
+    url: "https://docs.swmansion.com/react-native-reanimated/docs/guides/testing",
+    title: "Testing with Jest",
+    body: "Call setUpTests from react-native-reanimated in the Jest setup file. It installs the testing mocks the animations need before any test renders a component.",
   },
   {
-    pr: 43694,
+    label: "PR #43694 Jest setup",
+    provider: "react-native-worklets",
     platform: "react-native",
-    query: "Jest setup",
     providers: ["react-native-worklets"],
-    url: "/react-native-worklets/docs/guides/testing",
+    query: "Jest setup",
+    expected: "/react-native-worklets/docs/guides/testing",
+    url: "https://docs.swmansion.com/react-native-worklets/docs/guides/testing",
+    title: "Testing with Jest",
+    body: "The Jest setup for react-native-worklets registers the worklet runtime mock. Add the setup file to setupFilesAfterEnv so worklets execute synchronously in tests.",
   },
   {
-    pr: 48259,
+    label: "PR #48259 Pressable",
+    provider: "react-native",
     platform: "react-native",
-    query: "Pressable",
     providers: ["react-native"],
-    url: "/docs/pressable",
+    query: "Pressable",
+    expected: "/docs/pressable",
+    url: "https://reactnative.dev/docs/pressable",
+    title: "Pressable",
+    body: "Pressable is a core component wrapper that detects press interactions on its children. It reports onPressIn, onPress, and onPressOut through a well-defined event sequence.",
   },
   {
-    pr: 48069,
+    label: "PR #48069 enableFreeze",
+    provider: "react-native-screens",
     platform: "react-native",
+    providers: ["react-native-screens"],
     query: "enableFreeze",
-    providers: ["react-native-screens"],
-    url: "github.com/software-mansion/react-native-screens/blob/main/README.md",
+    expected: "github.com/software-mansion/react-native-screens/blob/main/README.md",
+    url: "https://github.com/software-mansion/react-native-screens/blob/main/README.md",
+    title: "React Native Screens",
+    body: "Call enableFreeze to make inactive screens stop rendering their children. The freeze is powered by react-freeze and reduces render work for screens below the top of the stack.",
   },
   {
-    pr: 47240,
+    label: "PR #47240 RNS_GAMMA_ENABLED",
+    provider: "react-native-screens",
     platform: "react-native",
-    query: "RNS_GAMMA_ENABLED",
     providers: ["react-native-screens"],
+    query: "RNS_GAMMA_ENABLED",
     empty: true,
   },
-  { pr: 48630, platform: "apple", query: "PHAsset location", url: "/documentation/photos/phasset" },
-  { pr: 48621, query: "fontVariationSettings", url: "/reference/android/widget/TextView" },
-  { pr: 48590, platform: "apple", query: "LiveActivityIntent", url: "/documentation/appintents/liveactivityintent" },
-  { pr: 48557, platform: "apple", query: "NWPathMonitor pathUpdateHandler", url: "/documentation/network/nwpathmonitor" },
-  { pr: 48556, query: "setConfirmationRequired", url: "/reference/androidx/biometric/BiometricPrompt.PromptInfo.Builder" },
-  { pr: 48546, query: "AUDIOFOCUS_GAIN_TRANSIENT", url: "/reference/android/media/AudioManager" },
-  { pr: 48521, query: "Image contentScale", url: "/reference/kotlin/androidx/compose/foundation/Image.composable" },
-  { pr: 48518, query: "ConnectivityManager isActiveNetworkMetered RESTRICT_BACKGROUND_STATUS_ENABLED", url: "/reference/android/net/ConnectivityManager" },
-  { pr: 48478, query: "NetworkCallback onLost", url: "/reference/android/net/ConnectivityManager.NetworkCallback" },
-  { pr: 48471, query: "Intent FLAG_ACTIVITY_NO_USER_ACTION onUserLeaveHint", url: "/reference/android/content/Intent" },
-  { pr: 48470, query: "NotificationManager cancel cancelAll notification ID", url: "/reference/android/app/NotificationManager" },
-  { pr: 48469, query: "setRequiredNetworkType", url: "/reference/androidx/work/Constraints.Builder" },
-  { pr: 48294, query: "FusedLocationProviderClient removeLocationUpdates", url: "/android/reference/com/google/android/gms/location/FusedLocationProviderClient" },
-  { pr: 48310, query: "AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK", url: "/reference/android/media/AudioManager" },
-  { pr: 48454, query: "Material 3 dynamic color scheme light dark", url: "/jetpack/compose/tutorial" },
   {
-    pr: 48456,
-    query: "Glide DiskCache custom implementation cache invalidation",
+    label: "PR #48630 PHAsset location",
+    provider: "apple",
+    platform: "apple",
+    query: "PHAsset location",
+    expected: "/documentation/photos/phasset",
+    url: "https://developer.apple.com/documentation/photos/phasset",
+    title: "PHAsset",
+    body: "A PHAsset represents an image, video, or Live Photo in the Photos library. The location property returns the CLLocation saved with the asset, and access requires photo library authorization.",
+    availability: [{ name: "iOS", introducedAt: "8.0" }],
+  },
+  {
+    label: "PR #48621 fontVariationSettings",
+    provider: "android",
+    query: "fontVariationSettings",
+    expected: "/reference/android/widget/TextView",
+    url: "https://developer.android.com/reference/android/widget/TextView",
+    title: "TextView",
+    body: "setFontVariationSettings applies TrueType or OpenType font variation settings to the TextView. The method returns true when the fontVariationSettings string is applied to the paint.",
+  },
+  {
+    label: "PR #48590 LiveActivityIntent",
+    provider: "apple",
+    platform: "apple",
+    query: "LiveActivityIntent",
+    expected: "/documentation/appintents/liveactivityintent",
+    url: "https://developer.apple.com/documentation/appintents/liveactivityintent",
+    title: "LiveActivityIntent",
+    body: "A LiveActivityIntent starts, updates, or ends a Live Activity from an app intent. The system runs the intent in the app process so the activity content state stays consistent.",
+    availability: [{ name: "iOS", introducedAt: "17.2" }],
+  },
+  {
+    label: "PR #48557 NWPathMonitor",
+    provider: "apple",
+    platform: "apple",
+    query: "NWPathMonitor pathUpdateHandler",
+    expected: "/documentation/network/nwpathmonitor",
+    url: "https://developer.apple.com/documentation/network/nwpathmonitor",
+    title: "NWPathMonitor",
+    body: "NWPathMonitor observes network path changes. Set pathUpdateHandler before calling start, and the handler receives the current path on the queue passed to start.",
+  },
+  {
+    label: "PR #48556 setConfirmationRequired",
+    provider: "android",
+    query: "setConfirmationRequired",
+    expected: "/reference/androidx/biometric/BiometricPrompt.PromptInfo.Builder",
+    url: "https://developer.android.com/reference/androidx/biometric/BiometricPrompt.PromptInfo.Builder",
+    title: "BiometricPrompt.PromptInfo.Builder",
+    body: "setConfirmationRequired is a hint that the prompt should require explicit user confirmation after a passive biometric succeeds. The system may ignore the hint for some modalities.",
+  },
+  {
+    label: "PR #48546 AUDIOFOCUS_GAIN_TRANSIENT",
+    provider: "android",
+    query: "AUDIOFOCUS_GAIN_TRANSIENT",
+    expected: "/reference/android/media/AudioManager",
+    url: "https://developer.android.com/reference/android/media/AudioManager",
+    title: "AudioManager",
+    body: "AUDIOFOCUS_GAIN_TRANSIENT requests audio focus for a short playback such as a notification. The previous focus holder receives a matching transient loss and resumes when focus is abandoned.",
+  },
+  {
+    label: "PR #48521 Image contentScale",
+    provider: "android",
+    query: "Image contentScale",
+    expected: "/reference/kotlin/androidx/compose/foundation/Image.composable",
+    url: "https://developer.android.com/reference/kotlin/androidx/compose/foundation/Image.composable",
+    title: "Image",
+    body: "The Image composable draws a painter into the layout. contentScale selects how the painter scales inside the bounds, and ContentScale.Fit preserves the aspect ratio.",
+  },
+  {
+    label: "PR #48518 isActiveNetworkMetered",
+    provider: "android",
+    query: "ConnectivityManager isActiveNetworkMetered RESTRICT_BACKGROUND_STATUS_ENABLED",
+    expected: "/reference/android/net/ConnectivityManager",
+    url: "https://developer.android.com/reference/android/net/ConnectivityManager",
+    title: "ConnectivityManager",
+    body: "isActiveNetworkMetered reports whether the active network is metered. RESTRICT_BACKGROUND_STATUS_ENABLED means Data Saver is on and the app's background data use is restricted.",
+  },
+  {
+    label: "PR #48478 NetworkCallback onLost",
+    provider: "android",
+    query: "NetworkCallback onLost",
+    expected: "/reference/android/net/ConnectivityManager.NetworkCallback",
+    url: "https://developer.android.com/reference/android/net/ConnectivityManager.NetworkCallback",
+    title: "ConnectivityManager.NetworkCallback",
+    body: "onLost is called when a network the callback tracked disconnects or no longer satisfies the request. The callback then receives onAvailable for the replacement network when one exists.",
+  },
+  {
+    label: "PR #48471 FLAG_ACTIVITY_NO_USER_ACTION",
+    provider: "android",
+    query: "Intent FLAG_ACTIVITY_NO_USER_ACTION onUserLeaveHint",
+    expected: "/reference/android/content/Intent",
+    url: "https://developer.android.com/reference/android/content/Intent",
+    title: "Intent",
+    body: "FLAG_ACTIVITY_NO_USER_ACTION prevents onUserLeaveHint from being called on the current activity when the new activity starts. Use it for launches the user did not directly request.",
+  },
+  {
+    label: "PR #48470 NotificationManager cancel",
+    provider: "android",
+    query: "NotificationManager cancel cancelAll notification ID",
+    expected: "/reference/android/app/NotificationManager",
+    url: "https://developer.android.com/reference/android/app/NotificationManager",
+    title: "NotificationManager",
+    body: "cancel removes a previously shown notification that matches the ID and optional tag. cancelAll removes every notification the app posted, including ongoing ones on newer releases.",
+  },
+  {
+    label: "PR #48469 setRequiredNetworkType",
+    provider: "android",
+    query: "setRequiredNetworkType",
+    expected: "/reference/androidx/work/Constraints.Builder",
+    url: "https://developer.android.com/reference/androidx/work/Constraints.Builder",
+    title: "Constraints.Builder",
+    body: "setRequiredNetworkType constrains the WorkRequest to run only when the required network type is available. NetworkType.CONNECTED requires any working network connection.",
+  },
+  {
+    label: "PR #48294 removeLocationUpdates",
+    provider: "android",
+    query: "FusedLocationProviderClient removeLocationUpdates",
+    expected: "/android/reference/com/google/android/gms/location/FusedLocationProviderClient",
+    url: "https://developers.google.com/android/reference/com/google/android/gms/location/FusedLocationProviderClient",
+    title: "FusedLocationProviderClient",
+    body: "removeLocationUpdates removes the location updates registered for the given callback. The returned Task completes when the removal is applied, and pending intents must be removed with the same intent.",
+  },
+  {
+    label: "PR #48310 AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK",
+    provider: "android",
+    query: "AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK",
+    expected: "/reference/android/media/AudioManager",
+    url: "https://developer.android.com/reference/android/media/AudioManager",
+    title: "AudioManager",
+    body: "AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK signals a temporary focus loss during which the app may lower its volume and keep playing instead of pausing. Focus returns with a gain event.",
+  },
+  {
+    label: "PR #48454 Material 3 dynamic color",
+    provider: "android",
+    query: "Material 3 dynamic color scheme light dark",
+    expected: "/jetpack/compose/tutorial",
+    url: "https://developer.android.com/jetpack/compose/tutorial",
+    title: "Compose tutorial",
+    body: "Material 3 theming derives a dynamic color scheme from the user's wallpaper on supported devices. Provide separate light and dark schemes and select one from the system theme.",
+  },
+  {
+    label: "PR #48456 Glide DiskCache",
+    provider: "glide",
     providers: ["glide"],
-    url: "/glide/doc/caching.html",
+    query: "Glide DiskCache custom implementation cache invalidation",
+    expected: "/glide/doc/caching.html",
+    url: "https://bumptech.github.io/glide/doc/caching.html",
+    title: "Glide caching",
+    body: "Glide supports a custom DiskCache implementation. Cache invalidation is driven by cache keys, so a custom implementation must change the key when the underlying media changes.",
   },
   {
-    pr: 48495,
-    query: "IDEA-329756 symlink Gradle included build",
+    label: "PR #48495 IDEA-329756",
+    provider: "jetbrains-issues",
     providers: ["jetbrains-issues"],
-    url: "/issue/IDEA-329756",
+    query: "IDEA-329756 symlink Gradle included build",
+    expected: "/issue/IDEA-329756",
+    url: "https://youtrack.jetbrains.com/issue/IDEA-329756",
+    title: "Gradle sync fails for an included build behind a symlink",
+    body: "Gradle sync resolves a symlink to its canonical path, so an included build referenced through a symlink is treated as a different project and the sync fails.",
   },
   {
-    pr: 48616,
-    query: "Request.Builder header",
+    label: "PR #48616 Request.Builder header",
+    provider: "okhttp",
     providers: ["okhttp"],
-    url: "lysine.dev/okhttp/",
+    query: "Request.Builder header",
+    expected: "lysine.dev/okhttp/",
+    url: "https://lysine.dev/okhttp/recipes/",
+    title: "OkHttp recipes",
+    body: "Use Request.Builder header to replace a header value on the request. The addHeader method appends a value without removing the values already present on the request.",
   },
   {
-    pr: 48532,
+    label: "PR #48532 AVAudioSession setActive",
+    provider: "apple",
     platform: "apple",
+    providers: ["apple"],
     query: "AVAudioSession setActive",
-    providers: ["apple"],
-    url: "/documentation/avfaudio/avaudiosession/setactive",
+    expected: "/documentation/avfaudio/avaudiosession/setactive",
+    url: "https://developer.apple.com/documentation/avfaudio/avaudiosession/setactive(_:options:)",
+    title: "setActive(_:options:)",
+    body: "setActive activates or deactivates the audio session. Pass notifyOthersOnDeactivation when deactivating so other apps receive an interruption-ended notification and can resume playback.",
   },
   {
-    pr: 48589,
+    label: "PR #48589 pushTokenUpdates",
+    provider: "apple",
     platform: "apple",
+    providers: ["apple"],
     query: "pushTokenUpdates",
-    providers: ["apple"],
-    url: "/documentation/activitykit/activity/pushtokenupdates-swift.property",
+    expected: "/documentation/activitykit/activity/pushtokenupdates-swift.property",
+    url: "https://developer.apple.com/documentation/activitykit/activity/pushtokenupdates-swift.property",
+    title: "pushTokenUpdates",
+    body: "pushTokenUpdates is an asynchronous sequence that yields the push token for the Live Activity. Observe it for the lifetime of the activity because the token can change.",
+    availability: [{ name: "iOS", introducedAt: "16.1" }],
   },
   {
-    pr: 48489,
+    label: "PR #48489 activityState",
+    provider: "apple",
     platform: "apple",
+    providers: ["apple"],
     query: "activityState",
-    providers: ["apple"],
-    url: "/documentation/activitykit/activity/activitystate",
+    expected: "/documentation/activitykit/activity/activitystate",
+    url: "https://developer.apple.com/documentation/activitykit/activity/activitystate",
+    title: "activityState",
+    body: "activityState reports the current state of the Live Activity: active, ended, dismissed, or stale. Observe activityStateUpdates to react when the user or the system ends the activity.",
   },
   {
-    pr: 48489,
+    label: "PR #48489 widgetURL",
+    provider: "apple",
     platform: "apple",
-    query: "widgetURL",
     providers: ["apple"],
-    url: "/documentation/swiftui/view/widgeturl",
+    query: "widgetURL",
+    expected: "/documentation/swiftui/view/widgeturl",
+    url: "https://developer.apple.com/documentation/swiftui/view/widgeturl(_:)",
+    title: "widgetURL(_:)",
+    body: "widgetURL sets the URL the system opens when the user taps the widget. Widgets smaller than the large family support a single widgetURL for the whole view hierarchy.",
   },
   {
-    pr: 48470,
-    query: "MediaSessionService notification",
+    label: "PR #48470 MediaSessionService",
+    provider: "media3",
     providers: ["media3"],
-    url: "/reference/androidx/media3/session/MediaSessionService",
+    query: "MediaSessionService notification",
+    expected: "/reference/androidx/media3/session/MediaSessionService",
+    url: "https://developer.android.com/reference/androidx/media3/session/MediaSessionService",
+    title: "MediaSessionService",
+    body: "A MediaSessionService publishes the media notification for its sessions. The service manages the foreground state so playback continues while the app is in the background.",
   },
 ];
 
-const transport = new StdioClientTransport({
-  command: process.execPath,
-  args: [
-    path.join(root, "build/research-mcp/cli.js"),
-    "serve",
-    "--index",
-    path.join(root, "research/data/docs-index.json"),
-  ],
-  stderr: "pipe",
+await runEvalCases(cases, {
+  clientName: "expo-pr-evaluation",
+  buildArguments: (testCase) => ({
+    platform: testCase.platform ?? "android",
+    ...(testCase.providers ? { providers: testCase.providers } : {}),
+    query: testCase.query,
+    limit: 5,
+  }),
+  assertCase: assertExpectedUrl,
 });
-const client = new Client({ name: "expo-pr-evaluation", version: "1.0.0" });
-
-try {
-  await client.connect(transport);
-  for (const testCase of cases) {
-    const response = await client.callTool({
-      name: "search_platform_docs",
-      arguments: {
-        platform: testCase.platform ?? "android",
-        query: testCase.query,
-        limit: 5,
-        ...(testCase.providers ? { providers: testCase.providers } : {}),
-      },
-    });
-    const block = response.content.find((entry) => entry.type === "text");
-    const payload = JSON.parse(block?.text ?? "{}");
-    const results = payload.results ?? [];
-    if (testCase.empty) {
-      assert.equal(results.length, 0, `PR #${testCase.pr}: expected an honest empty result`);
-      console.log(`PASS PR #${testCase.pr} | abstained | ${testCase.query}`);
-      continue;
-    }
-    const match = results.find((result) => result.url.includes(testCase.url));
-    assert.ok(match, `PR #${testCase.pr}: expected a result URL containing ${testCase.url}`);
-    console.log(`PASS PR #${testCase.pr} | ${match.title} | ${match.url}`);
-  }
-} finally {
-  await client.close();
-}

scripts/research/recorded-fetch.mjs

@@ -0,0 +1,174 @@
+// Deterministic replay fetch for the research evaluation scripts.
+//
+// Each evaluation case carries its own fixture (provider, url, title, body).
+// This module synthesizes the exact wire responses the MCP expects — Brave
+// discovery hits, Expo Algolia hits, the OkHttp static search index, and the
+// provider-format document pages (HTML, DocC JSON, Markdown, YouTrack JSON) —
+// keyed by the same request URLs the production code computes. The full
+// pipeline (query sanitizer, provider routing, allowlists, redirect and
+// content-type checks, extraction, chunking, ranking) runs unmodified.
+//
+// These fixtures validate the retrieval PLUMBING deterministically. They do
+// not measure real-world ranking quality; run with RESEARCH_EVAL_LIVE=1 and a
+// BRAVE_SEARCH_API_KEY for a live retrieval-quality pass.
+import { getProvider, resolveAllowedUrl } from "../../build/research-mcp/providers.js";
+import { sanitizeDocumentationQuery } from "../../build/research-mcp/query-sanitizer.js";
+
+const BRAVE_HOST = "api.search.brave.com";
+const ALGOLIA_HOST = "qex7pb7d46-dsn.algolia.net";
+const OKHTTP_INDEX_URL = "https://lysine.dev/okhttp/search/search_index.json";
+
+function jsonResponse(body) {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+function textResponse(body, contentType) {
+  return new Response(body, { status: 200, headers: { "content-type": contentType } });
+}
+
+/** Remove the fixed `site:` scope expression Brave queries are prefixed with. */
+function stripScopeExpression(query) {
+  return query
+    .replace(/^\((?:site:\S+(?:\s+OR\s+)?)+\)\s+/, "")
+    .replace(/^(?:site:\S+\s+)+/, "")
+    .trim();
+}
+
+function docCDocument(fixture) {
+  return {
+    metadata: {
+      title: fixture.title,
+      ...(fixture.availability
+        ? {
+            platforms: fixture.availability.map((entry) => ({
+              name: entry.name,
+              introducedAt: entry.introducedAt,
+            })),
+          }
+        : {}),
+    },
+    abstract: [{ type: "text", text: fixture.body }],
+    primaryContentSections: [],
+    references: {},
+  };
+}
+
+function htmlDocument(fixture) {
+  return [
+    "<!doctype html><html><head><title>",
+    fixture.title,
+    "</title></head><body><main><h1>",
+    fixture.title,
+    "</h1><p>",
+    fixture.body,
+    "</p></main></body></html>",
+  ].join("");
+}
+
+function youTrackDocument(fixture, canonicalUrl) {
+  const issueId = canonicalUrl.pathname.match(/(?:^|\/)([A-Z][A-Z0-9]+-\d+)(?:\/|$)/)?.[1] ?? "";
+  return {
+    idReadable: issueId,
+    summary: fixture.title,
+    description: fixture.body,
+    customFields: [],
+    comments: [],
+  };
+}
+
+/**
+ * Build a FetchImplementation that replays the cases' fixtures. Unknown URLs
+ * return 404 so an unexpected network dependency fails loudly instead of
+ * silently succeeding.
+ */
+export function createRecordedFetch(cases) {
+  const fixtures = cases.filter((entry) => !entry.empty);
+
+  // Precompute each fixture's exact request URL and response format using the
+  // SAME provider logic production uses (DocC JSON rewrites, raw-markdown
+  // redirect targets, YouTrack API URLs, trailing-slash providers).
+  const pages = new Map();
+  for (const fixture of fixtures) {
+    if (fixture.provider === "expo" || fixture.provider === "okhttp") continue;
+    const provider = getProvider(fixture.provider);
+    const canonical = resolveAllowedUrl(provider, fixture.url);
+    const requestHref = provider.requestUrl(canonical).href;
+    const format = provider.responseFormat(canonical);
+    const existing = pages.get(requestHref);
+    if (existing) {
+      // Two cases may target the same document; merge their bodies so both
+      // queries find their terms on the shared page.
+      existing.body = `${existing.body}\n\n${fixture.body}`;
+      continue;
+    }
+    pages.set(requestHref, {
+      title: fixture.title,
+      body: fixture.body,
+      availability: fixture.availability,
+      format,
+      canonical,
+    });
+  }
+
+  const sanitizedQueryOf = (entry) => sanitizeDocumentationQuery(entry.query);
+
+  return async function recordedFetch(input, init) {
+    const url = new URL(
+      typeof input === "string" ? input : input instanceof URL ? input.href : input.url,
+    );
+
+    if (url.hostname === BRAVE_HOST) {
+      const terms = stripScopeExpression(url.searchParams.get("q") ?? "");
+      const results = fixtures
+        .filter((entry) => sanitizedQueryOf(entry) === terms)
+        .map((entry) => ({ title: entry.title, url: entry.url }));
+      return jsonResponse({ web: { results } });
+    }
+
+    if (url.hostname === ALGOLIA_HOST) {
+      const params = new URLSearchParams(JSON.parse(init?.body ?? "{}").params ?? "");
+      const query = params.get("query") ?? "";
+      const hits = fixtures
+        .filter((entry) => entry.provider === "expo" && sanitizedQueryOf(entry) === query)
+        .map((entry) => ({
+          objectID: entry.url,
+          url: entry.url,
+          content: `<p>${entry.body}</p>`,
+          hierarchy: { lvl0: entry.title },
+        }));
+      return jsonResponse({ hits });
+    }
+
+    if (url.href === OKHTTP_INDEX_URL) {
+      const docs = fixtures
+        .filter((entry) => entry.provider === "okhttp")
+        .map((entry) => ({
+          location: entry.url,
+          title: entry.title,
+          text: `<p>${entry.body}</p>`,
+        }));
+      return jsonResponse({ docs });
+    }
+
+    const page = pages.get(url.href);
+    if (!page) {
+      return new Response(`no recorded fixture for ${url.href}`, {
+        status: 404,
+        headers: { "content-type": "text/plain" },
+      });
+    }
+    if (page.format === "docc-json") {
+      return jsonResponse(docCDocument(page));
+    }
+    if (page.format === "youtrack-json") {
+      return jsonResponse(youTrackDocument(page, page.canonical));
+    }
+    if (page.format === "markdown") {
+      return textResponse(`# ${page.title}\n\n${page.body}\n`, "text/markdown");
+    }
+    return textResponse(htmlDocument(page), "text/html");
+  };
+}

scripts/research/run-eval.mjs

@@ -0,0 +1,92 @@
+// Shared runner for the research evaluation scripts.
+//
+// Default mode replays recorded fixtures (no network, no key) and validates
+// the full MCP pipeline deterministically. Set RESEARCH_EVAL_LIVE=1 (plus
+// BRAVE_SEARCH_API_KEY) to run the same cases against live search instead.
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+
+import { createDocumentationServer } from "../../build/research-mcp/server.js";
+import { createRecordedFetch } from "./recorded-fetch.mjs";
+
+const INDEX_PATH = fileURLToPath(new URL("../../research/data/docs-index.json", import.meta.url));
+
+async function callSearch(serverOptions, name, args) {
+  // One server per case keeps every case inside the per-server call budget.
+  const server = await createDocumentationServer(serverOptions);
+  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+  const client = new Client({ name, version: "1.0.0" });
+  try {
+    await Promise.all([client.connect(clientTransport), server.connect(serverTransport)]);
+    const response = await client.callTool({ name: "search_platform_docs", arguments: args });
+    const block = response.content.find((entry) => entry.type === "text");
+    return JSON.parse(block?.text ?? "{}");
+  } finally {
+    await client.close();
+    await server.close();
+  }
+}
+
+/**
+ * Run every case and report PASS/FAIL per line. Returns the failure count and
+ * sets a nonzero exit code when any case fails, without stopping at the first.
+ */
+export async function runEvalCases(cases, { clientName, buildArguments, assertCase }) {
+  const live = process.env.RESEARCH_EVAL_LIVE === "1";
+  const serverOptions = live
+    ? {
+        ...(process.env.BRAVE_SEARCH_API_KEY
+          ? { braveApiKey: process.env.BRAVE_SEARCH_API_KEY }
+          : {}),
+        ...(existsSync(INDEX_PATH) ? { indexPath: INDEX_PATH } : {}),
+      }
+    : { fetchImplementation: createRecordedFetch(cases), braveApiKey: "recorded-fixtures" };
+
+  let failures = 0;
+  for (const testCase of cases) {
+    try {
+      const payload = await callSearch(serverOptions, clientName, buildArguments(testCase));
+      const failure = assertCase(testCase, payload.results ?? [], payload);
+      if (failure) {
+        failures++;
+        console.log(`FAIL ${testCase.label} | ${failure}`);
+      } else {
+        console.log(`PASS ${testCase.label} | ${testCase.query}`);
+      }
+    } catch (error) {
+      failures++;
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`FAIL ${testCase.label} | tool call failed: ${message}`);
+    }
+  }
+  console.log(
+    `${cases.length - failures}/${cases.length} cases passed (${live ? "live" : "recorded"} mode)`,
+  );
+  if (failures > 0) {
+    process.exitCode = 1;
+  }
+  return failures;
+}
+
+/** Standard assertion: a result URL contains the expected substring (or none exist). */
+export function assertExpectedUrl(testCase, results) {
+  if (testCase.empty) {
+    return results.length === 0 ? undefined : `expected an honest empty result, got ${results.length}`;
+  }
+  const expected = testCase.expected ?? testCase.url;
+  const match = results.find((result) => result.url.includes(expected));
+  if (!match) {
+    const seen = results.map((result) => result.url).join(", ") || "(none)";
+    return `expected a result URL containing ${expected}; got ${seen}`;
+  }
+  if (testCase.sourceKind && match.sourceKind !== testCase.sourceKind) {
+    return `expected sourceKind ${testCase.sourceKind}; got ${match.sourceKind}`;
+  }
+  if (testCase.providers?.length === 1 && match.provider !== testCase.providers[0]) {
+    return `expected provider ${testCase.providers[0]}; got ${match.provider}`;
+  }
+  return undefined;
+}

src/research-mcp/expo-algolia.ts

@@ -4,6 +4,7 @@
 import * as cheerio from "cheerio";
 import { z } from "zod";
 
+import type { FetchImplementation } from "./brave-search.js";
 import { expoProvider, resolveAllowedUrl } from "./providers.js";
 import { readBodyWithLimit } from "./response.js";
 import type { DiscoveredDocument } from "./types.js";
@@ -66,8 +67,9 @@ async function fetchExpoAlgolia(
   limit: number,
   timeoutMs: number,
   maxResponseBytes: number,
+  fetchImplementation: FetchImplementation,
 ): Promise<DiscoveredDocument[]> {
-  const response = await fetch(EXPO_ALGOLIA_ENDPOINT, {
+  const response = await fetchImplementation(EXPO_ALGOLIA_ENDPOINT, {
     method: "POST",
     redirect: "error",
     signal: AbortSignal.timeout(timeoutMs),
@@ -99,6 +101,7 @@ async function fetchExpoAlgolia(
 export async function searchExpoAlgolia(
   query: string,
   limit: number,
+  fetchImplementation: FetchImplementation = fetch,
 ): Promise<DiscoveredDocument[]> {
   const normalized = query.replace(/\s+/g, " ").trim();
   if (!normalized || normalized.length > 300) {
@@ -107,5 +110,5 @@ export async function searchExpoAlgolia(
   if (!Number.isInteger(limit) || limit < 1 || limit > 10) {
     throw new Error("Expo Algolia result limit must be between 1 and 10");
   }
-  return fetchExpoAlgolia(normalized, limit, 5000, 1_000_000);
+  return fetchExpoAlgolia(normalized, limit, 5000, 1_000_000, fetchImplementation);
 }

src/research-mcp/server.ts

@@ -126,7 +126,11 @@ export async function createDocumentationServer(options: DocumentationServerOpti
                 return { results: [] as SearchResult[], warnings: [] as string[] };
               }
               try {
-                const documents = await searchExpoAlgolia(sanitizedQuery, perProviderLimit);
+                const documents = await searchExpoAlgolia(
+                  sanitizedQuery,
+                  perProviderLimit,
+                  options.fetchImplementation ?? fetch,
+                );
                 return {
                   results: documents.map((document, position) => ({
                     id: `expo-algolia:${document.url}`,