diff --git a/CHANGELOG.md b/CHANGELOG.md
index c94ec6f..c8baee3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Live SSE stream (`/platform/traces/stream`): a single connection multiplexes
   `trace` / `metrics` / `modules` / `summary` events pushed ~1×/s, with manual
   **Connect / Disconnect** stream control (`LIVE` / `PAUSED`).
+- Connection ack (`ready`): the platform states its identity and version, its
+  trace-ring `capacity`, whether traces/metrics are recording, and its push
+  period (`tickMs`) as the first frame of every connection. The header shows the
+  platform it is talking to and the real ring size, the module table says whether
+  metrics are off or merely idle instead of inferring it from an empty array, and
+  the silence watchdog is sized from the stated period rather than an assumed
+  1Hz. Platforms that send no ack are unchanged — the console reports what it was
+  not told as unknown.
 - Windowed header KPIs: the `summary` event drives the trend sub-lines (requests
   / error-rate / p95 vs the previous window) and the active-module split by
   isolation mode. Trend fields are nullable — a muted placeholder is shown
diff --git a/README.md b/README.md
index d798add..c7ac52e 100644
--- a/README.md
+++ b/README.md
@@ -55,6 +55,13 @@ in logs.
 - **Live SSE stream** — one connection to `/platform/traces/stream` multiplexes
   `trace` / `metrics` / `modules` / `summary` events pushed ~1×/s, with manual
   **Connect / Disconnect** control. Replaces the previous 5s REST polling.
+- **Connection ack** — the platform's `ready` frame names itself and its version,
+  states its trace-ring capacity, whether traces and per-module metrics are
+  recording, and its push period. The console reports those instead of assuming
+  them: the silence watchdog is sized from the stated period, the header prints
+  the stated ring size, and the module table stops guessing why it is empty. A
+  platform that sends no ack keeps working — the console then says it does not
+  know rather than falling back to a number nobody gave it.
 - **Live / sample auto-fallback** — when a platform is reachable, data is `live`;
   when none is running, the console falls back to grounded mock data so the UI is
   always explorable. The top bar shows a **LIVE** vs **SAMPLE DATA** badge.
@@ -180,15 +187,40 @@ src/
 ## Platform API surface
 
 The live path is a single SSE connection to `GET /platform/traces/stream`, which
-multiplexes four named events:
+opens with an acknowledgement and then multiplexes four named events:
 
 | Event | Maps to | Notes |
 |---|---|---|
+| `ready` | `StreamReady` | Connection ack, first frame, repeated on every reconnect. Optional: platforms that predate it are supported. |
 | `trace` | `RequestTrace[]` | Incremental delta since the last seq (initial snapshot on connect). |
 | `metrics` | `ModuleMetricsSnapshot[]` | Full per-module snapshot each tick. Opt-in via `protean.trace.metrics.enabled`. |
 | `modules` | `ModuleStatus[]` | Joined into the module table for isolation mode / trust tier. |
 | `summary` | `TraceSummary` | Windowed KPI aggregate + trend vs the previous window + active-module split by mode. |
 
+The `ready` ack is not a data frame. It carries what a client must learn once, at
+connect time, and cannot derive from the stream afterwards — on a quiet platform
+nothing else arrives at all, so it is also the only thing separating *the stream
+is open* from *the platform is running*:
+
+```
+event: ready
+data: {"platform":"protean","platformVersion":"0.1.0","tracesEnabled":true,
+       "metricsEnabled":false,"buffered":5,"tickMs":1000,"capacity":200}
+```
+
+| Field | What the console does with it |
+|---|---|
+| `platform` / `platformVersion` | Shown beside the origin in the header. **Display only** — no behaviour branches on which implementation answered. `null` version is rendered as unknown, never replaced with a guess. |
+| `tracesEnabled` / `metricsEnabled` | Separates "recording is off" from "recording is on and idle" — the two an empty panel cannot tell apart. `tracesEnabled` is read first: per-module metrics are aggregated from recorded requests, so with recording off no rows can appear whatever the metrics flag says. |
+| `buffered` | Read, but not acted on: it counts the rows of the `trace` frame that follows (not the ring's size), and those rows arrive regardless. |
+| `tickMs` | Sizes the silence watchdog (6 periods, clamped to 2–60s) instead of assuming 1Hz. |
+| `capacity` | The ring size as of this connection, printed in the `LIVE` badge. |
+
+Fields may be added later; the console ignores the ones it does not recognize.
+Every value is connection-scoped — the console drops them when the stream is
+rebuilt and re-learns them from the next ack, because they are live settings on
+the platform.
+
 The read-only REST surface (`GET /platform/traces`, `/platform/traces/metrics`,
 `/platform/modules`, `/platform/modules/{id}/routes`) is still mirrored in
 `api.ts` as a fallback and for the module-routes drawer.
diff --git a/src/App.tsx b/src/App.tsx
index 936d793..a11503f 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -32,7 +32,7 @@ export default function App() {
   const [selectedModuleId, setSelectedModuleId] = useState<string | null>(null)
 
   const { settings, save: saveSettings } = useSettings()
-  const { data, conn, channels, streaming, setStreaming } = useConsoleData(settings)
+  const { data, conn, channels, platform, streaming, setStreaming } = useConsoleData(settings)
   const disconnected = conn.status === 'disconnected'
 
   // Retain trace history in IndexedDB for a real platform; pass mock through.
@@ -68,6 +68,7 @@ export default function App() {
         onToggleTheme={toggle}
         conn={conn}
         channels={channels}
+        platform={platform}
         storage={traceStore.storage}
         settings={settings}
         onSaveSettings={saveSettings}
@@ -99,6 +100,8 @@ export default function App() {
             <ModuleTable
               metrics={data.metrics}
               modules={data.modules}
+              metricsEnabled={platform?.metricsEnabled ?? null}
+              tracesEnabled={platform?.tracesEnabled ?? null}
               sort={sort}
               onSort={setSort}
               selectedId={selectedModuleId}
@@ -108,7 +111,11 @@ export default function App() {
 
           {/* The trace table itself is left legible — dimming rows the operator is
               reading to find something is a poor trade. The note sits in its header. */}
-          <TraceTable store={traceStore} staleReason={staleTraceDerived} />
+          <TraceTable
+            store={traceStore}
+            staleReason={staleTraceDerived}
+            tracesEnabled={platform?.tracesEnabled ?? null}
+          />
 
           <footer className="font-mono text-[11px] leading-relaxed text-muted-foreground">
             Columns map 1:1 to the platform trace surface — rows are{' '}
diff --git a/src/components/latency-chart.test.tsx b/src/components/latency-chart.test.tsx
index 9f0c84a..6f1bd7a 100644
--- a/src/components/latency-chart.test.tsx
+++ b/src/components/latency-chart.test.tsx
@@ -1,6 +1,8 @@
-import { act, render, waitFor } from '@testing-library/react'
+import { act, cleanup, render, waitFor } from '@testing-library/react'
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 import { LatencyChart } from '@/components/latency-chart'
+import { StatusMix } from '@/components/status-mix'
+import type { RequestTrace } from '@/lib/types'
 import { useConsoleUnderTest } from '@/test/console-driver'
 import { GO_CONNECT, SPRING_CONNECT } from '@/test/stream-fixtures'
 import { FakeEventSource, installFakeEventSource, replay } from '@/test/sse-stream'
@@ -99,3 +101,74 @@ describe.each([
     expect(svg.querySelectorAll('circle').length).toBeGreaterThanOrEqual(1)
   })
 })
+
+describe('latency chart with no samples', () => {
+  // This file has no automatic cleanup (the scenarios above keep their renders), so
+  // these unmount themselves — two charts in one DOM make every text query ambiguous.
+  afterEach(cleanup)
+
+  /**
+   * An idle platform is the normal state of a console someone just opened, and the
+   * card used to vanish on it — taking half of the row it shares with the status
+   * mix and leaving a layout that looked broken rather than quiet.
+   *
+   * The frame is drawn instead. What must not appear with it is a shape: a line,
+   * an area or a point would all be data this console never received.
+   */
+  it('draws the frame but nothing to read as data', () => {
+    const { container } = render(<LatencyChart series={[]} />)
+    const svg = container.querySelector('svg')
+    expect(svg).not.toBeNull()
+    expect(svg!.querySelector('polyline')).toBeNull()
+    expect(svg!.querySelector('polygon')).toBeNull()
+    expect(svg!.querySelector('circle'), 'marked a sample that does not exist').toBeNull()
+  })
+
+  it('says the scale is a default rather than a measurement', () => {
+    // The axis numbers are this console's choice, not the platform's data. Left
+    // unlabelled they read as a measured range — which is the lie the vanished
+    // card at least never told.
+    const { getByText } = render(<LatencyChart series={[]} />)
+    expect(getByText(/default scale/)).toBeTruthy()
+    expect(getByText('No samples in this window yet')).toBeTruthy()
+  })
+
+  it('goes back to the measured scale as soon as a sample lands', () => {
+    const { container, getByText, rerender } = render(<LatencyChart series={[]} />)
+    rerender(<LatencyChart series={[12, 40]} />)
+    expect(getByText(/rolling window/)).toBeTruthy()
+    expect(container.querySelector('polyline')).not.toBeNull()
+  })
+})
+
+describe('status mix', () => {
+  afterEach(cleanup)
+
+  /**
+   * The header count and the bar geometry were one number, and the `|| 1` that
+   * keeps a width from dividing by zero was also what the header printed: an idle
+   * platform read "1 req" beside four zeroes, which is a request that never
+   * happened.
+   */
+  it('counts no requests as none', () => {
+    const { getByText } = render(<StatusMix traces={[]} />)
+    expect(getByText('0 req')).toBeTruthy()
+  })
+
+  it('still counts what did arrive', () => {
+    const t = (status: number, seq: number): RequestTrace => ({
+      seq,
+      epochMillis: 1789971324000 + seq,
+      method: 'GET',
+      uri: '/x',
+      pattern: null,
+      moduleId: null,
+      status,
+      latencyMs: 1,
+      error: null,
+      traceId: `dddd${seq}`,
+    })
+    const { getByText } = render(<StatusMix traces={[t(200, 1), t(404, 2), t(500, 3)]} />)
+    expect(getByText('3 req')).toBeTruthy()
+  })
+})
diff --git a/src/components/latency-chart.tsx b/src/components/latency-chart.tsx
index 625000d..976ffa7 100644
--- a/src/components/latency-chart.tsx
+++ b/src/components/latency-chart.tsx
@@ -22,17 +22,28 @@ function niceTicks(max: number, count = 4): number[] {
   return ticks
 }
 
+/**
+ * The axis an empty chart is drawn on.
+ *
+ * With no samples there is nothing to scale to, and the card used to disappear
+ * entirely — which left the row it shares with the status mix broken, and told a
+ * platform with no traffic yet that it had no chart. The frame is drawn instead,
+ * on a scale this console picked rather than measured, and the header says so:
+ * a chart whose numbers could be read as a measured range is worse than none.
+ */
+const EMPTY_SCALE_MAX = 100
+
 /** Single-series p95 latency area with a crosshair+tooltip. One hue (telemetry), no legend needed. */
 export function LatencyChart({ series }: { series: number[] }) {
   const gradId = useId()
   const svgRef = useRef<SVGSVGElement>(null)
   const [hover, setHover] = useState<number | null>(null)
   const n = series.length
+  const empty = n === 0
 
-  if (n === 0) return null
   // Nice round ticks give the scale; the top tick already clears the data max,
   // so the axis has headroom without an arbitrary multiplier.
-  const gridVals = niceTicks(Math.max(...series))
+  const gridVals = niceTicks(empty ? EMPTY_SCALE_MAX : Math.max(...series))
   const max = gridVals[gridVals.length - 1] || 1
   // A single bucket has no span to interpolate across — `i / (n - 1)` would be
   // 0/0 and poison every coordinate with NaN. Pin the lone sample to the right
@@ -41,9 +52,10 @@ export function LatencyChart({ series }: { series: number[] }) {
   const y = (v: number) => PAD.t + (1 - v / max) * (H - PAD.t - PAD.b)
 
   const pts = series.map((v, i) => `${x(i)},${y(v)}`).join(' ')
-  const area = `${PAD.l},${y(0)} ${pts} ${x(n - 1)},${y(0)}`
+  const area = empty ? '' : `${PAD.l},${y(0)} ${pts} ${x(n - 1)},${y(0)}`
 
   function onMove(e: React.PointerEvent<SVGSVGElement>) {
+    if (empty) return // nothing to point at, and `x`/`y` have no sample to resolve
     const r = svgRef.current!.getBoundingClientRect()
     const relX = ((e.clientX - r.left) / r.width) * W
     const i = Math.max(0, Math.min(n - 1, Math.round((relX - PAD.l) / (W - PAD.l - PAD.r) * (n - 1))))
@@ -54,7 +66,9 @@ export function LatencyChart({ series }: { series: number[] }) {
     <Card className="gap-0 overflow-hidden pb-3">
       <CardHeader className="flex items-baseline justify-between pb-2">
         <CardTitle className="text-[13.5px] font-semibold">Latency p95 over time</CardTitle>
-        <span className="font-mono text-[11px] text-muted-foreground">ms · rolling window</span>
+        <span className="font-mono text-[11px] text-muted-foreground">
+          {empty ? 'ms · default scale' : 'ms · rolling window'}
+        </span>
       </CardHeader>
       <div className="relative px-2.5">
         <svg
@@ -82,12 +96,16 @@ export function LatencyChart({ series }: { series: number[] }) {
             </g>
           ))}
           {/* Line and area need two points to mean anything; with one bucket the
-              area would ramp from a zero baseline it never measured. Show the dot alone. */}
+              area would ramp from a zero baseline it never measured. Show the dot alone.
+              With no samples at all, nothing is drawn over the grid — an empty chart
+              must not be given a shape to read. */}
           {n > 1 && <polygon points={area} fill={`url(#${gradId})`} />}
           {n > 1 && (
             <polyline points={pts} fill="none" stroke="var(--telemetry)" strokeWidth={2} strokeLinejoin="round" strokeLinecap="round" />
           )}
-          <circle cx={x(n - 1)} cy={y(series[n - 1])} r={3.6} fill="var(--telemetry)" stroke="var(--card)" strokeWidth={2} />
+          {!empty && (
+            <circle cx={x(n - 1)} cy={y(series[n - 1])} r={3.6} fill="var(--telemetry)" stroke="var(--card)" strokeWidth={2} />
+          )}
           {hover != null && (
             <>
               <line x1={x(hover)} y1={PAD.t} x2={x(hover)} y2={H - PAD.b} stroke="var(--telemetry)" strokeWidth={1} opacity={0.5} />
@@ -95,6 +113,11 @@ export function LatencyChart({ series }: { series: number[] }) {
             </>
           )}
         </svg>
+        {empty && (
+          <p className="pointer-events-none absolute inset-0 flex items-center justify-center font-mono text-[11.5px] text-muted-foreground">
+            No samples in this window yet
+          </p>
+        )}
         {hover != null && (
           <div
             className="pointer-events-none absolute -translate-x-1/2 -translate-y-2 rounded-md bg-foreground px-2 py-1 font-mono text-[11px] text-background shadow-lg"
diff --git a/src/components/module-table.tsx b/src/components/module-table.tsx
index 84f121a..b6193b9 100644
--- a/src/components/module-table.tsx
+++ b/src/components/module-table.tsx
@@ -1,4 +1,4 @@
-import { useMemo, useRef, useState } from 'react'
+import { useMemo, useRef, useState, type ReactNode } from 'react'
 import { ArrowDown, ArrowUp, ChevronsUpDown, Gauge, SearchX } from 'lucide-react'
 import { useVirtualizer } from '@tanstack/react-virtual'
 import { Card } from '@/components/ui/card'
@@ -36,9 +36,92 @@ function compare(a: ModuleMetricsSnapshot, b: ModuleMetricsSnapshot, key: Metric
   return a[key] - b[key]
 }
 
+/**
+ * What the table says when it has no metrics to show.
+ *
+ * An empty `metrics` array means two different things — recording is off, or it
+ * is on and no module has been called yet — and the array cannot tell them apart.
+ * The console used to guess, and told operators to switch on a setting that was
+ * already on. It no longer guesses: the platform states `metricsEnabled` in the
+ * connection ack and that is what this reads.
+ *
+ * `null` is the third case, and it is not a failure: a platform that sends no ack
+ * has not been asked and has not answered. The copy then says what is true of
+ * both possibilities rather than picking one.
+ *
+ * 🔴 `tracesEnabled` is read first, and that ordering is required rather than
+ * defensive. Per-module metrics are aggregated from recorded requests, so with
+ * recording off nothing reaches the aggregate — and the contract states
+ * `metricsEnabled` as the *effective* value, which means a platform with recording
+ * off reports metrics off too. Read on its own, that value would send this panel
+ * into "turn it on and rows appear as modules receive traffic": an instruction
+ * that changes nothing and a promise nothing can keep while recording is off.
+ *
+ * It also covers the reverse pair. `metricsEnabled: true` alongside
+ * `tracesEnabled: false` contradicts the contract, but the console cannot verify
+ * an ack — it can only decline to promise rows on the strength of one.
+ */
+function emptyMetrics(
+  metricsEnabled: boolean | null,
+  tracesEnabled: boolean | null,
+): { title: string; description: ReactNode } {
+  if (tracesEnabled === false) {
+    return {
+      title: 'Trace recording is off',
+      description: (
+        <>
+          The platform reported <Setting>protean.trace.enabled=false</Setting> when this connection opened.
+          Per-module metrics are aggregated from recorded requests, so no rows can appear here while recording
+          is off.
+        </>
+      ),
+    }
+  }
+  if (metricsEnabled === false) {
+    return {
+      title: 'Module metrics are off',
+      description: (
+        <>
+          The platform reported <Setting>protean.trace.metrics.enabled=false</Setting> when this connection
+          opened. Turn it on and rows appear as modules receive traffic.
+        </>
+      ),
+    }
+  }
+  if (metricsEnabled === true) {
+    return {
+      title: 'No module traffic yet',
+      description: (
+        <>
+          Per-module metrics are on. No module has served a request the platform recorded, so there is nothing
+          to aggregate yet — rows appear as traffic arrives.
+        </>
+      ),
+    }
+  }
+  return {
+    title: 'No module metrics',
+    description: (
+      <>
+        This platform did not state whether per-module metrics are recording, so this is either off or on and
+        idle. They are opt-in via <Setting>protean.trace.metrics.enabled</Setting>; when on, rows appear as
+        modules receive traffic.
+      </>
+    ),
+  }
+}
+
+function Setting({ children }: { children: ReactNode }) {
+  return (
+    <code className="rounded bg-muted px-1.5 py-0.5 font-mono text-[12px] text-foreground">{children}</code>
+  )
+}
+
 export function ModuleTable({
   metrics,
   modules,
+  metricsEnabled,
+  tracesEnabled,
   sort,
   onSort,
   selectedId,
@@ -46,6 +129,10 @@ export function ModuleTable({
 }: {
   metrics: ModuleMetricsSnapshot[]
   modules: ModuleStatus[]
+  /** From the platform's `ready` ack; `null` when it sent none. */
+  metricsEnabled: boolean | null
+  /** Also from the ack. Gates the above — see `emptyMetrics`. */
+  tracesEnabled: boolean | null
   sort: MetricSort
   onSort: (s: MetricSort) => void
   selectedId: string | null
@@ -79,6 +166,7 @@ export function ModuleTable({
     estimateSize: () => ROW_H,
     overscan: 12,
   })
+  const empty = emptyMetrics(metricsEnabled, tracesEnabled)
   const items = virtualizer.getVirtualItems()
   const paddingTop = items.length > 0 ? items[0].start : 0
   const paddingBottom = items.length > 0 ? virtualizer.getTotalSize() - items[items.length - 1].end : 0
@@ -130,14 +218,8 @@ export function ModuleTable({
                 <EmptyMedia variant="icon">
                   <Gauge />
                 </EmptyMedia>
-                <EmptyTitle>No module metrics</EmptyTitle>
-                <EmptyDescription>
-                  Per-module latency and error rates are opt-in. Enable{' '}
-                  <code className="rounded bg-muted px-1.5 py-0.5 font-mono text-[12px] text-foreground">
-                    protean.trace.metrics.enabled=true
-                  </code>{' '}
-                  on the platform and restart; rows appear once modules receive traffic.
-                </EmptyDescription>
+                <EmptyTitle>{empty.title}</EmptyTitle>
+                <EmptyDescription>{empty.description}</EmptyDescription>
               </EmptyHeader>
             </Empty>
           ) : (
diff --git a/src/components/options-menu.test.tsx b/src/components/options-menu.test.tsx
index 821a10c..60699d2 100644
--- a/src/components/options-menu.test.tsx
+++ b/src/components/options-menu.test.tsx
@@ -43,6 +43,7 @@ function Harness() {
       onToggleTheme={() => setTheme((t) => (t === 'dark' ? 'light' : 'dark'))}
       conn={{ status: 'live', lastUpdated: connectedAt }}
       channels={ALL_HEALTHY}
+      platform={null}
       storage={STORAGE_OK}
       settings={settings}
       onSaveSettings={save}
diff --git a/src/components/platform-identity.test.tsx b/src/components/platform-identity.test.tsx
new file mode 100644
index 0000000..1ff03f6
--- /dev/null
+++ b/src/components/platform-identity.test.tsx
@@ -0,0 +1,187 @@
+import { cleanup, render, screen } from '@testing-library/react'
+import { afterEach, describe, expect, it } from 'vitest'
+import { ModuleTable } from '@/components/module-table'
+import { TopBar } from '@/components/top-bar'
+import { TraceTable } from '@/components/trace-table'
+import type { TraceStoreView } from '@/hooks/use-trace-store'
+import { ALL_HEALTHY, type PlatformInfo } from '@/hooks/use-console-data'
+import { STORAGE_OK } from '@/hooks/use-trace-store'
+import { DEFAULT_SETTINGS } from '@/lib/settings'
+
+/**
+ * What the connection ack changes on screen.
+ *
+ * `ready-ack.test.ts` proves the hook reads the frame; this is the hop after it.
+ * Three statements the console used to make without being told anything are the
+ * subject: a ring size it printed as a constant, an "enable this setting" instruction
+ * it inferred from an empty array, and the identity of the platform it was talking
+ * to, which it never showed at all.
+ *
+ * Each is asserted twice — with the ack and without it — because the failure worth
+ * catching is not the stated value being wrong. It is the console going back to
+ * asserting something when the platform said nothing.
+ */
+
+function info(fields: Partial<PlatformInfo> = {}): PlatformInfo {
+  return {
+    platform: 'protean',
+    platformVersion: '0.1.0',
+    tracesEnabled: true,
+    metricsEnabled: false,
+    buffered: 0,
+    tickMs: 1000,
+    capacity: 200,
+    ...fields,
+  }
+}
+
+function renderHeader(platform: PlatformInfo | null) {
+  render(
+    <TopBar
+      streaming
+      onToggleStream={() => {}}
+      theme="dark"
+      onToggleTheme={() => {}}
+      conn={{ status: 'live', lastUpdated: 1788161788025 }}
+      channels={ALL_HEALTHY}
+      platform={platform}
+      storage={STORAGE_OK}
+      settings={DEFAULT_SETTINGS}
+      onSaveSettings={() => {}}
+    />,
+  )
+}
+
+afterEach(cleanup)
+
+describe('the buffer figure in the live badge', () => {
+  it('is the capacity the platform stated', () => {
+    renderHeader(info({ capacity: 5_000 }))
+    expect(screen.getByText(/LIVE · 5000 buffer/)).toBeTruthy()
+  })
+
+  it('is left off entirely when no platform stated one', () => {
+    // It read "LIVE · 200 buffer" on every platform, including ones whose ring was
+    // a different size — a number this console had never been told and could not
+    // see. Saying only LIVE is the honest version.
+    renderHeader(null)
+    expect(screen.getByText('LIVE')).toBeTruthy()
+    expect(screen.queryByText(/buffer/)).toBeNull()
+  })
+})
+
+describe('which platform answered', () => {
+  it('is named next to the origin', () => {
+    renderHeader(info())
+    expect(screen.getByText(/protean 0\.1\.0/)).toBeTruthy()
+  })
+
+  it('says the version is unknown rather than picking one', () => {
+    renderHeader(info({ platformVersion: null }))
+    expect(screen.getByText(/protean \(version unknown\)/)).toBeTruthy()
+  })
+
+  it('names nothing when the platform introduced nothing', () => {
+    renderHeader(null)
+    expect(screen.queryByText(/protean \d/)).toBeNull()
+  })
+})
+
+describe('the module table with no metrics to show', () => {
+  /**
+   * An empty `metrics` array is true of two different platforms: one not recording
+   * per-module metrics, and one recording them that has served nothing. The console
+   * used to answer for both by telling the operator to switch a setting on — which,
+   * on the second platform, was already on.
+   */
+  function renderTable(metricsEnabled: boolean | null, tracesEnabled: boolean | null = true) {
+    render(
+      <ModuleTable
+        metrics={[]}
+        modules={[]}
+        metricsEnabled={metricsEnabled}
+        tracesEnabled={tracesEnabled}
+        sort={{ key: 'count', dir: 'desc' }}
+        onSort={() => {}}
+        selectedId={null}
+        onSelect={() => {}}
+      />,
+    )
+  }
+
+  it('says metrics are off when the platform said so', () => {
+    renderTable(false)
+    expect(screen.getByText('Module metrics are off')).toBeTruthy()
+    expect(screen.getByText(/protean\.trace\.metrics\.enabled=false/)).toBeTruthy()
+  })
+
+  it('does not tell an operator to enable a setting that is already on', () => {
+    renderTable(true)
+    expect(screen.getByText('No module traffic yet')).toBeTruthy()
+    expect(screen.queryByText(/=true/), 'told the operator to enable what is on').toBeNull()
+  })
+
+  it('states the ambiguity when no platform resolved it', () => {
+    renderTable(null, null)
+    expect(screen.getByText('No module metrics')).toBeTruthy()
+    expect(screen.getByText(/did not state whether/)).toBeTruthy()
+  })
+
+  it('leads with recording being off when both are off', () => {
+    // The reachable case under the contract, and the reason the ordering is not
+    // optional: `metricsEnabled` is the effective value, so recording off reports
+    // metrics off — and "turn it on and rows appear" would be an instruction that
+    // changes nothing beside a promise nothing can keep.
+    renderTable(false, false)
+    expect(screen.getByText('Trace recording is off')).toBeTruthy()
+    expect(screen.queryByText(/Turn it on and rows appear/), 'told the operator to flip a switch that would not help').toBeNull()
+  })
+
+  it('declines to promise rows on an ack that contradicts itself', () => {
+    // `metricsEnabled: true` with `tracesEnabled: false` should not be sent — the
+    // contract says the metrics flag is the effective value. The console cannot
+    // verify an ack, though, so it declines the promise rather than repeating it.
+    renderTable(true, false)
+    expect(screen.getByText('Trace recording is off')).toBeTruthy()
+    expect(screen.queryByText(/rows appear as traffic arrives/), 'promised rows that cannot come').toBeNull()
+  })
+})
+
+describe('the trace table with nothing in it', () => {
+  /**
+   * The empty table makes a promise — "requests appear here as the platform serves
+   * them". On a platform recording nothing it is a promise no request will ever
+   * keep, and the operator would have waited at a table that was never going to
+   * fill. `tracesEnabled` is the only thing that can tell them.
+   */
+  const EMPTY_STORE: TraceStoreView = {
+    rows: [],
+    total: 0,
+    hasMore: false,
+    loadingOlder: false,
+    loadOlder: () => {},
+    clear: () => {},
+    storage: STORAGE_OK,
+    filter: { chip: 'all', query: '' },
+    setFilter: () => {},
+    searching: false,
+  }
+
+  it('says recording is off rather than promising rows that cannot come', () => {
+    render(<TraceTable store={EMPTY_STORE} tracesEnabled={false} />)
+    expect(screen.getByText('Trace recording is off')).toBeTruthy()
+    expect(screen.queryByText(/appear here as the platform serves them/)).toBeNull()
+  })
+
+  it('keeps the promise where it holds', () => {
+    render(<TraceTable store={EMPTY_STORE} tracesEnabled={true} />)
+    expect(screen.getByText('No traces yet')).toBeTruthy()
+  })
+
+  it('keeps it for a platform that stated nothing', () => {
+    // No ack, no fact — and the table has no more grounds to announce an outage of
+    // recording than it had before the frame existed.
+    render(<TraceTable store={EMPTY_STORE} tracesEnabled={null} />)
+    expect(screen.getByText('No traces yet')).toBeTruthy()
+  })
+})
diff --git a/src/components/status-mix.tsx b/src/components/status-mix.tsx
index 9151596..c1d6aa6 100644
--- a/src/components/status-mix.tsx
+++ b/src/components/status-mix.tsx
@@ -12,7 +12,11 @@ const BUCKETS = [
 /** Status-code distribution over the sampled traces — magnitude bars, one hue per status. */
 export function StatusMix({ traces }: { traces: RequestTrace[] }) {
   const counts = BUCKETS.map((b) => ({ ...b, n: traces.filter((t) => b.test(t.status)).length }))
-  const total = counts.reduce((a, b) => a + b.n, 0) || 1
+  const total = counts.reduce((a, b) => a + b.n, 0)
+  // Separated because they were one value, and the `|| 1` that keeps the bar widths
+  // from dividing by zero was also what the header printed: an idle platform read
+  // "1 req" beside four zeroes. The guard belongs to the geometry, not to the count.
+  const denom = total || 1
 
   return (
     <Card className="gap-0">
@@ -30,7 +34,7 @@ export function StatusMix({ traces }: { traces: RequestTrace[] }) {
             <span className="h-2 overflow-hidden rounded-full bg-muted" title={b.label}>
               <span
                 className="block h-full rounded-full"
-                style={{ width: `${Math.max(2, (b.n / total) * 100)}%`, background: b.color }}
+                style={{ width: `${Math.max(2, (b.n / denom) * 100)}%`, background: b.color }}
               />
             </span>
             <span className="font-mono text-xs tabular-nums text-muted-foreground">{num(b.n)}</span>
diff --git a/src/components/top-bar.tsx b/src/components/top-bar.tsx
index 2411fa3..9045932 100644
--- a/src/components/top-bar.tsx
+++ b/src/components/top-bar.tsx
@@ -13,16 +13,50 @@ import {
 import { SettingsDialog } from '@/components/settings-dialog'
 import type { Settings } from '@/lib/settings'
 import { cn } from '@/lib/utils'
-import { platformOrigin, type ChannelStates, type ConnState } from '@/hooks/use-console-data'
+import { platformOrigin, type ChannelStates, type ConnState, type PlatformInfo } from '@/hooks/use-console-data'
 import type { StorageHealth } from '@/hooks/use-trace-store'
 
 type Tone = 'ok' | 'warn' | 'crit'
 type StatusView = { label: string; tone: Tone; ping: boolean; title: string; Icon?: ComponentType<{ className?: string }> }
 
-function statusView(conn: ConnState): StatusView {
+/**
+ * What the platform said it is, for the header line under the wordmark.
+ *
+ * Identity only — nothing on this screen branches on it. It is here because an
+ * operator watching one of several implementations of this contract cannot tell
+ * from the data alone which one answered, and a bare version number would not
+ * tell them either.
+ *
+ * A platform that sent no ack contributes nothing: the line stays the origin
+ * alone, rather than naming a platform we are guessing at. One that sent an ack
+ * without a readable version says so — `protean (version unknown)` is true, and a
+ * platform whose classes carry no version manifest is the platform's own
+ * documented answer, not a gap this console should paper over.
+ */
+function platformLine(platform: PlatformInfo | null): string {
+  const origin = platformOrigin()
+  if (!platform?.platform) return origin
+  return `${origin} · ${platform.platform} ${platform.platformVersion ?? '(version unknown)'}`
+}
+
+function statusView(conn: ConnState, platform: PlatformInfo | null): StatusView {
   switch (conn.status) {
-    case 'live':
-      return { label: 'LIVE · 200 buffer', tone: 'ok', ping: true, title: 'connected to a live platform' }
+    case 'live': {
+      // The buffer figure is the platform's `capacity` as of this connection, not a
+      // constant: it used to read "200 buffer" on every platform, which was this
+      // console asserting a ring size it had never been told and could not see. A
+      // platform that did not state one gets no claim at all.
+      const capacity = platform?.capacity
+      return {
+        label: capacity == null ? 'LIVE' : `LIVE · ${capacity} buffer`,
+        tone: 'ok',
+        ping: true,
+        title:
+          capacity == null
+            ? 'connected to a live platform'
+            : `connected to a live platform · retains up to ${capacity} traces`,
+      }
+    }
     case 'sample':
       return { label: 'SAMPLE DATA', tone: 'warn', ping: false, title: 'no platform reachable — showing sample data' }
     case 'disconnected':
@@ -72,6 +106,7 @@ export function TopBar({
   onToggleTheme,
   conn,
   channels,
+  platform,
   storage,
   settings,
   onSaveSettings,
@@ -82,12 +117,13 @@ export function TopBar({
   onToggleTheme: () => void
   conn: ConnState
   channels: ChannelStates
+  platform: PlatformInfo | null
   storage: StorageHealth
   settings: Settings
   onSaveSettings: (next: Settings) => void
 }) {
   const [settingsOpen, setSettingsOpen] = useState(false)
-  const s = statusView(conn)
+  const s = statusView(conn, platform)
   // Frames the platform sent that we could not read. Counted for the whole session,
   // not just the current run of them: a burst that recovered still happened, and a
   // number that resets itself is a number nobody can act on.
@@ -95,7 +131,7 @@ export function TopBar({
   const staleChannels = (Object.keys(channels) as Array<keyof ChannelStates>).filter((k) => channels[k].stale)
   return (
     <header className="flex flex-wrap items-center gap-3.5">
-      <BrandLockup subtitle={platformOrigin()} />
+      <BrandLockup subtitle={platformLine(platform)} />
 
       <span
         className={cn(
diff --git a/src/components/trace-table.tsx b/src/components/trace-table.tsx
index 7d52779..6250528 100644
--- a/src/components/trace-table.tsx
+++ b/src/components/trace-table.tsx
@@ -84,10 +84,20 @@ export function shouldLoadOlder({
 export function TraceTable({
   store,
   staleReason,
+  tracesEnabled,
 }: {
   store: TraceStoreView
   /** Set when the trace channel has gone unreadable; shown in the header, never over the rows. */
   staleReason?: string | null
+  /**
+   * From the platform's `ready` ack; `null` when it sent none.
+   *
+   * An empty table says "requests appear here as the platform serves them". That
+   * is a promise, and on a platform with `protean.trace.enabled=false` it is one
+   * nothing will ever keep — no request is being recorded, so waiting is futile
+   * and the operator has no way to learn that from an empty table.
+   */
+  tracesEnabled?: boolean | null
 }) {
   const storageNote = storageReason(store.storage)
   // 🔴 The filter is not applied here. It is a query the store answers against the
@@ -234,9 +244,20 @@ export function TraceTable({
                 <EmptyMedia variant="icon">
                   <Inbox />
                 </EmptyMedia>
-                <EmptyTitle>No traces yet</EmptyTitle>
+                <EmptyTitle>{tracesEnabled === false ? 'Trace recording is off' : 'No traces yet'}</EmptyTitle>
                 <EmptyDescription>
-                  Requests appear here as the platform serves them, and are kept across reloads.
+                  {tracesEnabled === false ? (
+                    <>
+                      The platform reported{' '}
+                      <code className="rounded bg-muted px-1.5 py-0.5 font-mono text-[12px] text-foreground">
+                        protean.trace.enabled=false
+                      </code>{' '}
+                      when this connection opened. Nothing is being recorded, so no request will appear here
+                      until it is turned on.
+                    </>
+                  ) : (
+                    <>Requests appear here as the platform serves them, and are kept across reloads.</>
+                  )}
                 </EmptyDescription>
               </EmptyHeader>
             </Empty>
diff --git a/src/hooks/ready-ack.test.ts b/src/hooks/ready-ack.test.ts
new file mode 100644
index 0000000..aae2626
--- /dev/null
+++ b/src/hooks/ready-ack.test.ts
@@ -0,0 +1,265 @@
+import { act, renderHook } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { useConsoleData } from '@/hooks/use-console-data'
+import { GO_CONNECT, PROTEAN_CONNECT, SPRING_CONNECT } from '@/test/stream-fixtures'
+import { FakeEventSource, installFakeEventSource, replay } from '@/test/sse-stream'
+
+/**
+ * The connection ack (`event: ready`).
+ *
+ * It is the one frame that arrives on a platform serving no traffic, and it is
+ * the only place the console learns four things it used to assume, invent, or
+ * infer: the push period its watchdog is sized against, the ring size its badge
+ * prints, whether metrics are recording, and which implementation answered.
+ *
+ * Every assumption it replaces is asserted here in both directions — the value
+ * the platform states, and the honest blank for a platform that states nothing.
+ * A console that quietly falls back to its old guesses would pass a test that
+ * only checked the first.
+ */
+
+/** An ack with the fields a case cares about, on a platform-shaped default. */
+function ready(fields: Record<string, unknown> = {}): string {
+  return JSON.stringify({
+    platform: 'protean',
+    platformVersion: '0.1.0',
+    tracesEnabled: true,
+    metricsEnabled: false,
+    buffered: 0,
+    tickMs: 1000,
+    capacity: 200,
+    ...fields,
+  })
+}
+
+let restoreEventSource: () => void
+
+beforeEach(() => {
+  restoreEventSource = installFakeEventSource()
+  vi.useFakeTimers()
+})
+
+afterEach(() => {
+  vi.useRealTimers()
+  restoreEventSource()
+})
+
+describe('the ack on a quiet platform', () => {
+  it('is enough to report the stream live', () => {
+    // The whole reason the frame exists: a platform with no traffic sends no
+    // `trace` frames, so without the ack "the socket opened" and "the platform is
+    // running" are the same observation. The console must take the ack as the
+    // second one.
+    const { result } = renderHook(() => useConsoleData())
+    act(() => {
+      const es = FakeEventSource.current()
+      es.emit('open')
+      es.emit('ready', ready({ buffered: 0 }))
+    })
+    expect(result.current.conn.status).toBe('live')
+  })
+
+  it('carries the connect-time facts onto the screen', () => {
+    const { result } = renderHook(() => useConsoleData())
+    act(() => {
+      const es = FakeEventSource.current()
+      es.emit('open')
+      replay(es, PROTEAN_CONNECT)
+    })
+    expect(result.current.platform).toEqual({
+      platform: 'protean',
+      platformVersion: '0.1.0-SNAPSHOT', // the captured build; printed, never compared
+      tracesEnabled: true,
+      metricsEnabled: false,
+      buffered: 5, // equal to the rows of the `trace` frame behind it, as captured
+      tickMs: 1000,
+      capacity: 200,
+    })
+  })
+})
+
+describe('a platform that sends no ack', () => {
+  /**
+   * Older platforms, and the other implementations of this contract that have not
+   * adopted the frame yet. They must keep working exactly as before — and the
+   * console must not fill the gap with numbers nobody gave it.
+   */
+  it.each([
+    ['spring', SPRING_CONNECT],
+    ['go', GO_CONNECT],
+  ])('stays live on %s and claims nothing about it', (_name, connect) => {
+    const { result } = renderHook(() => useConsoleData())
+    act(() => {
+      const es = FakeEventSource.current()
+      es.emit('open')
+      replay(es, connect)
+    })
+    expect(result.current.conn.status).toBe('live')
+    expect(result.current.platform).toBeNull()
+  })
+
+  it('is still judged by the assumed period', () => {
+    // The 6s window predates the ack and remains the fallback. A platform that
+    // states nothing must not become un-watchable.
+    const { result } = renderHook(() => useConsoleData())
+    act(() => {
+      const es = FakeEventSource.current()
+      es.emit('open')
+      replay(es, GO_CONNECT)
+    })
+    act(() => {
+      vi.advanceTimersByTime(6_500)
+    })
+    expect(result.current.conn.status).toBe('disconnected')
+  })
+})
+
+describe('the watchdog sizes itself from the stated period', () => {
+  /**
+   * The window used to be six seconds because the platform was assumed to push
+   * once a second. `tickMs` turns that assumption into a contract — and the test
+   * that matters is the slow platform, because that is the one the old constant
+   * declared dead while it was working perfectly.
+   */
+  function connectWith(tickMs: number) {
+    const hook = renderHook(() => useConsoleData())
+    act(() => {
+      const es = FakeEventSource.current()
+      es.emit('open')
+      es.emit('ready', ready({ tickMs }))
+    })
+    return hook
+  }
+
+  it('holds live through a gap that would kill a 1Hz platform', () => {
+    const { result } = connectWith(3_000) // 6 ticks = 18s
+    act(() => {
+      vi.advanceTimersByTime(10_000) // well past the 6s default, well inside 18s
+    })
+    expect(result.current.conn.status).toBe('live')
+  })
+
+  it('still reports the outage once the stated window passes', () => {
+    // The other direction: a wider window is not an excuse to stop watching.
+    const { result } = connectWith(3_000)
+    act(() => {
+      vi.advanceTimersByTime(18_500)
+    })
+    expect(result.current.conn.status).toBe('disconnected')
+  })
+
+  it('reports a fast platform sooner than the old constant would', () => {
+    const { result } = connectWith(400) // 6 ticks = 2.4s
+    act(() => {
+      vi.advanceTimersByTime(2_600)
+    })
+    expect(result.current.conn.status).toBe('disconnected')
+  })
+
+  it('refuses a period that would make the watchdog useless at either end', () => {
+    // A stated period is a contract, not a free hand: a few milliseconds would
+    // trip on scheduler jitter, an hour would never trip at all. Both are clamped.
+    const fast = connectWith(1) // 6ms → floored to 2s
+    act(() => {
+      vi.advanceTimersByTime(1_500)
+    })
+    expect(fast.result.current.conn.status, 'floor not applied').toBe('live')
+    act(() => {
+      vi.advanceTimersByTime(1_000)
+    })
+    expect(fast.result.current.conn.status).toBe('disconnected')
+    fast.unmount()
+
+    const slow = connectWith(3_600_000) // 6 hours → capped at 60s
+    act(() => {
+      vi.advanceTimersByTime(61_000)
+    })
+    expect(slow.result.current.conn.status, 'ceiling not applied').toBe('disconnected')
+  })
+})
+
+describe('an ack the console cannot read', () => {
+  it('is counted as a bad frame and invents nothing', () => {
+    const { result } = renderHook(() => useConsoleData())
+    act(() => {
+      const es = FakeEventSource.current()
+      es.emit('open')
+      es.emit('ready', '[]') // an array where the contract says object
+      replay(es, SPRING_CONNECT)
+    })
+    expect(result.current.platform).toBeNull()
+    expect(result.current.channels.ready.total).toBe(1)
+    expect(result.current.conn.status).toBe('live') // the data frames still arrived
+  })
+
+  it('keeps the fields it can read when one of them is the wrong type', () => {
+    // The ack is extensible by design, so a value this console cannot read is
+    // "not stated", not a reason to throw away the six values it can read.
+    const { result } = renderHook(() => useConsoleData())
+    act(() => {
+      const es = FakeEventSource.current()
+      es.emit('open')
+      es.emit('ready', ready({ tickMs: 'fast', somethingNewer: { added: 'later' } }))
+    })
+    expect(result.current.platform?.capacity).toBe(200)
+    expect(result.current.platform?.tickMs).toBeNull()
+
+    // And an unreadable period falls back to the assumed one rather than to no
+    // watchdog at all.
+    act(() => {
+      vi.advanceTimersByTime(6_500)
+    })
+    expect(result.current.conn.status).toBe('disconnected')
+  })
+
+  it('reports a missing version as unknown rather than as a version', () => {
+    // A platform whose classes carry no version manifest genuinely does not know
+    // its own version — protean's own test suite runs that way, and so does any
+    // consumer that repackages it into an uber-jar without preserving the
+    // manifest. `null` is the platform's answer, and the console keeps it as one.
+    const { result } = renderHook(() => useConsoleData())
+    act(() => {
+      const es = FakeEventSource.current()
+      es.emit('open')
+      es.emit('ready', ready({ platformVersion: null }))
+    })
+    expect(result.current.platform?.platform).toBe('protean')
+    expect(result.current.platform?.platformVersion).toBeNull()
+  })
+})
+
+describe('the facts belong to the connection that stated them', () => {
+  /**
+   * `capacity`, `tracesEnabled` and `metricsEnabled` are live settings on the
+   * platform, and the ack is the only time the console is told them. Carrying a
+   * dead connection's answers into the next one would put a claim on screen that
+   * nothing has made — and the platform answering now may not even be the one
+   * that answered before.
+   */
+  it('drops them when the stream is rebuilt and re-learns them from the next ack', () => {
+    const { result } = renderHook(() => useConsoleData())
+    act(() => {
+      const es = FakeEventSource.current()
+      es.emit('open')
+      es.emit('ready', ready({ capacity: 200 }))
+    })
+    expect(result.current.platform?.capacity).toBe(200)
+
+    // The platform goes quiet and the hook rebuilds the stream.
+    act(() => {
+      vi.advanceTimersByTime(6_500)
+    })
+    act(() => {
+      vi.advanceTimersByTime(5_500)
+    })
+    expect(result.current.platform, 'last connection’s facts outlived it').toBeNull()
+
+    act(() => {
+      const es = FakeEventSource.current()
+      es.emit('open')
+      es.emit('ready', ready({ capacity: 5_000, metricsEnabled: true }))
+    })
+    expect(result.current.platform?.capacity).toBe(5_000)
+    expect(result.current.platform?.metricsEnabled).toBe(true)
+  })
+})
diff --git a/src/hooks/trace-history.test.ts b/src/hooks/trace-history.test.ts
index 8c972d5..c5cd38a 100644
--- a/src/hooks/trace-history.test.ts
+++ b/src/hooks/trace-history.test.ts
@@ -1,11 +1,7 @@
 import { act, renderHook, waitFor } from '@testing-library/react'
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 import { useConsoleUnderTest } from '@/test/console-driver'
-import {
-  FIXTURE_NEWEST_EPOCH,
-  PLATFORMS,
-  traceFrame,
-} from '@/test/stream-fixtures'
+import { PLATFORMS, traceFrame } from '@/test/stream-fixtures'
 import { FakeEventSource, installFakeEventSource, replay, tracesIn } from '@/test/sse-stream'
 import { clearTraces, countTraces, getTracePage } from '@/lib/trace-db'
 
@@ -16,8 +12,9 @@ import { clearTraces, countTraces, getTracePage } from '@/lib/trace-db'
  * precondition really was destroyed. Without that negative step, a later success
  * cannot distinguish "the fix worked" from "nothing was ever broken".
  *
- * Both platforms' captured connect sequences run every scenario, because the
- * console's job is to be right about whichever one it is pointed at.
+ * Every captured connect sequence runs every scenario, because the console's job
+ * is to be right about whichever platform it is pointed at — including the ones
+ * that open with a `ready` ack and the ones that do not.
  */
 
 /** Retained rows, read from IndexedDB rather than from the hook's own state. */
@@ -49,7 +46,7 @@ afterEach(() => {
   restoreEventSource()
 })
 
-describe.each(PLATFORMS)('$name platform', ({ connect }) => {
+describe.each(PLATFORMS)('$name platform', ({ connect, newestEpoch }) => {
   const dumped = tracesIn(connect)
   const dumpedSeqs = dumped.map((t) => t.seq).sort((a, b) => a - b)
 
@@ -77,7 +74,7 @@ describe.each(PLATFORMS)('$name platform', ({ connect }) => {
 
     // ④ real traffic still accumulates on top.
     await act(async () => {
-      FakeEventSource.current().emit('trace', traceFrame(9001, FIXTURE_NEWEST_EPOCH + 1_000))
+      FakeEventSource.current().emit('trace', traceFrame(9001, newestEpoch + 1_000))
     })
     await waitFor(async () => expect(await countTraces()).toBe(dumped.length + 1))
   })
@@ -111,7 +108,7 @@ describe.each(PLATFORMS)('$name platform', ({ connect }) => {
 
     // ③ traffic after the clear is kept — the clear must not deafen the store.
     await act(async () => {
-      FakeEventSource.current().emit('trace', traceFrame(9002, FIXTURE_NEWEST_EPOCH + 2_000))
+      FakeEventSource.current().emit('trace', traceFrame(9002, newestEpoch + 2_000))
     })
     await waitFor(async () => expect(await retained()).toEqual([9002]))
   })
@@ -168,7 +165,7 @@ describe.each(PLATFORMS)('$name platform', ({ connect }) => {
 
     // Still listening: traffic after the clear lands normally.
     await act(async () => {
-      FakeEventSource.current().emit('trace', traceFrame(9003, FIXTURE_NEWEST_EPOCH + 3_000))
+      FakeEventSource.current().emit('trace', traceFrame(9003, newestEpoch + 3_000))
     })
     await waitFor(async () => expect(await retained()).toEqual([9003]))
   })
diff --git a/src/hooks/use-console-data.ts b/src/hooks/use-console-data.ts
index 92c5aba..ac5e197 100644
--- a/src/hooks/use-console-data.ts
+++ b/src/hooks/use-console-data.ts
@@ -2,7 +2,7 @@ import { useEffect, useRef, useState } from 'react'
 import { deriveP95, type ConnReason, type LiveData } from '@/lib/api'
 import { mockLatencySeries, mockMetrics, mockModules, mockSummary, mockTraces } from '@/lib/mock'
 import { traceKey } from '@/lib/trace-db'
-import type { ModuleMetricsSnapshot, ModuleStatus, RequestTrace, TraceSummary } from '@/lib/types'
+import type { ModuleMetricsSnapshot, ModuleStatus, RequestTrace, StreamReady, TraceSummary } from '@/lib/types'
 
 const STREAM_URL = '/platform/traces/stream'
 
@@ -18,6 +18,12 @@ const STREAM_URL = '/platform/traces/stream'
  * that `vite build` does not carry, so a production bundle sends every request to
  * its own origin no matter what the variable said at build time. Printing the
  * variable there would name an address no request ever goes to.
+ *
+ * In dev the variable is always set: `vite.config.ts` resolves the proxy's target
+ * — including its default — and injects that exact string, so this cannot name a
+ * host the proxy is not forwarding to. The empty-string handling below is kept for
+ * the case that injection is absent (a production bundle, or a test stubbing the
+ * env directly).
  */
 export function platformOrigin(): string {
   const configured = import.meta.env.DEV ? (import.meta.env.VITE_PROTEAN_TARGET as string | undefined) : undefined
@@ -33,15 +39,33 @@ const TRACE_WINDOW = 500
 // If the stream never opens (no platform reachable), fall back to sample data.
 // The wait is a user setting; this is the fallback for callers without one.
 const SAMPLE_DELAY_MS = 2500
-// A healthy stream pushes metrics/modules snapshots ~1×/s, so it's never silent
-// for long. If no event arrives within this window the connection is dead — even
-// when EventSource still reports it open (see the watchdog note below).
-const STALE_TIMEOUT_MS = 6000
+// How many pushes may be missed before the connection is called dead. A healthy
+// stream pushes metrics/modules snapshots every `tickMs`, so silence for several
+// periods means the connection is gone — even when EventSource still reports it
+// open (see the watchdog note below).
+const STALE_TICKS = 6
+// The period assumed when the platform has not stated one. Before the `ready` ack
+// existed, 1Hz was the console's standing assumption about every platform; it is
+// still the only thing to fall back on for a platform that sends no ack, and it
+// keeps the window at the 6s this console has always used.
+const ASSUMED_TICK_MS = 1000
+// The stated period is a contract, not a free hand. A period of a few
+// milliseconds would make a watchdog that trips on ordinary scheduler jitter, and
+// one of an hour would make a watchdog that never trips at all — and this is the
+// only signal the console has that a platform is gone.
+const MIN_STALE_WINDOW_MS = 2000
+const MAX_STALE_WINDOW_MS = 60_000
+
+/** The silence window for a platform that pushes every `tickMs`. */
+function staleTimeoutFor(tickMs: number | null): number {
+  const period = tickMs == null || !Number.isFinite(tickMs) || tickMs <= 0 ? ASSUMED_TICK_MS : tickMs
+  return Math.min(MAX_STALE_WINDOW_MS, Math.max(MIN_STALE_WINDOW_MS, period * STALE_TICKS))
+}
 // Consecutive malformed frames on one channel before its panel is marked stale.
 // One bad frame is an incident, not an outage: a platform mid-deploy can emit a
-// single odd frame and recover on the next tick. Three at 1Hz is three seconds —
-// under the silence watchdog below, so a channel going bad can never take longer
-// to surface than the whole stream going quiet.
+// single odd frame and recover on the next tick. Three ticks is under the silence
+// window above (six), whatever the platform's period turns out to be, so a channel
+// going bad can never take longer to surface than the whole stream going quiet.
 const MALFORMED_TOLERANCE = 3
 // After a dead/stalled stream, wait this long before rebuilding the EventSource.
 // How long to wait before rebuilding a stream that failed. This is not the whole
@@ -72,7 +96,7 @@ const RECONNECT_DELAY_MS = 5000
  * A channel the platform publishes on. Each one feeds a different part of the
  * screen, so they are tracked apart: one bad channel must not blank the rest.
  */
-export type Channel = 'trace' | 'metrics' | 'modules' | 'summary'
+export type Channel = 'ready' | 'trace' | 'metrics' | 'modules' | 'summary'
 
 /**
  * Per-channel health. `rejected` counts frames dropped since the channel was last
@@ -94,6 +118,7 @@ export type ChannelStates = Record<Channel, ChannelHealth>
 
 const HEALTHY: ChannelHealth = { rejected: 0, total: 0, stale: false }
 export const ALL_HEALTHY: ChannelStates = {
+  ready: HEALTHY,
   trace: HEALTHY,
   metrics: HEALTHY,
   modules: HEALTHY,
@@ -108,6 +133,35 @@ export type ConnState =
   | { status: 'unreadable'; lastUpdated: number | null } // connected and receiving, but nothing we can read
   | { status: 'paused'; lastUpdated: number | null } // stream deliberately closed by the user
 
+/**
+ * What the platform told us about itself when this connection opened — the
+ * `ready` ack, with every field nullable.
+ *
+ * `null` for the whole thing means no ack arrived: an older platform, another
+ * implementation that has not adopted the frame yet, or the sample demo. `null`
+ * for one field means the ack did not carry a value this console could read for
+ * it. Both say the same thing, and it is the only honest thing to say: we do not
+ * know. Nothing here is defaulted into a number the screen could then present as
+ * something the platform said.
+ *
+ * Connection-scoped, like the ack itself: it is dropped when the stream is rebuilt
+ * and re-learned from the next ack, because `capacity` and the enabled flags are
+ * live settings on the platform and the values from the last connection may no
+ * longer be true.
+ */
+export type PlatformInfo = { [K in keyof StreamReady]: StreamReady[K] | null }
+
+/** A `ready` value we can use, or `null` — never a substitute for one. */
+function str(v: unknown): string | null {
+  return typeof v === 'string' ? v : null
+}
+function bool(v: unknown): boolean | null {
+  return typeof v === 'boolean' ? v : null
+}
+function int(v: unknown): number | null {
+  return typeof v === 'number' && Number.isFinite(v) ? v : null
+}
+
 function mockData(now: number): LiveData {
   return {
     traces: mockTraces(now),
@@ -131,6 +185,7 @@ export function useConsoleData(settings?: { sampleDelayMs: number }) {
   const [conn, setConn] = useState<ConnState>({ status: 'initial' })
   const [streaming, setStreaming] = useState(true)
   const [channels, setChannels] = useState<ChannelStates>(ALL_HEALTHY)
+  const [platform, setPlatform] = useState<PlatformInfo | null>(null)
 
   const tracesRef = useRef<RequestTrace[]>([])
   const metricsRef = useRef<ModuleMetricsSnapshot[]>([])
@@ -160,6 +215,12 @@ export function useConsoleData(settings?: { sampleDelayMs: number }) {
     // first is owed to the operator the moment the data stops, the second must wait
     // until this stream has had its own chance to deliver something.
     let openedAt = 0
+    // The silence window this connection is judged by. It starts as the assumed
+    // period and narrows or widens to the one the `ready` ack states, so the
+    // watchdog stops being a guess about the platform's tick the moment the
+    // platform declares it. Reset per connection, since a rebuilt stream may reach
+    // a platform that pushes at a different rate.
+    let staleWindowMs = staleTimeoutFor(null)
 
     function publish() {
       const traces = tracesRef.current
@@ -243,22 +304,46 @@ export function useConsoleData(settings?: { sampleDelayMs: number }) {
       return v as T
     }
 
+    /**
+     * Read the connection ack. Unknown fields are ignored and a field whose value
+     * is not the type the contract promises is read as "not stated" rather than as
+     * a malformed frame: the ack is extensible by design, and one field this
+     * console cannot read is no reason to discard the six it can.
+     */
+    function readReady(e: Event): PlatformInfo | null {
+      const v = readObject<Record<string, unknown>>(e, 'ready')
+      if (!v) return null
+      return {
+        platform: str(v.platform),
+        platformVersion: str(v.platformVersion),
+        tracesEnabled: bool(v.tracesEnabled),
+        metricsEnabled: bool(v.metricsEnabled),
+        buffered: int(v.buffered),
+        tickMs: int(v.tickMs),
+        capacity: int(v.capacity),
+      }
+    }
+
     // (Re)arm the silence watchdog. A healthy stream pushes metrics/modules
-    // snapshots ~1×/s, so if nothing arrives within STALE_TIMEOUT_MS the connection
-    // is dead — even when EventSource still reports it open. A dev proxy (Vite) can
-    // hold the client socket open after the upstream dies, so 'error' never fires;
-    // the watchdog is then the ONLY signal that we've lost the platform.
+    // snapshots every tick, so if nothing arrives within `staleWindowMs` the
+    // connection is dead — even when EventSource still reports it open. A dev proxy
+    // (Vite) can hold the client socket open after the upstream dies, so 'error'
+    // never fires; the watchdog is then the ONLY signal that we've lost the platform.
     //
     // The deadline is anchored to the last frame we accepted, not to this call, so
     // re-arming can only bring it closer. `open` re-arms on every rebuilt stream,
     // and a refused platform rebuilds every RECONNECT_DELAY_MS (5s) — under the 6s
-    // window. Setting a fresh 6s each time let the retry loop postpone the deadline
-    // it exists to trip, and the console held LIVE over a platform that was gone
-    // for as long as it kept failing.
+    // window a 1Hz platform gets. Setting a fresh window each time let the retry
+    // loop postpone the deadline it exists to trip, and the console held LIVE over
+    // a platform that was gone for as long as it kept failing.
+    //
+    // ⚠️ A platform that states a tick slower than RECONNECT_DELAY_MS gets a window
+    // wider than its own retry interval, which is the correct way round: the
+    // deadline is anchored to the last frame, so retries still cannot push it.
     function armWatchdog() {
       window.clearTimeout(staleTimer)
       const last = lastUpdatedRef.current
-      const remaining = last == null ? STALE_TIMEOUT_MS : Math.max(0, STALE_TIMEOUT_MS - (Date.now() - last))
+      const remaining = last == null ? staleWindowMs : Math.max(0, staleWindowMs - (Date.now() - last))
       staleTimer = window.setTimeout(onSilence, remaining)
     }
 
@@ -269,14 +354,14 @@ export function useConsoleData(settings?: { sampleDelayMs: number }) {
       // stream would only fetch the same frames again. Report it for what it is
       // and keep the stream — the panels already name which channel went quiet.
       const lastFrame = lastFrameAtRef.current
-      if (everOpenRef.current && lastFrame != null && Date.now() - lastFrame < STALE_TIMEOUT_MS) {
+      if (everOpenRef.current && lastFrame != null && Date.now() - lastFrame < staleWindowMs) {
         setConn({ status: 'unreadable', lastUpdated: lastUpdatedRef.current })
         // Anchored to the last frame, like the deadline above. Re-arming a fresh
         // window here would let the check drift a window behind the traffic, so a
         // platform that went unreadable and then silent could take twice as long to
         // be called an outage as one that simply went silent.
         window.clearTimeout(staleTimer)
-        staleTimer = window.setTimeout(onSilence, Math.max(0, STALE_TIMEOUT_MS - (Date.now() - lastFrame)))
+        staleTimer = window.setTimeout(onSilence, Math.max(0, staleWindowMs - (Date.now() - lastFrame)))
         return
       }
 
@@ -290,12 +375,12 @@ export function useConsoleData(settings?: { sampleDelayMs: number }) {
       // was opened for — the deadline above is anchored to the last frame, so it
       // can come due while this stream is still new.
       const streamAge = Date.now() - openedAt
-      if (streamAge >= STALE_TIMEOUT_MS) {
+      if (streamAge >= staleWindowMs) {
         reconnect()
         return
       }
       window.clearTimeout(staleTimer)
-      staleTimer = window.setTimeout(onSilence, STALE_TIMEOUT_MS - streamAge)
+      staleTimer = window.setTimeout(onSilence, staleWindowMs - streamAge)
     }
 
     // Tear down the (possibly half-open) stream and rebuild it after a short delay,
@@ -320,6 +405,12 @@ export function useConsoleData(settings?: { sampleDelayMs: number }) {
 
     function open() {
       openedAt = Date.now()
+      // Connect-time facts belong to the connection that stated them. Carrying the
+      // last one's `capacity` or `metricsEnabled` into this one would put a claim
+      // on screen that nothing has made this connection — they are live settings,
+      // and the platform answering now may not be the one that answered before.
+      staleWindowMs = staleTimeoutFor(null)
+      setPlatform((p) => (p === null ? p : null))
       try {
         es = new EventSource(STREAM_URL)
       } catch {
@@ -334,6 +425,17 @@ export function useConsoleData(settings?: { sampleDelayMs: number }) {
 
       es.addEventListener('open', () => markLive())
 
+      // The ack. Listening for it is the point of the frame: on a quiet platform
+      // nothing else arrives, so this is the only thing that tells the console the
+      // stream is live rather than merely open.
+      es.addEventListener('ready', (e) => {
+        const info = readReady(e)
+        if (!info) return
+        setPlatform(info)
+        staleWindowMs = staleTimeoutFor(info.tickMs)
+        markLive() // re-arms the watchdog on the window the platform just stated
+      })
+
       es.addEventListener('trace', (e) => {
         const batch = readArray<RequestTrace>(e, 'trace')
         if (!batch) return
@@ -395,5 +497,5 @@ export function useConsoleData(settings?: { sampleDelayMs: number }) {
     }
   }, [streaming, settings?.sampleDelayMs])
 
-  return { data, conn, channels, streaming, setStreaming }
+  return { data, conn, channels, platform, streaming, setStreaming }
 }
diff --git a/src/lib/types.ts b/src/lib/types.ts
index ce2c8d0..8b231ff 100644
--- a/src/lib/types.ts
+++ b/src/lib/types.ts
@@ -1,3 +1,30 @@
+/**
+ * Mirrors org.htcom.protean.web.StreamReady (SSE `ready` event).
+ *
+ * The connection acknowledgement: the first frame of every stream connection,
+ * ahead of the initial `trace` replay, and repeated on every reconnect. It exists
+ * because "the stream is open" and "the platform is actually running" look
+ * identical to a client on a quiet platform — nothing else arrives until traffic
+ * does.
+ *
+ * It carries only what a client must learn once, at connect time, and cannot
+ * derive from the stream afterwards. Everything that changes on a schedule stays
+ * in the `metrics` / `modules` / `summary` frames.
+ *
+ * `platform` is display and diagnostics only — the console must not branch its
+ * behaviour on which implementation answered. Later versions may add fields; the
+ * console ignores the ones it does not recognize.
+ */
+export interface StreamReady {
+  platform: string // implementation id, e.g. "protean" (Java), for display only
+  platformVersion: string | null // null when the platform cannot read its own version
+  tracesEnabled: boolean // protean.trace.enabled
+  metricsEnabled: boolean // protean.trace.metrics.enabled
+  buffered: number // rows the `trace` frame that follows carries — not the ring's size
+  tickMs: number // push period, the contract a silence watchdog sizes itself against
+  capacity: number // protean.trace.capacity as of this connection
+}
+
 // Mirrors org.htcom.protean.runtime.RequestTrace
 export interface RequestTrace {
   seq: number
diff --git a/src/test/stream-fixtures.ts b/src/test/stream-fixtures.ts
index 40606b6..330ab72 100644
--- a/src/test/stream-fixtures.ts
+++ b/src/test/stream-fixtures.ts
@@ -13,7 +13,10 @@
  * both rather than against one and a guess about the other:
  *
  *  - Spring opens with the ring-buffer dump; Go opens with a `hello` frame the
- *    console has no listener for, then the dump.
+ *    console has no listener for, then the dump. Protean has since replaced both
+ *    openings with a `ready` ack — see `PROTEAN_CONNECT` below, and note that the
+ *    two captures are kept as they are: platforms that send no ack still exist
+ *    (Go and Rust have not adopted it), and that is an axis worth testing.
  *  - Both send the dump newest-first, as one array in one frame.
  *  - Module rows carry different fields (`controllerFqcn`/`needsSharedBeans`
  *    exist only on the JVM); `mode` is the field the console reads.
@@ -52,10 +55,58 @@ data: {"windowMs":60000,"count":5,"errorCount":0,"errorRate":0,"p50LatencyMs":0,
 
 `
 
-/** Both connect sequences, for scenarios that must hold on either platform. */
+/**
+ * Protean (Java) with the `ready` ack — captured 2026-09-21 against
+ * `examples/quickstart` on :8080 (in-process mode, H2), running protean `237bcd0`
+ * (#80, `feat(web): ack a console stream connection with a ready frame`).
+ *
+ * Abridged the same way as the two captures above: correlation ids are synthetic
+ * because this is a public repository. Everything else is the bytes as they
+ * arrived — `event:ready` with no space after the colon, the ack ahead of the
+ * replay, and `buffered` equal to the number of rows in the `trace` frame that
+ * follows it (5 and 5, asserted in `ready-ack.test.ts`).
+ *
+ * Two values here are the platform as it really runs, not as a contract example
+ * would draw it, and both are worth keeping:
+ *
+ *  - `platformVersion` is `0.1.0-SNAPSHOT` — a development build. The console
+ *    prints it and does not compare it: the only released version, `0.0.1`, sends
+ *    no ack at all, and a `-SNAPSHOT` sorts *below* the release it precedes.
+ *  - `metricsEnabled` is `false`, quickstart's default, with an empty `metrics`
+ *    frame behind it. That pairing is the one the console used to misread as
+ *    "enable this setting" when it was already on.
+ */
+export const PROTEAN_CONNECT = `event:ready
+data:{"platform":"protean","platformVersion":"0.1.0-SNAPSHOT","tracesEnabled":true,"metricsEnabled":false,"buffered":5,"tickMs":1000,"capacity":200}
+
+event:trace
+data:[{"seq":5,"epochMillis":1789971324093,"method":"GET","uri":"/platform/mcp","pattern":"/**","moduleId":null,"status":404,"latencyMs":0,"error":null,"traceId":"cccc0000-0000-4000-8000-000000000005"},{"seq":4,"epochMillis":1789971324089,"method":"POST","uri":"/platform/mcp","pattern":"/**","moduleId":null,"status":404,"latencyMs":0,"error":null,"traceId":"cccc0000-0000-4000-8000-000000000004"},{"seq":3,"epochMillis":1789971324080,"method":"POST","uri":"/platform/mcp","pattern":"/**","moduleId":null,"status":404,"latencyMs":3,"error":null,"traceId":"cccc0000-0000-4000-8000-000000000003"},{"seq":2,"epochMillis":1789971283514,"method":"GET","uri":"/platform/modules","pattern":"/platform/modules","moduleId":null,"status":200,"latencyMs":0,"error":null,"traceId":"cccc0000-0000-4000-8000-000000000002"},{"seq":1,"epochMillis":1789971283503,"method":"GET","uri":"/platform/modules","pattern":"/platform/modules","moduleId":null,"status":200,"latencyMs":21,"error":null,"traceId":"cccc0000-0000-4000-8000-000000000001"}]
+
+event:metrics
+data:[]
+
+event:modules
+data:[{"id":"sample-data-access","version":"1","trustTier":"TRUSTED","desiredState":"ACTIVE","controllerFqcn":"sample.items.ItemController","mode":"in-process","needsSharedBeans":false,"bridgedInterfaces":null,"boundGeneration":0,"kind":"NORMAL","exports":[],"uses":[],"boundLibraryGenerations":[],"libraryGeneration":null,"scope":null,"runtimeId":"main"}]
+
+event:summary
+data:{"windowMs":60000,"count":3,"errorCount":0,"errorRate":0.0,"p50LatencyMs":0,"p95LatencyMs":3,"p99LatencyMs":3,"maxLatencyMs":3,"requestsDeltaPct":0.5,"errorRateDeltaPp":0.0,"p95DeltaMs":-18,"activeModules":1,"modulesByMode":{"in-process":1}}
+
+`
+
+/**
+ * Every connect sequence, for scenarios that must hold on any platform.
+ *
+ * `newestEpoch` is that fixture's newest trace, because "and then real traffic
+ * arrives" means newer than *this* capture — and the three were taken weeks
+ * apart. A scenario that loops over these must take the epoch from the row it is
+ * running, not from a single constant: the protean capture is three weeks newer
+ * than the other two, so one shared floor would make traffic "arrive" before the
+ * replay it follows on two of the three.
+ */
 export const PLATFORMS = [
-  { name: 'spring', connect: SPRING_CONNECT },
-  { name: 'go', connect: GO_CONNECT },
+  { name: 'protean', connect: PROTEAN_CONNECT, newestEpoch: 1789971324093 },
+  { name: 'spring', connect: SPRING_CONNECT, newestEpoch: 1788159685413 },
+  { name: 'go', connect: GO_CONNECT, newestEpoch: 1788161788025 },
 ] as const
 
 /**
@@ -79,5 +130,15 @@ export function traceFrame(seq: number, atMillis: number): string {
   ])
 }
 
-/** Newest epoch in a connect fixture — the floor for `traceFrame` timestamps. */
+/**
+ * Newest epoch in the **Go** capture — the floor for `traceFrame` timestamps in
+ * scenarios that replay `GO_CONNECT` alone.
+ *
+ * Deliberately not the newest of all three. Scenarios that seed synthetic history
+ * around this value and then assert which rows get evicted need that history to
+ * sit next to the replayed rows on the same timeline; anchoring it to a capture
+ * three weeks later would put every seeded row above every replayed one and quietly
+ * change what those tests are measuring (measured: two of them then failed). A
+ * scenario running against several platforms takes `newestEpoch` from `PLATFORMS`.
+ */
 export const FIXTURE_NEWEST_EPOCH = 1788161788025
diff --git a/vite.config.ts b/vite.config.ts
index cbccf58..787b365 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -1,24 +1,49 @@
 import path from 'node:path'
-import { defineConfig } from 'vite'
+import { defineConfig, loadEnv } from 'vite'
 import react from '@vitejs/plugin-react'
 import tailwindcss from '@tailwindcss/vite'
 
 // https://vite.dev/config/
-export default defineConfig({
-  plugins: [react(), tailwindcss()],
-  resolve: {
-    alias: {
-      '@': path.resolve(__dirname, './src'),
+export default defineConfig(({ command, mode }) => {
+  /**
+   * The platform this dev server talks to — resolved once, here, and then used by
+   * both the proxy and the header that names it.
+   *
+   * Two things were wrong with reading it separately in each place. The proxy read
+   * `process.env`, which does not carry `.env` files (Vite loads those itself), so
+   * setting `VITE_PROTEAN_TARGET` in `.env` moved the label in the header while
+   * every request still went to the default — the header named a host nothing was
+   * sent to. And with the variable unset the two fell back differently: the proxy
+   * to `http://localhost:8080`, the header to the dev server's own origin. Both
+   * are the same question, so it is answered in one place and handed to both.
+   */
+  const env = loadEnv(mode, process.cwd(), 'VITE_')
+  const platformTarget = env.VITE_PROTEAN_TARGET?.trim() || 'http://localhost:8080'
+
+  return {
+    plugins: [react(), tailwindcss()],
+    resolve: {
+      alias: {
+        '@': path.resolve(__dirname, './src'),
+      },
     },
-  },
-  server: {
-    // Dev proxy → any Protean-enabled Spring app exposing the /platform control plane.
-    // Override the target with VITE_PROTEAN_TARGET when the platform runs elsewhere.
-    proxy: {
-      '/platform': {
-        target: process.env.VITE_PROTEAN_TARGET ?? 'http://localhost:8080',
-        changeOrigin: true,
+    // Dev only, and deliberately so: `vite build` carries no proxy, so a production
+    // bundle sends every request to its own origin whatever this said at build time.
+    // Injecting it there would let the header name an address no request goes to —
+    // which is why the console ignores this variable outside dev (`platformOrigin`).
+    define:
+      command === 'serve'
+        ? { 'import.meta.env.VITE_PROTEAN_TARGET': JSON.stringify(platformTarget) }
+        : {},
+    server: {
+      // Dev proxy → any Protean-enabled Spring app exposing the /platform control plane.
+      // Override the target with VITE_PROTEAN_TARGET (shell or .env).
+      proxy: {
+        '/platform': {
+          target: platformTarget,
+          changeOrigin: true,
+        },
       },
     },
-  },
+  }
 })