From 1dd3eadae5d7d45b7d9319d5e7ee14b3a114f789 Mon Sep 17 00:00:00 2001
From: Younes Abouelnagah <timeleft--@users.noreply.github.com>
Date: Thu, 29 Oct 2026 18:01:43 -0400
Subject: [PATCH 1/4] feat(mcp): record first-load evidence on the server and
 in the card

Issue #335: in Claude web and ChatGPT web the host's own error replaced the
card on first load and one Retry recovered it. The card's own failure texts
never appeared, and the server logged every exchange as a bare `POST`, so a
stale card read (JSON-RPC -32602 inside HTTP 200) looked like a successful one.

- Server, always on: `mcp.request`/`mcp.response` lines joined by `rid`, with
  the JSON-RPC method, the card address read and whether it is current, the
  handshake's client and protocol, status, error code, bytes, timings and
  whether the client hung up. Handler errors log name and code only.
- Card, always on: an early script records script start, errors, rejections,
  CSP violations and host message arrival (tool input/result/cancel, teardown
  request); the stack's hooks mark fonts, context, start outcome and the first
  rendered answer or problem. Each report is an `[ansari-view]` console line.
- Diagnosed deployment only: MCP_VIEW_DIAGNOSTICS_ORIGIN opens connect-src to
  that one origin and adds `POST /diag/view`, which accepts a fixed report
  shape and logs it as `view.report`. Unset, the route does not exist and the
  card's permissions stay closed.
- scripts/first-load-trial.sh and first-load-timeline.mjs turn host trials and
  Railway deployment/edge logs into one timeline per trial with findings.

The browser suite found one violation on every load: zod's caught
`new Function('')` probe under the card's script-src. It is the recorded
baseline; any other error fails the check.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 apps/mcp/README.md                       |  43 +++++++
 apps/mcp/scripts/first-load-timeline.mjs |  78 ++++++++++++
 apps/mcp/scripts/first-load-trial.sh     |  42 +++++++
 apps/mcp/src/node/http-server.ts         |   1 +
 apps/mcp/src/server/exchange-log.ts      | 116 +++++++++++++++++
 apps/mcp/src/server/fetch-app.ts         |  52 ++++++--
 apps/mcp/src/server/runtime-config.ts    |  15 +++
 apps/mcp/src/server/view-artifact.ts     |  20 ++-
 apps/mcp/src/server/view-report.ts       |  68 ++++++++++
 apps/mcp/src/view/diagnostic-marks.ts    |  17 +++
 apps/mcp/src/view/diagnostics.ts         |  94 ++++++++++++++
 apps/mcp/src/view/main.tsx               |  20 ++-
 apps/mcp/src/view/mcp-app-react.html     |  31 +++++
 apps/mcp/src/worker/index.ts             |   1 +
 apps/mcp/test/browser.ts                 |  45 ++++++-
 apps/mcp/test/diagnostics.test.ts        | 152 +++++++++++++++++++++++
 apps/mcp/turbo.json                      |   2 +
 17 files changed, 778 insertions(+), 19 deletions(-)
 create mode 100644 apps/mcp/scripts/first-load-timeline.mjs
 create mode 100644 apps/mcp/scripts/first-load-trial.sh
 create mode 100644 apps/mcp/src/server/exchange-log.ts
 create mode 100644 apps/mcp/src/server/view-report.ts
 create mode 100644 apps/mcp/src/view/diagnostic-marks.ts
 create mode 100644 apps/mcp/src/view/diagnostics.ts
 create mode 100644 apps/mcp/test/diagnostics.test.ts

diff --git a/apps/mcp/README.md b/apps/mcp/README.md
index b983f99b..a1b7291e 100644
--- a/apps/mcp/README.md
+++ b/apps/mcp/README.md
@@ -95,11 +95,54 @@ The Worker takes the variables in the table below as Wrangler `vars` or secrets,
 | `MCP_ALLOWED_ORIGINS` | Comma-separated allowed browser origin hostnames. A configured list replaces defaults; an explicitly empty list permits no Origin header value. Requests without Origin remain supported. |
 | `MCP_RESPONSE_MODE` | `json` for modern MCP final-answer-only responses; otherwise SSE, which supports client-requested progress notifications. Older-host compatibility responses may use SSE. |
 | `ANSARI_RELEASE` | Optional safe release identifier, embedded in served HTML and health/log records. |
+| `MCP_VIEW_DIAGNOSTICS_ORIGIN` | Set only on a deployment being diagnosed: its own public origin, such as `https://ansari-mcp-development.up.railway.app`. The card may then connect to that one origin and reports its start-up milestones to `POST /diag/view`; this changes the card's bytes and so its address. Unset, the card, its address and its closed permissions are unchanged and the route does not exist. A value that is not a bare `https` origin (`http` only for localhost) stops startup. See [First-load diagnosis](#first-load-diagnosis). |
 
 `POST /mcp` serves stateless MCP requests through Hono and the official MCP request handler. Modern requests need no initialization; older hosts can use the handler’s stateless compatibility path. No MCP session IDs, session map, expiry timer or replay store are retained. `GET /mcp` and `DELETE /mcp` return 405. `/health` exposes the release. The HTML is supplied by the hosting target (read from `dist/` at Node start, bundled into the Worker), revision-stamped and fingerprinted once before the first request is served: the release is stamped first, so equal final bytes have equal identities and a release change legitimately changes the hash. Each request creates its own lightweight MCP server using that prepared view; resource bytes and identity stay fixed until restart. No demo, font server, alternative renderer or historical resource is served. Tool calls have a fresh 60-second budget; timeout yields a safe error and leaves subsequent calls usable. The same lifetime signal aborts the upstream fetch and response-body read when the request ends or the budget expires.
 
 Closing a request server releases its budget even if it was never connected to a transport. On SIGINT or SIGTERM the listener stops accepting requests, closes MCP handlers and HTTP connections, and exits; unfinished calls are interrupted, including older-host SSE calls. Fetch cancellation does not guarantee that the remote backend has stopped processing. Caller-disconnect propagation depends on the host transport; the local Workers runtime does not establish immediate upstream cancellation from a client disconnect. Actual fetch cancellation at the request deadline is covered on both hosting targets.
 
+## First-load diagnosis
+
+Issue #335: in Claude web and ChatGPT web the host's own error replaced the card on first load, and one Retry
+recovered it. The card's own failure texts never appeared, so the host gave up before the card showed anything. These
+records tell the possible causes apart.
+
+**Server, always on.** Each `/mcp` exchange writes an `mcp.request` line when it arrives and an `mcp.response` line
+when it ends, joined by `rid`. The request line names the JSON-RPC method; for a card read, the address read and
+whether it is the one served now (`uriCurrent`); for the opening handshake, the client's name, version and protocol;
+for a tool call, the tool name. The response line has the HTTP status, any JSON-RPC error code (a stale card read is
+error `-32602` inside an HTTP 200), bytes sent, time to headers and total time, and whether the response was
+`complete`, `cancelled` by the client or `failed`. Handler errors are logged by name and code. No question, answer or
+other parameter value is logged.
+
+**Card, always on.** A small script runs before the bundle and records when it started, any error, unhandled
+rejection or content-policy violation, and when the host's messages arrive (first message, tool input, tool result,
+cancellation, teardown request), by method name only. The stack's hooks add when fonts loaded, when the host context
+was delivered, how starting ended and when the first answer or problem was rendered. The card writes each report as an
+`[ansari-view]` console line in its frame. One violation is expected on every load: zod's `new Function('')`
+capability probe under the card's `script-src`, which it catches.
+
+**Card beacon, diagnosed deployment only.** With `MCP_VIEW_DIAGNOSTICS_ORIGIN` set, the card also sends each report
+to `POST /diag/view` when it starts or fails, renders its first answer or problem, is put away, or has not started
+after 15 seconds. The server accepts only the fixed report shape (milestones, enumerated failures, error names) and
+logs it as `view.report`, with the host sandbox's origin name.
+
+**Trials.** Run one trial per new conversation, with the deployment live for hours (`aged`) and right after a
+redeploy (`fresh`):
+
+```sh
+bash scripts/first-load-trial.sh claude aged
+bash scripts/first-load-trial.sh chatgpt fresh
+# Railway: deployment and edge HTTP logs for the trial window, then one timeline per trial.
+railway logs --deployment --json --since 1h > test-results/first-load/app.jsonl
+railway logs --http --json --since 1h > test-results/first-load/edge.jsonl
+node scripts/first-load-timeline.mjs test-results/first-load/trials.jsonl test-results/first-load/app.jsonl test-results/first-load/edge.jsonl
+```
+
+The timeline flags a card read that never reached the server, a card address that is not the current deploy's, a card
+read that was cancelled or slow, a card whose host asked to tear it down before it was ready, a card that never heard
+from the host, and a slow start.
+
 ## Workspace and container
 
 This package lives at `apps/mcp` and is named `ansari-mcp`. The root `pnpm-lock.yaml` and `pnpm-workspace.yaml` are the only install inputs. `pnpm mcp <script>` targets this app. Shared TypeScript and lint tools use the workspace catalog; no application-local lockfile or standalone workspace is maintained.
diff --git a/apps/mcp/scripts/first-load-timeline.mjs b/apps/mcp/scripts/first-load-timeline.mjs
new file mode 100644
index 00000000..dd26939f
--- /dev/null
+++ b/apps/mcp/scripts/first-load-timeline.mjs
@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+// Joins first-load trials (scripts/first-load-trial.sh) with the server's logs, one timeline per trial (#335).
+//
+// Usage: node scripts/first-load-timeline.mjs <trials.jsonl> <log.jsonl>...
+// Each log file holds JSON lines in any of three forms: the application's own records (`event`, with `at`),
+// Railway deployment logs (`railway logs --deployment --json`: `timestamp` and the record in `message`), or Railway
+// edge HTTP logs (`railway logs --http --json`: `timestamp`, path, status, duration and bytes).
+import {readFileSync} from 'node:fs';
+
+const [trialsFile, ...logFiles] = process.argv.slice(2);
+if (!trialsFile || logFiles.length === 0) {
+  console.error('usage: node scripts/first-load-timeline.mjs <trials.jsonl> <log.jsonl>...');
+  process.exit(2);
+}
+const lines = file => readFileSync(file, 'utf8').split('\n').filter(line => line.trim()).flatMap(line => {
+  try { return [JSON.parse(line)]; } catch { return []; }
+});
+const MARGIN_MS = 5_000;
+
+/** One normalized entry: when, what kind, and the fields worth printing. */
+function normalize(raw) {
+  const time = Date.parse(raw.timestamp ?? '') || raw.at;
+  if (typeof raw.message === 'string' && raw.message.startsWith('{')) {
+    try { const record = JSON.parse(raw.message); return {...record, at: record.at ?? time}; } catch { /* plain text line */ }
+  }
+  if (raw.event) return {...raw, at: time};
+  const path = raw.path ?? raw.attributes?.path;
+  if (path !== undefined) return {event: 'edge', at: time, ...raw};
+  return undefined;
+}
+const entries = logFiles.flatMap(lines).map(normalize).filter(entry => entry && typeof entry.at === 'number').sort((a, b) => a.at - b.at);
+const diagnosticsSeen = entries.some(entry => entry.event === 'view.report');
+
+function describe(entry, zero) {
+  const t = `+${((entry.at - zero) / 1000).toFixed(2)}s`.padStart(9);
+  switch (entry.event) {
+    case 'mcp.request': return `${t} → ${entry.rpc}${entry.uri ? ` ${entry.uri}${entry.uriCurrent === false ? ' (NOT CURRENT)' : ''}` : ''}${entry.client ? ` client=${entry.client}/${entry.clientVersion}` : ''} [${entry.rid}]`;
+    case 'mcp.response': return `${t} ← ${entry.rpc} ${entry.status} ${entry.outcome} ${entry.bytes}B headers=${entry.headersMs}ms total=${entry.ms}ms${entry.errorCode === undefined ? '' : ` error=${entry.errorCode}`} [${entry.rid}]`;
+    case 'view.report': return `${t} ◆ card ${entry.view} ${entry.reason}${entry.failure ? ` failure=${entry.failure}` : ''} host=${entry.host ?? '?'} origin=${entry.origin} marks=${JSON.stringify(entry.marks)}${entry.errors?.length ? ` errors=${JSON.stringify(entry.errors)}` : ''}`;
+    case 'edge': {
+      const pick = ['method', 'path', 'httpStatus', 'totalDuration', 'responseTime', 'txBytes', 'rxBytes', 'clientUa', 'responseDetails'];
+      return `${t} ▸ edge ${pick.map(key => entry[key] ?? entry.attributes?.[key]).filter(value => value !== undefined).join(' ')}`;
+    }
+    default: return `${t} · ${entry.event}${entry.rpc ? ` ${entry.rpc}` : ''}${entry.name ? ` ${entry.name}` : ''}${entry.code !== undefined ? ` code=${entry.code}` : ''}`;
+  }
+}
+
+/** What the window shows, as findings tied to the hypotheses in #335. */
+function findings(window) {
+  const out = [];
+  const reads = window.filter(entry => entry.event === 'mcp.request' && entry.rpc === 'resources/read');
+  const readEnds = window.filter(entry => entry.event === 'mcp.response' && entry.rpc === 'resources/read');
+  if (reads.length === 0) out.push('no card read reached the server in this window (the host used a cached card, or never asked)');
+  if (reads.some(entry => entry.uriCurrent === false)) out.push('a card address that is not the current deploy\'s was read (stale discovery)');
+  for (const end of readEnds) if (end.outcome !== 'complete') out.push(`a card read was ${end.outcome} after ${end.ms}ms and ${end.bytes}B`);
+  const slow = readEnds.filter(end => end.ms > 2_000);
+  if (slow.length) out.push(`card reads slower than 2s: ${slow.map(end => `${end.ms}ms`).join(', ')}`);
+  const cards = new Map();
+  for (const entry of window.filter(item => item.event === 'view.report')) cards.set(entry.view, entry);
+  if (diagnosticsSeen) out.push(`${cards.size} card instance(s) reported`);
+  for (const [id, last] of cards) {
+    const m = last.marks ?? {};
+    if (m.teardownRequested !== undefined && m.ready === undefined) out.push(`card ${id}: the host asked to tear it down before it was ready`);
+    if (last.failure) out.push(`card ${id}: start failed (${last.failure})`);
+    if (m.ready !== undefined && m.script !== undefined && m.ready - m.script > 3_000) out.push(`card ${id}: ${Math.round(m.ready - m.script)}ms from script start to ready`);
+    if (m.hostMessage === undefined) out.push(`card ${id}: no message from the host ever arrived`);
+  }
+  return out;
+}
+
+for (const trial of lines(trialsFile)) {
+  const start = Date.parse(trial.start);
+  const end = Date.parse(trial.end);
+  const window = entries.filter(entry => entry.at >= start - MARGIN_MS && entry.at <= end + MARGIN_MS);
+  console.log(`\n=== ${trial.host} / ${trial.deploy} / ${trial.label}: first=${trial.first} retry=${trial.retry} (${trial.start} → ${trial.end})`);
+  for (const entry of window) console.log(describe(entry, start));
+  for (const finding of findings(window)) console.log(`  ! ${finding}`);
+}
diff --git a/apps/mcp/scripts/first-load-trial.sh b/apps/mcp/scripts/first-load-trial.sh
new file mode 100644
index 00000000..28dfa2f4
--- /dev/null
+++ b/apps/mcp/scripts/first-load-trial.sh
@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+# One first-load trial in a real host (#335). The person at the host follows the prompts; the script records the
+# trial window and what they saw as one JSON line, which scripts/first-load-timeline.mjs joins with the server logs.
+#
+# Usage: bash scripts/first-load-trial.sh <host: claude|chatgpt> <deploy: fresh|aged> [case label]
+# Output: test-results/first-load/trials.jsonl (git-ignored)
+set -euo pipefail
+
+host="${1:?host: claude or chatgpt}"
+deploy="${2:?deploy: fresh (just redeployed) or aged (live for hours)}"
+label="${3:-english-greeting}"
+out="$(dirname "$0")/../test-results/first-load"
+mkdir -p "$out"
+
+step() {
+  printf '\n>>> %s\n' "$1"
+  read -r -p "    [Enter when done] " _
+}
+capture() {
+  local var="$1" question="$2" answer
+  printf '\n>>> %s\n' "$question"
+  read -r -p "    > " answer
+  printf -v "$var" '%s' "$answer"
+}
+
+step "In $host, open a NEW conversation with the Ansari Dev connector enabled. Do not send anything yet. Optional: open devtools on the page."
+start="$(date -u +%Y-%m-%dT%H:%M:%S.000Z)"
+step "Send: Use Ansari Faithful Answers Dev to answer: What does \"assalamu alaikum\" mean? Please keep the answer brief."
+capture first "What did the embed show first? (card / error / blank / none)"
+retry="n-a"
+if [ "$first" != "card" ]; then
+  capture retry "Press the host's Retry / Try again once. What does it show now? (card / error / blank / none)"
+fi
+capture console "Optional: paste the [ansari-view] console lines from the card frame, or press Enter"
+end="$(date -u +%Y-%m-%dT%H:%M:%S.000Z)"
+
+node -e 'const [host, deploy, label, start, end, first, retry, consoleLines] = process.argv.slice(1);
+  process.stdout.write(JSON.stringify({host, deploy, label, start, end, first, retry, console: consoleLines || undefined}) + "\n");' \
+  "$host" "$deploy" "$label" "$start" "$end" "$first" "$retry" "$console" >> "$out/trials.jsonl"
+
+printf '\n--- Recorded in %s ---\n' "$out/trials.jsonl"
+tail -n 1 "$out/trials.jsonl"
diff --git a/apps/mcp/src/node/http-server.ts b/apps/mcp/src/node/http-server.ts
index 1367dd3c..73336017 100644
--- a/apps/mcp/src/node/http-server.ts
+++ b/apps/mcp/src/node/http-server.ts
@@ -43,6 +43,7 @@ export function createHttpServer(options: ListenOptions = {}) {
     enableJsonResponse: settings.enableJsonResponse,
     logger: options.logger ?? defaultOperationLogger,
     requestMs: options.requestMs,
+    viewDiagnosticsOrigin: settings.viewDiagnosticsOrigin,
   });
 
   // The adapter's default createServer is Node's HTTP/1 server.
diff --git a/apps/mcp/src/server/exchange-log.ts b/apps/mcp/src/server/exchange-log.ts
new file mode 100644
index 00000000..61b79c2b
--- /dev/null
+++ b/apps/mcp/src/server/exchange-log.ts
@@ -0,0 +1,116 @@
+// What one MCP exchange looked like on the wire, for first-load diagnosis (#335): which method a host called,
+// which card address it read and whether that address is the one served now, and how the response ended.
+// Only fixed fields are derived from the request; no question, answer or other parameter value is kept.
+
+/** Request bodies larger than this are not inspected; MCP requests from hosts are a few kilobytes at most. */
+const MAX_INSPECTED_BODY = 65_536;
+/** How much of a response is searched for a JSON-RPC error code. A successful card read is far larger. */
+const RESPONSE_HEAD = 2_048;
+const TOKEN = /^[A-Za-z0-9 ._:/@+-]{1,80}$/;
+const UI_URI = /^ui:\/\/[A-Za-z0-9._/-]{1,200}$/;
+const ERROR_CODE = /"error"\s*:\s*\{\s*"code"\s*:\s*(-?\d{1,6})/;
+
+export type RpcSummary = {
+  rpc: string;
+  requestId?: string | number;
+  uri?: string;
+  uriCurrent?: boolean;
+  client?: string;
+  clientVersion?: string;
+  protocol?: string;
+  tool?: string;
+};
+
+export type ExchangeEnd = {outcome: 'complete' | 'cancelled' | 'failed'; bytes: number; errorCode?: number};
+
+const token = (value: unknown): string | undefined => typeof value === 'string' ? (TOKEN.test(value) ? value : 'other') : undefined;
+const record = (value: unknown): Record<string, unknown> => typeof value === 'object' && value !== null && !Array.isArray(value) ? value as Record<string, unknown> : {};
+
+function summarizeMessage(message: Record<string, unknown>, currentUri: string): RpcSummary {
+  if (typeof message.method !== 'string') return {rpc: 'result' in message || 'error' in message ? 'response' : 'unparsed'};
+  const summary: RpcSummary = {rpc: token(message.method)!};
+  if (typeof message.id === 'number' || (typeof message.id === 'string' && TOKEN.test(message.id))) summary.requestId = message.id;
+  const params = record(message.params);
+  if (message.method === 'initialize') {
+    const clientInfo = record(params.clientInfo);
+    summary.client = token(clientInfo.name);
+    summary.clientVersion = token(clientInfo.version);
+    summary.protocol = token(params.protocolVersion);
+  } else if (message.method === 'tools/call') {
+    summary.tool = token(params.name);
+  } else if (message.method === 'resources/read') {
+    const uri = typeof params.uri === 'string' && UI_URI.test(params.uri) ? params.uri : 'other';
+    summary.uri = uri;
+    summary.uriCurrent = uri === currentUri;
+  }
+  return summary;
+}
+
+/** The JSON-RPC method(s) of a request body, with the few identifying fields that tell first-load paths apart. */
+export function summarizeRpc(body: string, currentUri: string): RpcSummary {
+  let parsed: unknown;
+  try { parsed = JSON.parse(body); } catch { return {rpc: 'unparsed'}; }
+  if (Array.isArray(parsed)) {
+    const messages = parsed.slice(0, 5).map(item => summarizeMessage(record(item), currentUri));
+    return {...messages[0], rpc: messages.map(message => message.rpc).join(',') || 'empty'};
+  }
+  return summarizeMessage(record(parsed), currentUri);
+}
+
+/** The body of a POST, read from a copy so the MCP handler still receives the original. */
+export async function inspectableBody(request: Request): Promise<string | undefined> {
+  if (request.method !== 'POST') return undefined;
+  const declared = Number(request.headers.get('content-length') ?? 0);
+  if (declared > MAX_INSPECTED_BODY) return undefined;
+  const text = await request.clone().text();
+  return text.length > MAX_INSPECTED_BODY ? undefined : text;
+}
+
+/**
+ * Passes the response through unchanged while counting what is sent, and reports once how it ended: fully sent,
+ * abandoned by the client, or failed. The first bytes are searched for a JSON-RPC error code, which an MCP error
+ * carries inside an HTTP 200.
+ */
+export function observeResponse(response: Response, done: (end: ExchangeEnd) => void): Response {
+  let ended = false;
+  let bytes = 0;
+  let head = '';
+  const decoder = new TextDecoder();
+  const finish = (outcome: ExchangeEnd['outcome']) => {
+    if (ended) return;
+    ended = true;
+    const code = ERROR_CODE.exec(head)?.[1];
+    done({outcome, bytes, ...(code === undefined ? {} : {errorCode: Number(code)})});
+  };
+  if (response.body === null) { finish('complete'); return response; }
+  const reader = response.body.getReader();
+  const body = new ReadableStream<Uint8Array>({
+    async pull(controller) {
+      try {
+        const {done: last, value} = await reader.read();
+        if (last) { finish('complete'); controller.close(); return; }
+        bytes += value.byteLength;
+        if (head.length < RESPONSE_HEAD) head += decoder.decode(value.subarray(0, RESPONSE_HEAD), {stream: true});
+        controller.enqueue(value);
+      } catch (error) {
+        finish('failed');
+        controller.error(error);
+      }
+    },
+    cancel(reason) {
+      finish('cancelled');
+      return reader.cancel(reason);
+    },
+  });
+  return new Response(body, {status: response.status, statusText: response.statusText, headers: response.headers});
+}
+
+/** An error's name and code only: never its message, which can carry request content. */
+export function errorIdentity(error: unknown): {name?: string; code?: string | number} {
+  const value = record(error);
+  const code = value.code;
+  return {
+    name: error instanceof Error ? token(error.name) : undefined,
+    ...(typeof code === 'number' ? {code} : typeof code === 'string' ? {code: token(code)} : {}),
+  };
+}
diff --git a/apps/mcp/src/server/fetch-app.ts b/apps/mcp/src/server/fetch-app.ts
index ef746b9d..cf075f3d 100644
--- a/apps/mcp/src/server/fetch-app.ts
+++ b/apps/mcp/src/server/fetch-app.ts
@@ -3,7 +3,9 @@ import {createMcpHandler} from '@modelcontextprotocol/server';
 import {Hono} from 'hono';
 import type {AnswerCompleter} from './ansari-client.js';
 import {createAnsariMcpServer} from './create-server.js';
-import {prepareAnswerView} from './view-artifact.js';
+import {errorIdentity, inspectableBody, observeResponse, summarizeRpc} from './exchange-log.js';
+import {VIEW_DIAGNOSTICS_PATH, prepareAnswerView} from './view-artifact.js';
+import {MAX_VIEW_REPORT_BYTES, originHost, parseViewReport} from './view-report.js';
 import {type OperationLogger, writeOperationLog} from './operation-log.js';
 
 export const MCP_PATH = '/mcp';
@@ -22,6 +24,8 @@ export type FetchAppOptions = {
   enableJsonResponse: boolean;
   logger: OperationLogger;
   requestMs?: number;
+  /** Dev-only: the public origin a diagnostic card reports its milestones to (see `VIEW_DIAGNOSTICS_PATH`). */
+  viewDiagnosticsOrigin?: string;
 };
 
 export type FetchApp = {
@@ -34,24 +38,56 @@ export function createFetchApp(options: FetchAppOptions): FetchApp {
   const {completer, logger, release} = options;
   const log = (record: Parameters<typeof writeOperationLog>[0]) => writeOperationLog(record, logger, release);
   // The view is prepared once: release stamping first, then the resource identity from the final bytes.
-  const view = prepareAnswerView(options.html, release);
+  const view = prepareAnswerView(options.html, release, options.viewDiagnosticsOrigin);
   // The official handler owns per-request transports, protocol negotiation and cleanup.
   // Both modern MCP and its older-host fallback are stateless; only the prepared view is shared.
   const mcp = createMcpHandler(
     () => createAnsariMcpServer({completer, view, logger, release, requestMs: options.requestMs}),
-    {responseMode: options.enableJsonResponse ? 'json' : 'sse', onerror: () => log({event: 'mcp.error'})},
+    {responseMode: options.enableJsonResponse ? 'json' : 'sse', onerror: (error: unknown) => log({event: 'mcp.error', ...errorIdentity(error)})},
   );
   const app = new Hono();
   app.get('/health', c => c.json({ok: true, mcp: MCP_PATH, release}));
   app.use(MCP_PATH, hostHeaderValidation(options.allowedHosts));
   app.use(MCP_PATH, originValidation(options.allowedOrigins));
-  app.all(MCP_PATH, c => {
-    log({event: 'mcp.request', method: c.req.method});
-    return mcp.fetch(c.req.raw);
+  // One line when a request arrives and one when its response ends, joined by `rid`: which method a host called,
+  // which card address it read, and whether the response was fully sent (#335).
+  app.all(MCP_PATH, async c => {
+    const started = Date.now();
+    const rid = crypto.randomUUID().slice(0, 8);
+    const body = await inspectableBody(c.req.raw);
+    const summary = body === undefined ? {rpc: c.req.method === 'POST' ? 'oversize' : 'none'} : summarizeRpc(body, view.uri);
+    log({event: 'mcp.request', at: started, method: c.req.method, rid, ...summary});
+    const response = await mcp.fetch(c.req.raw);
+    const headersMs = Date.now() - started;
+    return observeResponse(response, end => log({event: 'mcp.response', at: Date.now(), rid, rpc: summary.rpc, status: response.status, headersMs, ms: Date.now() - started, ...end}));
   });
+  if (options.viewDiagnosticsOrigin !== undefined) {
+    app.use(VIEW_DIAGNOSTICS_PATH, hostHeaderValidation(options.allowedHosts));
+    // A beacon from a sandboxed card: no credentials, a simple text/plain request and nothing to read back.
+    app.post(VIEW_DIAGNOSTICS_PATH, async c => {
+      c.header('access-control-allow-origin', '*');
+      const origin = originHost(c.req.header('origin') ?? null);
+      if (Number(c.req.header('content-length') ?? 0) > MAX_VIEW_REPORT_BYTES) {
+        log({event: 'view.report.invalid', reason: 'size', origin});
+        return c.body(null, 413);
+      }
+      const text = await c.req.text();
+      if (text.length > MAX_VIEW_REPORT_BYTES) {
+        log({event: 'view.report.invalid', reason: 'size', origin});
+        return c.body(null, 413);
+      }
+      const report = parseViewReport(text);
+      if (report === undefined) {
+        log({event: 'view.report.invalid', reason: 'shape', origin});
+        return c.body(null, 400);
+      }
+      log({event: 'view.report', at: Date.now(), origin, ...report});
+      return c.body(null, 204);
+    });
+  }
   app.notFound(c => c.json({error: 'not found'}, 404));
-  app.onError((_, c) => {
-    log({event: 'mcp.error', method: c.req.method});
+  app.onError((error, c) => {
+    log({event: 'mcp.error', method: c.req.method, ...errorIdentity(error)});
     return c.json({error: 'internal error'}, 500);
   });
   return {fetch: request => app.fetch(request), close: () => mcp.close()};
diff --git a/apps/mcp/src/server/runtime-config.ts b/apps/mcp/src/server/runtime-config.ts
index 1b8e4a7b..1a67b84f 100644
--- a/apps/mcp/src/server/runtime-config.ts
+++ b/apps/mcp/src/server/runtime-config.ts
@@ -26,9 +26,23 @@ export type EnvSettings = {
   allowedHosts: string[];
   allowedOrigins: string[];
   enableJsonResponse: boolean;
+  /** First-load diagnosis: the public origin the card's beacon reports to. Unset unless a deployment is being diagnosed. */
+  viewDiagnosticsOrigin?: string;
   ansari: {baseUrl?: string; clientName?: string; authorization?: string};
 };
 
+/** A bare https origin (http only for a local listener), or a startup error: a wrong value must not pass silently. */
+function diagnosticsOrigin(value: string | undefined): string | undefined {
+  if (value === undefined) return undefined;
+  const refuse = (): never => { throw new Error(`MCP_VIEW_DIAGNOSTICS_ORIGIN must be a bare origin such as https://mcp.example: ${JSON.stringify(value)}`); };
+  let url: URL;
+  try { url = new URL(value); } catch { return refuse(); }
+  const local = url.hostname === 'localhost' || url.hostname === '127.0.0.1';
+  if (!(url.protocol === 'https:' || (url.protocol === 'http:' && local))) refuse();
+  if (url.username || url.password || url.pathname !== '/' || url.search || url.hash || value.includes('?') || value.includes('#')) refuse();
+  return url.origin;
+}
+
 /** Explicit overrides, then configured lists (including empty), then local defaults. */
 function allowedList(value: unknown, override: string[] | undefined, fallback: string[]): string[] {
   const selected = override ?? (typeof value === 'string' ? list(value) : fallback);
@@ -44,6 +58,7 @@ export function settingsFromEnv(env: RuntimeEnv, overrides: {allowedHosts?: stri
     allowedHosts,
     allowedOrigins,
     enableJsonResponse: overrides.enableJsonResponse ?? setting(env, 'MCP_RESPONSE_MODE') === 'json',
+    viewDiagnosticsOrigin: diagnosticsOrigin(setting(env, 'MCP_VIEW_DIAGNOSTICS_ORIGIN')),
     ansari: {baseUrl: setting(env, 'ANSARI_API_BASE_URL'), clientName: setting(env, 'ANSARI_CLIENT'), authorization: setting(env, 'ANSARI_API_AUTHORIZATION')},
   };
 }
diff --git a/apps/mcp/src/server/view-artifact.ts b/apps/mcp/src/server/view-artifact.ts
index d26b0bd0..c6b67ece 100644
--- a/apps/mcp/src/server/view-artifact.ts
+++ b/apps/mcp/src/server/view-artifact.ts
@@ -3,10 +3,24 @@ import {stampHtmlRevision} from './operation-log.js';
 
 /** The file name the view's content identity keeps: `ui://views/answer-card.<fingerprint>.html`. */
 export const VIEW_FILENAME = 'answer-card.html';
+/** Where a diagnostic card sends its milestone reports (#335). Served only when a diagnostics origin is configured. */
+export const VIEW_DIAGNOSTICS_PATH = '/diag/view';
+const CLOSED_CONNECT = "connect-src 'none'";
 
-/** Prepare immutable deployment bytes once from the built card the host supplies: no file is read here. */
-export function prepareAnswerView(html: string, release?: string): OperationView {
-  const currentHtml = stampHtmlRevision(html, release);
+/**
+ * Prepare immutable deployment bytes once from the built card the host supplies: no file is read here.
+ * With a diagnostics origin (Dev only), the card may connect to that one origin and is told where to report; this
+ * changes its bytes and so its address. Without one, the card and its permissions are exactly the built card's.
+ */
+export function prepareAnswerView(html: string, release?: string, diagnosticsOrigin?: string): OperationView {
+  let currentHtml = stampHtmlRevision(html, release);
+  if (diagnosticsOrigin !== undefined) {
+    if (!currentHtml.includes(CLOSED_CONNECT)) throw new Error(`The card has no "${CLOSED_CONNECT}" rule to open for diagnostics.`);
+    currentHtml = currentHtml
+      .replace(CLOSED_CONNECT, `connect-src ${diagnosticsOrigin}`)
+      .replace(/<body([^>]*)>/, `<body$1 data-diagnostics="${diagnosticsOrigin}${VIEW_DIAGNOSTICS_PATH}">`);
+    return Object.freeze(operationViewFromHtml({html: currentHtml, filename: VIEW_FILENAME, title: 'Ansari answer card', csp: {connectDomains: [diagnosticsOrigin]}}));
+  }
   // The identity is taken from the final bytes, after revision stamping. Declared permissions stay closed.
   return Object.freeze(operationViewFromHtml({html: currentHtml, filename: VIEW_FILENAME, title: 'Ansari answer card'}));
 }
diff --git a/apps/mcp/src/server/view-report.ts b/apps/mcp/src/server/view-report.ts
new file mode 100644
index 00000000..68834de1
--- /dev/null
+++ b/apps/mcp/src/server/view-report.ts
@@ -0,0 +1,68 @@
+import {z} from 'zod';
+import {VIEW_MARKS, VIEW_REPORT_REASONS} from '../view/diagnostic-marks.js';
+
+// The one report shape a diagnostic card may send to the beacon (#335). Every field is an enumerated value, a
+// bounded token or a number; unknown keys and free text (error messages included) are dropped before logging.
+
+export const MAX_VIEW_REPORT_BYTES = 8_192;
+
+const TOKEN = /^[A-Za-z0-9._+-]{1,80}$/;
+const token = z.string().regex(TOKEN);
+const lenientToken = z.string().max(200).transform(value => /^[A-Za-z0-9 ._+-]{1,80}$/.test(value) ? value : 'other');
+
+const reportSchema = z.object({
+  v: z.literal(1),
+  id: z.string().regex(/^[a-z0-9]{8,32}$/),
+  release: token,
+  reason: z.enum(VIEW_REPORT_REASONS),
+  visibility: z.enum(['visible', 'hidden']).optional(),
+  host: lenientToken.optional(),
+  failure: z.enum(['policy', 'connect', 'ready', 'application', 'disposed']).optional(),
+  marks: z.record(z.string(), z.number().finite().nonnegative().max(3_600_000)),
+  errors: z.array(z.object({
+    type: z.enum(['error', 'rejection', 'csp', 'callback']),
+    name: lenientToken.optional(),
+    directive: lenientToken.optional(),
+    blocked: lenientToken.optional(),
+    phase: lenientToken.optional(),
+  })).max(20).optional(),
+});
+
+export type ViewReport = {
+  view: string;
+  viewRelease: string;
+  reason: string;
+  visibility?: string;
+  host?: string;
+  failure?: string;
+  marks: Record<string, number>;
+  errors: Record<string, string>[];
+};
+
+/** The report's loggable fields, or `undefined` when the body is not exactly the report shape. */
+export function parseViewReport(body: string): ViewReport | undefined {
+  let json: unknown;
+  try { json = JSON.parse(body); } catch { return undefined; }
+  const parsed = reportSchema.safeParse(json);
+  if (!parsed.success) return undefined;
+  const report = parsed.data;
+  const marks: Record<string, number> = {};
+  for (const name of VIEW_MARKS) if (report.marks[name] !== undefined) marks[name] = Math.round(report.marks[name]);
+  return {
+    view: report.id,
+    viewRelease: report.release,
+    reason: report.reason,
+    ...(report.visibility === undefined ? {} : {visibility: report.visibility}),
+    ...(report.host === undefined ? {} : {host: report.host}),
+    ...(report.failure === undefined ? {} : {failure: report.failure}),
+    marks,
+    errors: (report.errors ?? []).map(error => Object.fromEntries(Object.entries(error).filter(([, value]) => value !== undefined)) as Record<string, string>),
+  };
+}
+
+/** The sending document's origin as a host name only: which host sandbox the card ran in. */
+export function originHost(origin: string | null): string {
+  if (origin === null) return 'none';
+  if (origin === 'null') return 'null';
+  try { return new URL(origin).hostname || 'other'; } catch { return 'other'; }
+}
diff --git a/apps/mcp/src/view/diagnostic-marks.ts b/apps/mcp/src/view/diagnostic-marks.ts
new file mode 100644
index 00000000..74a7732b
--- /dev/null
+++ b/apps/mcp/src/view/diagnostic-marks.ts
@@ -0,0 +1,17 @@
+/**
+ * Milestones a card records for first-load diagnosis (#335), shared by the card and the server that accepts its reports,
+ * in milliseconds since the card's document started:
+ * - `script`, `main`: the early script ran; the bundle finished evaluating.
+ * - `hostMessage`, `toolInput`, `toolResult`, `toolCancelled`, `teardownRequested`: the host's first JSON-RPC message, its tool
+ *   input, result and cancellation notifications, and its request to tear the card down, as they arrived.
+ * - `fonts`, `context`, `ready`, `failed`: the stack's readiness work, host context delivery (after the handshake
+ *   and fonts), and how starting ended.
+ * - `result`, `problem`: the first answer or problem the chrome rendered.
+ * - `firstPaint`, `firstContentfulPaint`: the browser's paint timings.
+ */
+export const VIEW_MARKS = ['script', 'main', 'hostMessage', 'toolInput', 'toolResult', 'toolCancelled', 'teardownRequested', 'fonts', 'context', 'ready', 'failed', 'result', 'problem', 'firstPaint', 'firstContentfulPaint'] as const;
+export type ViewMark = (typeof VIEW_MARKS)[number];
+
+/** Why a card sent a report. */
+export const VIEW_REPORT_REASONS = ['ready', 'failed', 'result', 'problem', 'pagehide', 'timeout'] as const;
+export type ViewReportReason = (typeof VIEW_REPORT_REASONS)[number];
diff --git a/apps/mcp/src/view/diagnostics.ts b/apps/mcp/src/view/diagnostics.ts
new file mode 100644
index 00000000..2ea0d046
--- /dev/null
+++ b/apps/mcp/src/view/diagnostics.ts
@@ -0,0 +1,94 @@
+import type {CardChromeProps} from '@saga-a2ui/react-mcp-stack/faithful-card';
+import {createElement, useEffect, type ComponentType} from 'react';
+import type {ViewMark, ViewReportReason} from './diagnostic-marks.js';
+
+// First-load diagnosis (#335). The stack's hooks (hostContext, readyWhen, onError, the `ready` promise and the
+// chrome) mark how far this card got; the early script in mcp-app-react.html has already recorded the script
+// start and any error, rejection or content-policy violation before the bundle ran. A report is one tagged
+// console line, and, only when the served card carries a `data-diagnostics` address (Dev), a beacon to it.
+// Reports carry milestones, enumerated failures and error names only: never answer text or error messages.
+
+type EarlyRecord = {id: string; marks: Partial<Record<ViewMark, number>>; errors: Record<string, string>[]};
+declare global {
+  interface Window { __ansariDiag?: EarlyRecord }
+}
+
+const MAX_ERRORS = 20;
+const TIMEOUT_MS = 15_000;
+const early: EarlyRecord = window.__ansariDiag ?? {
+  id: Array.from(crypto.getRandomValues(new Uint8Array(8)), byte => byte.toString(16).padStart(2, '0')).join(''),
+  marks: {},
+  errors: [],
+};
+let hostName: string | undefined;
+let failure: string | undefined;
+let settled = false;
+
+export function mark(name: ViewMark): void {
+  early.marks[name] ??= performance.now();
+}
+
+export function noteHost(name: string | undefined): void {
+  hostName ??= name;
+}
+
+export function noteFailure(kind: string): void {
+  failure = kind;
+}
+
+export function noteCallbackError(error: unknown, phase: string): void {
+  if (early.errors.length < MAX_ERRORS) early.errors.push({type: 'callback', name: error instanceof Error ? error.name : typeof error, phase});
+}
+
+export function report(reason: ViewReportReason): void {
+  for (const entry of performance.getEntriesByType('paint')) {
+    if (entry.name === 'first-paint') early.marks.firstPaint ??= entry.startTime;
+    if (entry.name === 'first-contentful-paint') early.marks.firstContentfulPaint ??= entry.startTime;
+  }
+  const body = JSON.stringify({
+    v: 1,
+    id: early.id,
+    release: document.body.dataset.revision ?? document.body.dataset.release ?? 'unknown',
+    reason,
+    visibility: document.visibilityState === 'hidden' ? 'hidden' : 'visible',
+    ...(hostName === undefined ? {} : {host: hostName}),
+    ...(failure === undefined ? {} : {failure}),
+    marks: early.marks,
+    errors: early.errors,
+  });
+  console.info('[ansari-view]', body);
+  const endpoint = document.body.dataset.diagnostics;
+  if (endpoint === undefined) return;
+  try {
+    if (!navigator.sendBeacon(endpoint, new Blob([body], {type: 'text/plain'}))) {
+      void fetch(endpoint, {method: 'POST', body, mode: 'no-cors', keepalive: true}).catch(() => undefined);
+    }
+  } catch {
+    // Diagnosis never disturbs the card.
+  }
+}
+
+/** Reports once when the card starts or fails, when the page is put away, and if it has not started in time. */
+export function watchStart(ready: Promise<void>, failureKind: (failure: unknown) => string): void {
+  ready.then(
+    () => { settled = true; mark('ready'); report('ready'); },
+    (error: unknown) => { settled = true; noteFailure(failureKind(error)); mark('failed'); report('failed'); },
+  );
+  addEventListener('pagehide', () => report('pagehide'), {once: true});
+  setTimeout(() => { if (!settled) report('timeout'); }, TIMEOUT_MS);
+}
+
+/** The application's chrome, marking the first answer and the first problem it actually rendered. */
+export function observedChrome(Chrome: ComponentType<CardChromeProps>): ComponentType<CardChromeProps> {
+  return function ObservedChrome(props: CardChromeProps) {
+    const kind = props.state.kind;
+    useEffect(() => {
+      if (kind === 'waiting') return;
+      const name = kind === 'answer' ? 'result' : 'problem';
+      if (early.marks[name] !== undefined) return;
+      mark(name);
+      report(name);
+    }, [kind]);
+    return createElement(Chrome, props);
+  };
+}
diff --git a/apps/mcp/src/view/main.tsx b/apps/mcp/src/view/main.tsx
index 03063569..c13421ec 100644
--- a/apps/mcp/src/view/main.tsx
+++ b/apps/mcp/src/view/main.tsx
@@ -1,9 +1,10 @@
 import '@saga-a2ui/react-mcp-stack/faithful-card.css';
 import './theme.css';
-import {FaithfulCardApp, readingProfile, startFaithfulCardApp} from '@saga-a2ui/react-mcp-stack/faithful-card';
+import {FaithfulCardApp, StartFailure, readingProfile, startFaithfulCardApp} from '@saga-a2ui/react-mcp-stack/faithful-card';
 import {APP_VERSION} from '../version.js';
 import {AnswerView} from './answer-view.js';
 import {BRANDING} from './branding.js';
+import {mark, noteCallbackError, noteHost, observedChrome, watchStart} from './diagnostics.js';
 import {CARD_MAX_UTF16_UNITS} from './envelope.js';
 import {installFloralArtwork} from './floral-artwork.js';
 import {loadKitab} from './fonts.js';
@@ -17,6 +18,8 @@ import {classifyCardResult} from './tool-result.js';
 // receives the whole delivery-neutral result (a failed call, text-only delivery and a malformed
 // envelope included), so nothing is intercepted before it.
 
+mark('main');
+
 const definition = FaithfulCardApp.define({name: BRANDING.name, version: APP_VERSION})
   .reader({dialect: 'commonmark-tables-strikethrough', maxLength: CARD_MAX_UTF16_UNITS})
   .policy('document')
@@ -36,11 +39,18 @@ installFloralArtwork(root);
 const container = document.getElementById('root');
 if (container === null) throw new Error('The page has no #root element.');
 
-startFaithfulCardApp(definition, {
+// Each hook also marks how far the card got (diagnostics.ts, #335); none of them changes what is shown.
+const running = startFaithfulCardApp(definition, {
   container,
   sizing: 'own',
   // Do not present an answer using a substituted device font if the embedded fonts fail.
-  readyWhen: signal => loadKitab(document, signal),
-  hostContext: (context, hostName) => { applyHostTheme(root, context, hostName, readingProfile(context, hostName)); },
-  chrome: AnswerView,
+  readyWhen: signal => loadKitab(document, signal).then(() => mark('fonts')),
+  hostContext: (context, hostName) => {
+    mark('context');
+    noteHost(hostName);
+    applyHostTheme(root, context, hostName, readingProfile(context, hostName));
+  },
+  chrome: observedChrome(AnswerView),
+  onError: (error, phase) => { noteCallbackError(error, phase); console.error(error); },
 });
+watchStart(running.ready, failure => failure instanceof StartFailure ? failure.kind : 'application');
diff --git a/apps/mcp/src/view/mcp-app-react.html b/apps/mcp/src/view/mcp-app-react.html
index 8a5cee35..b1899aa5 100644
--- a/apps/mcp/src/view/mcp-app-react.html
+++ b/apps/mcp/src/view/mcp-app-react.html
@@ -2,6 +2,37 @@
 <html lang="en">
   <head>
     <meta charset="UTF-8" />
+    <script>
+      // First-load diagnosis (#335): runs before the card's bundle is parsed, so a failure before it starts is still
+      // recorded. Names and kinds only; src/view/diagnostics.ts reports what this collects.
+      (function () {
+        var bytes = crypto.getRandomValues(new Uint8Array(8));
+        var id = Array.prototype.map.call(bytes, function (b) { return (b + 256).toString(16).slice(1); }).join('');
+        var record = window.__ansariDiag = {id: id, marks: {script: performance.now()}, errors: []};
+        var token = function (value) { return typeof value === 'string' && value ? value.slice(0, 80) : undefined; };
+        var push = function (entry) { if (record.errors.length < 20) record.errors.push(entry); };
+        addEventListener('error', function (event) {
+          var target = event.target && event.target !== window ? event.target.tagName : undefined;
+          push({type: 'error', name: token(event.error && event.error.name) || (target ? 'resource-' + target : 'Error')});
+        }, true);
+        addEventListener('unhandledrejection', function (event) {
+          push({type: 'rejection', name: token(event.reason && event.reason.name) || typeof event.reason});
+        });
+        // When the host's messages arrive, by method name only: the handshake reply, the tool input and result, teardown.
+        var arrivals = {'ui/notifications/tool-input': 'toolInput', 'ui/notifications/tool-result': 'toolResult', 'ui/notifications/tool-cancelled': 'toolCancelled', 'ui/resource-teardown': 'teardownRequested'};
+        addEventListener('message', function (event) {
+          var data = event.data;
+          if (event.source !== window.parent || !data || data.jsonrpc !== '2.0') return;
+          var now = performance.now();
+          if (record.marks.hostMessage === undefined) record.marks.hostMessage = now;
+          var name = arrivals[data.method];
+          if (name && record.marks[name] === undefined) record.marks[name] = now;
+        });
+        addEventListener('securitypolicyviolation', function (event) {
+          push({type: 'csp', directive: token(event.effectiveDirective), blocked: token(String(event.blockedURI).split(':')[0])});
+        });
+      })();
+    </script>
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <!--
       No Content-Security-Policy here: the build derives it from the application's content policy and
diff --git a/apps/mcp/src/worker/index.ts b/apps/mcp/src/worker/index.ts
index 50fa8b84..ce9c15df 100644
--- a/apps/mcp/src/worker/index.ts
+++ b/apps/mcp/src/worker/index.ts
@@ -18,6 +18,7 @@ function applicationFor(env: RuntimeEnv): FetchApp {
     allowedHosts: settings.allowedHosts,
     allowedOrigins: settings.allowedOrigins,
     enableJsonResponse: settings.enableJsonResponse,
+    viewDiagnosticsOrigin: settings.viewDiagnosticsOrigin,
     logger: record => console.log(JSON.stringify(record)),
   });
   return app;
diff --git a/apps/mcp/test/browser.ts b/apps/mcp/test/browser.ts
index 77f0a379..bd0928ef 100644
--- a/apps/mcp/test/browser.ts
+++ b/apps/mcp/test/browser.ts
@@ -10,7 +10,8 @@ import {chromium, type Frame, type Page} from '@playwright/test';
 import {build, preview} from 'vite';
 import {createHttpServer as createBaseHttpServer} from '../src/node/http-server.ts';
 import {stampHtmlRevision} from '../src/server/operation-log.ts';
-import {VIEW_FILENAME} from '../src/server/view-artifact.ts';
+import {VIEW_DIAGNOSTICS_PATH, VIEW_FILENAME, prepareAnswerView} from '../src/server/view-artifact.ts';
+import {parseViewReport} from '../src/server/view-report.ts';
 import {ANSWER_A, ANSWER_B, ANSWER_C, ANSWER_HOSTILE, ATTRIBUTION_CASES, QUESTION_A, QUESTION_B} from './react-answers.ts';
 
 const root = new URL('./', import.meta.url).pathname;
@@ -30,8 +31,9 @@ const ports: number[] = [];
 const evidence: Record<string, unknown> = {};
 const check = (name: string, f: () => void) => { f(); checks.push({name, pass: true}); if (process.env.REACT_BROWSER_TRACE) console.error('ok', name); };
 
-let browser: any, host: any, child: any, service: any, mcpClient: Client | undefined;
+let browser: any, host: any, child: any, beacon: any, service: any, mcpClient: Client | undefined;
 const served = new Map<string, string>();
+const beacons: string[] = [];
 const requests: {url: string; from: string}[] = [];
 
 async function main() {
@@ -46,6 +48,16 @@ async function main() {
   });
   await new Promise<void>(r => child.listen(0, '127.0.0.1', r));
   ports.push(child.address().port);
+  // The Dev diagnostics beacon (#335): records each report body exactly as the card sent it.
+  beacon = http.createServer((req, res) => {
+    let body = '';
+    req.setEncoding('utf8');
+    req.on('data', chunk => body += chunk);
+    req.on('end', () => { if (req.method === 'POST' && req.url === VIEW_DIAGNOSTICS_PATH) beacons.push(body); res.writeHead(204, {'access-control-allow-origin': '*'}).end(); });
+  });
+  await new Promise<void>(r => beacon.listen(0, '127.0.0.1', r));
+  const diagnosticsOrigin = `http://127.0.0.1:${beacon.address().port}`;
+  ports.push(beacon.address().port);
 
   const logs: any[] = [];
   service = createBaseHttpServer({
@@ -94,7 +106,7 @@ async function main() {
   page.on('pageerror', e => errors.push(String(e)));
   page.on('console', m => { if (m.type() === 'error') errors.push(`console: ${m.text()}`); });
   // Runtime networking is unavailable to the view: only the host fixture and the view document are reachable.
-  const allowedOrigins = () => [`http://127.0.0.1:${ports[0]}`, `http://127.0.0.1:${ports[1]}`];
+  const allowedOrigins = () => [`http://127.0.0.1:${ports[0]}`, `http://127.0.0.1:${ports[1]}`, diagnosticsOrigin];
   await context.route('**/*', (route: any) => {
     const url = route.request().url();
     const frame = route.request().frame();
@@ -799,6 +811,32 @@ async function main() {
     assert.equal(opensAfter, opensBefore);
   });
 
+  // ---- First-load diagnosis: a Dev card reports how far it got, in a shape the server accepts --------
+  // Every card above made no request (network check). Only a card served with a diagnostics origin sends reports.
+  assert.deepEqual(beacons, [], 'a production card sends no diagnostics');
+  const diagnostic = await openView(760, 900, prepareAnswerView(html, undefined, diagnosticsOrigin).html);
+  await deliver(diagnostic.id, resultA);
+  await diagnostic.frame.locator('[data-testid="answer-card"]').waitFor();
+  for (let waited = 0; beacons.length < 2 && waited < 3000; waited += 50) await new Promise(r => setTimeout(r, 50));
+  const reports = beacons.map(parseViewReport);
+  const lastReport = reports.at(-1);
+  check('diagnostics:dev-card-reports-ready-and-result-accepted-by-the-server', () => {
+    assert.ok(reports.length >= 2 && reports.every(r => r !== undefined), 'every report is exactly the accepted shape');
+    assert.deepEqual(reports.map(r => r!.reason), ['ready', 'result']);
+    assert.equal(new Set(reports.map(r => r!.view)).size, 1, 'one card, one id');
+    // The one known violation: zod's capability probe (`try { new Function('') } catch`) under the card's script-src,
+    // which has no 'unsafe-eval'. It is caught and harmless; any other error, rejection or violation fails here.
+    assert.deepEqual(lastReport!.errors, [{type: 'csp', directive: 'script-src', blocked: 'eval'}]);
+  });
+  check('diagnostics:milestones-are-recorded-in-start-order', () => {
+    const m = lastReport!.marks;
+    for (const name of ['script', 'main', 'hostMessage', 'fonts', 'context', 'ready', 'toolResult', 'result']) assert.equal(typeof m[name], 'number', name);
+    assert.ok(m.script! <= m.main! && m.main! <= m.hostMessage! && m.hostMessage! <= m.context! && m.fonts! <= m.ready! && m.context! <= m.ready!);
+    assert.ok(m.ready! <= m.result! && m.toolResult! <= m.result!);
+  });
+  check('diagnostics:reports-carry-no-answer-text', () => assert.ok(!beacons.join('').includes(ANSWER_A.slice(0, 40))));
+  evidence.diagnostics = lastReport;
+
   const states = await page.evaluate(() => Array.from(document.querySelectorAll('iframe')).map(f => (window as any).hostProbe.state(f.id)));
   check('host:no-view-initiated-tool-calls-and-no-host-errors', () => {
     for (const s of states) { assert.equal(s.answerCalls, 0); assert.deepEqual(s.hostErrors, []); }
@@ -822,6 +860,7 @@ try {
   if (service) { service.server.closeAllConnections?.(); await bounded(service.close?.()); }
   if (host) await bounded(new Promise<void>(r => (host.httpServer.closeAllConnections(), host.httpServer.close(() => r()))));
   if (child) await bounded(new Promise<void>(r => (child.closeAllConnections(), child.close(() => r()))));
+  if (beacon) await bounded(new Promise<void>(r => (beacon.closeAllConnections(), beacon.close(() => r()))));
   fs.writeFileSync(`${out}/react-results.json`, JSON.stringify({checks, errors, ports, evidence, failed: failure === undefined ? undefined : String(failure), scope: 'built from packed SAGA packages; real MCP server and connection; sandboxed iframe in a local AppBridge fixture; local Chromium; not actual-host evidence'}, null, 2) + '\n');
 }
 if (failure !== undefined) process.exit(1);
diff --git a/apps/mcp/test/diagnostics.test.ts b/apps/mcp/test/diagnostics.test.ts
new file mode 100644
index 00000000..dd423ffc
--- /dev/null
+++ b/apps/mcp/test/diagnostics.test.ts
@@ -0,0 +1,152 @@
+import assert from 'node:assert/strict';
+import {test} from 'node:test';
+import {createFetchApp} from '../src/server/fetch-app.ts';
+import type {OperationRecord} from '../src/server/operation-log.ts';
+import {settingsFromEnv} from '../src/server/runtime-config.ts';
+import {VIEW_DIAGNOSTICS_PATH, prepareAnswerView} from '../src/server/view-artifact.ts';
+
+// First-load diagnosis (#335): what the server and the card record, and the Dev-only beacon channel.
+const CSP = `<meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'unsafe-inline'; connect-src 'none'; frame-src 'none'">`;
+const html = `<html><head>${CSP}</head><body data-release="0">synthetic card ${'x'.repeat(4096)}</body></html>`;
+const QUESTION = 'PRIVATE_QUESTION_CANARY';
+const ANSWER = 'PRIVATE_ANSWER_CANARY';
+const STALE = 'ui://views/answer-card.a0cf6be6ed3f0fc75f083280d39ee589.html';
+const ORIGIN = 'https://dev.example';
+
+function harness(env: Record<string, string> = {}, complete: () => Promise<string> = async () => ANSWER) {
+  const logs: OperationRecord[] = [];
+  const app = createFetchApp({...settingsFromEnv(env), html, logger: record => logs.push(record), completer: {complete}});
+  let id = 0;
+  const rpc = (method: string, params: Record<string, unknown> = {}) => app.fetch(new Request('http://localhost/mcp', {
+    method: 'POST',
+    headers: {host: 'localhost', 'content-type': 'application/json', accept: 'application/json, text/event-stream', 'mcp-protocol-version': '2025-11-25'},
+    body: JSON.stringify({jsonrpc: '2.0', id: ++id, method, params}),
+  }));
+  const beacon = (body: string, headers: Record<string, string> = {}) => app.fetch(new Request(`http://localhost${VIEW_DIAGNOSTICS_PATH}`, {
+    method: 'POST', headers: {host: 'localhost', 'content-type': 'text/plain', origin: 'https://sandbox.host.example', ...headers}, body,
+  }));
+  return {app, logs, rpc, beacon};
+}
+
+const settled = async (response: Response) => { await response.text(); await new Promise(resolve => setTimeout(resolve, 0)); };
+const byRid = (logs: OperationRecord[], event: string, rpc: string) => logs.filter(r => r.event === event && r.rpc === rpc);
+
+test('each MCP exchange records its method, card address, outcome, size and timing without content', async () => {
+  const {app, logs, rpc} = harness();
+  try {
+    const listed = await rpc('tools/list');
+    const uri = (JSON.parse((await listed.text()).replace(/^[\s\S]*?data: /, '')) as {result: {tools: {_meta: {ui: {resourceUri: string}}}[]}}).result.tools[0]._meta.ui.resourceUri;
+    await settled(await rpc('initialize', {protocolVersion: '2025-06-18', capabilities: {}, clientInfo: {name: 'probe-host', version: '9.1'}}));
+    await settled(await rpc('resources/read', {uri}));
+    await settled(await rpc('resources/read', {uri: STALE}));
+    await settled(await rpc('tools/call', {name: 'answer_islamic_question', arguments: {question: QUESTION}}));
+
+    const [current, stale] = byRid(logs, 'mcp.request', 'resources/read');
+    assert.equal(current.uri, uri);
+    assert.equal(current.uriCurrent, true);
+    assert.equal(stale.uri, STALE);
+    assert.equal(stale.uriCurrent, false, 'a card address from an earlier deploy is visible as such');
+    const initialize = byRid(logs, 'mcp.request', 'initialize')[0];
+    assert.equal(initialize.client, 'probe-host');
+    assert.equal(initialize.clientVersion, '9.1');
+    assert.equal(initialize.protocol, '2025-06-18');
+    assert.equal(byRid(logs, 'mcp.request', 'tools/call')[0].tool, 'answer_islamic_question');
+
+    const [read, missing] = byRid(logs, 'mcp.response', 'resources/read');
+    assert.equal(read.rid, current.rid, 'request and response lines share one id');
+    assert.equal(read.status, 200);
+    assert.equal(read.outcome, 'complete');
+    assert.equal(read.errorCode, undefined);
+    assert.ok((read.bytes as number) > html.length, 'the card read reports the bytes actually sent');
+    assert.equal(typeof read.ms, 'number');
+    assert.equal(typeof read.headersMs, 'number');
+    assert.equal(missing.errorCode, -32602, 'a stale card read is a JSON-RPC error inside an HTTP 200');
+    for (const record of logs.filter(r => r.event === 'mcp.request')) assert.equal(record.method, 'POST', 'the request line keeps the HTTP verb in `method`');
+    const serialized = JSON.stringify(logs);
+    assert.ok(!serialized.includes(QUESTION) && !serialized.includes(ANSWER), 'no question or answer text is logged');
+  } finally { await app.close(); }
+});
+
+test('a client that hangs up mid-response is recorded as cancelled', async () => {
+  let release!: () => void;
+  const {app, logs, rpc} = harness({}, () => new Promise(resolve => { release = () => resolve(ANSWER); }));
+  try {
+    const response = await rpc('tools/call', {name: 'answer_islamic_question', arguments: {question: QUESTION}});
+    assert.equal(response.headers.get('content-type')?.startsWith('text/event-stream'), true);
+    await response.body!.cancel();
+    release();
+    for (let waited = 0; !byRid(logs, 'mcp.response', 'tools/call').length && waited < 1000; waited += 10) await new Promise(r => setTimeout(r, 10));
+    assert.equal(byRid(logs, 'mcp.response', 'tools/call')[0]?.outcome, 'cancelled');
+  } finally { await app.close(); }
+});
+
+test('handler errors are logged by name and code only', async () => {
+  const {app, logs} = harness();
+  try {
+    const response = await app.fetch(new Request('http://localhost/mcp', {
+      method: 'POST', headers: {host: 'localhost', 'content-type': 'application/json', accept: 'application/json, text/event-stream'}, body: '{not json',
+    }));
+    await response.text();
+    const request = logs.find(r => r.event === 'mcp.request')!;
+    assert.equal(request.rpc, 'unparsed');
+    const response_ = logs.find(r => r.event === 'mcp.response')!;
+    assert.equal((response_.status as number) >= 400 || typeof response_.errorCode === 'number', true);
+  } finally { await app.close(); }
+});
+
+test('without a diagnostics origin the card, its address and its permissions are unchanged', async () => {
+  assert.equal(settingsFromEnv({}).viewDiagnosticsOrigin, undefined);
+  const plain = prepareAnswerView(html, 'r1');
+  assert.deepEqual(prepareAnswerView(html, 'r1', undefined), plain);
+  assert.ok(!plain.html.includes('data-diagnostics'));
+  assert.ok(plain.html.includes("connect-src 'none'"));
+  assert.deepEqual(plain.csp.connectDomains, []);
+  const {app, beacon} = harness();
+  try { assert.equal((await beacon('{}')).status, 404, 'no beacon route unless diagnostics are configured'); } finally { await app.close(); }
+});
+
+test('a diagnostics origin opens exactly one connect origin and stamps the beacon address', () => {
+  const settings = settingsFromEnv({MCP_VIEW_DIAGNOSTICS_ORIGIN: `${ORIGIN}/`});
+  assert.equal(settings.viewDiagnosticsOrigin, ORIGIN);
+  const view = prepareAnswerView(html, 'r1', ORIGIN);
+  assert.ok(view.html.includes(`data-diagnostics="${ORIGIN}${VIEW_DIAGNOSTICS_PATH}"`));
+  assert.ok(view.html.includes(`connect-src ${ORIGIN};`));
+  assert.ok(!view.html.includes("connect-src 'none'"));
+  assert.deepEqual(view.csp.connectDomains, [ORIGIN]);
+  assert.notEqual(view.uri, prepareAnswerView(html, 'r1').uri, 'a diagnostic card has its own address');
+  for (const bad of ['http://dev.example', 'https://dev.example/path', 'https://user@dev.example', 'not a url', 'https://dev.example?x=1']) {
+    assert.throws(() => settingsFromEnv({MCP_VIEW_DIAGNOSTICS_ORIGIN: bad}), /MCP_VIEW_DIAGNOSTICS_ORIGIN/, bad);
+  }
+  assert.equal(settingsFromEnv({MCP_VIEW_DIAGNOSTICS_ORIGIN: 'http://127.0.0.1:8080'}).viewDiagnosticsOrigin, 'http://127.0.0.1:8080');
+  assert.throws(() => prepareAnswerView('<html><body></body></html>', 'r1', ORIGIN), /connect-src/, 'a card without the closed connect rule fails loudly');
+});
+
+test('the beacon accepts only the fixed report shape and logs it without free text', async () => {
+  const {app, logs, beacon} = harness({MCP_VIEW_DIAGNOSTICS_ORIGIN: ORIGIN});
+  try {
+    const report = {
+      v: 1, id: 'abc123def456', release: 'r1', reason: 'pagehide', visibility: 'hidden', host: 'Claude',
+      marks: {script: 12.4, main: 410.9, context: 980.2, fonts: 1300.1, unknownMark: 5},
+      errors: [{type: 'csp', directive: 'connect-src', blocked: 'https'}, {type: 'error', name: 'TypeError', message: ANSWER}],
+      failure: 'connect', extra: ANSWER,
+    };
+    const accepted = await beacon(JSON.stringify(report));
+    assert.equal(accepted.status, 204);
+    assert.equal(accepted.headers.get('access-control-allow-origin'), '*');
+    const logged = logs.find(r => r.event === 'view.report')!;
+    assert.equal(logged.view, 'abc123def456');
+    assert.equal(logged.reason, 'pagehide');
+    assert.equal(logged.failure, 'connect');
+    assert.equal(logged.host, 'Claude');
+    assert.equal(logged.origin, 'sandbox.host.example');
+    assert.deepEqual(logged.marks, {script: 12, main: 411, fonts: 1300, context: 980});
+    assert.deepEqual(logged.errors, [{type: 'csp', directive: 'connect-src', blocked: 'https'}, {type: 'error', name: 'TypeError'}]);
+    assert.ok(!JSON.stringify(logs).includes(ANSWER), 'free text in a report is never logged');
+
+    for (const bad of ['not json', JSON.stringify({...report, v: 2}), JSON.stringify({...report, id: 'has space'}), JSON.stringify({...report, reason: 'other'})]) {
+      assert.equal((await beacon(bad)).status, 400, bad);
+    }
+    assert.equal((await beacon('x'.repeat(9000))).status, 413);
+    assert.equal(logs.filter(r => r.event === 'view.report.invalid').length, 5);
+  } finally { await app.close(); }
+});
diff --git a/apps/mcp/turbo.json b/apps/mcp/turbo.json
index 226eadc1..e6b02119 100644
--- a/apps/mcp/turbo.json
+++ b/apps/mcp/turbo.json
@@ -33,6 +33,7 @@
         "MCP_ALLOWED_HOSTS",
         "MCP_ALLOWED_ORIGINS",
         "MCP_RESPONSE_MODE",
+        "MCP_VIEW_DIAGNOSTICS_ORIGIN",
         "ANSARI_RELEASE",
         "RAILWAY_GIT_COMMIT_SHA"
       ],
@@ -48,6 +49,7 @@
         "MCP_ALLOWED_HOSTS",
         "MCP_ALLOWED_ORIGINS",
         "MCP_RESPONSE_MODE",
+        "MCP_VIEW_DIAGNOSTICS_ORIGIN",
         "ANSARI_RELEASE",
         "RAILWAY_GIT_COMMIT_SHA"
       ],

From bc62edf272e7eed6f763a11275ffd92ddd34c321 Mon Sep 17 00:00:00 2001
From: Younes Abouelnagah <timeleft--@users.noreply.github.com>
Date: Thu, 29 Oct 2026 18:38:27 -0400
Subject: [PATCH 2/4] fix(mcp): bound and narrow the first-load diagnostics

Corrects measurement defects in the first-load instrumentation and scopes
it as a bounded experiment for #335.

- Request inspection reads a tee of the request alongside the handler, up
  to 64 KiB actually read, so a missing or wrong Content-Length can no
  longer make it read or wait for the whole body. The beacon reads at most
  8 KiB the same way and accepts 120 reports a minute per instance.
- JSON-RPC errors are decoded from JSON and SSE bodies up to 64 KiB rather
  than matched by pattern. The stream outcome is `drained`, `cancelled` or
  `failed` on this side; it does not claim delivery to the host.
- Card diagnostics run only in a diagnostic card. The early script reads an
  `ansari-diagnostics` head address and reports by itself at load, pagehide
  and timeout, so a bundle that never runs is still reported. The closed
  card's early script does nothing and writes no console line.
- `view.prepared` records the served card's address, size, diagnostic state
  and connect origins; reports are logged as client-authored.
- Trials record the deployment release and the first attempt and Retry as
  separate windows. The timeline flags mixed clients, overlapping trials
  and other releases as ambiguous, and words findings as observations.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 apps/mcp/README.md                       |  77 ++++++++-------
 apps/mcp/scripts/first-load-timeline.mjs |  64 +++++++++----
 apps/mcp/scripts/first-load-trial.sh     |  45 ++++++---
 apps/mcp/src/server/exchange-log.ts      | 116 ++++++++++++++++++-----
 apps/mcp/src/server/fetch-app.ts         |  44 +++++----
 apps/mcp/src/server/view-artifact.ts     |  10 +-
 apps/mcp/src/server/view-report.ts       |   5 +-
 apps/mcp/src/view/diagnostic-marks.ts    |   2 +-
 apps/mcp/src/view/diagnostics.ts         |  99 ++++++++-----------
 apps/mcp/src/view/mcp-app-react.html     |  40 ++++++--
 apps/mcp/test/browser.ts                 |  45 ++++++---
 apps/mcp/test/diagnostics.test.ts        |  79 +++++++++++++--
 12 files changed, 429 insertions(+), 197 deletions(-)

diff --git a/apps/mcp/README.md b/apps/mcp/README.md
index a1b7291e..314be6e2 100644
--- a/apps/mcp/README.md
+++ b/apps/mcp/README.md
@@ -95,7 +95,7 @@ The Worker takes the variables in the table below as Wrangler `vars` or secrets,
 | `MCP_ALLOWED_ORIGINS` | Comma-separated allowed browser origin hostnames. A configured list replaces defaults; an explicitly empty list permits no Origin header value. Requests without Origin remain supported. |
 | `MCP_RESPONSE_MODE` | `json` for modern MCP final-answer-only responses; otherwise SSE, which supports client-requested progress notifications. Older-host compatibility responses may use SSE. |
 | `ANSARI_RELEASE` | Optional safe release identifier, embedded in served HTML and health/log records. |
-| `MCP_VIEW_DIAGNOSTICS_ORIGIN` | Set only on a deployment being diagnosed: its own public origin, such as `https://ansari-mcp-development.up.railway.app`. The card may then connect to that one origin and reports its start-up milestones to `POST /diag/view`; this changes the card's bytes and so its address. Unset, the card, its address and its closed permissions are unchanged and the route does not exist. A value that is not a bare `https` origin (`http` only for localhost) stops startup. See [First-load diagnosis](#first-load-diagnosis). |
+| `MCP_VIEW_DIAGNOSTICS_ORIGIN` | Set only on a deployment being diagnosed: its own public origin, such as `https://ansari-mcp-development.up.railway.app`. The card may then connect to that one origin and reports its start-up milestones to `POST /diag/view`; this changes the card's bytes, address and permissions. Unset, the card, its address and its closed permissions are unchanged and the route does not exist. A value that is not a bare `https` origin (`http` only for localhost) stops startup. See [First-load diagnosis](#first-load-diagnosis). |
 
 `POST /mcp` serves stateless MCP requests through Hono and the official MCP request handler. Modern requests need no initialization; older hosts can use the handler’s stateless compatibility path. No MCP session IDs, session map, expiry timer or replay store are retained. `GET /mcp` and `DELETE /mcp` return 405. `/health` exposes the release. The HTML is supplied by the hosting target (read from `dist/` at Node start, bundled into the Worker), revision-stamped and fingerprinted once before the first request is served: the release is stamped first, so equal final bytes have equal identities and a release change legitimately changes the hash. Each request creates its own lightweight MCP server using that prepared view; resource bytes and identity stay fixed until restart. No demo, font server, alternative renderer or historical resource is served. Tool calls have a fresh 60-second budget; timeout yields a safe error and leaves subsequent calls usable. The same lifetime signal aborts the upstream fetch and response-body read when the request ends or the budget expires.
 
@@ -103,45 +103,56 @@ Closing a request server releases its budget even if it was never connected to a
 
 ## First-load diagnosis
 
-Issue #335: in Claude web and ChatGPT web the host's own error replaced the card on first load, and one Retry
-recovered it. The card's own failure texts never appeared, so the host gave up before the card showed anything. These
-records tell the possible causes apart.
-
-**Server, always on.** Each `/mcp` exchange writes an `mcp.request` line when it arrives and an `mcp.response` line
-when it ends, joined by `rid`. The request line names the JSON-RPC method; for a card read, the address read and
-whether it is the one served now (`uriCurrent`); for the opening handshake, the client's name, version and protocol;
-for a tool call, the tool name. The response line has the HTTP status, any JSON-RPC error code (a stale card read is
-error `-32602` inside an HTTP 200), bytes sent, time to headers and total time, and whether the response was
-`complete`, `cancelled` by the client or `failed`. Handler errors are logged by name and code. No question, answer or
-other parameter value is logged.
-
-**Card, always on.** A small script runs before the bundle and records when it started, any error, unhandled
-rejection or content-policy violation, and when the host's messages arrive (first message, tool input, tool result,
-cancellation, teardown request), by method name only. The stack's hooks add when fonts loaded, when the host context
-was delivered, how starting ended and when the first answer or problem was rendered. The card writes each report as an
-`[ansari-view]` console line in its frame. One violation is expected on every load: zod's `new Function('')`
-capability probe under the card's `script-src`, which it catches.
-
-**Card beacon, diagnosed deployment only.** With `MCP_VIEW_DIAGNOSTICS_ORIGIN` set, the card also sends each report
-to `POST /diag/view` when it starts or fails, renders its first answer or problem, is put away, or has not started
-after 15 seconds. The server accepts only the fixed report shape (milestones, enumerated failures, error names) and
-logs it as `view.report`, with the host sandbox's origin name.
-
-**Trials.** Run one trial per new conversation, with the deployment live for hours (`aged`) and right after a
-redeploy (`fresh`):
+A bounded experiment for issue #335, not a permanent observability design. In Claude web and ChatGPT web the host's
+own error replaced the card on first load and one Retry recovered it; the card's own failure texts never appeared, so
+the host gave up before the card showed anything. The aim is to locate the first missing step between the card read,
+the card's start, the host handshake, tool-result arrival and the first rendered answer, where that step can be
+observed at all. After the trials, this is removed or narrowed to what proved useful.
+
+**Server records, always on.** Each `/mcp` exchange writes `mcp.request` and `mcp.response` lines joined by `rid`. The
+request is inspected from a copy, alongside the handler and up to 64 KiB actually read, so inspection never holds up
+or alters the exchange; a larger body is recorded as `oversize`. The request line names the JSON-RPC method; for a card
+read, the address read and whether it is the one this instance serves (`uriCurrent`); for the handshake, the client's
+name, version and protocol; for a tool call, the tool name. The response line has the HTTP status, bytes, time to
+headers and total time, and `stream`: whether this side's response stream was `drained`, `cancelled` or `failed`. That
+is not proof the host received or rendered it. Responses up to 64 KiB are decoded as JSON-RPC for an error code; a
+stale card read is `-32602` inside an HTTP 200. At start, `view.prepared` records the served card's address, size,
+whether it is a diagnostic card and its connect origins. Handler errors are logged by name and code. These records hold
+no question, answer or other parameter value.
+
+**Card reports, diagnostic card only.** With `MCP_VIEW_DIAGNOSTICS_ORIGIN` set, the served card carries an
+`ansari-diagnostics` address in its head, may connect to that one origin, and changes bytes, address and permissions.
+Compare its trials with the closed card's rather than assuming they behave the same. An early script, which runs
+before the bundle is parsed, records errors, unhandled rejections, content-policy violations and when the host's
+messages arrive (first message, tool input, tool result, cancellation, teardown request), by method name only. The
+stack's hooks add font loading, host-context delivery, how starting ended and the first rendered answer or problem. The
+early script reports by itself at `load`, at `pagehide` and after 15 s without a start, so a bundle that never runs is
+still reported; the bundle adds reports when the card is ready, fails, or renders its first answer or problem. Each
+report is an `[ansari-view]` console line and a beacon to `POST /diag/view`. The route accepts only the fixed report
+shape, at most 8 KiB and 120 reports a minute per instance, and logs `view.report` with `clientAuthored: true`: the
+shape limits what is logged, but anyone who can reach the route can send a report. Report fields are milestones,
+enumerated failures and error names; the stack still prints a callback's own error to the console, as before. One
+violation is expected on every load: zod's `new Function('')` capability probe under the card's `script-src`, which it
+catches. The closed card's early script does nothing.
+
+**Trials.** Use the deployment for nothing else while a trial runs. Run one trial per new conversation, with the
+deployment live for hours (`aged`) and right after a redeploy (`fresh`), and with the diagnostic and the closed card.
+The trial script records the deployment's release and the first attempt and Retry as separate windows:
 
 ```sh
-bash scripts/first-load-trial.sh claude aged
-bash scripts/first-load-trial.sh chatgpt fresh
-# Railway: deployment and edge HTTP logs for the trial window, then one timeline per trial.
+bash scripts/first-load-trial.sh https://ansari-mcp-development.up.railway.app claude aged diagnostic
+# Railway: deployment and edge HTTP logs covering the trials, then one timeline per trial.
 railway logs --deployment --json --since 1h > test-results/first-load/app.jsonl
 railway logs --http --json --since 1h > test-results/first-load/edge.jsonl
 node scripts/first-load-timeline.mjs test-results/first-load/trials.jsonl test-results/first-load/app.jsonl test-results/first-load/edge.jsonl
 ```
 
-The timeline flags a card read that never reached the server, a card address that is not the current deploy's, a card
-read that was cancelled or slow, a card whose host asked to tear it down before it was ready, a card that never heard
-from the host, and a slow start.
+Records are attributed to an attempt by time only; neither `rid` nor a card's id links to the host's attempt. The
+timeline lists what was observed in each window and flags windows with more than one MCP client, overlapping trials or
+another release as ambiguous. A finding such as "no host message observed by its last report" says only that. Two
+controlled cases have known answers: a stale card read (`resources/read` of an earlier address, answered `-32602`) and
+a bundle that fails before it runs (covered by the browser checks: a `load` report without `main` and with the
+`SyntaxError`).
 
 ## Workspace and container
 
diff --git a/apps/mcp/scripts/first-load-timeline.mjs b/apps/mcp/scripts/first-load-timeline.mjs
index dd26939f..cd28070a 100644
--- a/apps/mcp/scripts/first-load-timeline.mjs
+++ b/apps/mcp/scripts/first-load-timeline.mjs
@@ -5,6 +5,10 @@
 // Each log file holds JSON lines in any of three forms: the application's own records (`event`, with `at`),
 // Railway deployment logs (`railway logs --deployment --json`: `timestamp` and the record in `message`), or Railway
 // edge HTTP logs (`railway logs --http --json`: `timestamp`, path, status, duration and bytes).
+//
+// Records are attributed to a trial by time only: neither a server `rid` nor a card id links to the host's attempt.
+// The timeline therefore says what was observed in each window, flags windows whose traffic may not be the trial's,
+// and never claims that something did not happen anywhere.
 import {readFileSync} from 'node:fs';
 
 const [trialsFile, ...logFiles] = process.argv.slice(2);
@@ -15,7 +19,8 @@ if (!trialsFile || logFiles.length === 0) {
 const lines = file => readFileSync(file, 'utf8').split('\n').filter(line => line.trim()).flatMap(line => {
   try { return [JSON.parse(line)]; } catch { return []; }
 });
-const MARGIN_MS = 5_000;
+/** Records before the first window's start that still belong to it (discovery right before sending). */
+const LEAD_MS = 2_000;
 
 /** One normalized entry: when, what kind, and the fields worth printing. */
 function normalize(raw) {
@@ -29,14 +34,15 @@ function normalize(raw) {
   return undefined;
 }
 const entries = logFiles.flatMap(lines).map(normalize).filter(entry => entry && typeof entry.at === 'number').sort((a, b) => a.at - b.at);
-const diagnosticsSeen = entries.some(entry => entry.event === 'view.report');
+const trials = lines(trialsFile);
 
 function describe(entry, zero) {
   const t = `+${((entry.at - zero) / 1000).toFixed(2)}s`.padStart(9);
   switch (entry.event) {
     case 'mcp.request': return `${t} → ${entry.rpc}${entry.uri ? ` ${entry.uri}${entry.uriCurrent === false ? ' (NOT CURRENT)' : ''}` : ''}${entry.client ? ` client=${entry.client}/${entry.clientVersion}` : ''} [${entry.rid}]`;
-    case 'mcp.response': return `${t} ← ${entry.rpc} ${entry.status} ${entry.outcome} ${entry.bytes}B headers=${entry.headersMs}ms total=${entry.ms}ms${entry.errorCode === undefined ? '' : ` error=${entry.errorCode}`} [${entry.rid}]`;
+    case 'mcp.response': return `${t} ← ${entry.rpc} ${entry.status} stream=${entry.stream} ${entry.bytes}B headers=${entry.headersMs}ms total=${entry.ms}ms${entry.errorCode === undefined ? '' : ` error=${entry.errorCode}`} [${entry.rid}]`;
     case 'view.report': return `${t} ◆ card ${entry.view} ${entry.reason}${entry.failure ? ` failure=${entry.failure}` : ''} host=${entry.host ?? '?'} origin=${entry.origin} marks=${JSON.stringify(entry.marks)}${entry.errors?.length ? ` errors=${JSON.stringify(entry.errors)}` : ''}`;
+    case 'view.prepared': return `${t} ◇ serving ${entry.uri} ${entry.bytes}B diagnostics=${entry.diagnostics}`;
     case 'edge': {
       const pick = ['method', 'path', 'httpStatus', 'totalDuration', 'responseTime', 'txBytes', 'rxBytes', 'clientUa', 'responseDetails'];
       return `${t} ▸ edge ${pick.map(key => entry[key] ?? entry.attributes?.[key]).filter(value => value !== undefined).join(' ')}`;
@@ -45,34 +51,58 @@ function describe(entry, zero) {
   }
 }
 
-/** What the window shows, as findings tied to the hypotheses in #335. */
-function findings(window) {
+/** What one attempt's window shows. Each finding is an observation in that window, not a claim about the host. */
+function findings(window, card) {
   const out = [];
   const reads = window.filter(entry => entry.event === 'mcp.request' && entry.rpc === 'resources/read');
   const readEnds = window.filter(entry => entry.event === 'mcp.response' && entry.rpc === 'resources/read');
-  if (reads.length === 0) out.push('no card read reached the server in this window (the host used a cached card, or never asked)');
-  if (reads.some(entry => entry.uriCurrent === false)) out.push('a card address that is not the current deploy\'s was read (stale discovery)');
-  for (const end of readEnds) if (end.outcome !== 'complete') out.push(`a card read was ${end.outcome} after ${end.ms}ms and ${end.bytes}B`);
+  if (reads.length === 0) out.push('no card read was observed at the server in this window');
+  if (reads.some(entry => entry.uriCurrent === false)) out.push('a card address that is not the one this instance serves was read');
+  for (const end of readEnds) if (end.stream !== 'drained') out.push(`a card read stream was ${end.stream} after ${end.ms}ms and ${end.bytes}B`);
+  for (const end of readEnds) if (end.errorCode !== undefined) out.push(`a card read answered JSON-RPC error ${end.errorCode}`);
   const slow = readEnds.filter(end => end.ms > 2_000);
-  if (slow.length) out.push(`card reads slower than 2s: ${slow.map(end => `${end.ms}ms`).join(', ')}`);
+  if (slow.length) out.push(`card read streams slower than 2s on this side: ${slow.map(end => `${end.ms}ms`).join(', ')}`);
   const cards = new Map();
   for (const entry of window.filter(item => item.event === 'view.report')) cards.set(entry.view, entry);
-  if (diagnosticsSeen) out.push(`${cards.size} card instance(s) reported`);
+  if (card === 'diagnostic') out.push(`${cards.size} card instance(s) reported in this window${cards.size === 0 ? ' (none observed: a card may not have run, or its report did not arrive)' : ''}`);
   for (const [id, last] of cards) {
     const m = last.marks ?? {};
-    if (m.teardownRequested !== undefined && m.ready === undefined) out.push(`card ${id}: the host asked to tear it down before it was ready`);
+    if (m.main === undefined) out.push(`card ${id}: the bundle had not evaluated by its last report (${last.reason})`);
+    if (m.teardownRequested !== undefined && m.ready === undefined) out.push(`card ${id}: the host asked for teardown before the card was ready, as of its last report`);
     if (last.failure) out.push(`card ${id}: start failed (${last.failure})`);
     if (m.ready !== undefined && m.script !== undefined && m.ready - m.script > 3_000) out.push(`card ${id}: ${Math.round(m.ready - m.script)}ms from script start to ready`);
-    if (m.hostMessage === undefined) out.push(`card ${id}: no message from the host ever arrived`);
+    if (m.hostMessage === undefined) out.push(`card ${id}: no host message observed by its last report (${last.reason})`);
   }
   return out;
 }
 
-for (const trial of lines(trialsFile)) {
+/** Signs that a window holds traffic other than this trial's, so its records cannot be attributed with confidence. */
+function ambiguity(window, trial) {
+  const out = [];
+  const clients = new Set(window.filter(entry => entry.event === 'mcp.request' && entry.client).map(entry => `${entry.client}/${entry.clientVersion}`));
+  if (clients.size > 1) out.push(`${clients.size} different MCP clients: ${[...clients].join(', ')}`);
+  const overlapping = trials.filter(other => other !== trial && Date.parse(other.start) < Date.parse(trial.end) && Date.parse(other.end) > Date.parse(trial.start));
+  if (overlapping.length) out.push(`${overlapping.length} other trial(s) overlap this one`);
+  const releases = new Set(window.filter(entry => entry.release).map(entry => entry.release));
+  if (trial.release && trial.release !== 'unknown' && releases.size && ![...releases].every(release => release === trial.release)) out.push(`records from releases ${[...releases].join(', ')}, trial recorded ${trial.release}`);
+  return out;
+}
+
+for (const trial of trials) {
   const start = Date.parse(trial.start);
   const end = Date.parse(trial.end);
-  const window = entries.filter(entry => entry.at >= start - MARGIN_MS && entry.at <= end + MARGIN_MS);
-  console.log(`\n=== ${trial.host} / ${trial.deploy} / ${trial.label}: first=${trial.first} retry=${trial.retry} (${trial.start} → ${trial.end})`);
-  for (const entry of window) console.log(describe(entry, start));
-  for (const finding of findings(window)) console.log(`  ! ${finding}`);
+  const retryAt = trial.retryAt ? Date.parse(trial.retryAt) : undefined;
+  const all = entries.filter(entry => entry.at >= start - LEAD_MS && entry.at <= end);
+  const serving = entries.filter(entry => entry.event === 'view.prepared' && entry.at <= end).at(-1);
+  console.log(`\n=== ${trial.host} / ${trial.deploy} / ${trial.card ?? '?'} card / ${trial.label}: first=${trial.first} retry=${trial.retry}`);
+  console.log(`    release ${trial.release ?? '?'} at ${trial.origin ?? '?'}; serving ${serving ? `${serving.uri} (${serving.bytes}B, diagnostics=${serving.diagnostics})` : 'not observed in these logs'}`);
+  for (const warning of ambiguity(all, trial)) console.log(`  ? AMBIGUOUS: ${warning}`);
+  const attempts = [['first attempt', start - LEAD_MS, retryAt ?? end]];
+  if (retryAt !== undefined) attempts.push(['retry', retryAt, end]);
+  for (const [name, from, to] of attempts) {
+    const window = entries.filter(entry => entry.at >= from && entry.at < to || (to === end && entry.at === end));
+    console.log(`  -- ${name} (${new Date(from).toISOString()} → ${new Date(to).toISOString()})`);
+    for (const entry of window) console.log(describe(entry, start));
+    for (const finding of findings(window, trial.card)) console.log(`  ! ${finding}`);
+  }
 }
diff --git a/apps/mcp/scripts/first-load-trial.sh b/apps/mcp/scripts/first-load-trial.sh
index 28dfa2f4..acd62a0f 100644
--- a/apps/mcp/scripts/first-load-trial.sh
+++ b/apps/mcp/scripts/first-load-trial.sh
@@ -1,17 +1,22 @@
 #!/usr/bin/env bash
 # One first-load trial in a real host (#335). The person at the host follows the prompts; the script records the
-# trial window and what they saw as one JSON line, which scripts/first-load-timeline.mjs joins with the server logs.
+# deployment's identity, the first attempt and the Retry as separate time windows, and what was seen in each, as one
+# JSON line that scripts/first-load-timeline.mjs joins with the server logs.
 #
-# Usage: bash scripts/first-load-trial.sh <host: claude|chatgpt> <deploy: fresh|aged> [case label]
+# Usage: bash scripts/first-load-trial.sh <origin> <host: claude|chatgpt> <deploy: fresh|aged> <card: diagnostic|closed> [label]
+#   origin: the deployment's public origin, for example https://ansari-mcp-development.up.railway.app
 # Output: test-results/first-load/trials.jsonl (git-ignored)
 set -euo pipefail
 
-host="${1:?host: claude or chatgpt}"
-deploy="${2:?deploy: fresh (just redeployed) or aged (live for hours)}"
-label="${3:-english-greeting}"
+origin="${1:?origin: the public origin of the deployment}"
+host="${2:?host: claude or chatgpt}"
+deploy="${3:?deploy: fresh (just redeployed) or aged (live for hours)}"
+card="${4:?card: diagnostic (MCP_VIEW_DIAGNOSTICS_ORIGIN set) or closed (unset)}"
+label="${5:-english-greeting}"
 out="$(dirname "$0")/../test-results/first-load"
 mkdir -p "$out"
 
+now() { node -e 'console.log(new Date().toISOString())'; }
 step() {
   printf '\n>>> %s\n' "$1"
   read -r -p "    [Enter when done] " _
@@ -23,20 +28,32 @@ capture() {
   printf -v "$var" '%s' "$answer"
 }
 
-step "In $host, open a NEW conversation with the Ansari Dev connector enabled. Do not send anything yet. Optional: open devtools on the page."
-start="$(date -u +%Y-%m-%dT%H:%M:%S.000Z)"
-step "Send: Use Ansari Faithful Answers Dev to answer: What does \"assalamu alaikum\" mean? Please keep the answer brief."
+release="$(curl -fsS --max-time 10 "$origin/health" | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>console.log(JSON.parse(s).release))' || echo unknown)"
+printf 'Deployment release: %s\n' "$release"
+printf 'Isolate the deployment for this trial: no other conversation or client should use it until the trial ends.\n'
+
+step "In $host, open a NEW conversation with the Ansari connector for $origin enabled. Do not send anything yet. Optional: open devtools on the page."
+start="$(now)"
+step "Send: Use Ansari Faithful Answers Dev to answer: What does \"assalamu alaikum\" mean? Please keep the answer brief. Press Enter as soon as it is sent."
+sent="$(now)"
 capture first "What did the embed show first? (card / error / blank / none)"
-retry="n-a"
+firstSeen="$(now)"
+retry="n-a"; retryAt=""; retrySeen=""
 if [ "$first" != "card" ]; then
-  capture retry "Press the host's Retry / Try again once. What does it show now? (card / error / blank / none)"
+  step "Press the host's Retry / Try again once, then press Enter immediately."
+  retryAt="$(now)"
+  capture retry "What does it show now? (card / error / blank / none)"
+  retrySeen="$(now)"
 fi
 capture console "Optional: paste the [ansari-view] console lines from the card frame, or press Enter"
-end="$(date -u +%Y-%m-%dT%H:%M:%S.000Z)"
+end="$(now)"
 
-node -e 'const [host, deploy, label, start, end, first, retry, consoleLines] = process.argv.slice(1);
-  process.stdout.write(JSON.stringify({host, deploy, label, start, end, first, retry, console: consoleLines || undefined}) + "\n");' \
-  "$host" "$deploy" "$label" "$start" "$end" "$first" "$retry" "$console" >> "$out/trials.jsonl"
+node -e 'const [origin, release, host, deploy, card, label, start, sent, first, firstSeen, retryAt, retry, retrySeen, end, consoleLines] = process.argv.slice(1);
+  const trial = {origin, release, host, deploy, card, label, start, sent, first, firstSeen, retry, end};
+  if (retryAt) Object.assign(trial, {retryAt, retrySeen});
+  if (consoleLines) trial.console = consoleLines;
+  process.stdout.write(JSON.stringify(trial) + "\n");' \
+  "$origin" "$release" "$host" "$deploy" "$card" "$label" "$start" "$sent" "$first" "$firstSeen" "$retryAt" "$retry" "$retrySeen" "$end" "$console" >> "$out/trials.jsonl"
 
 printf '\n--- Recorded in %s ---\n' "$out/trials.jsonl"
 tail -n 1 "$out/trials.jsonl"
diff --git a/apps/mcp/src/server/exchange-log.ts b/apps/mcp/src/server/exchange-log.ts
index 61b79c2b..0a09752f 100644
--- a/apps/mcp/src/server/exchange-log.ts
+++ b/apps/mcp/src/server/exchange-log.ts
@@ -1,14 +1,16 @@
 // What one MCP exchange looked like on the wire, for first-load diagnosis (#335): which method a host called,
-// which card address it read and whether that address is the one served now, and how the response ended.
+// which card address it read and whether that address is the one served now, and how the response stream ended.
 // Only fixed fields are derived from the request; no question, answer or other parameter value is kept.
+//
+// Observation never sits on the request path: the request is inspected from a copy, alongside the handler, up to a
+// byte bound, and any failure to inspect is recorded as such instead of affecting the exchange.
 
-/** Request bodies larger than this are not inspected; MCP requests from hosts are a few kilobytes at most. */
-const MAX_INSPECTED_BODY = 65_536;
-/** How much of a response is searched for a JSON-RPC error code. A successful card read is far larger. */
-const RESPONSE_HEAD = 2_048;
+/** Request bytes inspected at most; MCP requests from hosts are a few kilobytes. Larger bodies are recorded as `oversize`. */
+export const MAX_INSPECTED_BODY = 65_536;
+/** Response bytes kept for decoding a JSON-RPC error. A successful card read is larger and needs no decoding. */
+const MAX_DECODED_RESPONSE = 65_536;
 const TOKEN = /^[A-Za-z0-9 ._:/@+-]{1,80}$/;
 const UI_URI = /^ui:\/\/[A-Za-z0-9._/-]{1,200}$/;
-const ERROR_CODE = /"error"\s*:\s*\{\s*"code"\s*:\s*(-?\d{1,6})/;
 
 export type RpcSummary = {
   rpc: string;
@@ -21,7 +23,19 @@ export type RpcSummary = {
   tool?: string;
 };
 
-export type ExchangeEnd = {outcome: 'complete' | 'cancelled' | 'failed'; bytes: number; errorCode?: number};
+/**
+ * How the response stream ended on this side: `drained` (the transport read it to the end), `cancelled` (the reader
+ * stopped early, as when the client goes away) or `failed`. Neither says the host received or rendered it.
+ */
+export type StreamOutcome = 'drained' | 'cancelled' | 'failed';
+export type ExchangeEnd = {
+  stream: StreamOutcome;
+  bytes: number;
+  /** The JSON-RPC error code, when the response decoded as JSON-RPC within the kept bytes. */
+  errorCode?: number;
+  /** Whether the kept bytes decoded as JSON-RPC at all; `false` for a body too large to keep or not JSON-RPC. */
+  decoded: boolean;
+};
 
 const token = (value: unknown): string | undefined => typeof value === 'string' ? (TOKEN.test(value) ? value : 'other') : undefined;
 const record = (value: unknown): Record<string, unknown> => typeof value === 'object' && value !== null && !Array.isArray(value) ? value as Record<string, unknown> : {};
@@ -57,40 +71,92 @@ export function summarizeRpc(body: string, currentUri: string): RpcSummary {
   return summarizeMessage(record(parsed), currentUri);
 }
 
-/** The body of a POST, read from a copy so the MCP handler still receives the original. */
-export async function inspectableBody(request: Request): Promise<string | undefined> {
-  if (request.method !== 'POST') return undefined;
-  const declared = Number(request.headers.get('content-length') ?? 0);
-  if (declared > MAX_INSPECTED_BODY) return undefined;
-  const text = await request.clone().text();
-  return text.length > MAX_INSPECTED_BODY ? undefined : text;
+/**
+ * Reads a stream up to `limit` bytes. Stops and cancels as soon as the limit is passed, whatever the stream's
+ * declared length, so an absent or wrong Content-Length cannot make it read more.
+ */
+export async function readBounded(stream: ReadableStream<Uint8Array>, limit: number): Promise<{text: string} | {exceeded: true}> {
+  const reader = stream.getReader();
+  const chunks: Uint8Array[] = [];
+  let size = 0;
+  for (;;) {
+    const {done, value} = await reader.read();
+    if (done) break;
+    size += value.byteLength;
+    if (size > limit) {
+      await reader.cancel().catch(() => undefined);
+      return {exceeded: true};
+    }
+    chunks.push(value);
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) { bytes.set(chunk, offset); offset += chunk.byteLength; }
+  return {text: new TextDecoder().decode(bytes)};
+}
+
+/**
+ * Starts inspecting a request from a copy and returns at once; the caller hands the original to the handler without
+ * waiting. Must be called before the original body is read. Never rejects.
+ */
+export function inspectRequest(request: Request, currentUri: string): Promise<RpcSummary> {
+  if (request.method !== 'POST') return Promise.resolve({rpc: 'none'});
+  if (request.body === null) return Promise.resolve({rpc: 'empty'});
+  const copy = request.clone().body!;
+  return readBounded(copy, MAX_INSPECTED_BODY).then(
+    read => 'exceeded' in read ? {rpc: 'oversize'} : summarizeRpc(read.text, currentUri),
+    () => ({rpc: 'unread'}),
+  );
+}
+
+/** The first JSON-RPC error code in a JSON or SSE response body, decoded rather than pattern-matched. */
+function decodeRpcError(text: string, contentType: string): {decoded: boolean; errorCode?: number} {
+  const payloads = contentType.includes('text/event-stream')
+    ? text.split(/\r?\n\r?\n/).map(event => event.split(/\r?\n/).filter(line => line.startsWith('data:')).map(line => line.slice(5).trimStart()).join('\n')).filter(Boolean)
+    : [text];
+  let decoded = false;
+  for (const payload of payloads) {
+    let message: unknown;
+    try { message = JSON.parse(payload); } catch { continue; }
+    for (const item of Array.isArray(message) ? message : [message]) {
+      const value = record(item);
+      if (value.jsonrpc !== '2.0') continue;
+      decoded = true;
+      const code = record(value.error).code;
+      if (typeof code === 'number') return {decoded, errorCode: code};
+    }
+  }
+  return {decoded};
 }
 
 /**
- * Passes the response through unchanged while counting what is sent, and reports once how it ended: fully sent,
- * abandoned by the client, or failed. The first bytes are searched for a JSON-RPC error code, which an MCP error
- * carries inside an HTTP 200.
+ * Passes the response through unchanged while counting what the transport reads, and reports once how that stream
+ * ended. Responses small enough to keep are decoded for a JSON-RPC error, which MCP carries inside an HTTP 200.
  */
 export function observeResponse(response: Response, done: (end: ExchangeEnd) => void): Response {
+  const contentType = response.headers.get('content-type') ?? '';
   let ended = false;
   let bytes = 0;
-  let head = '';
-  const decoder = new TextDecoder();
-  const finish = (outcome: ExchangeEnd['outcome']) => {
+  const kept: Uint8Array[] = [];
+  const finish = (stream: StreamOutcome) => {
     if (ended) return;
     ended = true;
-    const code = ERROR_CODE.exec(head)?.[1];
-    done({outcome, bytes, ...(code === undefined ? {} : {errorCode: Number(code)})});
+    if (bytes > MAX_DECODED_RESPONSE || bytes === 0) { done({stream, bytes, decoded: false}); return; }
+    const all = new Uint8Array(bytes);
+    let offset = 0;
+    for (const chunk of kept) { all.set(chunk, offset); offset += chunk.byteLength; }
+    done({stream, bytes, ...decodeRpcError(new TextDecoder().decode(all), contentType)});
   };
-  if (response.body === null) { finish('complete'); return response; }
+  if (response.body === null) { finish('drained'); return response; }
   const reader = response.body.getReader();
   const body = new ReadableStream<Uint8Array>({
     async pull(controller) {
       try {
         const {done: last, value} = await reader.read();
-        if (last) { finish('complete'); controller.close(); return; }
+        if (last) { finish('drained'); controller.close(); return; }
         bytes += value.byteLength;
-        if (head.length < RESPONSE_HEAD) head += decoder.decode(value.subarray(0, RESPONSE_HEAD), {stream: true});
+        if (bytes <= MAX_DECODED_RESPONSE) kept.push(value);
+        else kept.length = 0;
         controller.enqueue(value);
       } catch (error) {
         finish('failed');
diff --git a/apps/mcp/src/server/fetch-app.ts b/apps/mcp/src/server/fetch-app.ts
index cf075f3d..d181cfe1 100644
--- a/apps/mcp/src/server/fetch-app.ts
+++ b/apps/mcp/src/server/fetch-app.ts
@@ -3,9 +3,9 @@ import {createMcpHandler} from '@modelcontextprotocol/server';
 import {Hono} from 'hono';
 import type {AnswerCompleter} from './ansari-client.js';
 import {createAnsariMcpServer} from './create-server.js';
-import {errorIdentity, inspectableBody, observeResponse, summarizeRpc} from './exchange-log.js';
+import {errorIdentity, inspectRequest, observeResponse, readBounded} from './exchange-log.js';
 import {VIEW_DIAGNOSTICS_PATH, prepareAnswerView} from './view-artifact.js';
-import {MAX_VIEW_REPORT_BYTES, originHost, parseViewReport} from './view-report.js';
+import {MAX_VIEW_REPORT_BYTES, VIEW_REPORTS_PER_MINUTE, originHost, parseViewReport} from './view-report.js';
 import {type OperationLogger, writeOperationLog} from './operation-log.js';
 
 export const MCP_PATH = '/mcp';
@@ -49,39 +49,49 @@ export function createFetchApp(options: FetchAppOptions): FetchApp {
   app.get('/health', c => c.json({ok: true, mcp: MCP_PATH, release}));
   app.use(MCP_PATH, hostHeaderValidation(options.allowedHosts));
   app.use(MCP_PATH, originValidation(options.allowedOrigins));
-  // One line when a request arrives and one when its response ends, joined by `rid`: which method a host called,
-  // which card address it read, and whether the response was fully sent (#335).
+  // The exact card this instance serves: a diagnostic card differs from the closed one in bytes, address and permissions.
+  log({event: 'view.prepared', at: Date.now(), uri: view.uri, bytes: new TextEncoder().encode(view.html).byteLength, diagnostics: options.viewDiagnosticsOrigin !== undefined, connectDomains: view.csp.connectDomains.join(',')});
+  // One line when a request has been inspected and one when its response stream ends, joined by `rid`: which method a
+  // host called, which card address it read, and how the response stream ended (#335). Inspection reads a copy
+  // alongside the handler and never holds up or alters the exchange.
   app.all(MCP_PATH, async c => {
     const started = Date.now();
     const rid = crypto.randomUUID().slice(0, 8);
-    const body = await inspectableBody(c.req.raw);
-    const summary = body === undefined ? {rpc: c.req.method === 'POST' ? 'oversize' : 'none'} : summarizeRpc(body, view.uri);
-    log({event: 'mcp.request', at: started, method: c.req.method, rid, ...summary});
+    const inspected = inspectRequest(c.req.raw, view.uri);
+    void inspected.then(summary => log({event: 'mcp.request', at: started, method: c.req.method, rid, ...summary}));
     const response = await mcp.fetch(c.req.raw);
     const headersMs = Date.now() - started;
-    return observeResponse(response, end => log({event: 'mcp.response', at: Date.now(), rid, rpc: summary.rpc, status: response.status, headersMs, ms: Date.now() - started, ...end}));
+    return observeResponse(response, end => {
+      const ms = Date.now() - started;
+      void inspected.then(summary => log({event: 'mcp.response', at: Date.now(), rid, rpc: summary.rpc, status: response.status, headersMs, ms, ...end}));
+    });
   });
   if (options.viewDiagnosticsOrigin !== undefined) {
     app.use(VIEW_DIAGNOSTICS_PATH, hostHeaderValidation(options.allowedHosts));
-    // A beacon from a sandboxed card: no credentials, a simple text/plain request and nothing to read back.
+    let windowStart = 0;
+    let windowCount = 0;
+    // A beacon from a sandboxed card: unauthenticated, client-authored and only as trustworthy as the card that sent
+    // it. Bounded in size and rate; nothing is read back.
     app.post(VIEW_DIAGNOSTICS_PATH, async c => {
       c.header('access-control-allow-origin', '*');
-      const origin = originHost(c.req.header('origin') ?? null);
-      if (Number(c.req.header('content-length') ?? 0) > MAX_VIEW_REPORT_BYTES) {
-        log({event: 'view.report.invalid', reason: 'size', origin});
-        return c.body(null, 413);
+      const now = Date.now();
+      if (now - windowStart >= 60_000) { windowStart = now; windowCount = 0; }
+      if (++windowCount > VIEW_REPORTS_PER_MINUTE) {
+        if (windowCount === VIEW_REPORTS_PER_MINUTE + 1) log({event: 'view.report.limited', perMinute: VIEW_REPORTS_PER_MINUTE});
+        return c.body(null, 429);
       }
-      const text = await c.req.text();
-      if (text.length > MAX_VIEW_REPORT_BYTES) {
+      const origin = originHost(c.req.header('origin') ?? null);
+      const read = c.req.raw.body === null ? {text: ''} : await readBounded(c.req.raw.body, MAX_VIEW_REPORT_BYTES).catch(() => ({exceeded: true as const}));
+      if ('exceeded' in read) {
         log({event: 'view.report.invalid', reason: 'size', origin});
         return c.body(null, 413);
       }
-      const report = parseViewReport(text);
+      const report = parseViewReport(read.text);
       if (report === undefined) {
         log({event: 'view.report.invalid', reason: 'shape', origin});
         return c.body(null, 400);
       }
-      log({event: 'view.report', at: Date.now(), origin, ...report});
+      log({event: 'view.report', at: now, clientAuthored: true, origin, ...report});
       return c.body(null, 204);
     });
   }
diff --git a/apps/mcp/src/server/view-artifact.ts b/apps/mcp/src/server/view-artifact.ts
index c6b67ece..74221e24 100644
--- a/apps/mcp/src/server/view-artifact.ts
+++ b/apps/mcp/src/server/view-artifact.ts
@@ -5,20 +5,24 @@ import {stampHtmlRevision} from './operation-log.js';
 export const VIEW_FILENAME = 'answer-card.html';
 /** Where a diagnostic card sends its milestone reports (#335). Served only when a diagnostics origin is configured. */
 export const VIEW_DIAGNOSTICS_PATH = '/diag/view';
+/** The head element that switches a card's diagnostics on; the card's early script reads it before the bundle runs. */
+export const VIEW_DIAGNOSTICS_META = 'ansari-diagnostics';
 const CLOSED_CONNECT = "connect-src 'none'";
 
 /**
  * Prepare immutable deployment bytes once from the built card the host supplies: no file is read here.
- * With a diagnostics origin (Dev only), the card may connect to that one origin and is told where to report; this
- * changes its bytes and so its address. Without one, the card and its permissions are exactly the built card's.
+ * With a diagnostics origin (a deployment under diagnosis), the card may connect to that one origin and is told
+ * where to report. That changes its bytes, its address and its permissions, so a diagnostic run is compared with
+ * the closed card, not assumed equal to it. Without one, the card and its permissions are exactly the built card's.
  */
 export function prepareAnswerView(html: string, release?: string, diagnosticsOrigin?: string): OperationView {
   let currentHtml = stampHtmlRevision(html, release);
   if (diagnosticsOrigin !== undefined) {
     if (!currentHtml.includes(CLOSED_CONNECT)) throw new Error(`The card has no "${CLOSED_CONNECT}" rule to open for diagnostics.`);
+    if (!/<head[^>]*>/.test(currentHtml)) throw new Error('The card has no <head> to carry its diagnostics address.');
     currentHtml = currentHtml
       .replace(CLOSED_CONNECT, `connect-src ${diagnosticsOrigin}`)
-      .replace(/<body([^>]*)>/, `<body$1 data-diagnostics="${diagnosticsOrigin}${VIEW_DIAGNOSTICS_PATH}">`);
+      .replace(/<head[^>]*>/, head => `${head}<meta name="${VIEW_DIAGNOSTICS_META}" content="${diagnosticsOrigin}${VIEW_DIAGNOSTICS_PATH}">`);
     return Object.freeze(operationViewFromHtml({html: currentHtml, filename: VIEW_FILENAME, title: 'Ansari answer card', csp: {connectDomains: [diagnosticsOrigin]}}));
   }
   // The identity is taken from the final bytes, after revision stamping. Declared permissions stay closed.
diff --git a/apps/mcp/src/server/view-report.ts b/apps/mcp/src/server/view-report.ts
index 68834de1..e1fd6494 100644
--- a/apps/mcp/src/server/view-report.ts
+++ b/apps/mcp/src/server/view-report.ts
@@ -2,9 +2,12 @@ import {z} from 'zod';
 import {VIEW_MARKS, VIEW_REPORT_REASONS} from '../view/diagnostic-marks.js';
 
 // The one report shape a diagnostic card may send to the beacon (#335). Every field is an enumerated value, a
-// bounded token or a number; unknown keys and free text (error messages included) are dropped before logging.
+// bounded token or a number; unknown keys and free text (error messages included) are dropped before logging. The
+// shape limits what is logged; it does not make a report authentic. Anyone who can reach the route can send one.
 
 export const MAX_VIEW_REPORT_BYTES = 8_192;
+/** Reports accepted per instance per minute; more are refused with 429 and noted once. */
+export const VIEW_REPORTS_PER_MINUTE = 120;
 
 const TOKEN = /^[A-Za-z0-9._+-]{1,80}$/;
 const token = z.string().regex(TOKEN);
diff --git a/apps/mcp/src/view/diagnostic-marks.ts b/apps/mcp/src/view/diagnostic-marks.ts
index 74a7732b..1c05d375 100644
--- a/apps/mcp/src/view/diagnostic-marks.ts
+++ b/apps/mcp/src/view/diagnostic-marks.ts
@@ -13,5 +13,5 @@ export const VIEW_MARKS = ['script', 'main', 'hostMessage', 'toolInput', 'toolRe
 export type ViewMark = (typeof VIEW_MARKS)[number];
 
 /** Why a card sent a report. */
-export const VIEW_REPORT_REASONS = ['ready', 'failed', 'result', 'problem', 'pagehide', 'timeout'] as const;
+export const VIEW_REPORT_REASONS = ['load', 'ready', 'failed', 'result', 'problem', 'pagehide', 'timeout'] as const;
 export type ViewReportReason = (typeof VIEW_REPORT_REASONS)[number];
diff --git a/apps/mcp/src/view/diagnostics.ts b/apps/mcp/src/view/diagnostics.ts
index 2ea0d046..3e7fa7ea 100644
--- a/apps/mcp/src/view/diagnostics.ts
+++ b/apps/mcp/src/view/diagnostics.ts
@@ -2,80 +2,60 @@ import type {CardChromeProps} from '@saga-a2ui/react-mcp-stack/faithful-card';
 import {createElement, useEffect, type ComponentType} from 'react';
 import type {ViewMark, ViewReportReason} from './diagnostic-marks.js';
 
-// First-load diagnosis (#335). The stack's hooks (hostContext, readyWhen, onError, the `ready` promise and the
-// chrome) mark how far this card got; the early script in mcp-app-react.html has already recorded the script
-// start and any error, rejection or content-policy violation before the bundle ran. A report is one tagged
-// console line, and, only when the served card carries a `data-diagnostics` address (Dev), a beacon to it.
-// Reports carry milestones, enumerated failures and error names only: never answer text or error messages.
+// First-load diagnosis (#335). The early script in mcp-app-react.html owns the record and all reporting, and exists
+// only in a card served with a diagnostics address. The stack's hooks (hostContext, readyWhen, onError, the `ready`
+// promise and the chrome) add how far the card got, and report at its own milestones. In any other card every
+// function here does nothing.
 
-type EarlyRecord = {id: string; marks: Partial<Record<ViewMark, number>>; errors: Record<string, string>[]};
+type DiagnosticRecord = {
+  marks: Partial<Record<ViewMark, number>>;
+  errors: Record<string, string>[];
+  settled: boolean;
+  host?: string;
+  failure?: string;
+  report: (reason: ViewReportReason) => void;
+};
 declare global {
-  interface Window { __ansariDiag?: EarlyRecord }
+  interface Window { __ansariDiag?: DiagnosticRecord }
 }
 
 const MAX_ERRORS = 20;
-const TIMEOUT_MS = 15_000;
-const early: EarlyRecord = window.__ansariDiag ?? {
-  id: Array.from(crypto.getRandomValues(new Uint8Array(8)), byte => byte.toString(16).padStart(2, '0')).join(''),
-  marks: {},
-  errors: [],
-};
-let hostName: string | undefined;
-let failure: string | undefined;
-let settled = false;
+const diagnostic = (): DiagnosticRecord | undefined => window.__ansariDiag;
 
 export function mark(name: ViewMark): void {
-  early.marks[name] ??= performance.now();
+  const record = diagnostic();
+  if (record) record.marks[name] ??= performance.now();
 }
 
 export function noteHost(name: string | undefined): void {
-  hostName ??= name;
-}
-
-export function noteFailure(kind: string): void {
-  failure = kind;
+  const record = diagnostic();
+  if (record && name !== undefined) record.host ??= name;
 }
 
 export function noteCallbackError(error: unknown, phase: string): void {
-  if (early.errors.length < MAX_ERRORS) early.errors.push({type: 'callback', name: error instanceof Error ? error.name : typeof error, phase});
-}
-
-export function report(reason: ViewReportReason): void {
-  for (const entry of performance.getEntriesByType('paint')) {
-    if (entry.name === 'first-paint') early.marks.firstPaint ??= entry.startTime;
-    if (entry.name === 'first-contentful-paint') early.marks.firstContentfulPaint ??= entry.startTime;
-  }
-  const body = JSON.stringify({
-    v: 1,
-    id: early.id,
-    release: document.body.dataset.revision ?? document.body.dataset.release ?? 'unknown',
-    reason,
-    visibility: document.visibilityState === 'hidden' ? 'hidden' : 'visible',
-    ...(hostName === undefined ? {} : {host: hostName}),
-    ...(failure === undefined ? {} : {failure}),
-    marks: early.marks,
-    errors: early.errors,
-  });
-  console.info('[ansari-view]', body);
-  const endpoint = document.body.dataset.diagnostics;
-  if (endpoint === undefined) return;
-  try {
-    if (!navigator.sendBeacon(endpoint, new Blob([body], {type: 'text/plain'}))) {
-      void fetch(endpoint, {method: 'POST', body, mode: 'no-cors', keepalive: true}).catch(() => undefined);
-    }
-  } catch {
-    // Diagnosis never disturbs the card.
-  }
+  const record = diagnostic();
+  if (record && record.errors.length < MAX_ERRORS) record.errors.push({type: 'callback', name: error instanceof Error ? error.name : typeof error, phase});
 }
 
-/** Reports once when the card starts or fails, when the page is put away, and if it has not started in time. */
+/** Reports once when the card has started, or failed to start. */
 export function watchStart(ready: Promise<void>, failureKind: (failure: unknown) => string): void {
   ready.then(
-    () => { settled = true; mark('ready'); report('ready'); },
-    (error: unknown) => { settled = true; noteFailure(failureKind(error)); mark('failed'); report('failed'); },
+    () => {
+      const record = diagnostic();
+      if (!record) return;
+      record.settled = true;
+      mark('ready');
+      record.report('ready');
+    },
+    (error: unknown) => {
+      const record = diagnostic();
+      if (!record) return;
+      record.settled = true;
+      record.failure = failureKind(error);
+      mark('failed');
+      record.report('failed');
+    },
   );
-  addEventListener('pagehide', () => report('pagehide'), {once: true});
-  setTimeout(() => { if (!settled) report('timeout'); }, TIMEOUT_MS);
 }
 
 /** The application's chrome, marking the first answer and the first problem it actually rendered. */
@@ -83,11 +63,12 @@ export function observedChrome(Chrome: ComponentType<CardChromeProps>): Componen
   return function ObservedChrome(props: CardChromeProps) {
     const kind = props.state.kind;
     useEffect(() => {
-      if (kind === 'waiting') return;
+      const record = diagnostic();
+      if (!record || kind === 'waiting') return;
       const name = kind === 'answer' ? 'result' : 'problem';
-      if (early.marks[name] !== undefined) return;
+      if (record.marks[name] !== undefined) return;
       mark(name);
-      report(name);
+      record.report(name);
     }, [kind]);
     return createElement(Chrome, props);
   };
diff --git a/apps/mcp/src/view/mcp-app-react.html b/apps/mcp/src/view/mcp-app-react.html
index b1899aa5..5c48749f 100644
--- a/apps/mcp/src/view/mcp-app-react.html
+++ b/apps/mcp/src/view/mcp-app-react.html
@@ -3,12 +3,17 @@
   <head>
     <meta charset="UTF-8" />
     <script>
-      // First-load diagnosis (#335): runs before the card's bundle is parsed, so a failure before it starts is still
-      // recorded. Names and kinds only; src/view/diagnostics.ts reports what this collects.
+      // First-load diagnosis (#335), active only in a card served with an `ansari-diagnostics` address (a deployment
+      // under diagnosis); otherwise it returns at once. It runs before the bundle is parsed and reports by itself at
+      // `load`, at `pagehide` and after 15 s without a start, so a bundle that never runs still produces a report.
+      // Names, kinds and times only; the bundle adds its milestones through src/view/diagnostics.ts.
       (function () {
+        var address = document.querySelector('meta[name="ansari-diagnostics"]');
+        if (!address) return;
+        var endpoint = address.getAttribute('content');
         var bytes = crypto.getRandomValues(new Uint8Array(8));
         var id = Array.prototype.map.call(bytes, function (b) { return (b + 256).toString(16).slice(1); }).join('');
-        var record = window.__ansariDiag = {id: id, marks: {script: performance.now()}, errors: []};
+        var record = window.__ansariDiag = {id: id, marks: {script: performance.now()}, errors: [], settled: false};
         var token = function (value) { return typeof value === 'string' && value ? value.slice(0, 80) : undefined; };
         var push = function (entry) { if (record.errors.length < 20) record.errors.push(entry); };
         addEventListener('error', function (event) {
@@ -18,7 +23,11 @@
         addEventListener('unhandledrejection', function (event) {
           push({type: 'rejection', name: token(event.reason && event.reason.name) || typeof event.reason});
         });
-        // When the host's messages arrive, by method name only: the handshake reply, the tool input and result, teardown.
+        addEventListener('securitypolicyviolation', function (event) {
+          push({type: 'csp', directive: token(event.effectiveDirective), blocked: token(String(event.blockedURI).split(':')[0])});
+        });
+        // When the host's messages arrive, by method name only. This reads the MCP Apps protocol directly for this
+        // experiment; if the observation proves necessary it belongs in the SDK's view lifecycle, not in the card.
         var arrivals = {'ui/notifications/tool-input': 'toolInput', 'ui/notifications/tool-result': 'toolResult', 'ui/notifications/tool-cancelled': 'toolCancelled', 'ui/resource-teardown': 'teardownRequested'};
         addEventListener('message', function (event) {
           var data = event.data;
@@ -28,9 +37,26 @@
           var name = arrivals[data.method];
           if (name && record.marks[name] === undefined) record.marks[name] = now;
         });
-        addEventListener('securitypolicyviolation', function (event) {
-          push({type: 'csp', directive: token(event.effectiveDirective), blocked: token(String(event.blockedURI).split(':')[0])});
-        });
+        record.report = function (reason) {
+          performance.getEntriesByType('paint').forEach(function (entry) {
+            var name = entry.name === 'first-paint' ? 'firstPaint' : entry.name === 'first-contentful-paint' ? 'firstContentfulPaint' : undefined;
+            if (name && record.marks[name] === undefined) record.marks[name] = entry.startTime;
+          });
+          var report = {v: 1, id: id, release: (document.body && (document.body.dataset.revision || document.body.dataset.release)) || 'unknown',
+            reason: reason, visibility: document.visibilityState === 'hidden' ? 'hidden' : 'visible', marks: record.marks, errors: record.errors};
+          if (record.host) report.host = record.host;
+          if (record.failure) report.failure = record.failure;
+          var body = JSON.stringify(report);
+          console.info('[ansari-view]', body);
+          try {
+            if (!navigator.sendBeacon(endpoint, new Blob([body], {type: 'text/plain'}))) {
+              fetch(endpoint, {method: 'POST', body: body, mode: 'no-cors', keepalive: true}).catch(function () {});
+            }
+          } catch (error) { /* Diagnosis never disturbs the card. */ }
+        };
+        addEventListener('load', function () { record.report('load'); });
+        addEventListener('pagehide', function () { record.report('pagehide'); }, {once: true});
+        setTimeout(function () { if (!record.settled) record.report('timeout'); }, 15000);
       })();
     </script>
     <meta name="viewport" content="width=device-width, initial-scale=1" />
diff --git a/apps/mcp/test/browser.ts b/apps/mcp/test/browser.ts
index bd0928ef..a5d38a23 100644
--- a/apps/mcp/test/browser.ts
+++ b/apps/mcp/test/browser.ts
@@ -34,6 +34,7 @@ const check = (name: string, f: () => void) => { f(); checks.push({name, pass: t
 let browser: any, host: any, child: any, beacon: any, service: any, mcpClient: Client | undefined;
 const served = new Map<string, string>();
 const beacons: string[] = [];
+const viewReportLines: string[] = [];
 const requests: {url: string; from: string}[] = [];
 
 async function main() {
@@ -104,7 +105,7 @@ async function main() {
   await page.setViewportSize({width: 1700, height: 9000});
   page.setDefaultTimeout(7000);
   page.on('pageerror', e => errors.push(String(e)));
-  page.on('console', m => { if (m.type() === 'error') errors.push(`console: ${m.text()}`); });
+  page.on('console', m => { if (m.type() === 'error') errors.push(`console: ${m.text()}`); if (m.text().startsWith('[ansari-view]')) viewReportLines.push(m.text()); });
   // Runtime networking is unavailable to the view: only the host fixture and the view document are reachable.
   const allowedOrigins = () => [`http://127.0.0.1:${ports[0]}`, `http://127.0.0.1:${ports[1]}`, diagnosticsOrigin];
   await context.route('**/*', (route: any) => {
@@ -811,18 +812,24 @@ async function main() {
     assert.equal(opensAfter, opensBefore);
   });
 
-  // ---- First-load diagnosis: a Dev card reports how far it got, in a shape the server accepts --------
-  // Every card above made no request (network check). Only a card served with a diagnostics origin sends reports.
-  assert.deepEqual(beacons, [], 'a production card sends no diagnostics');
-  const diagnostic = await openView(760, 900, prepareAnswerView(html, undefined, diagnosticsOrigin).html);
+  // ---- First-load diagnosis: a diagnostic card reports how far it got, in a shape the server accepts --------
+  // Every card above is a closed card: it made no request (network check), sent no report and wrote no report line.
+  check('diagnostics:closed-cards-are-silent', () => {
+    assert.deepEqual(beacons, []);
+    assert.deepEqual(viewReportLines, []);
+  });
+  const diagnosticBytes = prepareAnswerView(html, undefined, diagnosticsOrigin).html;
+  const waitForReports = async (count: number) => { for (let waited = 0; beacons.length < count && waited < 4000; waited += 50) await new Promise(r => setTimeout(r, 50)); };
+  const diagnostic = await openView(760, 900, diagnosticBytes);
   await deliver(diagnostic.id, resultA);
   await diagnostic.frame.locator('[data-testid="answer-card"]').waitFor();
-  for (let waited = 0; beacons.length < 2 && waited < 3000; waited += 50) await new Promise(r => setTimeout(r, 50));
-  const reports = beacons.map(parseViewReport);
+  await waitForReports(3);
+  const reports = beacons.splice(0).map(parseViewReport);
   const lastReport = reports.at(-1);
-  check('diagnostics:dev-card-reports-ready-and-result-accepted-by-the-server', () => {
-    assert.ok(reports.length >= 2 && reports.every(r => r !== undefined), 'every report is exactly the accepted shape');
-    assert.deepEqual(reports.map(r => r!.reason), ['ready', 'result']);
+  check('diagnostics:card-reports-load-ready-and-result-accepted-by-the-server', () => {
+    assert.ok(reports.length === 3 && reports.every(r => r !== undefined), 'every report is exactly the accepted shape');
+    assert.deepEqual(reports.map(r => r!.reason).sort(), ['load', 'ready', 'result']);
+    assert.equal(lastReport!.reason, 'result');
     assert.equal(new Set(reports.map(r => r!.view)).size, 1, 'one card, one id');
     // The one known violation: zod's capability probe (`try { new Function('') } catch`) under the card's script-src,
     // which has no 'unsafe-eval'. It is caught and harmless; any other error, rejection or violation fails here.
@@ -834,9 +841,25 @@ async function main() {
     assert.ok(m.script! <= m.main! && m.main! <= m.hostMessage! && m.hostMessage! <= m.context! && m.fonts! <= m.ready! && m.context! <= m.ready!);
     assert.ok(m.ready! <= m.result! && m.toolResult! <= m.result!);
   });
-  check('diagnostics:reports-carry-no-answer-text', () => assert.ok(!beacons.join('').includes(ANSWER_A.slice(0, 40))));
+  check('diagnostics:reports-carry-no-answer-text', () => assert.ok(!JSON.stringify(reports).includes(ANSWER_A.slice(0, 40))));
   evidence.diagnostics = lastReport;
 
+  // A bundle that fails before it runs: the early script still reports, and the report shows the bundle never ran.
+  const bundle = /(<script type="module"[^>]*>)[\s\S]*?(<\/script>)/;
+  assert.ok(bundle.test(diagnosticBytes), 'the card has one inline module bundle');
+  const brokenBundle = diagnosticBytes.replace(bundle, '$1export const broken = ;$2');
+  const broken = await openStartFailure(brokenBundle, true);
+  await waitForReports(1);
+  const brokenReport = parseViewReport(beacons.splice(0)[0] ?? '');
+  check('diagnostics:a-bundle-that-never-runs-is-still-reported', () => {
+    assert.equal(brokenReport?.reason, 'load');
+    assert.equal(typeof brokenReport?.marks.script, 'number');
+    assert.equal(brokenReport?.marks.main, undefined, 'the bundle never evaluated');
+    assert.ok(brokenReport?.errors.some(e => e.type === 'error' && e.name === 'SyntaxError'), JSON.stringify(brokenReport?.errors));
+  });
+  await page.evaluate(id => document.getElementById(id)?.remove(), broken.id);
+  errors.splice(0, errors.length, ...errors.filter(e => !/SyntaxError|Unexpected token/.test(e)));
+
   const states = await page.evaluate(() => Array.from(document.querySelectorAll('iframe')).map(f => (window as any).hostProbe.state(f.id)));
   check('host:no-view-initiated-tool-calls-and-no-host-errors', () => {
     for (const s of states) { assert.equal(s.answerCalls, 0); assert.deepEqual(s.hostErrors, []); }
diff --git a/apps/mcp/test/diagnostics.test.ts b/apps/mcp/test/diagnostics.test.ts
index dd423ffc..66d91d25 100644
--- a/apps/mcp/test/diagnostics.test.ts
+++ b/apps/mcp/test/diagnostics.test.ts
@@ -3,7 +3,9 @@ import {test} from 'node:test';
 import {createFetchApp} from '../src/server/fetch-app.ts';
 import type {OperationRecord} from '../src/server/operation-log.ts';
 import {settingsFromEnv} from '../src/server/runtime-config.ts';
-import {VIEW_DIAGNOSTICS_PATH, prepareAnswerView} from '../src/server/view-artifact.ts';
+import {MAX_INSPECTED_BODY, readBounded} from '../src/server/exchange-log.ts';
+import {VIEW_DIAGNOSTICS_META, VIEW_DIAGNOSTICS_PATH, prepareAnswerView} from '../src/server/view-artifact.ts';
+import {VIEW_REPORTS_PER_MINUTE} from '../src/server/view-report.ts';
 
 // First-load diagnosis (#335): what the server and the card record, and the Dev-only beacon channel.
 const CSP = `<meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'unsafe-inline'; connect-src 'none'; frame-src 'none'">`;
@@ -23,11 +25,22 @@ function harness(env: Record<string, string> = {}, complete: () => Promise<strin
     body: JSON.stringify({jsonrpc: '2.0', id: ++id, method, params}),
   }));
   const beacon = (body: string, headers: Record<string, string> = {}) => app.fetch(new Request(`http://localhost${VIEW_DIAGNOSTICS_PATH}`, {
-    method: 'POST', headers: {host: 'localhost', 'content-type': 'text/plain', origin: 'https://sandbox.host.example', ...headers}, body,
-  }));
+    method: 'POST', headers: {host: 'localhost', 'content-type': 'text/plain', origin: 'https://sandbox.host.example', ...headers}, body, duplex: 'half',
+  } as RequestInit));
   return {app, logs, rpc, beacon};
 }
 
+/** A streamed body of `size` bytes with no Content-Length, delivered in 4 KiB chunks. */
+function streamOf(size: number): ReadableStream<Uint8Array> {
+  let sent = 0;
+  return new ReadableStream({pull(controller) {
+    if (sent >= size) { controller.close(); return; }
+    const chunk = new TextEncoder().encode('x'.repeat(Math.min(4096, size - sent)));
+    sent += chunk.byteLength;
+    controller.enqueue(chunk);
+  }});
+}
+
 const settled = async (response: Response) => { await response.text(); await new Promise(resolve => setTimeout(resolve, 0)); };
 const byRid = (logs: OperationRecord[], event: string, rpc: string) => logs.filter(r => r.event === event && r.rpc === rpc);
 
@@ -55,12 +68,18 @@ test('each MCP exchange records its method, card address, outcome, size and timi
     const [read, missing] = byRid(logs, 'mcp.response', 'resources/read');
     assert.equal(read.rid, current.rid, 'request and response lines share one id');
     assert.equal(read.status, 200);
-    assert.equal(read.outcome, 'complete');
+    assert.equal(read.stream, 'drained', 'the transport read the whole stream; delivery to the host is not claimed');
+    assert.equal(read.decoded, true);
     assert.equal(read.errorCode, undefined);
     assert.ok((read.bytes as number) > html.length, 'the card read reports the bytes actually sent');
     assert.equal(typeof read.ms, 'number');
     assert.equal(typeof read.headersMs, 'number');
-    assert.equal(missing.errorCode, -32602, 'a stale card read is a JSON-RPC error inside an HTTP 200');
+    assert.equal(missing.status, 200);
+    assert.equal(missing.errorCode, -32602, 'a stale card read is a decoded JSON-RPC error inside an HTTP 200');
+    const prepared = logs.find(r => r.event === 'view.prepared')!;
+    assert.equal(prepared.uri, uri, 'the served card identity is recorded once at start');
+    assert.equal(prepared.diagnostics, false);
+    assert.equal(prepared.connectDomains, '');
     for (const record of logs.filter(r => r.event === 'mcp.request')) assert.equal(record.method, 'POST', 'the request line keeps the HTTP verb in `method`');
     const serialized = JSON.stringify(logs);
     assert.ok(!serialized.includes(QUESTION) && !serialized.includes(ANSWER), 'no question or answer text is logged');
@@ -76,7 +95,7 @@ test('a client that hangs up mid-response is recorded as cancelled', async () =>
     await response.body!.cancel();
     release();
     for (let waited = 0; !byRid(logs, 'mcp.response', 'tools/call').length && waited < 1000; waited += 10) await new Promise(r => setTimeout(r, 10));
-    assert.equal(byRid(logs, 'mcp.response', 'tools/call')[0]?.outcome, 'cancelled');
+    assert.equal(byRid(logs, 'mcp.response', 'tools/call')[0]?.stream, 'cancelled');
   } finally { await app.close(); }
 });
 
@@ -98,7 +117,7 @@ test('without a diagnostics origin the card, its address and its permissions are
   assert.equal(settingsFromEnv({}).viewDiagnosticsOrigin, undefined);
   const plain = prepareAnswerView(html, 'r1');
   assert.deepEqual(prepareAnswerView(html, 'r1', undefined), plain);
-  assert.ok(!plain.html.includes('data-diagnostics'));
+  assert.ok(!plain.html.includes(VIEW_DIAGNOSTICS_META));
   assert.ok(plain.html.includes("connect-src 'none'"));
   assert.deepEqual(plain.csp.connectDomains, []);
   const {app, beacon} = harness();
@@ -109,7 +128,7 @@ test('a diagnostics origin opens exactly one connect origin and stamps the beaco
   const settings = settingsFromEnv({MCP_VIEW_DIAGNOSTICS_ORIGIN: `${ORIGIN}/`});
   assert.equal(settings.viewDiagnosticsOrigin, ORIGIN);
   const view = prepareAnswerView(html, 'r1', ORIGIN);
-  assert.ok(view.html.includes(`data-diagnostics="${ORIGIN}${VIEW_DIAGNOSTICS_PATH}"`));
+  assert.ok(view.html.startsWith(`<html><head><meta name="${VIEW_DIAGNOSTICS_META}" content="${ORIGIN}${VIEW_DIAGNOSTICS_PATH}">`), 'the address precedes everything in head, so the early script can read it');
   assert.ok(view.html.includes(`connect-src ${ORIGIN};`));
   assert.ok(!view.html.includes("connect-src 'none'"));
   assert.deepEqual(view.csp.connectDomains, [ORIGIN]);
@@ -139,6 +158,7 @@ test('the beacon accepts only the fixed report shape and logs it without free te
     assert.equal(logged.failure, 'connect');
     assert.equal(logged.host, 'Claude');
     assert.equal(logged.origin, 'sandbox.host.example');
+    assert.equal(logged.clientAuthored, true, 'a report is marked as untrusted client input');
     assert.deepEqual(logged.marks, {script: 12, main: 411, fonts: 1300, context: 980});
     assert.deepEqual(logged.errors, [{type: 'csp', directive: 'connect-src', blocked: 'https'}, {type: 'error', name: 'TypeError'}]);
     assert.ok(!JSON.stringify(logs).includes(ANSWER), 'free text in a report is never logged');
@@ -147,6 +167,47 @@ test('the beacon accepts only the fixed report shape and logs it without free te
       assert.equal((await beacon(bad)).status, 400, bad);
     }
     assert.equal((await beacon('x'.repeat(9000))).status, 413);
-    assert.equal(logs.filter(r => r.event === 'view.report.invalid').length, 5);
+    assert.equal((await beacon(streamOf(9000) as unknown as string, {})).status, 413, 'the size bound holds without a Content-Length');
+    assert.equal(logs.filter(r => r.event === 'view.report.invalid').length, 6);
   } finally { await app.close(); }
 });
+
+test('request inspection is bounded by bytes read, not by the declared length, and never blocks the exchange', async () => {
+  const {app, logs} = harness();
+  try {
+    const response = await app.fetch(new Request('http://localhost/mcp', {
+      method: 'POST', headers: {host: 'localhost', 'content-type': 'application/json', accept: 'application/json, text/event-stream'},
+      body: streamOf(2 * MAX_INSPECTED_BODY), duplex: 'half',
+    } as RequestInit));
+    await response.text();
+    for (let waited = 0; !logs.some(r => r.event === 'mcp.response') && waited < 1000; waited += 10) await new Promise(r => setTimeout(r, 10));
+    assert.equal(logs.find(r => r.event === 'mcp.request')?.rpc, 'oversize');
+    assert.equal(logs.find(r => r.event === 'mcp.response')?.rpc, 'oversize', 'the handler still answered the request');
+  } finally { await app.close(); }
+});
+
+test('beacon reports are limited per minute and the limit is noted once', async () => {
+  const {app, logs, beacon} = harness({MCP_VIEW_DIAGNOSTICS_ORIGIN: ORIGIN});
+  try {
+    const body = JSON.stringify({v: 1, id: 'abc123def456', release: 'r1', reason: 'load', marks: {script: 1}});
+    const statuses: number[] = [];
+    for (let i = 0; i < VIEW_REPORTS_PER_MINUTE + 3; i++) statuses.push((await beacon(body)).status);
+    assert.equal(statuses.filter(status => status === 204).length, VIEW_REPORTS_PER_MINUTE);
+    assert.deepEqual(statuses.slice(VIEW_REPORTS_PER_MINUTE), [429, 429, 429]);
+    assert.equal(logs.filter(r => r.event === 'view.report.limited').length, 1);
+    assert.equal(logs.find(r => r.event === 'view.prepared')?.diagnostics, true);
+    assert.equal(logs.find(r => r.event === 'view.prepared')?.connectDomains, ORIGIN);
+  } finally { await app.close(); }
+});
+
+test('a bounded read stops pulling once the limit is passed', async () => {
+  let pulled = 0;
+  const source = new ReadableStream<Uint8Array>({pull(controller) {
+    const chunk = new Uint8Array(4096);
+    pulled += chunk.byteLength;
+    controller.enqueue(chunk);
+  }}, {highWaterMark: 0});
+  const read = await readBounded(source, MAX_INSPECTED_BODY);
+  assert.ok('exceeded' in read);
+  assert.ok(pulled <= MAX_INSPECTED_BODY + 4096, `pulled ${pulled} bytes from an endless stream`);
+});

From 734d1b3c1a6274c224f266f4f6dc7bffa1ad874d Mon Sep 17 00:00:00 2001
From: Younes Abouelnagah <timeleft--@users.noreply.github.com>
Date: Fri, 30 Oct 2026 07:47:18 -0400
Subject: [PATCH 3/4] feat(mcp): log levels, with measurement records only at
 debug

Every operation record now carries a level: error (mcp.error, source.error),
warn (rejected or rate-limited card reports), info (startup, mcp.request,
source.start, source.complete) or debug (the first-load measurement records).

MCP_LOG_LEVEL selects info (default) or debug; a diagnostic card implies debug
and contradicting it stops startup. At info the server neither inspects nor
wraps an exchange and writes the same records as before this experiment, plus
the level and error names and codes. The inspected request summary moves from
mcp.request to a separate debug mcp.rpc record, so dropping debug lines from a
measured deployment leaves exactly the unmeasured records; a test checks this
and fails when measuring is forced on.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 apps/mcp/README.md                       | 19 ++++--
 apps/mcp/scripts/first-load-timeline.mjs |  9 ++-
 apps/mcp/src/node/http-server.ts         |  1 +
 apps/mcp/src/node/index.ts               |  2 +-
 apps/mcp/src/server/create-server.ts     |  6 +-
 apps/mcp/src/server/fetch-app.ts         | 36 +++++++-----
 apps/mcp/src/server/operation-log.ts     |  7 +++
 apps/mcp/src/server/runtime-config.ts    | 18 +++++-
 apps/mcp/src/worker/index.ts             |  1 +
 apps/mcp/test/diagnostics.test.ts        | 74 ++++++++++++++++++++----
 apps/mcp/test/operation-log.test.ts      |  1 +
 apps/mcp/turbo.json                      |  2 +
 12 files changed, 137 insertions(+), 39 deletions(-)

diff --git a/apps/mcp/README.md b/apps/mcp/README.md
index 314be6e2..344f2aad 100644
--- a/apps/mcp/README.md
+++ b/apps/mcp/README.md
@@ -95,7 +95,8 @@ The Worker takes the variables in the table below as Wrangler `vars` or secrets,
 | `MCP_ALLOWED_ORIGINS` | Comma-separated allowed browser origin hostnames. A configured list replaces defaults; an explicitly empty list permits no Origin header value. Requests without Origin remain supported. |
 | `MCP_RESPONSE_MODE` | `json` for modern MCP final-answer-only responses; otherwise SSE, which supports client-requested progress notifications. Older-host compatibility responses may use SSE. |
 | `ANSARI_RELEASE` | Optional safe release identifier, embedded in served HTML and health/log records. |
-| `MCP_VIEW_DIAGNOSTICS_ORIGIN` | Set only on a deployment being diagnosed: its own public origin, such as `https://ansari-mcp-development.up.railway.app`. The card may then connect to that one origin and reports its start-up milestones to `POST /diag/view`; this changes the card's bytes, address and permissions. Unset, the card, its address and its closed permissions are unchanged and the route does not exist. A value that is not a bare `https` origin (`http` only for localhost) stops startup. See [First-load diagnosis](#first-load-diagnosis). |
+| `MCP_VIEW_DIAGNOSTICS_ORIGIN` | Set only on a deployment being diagnosed: its own public origin, such as `https://ansari-mcp-development.up.railway.app`. The card may then connect to that one origin and reports its start-up milestones to `POST /diag/view`; this changes the card's bytes, address and permissions. Unset, the card, its address and its closed permissions are unchanged and the route does not exist. A value that is not a bare `https` origin (`http` only for localhost) stops startup. Implies `MCP_LOG_LEVEL=debug`. See [First-load diagnosis](#first-load-diagnosis). |
+| `MCP_LOG_LEVEL` | `info` (default) or `debug`. `debug` also writes the first-load measurement records; set it only on a deployment being measured. Any other value, or `info` together with `MCP_VIEW_DIAGNOSTICS_ORIGIN`, stops startup. |
 
 `POST /mcp` serves stateless MCP requests through Hono and the official MCP request handler. Modern requests need no initialization; older hosts can use the handler’s stateless compatibility path. No MCP session IDs, session map, expiry timer or replay store are retained. `GET /mcp` and `DELETE /mcp` return 405. `/health` exposes the release. The HTML is supplied by the hosting target (read from `dist/` at Node start, bundled into the Worker), revision-stamped and fingerprinted once before the first request is served: the release is stamped first, so equal final bytes have equal identities and a release change legitimately changes the hash. Each request creates its own lightweight MCP server using that prepared view; resource bytes and identity stay fixed until restart. No demo, font server, alternative renderer or historical resource is served. Tool calls have a fresh 60-second budget; timeout yields a safe error and leaves subsequent calls usable. The same lifetime signal aborts the upstream fetch and response-body read when the request ends or the budget expires.
 
@@ -109,8 +110,15 @@ the host gave up before the card showed anything. The aim is to locate the first
 the card's start, the host handshake, tool-result arrival and the first rendered answer, where that step can be
 observed at all. After the trials, this is removed or narrowed to what proved useful.
 
-**Server records, always on.** Each `/mcp` exchange writes `mcp.request` and `mcp.response` lines joined by `rid`. The
-request is inspected from a copy, alongside the handler and up to 64 KiB actually read, so inspection never holds up
+**Log levels.** Every record carries a `level`. `error`: `mcp.error` and `source.error`, by error name and code only.
+`warn`: rejected or rate-limited card reports. `info`: the operational records (`startup`, `mcp.request` with the HTTP
+method, `source.start`, `source.complete`). `debug`: the measurement records below, written only with
+`MCP_LOG_LEVEL=debug`. At `info` the server neither inspects nor wraps an exchange, and it writes the records of a
+deployment without this experiment, plus a level on each and error
+names and codes; dropping the `debug` lines from a measured deployment leaves the same records.
+
+**Server records, while measuring.** Each `/mcp` exchange also writes `mcp.rpc` and `mcp.response` lines joined by
+`rid`. The request is inspected from a copy, alongside the handler and up to 64 KiB actually read, so inspection never holds up
 or alters the exchange; a larger body is recorded as `oversize`. The request line names the JSON-RPC method; for a card
 read, the address read and whether it is the one this instance serves (`uriCurrent`); for the handshake, the client's
 name, version and protocol; for a tool call, the tool name. The response line has the HTTP status, bytes, time to
@@ -118,7 +126,8 @@ headers and total time, and `stream`: whether this side's response stream was `d
 is not proof the host received or rendered it. Responses up to 64 KiB are decoded as JSON-RPC for an error code; a
 stale card read is `-32602` inside an HTTP 200. At start, `view.prepared` records the served card's address, size,
 whether it is a diagnostic card and its connect origins. Handler errors are logged by name and code. These records hold
-no question, answer or other parameter value.
+no question, answer or other parameter value. A closed-card trial still needs these records: set
+`MCP_LOG_LEVEL=debug` and leave `MCP_VIEW_DIAGNOSTICS_ORIGIN` unset.
 
 **Card reports, diagnostic card only.** With `MCP_VIEW_DIAGNOSTICS_ORIGIN` set, the served card carries an
 `ansari-diagnostics` address in its head, may connect to that one origin, and changes bytes, address and permissions.
@@ -129,7 +138,7 @@ stack's hooks add font loading, host-context delivery, how starting ended and th
 early script reports by itself at `load`, at `pagehide` and after 15 s without a start, so a bundle that never runs is
 still reported; the bundle adds reports when the card is ready, fails, or renders its first answer or problem. Each
 report is an `[ansari-view]` console line and a beacon to `POST /diag/view`. The route accepts only the fixed report
-shape, at most 8 KiB and 120 reports a minute per instance, and logs `view.report` with `clientAuthored: true`: the
+shape, at most 8 KiB and 120 reports a minute per instance, and logs `view.report` (level `debug`) with `clientAuthored: true`: the
 shape limits what is logged, but anyone who can reach the route can send a report. Report fields are milestones,
 enumerated failures and error names; the stack still prints a callback's own error to the console, as before. One
 violation is expected on every load: zod's `new Function('')` capability probe under the card's `script-src`, which it
diff --git a/apps/mcp/scripts/first-load-timeline.mjs b/apps/mcp/scripts/first-load-timeline.mjs
index cd28070a..b02c3acd 100644
--- a/apps/mcp/scripts/first-load-timeline.mjs
+++ b/apps/mcp/scripts/first-load-timeline.mjs
@@ -6,6 +6,9 @@
 // Railway deployment logs (`railway logs --deployment --json`: `timestamp` and the record in `message`), or Railway
 // edge HTTP logs (`railway logs --http --json`: `timestamp`, path, status, duration and bytes).
 //
+// The server writes the records read here only while measuring (`MCP_LOG_LEVEL=debug`, which a diagnostic card
+// implies); their `level` is `debug`. Without them a window shows only edge and operational lines.
+//
 // Records are attributed to a trial by time only: neither a server `rid` nor a card id links to the host's attempt.
 // The timeline therefore says what was observed in each window, flags windows whose traffic may not be the trial's,
 // and never claims that something did not happen anywhere.
@@ -39,7 +42,7 @@ const trials = lines(trialsFile);
 function describe(entry, zero) {
   const t = `+${((entry.at - zero) / 1000).toFixed(2)}s`.padStart(9);
   switch (entry.event) {
-    case 'mcp.request': return `${t} → ${entry.rpc}${entry.uri ? ` ${entry.uri}${entry.uriCurrent === false ? ' (NOT CURRENT)' : ''}` : ''}${entry.client ? ` client=${entry.client}/${entry.clientVersion}` : ''} [${entry.rid}]`;
+    case 'mcp.rpc': return `${t} → ${entry.rpc}${entry.uri ? ` ${entry.uri}${entry.uriCurrent === false ? ' (NOT CURRENT)' : ''}` : ''}${entry.client ? ` client=${entry.client}/${entry.clientVersion}` : ''} [${entry.rid}]`;
     case 'mcp.response': return `${t} ← ${entry.rpc} ${entry.status} stream=${entry.stream} ${entry.bytes}B headers=${entry.headersMs}ms total=${entry.ms}ms${entry.errorCode === undefined ? '' : ` error=${entry.errorCode}`} [${entry.rid}]`;
     case 'view.report': return `${t} ◆ card ${entry.view} ${entry.reason}${entry.failure ? ` failure=${entry.failure}` : ''} host=${entry.host ?? '?'} origin=${entry.origin} marks=${JSON.stringify(entry.marks)}${entry.errors?.length ? ` errors=${JSON.stringify(entry.errors)}` : ''}`;
     case 'view.prepared': return `${t} ◇ serving ${entry.uri} ${entry.bytes}B diagnostics=${entry.diagnostics}`;
@@ -54,7 +57,7 @@ function describe(entry, zero) {
 /** What one attempt's window shows. Each finding is an observation in that window, not a claim about the host. */
 function findings(window, card) {
   const out = [];
-  const reads = window.filter(entry => entry.event === 'mcp.request' && entry.rpc === 'resources/read');
+  const reads = window.filter(entry => entry.event === 'mcp.rpc' && entry.rpc === 'resources/read');
   const readEnds = window.filter(entry => entry.event === 'mcp.response' && entry.rpc === 'resources/read');
   if (reads.length === 0) out.push('no card read was observed at the server in this window');
   if (reads.some(entry => entry.uriCurrent === false)) out.push('a card address that is not the one this instance serves was read');
@@ -79,7 +82,7 @@ function findings(window, card) {
 /** Signs that a window holds traffic other than this trial's, so its records cannot be attributed with confidence. */
 function ambiguity(window, trial) {
   const out = [];
-  const clients = new Set(window.filter(entry => entry.event === 'mcp.request' && entry.client).map(entry => `${entry.client}/${entry.clientVersion}`));
+  const clients = new Set(window.filter(entry => entry.event === 'mcp.rpc' && entry.client).map(entry => `${entry.client}/${entry.clientVersion}`));
   if (clients.size > 1) out.push(`${clients.size} different MCP clients: ${[...clients].join(', ')}`);
   const overlapping = trials.filter(other => other !== trial && Date.parse(other.start) < Date.parse(trial.end) && Date.parse(other.end) > Date.parse(trial.start));
   if (overlapping.length) out.push(`${overlapping.length} other trial(s) overlap this one`);
diff --git a/apps/mcp/src/node/http-server.ts b/apps/mcp/src/node/http-server.ts
index 73336017..b4b16e4f 100644
--- a/apps/mcp/src/node/http-server.ts
+++ b/apps/mcp/src/node/http-server.ts
@@ -44,6 +44,7 @@ export function createHttpServer(options: ListenOptions = {}) {
     logger: options.logger ?? defaultOperationLogger,
     requestMs: options.requestMs,
     viewDiagnosticsOrigin: settings.viewDiagnosticsOrigin,
+    logLevel: settings.logLevel,
   });
 
   // The adapter's default createServer is Node's HTTP/1 server.
diff --git a/apps/mcp/src/node/index.ts b/apps/mcp/src/node/index.ts
index be7b8b12..41e5dd8e 100644
--- a/apps/mcp/src/node/index.ts
+++ b/apps/mcp/src/node/index.ts
@@ -2,7 +2,7 @@ import {defaultOperationLogger, listen} from './http-server.js';
 import {writeOperationLog} from '../server/operation-log.js';
 import {releaseFromEnv} from '../server/runtime-config.js';
 const service = await listen();
-writeOperationLog({event: 'startup', port: service.port}, defaultOperationLogger, releaseFromEnv(process.env));
+writeOperationLog({level: 'info', event: 'startup', port: service.port}, defaultOperationLogger, releaseFromEnv(process.env));
 for (const signal of ['SIGINT', 'SIGTERM'] as const) {
   process.once(signal, () => { void service.close().then(() => process.exit(0)); });
 }
diff --git a/apps/mcp/src/server/create-server.ts b/apps/mcp/src/server/create-server.ts
index b3aaaac5..b58e4576 100644
--- a/apps/mcp/src/server/create-server.ts
+++ b/apps/mcp/src/server/create-server.ts
@@ -44,7 +44,7 @@ export function createAnsariMcpServer(options:CreateMcpServerOptions):McpServer{
     view:options.view,
     failures:{absent:TOOL_UNAVAILABLE_TEXT,unavailable:TOOL_UNAVAILABLE_TEXT,invalidOutput:TOOL_UNAVAILABLE_TEXT},
     async handle({question},request){
-      writeOperationLog({event:'source.start',method:'tools/call'},options.logger,options.release);
+      writeOperationLog({level:'info',event:'source.start',method:'tools/call'},options.logger,options.release);
       await request.reportProgress({progress:0,total:1});
       // Source records do not claim terminal MCP delivery or upstream abortion.
       let answer:string;
@@ -52,10 +52,10 @@ export function createAnsariMcpServer(options:CreateMcpServerOptions):McpServer{
         answer=await options.completer.complete({question,signal:request.signal});
       } catch (error) {
         // Record source failure without inspecting or serializing the exception.
-        writeOperationLog({event:'source.error',method:'tools/call'},options.logger,options.release);
+        writeOperationLog({level:'error',event:'source.error',method:'tools/call'},options.logger,options.release);
         throw error;
       }
-      writeOperationLog({event:'source.complete',method:'tools/call',...answerFingerprint(answer)},options.logger,options.release);
+      writeOperationLog({level:'info',event:'source.complete',method:'tools/call',...answerFingerprint(answer)},options.logger,options.release);
       return {kind:'record' as const,record:{question,answer}};
     },
     project:record=>({text:record.answer,data:{version:ANSWER_ENVELOPE_VERSION,question:record.question,answer:record.answer}}),
diff --git a/apps/mcp/src/server/fetch-app.ts b/apps/mcp/src/server/fetch-app.ts
index d181cfe1..8b82aa64 100644
--- a/apps/mcp/src/server/fetch-app.ts
+++ b/apps/mcp/src/server/fetch-app.ts
@@ -6,7 +6,7 @@ import {createAnsariMcpServer} from './create-server.js';
 import {errorIdentity, inspectRequest, observeResponse, readBounded} from './exchange-log.js';
 import {VIEW_DIAGNOSTICS_PATH, prepareAnswerView} from './view-artifact.js';
 import {MAX_VIEW_REPORT_BYTES, VIEW_REPORTS_PER_MINUTE, originHost, parseViewReport} from './view-report.js';
-import {type OperationLogger, writeOperationLog} from './operation-log.js';
+import {type OperationLogger, type OperationRecord, writeOperationLog} from './operation-log.js';
 
 export const MCP_PATH = '/mcp';
 
@@ -26,6 +26,8 @@ export type FetchAppOptions = {
   requestMs?: number;
   /** Dev-only: the public origin a diagnostic card reports its milestones to (see `VIEW_DIAGNOSTICS_PATH`). */
   viewDiagnosticsOrigin?: string;
+  /** `debug` writes the first-load measurement records too; the default `info` writes only the operational ones. */
+  logLevel?: 'info' | 'debug';
 };
 
 export type FetchApp = {
@@ -36,34 +38,40 @@ export type FetchApp = {
 /** One Hono application over the official stateless MCP handler. Hosting adapters only supply a listener or an entry point. */
 export function createFetchApp(options: FetchAppOptions): FetchApp {
   const {completer, logger, release} = options;
-  const log = (record: Parameters<typeof writeOperationLog>[0]) => writeOperationLog(record, logger, release);
+  // Measuring adds `debug` records and inspects each exchange; otherwise the exchange is passed straight through.
+  const measuring = options.logLevel === 'debug';
+  const log = (record: OperationRecord) => {
+    if (record.level !== 'debug' || measuring) writeOperationLog(record, logger, release);
+  };
   // The view is prepared once: release stamping first, then the resource identity from the final bytes.
   const view = prepareAnswerView(options.html, release, options.viewDiagnosticsOrigin);
   // The official handler owns per-request transports, protocol negotiation and cleanup.
   // Both modern MCP and its older-host fallback are stateless; only the prepared view is shared.
   const mcp = createMcpHandler(
     () => createAnsariMcpServer({completer, view, logger, release, requestMs: options.requestMs}),
-    {responseMode: options.enableJsonResponse ? 'json' : 'sse', onerror: (error: unknown) => log({event: 'mcp.error', ...errorIdentity(error)})},
+    {responseMode: options.enableJsonResponse ? 'json' : 'sse', onerror: (error: unknown) => log({level: 'error', event: 'mcp.error', ...errorIdentity(error)})},
   );
   const app = new Hono();
   app.get('/health', c => c.json({ok: true, mcp: MCP_PATH, release}));
   app.use(MCP_PATH, hostHeaderValidation(options.allowedHosts));
   app.use(MCP_PATH, originValidation(options.allowedOrigins));
   // The exact card this instance serves: a diagnostic card differs from the closed one in bytes, address and permissions.
-  log({event: 'view.prepared', at: Date.now(), uri: view.uri, bytes: new TextEncoder().encode(view.html).byteLength, diagnostics: options.viewDiagnosticsOrigin !== undefined, connectDomains: view.csp.connectDomains.join(',')});
-  // One line when a request has been inspected and one when its response stream ends, joined by `rid`: which method a
-  // host called, which card address it read, and how the response stream ended (#335). Inspection reads a copy
-  // alongside the handler and never holds up or alters the exchange.
+  log({level: 'debug', event: 'view.prepared', at: Date.now(), uri: view.uri, bytes: new TextEncoder().encode(view.html).byteLength, diagnostics: options.viewDiagnosticsOrigin !== undefined, connectDomains: view.csp.connectDomains.join(',')});
   app.all(MCP_PATH, async c => {
+    log({level: 'info', event: 'mcp.request', method: c.req.method});
+    if (!measuring) return mcp.fetch(c.req.raw);
+    // While measuring, one line when the request has been inspected and one when its response stream ends, joined by
+    // `rid`: which method a host called, which card address it read, and how the response stream ended (#335).
+    // Inspection reads a copy alongside the handler and never holds up or alters the exchange.
     const started = Date.now();
     const rid = crypto.randomUUID().slice(0, 8);
     const inspected = inspectRequest(c.req.raw, view.uri);
-    void inspected.then(summary => log({event: 'mcp.request', at: started, method: c.req.method, rid, ...summary}));
+    void inspected.then(summary => log({level: 'debug', event: 'mcp.rpc', at: started, rid, ...summary}));
     const response = await mcp.fetch(c.req.raw);
     const headersMs = Date.now() - started;
     return observeResponse(response, end => {
       const ms = Date.now() - started;
-      void inspected.then(summary => log({event: 'mcp.response', at: Date.now(), rid, rpc: summary.rpc, status: response.status, headersMs, ms, ...end}));
+      void inspected.then(summary => log({level: 'debug', event: 'mcp.response', at: Date.now(), rid, rpc: summary.rpc, status: response.status, headersMs, ms, ...end}));
     });
   });
   if (options.viewDiagnosticsOrigin !== undefined) {
@@ -77,27 +85,27 @@ export function createFetchApp(options: FetchAppOptions): FetchApp {
       const now = Date.now();
       if (now - windowStart >= 60_000) { windowStart = now; windowCount = 0; }
       if (++windowCount > VIEW_REPORTS_PER_MINUTE) {
-        if (windowCount === VIEW_REPORTS_PER_MINUTE + 1) log({event: 'view.report.limited', perMinute: VIEW_REPORTS_PER_MINUTE});
+        if (windowCount === VIEW_REPORTS_PER_MINUTE + 1) log({level: 'warn', event: 'view.report.limited', perMinute: VIEW_REPORTS_PER_MINUTE});
         return c.body(null, 429);
       }
       const origin = originHost(c.req.header('origin') ?? null);
       const read = c.req.raw.body === null ? {text: ''} : await readBounded(c.req.raw.body, MAX_VIEW_REPORT_BYTES).catch(() => ({exceeded: true as const}));
       if ('exceeded' in read) {
-        log({event: 'view.report.invalid', reason: 'size', origin});
+        log({level: 'warn', event: 'view.report.invalid', reason: 'size', origin});
         return c.body(null, 413);
       }
       const report = parseViewReport(read.text);
       if (report === undefined) {
-        log({event: 'view.report.invalid', reason: 'shape', origin});
+        log({level: 'warn', event: 'view.report.invalid', reason: 'shape', origin});
         return c.body(null, 400);
       }
-      log({event: 'view.report', at: now, clientAuthored: true, origin, ...report});
+      log({level: 'debug', event: 'view.report', at: now, clientAuthored: true, origin, ...report});
       return c.body(null, 204);
     });
   }
   app.notFound(c => c.json({error: 'not found'}, 404));
   app.onError((error, c) => {
-    log({event: 'mcp.error', method: c.req.method, ...errorIdentity(error)});
+    log({level: 'error', event: 'mcp.error', method: c.req.method, ...errorIdentity(error)});
     return c.json({error: 'internal error'}, 500);
   });
   return {fetch: request => app.fetch(request), close: () => mcp.close()};
diff --git a/apps/mcp/src/server/operation-log.ts b/apps/mcp/src/server/operation-log.ts
index 03317010..d252ac7c 100644
--- a/apps/mcp/src/server/operation-log.ts
+++ b/apps/mcp/src/server/operation-log.ts
@@ -1,4 +1,11 @@
+/**
+ * How much a record matters. `debug` records exist only for first-load measurement (#335): they are written only
+ * while a deployment is configured to measure (`MCP_LOG_LEVEL=debug`), so a reader can drop them as one class.
+ */
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug';
+
 export type OperationRecord = {
+  level: LogLevel;
   event: string;
   method?: string;
   requestId?: string | number | null;
diff --git a/apps/mcp/src/server/runtime-config.ts b/apps/mcp/src/server/runtime-config.ts
index 1a67b84f..abea0728 100644
--- a/apps/mcp/src/server/runtime-config.ts
+++ b/apps/mcp/src/server/runtime-config.ts
@@ -1,4 +1,4 @@
-import {DEFAULT_RELEASE, SAFE_REVISION} from './operation-log.js';
+import {DEFAULT_RELEASE, SAFE_REVISION, type LogLevel} from './operation-log.js';
 
 /** Plain string settings: the Node environment, or the Workers `env` bindings. */
 export type RuntimeEnv = Readonly<Record<string, unknown>>;
@@ -28,6 +28,8 @@ export type EnvSettings = {
   enableJsonResponse: boolean;
   /** First-load diagnosis: the public origin the card's beacon reports to. Unset unless a deployment is being diagnosed. */
   viewDiagnosticsOrigin?: string;
+  /** The lowest level written: `debug` while a deployment is measured, `info` otherwise. */
+  logLevel: Extract<LogLevel, 'info' | 'debug'>;
   ansari: {baseUrl?: string; clientName?: string; authorization?: string};
 };
 
@@ -43,6 +45,16 @@ function diagnosticsOrigin(value: string | undefined): string | undefined {
   return url.origin;
 }
 
+/**
+ * `MCP_LOG_LEVEL` (`info` or `debug`). A diagnostic card implies `debug`, since its reports are debug records; asking
+ * for both a diagnostic card and `info` would drop every report, so it is a startup error.
+ */
+function logLevel(value: string | undefined, diagnosing: boolean): EnvSettings['logLevel'] {
+  if (value !== undefined && value !== 'info' && value !== 'debug') throw new Error(`MCP_LOG_LEVEL must be info or debug: ${JSON.stringify(value)}`);
+  if (diagnosing && value === 'info') throw new Error('MCP_LOG_LEVEL=info would drop the reports MCP_VIEW_DIAGNOSTICS_ORIGIN asks for; unset it or use debug');
+  return value ?? (diagnosing ? 'debug' : 'info');
+}
+
 /** Explicit overrides, then configured lists (including empty), then local defaults. */
 function allowedList(value: unknown, override: string[] | undefined, fallback: string[]): string[] {
   const selected = override ?? (typeof value === 'string' ? list(value) : fallback);
@@ -53,12 +65,14 @@ function allowedList(value: unknown, override: string[] | undefined, fallback: s
 export function settingsFromEnv(env: RuntimeEnv, overrides: {allowedHosts?: string[]; allowedOrigins?: string[]; enableJsonResponse?: boolean} = {}): EnvSettings {
   const allowedHosts = allowedList(env.MCP_ALLOWED_HOSTS, overrides.allowedHosts, DEFAULT_ALLOWED_HOSTS);
   const allowedOrigins = allowedList(env.MCP_ALLOWED_ORIGINS, overrides.allowedOrigins, allowedHosts);
+  const viewDiagnosticsOrigin = diagnosticsOrigin(setting(env, 'MCP_VIEW_DIAGNOSTICS_ORIGIN'));
   return {
     release: releaseFromEnv(env),
     allowedHosts,
     allowedOrigins,
     enableJsonResponse: overrides.enableJsonResponse ?? setting(env, 'MCP_RESPONSE_MODE') === 'json',
-    viewDiagnosticsOrigin: diagnosticsOrigin(setting(env, 'MCP_VIEW_DIAGNOSTICS_ORIGIN')),
+    viewDiagnosticsOrigin,
+    logLevel: logLevel(setting(env, 'MCP_LOG_LEVEL'), viewDiagnosticsOrigin !== undefined),
     ansari: {baseUrl: setting(env, 'ANSARI_API_BASE_URL'), clientName: setting(env, 'ANSARI_CLIENT'), authorization: setting(env, 'ANSARI_API_AUTHORIZATION')},
   };
 }
diff --git a/apps/mcp/src/worker/index.ts b/apps/mcp/src/worker/index.ts
index ce9c15df..d7fc276b 100644
--- a/apps/mcp/src/worker/index.ts
+++ b/apps/mcp/src/worker/index.ts
@@ -19,6 +19,7 @@ function applicationFor(env: RuntimeEnv): FetchApp {
     allowedOrigins: settings.allowedOrigins,
     enableJsonResponse: settings.enableJsonResponse,
     viewDiagnosticsOrigin: settings.viewDiagnosticsOrigin,
+    logLevel: settings.logLevel,
     logger: record => console.log(JSON.stringify(record)),
   });
   return app;
diff --git a/apps/mcp/test/diagnostics.test.ts b/apps/mcp/test/diagnostics.test.ts
index 66d91d25..6dd8dcbc 100644
--- a/apps/mcp/test/diagnostics.test.ts
+++ b/apps/mcp/test/diagnostics.test.ts
@@ -44,8 +44,10 @@ function streamOf(size: number): ReadableStream<Uint8Array> {
 const settled = async (response: Response) => { await response.text(); await new Promise(resolve => setTimeout(resolve, 0)); };
 const byRid = (logs: OperationRecord[], event: string, rpc: string) => logs.filter(r => r.event === event && r.rpc === rpc);
 
+const MEASURING = {MCP_LOG_LEVEL: 'debug'};
+
 test('each MCP exchange records its method, card address, outcome, size and timing without content', async () => {
-  const {app, logs, rpc} = harness();
+  const {app, logs, rpc} = harness(MEASURING);
   try {
     const listed = await rpc('tools/list');
     const uri = (JSON.parse((await listed.text()).replace(/^[\s\S]*?data: /, '')) as {result: {tools: {_meta: {ui: {resourceUri: string}}}[]}}).result.tools[0]._meta.ui.resourceUri;
@@ -54,16 +56,16 @@ test('each MCP exchange records its method, card address, outcome, size and timi
     await settled(await rpc('resources/read', {uri: STALE}));
     await settled(await rpc('tools/call', {name: 'answer_islamic_question', arguments: {question: QUESTION}}));
 
-    const [current, stale] = byRid(logs, 'mcp.request', 'resources/read');
+    const [current, stale] = byRid(logs, 'mcp.rpc', 'resources/read');
     assert.equal(current.uri, uri);
     assert.equal(current.uriCurrent, true);
     assert.equal(stale.uri, STALE);
     assert.equal(stale.uriCurrent, false, 'a card address from an earlier deploy is visible as such');
-    const initialize = byRid(logs, 'mcp.request', 'initialize')[0];
+    const initialize = byRid(logs, 'mcp.rpc', 'initialize')[0];
     assert.equal(initialize.client, 'probe-host');
     assert.equal(initialize.clientVersion, '9.1');
     assert.equal(initialize.protocol, '2025-06-18');
-    assert.equal(byRid(logs, 'mcp.request', 'tools/call')[0].tool, 'answer_islamic_question');
+    assert.equal(byRid(logs, 'mcp.rpc', 'tools/call')[0].tool, 'answer_islamic_question');
 
     const [read, missing] = byRid(logs, 'mcp.response', 'resources/read');
     assert.equal(read.rid, current.rid, 'request and response lines share one id');
@@ -80,7 +82,8 @@ test('each MCP exchange records its method, card address, outcome, size and timi
     assert.equal(prepared.uri, uri, 'the served card identity is recorded once at start');
     assert.equal(prepared.diagnostics, false);
     assert.equal(prepared.connectDomains, '');
-    for (const record of logs.filter(r => r.event === 'mcp.request')) assert.equal(record.method, 'POST', 'the request line keeps the HTTP verb in `method`');
+    for (const record of logs.filter(r => r.event === 'mcp.request')) assert.equal(record.method, 'POST', 'the operational request line keeps the HTTP verb');
+    for (const event of ['mcp.rpc', 'mcp.response', 'view.prepared']) assert.ok(logs.filter(r => r.event === event).every(r => r.level === 'debug'), event);
     const serialized = JSON.stringify(logs);
     assert.ok(!serialized.includes(QUESTION) && !serialized.includes(ANSWER), 'no question or answer text is logged');
   } finally { await app.close(); }
@@ -88,7 +91,7 @@ test('each MCP exchange records its method, card address, outcome, size and timi
 
 test('a client that hangs up mid-response is recorded as cancelled', async () => {
   let release!: () => void;
-  const {app, logs, rpc} = harness({}, () => new Promise(resolve => { release = () => resolve(ANSWER); }));
+  const {app, logs, rpc} = harness(MEASURING, () => new Promise(resolve => { release = () => resolve(ANSWER); }));
   try {
     const response = await rpc('tools/call', {name: 'answer_islamic_question', arguments: {question: QUESTION}});
     assert.equal(response.headers.get('content-type')?.startsWith('text/event-stream'), true);
@@ -99,20 +102,67 @@ test('a client that hangs up mid-response is recorded as cancelled', async () =>
   } finally { await app.close(); }
 });
 
-test('handler errors are logged by name and code only', async () => {
-  const {app, logs} = harness();
+test('an unparsable request is recorded as such', async () => {
+  const {app, logs} = harness(MEASURING);
   try {
     const response = await app.fetch(new Request('http://localhost/mcp', {
       method: 'POST', headers: {host: 'localhost', 'content-type': 'application/json', accept: 'application/json, text/event-stream'}, body: '{not json',
     }));
     await response.text();
-    const request = logs.find(r => r.event === 'mcp.request')!;
+    const request = logs.find(r => r.event === 'mcp.rpc')!;
     assert.equal(request.rpc, 'unparsed');
     const response_ = logs.find(r => r.event === 'mcp.response')!;
     assert.equal((response_.status as number) >= 400 || typeof response_.errorCode === 'number', true);
   } finally { await app.close(); }
 });
 
+/** One complete exchange: handshake, listing, card read, tool call. */
+async function exchange(rpc: ReturnType<typeof harness>['rpc']) {
+  await settled(await rpc('initialize', {protocolVersion: '2025-06-18', capabilities: {}, clientInfo: {name: 'probe-host', version: '9.1'}}));
+  const listed = await rpc('tools/list');
+  const uri = (JSON.parse((await listed.text()).replace(/^[\s\S]*?data: /, '')) as {result: {tools: {_meta: {ui: {resourceUri: string}}}[]}}).result.tools[0]._meta.ui.resourceUri;
+  await settled(await rpc('resources/read', {uri}));
+  await settled(await rpc('tools/call', {name: 'answer_islamic_question', arguments: {question: QUESTION}}));
+  for (let waited = 0; waited < 50; waited += 10) await new Promise(r => setTimeout(r, 10));
+}
+
+test('a deployment that is not measuring writes only the operational records', async () => {
+  const operational = harness();
+  const measured = harness(MEASURING);
+  try {
+    await exchange(operational.rpc);
+    await exchange(measured.rpc);
+    // The records a deployment without the experiment writes, each now with a level.
+    assert.deepEqual(operational.logs.map(r => [r.level, r.event, Object.keys(r).sort().join(',')]), [
+      ...['initialize', 'tools/list', 'resources/read'].map(() => ['info', 'mcp.request', 'event,level,method,release']),
+      ['info', 'mcp.request', 'event,level,method,release'],
+      ['info', 'source.start', 'event,level,method,release'],
+      ['info', 'source.complete', 'answerBytes,answerSha256,event,level,method,release'],
+    ]);
+    assert.deepEqual(measured.logs.filter(r => r.level !== 'debug'), operational.logs, 'dropping the debug lines leaves the same records');
+    assert.ok(measured.logs.some(r => r.level === 'debug'));
+    const levels = new Set(['error', 'warn', 'info', 'debug']);
+    assert.ok([...operational.logs, ...measured.logs].every(r => levels.has(r.level)), 'every record carries a level');
+  } finally { await operational.app.close(); await measured.app.close(); }
+});
+
+test('an upstream failure is logged at error level without its message', async () => {
+  const {app, logs, rpc} = harness({}, async () => { throw new Error(QUESTION); });
+  try {
+    await settled(await rpc('tools/call', {name: 'answer_islamic_question', arguments: {question: QUESTION}}));
+    assert.deepEqual(logs.filter(r => r.level === 'error').map(r => r.event), ['source.error']);
+    assert.ok(!JSON.stringify(logs).includes(QUESTION), 'neither the question nor the error message is logged');
+  } finally { await app.close(); }
+});
+
+test('the log level is info unless measuring, and contradictions stop startup', () => {
+  assert.equal(settingsFromEnv({}).logLevel, 'info');
+  assert.equal(settingsFromEnv({MCP_LOG_LEVEL: 'debug'}).logLevel, 'debug');
+  assert.equal(settingsFromEnv({MCP_VIEW_DIAGNOSTICS_ORIGIN: ORIGIN}).logLevel, 'debug', 'a diagnostic card implies debug');
+  assert.throws(() => settingsFromEnv({MCP_LOG_LEVEL: 'verbose'}), /MCP_LOG_LEVEL/);
+  assert.throws(() => settingsFromEnv({MCP_LOG_LEVEL: 'info', MCP_VIEW_DIAGNOSTICS_ORIGIN: ORIGIN}), /MCP_LOG_LEVEL=info/);
+});
+
 test('without a diagnostics origin the card, its address and its permissions are unchanged', async () => {
   assert.equal(settingsFromEnv({}).viewDiagnosticsOrigin, undefined);
   const plain = prepareAnswerView(html, 'r1');
@@ -159,6 +209,7 @@ test('the beacon accepts only the fixed report shape and logs it without free te
     assert.equal(logged.host, 'Claude');
     assert.equal(logged.origin, 'sandbox.host.example');
     assert.equal(logged.clientAuthored, true, 'a report is marked as untrusted client input');
+    assert.equal(logged.level, 'debug');
     assert.deepEqual(logged.marks, {script: 12, main: 411, fonts: 1300, context: 980});
     assert.deepEqual(logged.errors, [{type: 'csp', directive: 'connect-src', blocked: 'https'}, {type: 'error', name: 'TypeError'}]);
     assert.ok(!JSON.stringify(logs).includes(ANSWER), 'free text in a report is never logged');
@@ -169,11 +220,12 @@ test('the beacon accepts only the fixed report shape and logs it without free te
     assert.equal((await beacon('x'.repeat(9000))).status, 413);
     assert.equal((await beacon(streamOf(9000) as unknown as string, {})).status, 413, 'the size bound holds without a Content-Length');
     assert.equal(logs.filter(r => r.event === 'view.report.invalid').length, 6);
+    assert.ok(logs.filter(r => r.event === 'view.report.invalid').every(r => r.level === 'warn'));
   } finally { await app.close(); }
 });
 
 test('request inspection is bounded by bytes read, not by the declared length, and never blocks the exchange', async () => {
-  const {app, logs} = harness();
+  const {app, logs} = harness(MEASURING);
   try {
     const response = await app.fetch(new Request('http://localhost/mcp', {
       method: 'POST', headers: {host: 'localhost', 'content-type': 'application/json', accept: 'application/json, text/event-stream'},
@@ -181,7 +233,7 @@ test('request inspection is bounded by bytes read, not by the declared length, a
     } as RequestInit));
     await response.text();
     for (let waited = 0; !logs.some(r => r.event === 'mcp.response') && waited < 1000; waited += 10) await new Promise(r => setTimeout(r, 10));
-    assert.equal(logs.find(r => r.event === 'mcp.request')?.rpc, 'oversize');
+    assert.equal(logs.find(r => r.event === 'mcp.rpc')?.rpc, 'oversize');
     assert.equal(logs.find(r => r.event === 'mcp.response')?.rpc, 'oversize', 'the handler still answered the request');
   } finally { await app.close(); }
 });
diff --git a/apps/mcp/test/operation-log.test.ts b/apps/mcp/test/operation-log.test.ts
index 3e012c88..8bb5841f 100644
--- a/apps/mcp/test/operation-log.test.ts
+++ b/apps/mcp/test/operation-log.test.ts
@@ -17,6 +17,7 @@ describe('operation log', () => {
     const records: unknown[] = [];
     writeOperationLog(
       {
+        level: 'info',
         event: 'tool.start',
         method: 'tools/call',
         requestId: 10,
diff --git a/apps/mcp/turbo.json b/apps/mcp/turbo.json
index e6b02119..e3d96abd 100644
--- a/apps/mcp/turbo.json
+++ b/apps/mcp/turbo.json
@@ -34,6 +34,7 @@
         "MCP_ALLOWED_ORIGINS",
         "MCP_RESPONSE_MODE",
         "MCP_VIEW_DIAGNOSTICS_ORIGIN",
+        "MCP_LOG_LEVEL",
         "ANSARI_RELEASE",
         "RAILWAY_GIT_COMMIT_SHA"
       ],
@@ -50,6 +51,7 @@
         "MCP_ALLOWED_ORIGINS",
         "MCP_RESPONSE_MODE",
         "MCP_VIEW_DIAGNOSTICS_ORIGIN",
+        "MCP_LOG_LEVEL",
         "ANSARI_RELEASE",
         "RAILWAY_GIT_COMMIT_SHA"
       ],

From 58516770a302c512afa1ca89672c9338ae17e95e Mon Sep 17 00:00:00 2001
From: Younes Abouelnagah <timeleft--@users.noreply.github.com>
Date: Fri, 30 Oct 2026 08:29:59 -0400
Subject: [PATCH 4/4] fix(mcp): leave the closed card's start promise
 unobserved

watchStart attached handlers to the start promise in every card, so a closed
card's start failure was handled silently instead of surfacing as an unhandled
rejection, as it does without diagnostics. The closed card is the trials'
baseline, so it now attaches nothing when no diagnostic record exists.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 apps/mcp/src/view/diagnostics.ts | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/apps/mcp/src/view/diagnostics.ts b/apps/mcp/src/view/diagnostics.ts
index 3e7fa7ea..b16459c6 100644
--- a/apps/mcp/src/view/diagnostics.ts
+++ b/apps/mcp/src/view/diagnostics.ts
@@ -37,19 +37,20 @@ export function noteCallbackError(error: unknown, phase: string): void {
   if (record && record.errors.length < MAX_ERRORS) record.errors.push({type: 'callback', name: error instanceof Error ? error.name : typeof error, phase});
 }
 
-/** Reports once when the card has started, or failed to start. */
+/**
+ * Reports once when the card has started, or failed to start. A closed card attaches nothing, so a start failure
+ * still surfaces as an unhandled rejection, as it does without diagnostics.
+ */
 export function watchStart(ready: Promise<void>, failureKind: (failure: unknown) => string): void {
+  const record = diagnostic();
+  if (!record) return;
   ready.then(
     () => {
-      const record = diagnostic();
-      if (!record) return;
       record.settled = true;
       mark('ready');
       record.report('ready');
     },
     (error: unknown) => {
-      const record = diagnostic();
-      if (!record) return;
       record.settled = true;
       record.failure = failureKind(error);
       mark('failed');