diff --git a/apps/mcp/README.md b/apps/mcp/README.md
index b983f99b..344f2aad 100644
--- a/apps/mcp/README.md
+++ b/apps/mcp/README.md
@@ -95,11 +95,74 @@ 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. 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.
 
 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
+
+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.
+
+**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
+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. 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.
+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` (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
+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 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
+```
+
+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
 
 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..b02c3acd
--- /dev/null
+++ b/apps/mcp/scripts/first-load-timeline.mjs
@@ -0,0 +1,111 @@
+#!/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).
+//
+// 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.
+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 []; }
+});
+/** 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) {
+  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 trials = lines(trialsFile);
+
+function describe(entry, zero) {
+  const t = `+${((entry.at - zero) / 1000).toFixed(2)}s`.padStart(9);
+  switch (entry.event) {
+    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}`;
+    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 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.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');
+  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 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 (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.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 host message observed by its last report (${last.reason})`);
+  }
+  return out;
+}
+
+/** 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.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`);
+  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 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
new file mode 100644
index 00000000..acd62a0f
--- /dev/null
+++ b/apps/mcp/scripts/first-load-trial.sh
@@ -0,0 +1,59 @@
+#!/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
+# 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 <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
+
+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] " _
+}
+capture() {
+  local var="$1" question="$2" answer
+  printf '\n>>> %s\n' "$question"
+  read -r -p "    > " answer
+  printf -v "$var" '%s' "$answer"
+}
+
+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)"
+firstSeen="$(now)"
+retry="n-a"; retryAt=""; retrySeen=""
+if [ "$first" != "card" ]; then
+  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="$(now)"
+
+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/node/http-server.ts b/apps/mcp/src/node/http-server.ts
index 1367dd3c..b4b16e4f 100644
--- a/apps/mcp/src/node/http-server.ts
+++ b/apps/mcp/src/node/http-server.ts
@@ -43,6 +43,8 @@ export function createHttpServer(options: ListenOptions = {}) {
     enableJsonResponse: settings.enableJsonResponse,
     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/exchange-log.ts b/apps/mcp/src/server/exchange-log.ts
new file mode 100644
index 00000000..0a09752f
--- /dev/null
+++ b/apps/mcp/src/server/exchange-log.ts
@@ -0,0 +1,182 @@
+// 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 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 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}$/;
+
+export type RpcSummary = {
+  rpc: string;
+  requestId?: string | number;
+  uri?: string;
+  uriCurrent?: boolean;
+  client?: string;
+  clientVersion?: string;
+  protocol?: string;
+  tool?: string;
+};
+
+/**
+ * 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> : {};
+
+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);
+}
+
+/**
+ * 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 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;
+  const kept: Uint8Array[] = [];
+  const finish = (stream: StreamOutcome) => {
+    if (ended) return;
+    ended = true;
+    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('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('drained'); controller.close(); return; }
+        bytes += value.byteLength;
+        if (bytes <= MAX_DECODED_RESPONSE) kept.push(value);
+        else kept.length = 0;
+        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..8b82aa64 100644
--- a/apps/mcp/src/server/fetch-app.ts
+++ b/apps/mcp/src/server/fetch-app.ts
@@ -3,8 +3,10 @@ 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 {type OperationLogger, writeOperationLog} from './operation-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, VIEW_REPORTS_PER_MINUTE, originHost, parseViewReport} from './view-report.js';
+import {type OperationLogger, type OperationRecord, writeOperationLog} from './operation-log.js';
 
 export const MCP_PATH = '/mcp';
 
@@ -22,6 +24,10 @@ 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;
+  /** `debug` writes the first-load measurement records too; the default `info` writes only the operational ones. */
+  logLevel?: 'info' | 'debug';
 };
 
 export type FetchApp = {
@@ -32,26 +38,74 @@ 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);
+  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({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));
-  app.all(MCP_PATH, c => {
-    log({event: 'mcp.request', method: c.req.method});
-    return mcp.fetch(c.req.raw);
+  // The exact card this instance serves: a diagnostic card differs from the closed one in bytes, address and permissions.
+  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({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({level: 'debug', 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));
+    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 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({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({level: 'warn', event: 'view.report.invalid', reason: 'size', origin});
+        return c.body(null, 413);
+      }
+      const report = parseViewReport(read.text);
+      if (report === undefined) {
+        log({level: 'warn', event: 'view.report.invalid', reason: 'shape', origin});
+        return c.body(null, 400);
+      }
+      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((_, c) => {
-    log({event: 'mcp.error', method: c.req.method});
+  app.onError((error, c) => {
+    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 1b8e4a7b..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>>;
@@ -26,9 +26,35 @@ 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;
+  /** The lowest level written: `debug` while a deployment is measured, `info` otherwise. */
+  logLevel: Extract<LogLevel, 'info' | 'debug'>;
   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;
+}
+
+/**
+ * `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);
@@ -39,11 +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,
+    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/server/view-artifact.ts b/apps/mcp/src/server/view-artifact.ts
index d26b0bd0..74221e24 100644
--- a/apps/mcp/src/server/view-artifact.ts
+++ b/apps/mcp/src/server/view-artifact.ts
@@ -3,10 +3,28 @@ 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';
+/** 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. */
-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 (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(/<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.
   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..e1fd6494
--- /dev/null
+++ b/apps/mcp/src/server/view-report.ts
@@ -0,0 +1,71 @@
+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. 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);
+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..1c05d375
--- /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 = ['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
new file mode 100644
index 00000000..b16459c6
--- /dev/null
+++ b/apps/mcp/src/view/diagnostics.ts
@@ -0,0 +1,76 @@
+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 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 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?: DiagnosticRecord }
+}
+
+const MAX_ERRORS = 20;
+const diagnostic = (): DiagnosticRecord | undefined => window.__ansariDiag;
+
+export function mark(name: ViewMark): void {
+  const record = diagnostic();
+  if (record) record.marks[name] ??= performance.now();
+}
+
+export function noteHost(name: string | undefined): void {
+  const record = diagnostic();
+  if (record && name !== undefined) record.host ??= name;
+}
+
+export function noteCallbackError(error: unknown, phase: string): void {
+  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 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(
+    () => {
+      record.settled = true;
+      mark('ready');
+      record.report('ready');
+    },
+    (error: unknown) => {
+      record.settled = true;
+      record.failure = failureKind(error);
+      mark('failed');
+      record.report('failed');
+    },
+  );
+}
+
+/** 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(() => {
+      const record = diagnostic();
+      if (!record || kind === 'waiting') return;
+      const name = kind === 'answer' ? 'result' : 'problem';
+      if (record.marks[name] !== undefined) return;
+      mark(name);
+      record.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..5c48749f 100644
--- a/apps/mcp/src/view/mcp-app-react.html
+++ b/apps/mcp/src/view/mcp-app-react.html
@@ -2,6 +2,63 @@
 <html lang="en">
   <head>
     <meta charset="UTF-8" />
+    <script>
+      // 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: [], 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) {
+          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});
+        });
+        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;
+          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;
+        });
+        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" />
     <!--
       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..d7fc276b 100644
--- a/apps/mcp/src/worker/index.ts
+++ b/apps/mcp/src/worker/index.ts
@@ -18,6 +18,8 @@ function applicationFor(env: RuntimeEnv): FetchApp {
     allowedHosts: settings.allowedHosts,
     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/browser.ts b/apps/mcp/test/browser.ts
index 77f0a379..a5d38a23 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,10 @@ 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 viewReportLines: string[] = [];
 const requests: {url: string; from: string}[] = [];
 
 async function main() {
@@ -46,6 +49,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({
@@ -92,9 +105,9 @@ 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]}`];
+  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 +812,54 @@ async function main() {
     assert.equal(opensAfter, opensBefore);
   });
 
+  // ---- 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();
+  await waitForReports(3);
+  const reports = beacons.splice(0).map(parseViewReport);
+  const lastReport = reports.at(-1);
+  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.
+    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(!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, []); }
@@ -822,6 +883,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..6dd8dcbc
--- /dev/null
+++ b/apps/mcp/test/diagnostics.test.ts
@@ -0,0 +1,265 @@
+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 {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'">`;
+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, 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);
+
+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(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;
+    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.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.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.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');
+    assert.equal(read.status, 200);
+    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.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 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(); }
+});
+
+test('a client that hangs up mid-response is recorded as cancelled', async () => {
+  let release!: () => void;
+  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);
+    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]?.stream, 'cancelled');
+  } finally { await app.close(); }
+});
+
+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.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');
+  assert.deepEqual(prepareAnswerView(html, 'r1', undefined), plain);
+  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();
+  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.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]);
+  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.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');
+
+    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((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(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: 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.rpc')?.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`);
+});
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 226eadc1..e3d96abd 100644
--- a/apps/mcp/turbo.json
+++ b/apps/mcp/turbo.json
@@ -33,6 +33,8 @@
         "MCP_ALLOWED_HOSTS",
         "MCP_ALLOWED_ORIGINS",
         "MCP_RESPONSE_MODE",
+        "MCP_VIEW_DIAGNOSTICS_ORIGIN",
+        "MCP_LOG_LEVEL",
         "ANSARI_RELEASE",
         "RAILWAY_GIT_COMMIT_SHA"
       ],
@@ -48,6 +50,8 @@
         "MCP_ALLOWED_HOSTS",
         "MCP_ALLOWED_ORIGINS",
         "MCP_RESPONSE_MODE",
+        "MCP_VIEW_DIAGNOSTICS_ORIGIN",
+        "MCP_LOG_LEVEL",
         "ANSARI_RELEASE",
         "RAILWAY_GIT_COMMIT_SHA"
       ],