docs: the OB-flag sample finally ran - 11 candidates, and a real negative about the counter

A run that stayed animating for 25 minutes gave the first proper sample: 161
entities against a counter of 12, so "not a class head-count" is now confirmed on
a sample seven times larger than the frozen run's. Eleven candidate offsets, with
who they group recorded - and the two biggest groups look wrong for an objective
flag on inspection: seven consecutive floats shared by 12 of 32 attackers read
like one shared AI/weapon parameter block, and +0x0238 = 4 is shared by twelve
TURRETS, which do not fit an objective that says "shoot down all invading enemy
fighters". None of it is verified.

The reason it is not verified is itself the result: REMAINING OB held at 012 for
fifteen minutes of LIVE flight - not a frozen world this time - so there was no
second sample. And it held while the hostile population fell from 132 to 93 ADAN
entities. That is a much stronger version of the earlier head-count argument: the
counter is not "hostiles left".

Also recorded, because it weakens every kill-based experiment in the corpus:
pilot.py never fires. fire=1 appears in 0 of 13521 samples. It flies, chases and
evades, and the trigger is never pulled, so kills are the wingmen's.

Freeze frequency updated: 3 of the 7 runs that reached flight.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PMRJjbxLqZtsb5Vb7KunPE

docs/re/mission-freeze-and-ob-flag.md

@@ -81,3 +81,67 @@ and `ob_flag.py` now consult it after a minute of no movement and say
 * ❔ **What causes the freeze.** Not investigated here at all; this run only
   establishes that it happens, that it can happen within seconds of the HUD
   appearing, and how to detect it in one call.
+
+---
+
+## 2026-08-23 (later) — the flag experiment finally ran, and still cannot verify
+
+A run that stayed **animating for its whole 25 minutes** (checked repeatedly with
+`frozen.py`) got the first real sample:
+
+```
+HUD=12 RAM=12                       (0xbdb59668 again — 5 of 7 runs now)
+[A] counter=12 entities=161
+      114  UN_e007_ADAN_Turret
+       32  UN_e010_ADAN_Attacker_S
+       14  UN_f001_TCAF_DeltaSaber_T
+        1  UN_f001_TCAF_DeltaSaber_T_Player
+[A] classes whose head-count equals the counter: NONE
+[A] offsets where exactly 12 entities agree: 11
+```
+
+with a much bigger entity list than the frozen run's 23, so the earlier
+"🔴 not a class head-count" result is now confirmed on a **161-entity** sample too.
+
+The 11 candidates, with who they group — the part worth looking at:
+
+| offset | value | members |
+|---|---|---|
+| `+0x00d0` | `3f57f496` | 12 of the 14 friendly Delta Sabers |
+| `+0x017c`–`+0x0198` (7 words) | floats | 12 of the 32 `e010` attackers |
+| `+0x00b0`, `+0x015c` | `43f9ffff` | 10 turrets + 2 attackers |
+| `+0x0238` | `00000004` | 12 turrets |
+
+The seven consecutive floats at `+0x017c…+0x0198` shared by exactly twelve
+attackers look far more like **one shared parameter block** — a squad flying the
+same AI or weapon configuration — than like a per-entity objective flag, and
+`+0x0238 = 4` on twelve *turrets* is hard to reconcile with an objective that
+reads "shoot down all invading enemy fighters". **None of this is verified**, and
+the reason is the next paragraph.
+
+### 🔴 `REMAINING OB` held at `012` for fifteen minutes of live flight
+
+Not a frozen world this time — the game was animating throughout, and the run
+ended only because the experiment's window did. So the counter genuinely did not
+move, and there was no second sample to test the candidates against.
+
+**And it held while the hostile population fell by a third.** `pilot.py`'s own
+rescans went `132 ADAN` → `93 ADAN` over the window: roughly 39 hostiles died
+(to wingmen and to the ACROPOLIS's guns) and `REMAINING OB` did not change by
+one. That is a real negative about what the counter counts — it is **not**
+"hostiles left", on a much stronger sample than the earlier head-count argument.
+
+### 🔴 A tool defect that bounds every kill-based experiment
+
+`pilot.py` **never fires**: `fire=1` appears in **0** of its 13 521 logged
+samples in this run. It flies, chases and evades, but the trigger is never
+pulled. Every "kill something and watch X" experiment in this corpus is
+therefore relying on the wingmen, and the pilot's own contribution to a kill
+count is zero. Not fixed here — recorded because it silently weakens conclusions
+drawn from runs that assumed the pilot was shooting.
+
+### Freeze frequency, updated
+
+This run did **not** freeze in ~25 minutes. Of the seven Stage 02 runs that have
+reached flight, **three froze** — so it is common but not the majority, and a run
+that survives the first minute or two seems to keep going.