Critique 02: engineering correctness and safety

Round 2, 2026-10-13. Lens: engineering correctness and safety. Scope: prototype/server.py, mind.html, standard.html, index.html, and the tokens in shared.css where code depends on them. Reviewed against the bundled claude-api skill (2.1.291, Python SDK anthropic 1.13.0 as resolved by the script header) and research/claude-wiring.md.

Summary

The Claude wiring is sound where it matters most. The request shape matches the skill: beta stream, server-side-fallback-2026-07-01 paired with fallbacks: "default", explicit thinking: {type: "adaptive"}, output_config carrying effort low and a plain json_schema format, no sampling parameters, no prefill, no forced tool choice. The offline self-test passes. The schema is accepted live, say streams before ui, the streamed caption equals the final caption on every successful turn, the 1-hour system cache is byte-stable across server restarts, and append-only replay of a thinking block plus a mid-conversation surface note works live. Nothing a visitor types reaches the server log, the key is never printed, path traversal is blocked, and no model or fixture string reaches innerHTML.

The serious problems sit around that core:

1. mind.html breaks at phone width after every answer: the stage grid grows to the min-content width of the chip row, so on a 390 px phone the layout viewport becomes 741 px and the answer is clipped. Root cause found and a three-rule CSS fix verified in the browser.
2. The opening fork stays a blank white page for as long as the three.js CDN request stalls, because the lockup and doors are revealed only after three.js loads.
3. The local proxy accepts any Host, any Origin and text/plain bodies, with no budget, so any web page (or a DNS-rebinding page) can spend the owner's Anthropic key while it runs.
4. Both clients silently and permanently switch to scripted demo answers after any failed request (a 400, 429, 5xx, a restart, or the 81-message cap at the 42nd question).
5. On the standard route, an answer with two page-backed components keeps only the last one on the page.
6. Owner decisions 1, 2, 6 and 7 are not yet met in code, and decision 3 still has five uses of the retired ember.

Live spend: 6 exchanges, about $0.063. The server was stopped by its exact PID and port 8777 was verified free. Scratch files were removed.

How this was checked

Results at a glance

Self-test

scanner fuzz: 400/400 ok
sanitizer: ok {'dropped_ids': 3, 'dropped_components': 4}
digest: 38,880 chars (~9,720 tokens), schema 2,064 chars
exit 0

dropped_components should be 3 for that input; see finding 24 (double count). The token estimate is chars/4 and is about half the real figure; see finding 15.

Live exchanges (Claude Opus 5.5, effort low)

All six turns read the 19,468-token system prefix from the 1-hour cache that round 1 wrote about 40 minutes earlier, which also shows the digest is byte-identical across restarts.

Total about $0.063. request_id was null on all six (finding 22).

What holds up

• Request shape matches the skill exactly (verified in the harness): model=claude-opus-5-5, betas=["server-side-fallback-2026-07-01"], fallbacks="default", thinking={"type":"adaptive"}, output_config={"effort":"low","format":{"type":"json_schema",...}}, max_tokens=6000, two system blocks with the 1-hour marker on the snapshot block.
• The schema (an anyOf of seven closed objects, ["string","null"] unions) is accepted, and the decoder follows property order: say streams first, then each component as its object closes.
• Append-only history is exact: turn 2's request starts with turn 1's request byte for byte, holds [user, system, assistant(thinking, text), user, system], and ignores the client's copy of the assistant turn when the stored record matches.
• The incremental reader is correct under fuzzing (400/400), including escapes and surrogate pairs split across chunks.
• No visitor text in the server log (grep over the log for words from all six prompts: 0 hits); tracebacks print code lines only; the key is read once from secrets.json and never logged.
• Path traversal is blocked for raw .., %2e%2e, ..%2f and sibling directories (/..%2fbrief/... and /%2e%2e/research/... both 404).
• XSS: every model and fixture string is written with textContent, append or attribute setters. The three innerHTML sinks in standard.html (countdown, merge bar, dock note) receive only numbers and constant maps.
• SIGTERM shutdown is clean: the shutdown thread pattern is correct, the PID file is removed, the uv parent exits, the port is released.
• index.html: three.js is pinned to 0.180.0; the GPU path runs at 96 to 102 fps on an M1 Max; the console is clean; ?still=1 and ?nowebgl=1 work; WebGL context loss falls back to the CSS realm; tab order is skip link, map door, mind door.

Findings, ranked

1. Blocker - mind.html: the answer overflows and is clipped at phone width

Evidence. At 390 x 844 with mobile emulation, after one answer the layout viewport is 741 px and .stage resolves to a single 725 px column, so captions and session titles run off both edges (shots/c2e-mind-overflow-now-390x844.png; the round-1 shot mind-after2-390x844.png shows the same clipping). At 1440 x 900 a long unbroken question pushes the document to 4,899 px wide and the speaker grid runs off-screen (shots/c2e-mind-400-to-demo-1440x900.png).

Cause. .stage (line 61), .turn (line 80) and .ui (line 93) are grids with an implicit auto column, so the track takes the min-content width of its widest unbreakable descendant. Below 560 px, .chips is flex-wrap: nowrap (line 195); its scroll container does not reduce the min-content contribution of the .comp block that wraps it, and a long unbroken ask string does the same at any width. .thread{width:min(100%,760px)} cannot cap it because 100% resolves against the blown-out track.

Fix (verified in headless Chrome: 390 stays 390 and the 1440 case stays 1440; shots/c2e-mind-overflow-fixed-390x844.png):

.stage, .turn, .ui { grid-template-columns: minmax(0, 1fr); }
.thread > .turn, .comp { min-width: 0; }
.ask, .say { overflow-wrap: anywhere; }

Add a regression check to the capture script: after an answer, document.documentElement.scrollWidth === innerWidth at 390 px.

2. Major - index.html: the fork is blank while the three.js CDN stalls

Evidence. With requests to cdn.jsdelivr.net held open, after 8 s is-live is never set, the lockup and both doors are at opacity 0, and the page is plain white (shots/c2e-opening-cdn-stalled-1440x900.png). With the CDN failing fast the CSS realm takes over correctly, so only the slow-failure case is broken. The invisible doors remain focusable.

Cause. .reveal elements start at opacity 0 and animate only after goLive(), which runs only from boot() after import('three') resolves (line 313, line 730) or from fallbackToCss(). A stalled request can stay pending for minutes. Even when the CDN works, time to the fork is download plus parse of about 2.0 MB of JavaScript (three.module.js 603 KB imports three.core.js 1.40 MB, uncompressed) plus shader compile, before the 2.6 to 4.3 s reveal delays start counting.

Fix. Make the DOM independent of the realm:

const liveTimer = setTimeout(goLive, 1500);                      // the fork never waits on the CDN
const withTimeout = (p, ms) => Promise.race([p, new Promise((_, no) => setTimeout(() => no(new Error('timeout')), ms))]);
withTimeout(import('three'), 2500).then(boot).catch((err) => fallbackToCss('three.js unavailable: ' + err.message));

goLive is already idempotent (classList.add). Self-host three.js (or, better, replace it: the realm uses one fullscreen triangle, two render-target passes and a 3D texture, which raw WebGL2 covers in about 150 lines) and add <link rel="modulepreload"> for whatever remains.

3. Major - server.py: no Host, Origin or Content-Type checks, and no budget

Evidence (zero-cost probes, Appendix A). GET / with Host: attacker.example returns 200, which is the DNS-rebinding shape. POST /api/mind with Origin: https://evil.example and Host: evil.example:8777 goes straight to body validation; with a valid body it would reach Claude. Content-Type: text/plain;charset=UTF-8 is accepted, which is the CORS simple-request shape that needs no preflight. There is no authentication, rate limit or spend ceiling, and a valid request may carry 81 messages of 2,000 characters (roughly 40,000 to 55,000 uncached input tokens, about $0.16 to $0.22 a request). The key is the owner's personal anthropic.api_key from secrets.json.

Why it matters. Binding to 127.0.0.1 keeps the LAN out but not the browser: any page the owner visits while the prototype runs can POST to it blind (browsers gate public-to-loopback requests unevenly), and a rebinding page can read the answers too. The exposure jumps the moment the prototype is tunnelled for a Zpryme demo, which is a likely next step: it becomes an open Opus proxy on the owner's key.

Fix (lines 604 to 648):

ALLOWED_HOSTS = {f"127.0.0.1:{PORT}", f"localhost:{PORT}"}
ALLOWED_ORIGINS = {f"http://127.0.0.1:{PORT}", f"http://localhost:{PORT}"}

def _guard(self, post: bool) -> bool:
    if self.headers.get("Host") not in ALLOWED_HOSTS:
        self._json(421, {"error": "misdirected request"}); return False
    if post:
        origin = self.headers.get("Origin")
        if origin is not None and origin not in ALLOWED_ORIGINS:
            self._json(403, {"error": "forbidden origin"}); return False
        if (self.headers.get("Content-Type") or "").split(";")[0].strip().lower() != "application/json":
            self._json(415, {"error": "expected application/json"}); return False
    return True

Call it first in do_GET and do_POST. Add a process-wide limit (for example 30 turns per 10 minutes and a daily output-token ceiling summed from logged usage), and refuse to start on a non-loopback address unless an explicit flag and a shared token are given. For any shared demo, use a Zpryme-owned workspace and key with a Console spend limit (research section 3.5).

4. Major - mind.html and standard.html: any failed request silently and permanently switches to scripted demo answers

Evidence. mind.html?q= with 3,000 characters gets a 400 from the server; the page then shows the scripted lineup answer as if the mind had replied, flips data-mode to offline, and the next question makes no request at all and gets another scripted answer (1 POST for 2 questions). Only a small DEMO MODE tag changes (shots/c2e-mind-400-to-demo-1440x900.png).

Cause. streamAnswer throws on any non-OK status and ask()'s catch sets body.dataset.mode='offline' when no event has arrived yet (mind.html lines 445 to 448, standard.html line 544). The same path is taken for 429, 5xx, a server restart, a network blip, and the session cap: the server rejects more than 81 messages, so the 42nd question fails (sooner after failed turns, finding 13). Nothing ever switches back. This contradicts design-direction 4.7, where the unavailable state offers the map and recovers without a reload.

Fix. Keep demo mode for an explicit ?demo=1 or a failed boot health probe only. On a runtime failure, render the error state (persona copy, a retry chip, the [ open the map ] link), keep mode=live, and re-probe /api/health with backoff before the next send. Treat a 400 as a conversation reset: clear history, mint a new session id, and say so in one line. Have the server answer the cap with an explicit session_full code instead of a generic 400.

5. Major - standard.html: a second page-backed component wipes the first

Evidence. Replaying the real live answer from exchange 2 (venue_card + ticket_cta) into the dock leaves a merged component only in #register; the venue merge is gone, while the dock shows two shown on the page - jump there notes, one pointing at a section where nothing is merged (shots/c2e-standard-merge-1440x900.png). The merged ticket list also duplicates the ticket cards directly below it, with the dock-only classes unstyled in page context.

Cause. mergeIntoPage() calls clearMerges() for every component (line 506).

Fix. Clear once per answer (at the start of ask()), then merge each page-backed component. Better still, follow design-direction 5.6: reveal or filter what the page already shows (scroll to #register, hairline highlight, [ clear ]) instead of inserting a duplicate block.

6. Major - mind.html: the head shows through the answer as a grey disc (owner decision 6)

Evidence. At 1440 x 900, once the first answer scrolls up, the head (fixed, #realm at z-index 0 under the stage) reads as a grey egg behind the caption and the first kit line, because the components have transparent or 46 % white backgrounds (shots/c2e-mind-head-behind-content-1440x900.png, and the same at 390 px).

Fix. Choose one of the two forms decision 6 allows. Fade: add a class on the first ui event and transition #head and #realm .glow to opacity 0 over about 400 ms (body.has-ui #head, body.has-ui #realm .glow { opacity: 0 }). Glyph: move the presence into a small fixed glyph in .topbar beside the brand and keep the thinking pulse there. Either way, retint the pulse with --accent (finding 21).

7. Major - index.html: decisions 1 and 2 are not implemented, and the hand-off must not auto-send

Evidence. The fork still carries the round-1 copy (ENTER THE SITE, ASK THE MIND, the old explainers), no // two ways in eyebrow, no // you can switch any time., no [ browse ] / [ ask ] corner tags, link names made of all inner text, and the lockup reads // AUSTIN, TX // 2027 instead of // MAY 3-6, 2027 // AUSTIN, TX. Pressing / or a letter on the fork does nothing (verified). Tab order (map, then mind) is already right.

Engineering trap. mind.html auto-sends any ?q= on load (lines 538 to 539). If the fork hands a typed character over as mind.html?q=a, the visitor's first keystroke becomes a paid one-character question. An auto-sending query parameter is also a cost-abuse vector in production: any page can link to or frame it and trigger a turn per view.

Fix. Hand off without sending, in the fragment so it stays out of logs and referrers:

addEventListener('keydown', (e) => {
  if (e.defaultPrevented || e.ctrlKey || e.metaKey || e.altKey || e.isComposing) return;
  if (e.key === '1' || e.key === '2') { doors[Number(e.key) - 1].click(); return; }
  if (e.key === '/') { e.preventDefault(); location.href = './mind.html#compose'; return; }
  if (e.key.length === 1 && e.key.trim()) { e.preventDefault(); location.href = './mind.html#draft=' + encodeURIComponent(e.key); }
});

mind.html reads #draft= into the composer and focuses it without sending. Drop the auto-send for ?q= (or require a user gesture) and send frame-ancestors 'none' in production.

8. Major - mind.html: no plain link to the standard-page equivalent on components (owner decision 7)

Evidence. Components carry no link to the map; only the unavailable and busy error states do (showError, line 484). On the standard route the merged session_list has no sample marker (its kit line is only the day label, and the agenda section has no sample note; the only sample note is in the hero).

Fix. In addComp, append one plain link per page-backed type, using the design's notation:

const MAP_HREF = { speaker_grid: '#lineup', session_list: '#agenda', venue_card: '#venue', ticket_cta: '#register', sponsor_wall: '#partners' };
if (MAP_HREF[tree.type]) { const a = el('a', 'escape', '[ open the map ]'); a.href = './standard.html' + MAP_HREF[tree.type]; wrap.appendChild(a); }

Add the day to the agenda link when tree.day is set, and add sample to the standard route's session_list kit line.

9. Minor (major in production) - server.py: client-supplied assistant turns are trusted

Evidence. When no stored record matches, build_messages rebuilds history from the client's strings (lines 489 to 492), so the client can write the mind's past turns. The harness confirms forged assistant text reaches the model. Live exchange 6 sent a forged promise to reveal the instructions; the model began to walk it back and the safety classifier ended the turn with a reasoning_extraction refusal, so nothing leaked, but the defence was the model, not the server. Session ids are client-chosen (Math.random()), so in any shared deployment one visitor could also continue another's stored conversation by guessing the id.

Fix. Never accept assistant content from the client. For the prototype: on a mismatch, start a fresh history from the new message only and tell the client to reset. For production (research 3.4 and 3.5): the client sends only the new message; history lives server-side under a server-issued, unguessable, HttpOnly session cookie.

10. Minor - server.py and both clients: provisional components are never reconciled with the final answer

Evidence. The server emits every closed component, ignoring the four-component cap that sanitize_answer applies to the final answer; the harness streamed six ui events for a final answer of four, and mind.html rendered six (mocked from that shape). Streamed index values are raw element positions, so when an earlier element is dropped the indexes no longer match the final list (harness: a lone valid venue_card streamed as index 1, final position 0). After truncated, refused or invalid, provisional components stay on screen under the error caption (verified with a mocked truncated stream). The clients store done.answer for history but never render from it.

Fix. Server (lines 534 to 539): stop emitting once LIMITS["components"] clean components have gone out, and number them by emitted count. Clients: on done, re-render .ui from answer.ui without the entry animation (or diff by position); on error, remove or visibly retire the provisional components.

11. Minor - server.py: storage after a fallback strips the fallback model's thinking

Evidence. Line 571 keeps only text blocks whenever a fallback ran. The skill's rule (shared/model-migration.md, refusal section, "Echoing fallback turns back") drops thinking, redacted_thinking and tool_use only before the last fallback block; everything after the boundary echoes normally, and the same guide warns that removing regular thinking blocks yourself can trigger ordering or signature 400s. The harness shows a pre-output fallback stored as ['text'], discarding the fallback model's own thinking.

Fix. Port the research doc's toHistoryContent:

def history_content(content):
    kinds = [b.type for b in content]
    last = max((i for i, k in enumerate(kinds) if k == "fallback"), default=-1)
    if last < 0:
        return list(content)
    return [b for i, b in enumerate(content)
            if i > last or b.type not in ("thinking", "redacted_thinking", "tool_use")]

12. Minor - server.py: request handling has no body cap, no socket timeout, and three crash paths

Evidence (Appendix A).

• A negative Content-Length with the socket left open, or a Content-Length larger than the bytes sent, pins a handler thread until the client hangs up (no timeout on the handler). There is no upper bound on Content-Length.
• A JSON body that is not an object ([1,2,3], "hello") raises AttributeError; a list or object mode raises TypeError (unhashable); a %00 in a static path raises ValueError in resolve(). Each drops the connection with no response and prints a traceback.
• --pid-file with no value raises IndexError.

Fix.

class Handler(BaseHTTPRequestHandler):
    timeout = 20                                   # slow or half-sent requests cannot pin a thread
MAX_BODY = 256 * 1024
# do_POST
try:
    n = int(self.headers.get("Content-Length", ""))
except ValueError:
    return self._json(411, {"error": "length required"})
if not 0 < n <= MAX_BODY:
    return self._json(413, {"error": "body too large"})
try:
    body = json.loads(self.rfile.read(n))
except ValueError:
    return self._json(400, {"error": "invalid JSON"})
if not isinstance(body, dict) or not isinstance(body.get("mode", "mind"), str):
    return self._json(400, {"error": "expected an object"})
# do_GET
try:
    target = (ROOT / rel).resolve()
except (ValueError, OSError):
    return self._json(404, {"error": "not found"})

13. Minor - both clients: a failed turn leaves a dangling user message and knocks the server off its exact history

Evidence. ask() pushes the user message before the request and pushes an assistant message only on done. After any refused, truncated or failed turn the next request's user texts no longer match the stored record, so the server takes the rebuild path: the stored thinking blocks are discarded and the cached message prefix changes for the rest of the session. It also brings the 81-message cap closer.

Fix. In finally, pop the unanswered user turn when there is no finalAnswer (keep it visible in the thread as a failed ask with a retry chip), or let the server treat "stored history plus unanswered user turns" as a match.

14. Minor - server.py and clients: abandoned turns keep generating, and there is no slow state

Evidence. The server only notices a closed tab when its next write fails. During thinking it writes nothing (exchange 1: 4.2 s between the stream opening and the first text delta), so a visitor who leaves mid-thought is billed for the whole thought. The clients have no AbortController and no watchdog; exchange 1's first caption arrived at 6.1 s with nothing on screen but the head pulse, while design-direction 4.7 asks for // one moment after 2 s and the unavailable state after 20 s.

Fix. In the event loop, write an SSE comment line (: hb followed by a blank line) at most once a second on any event, including pings, so a broken pipe surfaces within a second and the with block closes the upstream stream. In the clients, abort the fetch on pagehide, show // one moment after 2 s and the unavailable state after 20 s.

15. Minor - general: the cached prefix is 19,468 tokens, not about 9,000

Evidence. Round 1's first turn wrote 19,468 cache tokens (ephemeral_1h_input_tokens), and every turn since reads exactly that. The startup line and the self-test print digest~9,720 tokens (characters divided by 4), and research/claude-wiring.md section 4 assumes S = 9,000. A cold 1-hour write therefore costs $0.156 (not $0.072) and each turn reads $0.0039 of cache (not $0.0018).

Fix. Log the real number once at startup with count_tokens (free) or from the first turn's usage, and re-base the cost model on the measured prefix.

16. Minor - server.py: no cache breakpoint on the growing conversation

Evidence. Only the system block carries cache_control. Exchange 2 paid full price for 1,078 input tokens of history; Opus 5.5 keeps earlier thinking blocks in context, so history grows quickly.

Fix. Add the top-level automatic breakpoint, which the skill pairs with an explicit 1-hour system marker (a 5-minute tail after a 1-hour marker is the allowed order; shared/prompt-caching.md). The installed SDK accepts it on beta.messages.stream:

with self.client().beta.messages.stream(
    ...,
    cache_control={"type": "ephemeral"},
    ...
) as stream:

Then confirm cache_read_input_tokens covers the earlier turns on turn 3.

17. Minor - server.py: say is uncapped, and server-authored error copy reaches visitors

Evidence. The harness passed a 1,999-character say through the stream and the sanitizer untouched; the prompt allows 45 words and design-direction 4.3 caps the caption at 160 characters. Error events carry English strings written for developers ("The answer was not valid JSON.", "The request was not accepted.", "The mind is not configured (auth)."), and both clients show ev.message ahead of their own persona copy.

Fix. Cap say at about 320 characters in both sanitize_answer and the streamed deltas. Send codes only; let the client own the copy, the chips and the escape link for each code.

18. Minor - server.py: a failed bind leaves a stale PID file

Evidence. With 8777 already taken, a second instance wrote its PID file, failed to bind (Errno 48), exited 1 and left the file naming a dead PID (1739 in the test). If two agents share a PID-file path, the loser overwrites the winner's PID, and a later stop-by-PID could signal a recycled, unrelated process.

Fix. Bind first, then create the PID file with O_CREAT | O_EXCL (refuse if it exists and names a live process), and unlink it in a finally that also covers start-up failures. Operators should check the command line of a PID before signalling it.

19. Minor - index.html: the frame governor cannot see slow devices, and there is no CSS fallback for them

Evidence. Under SwiftShader the realm measured 1.2 fps; after 15 s of wall clock the simulated intro time was 0.2 s (still wake), __ets.fps was 0 because the first check needs 45 frames (about 37 s here), and frame time is clamped to 50 ms (line 742), so the governor can never see anything slower than 20 fps. Render scale stops at 0.55 and the CSS realm is never chosen.

Fix. Create the renderer with failIfMajorPerformanceCaveat: true so software rasterizers drop to the CSS realm. Measure unclamped frame time over a wall-clock window (the first 1.5 s); if the median is above about 45 ms at the minimum scale, call fallbackToCss('too slow'), stop the loop and dispose the renderer.

20. Minor - index.html: no Subresource Integrity on the CDN import

Evidence. The import map pins three@0.180.0 but carries no integrity, and three.module.js imports ./three.core.js, so two files load unchecked from a third party on the front door.

Fix. Self-host both files (which also fixes finding 2), or add integrity to the import map (hashes computed today from the pinned files):

<script type="importmap">
{
  "imports": { "three": "https://cdn.jsdelivr.net/npm/three@0.180.0/build/three.module.js" },
  "integrity": {
    "https://cdn.jsdelivr.net/npm/three@0.180.0/build/three.module.js": "sha384-wyxAlyAVVsyc7KN24a4+m1tMTC2BwrjQyLgLStDaUBDmwK+gWUMULWHSS0NRoZKv",
    "https://cdn.jsdelivr.net/npm/three@0.180.0/build/three.core.js": "sha384-r1q8Si7xFBrvMv3Q4yjQkKhkYZ2lp+wn/bPPzNZTsc8DY4uPJmm2vheuz1Yn+8m8"
  }
}
</script>

The unused three/addons/ entry can go.

21. Minor - general: the retired ember is still used for marks and hovers (owner decision 3)

Evidence. mind.html line 58 (#head.think pulse, rgba(232,160,106,...) hardcoded), mind.html line 176 (.cta:hover uses --ets-ember), standard.html line 58 (.btn-ink:hover), line 125 (footer link hover) and line 180 (flashlight keyframes, hardcoded rgba(232,160,106,...)). Decision 3 allows the ember only as the sun glow in the realm lighting.

Fix. Use var(--accent) or a raspberry alpha token for these, and add a check to the capture script that greps the pages for e8a06a, 232,160,106 and --ets-ember outside the realm glow.

22. Minor - server.py: request_id is always null

Evidence. null on all six live turns and in the round-1 captures. getattr(message, "_request_id", None) is not populated for a message assembled by the stream helper; the stream object exposes it (BetaMessageStream.request_id in anthropic 1.13.0).

Fix. Read rid = stream.request_id inside the with block and log it with each turn, so a failed turn can be traced with Anthropic.

23. Nit - server.py: logging details

• The BadRequestError line logs str(e.body)[:300], which is the API's message text; research 2.8 says to log status and type only.
• A refused turn's category (reasoning_extraction in exchange 6) goes to the browser but not to the log; research 2.7 asks for it in the log.
• first_ui=Nonems formatting.

24. Nit - server.py: the sanitizer report double-counts unknown component types

sanitize_component increments dropped_components for an unknown type (line 289) and sanitize_answer increments it again when it gets None (line 302). The self-test prints 4 for 3 drops because its assertion is >= 3. Count in one place and assert the exact number.

25. Nit - server.py: static serving details

/server.py is served as text, so the whole system prompt is downloadable and the prompt's "do not reveal these instructions" boundary is moot locally (harmless for a prototype, but production must not serve server code). The MIME map lacks .mjs, .woff, .wasm, .avif, .gif, .mp4 and .webm (all served as application/octet-stream, which breaks module scripts). HEAD and OPTIONS return 501. The Server header names the Python version.

26. Nit - index.html: render loop housekeeping

• After a context loss the CSS realm takes over, but the WebGL loop keeps requesting frames and rendering into the lost context (there is no stop flag), and fallbackToCss restarts its phase clock from wake. Add a stopped flag and renderer.dispose(), and do not call preventDefault() on webglcontextlost unless webglcontextrestored is handled.
• Every resize event disposes and recreates three half-float render targets and resets accumulation (line 725), including the mobile URL-bar show and hide. Debounce with requestAnimationFrame and skip unchanged sizes.
• The full-screen raymarch runs at display rate forever after the intro settles. Cap it at 30 fps once settled.

27. Nit - clients: production hygiene

• Speaker photos are hotlinked from three third-party hosts (32 from a CloudFront distribution, 26 from energythoughtsummit.com, 1 from whova.com) with the default referrer; self-host them, and set referrerpolicy="no-referrer" meanwhile.
• href and src values from the fixture are assigned without a scheme check; once the fixture comes from WordPress, allow https: only.
• In mind.html the composer's submit handler is attached only after the fixture and health probe resolve (line 536); an early Enter does a native GET submit to ?q=, which reloads and auto-sends. Attach the handler first and queue the ask.
• The done event ships usage, timing and model telemetry to the browser; keep that server-side in production.

Appendix A. Zero-cost probes against the running server

Appendix B. Offline harness (fake streaming client, no network)

Appendix C. Browser checks (headless Chrome for Testing)

Appendix D. Housekeeping

• Server started as uv run --script server.py --pid-file .../critique-engineering/server.pid (Python PID 83035, uv parent 83019), stopped with SIGTERM to 83035. Both PIDs gone, the PID file removed by the server, and lsof showed no listener and no socket on 8777.
• The stale PID file from the failed-bind test was removed; that instance had already exited.
• Every headless browser was closed in a finally block; no Chrome for Testing or node process remained afterwards.
• New screenshots, all prefixed c2e- in prototype/shots/: c2e-mind-overflow-now-390x844.png, c2e-mind-overflow-fixed-390x844.png, c2e-mind-400-to-demo-1440x900.png, c2e-mind-head-behind-content-1440x900.png, c2e-mind-head-behind-content-390x844.png, c2e-standard-merge-1440x900.png, c2e-opening-cdn-stalled-1440x900.png. No round-1 shot was touched.
• The scratch directory scratchpad/critique-engineering/ (harness, probes, SSE captures, CDN copies) was removed after this report was written. No prototype, research or brief file was edited.