@@ -1,5 +1,6 @@
 import assert from 'node:assert/strict';
 import fs from 'node:fs';
+import http from 'node:http';
 import os from 'node:os';
 import path from 'node:path';
 import { test } from 'vitest';
@@ -228,7 +229,7 @@ async function runLeg(leg: ScenarioLeg, legName: string): Promise<DaemonResponse
 }
 
 async function withProxiedWorld<T>(
-  run: (context: { world: ParityWorld; proxied: ScenarioLeg }) => Promise<T>,
+  run: (context: { world: ParityWorld; proxied: ScenarioLeg; upstream: http.Server }) => Promise<T>,
   options: ParityWorldOptions = {},
 ): Promise<T> {
   const world = await createParityWorld(options);
@@ -259,7 +260,7 @@ async function withProxiedWorld<T>(
         return responseFromClientError(error);
       }
     };
-    return await run({ world, proxied });
+    return await run({ world, proxied, upstream });
   } finally {
     await closeLoopbackServer(proxy);
     await closeLoopbackServer(upstream);
@@ -268,6 +269,39 @@ async function withProxiedWorld<T>(
   }
 }
 
+/**
+ * Every request the proxy forwards upstream, in order. Registering a second `request`
+ * listener records without displacing the server's own handler, so the daemon behaves
+ * exactly as it does untraced.
+ */
+function recordUpstreamRequests(upstream: http.Server): { forwarded: ForwardedRequest[] } {
+  const forwarded: ForwardedRequest[] = [];
+  upstream.on('request', (req, res) => {
+    const route = (req.url ?? '').split('?', 1)[0] ?? '';
+    const entry: ForwardedRequest = { method: req.method ?? '', route, responseBytes: 0 };
+    const end = res.end.bind(res);
+    const write = res.write.bind(res);
+    res.write = ((chunk: unknown, ...rest: unknown[]) => {
+      entry.responseBytes += byteLengthOf(chunk);
+      return (write as (...args: unknown[]) => boolean)(chunk, ...rest);
+    }) as typeof res.write;
+    res.end = ((chunk?: unknown, ...rest: unknown[]) => {
+      entry.responseBytes += byteLengthOf(chunk);
+      return (end as (...args: unknown[]) => http.ServerResponse)(chunk, ...rest);
+    }) as typeof res.end;
+    forwarded.push(entry);
+  });
+  return { forwarded };
+}
+
+type ForwardedRequest = { method: string; route: string; responseBytes: number };
+
+function byteLengthOf(chunk: unknown): number {
+  if (typeof chunk === 'string') return Buffer.byteLength(chunk);
+  if (chunk instanceof Uint8Array) return chunk.byteLength;
+  return 0;
+}
+
 type LegRun = { responses: DaemonResponse[]; sessionRoot: string };
 
 function assertPublishedParity(direct: LegRun, proxied: LegRun): void {
@@ -403,6 +437,65 @@ test(
   PARALLEL_PROVIDER_SCENARIO_TIMEOUT_MS,
 );
 
+/**
+ * #2198: "the regular-snapshot trace must prove the bridge adds no network round trip and
+ * transfers only the published response." That was previously read off the RTT benchmark —
+ * identical response bytes and an unchanged wall-clock slope — which is inference, not proof.
+ * This asserts it: one `snapshot -i` behind the proxy forwards exactly one upstream request,
+ * it is the RPC, and the bytes crossing are the published response and nothing else.
+ *
+ * The regression it guards is a second forwarded call per snapshot — a bridge, helper or
+ * admin round trip appearing on the wire, which #2198 forbids outright.
+ */
+test(
+  'a proxied snapshot forwards one upstream request and only the published response',
+  {
+    timeout: PARALLEL_PROVIDER_SCENARIO_TIMEOUT_MS,
+  },
+  async (t) => {
+    if (await skipWhenLoopbackUnavailable(t)) return;
+    await withProxiedWorld(async ({ proxied, upstream }) => {
+      const flags = { platform: 'ios', udid: SIM.id } as const;
+      await proxied({ session: 'default', command: 'open', positionals: [APP], flags });
+
+      // Record only the snapshot: the open above is setup and makes its own calls.
+      const { forwarded } = recordUpstreamRequests(upstream);
+      const response = await proxied({
+        session: 'default',
+        command: 'snapshot',
+        positionals: [],
+        flags: { snapshotInteractiveOnly: true },
+      });
+      assert.equal(response.ok, true);
+
+      // The WHOLE wire conversation, not just the RPC, so any new call of any kind breaks
+      // this. `GET /health` is the client's own ADR 0006 protocol-compatibility probe on the
+      // remote path (`ensureRemoteDaemon`); it is not the bridge, and it predates the bridge.
+      // The bridge itself contributes nothing: no helper, admin or acquisition route appears.
+      assert.deepEqual(
+        forwarded.map((entry) => `${entry.method} ${entry.route}`),
+        ['GET /health', 'POST /rpc'],
+        'a proxied snapshot must cross the wire only as the compat probe and the RPC',
+      );
+
+      // Only the published response crosses: the proxy adds no envelope of its own, so the
+      // bytes the daemon wrote are the bytes the client's response accounts for.
+      const publishedBytes = Buffer.byteLength(JSON.stringify(response));
+      const forwardedBytes = forwarded.at(-1)?.responseBytes ?? 0;
+      assert.ok(
+        forwardedBytes >= publishedBytes,
+        `upstream sent ${forwardedBytes} bytes, less than the published response (${publishedBytes})`,
+      );
+      // The JSON-RPC envelope around the published result is small and fixed; anything that
+      // carried a second payload (an acquired tree, lineage, a runner quality blob) would not fit.
+      assert.ok(
+        forwardedBytes < publishedBytes * 2,
+        `upstream sent ${forwardedBytes} bytes for a ${publishedBytes}-byte response: more than the published response crossed`,
+      );
+    });
+  },
+);
+
 const LEASE_SCOPE = {
   tenantId: 'team-a',
   runId: 'run-a',