Strip doom-only TODOs from TODO.md

TODO.md had six items, four of which were action items against doom
code that no longer lives in this repo:

- 'fp16 inference for Flash Attention' — render decode loop, targets
  `torchwright/doom/compile.py`, `step_frame`, `make walkthrough`.
- 'Move ceiling/floor into the transformer' — the same Dumb-host-
  principle violation already deleted from CLAUDE.md, targets
  `torchwright/doom/compile.py` / `game_graph.py`.
- 'Clip column iteration to screen bounds' — render state machine,
  targets `torchwright/doom/game_graph.py`.
- 'Make graph-side done_flag work when N < max_walls' — render state
  machine, targets `torchwright/doom/game_graph.py` / `compile.py`.

Step E moved the doom code to the sibling `torchwright_doom` repo;
these TODOs belong with it, not here.

Kept the two general compiler-work items, both of which target files
that still exist here:

- 'Tests that validate Asserts on the compiled graph' — calls for
  tests that exercise `check_asserts_on_compiled` on real compiled
  graphs. Lightly scrubbed: replaced 'on the DOOM graph and on
  smaller stage-level graphs' with 'representative compiled graphs
  (the example transformers under `examples/`, plus stage-level
  synthetic graphs)', dropped 'the class of bug Mode C was' (only
  appearance of 'Mode C' in the repo — its definition lived in a
  deleted postmortem), and pointed new tests at `tests/` rather than
  the deleted `tests/doom/` and `tests/doom/stages/`.
- 'Softmax hardness assertion on attend_* primitives' — proposes an
  `assert_hardness_gt` kwarg across the `attend_*` family. All target
  files exist; kept verbatim.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: physicsrob

TODO.md

@@ -1,97 +1,23 @@
 # TODO
 
-## fp16 inference for Flash Attention
-
-The render decode loop runs at ~35ms/step (GPU-bound). The bottleneck is SDPA
-over long sequences (~800 positions): each step attends over an 800×800-ish
-matrix using PyTorch's materialized ("math") softmax kernel.
-
-**Why the math kernel is used:** PyTorch's SDPA dispatcher only enables Flash
-Attention for fp16/bf16 inputs. All model weights and activations are currently
-fp32, so every SDPA call falls back to the materialized kernel regardless of
-whether an `attn_mask` is provided.
-
-**The opportunity:** Casting weights and activations to fp16 at inference time
-(e.g., `.half()` on `CompiledHeadless._net`) would let SDPA dispatch to Flash
-Attention on A100. Flash Attention is O(N) in memory and substantially faster
-for long sequences — potentially 3–5× faster SDPA, which could bring decode
-from ~35ms to ~15–20ms per step.
-
-The dynamic decode path (`forward_cached`, `is_causal=False`, no explicit mask)
-already satisfies all Flash Attention preconditions except dtype. The static
-KV cache path (added in this branch) uses a float `attn_mask` and would need
-to switch to a boolean mask or be dropped in favour of the dynamic path.
-
-**Risk:** Weights are compiled in fp32 and encode precise numerical thresholds
-(comparison results, attention argmin/argmax patterns). fp16 has ~3 significant
-decimal digits vs ~7 for fp32. It's unknown whether the compiled logic survives
-the precision loss without correctness failures. A test that compares fp32 vs
-fp16 `step_frame` outputs would answer this.
-
-**Suggested experiment:**
-1. `module._net.to(torch.float16)` after `compile_game()`
-2. Cast inputs to fp16 in `_build_res_stream`
-3. Run `make walkthrough ARGS="--frames 5"` and compare to fp32 reference
-4. If pixel errors are within tolerance, fp16 is viable
-
-Files: `torchwright/compiler/export.py` (`_build_res_stream`, `CompiledHeadless`),
-`torchwright/compiler/components/attn.py` (weights), `torchwright/doom/compile.py`
-
-## Move ceiling/floor into the transformer
-
-The host currently decides ceiling vs floor per pixel (`ceil if y < center_y
-else floor_c`). This is computation on the host side. The transformer should
-emit ceiling/floor pixels itself — either as part of each render chunk (fill
-non-wall rows within the chunk) or as a separate post-render pass.
-
-Files: `torchwright/doom/compile.py` (step_frame render loop),
-`torchwright/doom/game_graph.py` (render output)
-
-## Clip column iteration to screen bounds
-
-The state machine iterates col_lo..col_hi, which can include negative columns
-and columns >= W (e.g., cols=[-2, 122) with W=120). The host safely skips
-out-of-bounds columns, but each is still a full autoregressive step (~70ms).
-At 120x100 with 4 full-screen walls, ~16 steps are wasted per frame.
-
-Fix: clamp col_lo/col_hi to [0, W) in the graph, or have the state machine
-skip out-of-bounds columns via the feedback loop.
-
-Files: `torchwright/doom/game_graph.py` (state machine col iteration)
-
-## Make graph-side done_flag work when N < max_walls
-
-The graph checks `mask_sum > max_walls - 0.5`, which only fires when all
-max_walls slots are masked. When the scene has fewer walls, the host
-terminates via bit-count instead. The graph's done_flag computation runs on
-every RENDER token but never triggers — wasted graph nodes.
-
-Options:
-- Feed N as a graph input so the threshold is dynamic
-- Detect sentinel wall data (score=99) after all real walls are masked
-- Accept the current host-side fix and remove the graph-side done_flag entirely
-
-Files: `torchwright/doom/game_graph.py` (state_transitions),
-`torchwright/doom/compile.py` (host-side termination)
-
 ## Tests that validate Asserts on the compiled graph
 
 `check_asserts_on_compiled` (`torchwright/debug/probe.py:964`) already
 runs each `Assert`'s predicate against the compiled transformer's
 residual stream, but no tests currently call it. Asserts today only
 fire during reference evaluation — the whole point of checking them
 post-compile is to catch invariants that exact math satisfies but
-compiled approximations violate (the class of bug Mode C was).
+compiled approximations violate.
 
-Add tests that exercise it on the DOOM graph and on smaller stage-level
-graphs.  At minimum: collect the asserts via
+Add tests that exercise it on representative compiled graphs (the
+example transformers under `examples/`, plus stage-level synthetic
+graphs).  At minimum: collect the asserts via
 `torchwright.graph.asserts.collect_asserts(output_node)` before
 `compile_headless`, compile, then call `check_asserts_on_compiled` on
 a representative input battery and assert no violations.
 
 Files: `torchwright/debug/probe.py` (`check_asserts_on_compiled`,
-`collect_asserts`), new tests under `tests/doom/` and
-`tests/doom/stages/`.
+`collect_asserts`), new tests under `tests/`.
 
 ## Softmax hardness assertion on `attend_*` primitives