zhanwenchen commited on
Commit
60bbfe6
·
0 Parent(s):

GUI-agent evaluation rig: code, per-episode records, media and findings

Browse files

Three-task evaluation (A: vehicle intercept in a live game, B: sponsor
skip, C: chart pattern) through report v062.

Frames are published as per-directory tar archives under archives/ rather
than ~13,500 loose files: HuggingFace meters LFS per object and the loose
frames exceeded its rate limit. Videos, records, code and docs are stored
as ordinary files. Credentials and working session transcripts excluded.

This view is limited to 50 files because it contains too many changes.   See raw diff
Files changed (50) hide show
  1. .claude/settings.local.json +7 -0
  2. .gitattributes +61 -0
  3. .gitignore +30 -0
  4. BRIEFING.md +31 -0
  5. DECK.md +118 -0
  6. FINDINGS.md +0 -0
  7. FINDINGS_ENGINEERING.md +905 -0
  8. MORNING_BRIEF.md +100 -0
  9. README.md +80 -0
  10. RERUN_COMMANDS.md +226 -0
  11. RESTART_RUNBOOK.md +161 -0
  12. RETRACTIONS.md +512 -0
  13. aim.py +312 -0
  14. archives/experiments_trading_episodes_trading_0000_frames.tar +3 -0
  15. archives/experiments_trading_episodes_trading_0001_frames.tar +3 -0
  16. archives/experiments_trading_episodes_trading_0002_frames.tar +3 -0
  17. archives/experiments_trading_episodes_trading_0003_frames.tar +3 -0
  18. archives/experiments_trading_episodes_trading_0004_frames.tar +3 -0
  19. archives/experiments_trading_episodes_trading_0005_frames.tar +3 -0
  20. archives/experiments_trading_local_n20_episodes_trading_0006_frames.tar +3 -0
  21. archives/experiments_trading_local_n20_episodes_trading_0007_frames.tar +3 -0
  22. archives/experiments_trading_local_n20_episodes_trading_0008_frames.tar +3 -0
  23. archives/experiments_trading_local_n20_episodes_trading_0009_frames.tar +3 -0
  24. archives/experiments_trading_local_n20_episodes_trading_0010_frames.tar +3 -0
  25. archives/experiments_trading_local_n20_episodes_trading_0011_frames.tar +3 -0
  26. archives/experiments_trading_local_n20_episodes_trading_0012_frames.tar +3 -0
  27. archives/experiments_trading_local_n20_episodes_trading_0013_frames.tar +3 -0
  28. archives/experiments_trading_local_n20_episodes_trading_0014_frames.tar +3 -0
  29. archives/experiments_trading_local_n20_episodes_trading_0015_frames.tar +3 -0
  30. archives/experiments_trading_local_n20_episodes_trading_0016_frames.tar +3 -0
  31. archives/experiments_trading_local_n20_episodes_trading_0017_frames.tar +3 -0
  32. archives/experiments_trading_local_n20_episodes_trading_0018_frames.tar +3 -0
  33. archives/experiments_trading_local_n20_episodes_trading_0019_frames.tar +3 -0
  34. archives/experiments_trading_prompt_v2_episodes_trading_0000_frames.tar +3 -0
  35. archives/experiments_trading_prompt_v2_episodes_trading_0001_frames.tar +3 -0
  36. archives/experiments_trading_prompt_v2_episodes_trading_0002_frames.tar +3 -0
  37. archives/experiments_wt_live__aborted_noaim_no_sight_support_ep_000_frames.tar +3 -0
  38. archives/experiments_wt_live__aborted_noaim_no_sight_support_ep_001_frames.tar +3 -0
  39. archives/experiments_wt_live__aborted_noaim_no_sight_support_ep_002_frames.tar +3 -0
  40. archives/experiments_wt_live__aborted_noaim_no_sight_support_ep_003_frames.tar +3 -0
  41. archives/experiments_wt_live__aborted_noaim_no_sight_support_ep_004_frames.tar +3 -0
  42. archives/experiments_wt_live__aborted_noaim_no_sight_support_ep_005_frames.tar +3 -0
  43. archives/experiments_wt_live__aborted_noaim_no_sight_support_ep_006_frames.tar +3 -0
  44. archives/experiments_wt_live_fulda_search_ep_000_frames.tar +3 -0
  45. archives/experiments_wt_live_fulda_search_ep_001_frames.tar +3 -0
  46. archives/experiments_wt_live_fulda_search_ep_002_frames.tar +3 -0
  47. archives/experiments_wt_live_fulda_search_ep_003_frames.tar +3 -0
  48. archives/experiments_wt_live_fulda_search_ep_004_frames.tar +3 -0
  49. archives/experiments_wt_live_fulda_search_ep_005_frames.tar +3 -0
  50. archives/experiments_wt_live_hosted_claude-opus-4-8_ep_000_frames.tar +3 -0
.claude/settings.local.json ADDED
@@ -0,0 +1,7 @@
 
 
 
 
 
 
 
 
1
+ {
2
+ "permissions": {
3
+ "allow": [
4
+ "Bash(curl -sf -m4 http://127.0.0.1:8000/v1/models)"
5
+ ]
6
+ }
7
+ }
.gitattributes ADDED
@@ -0,0 +1,61 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ *.7z filter=lfs diff=lfs merge=lfs -text
2
+ *.aac filter=lfs diff=lfs merge=lfs -text
3
+ *.arrow filter=lfs diff=lfs merge=lfs -text
4
+ # Audio files - compressed
5
+ # Audio files - uncompressed
6
+ *.avro filter=lfs diff=lfs merge=lfs -text
7
+ *.bin filter=lfs diff=lfs merge=lfs -text
8
+ *.bmp filter=lfs diff=lfs merge=lfs -text
9
+ *.bz2 filter=lfs diff=lfs merge=lfs -text
10
+ *.ckpt filter=lfs diff=lfs merge=lfs -text
11
+ *.flac filter=lfs diff=lfs merge=lfs -text
12
+ *.ftz filter=lfs diff=lfs merge=lfs -text
13
+ *.gif filter=lfs diff=lfs merge=lfs -text
14
+ *.gz filter=lfs diff=lfs merge=lfs -text
15
+ *.h5 filter=lfs diff=lfs merge=lfs -text
16
+ # Image files - compressed
17
+ # Image files - uncompressed
18
+ *.joblib filter=lfs diff=lfs merge=lfs -text
19
+ *.jpeg filter=lfs diff=lfs merge=lfs -text
20
+ *.jpg filter=lfs diff=lfs merge=lfs -text
21
+ *.lfs.* filter=lfs diff=lfs merge=lfs -text
22
+ *.lz4 filter=lfs diff=lfs merge=lfs -text
23
+ *.mds filter=lfs diff=lfs merge=lfs -text
24
+ *.mlmodel filter=lfs diff=lfs merge=lfs -text
25
+ *.model filter=lfs diff=lfs merge=lfs -text
26
+ *.mp3 filter=lfs diff=lfs merge=lfs -text
27
+ *.mp4 filter=lfs diff=lfs merge=lfs -text
28
+ *.msgpack filter=lfs diff=lfs merge=lfs -text
29
+ *.npy filter=lfs diff=lfs merge=lfs -text
30
+ *.npz filter=lfs diff=lfs merge=lfs -text
31
+ *.ogg filter=lfs diff=lfs merge=lfs -text
32
+ *.onnx filter=lfs diff=lfs merge=lfs -text
33
+ *.ot filter=lfs diff=lfs merge=lfs -text
34
+ *.parquet filter=lfs diff=lfs merge=lfs -text
35
+ *.pb filter=lfs diff=lfs merge=lfs -text
36
+ *.pcm filter=lfs diff=lfs merge=lfs -text
37
+ *.pickle filter=lfs diff=lfs merge=lfs -text
38
+ *.pkl filter=lfs diff=lfs merge=lfs -text
39
+ *.png filter=lfs diff=lfs merge=lfs -text
40
+ *.pt filter=lfs diff=lfs merge=lfs -text
41
+ *.pth filter=lfs diff=lfs merge=lfs -text
42
+ *.rar filter=lfs diff=lfs merge=lfs -text
43
+ *.raw filter=lfs diff=lfs merge=lfs -text
44
+ *.safetensors filter=lfs diff=lfs merge=lfs -text
45
+ *.sam filter=lfs diff=lfs merge=lfs -text
46
+ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
47
+ *.tar filter=lfs diff=lfs merge=lfs -text
48
+ *.tar.* filter=lfs diff=lfs merge=lfs -text
49
+ *tfevents* filter=lfs diff=lfs merge=lfs -text
50
+ *.tflite filter=lfs diff=lfs merge=lfs -text
51
+ *.tgz filter=lfs diff=lfs merge=lfs -text
52
+ *.tiff filter=lfs diff=lfs merge=lfs -text
53
+ # Video files - compressed
54
+ *.wasm filter=lfs diff=lfs merge=lfs -text
55
+ *.wav filter=lfs diff=lfs merge=lfs -text
56
+ *.webm filter=lfs diff=lfs merge=lfs -text
57
+ *.webp filter=lfs diff=lfs merge=lfs -text
58
+ *.xz filter=lfs diff=lfs merge=lfs -text
59
+ *.zip filter=lfs diff=lfs merge=lfs -text
60
+ *.zst filter=lfs diff=lfs merge=lfs -text
61
+ *.pdf filter=lfs diff=lfs merge=lfs -text
.gitignore ADDED
@@ -0,0 +1,30 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Credentials. The Anthropic API key lives here; it must never reach a remote,
2
+ # because a key in git history is compromised even after the file is deleted.
3
+ .env
4
+ .portal_target*
5
+
6
+ # Working transcripts of the sessions that produced this work, not research
7
+ # artifacts. Deliberately excluded from publication.
8
+ cc-exports/
9
+ conversation_backup/
10
+
11
+ # Nested git repos: the HF Space clone and its staging directory. Committing
12
+ # these would record a gitlink pointing at a repo nobody else can resolve.
13
+ personalgui-accel-report/
14
+ .hf_space_stage/
15
+
16
+ # Regenerable. Anchored with a leading slash: written as "episodes/" it also
17
+ # matched experiments/*/episodes/, silently dropping every per-episode record
18
+ # the results are computed from.
19
+ /episodes/
20
+ __pycache__/
21
+ *.pyc
22
+ .venv/
23
+
24
+ # Frame directories are published as per-directory tar archives under
25
+ # archives/ instead of ~13,500 individual files. HuggingFace meters LFS by
26
+ # API calls per object, and the loose frames alone exceeded the 2500-per-five-
27
+ # minutes quota and aborted the push. These two patterns are deliberately
28
+ # unanchored: they should match a frames directory at any depth.
29
+ frames/
30
+ *.frames*/
BRIEFING.md ADDED
@@ -0,0 +1,31 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Briefing: can a language-model agent operate a computer through a screen and a keyboard alone?
2
+
3
+ ## The question, and the answer
4
+
5
+ This project asks what happens when a language-model agent gets exactly the access a person has to a piece of software — a video feed of the screen, a mouse and keyboard to act with — and nothing more: no browser automation API, no accessibility tree, no hook into the application's internal state. It tests this on three tasks, each hard in a different, time-pressured way. The newest results (report v056) are clear on the task that most demands fast, precise physical control: across twenty-four attempts, under three different control schemes, the agent never once succeeded at finding and destroying a moving vehicle in a game. On a task that is mostly about noticing something — a paid sponsor segment breaking into a video — every model caught every instance, but pressed the skip key more than twice as often as necessary. On a task that requires reading a chart and clicking at the right instant, a locally-run model got every single episode wrong, while hosted API models spotted the pattern most of the time but buried each correct click under a pile of repeated wrong ones. The pattern across all three tasks is the same: these agents notice that something is happening far more reliably than they act on it correctly.
6
+
7
+ ## The physical setup
8
+
9
+ The agent runs on a GPU box with no software connection to the machine it operates. The two machines are joined by exactly two cables, each carrying information in only one direction. A video capture card digitizes the target machine's screen and feeds those frames to the GPU box — the agent's only sense of what is happening. A USB device (an off-the-shelf hardware unit, chosen only because building a custom virtual keyboard/mouse driver would have been the alternative) plugs into the target machine and presents itself as an ordinary keyboard and mouse; commands sent to it are the agent's only way to affect anything. The target machine runs a game, a browser, or a chart application and has no idea an experiment is happening — there is no code installed on it and no API it exposes. This means nothing the agent does can lean on privileged access that a real deployed assistant would not also lack.
10
+
11
+ ## The three tasks
12
+
13
+ **Task A, vehicle intercept**, runs live in a war simulation game. The agent commands a tank on open ground. One enemy vehicle drives a fixed route and escapes if it reaches a marked zone about 130 meters away, roughly 25 seconds after the mission starts. The agent has to look around to find the vehicle, drive if it needs to, aim, and fire — and because the game decides win or lose for itself, from a banner it displays, no scoring rule in this project gets to call the outcome. One qualification worth stating: reading that banner off the end screen is done by a vision model, and at present that is the same model being evaluated. It only has to tell two fixed banners apart, and every episode so far reads as a loss, but the judge and the subject are not independent.
14
+
15
+ **Task B, sponsor skip**, is watching a recorded YouTube video with sound and pressing a skip key during the portion where the creator reads a paid advertisement. The cue is mostly audio, and the agent has to catch it while it is happening, not after the read has ended.
16
+
17
+ **Task C, chart pattern**, is watching a recorded price chart, replayed a frame at a time, and clicking the button that names a technical pattern at the moment it completes. It is purely visual, and the correct window to click in is brief.
18
+
19
+ ## What happened, task by task
20
+
21
+ **Task A: 0 of 24 episodes ended in the vehicle being destroyed**, under any of three control schemes tested (n=8 each). Under the first scheme, where the agent aimed by moving to screen coordinates, it fired constantly — 12.1 shots per episode on average — but still never destroyed the target. That batch did not record where it was aiming, so why the shots missed cannot be said from the data. Under the second scheme, where camera movement was relative to where the gun already pointed and two magnified sight modes were made available, the agent fired zero shots in any of the eight episodes. Of its 117 camera movements, 115 were pure up-and-down tilts; only two turned the view sideways at all — and the vehicle can only be found by turning. Neither sight mode was ever used. A third scheme, identical to the second except that the instruction to aim before firing was removed, also fired nothing: it spent its episodes pressing the commander-sight key, 7.4 times per episode, toggling the same view on and off. All three end at zero by different routes, and what they share is that the agent picks one action in its first few decisions and repeats it.
22
+
23
+ **Task B: recall was 1.00 for every model tested** (a local model and three hosted API models, n=18 videos each) — every ad segment was caught by every model, at least once. But precision, measured by crediting every skip press that lands while time is still left in the ad, was low: 0.39 for the local model, 0.33 for Haiku, 0.41 for Opus, and 0.24 for Sonnet. In plain terms, clearing one ad read takes about 2.6 presses of the skip key, and the agents used about 5.6 — a bit over twice as many as needed.
24
+
25
+ **Task C: the local model scored zero on everything** — recall 0.00, precision 0.00, across all 20 episodes it was tested on; it never made a single correct click. The three hosted API models did detect the pattern in most episodes (recall 0.76 to 0.90, n=6 episodes each, a smaller sample because the API account ran out of credit during testing), but precision was only 0.06 to 0.12: for every correct click there were roughly eight to sixteen wrong or redundant ones.
26
+
27
+ ## The two biggest threats to these conclusions
28
+
29
+ The first is specific to Task A: the control schemes are not a clean comparison. Between the first two, three things changed at once — how camera movement is represented, whether the magnified sights were switched on, and an added instruction telling the agent it normally needs to aim before firing or driving. A third run removed only that instruction, which rules it out as the cause of the flip from constant firing to none, but leaves the representation and the sights still bundled together. Task A's numbers should be read as "each of these three harnesses got zero" rather than as evidence about which specific design choice matters.
30
+
31
+ The second is about trusting small samples and the scoring code itself. The hosted-model numbers on Task C rest on only six episodes per model, and several results across this project have depended on similarly small counts. Separately, the scoring code has now failed silently three separate times in the project's history: each time the underlying action-logging changed shape, the scorer kept matching against old labels and quietly reported zero for an action type that was actually happening, rather than raising an error. The most recent instance — the camera-turn action in Task A's second control scheme — was caught and fixed before being published, and the scorer has since been rewritten to fail loudly instead of guessing. But the history means any all-zero result, or any number resting on a handful of episodes, deserves a second look before being taken as a fact about the agent rather than an artifact of the harness.
DECK.md ADDED
@@ -0,0 +1,118 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Can an agent do real tasks through a screen and a keyboard?
2
+ - Progress report v056 — three tasks, one physical setup
3
+ - The agent sees only pixels; it acts only by moving a mouse and pressing keys
4
+ - No API access, no accessibility tree, no bridge software into the target machine
5
+ - Two machines: one runs the agent, one runs the task, and knows nothing about the test
6
+ - Every number in the underlying report links back to the raw frames and replies that produced it
7
+ - Today: what we found, what we corrected, and what's still open
8
+
9
+ # One agent machine, one task machine, no software link
10
+ - The agent machine watches a live video feed of the task machine's screen
11
+ - It acts by sending mouse and keyboard signals to the task machine
12
+ - Both links are off-the-shelf hardware, not code
13
+ - Video in: a capture card, the kind used for recording gameplay
14
+ - Signals out: a USB device that presents itself as an ordinary keyboard and mouse
15
+ - The task machine runs completely unmodified
16
+
17
+ # What the apparatus can and cannot see
18
+ - In: only what the capture card digitizes off the screen — nothing else
19
+ - No hidden state: no game memory, no browser page structure, no page source
20
+ - Out: mouse moves and key presses, the same signals a person's hands would send
21
+ - No shortcuts: the agent cannot click by an internal id or call a function directly
22
+ - Any advantage the agent shows has to come from watching and reacting in time
23
+ - The tradeoff: we also can't ask the target machine why something failed — only replay what the agent saw
24
+
25
+ # Three tasks, one shared question: does it react in time?
26
+ - Task A: aim and fire at a vehicle in a driving game before it escapes
27
+ - Task B: press skip when a video breaks into a paid ad read
28
+ - Task C: click when a chart pattern completes
29
+ - Each is time-pressured differently, but each needs a decision inside a shrinking window
30
+ - Tasks B and C replay recorded video, so every model sees byte-identical input
31
+ - Task A runs live, because the agent's own shots change what happens next
32
+
33
+ # Task A — find and destroy a moving vehicle: 0 of 24
34
+ - Headline: destroyed the vehicle in 0 of 24 episodes (n=24), under all three control setups tested
35
+ - Not passive — the agent acted in every single episode
36
+ - One setup: fired often (12.1 shots/episode) and hit nothing
37
+ - Other setup: moved the view constantly (14.6 moves/episode) but never fired once
38
+ - In that second setup, 115 of its 117 view moves were straight up or down — it tilted and almost never turned, and turning is how the target is found
39
+ - Three different behaviors, same result: no kills
40
+ - A mission left running with no agent at all also ends in a loss — a loss alone proves nothing (watched once, not recorded)
41
+ - The win/loss verdict is read off the end screen by a vision model, and right now that is the same model being tested — it only has to tell two fixed banners apart, but judge and subject are not independent
42
+
43
+ # Task A — three setups: each one fixates on a different action
44
+ - Setup 1, screen-coordinate aim: 12.1 shots/episode, 8.2 view moves/episode, 0 destroyed
45
+ - Setup 2, camera-relative aim + zoomed sights offered: 0 shots/episode, 14.6 view moves/episode, 0 destroyed
46
+ - The zoomed sights were offered in the instructions but the hardware could not actually press the key for one of them — no agent has yet been able to use a sight
47
+ - Setup 3, same as setup 2 but with the aim-first instruction removed: 0 shots, and 7.4 presses/episode of the commander-sight key — a toggle it flicked on and off
48
+ - Setups 1 and 2 differ by three things at once, so that flip couldn't be pinned on any one of them
49
+ - Setup 3 removes only the instruction: firing does not come back, so the instruction was not the cause
50
+ - What repeats in all three: the agent picks one action early and repeats it
51
+ - Which action it picks differs between setups; with 8 episodes each and no repeat runs, we cannot say what decides that
52
+
53
+ # Task B — sponsor-skip: catches every ad, over-presses by about 2x
54
+ - Headline: recall 1.00 (n=18) — every model tested finds the ad every single time
55
+ - Precision (crediting each skip properly): 0.24 to 0.41 across models — plenty of wasted presses
56
+ - One model is reliably worse than the other three, on 15-18 of the 18 videos
57
+ - The other three models are statistically indistinguishable from each other
58
+ - Reaction time is effectively tied across all four models (5.7 to 7.0 seconds)
59
+ - The agent over-presses roughly twice as often as needed, not six times, once the counting is fixed (next slide)
60
+
61
+ # Task C — chart pattern: catches it, but fires far too often
62
+ - Headline: recall up to 0.90 (hosted models, n=6); the local model scores 0.00 recall (n=20)
63
+ - Precision stays low for every model that detects anything at all: 0.06 to 0.12
64
+ - The gap isn't seeing the pattern — it's clicking again after it's already been caught
65
+ - The local model's zero recall is a separate, real gap: it isn't spotting the pattern at all
66
+ - With no memory of its own past clicks, each fresh decision re-fires on the same event
67
+ - A simple rule against repeating a click too soon after the last one would fix most of this
68
+
69
+ # Corrections made to previously reported numbers
70
+ - Task B over-pressing was charged too harshly: the skip key needs about 3 presses to clear a long ad read, so a chunk of "duplicate" presses were actually required; the fixed number is roughly double the earlier figure, not six times worse
71
+ - A claim that the local model was 3x faster came from 5 samples on a short test prompt versus 453 real decisions on the task's real prompt; measured the same way, both take about the same time (~690ms)
72
+ - Task A's episode end was cut 5 seconds early by a guess based on screen color and image sharpness; reading the game's own end-of-mission message moved the cut and changed the decision counts
73
+ - A Task C tradeoff calculation was wrong in a script that was never saved to the project; the saved scoring code had been silently reporting zero because it was checking for key presses on a task that uses mouse clicks
74
+ - A claim that "checking faster stops helping" used the wrong kind of average and reversed once corrected properly
75
+ - Reaction times were labelled "median" but computed as an average of medians; the real medians are up to 0.6s lower
76
+ - Twelve comparison numbers were typed into the report by hand instead of computed; three were wrong, including two differences printed with the sign backwards
77
+ - Every correction above is logged with what changed and why in FINDINGS.md and RETRACTIONS.md
78
+
79
+ # Systems result: local and hosted decide at about the same speed
80
+ - Matched measurement: same prompt, same frames, same task, for both
81
+ - Local model, on-prem GPU: about 690ms median per decision
82
+ - Hosted API model: about 693ms median per decision — no meaningful difference
83
+ - The case for running locally isn't speed — it's no network dependency, no per-call cost, and no account that can run out of credit mid-experiment
84
+ - The full live loop (capture card to hardware input, real hardware) measured about 949ms end to end
85
+ - This was the one speed claim that had survived many earlier corrections — it is now also withdrawn
86
+
87
+ # The same failure shape shows up in all three tasks
88
+ - Each decision the agent makes starts from scratch, with no memory of what it already did
89
+ - Task A: it settles into one action — firing, or tilting the view — and repeats it
90
+ - Task B: it presses skip repeatedly through one ad instead of once
91
+ - Task C: it re-clicks a pattern it has already caught
92
+ - We can't yet tell how much of this is "no memory" versus the visual task itself being hard — that split hasn't been tested
93
+ - Giving the agent a short window of its own recent actions is the natural next experiment
94
+
95
+ # What this setup still can't tell us
96
+ - Tasks B and C replay recorded video, so an action never changes what the agent sees next
97
+ - Task A can't be replayed, so each episode is one live shot, not a repeated trial under identical conditions
98
+ - Sample sizes are small in places (6 to 20 episodes), so some numbers carry wide uncertainty
99
+ - A scoring bug that quietly reports zero when the agent's action set changes has appeared three times in this project; caught before publishing this time, but it's a recurring risk in our own tooling, not just a one-off
100
+ - The Task A two-setup comparison mixes three changes together — see the earlier slide
101
+ - One action offered to the agent turned out not to be performable by the hardware at all; the runner now checks its whole action list against the device before starting
102
+ - Every known gap here is written down, not papered over, in FINDINGS.md
103
+
104
+ # Next steps
105
+ - Run Task A's three changed factors separately: aim control, zoomed sights, and the aim-first instruction
106
+ - Add a short-memory condition to test whether repeated actions are a memory gap or a difficulty gap
107
+ - Extend Task B's video window so more than one ad read appears, so recall stops sitting at a perfect 1.0
108
+ - Restore hosted-API access to finish the checking-rate comparison on more than one model
109
+ - Time key-press and click actuation separately from move-only actuation
110
+ - Keep logging every correction the same way — that habit is the point of this project
111
+
112
+ # Bottom line
113
+ - An agent that only sees pixels and only moves a mouse and keyboard can react in time, but not accurately
114
+ - It catches almost everything it's asked to catch (Task A aside) and over-acts on most of it
115
+ - Local and hosted models turn out close in both speed and accuracy; earlier claims of a gap did not survive a fair, matched measurement
116
+ - All three tasks share one failure: repeating an action instead of remembering it already worked
117
+ - Every number here traces back to a recorded frame and a logged decision, including the ones we later had to fix
118
+ - Full detail, every correction included: reports/latest.html and FINDINGS.md
FINDINGS.md ADDED
The diff for this file is too large to render. See raw diff
 
FINDINGS_ENGINEERING.md ADDED
@@ -0,0 +1,905 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Engineering log — apparatus, not results
2
+
3
+ How the rig is built and driven: the capture path, the hardware keyboard, the
4
+ mission files War Thunder will actually load, and the scripts that move files
5
+ onto the machine. Nothing here bears on a measurement. It is kept because the
6
+ same problems recur and the recovery is rarely obvious, not because any of it
7
+ belongs in a paper.
8
+
9
+ **Numbering is shared with FINDINGS.md and entries keep the number they were
10
+ written under.** Renumbering would break the cross-references in the report,
11
+ the retractions and the entries themselves, so F-numbers are unique across the
12
+ two files rather than restarting here. If a number is missing from one file,
13
+ it is in the other.
14
+
15
+ ## 2026-07-26 — F38: The mouse mapping is a property of the display state, not of the machine, which is why the "mismatch" kept returning after being fixed
16
+
17
+ **Finding.** Phil reports that War Thunder modifies the display scaling every
18
+ time it opens. That single observation explains a bug that has been fixed and
19
+ has returned more than once.
20
+
21
+ The portal converts a click position in the captured image into KMBox
22
+ coordinates using a measured target space. That measurement was treated as a
23
+ constant of the machine and cached in one file, `.portal_target`. If the game
24
+ changes the scaling when it launches, the true coordinate space is different on
25
+ the desktop and in game — so one cached number is necessarily wrong in one of
26
+ the two states. Whichever state it was measured in, it works there and fails in
27
+ the other, which looks exactly like a bug that was fixed and came back.
28
+
29
+ This also reframes F29's cache finding. The stale cache was real, but staleness
30
+ was not the root cause; a cache that could only ever hold one value for two
31
+ different display states was. The value measured on 2026-07-21 was 2548x1411
32
+ and today's desktop measurement resolved to 2560x1440 — consistent with the two
33
+ having been taken in different display states, though that cannot be confirmed
34
+ retroactively.
35
+
36
+ **Decision.** Calibration is now scoped to a named display state:
37
+ `.portal_target.<profile>`, selected with `--profile` (default `desktop`). The
38
+ old unlabelled cache migrates into the desktop profile on first run. The portal
39
+ prints, at startup, that a calibration only holds while the display stays in the
40
+ state it was measured in, and that the game changes that state.
41
+
42
+ The operating rule for Task A follows directly: **calibrate with War Thunder
43
+ running and in the foreground, using `--profile warthunder`**, because that is
44
+ the only state in which we actuate for that task. A desktop calibration is fine
45
+ for driving the VS Code terminal and useless for aiming in game.
46
+
47
+ **Alternatives rejected.** Detecting the change automatically from the captured
48
+ frames was considered and rejected for now — it would have to infer a scaling
49
+ change from image content, which is guesswork, and a wrong inference silently
50
+ restores exactly the failure being fixed. Naming the state is explicit and
51
+ cannot be wrong about itself. Snapping to standard resolutions (added earlier
52
+ today) helps with measurement noise but does not address this at all: both
53
+ display states can have perfectly standard, and different, resolutions.
54
+
55
+ **Consequences.** Any earlier click-accuracy measurement taken without recording
56
+ which display state it belonged to is uninterpretable, and none were recorded
57
+ that way. No published result depends on this: Task A has produced no agent
58
+ numbers, and Tasks B and C are replay-scored and never actuate. The practical
59
+ effect is on future rig sessions, where calibration now has to be part of
60
+ entering the game rather than something done once.
61
+
62
+ ## 2026-07-26 — F39: The firmware's own key tap is too short for a game to see, measured at under 2 ms
63
+
64
+ **Finding.** Phil asked why the code uses a helper called `kmk(c,ms)` rather
65
+ than the firmware's `km.press(c)`, and separately reported that `km.string('w')`
66
+ did nothing. Both have the same answer, and it is measurable.
67
+
68
+ `kmk` is not a KMBox builtin; it is ours, uploaded to the device at open() as
69
+ `def kmk(c,ms): km.down(c); time.sleep_ms(ms); km.up(c)` so that a timed tap is
70
+ a single serial write instead of three round trips. Timing both on the device,
71
+ using F13 (bound by nothing) so the measurement is safe to take at any time:
72
+
73
+ km.press(104) 1.6 – 2.2 ms (firmware tap)
74
+ kmk(104, 30) 32 ms (the hold we asked for)
75
+
76
+ **A game samples input once per frame.** At 60 fps that is every 16.7 ms, so a
77
+ press held for under 2 ms can begin and end between two samples and never be
78
+ observed. That is the likely reason keys appeared to do nothing in the game.
79
+ `km.string()` is worse still: it is a text-entry helper, it emits characters
80
+ rather than holding a key, and it cannot express a duration at all.
81
+
82
+ **Decision.** The default hold for `key()` is raised from 30 ms to 60 ms —
83
+ three frames at 60 fps, two at 30 fps. 30 ms was only about 1.8 frames, close
84
+ enough to the sampling interval to be unreliable. `key_down()` and `key_up()`
85
+ were added for sustained holds, which driving requires and a timed tap cannot
86
+ express; every held key is tracked and released in `close()` so a crash cannot
87
+ leave the vehicle driving.
88
+
89
+ Separately, `_KEYCODES` was hand-maintained. The device ships the authoritative
90
+ mapping via `km.table()`, so `verify_keycodes()` now compares the two and
91
+ reports disagreements. Run against the hardware it returned zero — our table
92
+ was right, but it was right by luck rather than by construction.
93
+
94
+ **Consequences.** No published result changes: Tasks B and C are replay-scored
95
+ and never actuate. This matters for Task A, where every action is a real
96
+ keypress, and it removes a plausible cause of an agent appearing to do nothing
97
+ when it had in fact issued the correct action.
98
+
99
+ ## 2026-07-26 — F45: A truncating grep produced a wrong vehicle identifier, and the search for a master list turned up the route format instead
100
+
101
+ **Finding, and a correction to something already passed on.** The list of
102
+ "proven" vehicle classes reported earlier was produced with the pattern
103
+ `unit_class:t=.[a-z0-9_]*`, which stops at a hyphen and at any capital letter.
104
+ It silently truncated most of the identifiers:
105
+
106
+ reported actual
107
+ germ_tiger germ_tigerI
108
+ bf bf-109f-4, bf-109k-4
109
+ fw fw-190a-5
110
+ ju ju-88a-4
111
+ la la-5fn
112
+ me me-262a-1a
113
+ p p-39n, p-39q_5, p-40e
114
+ he he-111h-2
115
+ yak yak-1b
116
+ ussr_zis5_amd ussr_zis5_med
117
+
118
+ `germ_tiger` was offered as a safe class to use. It does not exist; using it
119
+ would have produced an invalid class name, which is defect one from F15 all over
120
+ again — arrived at this time by a careless regex rather than by guessing.
121
+ `germ_horch`, `us_lvt_a_1` and `sample_m60a1` contain no hyphens or capitals and
122
+ were unaffected.
123
+
124
+ **On the master list.** Searching the whole install for a known identifier
125
+ returns only `ui/atlases.vromfs.bin`, `ui/tex.vromfs.bin` — texture atlases
126
+ holding icon names — and the sample missions. No plaintext list of vehicles was found. That is weaker than it first appears:
127
+ the search reads files as text, which finds an ASCII string inside a binary file
128
+ but cannot see inside a compressed one, and the packed archives were only listed
129
+ rather than examined. The honest statement is that no list was found by a
130
+ plaintext search, not that none exists. The asset viewer that ships with the
131
+ CDK is the untried path, and it should be tried before treating the
132
+ shipped-mission set as the whole of what is available.
133
+
134
+ **The more useful discovery.** The shipped mission that uses `germ_horch` puts
135
+ it in a `wheeled_vehicles{}` block rather than `tankModels{}`, with an empty
136
+ weapons string and no ammunition — putting it in a tank block would probably
137
+ have failed. And the same unit carries a populated `way{}` block, which is the
138
+ route format that F29 went looking for and did not find:
139
+
140
+ way{
141
+ germ_vehicle01_wp_01{
142
+ type:t="normal"
143
+ tm:m=[[1, 0, 0] [0, 1, 0] [0, 0, 1] [-2435.05, 548.2, 9070.15]]
144
+ props{
145
+ speed:r=0
146
+ moveType:t="MOVETO_STRAIGHT"
147
+ }
148
+ }
149
+ ...
150
+ }
151
+
152
+ Waypoints are named sub-blocks of the unit's own `way{}`, each with a position
153
+ and a speed. There was never a top-level route object for `unitSetRoute` to
154
+ reference, which is why F29's repair was aimed at the wrong place.
155
+
156
+ **Why that matters beyond this mission.** Task A is defined by a vehicle that is
157
+ only briefly visible. A stationary target cannot produce an exposure window; a
158
+ moving one is the task. This is the first time the project has had the format
159
+ that makes a unit drive a path, taken from a file the game loads rather than
160
+ from documentation.
161
+
162
+ **Decision.** v8 adds a third unit — the fast wheeled vehicle — in the block
163
+ type the shipped mission uses for it, with a two-waypoint route running across
164
+ the player's view rather than away from it, on the strip of ground already known
165
+ to hold a vehicle correctly. Installed and verified by checksum. v6 remains the
166
+ preserved known-good baseline.
167
+
168
+ **Consequences.** Still no agent numbers, and v8 has not been launched. The
169
+ correction above should be treated as the important part: an identifier passed
170
+ on as verified was not, and the cause was a pattern that failed quietly rather
171
+ than loudly. Any future extraction of identifiers should be checked by counting
172
+ how many distinct values it returns and eyeballing them, not trusted because it
173
+ ran without error.
174
+
175
+ ## 2026-07-26 — F46: v8 copied the waypoints and not the trigger that makes them mean anything
176
+
177
+ **Finding.** F45 reported the route format as the discovery that unblocked a
178
+ moving target, and v8 was built and installed on the strength of it. The review
179
+ checked the reference file rather than the write-up and found that v8's vehicle
180
+ would not have moved at all.
181
+
182
+ Every waypoint in the shipped mission carries `speed:r=0`, and so does every
183
+ waypoint copied into v8. The shipped unit moves because a **separate trigger**
184
+ sets a speed on it later:
185
+
186
+ 11 waypoints at speed:r=0
187
+ 2 unitSetProperties actions, setting speed:r=20 and speed:r=50
188
+
189
+ v8's `triggers{}` block was empty. So the vehicle had a route it would never
190
+ traverse, and would have sat still exactly like the two stationary tanks — with
191
+ the difference that it looked, in the file, as though it should move.
192
+
193
+ This is the same failure as F29 one layer down. In F29 the mission referenced a
194
+ route object that did not exist. Here the route exists and the thing that
195
+ animates it does not. Both come from reading enough of a working file to find
196
+ the part being looked for, and stopping there.
197
+
198
+ **A second defect in the same build.** v8's waypoints held the height 7.82523
199
+ constant while running the path out to x=162 and z from -52 to 147. The only
200
+ ground ever confirmed to hold a vehicle correctly is around x=62 to 102 at
201
+ z=47 — a strip about 40 m wide — and a second reference pulled from the rig
202
+ shows height 14.3933 roughly 70 m away on the same map. The terrain is
203
+ demonstrably not level, and the mission is named for a ridge. Extending a
204
+ constant-height path well outside the validated strip is F23's
205
+ spawn-below-terrain defect restaged at a larger radius.
206
+
207
+ **Decision.** v9 fixes both and is installed. It adds a trigger that sets
208
+ `speed:r=20` on the wheeled vehicle, copied in structure from the shipped
209
+ mission's own `to_waypoint04`, and pulls the route back inside the validated
210
+ strip: the vehicle now runs along x=82, between the two units already known to
211
+ spawn correctly at x=62 and x=102, from z=7 to z=87. The exposure is shorter
212
+ than intended, and that is the point — it tests whether the vehicle moves
213
+ without simultaneously testing unmeasured terrain. Distance can be extended once
214
+ movement is confirmed and heights are checked.
215
+
216
+ **Alternatives rejected.** Launching v8 first to see what happened was rejected:
217
+ with two known reasons to fail it would have produced an ambiguous result
218
+ needing another bisection, which is how this mission file has already consumed
219
+ six rounds. Guessing a height for the longer path was rejected for the same
220
+ reason it was rejected in F41 — the values that must match the game get read
221
+ from the game, not invented.
222
+
223
+ **Consequences.** Task A still has no agent numbers and nothing has been
224
+ launched. The report's Task A panel had also drifted the other way and said
225
+ plainly "the mission itself now works"; only v6 was ever observed working, and
226
+ v7 and v9 have never been launched. The panel now names each version and what
227
+ is actually known about it. Two related corrections were made at the same time:
228
+ the wrong vehicle identifiers passed on earlier are withdrawn as R14, and F45's
229
+ claim that no master vehicle list exists is narrowed — a plaintext search cannot
230
+ see inside compressed archives, and the CDK asset viewer was never tried.
231
+
232
+ ## 2026-07-26 — F52: The mission format's failure and area conditions were read out of 200 real missions instead of guessed, and the mission can now be won or lost
233
+
234
+ **Finding.** Task A had no way to express an outcome. The mission loaded, an
235
+ enemy fired, a vehicle could be given a route — but nothing in it could end,
236
+ so there was no in-game notion of the agent succeeding or failing. The four
237
+ constructs needed were all unknown: how to fail a mission, how to test whether
238
+ a named unit is inside an area, how to declare an area that is not a single
239
+ point, and how to test whether a unit has been destroyed. None appears in
240
+ either shipped mission file we hold.
241
+
242
+ Guessing them was the obvious move and the wrong one — inventing plausible
243
+ identifiers is what produced F15, F45 and R14. Instead the community mission
244
+ feed was used as a corpus. Its listing page is JavaScript-rendered and returns
245
+ no links to a plain fetch; the underlying endpoint is `POST
246
+ /api/feed/get_regular/` with `content=mission&sort=date&page=N`, which returns
247
+ direct download links. Two hundred real mission files were retrieved and kept
248
+ in `media/wt_incoming/reference/`.
249
+
250
+ Verified against those files, with usage counts across the corpus:
251
+
252
+ construct files role
253
+ unitWhenInArea 41 condition: is a named unit inside an area
254
+ unitWhenStatus 39 condition: unit status, e.g. isKilled
255
+ unitWhenKilled 21 condition: simpler unit-destroyed form
256
+ missionCompleted 11 action: end the mission as a win
257
+ missionFailed 4 action: end the mission as a loss
258
+
259
+ One file, `livewarthunder_1228279_11_-_Operation_Sea_Lion.blk`, carries a
260
+ complete win/loss pair with almost exactly the shape needed: a named unit
261
+ entering a sphere fires `missionFailed{team:t="Both"}`, and that unit being
262
+ killed fires `missionCompleted{team:t="Both"}`. Area shapes turn out to carry
263
+ no radius or size field at all — `Sphere`, `Box` and `Cylinder` encode their
264
+ size in the scale diagonal of the transform matrix, which is why looking for a
265
+ radius field found nothing.
266
+
267
+ **A discrepancy worth recording.** The official documentation's action table
268
+ spells the win action `missionComplete`. Not one of the 200 real files uses
269
+ that spelling; all eleven that end a mission use `missionCompleted`, and so
270
+ does the shipped mission we already hold. The documentation is taken to be
271
+ wrong. This is the same class of problem as the vehicle identifiers: the
272
+ authoritative-looking source disagreed with the files the game actually loads,
273
+ and the files win.
274
+
275
+ **Decision.** v11 adds both outcomes. The wheeled vehicle reaching a sphere at
276
+ the far end of its route fails the mission; the vehicle being destroyed
277
+ completes it. The area test uses `math:t="2D"` rather than the 3D form the
278
+ reference file uses, deliberately — every unit in this mission sits at a single
279
+ hard-coded height copied from another file, and a 3D test would depend on that
280
+ number being right. A 2D test does not. Also in v11: the enemy LVT is removed
281
+ and the vehicle's route runs along the one line of coordinates ever confirmed
282
+ to load.
283
+
284
+ **Alternatives rejected.** Writing `missionFailed{}` from memory was rejected
285
+ for the reason above. Using `playersDistanceBetween`, the one condition already
286
+ verified, was rejected because it tests the player's position rather than the
287
+ vehicle's, which is a different question wearing the right shape.
288
+
289
+ **Consequences.** Task A gains an outcome the game itself decides, which is
290
+ what a scored episode needs — the alternative was reading success off the
291
+ capture card. It remains unlaunched: v9, v10 and v11 have never been run, and
292
+ v6 is still the last version confirmed good in-game.
293
+
294
+ **What is still guessed, and it is the important one.** The mission runs on
295
+ `levels/empty_location.bin` and every unit is pinned to y=7.82523, a constant
296
+ copied from a reference file rather than read off terrain. A vehicle was
297
+ already once observed below the water line, which is the signature of that
298
+ constant not matching the ground at that position. So the route, the escape
299
+ sphere and the hill the vehicle is supposed to pass behind are all placed
300
+ without terrain data. v11 marks the far end of the route on the display so one
301
+ run reveals where it actually sits.
302
+
303
+ ## 2026-07-26 — F53: The actuator can fail silently, and the failure looks exactly like a dead device
304
+
305
+ **Finding.** Installing v11 during a ten-minute window on the rig produced a
306
+ failure mode this project had not seen and would have misdiagnosed. Three
307
+ attempts to type a command into a PowerShell prompt over the hardware keyboard
308
+ behaved like this:
309
+
310
+ 1. `km.string()` with a 75-character command delivered the first word, `iwr`,
311
+ and nothing else. No error.
312
+ 2. Discrete keycodes 12 ms apart delivered about thirty characters, stopping
313
+ mid-URL. Every character that did arrive was correct, including the
314
+ shifted ones, so the keycode table was not at fault.
315
+ 3. A third attempt, slower and with a shorter command, delivered nothing at
316
+ all. The prompt line did not change.
317
+
318
+ The natural reading after (2) is a serial buffer overrun, and that is what I
319
+ assumed. It was wrong. Reading the device echo instead of the screen showed
320
+ the REPL answering `print(1+1)` with `... ` — the MicroPython continuation
321
+ prompt. Somewhere in the burst a command left an unterminated block, and from
322
+ that point every line was consumed as part of that block. Commands were
323
+ accepted, no error was returned, and no input reached the PC.
324
+
325
+ **Why this is worth an entry rather than a fix in passing.** The symptom is
326
+ indistinguishable from a dead actuator from the outside, and the obvious
327
+ recovery makes it worse: sending Ctrl+C through the box is a HID chord aimed at
328
+ the attached machine and does nothing to the REPL. The REPL needs a raw 0x03
329
+ byte on the wire. Until that is sent, every subsequent run of every script will
330
+ appear to work and produce no input.
331
+
332
+ **Decision.** `KMBox.interrupt()` sends the raw interrupt and verifies the
333
+ prompt is no longer a continuation prompt, raising if it is. `open()` calls it
334
+ before anything else, so the state cannot survive from one run into the next.
335
+
336
+ **Alternatives rejected.** Slowing the keystroke rate was rejected as the fix
337
+ once the real cause was known — it addresses a buffer overrun that was not
338
+ happening, and would have left the true fault to reappear. Retrying on silence
339
+ was rejected for the same reason: the failure is silent by construction, so a
340
+ retry loop would have retried into a wedged REPL indefinitely.
341
+
342
+ **Consequences.** Any earlier result that depended on typed input and appeared
343
+ to do nothing is now suspect for a different reason than assumed. Nothing
344
+ published depends on typed input, so nothing changes. The lesson generalises
345
+ past this device: the actuator is the one component whose failure produces no
346
+ error anywhere, because there is no return path from the keyboard to the
347
+ program. It has to be checked by reading its echo, not by watching for an
348
+ exception.
349
+
350
+ **What was achieved in the window.** v11 installed and verified by hash on the
351
+ rig (`gua_bmp_ridge.blk` 61181b8e66718fd893211d8c95641686, 6388 bytes;
352
+ `usr_gua_bmp_ridge.csv` 358b761f6cee99a7f06067e3a3018a40, 1175 bytes), with the
353
+ previous files backed up to `UserMissions\backup-20260726-214216`. The mission
354
+ was NOT launched — the window had passed — so v6 remains the last version
355
+ confirmed good in-game and v11 is installed but untested.
356
+
357
+ ## 2026-07-26 — F55: The install script wrote its backups into a directory the game enumerates
358
+
359
+ **Finding.** The installer backed up the previous mission to
360
+ `UserMissions\backup-<timestamp>\`. War Thunder lists everything under
361
+ `UserMissions`, so each install added an entry to the in-game mission list.
362
+ The backup was correct, safe and in the worst possible place: a directory
363
+ belonging to the application, whose contents are its user interface.
364
+
365
+ **Decision.** Backups go to `%LOCALAPPDATA%\WarThunder\mission_backups\`,
366
+ outside the enumerated directory. The installer also moves any `backup-*`
367
+ folder the earlier version left behind, and prints the directories remaining
368
+ under `UserMissions` so the folder can be seen to be clean rather than assumed
369
+ to be. It moves rather than deletes — the point of a backup is not to be
370
+ removed by the tool that made it.
371
+
372
+ **Consequences.** The general form is worth keeping: a directory an
373
+ application reads is not scratch space, even for something as harmless as a
374
+ backup. The same reasoning applies to the frames and label files this project
375
+ writes next to media it replays from.
376
+
377
+ **State after this.** v13 installed and verified on the rig
378
+ (`gua_bmp_ridge.blk` cfebe634b606b9936af4e826c1dec9b3, 10546 bytes;
379
+ `usr_gua_bmp_ridge.csv` e36ecaac4f20ce60e24cb8ebd8f78268, 1175 bytes), no
380
+ directories left under `UserMissions`. Still not launched, so v6 remains the
381
+ last version confirmed good in-game.
382
+
383
+ ## 2026-07-26 — F56: Two mistakes in one install — every version overwrote the same mission slot, and the player vehicle is a requirement the game enforces
384
+
385
+ **Finding.** v13 was installed and turned out to be both destructive and
386
+ unplayable, for two unrelated reasons.
387
+
388
+ **One: a single slot.** Every version this project has produced was written to
389
+ `gua_bmp_ridge.blk`. There is only one such file, so each install replaced the
390
+ previous mission rather than adding to it. When v12/v13 moved to a different
391
+ map, the working configuration — the small piece of ground with the amphibious
392
+ player vehicle and a wheeled target — stopped existing anywhere on the rig. It
393
+ survived only because every version is also kept on the Linux box. A mission
394
+ that took several attempts to get right was destroyed by a step that was
395
+ supposed to be a deployment, not an edit.
396
+
397
+ **Two: the player's vehicle is a gate.** The User Missions panel showed
398
+ `Requirements: Purchase Leopard 2A7V` and the entry carried a padlock;
399
+ attempting to start it produced a modal, "To unlock this mission, you need:
400
+ Purchase Leopard 2A7V". The `unit_class` given to the player unit is checked
401
+ against the account, and a vehicle that is not owned makes the mission
402
+ un-startable. I picked `germ_leopard_2a7v` because it was proven to load on
403
+ the new map — proven for the game, not for this account, and I did not
404
+ distinguish the two. `us_lvt_a_1` was never just a vehicle that worked; it was
405
+ the vehicle this account owns.
406
+
407
+ **Decision.** Missions are now separate file pairs keyed by id, staged through
408
+ a manifest, so installing one cannot disturb another:
409
+
410
+ * `gua_island` — v11 restored exactly: the original location, the amphibious
411
+ player vehicle, the wheeled target, no enemy LVT.
412
+ * `gua_fulda` — v14: the new map and route, with the player vehicle changed
413
+ back to `us_lvt_a_1`.
414
+
415
+ The installer reads the manifest, backs up anything it would overwrite, and
416
+ moves the old shared-slot files out to `mission_backups` rather than deleting
417
+ them, since the rig copy was the only one on that machine.
418
+
419
+ **Alternatives rejected.** Picking a different modern vehicle for the Fulda
420
+ mission was rejected — the account's inventory is not known here, and the one
421
+ class with evidence behind it is the one that has already run. Deleting the
422
+ old `gua_bmp_ridge` files was rejected for the obvious reason.
423
+
424
+ **Consequences.** "Proven" needs to be qualified by what it was proven
425
+ against. A class read out of a mission the game ships is proven to exist and to
426
+ load; it is not proven to be available to the person playing. The same
427
+ distinction applies to maps, and probably to ammunition.
428
+
429
+ ## 2026-07-27 — F57: The keyboard is not a reliable channel, in a second way — an input-method change silently rewrites every keystroke
430
+
431
+ **Finding.** The install was typed twice. The second attempt produced this in
432
+ the shell:
433
+
434
+ PS C:\Users\philz> ¥ 大"¥ 恶女:LOCALAPPDATA、WarT混的人、User Missions"
435
+
436
+ Every keystroke had been reinterpreted by a Chinese input method. The KMBox
437
+ sent the same HID codes it always does; Windows turned them into different
438
+ characters. The commands failed with parser errors, nothing installed, and a
439
+ half-parsed command was left sitting at a continuation prompt.
440
+
441
+ The recovery is not obvious: the layout is switched with Win+Space, which has
442
+ to be sent through the same actuator that is being mistranslated — but as a
443
+ key chord it is unaffected by the input method, so it works. Ctrl+C cleared the
444
+ shell, Win+Space restored the layout, and a probe command echoed the correct
445
+ path before anything real was retyped.
446
+
447
+ **Why this belongs next to F53.** That entry recorded the actuator failing
448
+ silently because the device REPL was wedged: commands accepted, nothing
449
+ emitted. This is the same class and a different mechanism: commands accepted,
450
+ something emitted, but not what was sent. Both are invisible from the sending
451
+ side, because there is no return path from a keyboard to the program typing on
452
+ it. The rig has now produced two of these in one session, which makes it a
453
+ property of the channel rather than a pair of accidents.
454
+
455
+ **Decision.** Any sequence of typed commands begins with a probe whose expected
456
+ output is known — here, assigning a path and echoing it — and the screen is
457
+ read before the real commands are sent. This costs one round trip and would
458
+ have caught both failures immediately. It is a procedure rather than a code
459
+ change because the check has to happen on the screen, which is the only place
460
+ the truth is visible.
461
+
462
+ **Alternatives rejected.** Retrying on failure was rejected: neither failure
463
+ reports an error, so there is nothing to retry on. Avoiding the keyboard
464
+ entirely by having the operator run commands was rejected as the default —
465
+ it works, but the whole point of the rig is that the machine can be driven
466
+ without a person at it.
467
+
468
+ **Cause, from the operator.** Nothing switched the layout: Chinese pinyin
469
+ input was already selected. My first guess — that a stray or overlapping
470
+ modifier in the Win+R and Shift chords had triggered a layout hotkey — was
471
+ wrong, and is recorded here because it is the more flattering explanation and
472
+ I reached for it first. The actual lesson is duller and more useful: the rig's
473
+ input method is part of its state, it is set by whoever last used the machine,
474
+ and nothing about it is visible from the sending side.
475
+ Watching for a recurrence is cheaper than guessing.
476
+
477
+ **State.** Both missions installed and verified by hash: `gua_island.blk`
478
+ 7f80bce5b99d0e2bc6ac999e4a231115 (5300 bytes), `usr_gua_island.csv`
479
+ 7a14379120f5c14ccc120a061126db98 (1138), `gua_fulda.blk`
480
+ ad1ec77b9ca427a12d5e4384bf6a703e (7155), `usr_gua_fulda.csv`
481
+ 165dcc2d6832f7f3b274a5031c98dbb7 (1121). Neither has been launched.
482
+
483
+ ## 2026-07-27 — F62: The island target never moved, through five versions, because of which of two waypoint mechanisms the mission used
484
+
485
+ **Finding.** War Thunder missions can give a vehicle a route two ways, and only
486
+ one of them works on this rig.
487
+
488
+ * **Named route.** A route defined in the top-level `wayPoints{}` block with a
489
+ real `speed:r=` on every waypoint, referenced from the unit by
490
+ `wayPoints:t="<name>"`, with the unit's own `way{}` left empty. This is
491
+ what `fulda_convoy.blk` does.
492
+ * **Inline route with a trigger.** Waypoints inside the unit's own `way{}`,
493
+ each carrying `speed:r=0`, with a `unitSetProperties{ speed:r=N }` trigger
494
+ firing on a periodic event to supply the speed afterwards. This is what
495
+ `horch.blk` does, and it is the pattern F46 read off that file and adopted.
496
+
497
+ The Fulda mission used the first and drove its truck 130 m to its zone with no
498
+ player present, ending itself in a loss. The island mission used the second and
499
+ its car never moved once, across v11, v15, v19, v20 and v22. Switching the
500
+ island to the named route made it work immediately: the mission now drives the
501
+ car to the gate and declares the loss by itself.
502
+
503
+ **The symptom lied for a long time, and I read it wrong three times.** v19
504
+ ended in about three seconds and I recorded that as the car reaching its gate
505
+ too quickly. It was not: the car's spawn at x=102 sat exactly on the boundary
506
+ of a 40 m gate sphere centred at x=142, so the mission lost the instant it
507
+ started. Every version after that moved the spawn, the speed and the gate
508
+ radius in response to a symptom that had nothing to do with any of them. Three
509
+ edits, none of which could have helped, because the thing being adjusted was
510
+ never the thing that was broken.
511
+
512
+ **What should have caught it sooner.** The two missions were sitting side by
513
+ side with different mechanisms and one of them was known to work unattended.
514
+ Comparing them took one command and settled it. I reached for that only after
515
+ the operator asked "what did you change?" for the second time.
516
+
517
+ **Decision.** The named route is the mechanism for this project. `horch.blk`'s
518
+ pattern is not adopted again without first watching a vehicle actually move
519
+ under it — it is a shipped mission, but shipping is not evidence that a
520
+ particular part of it does anything.
521
+
522
+ **Consequence for the results.** Every Task A episode recorded before this
523
+ change was run against a mission whose target did not move, and three of those
524
+ batches were on a mission whose target unit did not exist at all. None of them
525
+ are agent measurements. The first episode after the fix shows the agent using
526
+ all four actions including driving, which is already different behaviour from
527
+ anything recorded before.
528
+
529
+ ## 2026-07-27 — F63: Half of every Task A episode was the agent deciding about a loading screen
530
+
531
+ **Finding.** The first valid Task A batch recorded 43 to 45 decisions per
532
+ episode. Sampling frames from the recordings showed the mission itself ends at
533
+ about 20.6 seconds, consistently across all eight episodes, against an episode
534
+ budget of 45 seconds. Everything after that is a loading screen and a debrief.
535
+
536
+ So roughly half of every episode was the agent answering questions about a
537
+ menu. Counted naively that produced:
538
+
539
+ per episode, as first counted look 8.5 drive 0.6 fire 12.1 none 22.3
540
+ per episode, mission only look 6.4 drive 0.8 fire 12.1 none ~0
541
+
542
+ The "none" column was the whole difference. Read from the raw counts, the agent
543
+ looked like it declined to act on half its decisions despite a prompt telling it
544
+ to search. In fact it acts on **essentially every decision while the mission is
545
+ running**, and every "none" was a frame showing a menu.
546
+
547
+ **This is the third instance of the same error in this project.** F51 found a
548
+ detection rate that was a property of how much of each video was downloaded.
549
+ F58 found a Task A zero produced by a mission that never showed the target. Now
550
+ an action distribution that was mostly an artefact of frames recorded after the
551
+ task had finished. In all three the arithmetic was right and the frames were
552
+ never looked at.
553
+
554
+ **Decision.** Episodes end when the mission ends, detected from the minimap
555
+ corner, which exists only during a battle. Scoring applies the same cut to the
556
+ eight episodes already recorded, so they did not need re-running — the frames
557
+ carry enough information to recover the correct window after the fact.
558
+
559
+ **Consequence.** The corrected numbers are the ones in the report: the agent
560
+ acted in 8 of 8 episodes, fired about twelve times per episode, drove less than
561
+ once, and destroyed the vehicle zero times. The action counts are now over
562
+ about 19 decisions rather than 44, which also means the agent gets far fewer
563
+ looks at the problem than the episode length suggested.
564
+
565
+ ## 2026-07-27 — F65: The end of an episode is stated by the game, and reading that statement moves the cut by five seconds
566
+
567
+ **Finding.** Every previous attempt to find where a Task A episode stops being
568
+ gameplay used a statistic computed over pixels: first the fraction of a corner
569
+ that was blue, then the amount of edge detail in the same corner. The game does
570
+ not require either. When the mission ends it prints "Mission Failed" or
571
+ "Mission Accomplished" in a fixed font at a fixed position. Matching that text
572
+ directly (normalised cross-correlation against a stored crop of the banner,
573
+ requiring two consecutive frames above 0.90) separates cleanly: debrief screens
574
+ score 1.000, and across whole episodes on both maps the best score reached by
575
+ any in-battle frame was 0.040, with no run of consecutive matches at all.
576
+
577
+ Reading the banner disagrees with the detail-energy detector it replaces. On the
578
+ island batches the game states the mission is over at t ≈ 25.5 s; the detail
579
+ detector cut at t ≈ 20.5 s. About five seconds of real in-battle decisions were
580
+ being discarded as post-mission menu frames. On the Fulda batch the banner never
581
+ appears, correctly — those episodes ended before their missions did — where the
582
+ blue-fraction proxy would have truncated every one of them at its third
583
+ decision.
584
+
585
+ **Decision.** `run_wt_live.py` and `score_wt.py` both key off the banner match.
586
+ The template is stored as an inspectable image at
587
+ `experiments/wt_live/_end_banner.png` rather than as numbers in the source, so a
588
+ reader can see what is being matched.
589
+
590
+ **Alternatives rejected.** Asking the local model on every frame whether the
591
+ mission had ended would have been robust to layout changes but costs a full
592
+ inference per frame and makes the episode boundary a model output rather than a
593
+ fact. Keeping a pixel statistic and tuning its threshold per map was what
594
+ produced F63's wrong boundary in the first place.
595
+
596
+ **Consequences.** F63's per-episode decision counts were computed against the
597
+ 20.5 s cut and undercount in-battle decisions. All Task A batches have been
598
+ rescored against the banner. The claim in F63 — that a large share of each
599
+ episode was menu frames — still holds; its boundary was wrong by five seconds.
600
+
601
+ ## 2026-07-27 — F66: A scorer keyed to action names returned zeros for a third time
602
+
603
+ **Finding.** `score_wt.py` counted actions by matching hardcoded strings
604
+ (`'look'`, `'fire'`, `'drive'`). The camera-relative action space emits
605
+ `'mouse'`. The scorer matched none of it and reported 0 camera motions per
606
+ episode for a batch that contains 117 of them, 14.6 per episode. Nothing raised.
607
+
608
+ This is the third instance of one defect: F50 and F59 were both a scorer testing
609
+ for action names that had changed underneath it and reporting zeros, and in F59
610
+ the zeros were published. Writing F50 did not prevent F59, and writing both did
611
+ not prevent this.
612
+
613
+ **Decision.** Counting now goes through `classify()`, which maps each action to
614
+ look / fire / drive / sight / none and **raises** on any kind or key it does not
615
+ recognise. A future action-space change stops the run instead of scoring the
616
+ batch as inactivity.
617
+
618
+ **Alternatives rejected.** Adding `'mouse'` to the existing string sets is what
619
+ was done after F50 and after F59, and it fixes the instance without touching the
620
+ mechanism. Deriving categories from the parser in `run_wt_live.py` would couple
621
+ the scorer to the runner, which is the coupling this project deliberately avoids
622
+ so the scorer cannot influence the outcome.
623
+
624
+ **Consequences.** The affected figure was never published: it was computed and
625
+ corrected within the same session. The `0 shots` and `0 drives` in the same row
626
+ are real — that batch contains no fire and no drive actions at all.
627
+
628
+ ## 2026-07-27 — F67: The capture card hands over undecodable frames, and guarding one consumer only moves the crash
629
+
630
+ **Finding.** The video capture path intermittently returns a truncated JPEG.
631
+ The first time this stopped a run it came through the end-of-mission check;
632
+ after that check was given a try/except it stopped the very next run through the
633
+ menu-comparison check instead. Two consumers, same bad bytes, same crash, one
634
+ minute apart. Every consumer in the runner decodes the picture, so handing out
635
+ bytes that cannot be decoded guarantees the failure reappears at whichever
636
+ caller touches them next.
637
+
638
+ **Decision.** `frame_timed()` decodes the bytes before returning them and asks
639
+ the portal again if the decode fails, up to four times, raising only if the
640
+ capture path is genuinely broken. Twelve consecutive frames now decode cleanly
641
+ through it. The per-consumer guard in the banner reader is kept, because a
642
+ frame read back off disk later can also be truncated, but it is no longer what
643
+ the live loop depends on.
644
+
645
+ **Alternatives rejected.** Wrapping each consumer in try/except is what was
646
+ tried first and it is a losing game — there are five decode sites and any new
647
+ one starts unguarded. Lowering the capture rate might reduce the truncation
648
+ rate but would change what the agent is timed against, which is a measurement
649
+ change made for a plumbing reason.
650
+
651
+ **Consequences.** No episodes were lost: both crashes happened during setup,
652
+ before any decision was recorded. A retried frame is a frame period older than
653
+ one that succeeded first time, which is recorded in the existing per-decision
654
+ capture timings rather than hidden.
655
+
656
+ ## 2026-07-27 — F68: An action was offered to the agent that the hardware could not perform
657
+
658
+ **Finding.** The Task A prompt offered the agent two magnified sight modes,
659
+ commander sight on `b` and gunner sight on `lshift`. The portal's key table had
660
+ no entry named `lshift`, so that action could never have been performed. The
661
+ run that first attempted it died mid-batch on `HTTP 400: unsupported key
662
+ 'lshift'`.
663
+
664
+ The reason this was not caught earlier is the uncomfortable part. The previous
665
+ batch reported "sights: 0.0 per episode" and that was read as a fact about the
666
+ agent's choices. It was — that batch emitted no key actions at all — but had it
667
+ tried, the run would have crashed. An action space was published in the report
668
+ that had never been exercised end to end.
669
+
670
+ **Decision.** Two changes. The portal gained the side-named modifier aliases
671
+ (`lshift`, `rshift`, `lctrl`, ...), which are aliases rather than new keys since
672
+ the HID codes are already side-specific. And the portal now answers `GET /keys`
673
+ with what it can press, so `run_wt_live.py` checks its whole action vocabulary
674
+ against the device before episode 0 and refuses to start if anything it offers
675
+ the agent cannot be produced.
676
+
677
+ **Alternatives rejected.** Adding `lshift` alone fixes the instance and leaves
678
+ the next added verb equally unchecked, which is the pattern F66 was written
679
+ about. Exercising each action for real as a warm-up would test more, but it
680
+ sends live input at whatever is on screen before the mission starts, and typing
681
+ without checking focus is what put the researcher's account into a live
682
+ multiplayer match earlier in this project.
683
+
684
+ **Consequences.** The `island_v23_cam` row's "sights: 0.0" stands as reported —
685
+ that agent never asked — but the report should not be read as evidence that
686
+ sights are unhelpful, because no agent has yet been able to use one. The
687
+ ablation batch that hit this was discarded and re-run.
688
+
689
+ ## 2026-07-27 — F69: Twelve numbers in the report were typed in, and three of them were wrong
690
+
691
+ **Finding.** The six paired comparisons for Task B appeared in the report as
692
+ literal table rows in `build_artifact.py`. `metrics_v2.paired_compare` exists
693
+ for exactly this and was never called by anything that builds the report.
694
+ Recomputing the twelve numbers from the records: the six F1 rows reproduce
695
+ exactly, and three of the six precision rows do not.
696
+
697
+ | comparison | as printed | recomputed |
698
+ |---|---|---|
699
+ | Opus vs local Qwen | +0.048 | −0.048 |
700
+ | Opus vs Haiku | +0.077 | −0.077 |
701
+ | local Qwen vs Haiku | 6 of 13 | 7 of 13 |
702
+
703
+ The two sign reversals are not a convention difference: they are backwards
704
+ against the F1 table directly above them, and against this report's own
705
+ sentence describing the same result as "Opus over Haiku". As printed, the row
706
+ said Haiku was ahead while the paragraph beneath said Opus was.
707
+
708
+ **Decision.** Both tables are generated by `_sign_test_table()` from the
709
+ records on every build. The medians, differing-video counts and p-values can no
710
+ longer drift from the data they describe.
711
+
712
+ **Alternatives rejected.** Correcting the three rows in place would have
713
+ restored the numbers and left intact the thing that produced them, which is the
714
+ same mechanism behind F50 and F59.
715
+
716
+ **Consequences.** The direction of two comparisons in published report versions
717
+ was reversed; RETRACTIONS R19. The conclusions drawn in the surrounding prose
718
+ were stated in the correct direction throughout, so no argument in the report
719
+ depended on the reversed figures — but a reader reading the table alone would
720
+ have taken the wrong ordering from it.
721
+
722
+ ## 2026-07-27 — F70: Pinning the coordinate span silently disabled the pointer re-zeroing that shared its endpoint
723
+
724
+ **Finding.** Six of eight episodes in an ablation batch never launched. The
725
+ runner behaved correctly — it refuses to record a menu and skipped them — but
726
+ the yield was one usable episode in eight.
727
+
728
+ The cause was a fix I made earlier. `/calibrate` did two unrelated jobs: it
729
+ measured the coordinate span through the camera, and, as a side effect of
730
+ re-running the device setup, it re-parked the pointer at the origin and
731
+ restarted absolute tracking. `finish_mission()` calls `/calibrate` only for the
732
+ second job, because the device's absolute origin does not survive the
733
+ display-state change when a battle ends. Pinning the span with `--target`
734
+ (itself a necessary fix: auto-measurement returned 2560x1440, then 1589x809,
735
+ then 1440x900 depending on screen content, and a wrong span is what started a
736
+ live multiplayer match) made `_calibrate_now()` return early — skipping the
737
+ re-zeroing along with the measurement. Every menu click after a battle then
738
+ landed on empty screen, the debrief stayed up, and each subsequent launch found
739
+ an overlay instead of a mission list.
740
+
741
+ What made it hard to see is that nothing reported an error. The device replied
742
+ `km.moveto(1277,1293)` and `current: 1277, 1293` — the request was accepted and
743
+ the internal position was exactly right — while the on-screen pointer had not
744
+ moved at all. The failure was visible only by comparing the device's own
745
+ account of where it was against a screenshot.
746
+
747
+ **Decision.** The two jobs are separated. When the span is pinned, the endpoint
748
+ still drops the device to relative mode, which clears the calibrated flag so
749
+ the next absolute move re-parks at (0,0) and restarts tracking. Verified
750
+ against the stuck debrief: the same click that had been doing nothing dismissed
751
+ the screen.
752
+
753
+ **Alternatives rejected.** Having `finish_mission()` post `/set_relative`
754
+ itself fixes this caller and leaves the endpoint's contract quietly broken for
755
+ every other one. Un-pinning the span would restore the re-zeroing and bring
756
+ back the failure that pinning was introduced to prevent.
757
+
758
+ **Consequences.** Two ablation batches were discarded and re-run; no scored
759
+ result was affected, because the runner never recorded the menus it saw. The
760
+ general lesson matches F65 and F66: this apparatus keeps producing failures
761
+ that report success, and the only thing that catches them is comparing what a
762
+ component says it did against a picture of what happened.
763
+
764
+ ## 2026-07-27 — F72: The "generate, don't type" fix was applied to two tables and three more of the same kind were left alone
765
+
766
+ **Finding.** F69 replaced two hand-typed tables with generated ones. A second
767
+ critic pass found that the sampling-rate section still contained three
768
+ structurally identical hand-typed tables — the rate sweep itself, the three
769
+ rate-transition sign tests, and a suppression comparison — doing the same kind
770
+ of statistical claim with the same exposure to drift. Fixing the instances that
771
+ were pointed out and leaving the neighbours is the same shape of mistake as
772
+ F66, where the fix after F50 and F59 was applied to one scorer at a time.
773
+
774
+ Recomputing them from the records: every number matched what was printed. The
775
+ defect here was the mechanism, not the values.
776
+
777
+ **Decision.** The rate sweep rows and the rate-transition sign tests are
778
+ generated by `_rate_rows()` and `_rate_step_table()`. Both reproduce the
779
+ published figures exactly.
780
+
781
+ **Alternatives rejected.** Leaving them because they happened to be correct is
782
+ what F69 already argued against: a static string cannot notice that the records
783
+ changed under it.
784
+
785
+ **Consequences.** One trap surfaced while doing this. The first generated
786
+ version silently changed four columns — decisions per episode became a batch
787
+ total, and three means became medians — because the aggregation was rewritten
788
+ rather than reproduced. That would have republished different numbers under
789
+ unchanged headings for no reason connected to correctness. The aggregation was
790
+ matched to what the table had always used and the values now regenerate
791
+ unchanged. Replacing a typed number with a computed one is only an improvement
792
+ if the computation is the one that produced it.
793
+
794
+ ## 2026-07-28 — F73: Absolute tracking clamped the human's mouse and flooded the serial link; the portal could not drive the game at all
795
+
796
+ **Finding.** Three faults reported from the rig, all real, all in the input
797
+ path, and none of them affecting the recorded episodes.
798
+
799
+ *The mouse could not move right past a point, but only through the KMBox.* The
800
+ device was being left in absolute tracking mode (`km.zero(1)` plus
801
+ `km.Screen(2560,1440)`) whenever it was not mid-aim. In that mode the box
802
+ clamps its tracked position to the calibrated box, and that position includes
803
+ movement arriving from a physical mouse plugged into it. The device's own
804
+ telemetry shows the clamp directly: `current: 2560, 190` repeating while y
805
+ continues to change, and `current: 908, 0` at the top edge. Absolute mode is
806
+ needed for one thing, landing a menu click on a given pixel, and was on the
807
+ rest of the time.
808
+
809
+ *The same mode floods the serial link.* Absolute tracking streams `current:
810
+ x, y` continuously, so the reply to every command arrives buried in position
811
+ reports. Any device-side error — a missing helper, a rejected key — is
812
+ unreadable. After dropping tracking, replies come back clean.
813
+
814
+ *Key presses from the portal page did nothing useful in game.* Two causes, and
815
+ neither was the suspected one: the device-side `kmk()` helper is still defined
816
+ (`<function kmk at 0x3ffe8a50>`), so it had not been lost. The page sent a
817
+ fixed 60 ms tap per key event, which cannot express holding W to drive, and it
818
+ dropped lone modifiers outright (`if key in _MODIFIERS: return True`), so
819
+ LSHIFT — the gunner sight — could never be sent from the page at all.
820
+
821
+ **Decision.** Absolute mode is now momentary: entered for a click, dropped
822
+ immediately after, so the box rests in relative mode with no clamp and no
823
+ streaming. `key()` uses `km.down`/`km.up` rather than the RAM-resident `kmk`
824
+ helper, since a firmware call cannot go missing. The portal's keyboard capture
825
+ holds a key for as long as it is actually held and maps browser modifier names
826
+ to side-specific device keys, and releases everything on blur. A `/raw`
827
+ endpoint and a row of manual controls (relative moves, the game keys, mode
828
+ switches, a raw REPL box) sit under the video, because every diagnosis above
829
+ needed the ability to ask the device a question by hand.
830
+
831
+ **Alternatives rejected.** Keeping absolute mode and raising the `km.Screen`
832
+ bounds would hide the clamp rather than remove it, and would not stop the
833
+ serial flood. Leaving `kmk` in place was defensible on the evidence — it was
834
+ not missing — but it is a helper in volatile memory standing in for a firmware
835
+ call that does the same job.
836
+
837
+ **Consequences for the results: none of the three explains the Task A
838
+ outcome, and this was checked rather than assumed.** Comparing each frame with
839
+ the next across all recorded episodes, every action type moved the screen well
840
+ clear of the do-nothing baseline of 0.14: fire 4.72, drive 18.55, look 23.33,
841
+ and the commander-sight key 72.29. The agent's inputs reached the game. The
842
+ one pattern that might have looked like a clamp — 115 of 117 camera movements
843
+ having no horizontal component (F64) — is not one: the model wrote `mouse(0,
844
+ -200)` itself, so the zero is in its own output, not in the actuator.
845
+
846
+ What the faults did break is the human path. A person at the rig could not
847
+ drive from the portal, because a tap is not a hold, and could not use the
848
+ gunner sight at all. That is worth stating plainly: the apparatus was easier
849
+ for the agent to use than for a person, and nobody noticed because nobody had
850
+ tried to play through it until now.
851
+
852
+ ## 2026-07-28 — F74: The pointer decouples because the game moves it where the device cannot see, so the check belongs at the click, not in a polling loop
853
+
854
+ **Finding.** Reported from the rig: while playing through the portal, the
855
+ Windows pointer periodically stops agreeing with where the portal thinks it
856
+ is, and pressing Recalibrate by hand restores it.
857
+
858
+ The mechanism follows from how absolute positioning works here. The KMBox
859
+ reaches a target by emitting the delta between its own model of the pointer
860
+ position and the requested point. That model is correct only while every
861
+ movement of the OS pointer originates at the box. War Thunder violates that:
862
+ in battle it takes raw input with the pointer hidden and locked, and on the way
863
+ back to a menu Windows restores the pointer somewhere the box never observed.
864
+ From then on every absolute move is wrong by that single unseen jump, in a
865
+ fixed direction, until something re-parks the pointer at a known point.
866
+ `km.zero(1)` does exactly that, which is why the manual button worked.
867
+
868
+ **Decision.** The portal verifies the pointer through the camera at the one
869
+ moment it matters — immediately before a click — rather than watching for
870
+ drift in the background. An absolute move now captures a frame before moving,
871
+ moves, and confirms that something changed within 70 video pixels of the
872
+ requested point. If it did not, the device is re-parked at the origin and the
873
+ move is repeated once.
874
+
875
+ Three properties this was built to have:
876
+
877
+ - *No background cost.* Nothing polls. The work happens on absolute moves,
878
+ which are menu clicks, a handful per episode: one frame and one difference
879
+ over a downscaled image.
880
+ - *It cannot quietly pass.* If the screen is animating (more than 6% of pixels
881
+ changing) or nothing changed at all, the check returns "could not tell"
882
+ rather than "landed", logs that, and counts it separately in `/status`.
883
+ Three findings this week were checks that returned the comfortable answer
884
+ when they could not actually see (F65, F66, F70).
885
+ - *It does not fire spuriously.* The first version reported a miss on 2 of 3
886
+ moves. Those were not desyncs: a re-calibrating move is three serial writes
887
+ plus a trip via the origin, so the first frame after it can simply be early.
888
+ Looking up to three times before concluding gave 6 of 6 landed, 0 missed,
889
+ 0 unknown, while the detector still separates the true target from decoy
890
+ points 300 and 700 pixels away.
891
+
892
+ **Alternatives rejected.** Polling the device position on a timer would cost
893
+ serial traffic continuously and still could not see a jump the box never
894
+ observed — the box's own position report is precisely the thing that is
895
+ wrong. Re-zeroing before every click unconditionally would be simpler and
896
+ correct, but it throws the pointer to the corner and adds three serial writes
897
+ to every click, which is a visible cost on a task measured in reaction time.
898
+ Raising the tolerance until misses stopped would have hidden the fault instead
899
+ of finding out it was a timing artefact.
900
+
901
+ **Consequences.** Recorded episodes are unaffected: the agent's clicks are menu
902
+ navigation, and a mis-landed menu click shows up as an episode that fails to
903
+ start, which the runner already refuses to record (F70). What changes is that
904
+ the failure is now detected and corrected in place instead of needing a person
905
+ to notice and press a button.
MORNING_BRIEF.md ADDED
@@ -0,0 +1,100 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Morning brief — GUI-agent evaluation rig
2
+
3
+ Current as of 2026-07-27, report **v048**. Findings F1–F60 across `FINDINGS.md`
4
+ (results) and `FINDINGS_ENGINEERING.md` (apparatus). Withdrawn claims R1–R17.
5
+
6
+ ## 1. TL;DR
7
+
8
+ **Task A now runs end to end with nobody at the keyboard.** The game is
9
+ launched, the mission list opened, a mission selected and started, the agent
10
+ plays through the capture card and the hardware keyboard and mouse, the mission
11
+ ends, the result screen is read, and the loop returns to the list for the next
12
+ episode. Eight episodes ran that way overnight. **The mission adjudicates its
13
+ own outcome** — destroying the vehicle is a win, letting it reach a marked zone
14
+ is a loss — so no scoring code of ours decides whether the agent succeeded. A
15
+ mission left running with no agent ends in a loss, which is the control.
16
+
17
+ **There are still no agent performance numbers for Task A, and the reason is
18
+ worth more than the numbers would have been.** The first real episodes gave a
19
+ clean-looking zero: the agent did nothing in 39 consecutive decisions. The
20
+ frames show why — the gun spawns in a railway cutting facing a viaduct and the
21
+ target is never in view. An agent reporting that it cannot see the vehicle is
22
+ answering correctly. The flat map was no better: the gun starts pointed away
23
+ from the target with a palm trunk across the centre of the view. Those zeros
24
+ measure my mission geometry, not the models, so they are not in the table
25
+ (F58).
26
+
27
+ **Two published numbers were wrong and are corrected.** Details in §3.
28
+
29
+ ## 2. What you should look at first
30
+
31
+ 1. **Report v048** — rewritten to stand on its own for someone outside the
32
+ project: what the question is, why the two-machine setup is the point, what
33
+ each task measures, what every column means, and a short glossary.
34
+ 2. **R17** — the local-versus-hosted speed claim is withdrawn.
35
+ 3. **F58** — why Task A has no scores, and the one launch that fixes it.
36
+
37
+ ## 3. Corrections made overnight
38
+
39
+ **R17 — "local decides ~3x faster than hosted" is withdrawn.** The two sides
40
+ were never measured the same way: local was five samples on one cached frame
41
+ with a 67-character prompt; hosted was 453 real decisions with the task's real
42
+ 764-character prompt. Measured the same way — same prompt, same frames, n=40 —
43
+ local is **690 ms** and hosted is **693 ms**. The same speed. This had been
44
+ carried as the one claim that survived sixteen retractions, so there is now no
45
+ surviving speed claim. The case for local inference is cost and independence,
46
+ not latency — and independence is exactly what mattered last night, because the
47
+ hosted account had no credit and no hosted model could be measured at all.
48
+
49
+ **F59 — the Task C suppression numbers came from a script that was never
50
+ committed, and they were wrong.** The committed scorer tested for a key press;
51
+ Task C clicks, so it had been silently returning zeros on that task. Recomputed
52
+ from committed code, precision goes 0.100 → 0.300 and detection falls 0.950 →
53
+ 0.536 at a ten-second window. The published figures (0.087 → 0.257, detection
54
+ 0.700 → 0.396) were all wrong. The conclusion survives — suppression triples
55
+ precision on Task C and collapses detection, the opposite of its effect on Task
56
+ B — but the magnitudes did not. This is F50 repeating: I wrote that finding
57
+ about exactly this failure and then repeated it in the same session.
58
+
59
+ Also corrected: the claim that one advertisement per video is purely a pipeline
60
+ artefact (4 of 18 videos still have only one at the widest span tested); the
61
+ sampling-rate section now states it covers the local model alone; and the
62
+ ten-second skip assumption is disclosed as never measured on this rig.
63
+
64
+ ## 4. Running now
65
+
66
+ vLLM is up. The hosted API had no credit all night — every attempt returned
67
+ "credit balance too low", so no hosted model was run. Per your instruction I
68
+ did not poll for it; I tried and spent where I could, and the local model did
69
+ all the work.
70
+
71
+ ## 5. What I could not do, plainly
72
+
73
+ You asked for Table A filled with numbers and videos. I did not get that. I did
74
+ get the environment to the point where the numbers are one launch away, and I
75
+ deliberately did not fill the table with the zeros I have, because they measure
76
+ the mission geometry rather than the models — the same error as F51, where a
77
+ detection rate turned out to be a property of how much of each video we
78
+ downloaded. Putting them in would have looked like a result and been worse than
79
+ an empty row.
80
+
81
+ ## 6. Next steps, in order
82
+
83
+ 1. **One launch with you watching** to place the target where the gun actually
84
+ points. The geometry was chosen by computing sight lines over the target
85
+ route's elevations, which says nothing about the ground between the gun and
86
+ the route, nor about the gun sitting in a cutting. That calculation is what
87
+ failed; more of it will not fix it. Once the target is in view, the episode
88
+ loop runs unattended and Table A fills in about twenty minutes.
89
+ 2. **Restore API credit** — it is the only reason there are no hosted rows
90
+ anywhere from last night.
91
+ 3. Run the committed pipeline end to end before publishing any number. Three of
92
+ the last five findings were numbers that measured the setup or came from code
93
+ nobody could run. The arithmetic was never the weak point.
94
+
95
+ ## 7. Open questions for you
96
+
97
+ - Task A's mission geometry: do you want to place the target yourself in one
98
+ session, or should I keep iterating it blind at a launch per attempt?
99
+ - Task B media: adopt the longer 600-second span so the detection rate can
100
+ vary? That changes the benchmark, so it is your call.
README.md ADDED
@@ -0,0 +1,80 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ ---
2
+ license: cc-by-nc-4.0
3
+ pretty_name: GUI-agent evaluation rig — code, records and captured media
4
+ tags:
5
+ - gui-agents
6
+ - vision-language-models
7
+ - evaluation
8
+ viewer: false
9
+ ---
10
+
11
+ # GUI-agent evaluation: code, per-episode records, and captured media
12
+
13
+ This repository holds everything behind a study of whether a language model can
14
+ operate real software when its only input is a video feed of the screen and its
15
+ only output is a keyboard and mouse. The rendered report lives in a separate
16
+ Space; this is the material it is computed from.
17
+
18
+ ## What the setup is
19
+
20
+ Two machines, joined by two cables and no software link. One runs the agent. The
21
+ other runs the task and is completely unmodified — nothing is installed on it and
22
+ it exposes no interface to the first machine. A capture card digitises its screen
23
+ and feeds those frames to the agent machine. A USB device that presents itself as
24
+ an ordinary keyboard and mouse carries actions back. The agent cannot read
25
+ application state, click by element id, or call a function; it sees pixels and
26
+ sends input, which is the same access a person has.
27
+
28
+ The hardware input device was chosen to avoid writing a virtual-HID driver. It is
29
+ used only to send input to the researcher's own machine.
30
+
31
+ ## The three tasks
32
+
33
+ - **A — vehicle intercept.** The agent commands a tank in a driving game and must
34
+ find and destroy one enemy vehicle before it escapes. Runs live, because the
35
+ agent's own actions change what happens next. The game adjudicates the outcome.
36
+ - **B — sponsor skip.** Press the skip key while a recorded video is inside a paid
37
+ advertisement read.
38
+ - **C — chart pattern.** Click the button naming a technical pattern at the moment
39
+ it completes on a replayed price chart.
40
+
41
+ Tasks B and C replay recorded frames, so every model sees byte-identical input.
42
+
43
+ ## Layout
44
+
45
+ | path | contents |
46
+ |---|---|
47
+ | `experiments/` | per-episode `record.json` (every decision: frame shown, prompt sent, verbatim reply, parsed action, stage timings), captured frames, and overlay videos |
48
+ | `media/` | source clips and capture-card output |
49
+ | `reports/` | built report versions and the per-inference audit pages |
50
+ | `FINDINGS.md` | decision log for anything bearing on a result |
51
+ | `FINDINGS_ENGINEERING.md` | decision log for the apparatus |
52
+ | `RETRACTIONS.md` | every claim this project made and then withdrew, with the evidence that killed it |
53
+ | `*.py` | the rig (capture and input control), the runners, the scorers, and the report builder |
54
+
55
+ Frames and videos are stored with git-lfs.
56
+
57
+ ## Reading the results
58
+
59
+ Two files are worth opening before any table. `FINDINGS.md` records what was
60
+ learned and what was decided; `RETRACTIONS.md` lists what was published and later
61
+ found to be wrong. Several headline numbers in earlier report versions were
62
+ withdrawn — a precision metric that charged presses it should have credited, a
63
+ speed comparison that measured two different prompts, and an episode boundary that
64
+ discarded five seconds of real gameplay. The retraction list is part of the
65
+ result, not an appendix to it.
66
+
67
+ Numbers in the report are regenerated from the records on every build rather than
68
+ transcribed, after three separate incidents of a figure drifting from the data it
69
+ described.
70
+
71
+ ## A note on the captured frames
72
+
73
+ The recorded frames and videos are of a personal desktop. They incidentally
74
+ contain a Windows username, local file paths, browser bookmarks, and a game
75
+ account name. None of it is the subject of the research; it is the background of a
76
+ screen that happened to be recorded. Please treat it accordingly.
77
+
78
+ ## Licence
79
+
80
+ CC BY-NC 4.0. The captured game footage remains the property of its publisher.
RERUN_COMMANDS.md ADDED
@@ -0,0 +1,226 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Rerun commands — every experiment, verbatim
2
+
3
+ All commands run from `~/personalgui-accel-setup`. All flags below were read
4
+ out of the scripts, not remembered.
5
+
6
+ Prerequisites:
7
+ - API keys come from `.env` (loaded automatically) — no export needed.
8
+ - Any command with the **local** model needs vLLM up first:
9
+ `curl -s http://127.0.0.1:8000/v1/models` (see RESTART_RUNBOOK.md).
10
+ - Every run is **replay** (cached frames + frozen transcripts). None of these
11
+ touch the capture card, the KMBox, or the Windows box.
12
+
13
+ Shorthand used below:
14
+
15
+ ```bash
16
+ LOCAL='local:nvidia/Qwen3.6-35B-A3B-NVFP4@http://127.0.0.1:8000/v1'
17
+ API3='claude-haiku-4-5 claude-sonnet-5 claude-opus-4-8'
18
+ ```
19
+
20
+ ---
21
+
22
+ ## 0. The one that is unfinished — leak-free Task B (do this first)
23
+
24
+ Why: the transcript leaked future speech and inflated every reaction time by
25
+ about 3 s (FINDINGS F21/F22/F25). `run_youtube.py` is fixed; this grid is the
26
+ corrected replacement. Safe to re-run repeatedly — episodes that already have a
27
+ record are skipped.
28
+
29
+ ```bash
30
+ # check what is already done (expect 18 per agent when complete)
31
+ ls experiments/youtube_nolookahead/episodes/*/record_*.json \
32
+ | grep -vE "scripted|_vision|_transcript" \
33
+ | sed -E 's#.*/record_(.*)\.json#\1#' | sort | uniq -c
34
+
35
+ # resume every agent, skipping completed episodes
36
+ LOCAL='local:nvidia/Qwen3.6-35B-A3B-NVFP4@http://127.0.0.1:8000/v1'
37
+ for m in claude-haiku-4-5 claude-sonnet-5 claude-opus-4-8 "$LOCAL"; do
38
+ tag=$(echo "$m" | sed -E 's#.*/##; s#@.*##')
39
+ for s in $(seq 0 17); do
40
+ f=experiments/youtube_nolookahead/episodes/yt_$(printf %04d $s)/record_${tag}.json
41
+ [ -f "$f" ] && continue
42
+ uv run run_youtube.py --replay --prompt antirefire --seed $s --model "$m" \
43
+ --sample-hz 0.5 --max-s 190 --out experiments/youtube_nolookahead/episodes
44
+ done
45
+ done
46
+ ```
47
+
48
+ Then score and publish:
49
+
50
+ ```bash
51
+ uv run rescore.py experiments/youtube_nolookahead --channel full
52
+ uv run build_landing.py --stamp "$(date +%Y-%m-%dT%H:%M)" \
53
+ --note "leak-free reaction times replace the inflated ones (F21/F22/F25)"
54
+ ```
55
+
56
+ Check progress by file mtime, not by process name — a previous run died
57
+ silently and the process check gave a false positive:
58
+
59
+ ```bash
60
+ ls -lt experiments/youtube_nolookahead/episodes/*/record_claude-opus-4-8.json | head -3
61
+ ```
62
+
63
+ ---
64
+
65
+ ## 1. Task B — YouTube sponsor-skip
66
+
67
+ 18 labeled videos; seed index maps to video (`seed % 18`).
68
+
69
+ ```bash
70
+ LOCAL='local:nvidia/Qwen3.6-35B-A3B-NVFP4@http://127.0.0.1:8000/v1'
71
+
72
+ # corrected "press skip once per ad" prompt (the main table)
73
+ for m in claude-haiku-4-5 claude-sonnet-5 claude-opus-4-8 "$LOCAL"; do
74
+ for s in $(seq 0 17); do
75
+ uv run run_youtube.py --replay --prompt antirefire --seed $s --model "$m" \
76
+ --sample-hz 0.5 --max-s 190 --out experiments/youtube_antirefire/episodes
77
+ done
78
+ done
79
+
80
+ # original prompt (baseline, for the paired prompt comparison)
81
+ for m in claude-haiku-4-5 claude-sonnet-5 claude-opus-4-8 "$LOCAL"; do
82
+ for s in $(seq 0 17); do
83
+ uv run run_youtube.py --replay --seed $s --model "$m" \
84
+ --sample-hz 0.5 --max-s 190 --out experiments/youtube/episodes
85
+ done
86
+ done
87
+ ```
88
+
89
+ Channel ablation (which modality carries the signal):
90
+
91
+ ```bash
92
+ # video only — no transcript
93
+ uv run run_youtube.py --replay --prompt antirefire --asr none \
94
+ --seed 0 --model claude-opus-4-8 --sample-hz 0.5 --max-s 190 \
95
+ --out experiments/youtube_antirefire/episodes
96
+
97
+ # audio only — blank gray frames
98
+ uv run run_youtube.py --replay --prompt antirefire --blank-frames \
99
+ --seed 0 --model claude-opus-4-8 --sample-hz 0.5 --max-s 190 \
100
+ --out experiments/youtube_antirefire/episodes
101
+ ```
102
+
103
+ Records carry a channel suffix (`_vision`, `_transcript`) so they never
104
+ overwrite the full-channel run. Score each arm separately:
105
+
106
+ ```bash
107
+ uv run rescore.py experiments/youtube_antirefire --channel full
108
+ uv run rescore.py experiments/youtube_antirefire --channel vision
109
+ uv run rescore.py experiments/youtube_antirefire --channel transcript
110
+ ```
111
+
112
+ ---
113
+
114
+ ## 2. Task C — Trading chart patterns
115
+
116
+ Episodes are generated deterministically from the seed, so no media prep is
117
+ needed. Currently n=6; raise the seed range to expand.
118
+
119
+ ```bash
120
+ LOCAL='local:nvidia/Qwen3.6-35B-A3B-NVFP4@http://127.0.0.1:8000/v1'
121
+ uv run run_experiment.py --task trading --replay \
122
+ --agents claude-haiku-4-5 claude-sonnet-5 claude-opus-4-8 "$LOCAL" \
123
+ --seeds 0 1 2 3 4 5
124
+
125
+ uv run rescore.py experiments/trading --channel full
126
+ ```
127
+
128
+ Cost warning: trading episodes are ~151 frames each (vs ~65 for YouTube), so a
129
+ 4-agent x 6-seed grid is roughly 3.6k API calls. Expanding to n=18 triples that.
130
+
131
+ ---
132
+
133
+ ## 3. Task A — War Thunder
134
+
135
+ No agent numbers yet. The mission now registers and loads in game (F15/F17/F18)
136
+ but crashed on start until the terrain-height fix (F23), which is deployed but
137
+ **not yet verified in game**. Remaining sequence, in order:
138
+
139
+ 1. Launch the mission in game and confirm it starts without crashing.
140
+ 2. Record one manual reference run (needs the capture card free):
141
+
142
+ ```bash
143
+ # stop the screenshot grabber first if it is running
144
+ kill $(cat /dev/shm/rig_grabber.pid) 2>/dev/null
145
+
146
+ FIFO=/tmp/wt_audio.pcm; rm -f $FIFO; mkfifo $FIFO
147
+ arecord -D hw:1,0 -f S16_LE -r 48000 -c 2 -t raw > $FIFO &
148
+ ffmpeg -y -f v4l2 -input_format mjpeg -video_size 1920x1080 -framerate 30 -i /dev/video0 \
149
+ -f s16le -ar 48000 -ac 2 -i $FIFO \
150
+ -c:v libx264 -preset veryfast -crf 20 -pix_fmt yuv420p -c:a aac -b:a 128k \
151
+ media/wt_reference/reference_$(date +%H%M%S).mp4
152
+ ```
153
+
154
+ Note: this ffmpeg build has **no ALSA input support**, hence the FIFO.
155
+
156
+ 3. Label the exposure windows from that recording.
157
+ 4. Score agents against the frozen labels.
158
+
159
+ ---
160
+
161
+ ## 4. Latency measurements
162
+
163
+ ```bash
164
+ # component benchmark (capture / encode / parse / local vs API decision)
165
+ uv run bench_latency.py
166
+
167
+ # real end-to-end loop through the capture card and KMBox (move-only, no clicks)
168
+ uv run measure_live_loop.py --model claude-haiku-4-5 --n 5
169
+ uv run measure_live_loop.py --model 'local:nvidia/Qwen3.6-35B-A3B-NVFP4@http://127.0.0.1:8000/v1' --n 5
170
+ ```
171
+
172
+ Both need `/dev/video0` free — stop the grabber first.
173
+
174
+ ---
175
+
176
+ ## 5. Rebuild artifacts (no experiments, always safe)
177
+
178
+ ```bash
179
+ # overlay replay videos for one episode
180
+ uv run render_overlay_yt.py experiments/youtube_antirefire/episodes/yt_0000 --speed 4 # Task B
181
+ uv run render_overlay.py experiments/trading/episodes/trading_0000 --speed 4 # Task C
182
+
183
+ # attach speed-matched audio to Task B overlays (safe to re-run; skips ones that have it)
184
+ uv run mux_audio.py experiments/youtube_antirefire --speed 4
185
+
186
+ # the whole public document in one command: data sections computed from the
187
+ # records, numbers parsed + Task A cross-checked, merged page assembled and
188
+ # staged into personalgui-accel-report/ (index.html + version archive)
189
+ uv run build_landing.py --stamp "$(date +%Y-%m-%dT%H:%M)" --note "what changed"
190
+
191
+ # check without writing anything (parse + cross-check only)
192
+ uv run build_landing.py --check-only
193
+ ```
194
+
195
+ Since the single-document merge (v061), the landing page and the detailed
196
+ report are one page. `build_landing.py` assembles everything;
197
+ `build_artifact.py` is the data-layer library (its CLI still works and
198
+ delegates to `build_landing.py`). `deploy_hf_space.py` predates the merged
199
+ layout and must not be used on v061 or later — staging is part of the build.
200
+
201
+ `build_demo.py` is deprecated and refuses to run — it renders the retired
202
+ composite score. Use `build_landing.py`.
203
+
204
+ ---
205
+
206
+ ## 6. Data preparation (only if adding videos)
207
+
208
+ ```bash
209
+ uv run expand_videos.py --want 12 --dry-run # preview candidates, no downloads
210
+ uv run expand_videos.py --want 12 # download + freeze SponsorBlock labels
211
+
212
+ HF_HUB_DISABLE_IMPLICIT_TOKEN=1 uv run prepare_media.py # frames + whisper transcripts
213
+ ```
214
+
215
+ The `HF_HUB_DISABLE_IMPLICIT_TOKEN=1` is required: the stored HF token is stale
216
+ and 401s even on public repos.
217
+
218
+ ---
219
+
220
+ ## 7. Smoke tests (free, no API calls)
221
+
222
+ ```bash
223
+ uv run run_youtube.py --replay --dry-run --seed 0 --out /tmp/smoke
224
+ uv run run_trading.py --replay --dry-run --seed 0 --out /tmp/smoke
225
+ uv run run_experiment.py --task trading --replay --dry-run --agents scripted --seeds 0 --out /tmp/smoke
226
+ ```
RESTART_RUNBOOK.md ADDED
@@ -0,0 +1,161 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Restart runbook — what is running, and how to bring it back
2
+
3
+ Written 2026-07-25 before a reboot for security/firmware updates.
4
+ Nothing here restarts automatically; everything below is manual.
5
+
6
+ Rule of thumb: only **vLLM** is required for local-model experiments.
7
+ Everything else is a convenience server or a one-off job.
8
+
9
+ ---
10
+
11
+ ## 1. Must restart — vLLM (local model server)
12
+
13
+ | | |
14
+ |---|---|
15
+ | Purpose | Serves `nvidia/Qwen3.6-35B-A3B-NVFP4` for the local-model tier of every task |
16
+ | Runs as | `tmux` session named `vllm` (survives SSH/Claude disconnects, NOT reboot) |
17
+ | Listens | `127.0.0.1:8000` |
18
+ | Uptime before reboot | ~1 day 19 h |
19
+ | Log | `~/vllm.log` |
20
+
21
+ Restart:
22
+
23
+ ```bash
24
+ SNAP=/home/zhanwenchen/.cache/huggingface/hub/models--nvidia--Qwen3.6-35B-A3B-NVFP4/snapshots/491c2f1ea524c639598bf8fa787a93fed5a6fbce
25
+ tmux new-session -d -s vllm "PATH=/home/zhanwenchen/personalgui-accel/.venv/bin:\$PATH HF_HUB_OFFLINE=1 \
26
+ vllm serve '$SNAP' --served-model-name nvidia/Qwen3.6-35B-A3B-NVFP4 \
27
+ --host 127.0.0.1 --port 8000 2>&1 | tee ~/vllm.log"
28
+ ```
29
+
30
+ Watch it load (about 3–4 min): `tmux attach -t vllm` — detach with `Ctrl+b` then `d`
31
+ (do NOT `Ctrl+c`, that kills the server). Ready when:
32
+
33
+ ```bash
34
+ curl -s http://127.0.0.1:8000/v1/models
35
+ ```
36
+
37
+ Two gotchas that have bitten us: the venv's `bin` must be on `PATH` (vLLM shells
38
+ out to `ninja`), and the model must be served from the local snapshot path with
39
+ `HF_HUB_OFFLINE=1` — the plain repo name fails because the stored HF token is
40
+ stale (401s even on public repos).
41
+
42
+ ---
43
+
44
+ ## 2. Restart only if you want them — HTTP servers
45
+
46
+ | Port | Purpose | Restart |
47
+ |---|---|---|
48
+ | 8080 | Serves the repo so you can view `reports/latest.html` **with its videos** in a browser | `cd ~/personalgui-accel-setup && python3 -m http.server 8080 --bind 0.0.0.0` |
49
+ | 8899 | Serves `gua_eval/tasks/warthunder/` so the Windows box can `curl` the mission file | `cd ~/personalgui-accel/gua_eval/tasks/warthunder && python3 -m http.server 8899 --bind 0.0.0.0` |
50
+ | 8901 | Receiver that accepts `curl -X PUT` uploads FROM the Windows box into `media/wt_incoming/` | script at `/tmp/.../scratchpad/recv.py` — recreate if needed; it is a scratch file and will not survive reboot |
51
+ | 8888 | Older local-only server, not used by current work | skip |
52
+
53
+ View the report after reboot: `http://192.168.68.70:8080/reports/latest.html`
54
+
55
+ ---
56
+
57
+ ## 3. Interrupted job — the leak-free Task B re-run (IMPORTANT)
58
+
59
+ This is real, unfinished experimental work; it was mid-flight at reboot time.
60
+
61
+ Why it exists: the rolling transcript was leaking future speech to the agent
62
+ (FINDINGS F21), which inflated every Task B reaction time by about 3 s (F22,
63
+ F25). `run_youtube.py` is fixed; the grid is being re-run into a separate
64
+ directory so the old results stay intact.
65
+
66
+ Progress before reboot: Haiku 18/18, Sonnet 18/18, Opus in progress, local
67
+ model not started. It is safe to re-run — the loop skips episodes whose record
68
+ already exists, so nothing is duplicated or lost.
69
+
70
+ ```bash
71
+ cd ~/personalgui-accel-setup
72
+ # check what is already done
73
+ ls experiments/youtube_nolookahead/episodes/*/record_*.json \
74
+ | grep -vE "scripted|_vision|_transcript" \
75
+ | sed -E 's#.*/record_(.*)\.json#\1#' | sort | uniq -c
76
+
77
+ # resume Opus, then the local model (needs vLLM up)
78
+ for s in $(seq 0 17); do
79
+ f=experiments/youtube_nolookahead/episodes/yt_$(printf %04d $s)/record_claude-opus-4-8.json
80
+ [ -f "$f" ] || uv run run_youtube.py --replay --prompt antirefire --seed $s \
81
+ --model claude-opus-4-8 --sample-hz 0.5 --max-s 190 \
82
+ --out experiments/youtube_nolookahead/episodes
83
+ done
84
+ for s in $(seq 0 17); do
85
+ uv run run_youtube.py --replay --prompt antirefire --seed $s \
86
+ --model 'local:nvidia/Qwen3.6-35B-A3B-NVFP4@http://127.0.0.1:8000/v1' \
87
+ --sample-hz 0.5 --max-s 190 --out experiments/youtube_nolookahead/episodes
88
+ done
89
+ ```
90
+
91
+ Watch out: an earlier run of this died silently after 2 episodes and reported
92
+ nothing. Check progress by FILE MTIME, not by whether a process name matches:
93
+
94
+ ```bash
95
+ ls -lt experiments/youtube_nolookahead/episodes/*/record_claude-opus-4-8.json | head -3
96
+ ```
97
+
98
+ When the grid completes:
99
+
100
+ ```bash
101
+ uv run rescore.py experiments/youtube_nolookahead --channel full
102
+ uv run build_artifact.py --stamp "$(date +%Y-%m-%dT%H:%M)" --note "leak-free reaction times"
103
+ ```
104
+
105
+ ---
106
+
107
+ ## 4. Optional — the fast screenshot server
108
+
109
+ | | |
110
+ |---|---|
111
+ | Purpose | Holds `/dev/video0` open and publishes the newest frame to `/dev/shm/rig_latest.jpg`, so a screenshot is a ~3 ms file read instead of a ~800 ms device open |
112
+ | State at reboot | not running |
113
+
114
+ ```bash
115
+ cd ~/personalgui-accel-setup
116
+ setsid uv run rig_grabber.py >~/rig_grabber.log 2>&1 </dev/null &
117
+ ```
118
+
119
+ It **holds the capture card**, so stop it before anything else needs the camera
120
+ (`portal.py`, a live task, a reference recording):
121
+
122
+ ```bash
123
+ kill $(cat /dev/shm/rig_grabber.pid)
124
+ ```
125
+
126
+ ---
127
+
128
+ ## 5. Subagents — nothing to restart
129
+
130
+ The Tom critic, briefing, and deck agents are one-shot: they run, write their
131
+ file, and exit. None is a daemon. Their outputs live in
132
+ `MORNING_BRIEF.md`, `meeting/MEETING_DECK.md`, and `reports/`, and their full
133
+ transcripts are under `~/.claude/projects/.../subagents/`.
134
+
135
+ The hourly master tick is scheduled inside the Claude Code session, not on the
136
+ machine — it disappears when that session ends and is not restored by a reboot.
137
+
138
+ ---
139
+
140
+ ## 6. Hardware — check after reboot
141
+
142
+ ```bash
143
+ ls /dev/video0 # Elgato capture
144
+ ls /dev/serial/by-id/usb-1a86_USB_Serial-if00-port0 # KMBox
145
+ nvidia-smi --query-gpu=name,memory.used --format=csv,noheader
146
+ ```
147
+
148
+ The KMBox device path can move between `ttyUSB0`/`ttyUSB1` on replug — always use
149
+ the `by-id` path above, never the bare number. If the KMBox REPL ever stops
150
+ responding, send `\r\x03\x03\r\n` (Ctrl-C) to clear a stuck continuation prompt.
151
+
152
+ ---
153
+
154
+ ## 7. Quick "is everything healthy" check
155
+
156
+ ```bash
157
+ curl -s http://127.0.0.1:8000/v1/models >/dev/null && echo "vLLM up" || echo "vLLM DOWN"
158
+ tmux ls
159
+ ss -ltn | grep -E '8000|8080|8899'
160
+ ls /dev/video0 /dev/serial/by-id/usb-1a86_USB_Serial-if00-port0
161
+ ```
RETRACTIONS.md ADDED
@@ -0,0 +1,512 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Retractions register
2
+
3
+ Every claim this project has made and then withdrawn, with the evidence that
4
+ killed it. Kept because a withdrawn number that is quietly deleted tends to
5
+ reappear in a stale slide; and because the reason each one fell is itself a
6
+ result worth reporting.
7
+
8
+ Format: **claim as stated** → why it fell → the concrete evidence → what
9
+ replaced it.
10
+
11
+ ---
12
+
13
+ ## R1 — "Composite score X ranks the agents"
14
+
15
+ **Claimed:** a single composite score per episode, used to rank models
16
+ (e.g. "local model 0.188 > Opus 0.151").
17
+
18
+ **Why it fell:** the metric was a step function, not a continuous score.
19
+
20
+ **Evidence:** `gua_eval/windows.py:122-124` —
21
+ `score = max(0, timeliness_sum - 0.25*n_false - 0.05*n_dup) / n_windows`.
22
+ Task B has `n_windows = 1`, so four wrong clicks (penalty 1.0) zero the
23
+ episode no matter how well timed the correct one was. It was nonzero in only
24
+ **2 of 12** Task-B cells, and exactly **0.000** for every API agent on Task C
25
+ under both prompts. The "0.188 vs 0.151" ranking was decided by a difference
26
+ of one duplicate click (7 vs 8) between two otherwise-zero score sets.
27
+
28
+ **Replaced by:** recall, precision, F1 and reaction time, each with a
29
+ percentile bootstrap CI. (FINDINGS F6)
30
+
31
+ ---
32
+
33
+ ## R2 — "The local model reaches a perfect score on Task B"
34
+
35
+ **Claimed:** precision = recall = F1 = 1.00 for Qwen3.6-35B, from 3 videos.
36
+
37
+ **Why it fell:** three videos, all easy; the number did not survive contact
38
+ with more data.
39
+
40
+ **Evidence:** at n=6, F1 fell to 0.819; at n=18, to 0.681. The n=3 result had
41
+ zero variance, which should itself have been the warning.
42
+
43
+ **Replaced by:** F1 0.681 [0.530, 0.821] at n=18. (F9 → F12 → F16)
44
+
45
+ ---
46
+
47
+ ## R3 — "The air-gapped local model is the best model on Task B"
48
+
49
+ **Claimed:** local Qwen leads the frontier API tier on F1 (0.819 vs Opus
50
+ 0.692 at n=6).
51
+
52
+ **Why it fell:** the ordering reversed when the sample tripled, and the
53
+ intervals always overlapped — the comparison never had the power to support
54
+ a ranking.
55
+
56
+ **Evidence:** at n=18, Opus 0.707 [0.574, 0.833] vs local 0.681 [0.530,
57
+ 0.821]. The two means differ by ~0.03 while each CI half-width is ~0.14.
58
+ Separating them would need roughly a 20x increase in videos (~350+), which
59
+ is out of budget.
60
+
61
+ **Replaced by:** no ranking claim at all — pre-registered in F20. Only the
62
+ accuracy/latency tradeoff, plus the one ordering the data does support:
63
+ Sonnet is worst (its CI does not overlap Opus's). (F12 → F16 → F20)
64
+
65
+ ---
66
+
67
+ ## R4 — "The YouTube task genuinely requires listening"
68
+
69
+ **Claimed:** the sponsor read is only detectable from audio; video alone
70
+ cannot solve the task.
71
+
72
+ **Why it fell:** the video-only condition did not collapse the way the claim
73
+ predicted.
74
+
75
+ **Evidence:** video-only recall was 0.33–1.00 depending on model, not ~0.
76
+ Opus reached recall 1.00 with no transcript at all.
77
+
78
+ **Replaced by:** an exploratory, caveated statement — audio alone is
79
+ sufficient and is the reliable channel; video alone is partial and
80
+ inconsistent. Not presented as a settled finding. (F10 → F14)
81
+
82
+ ---
83
+
84
+ ## R5 — "Opus detects every ad from the picture alone"
85
+
86
+ **Claimed:** video-only recall 1.00 shows Opus can spot a sponsor segment
87
+ visually.
88
+
89
+ **Why it fell:** recall 1.00 was produced by pressing skip often, not by
90
+ detection — and the metric could not tell the difference.
91
+
92
+ **Evidence:** raw per-frame logs, `experiments/youtube_antirefire/episodes/`:
93
+ in yt_0000 Opus fired 7 times, **3 of them outside** the single ad window
94
+ (t=1.5, 13.8, 20.5 s vs window 44.7–64.9 s); in yt_0001, **5 of 7** were
95
+ outside. Precision was 0.24 — three-quarters of its presses were wrong.
96
+ Recall hit 1.0 only because enough presses eventually landed inside the one
97
+ window.
98
+
99
+ **Replaced by:** the observation that pressing repeatedly when uncertain is
100
+ not a transcript artefact — it also appears with no transcript present.
101
+ (F14, corrected same day)
102
+
103
+ ---
104
+
105
+ ## R6 — "The prompt fix is model-dependent"
106
+
107
+ **Claimed:** the "press skip once per ad" instruction helps Haiku and the
108
+ local model but not Opus or Sonnet.
109
+
110
+ **Why it fell:** the per-model differences were not statistically
111
+ distinguishable from chance at n=6.
112
+
113
+ **Evidence:** two-sided sign test on paired per-video improvements —
114
+ Haiku 6/6 (p = 0.031, significant); local 5/6 (p = 0.219); Opus 3/6
115
+ (p = 1.000); Sonnet 2/6 (p = 0.688).
116
+
117
+ **Replaced by:** the fix demonstrably helps Haiku, plausibly helps the local
118
+ model, and for Opus and Sonnet there is **no evidence of an effect in either
119
+ direction** — which is not the same as showing it does not help them.
120
+ (F19 → F20)
121
+
122
+ ---
123
+
124
+ ## R7 — "Python/CPU overhead is burning the frame budget" (the original tier-III pitch)
125
+
126
+ **Claimed:** a C++/CUDA orchestrator is needed because Python and CPU work
127
+ consume the per-frame budget.
128
+
129
+ **Why it fell:** measured, and the CPU stages are negligible.
130
+
131
+ **Evidence:** capture 16.7 ms, base64 0.03 ms, request framing 0.07 ms,
132
+ `parse_action` 0.002 ms — together under 18 ms of a 1000 ms budget at 1 Hz.
133
+
134
+ **Replaced by:** the honest case for tier III is the high-rate regime
135
+ (4–10 Hz), where only the local model's ~211 ms decision fits at all.
136
+ (F4)
137
+
138
+ ---
139
+
140
+ ## R8 — "The transcript-leak inflation is uniform across models"
141
+
142
+ **Claimed:** because the leak is a property of the harness, every model's
143
+ reaction time is inflated by roughly the same amount (~3 s).
144
+
145
+ **Why it fell:** generalised from the only two agents that had finished, and
146
+ they happened to sit close together.
147
+
148
+ **Evidence:** the completed grid shows the correction ranges from **+1.82 s**
149
+ (Opus) to **+3.53 s** (local model) — Haiku +3.03, Sonnet +3.35.
150
+
151
+ **Replaced by:** the inflation is model-dependent, and because it is additive
152
+ it compresses ratios far more than it shifts the ordering. (F25 → F26)
153
+
154
+ ---
155
+
156
+ ## R9 — "The local model responds about 2x faster on Task B"
157
+
158
+ **Claimed:** local 2.67 s vs Opus 5.32 s median reaction — a decisive
159
+ task-level speed advantage.
160
+
161
+ **Why it fell:** those reaction times were measured with a data leak that
162
+ let agents act on speech before it was audible.
163
+
164
+ **Evidence:** the rolling transcript included a whisper segment as soon as it
165
+ STARTED, so its whole text was visible early — measured at **93.4% of 1170
166
+ frames**, median **2.08 s** and up to **12.44 s** of lookahead. Caught by
167
+ reading one replay frame: Opus pressed skip at t=106.0 s on 3NIXvqtVWso while
168
+ its on-screen transcript already read "...this video is brought to you by
169
+ thermal grizzly"; the true ad start (SponsorBlock) was 108.1 s.
170
+ After the fix (`e <= frame_time`), reaction times are local 6.20 s, Opus
171
+ 7.14 s, Haiku 7.17 s, Sonnet 7.22 s — a 1.15x gap, effectively tied.
172
+
173
+ **Replaced by:** no task-level speed claim. What survives is the component
174
+ measurement — **211 ms vs 693 ms per decision**, taken outside this grid and
175
+ unaffected — plus the more interesting observation that a 3.3x faster
176
+ per-decision model produces no task-level speed advantage, because reaction
177
+ is dominated by the fixed 2 s frame-sampling interval and by how many frames
178
+ a model waits before committing. (F21 → F22 → F26)
179
+
180
+ ---
181
+
182
+ ## R10 — "The mission validates in the CDK editor, so it works"
183
+
184
+ **Claimed:** the War Thunder mission was correct because the editor loaded it
185
+ without errors.
186
+
187
+ **Why it fell:** the editor is far more permissive than the game. Three
188
+ separate defects each passed the editor and failed later.
189
+
190
+ **Evidence:** (1) invalid vehicle class names — the editor reported
191
+ `Wrong unit "player_tank" class name "us_m4a1_sherman"`; (2) missing
192
+ registration fields — the game silently refused to list the mission until
193
+ `campaign:t="UserMissions"` (plus name, difficulty, tags, missionType and
194
+ four empty top-level blocks) were copied from a shipped sample; (3) an
195
+ invented level name — the editor rendered `levels/avg_tunisia.bin`, the game
196
+ said `can't open level file`; (4) units placed at Y=0.0 while the shipped
197
+ sample sits at Y=7.825, i.e. spawned under the terrain — the mission listed,
198
+ loaded, and then crash-dumped on start.
199
+
200
+ **Replaced by:** editor validation is not evidence a mission will list, load,
201
+ or run. For any asset that cannot be validated from the Linux side, copy the
202
+ value from a shipped working example first. (F15/F17/F18/F23)
203
+
204
+ ---
205
+
206
+ ## Pattern
207
+
208
+ **Withdrawals R1-R10.** Nine of those ten fell into two buckets: a sample too
209
+ small to support the claim, or an artefact of our own harness mistaken for
210
+ model behaviour.
211
+
212
+ **Withdrawals R11-R13 form a third bucket, and it is a different one.** Each was
213
+ found by someone reading the analysis or the code rather than the summary
214
+ tables, and each survived every check that looked only at outputs:
215
+
216
+ * R11 — the sampling claim was tested against frames that could not vary, so the
217
+ experiment could not have answered its own question.
218
+ * R12 — precision never charged for repeat presses, so the metric was blind to
219
+ the exact effect being measured.
220
+ * R13 — a paired design was analysed by subtracting group medians, which is a
221
+ different quantity and, here, a misleading one.
222
+
223
+ The first two buckets are about having too little evidence or a contaminated
224
+ rig. The third is about correct arithmetic answering the wrong question, which
225
+ no amount of extra data would have caught. It is the reason the adversarial
226
+ review of the analysis itself stays in the loop rather than being treated as a
227
+ formality.
228
+
229
+
230
+ ## R11 — "About 80% of Task B reaction time is the harness, not the model"
231
+
232
+ **Claimed:** F27 attributed roughly 80% of the ~7 s reaction time on the
233
+ YouTube task to the frame-sampling interval, and concluded that a faster
234
+ orchestrator would mostly fix responsiveness.
235
+
236
+ **Why it fell:** the claim was never actually tested against denser frames.
237
+ F28 already recorded that the first attempt was invalid — the sampling flag
238
+ only selects among frames that exist, and the stored frames were 2 s apart,
239
+ so asking for a faster rate changed nothing. This time a genuinely denser
240
+ frame set was extracted (0.5 s spacing) and the rate was varied for real.
241
+ Reaction time did not behave the way an 80% harness share predicts.
242
+
243
+ **Evidence:** quadrupling the sampling rate from 0.5 Hz to 2.0 Hz on the same
244
+ three videos moved median reaction time from 6.45 s to 4.70 s for Haiku and
245
+ from 5.76 s to 4.74 s for the local model. That is a reduction of 1.75 s and
246
+ 1.02 s — a harness share of about 27% and 18% of the original reaction time,
247
+ not 80%. Both models converge on a floor near 4.7 s that more frequent
248
+ sampling does not move.
249
+
250
+ **Replacement:** most of the reaction time is the model waiting for enough of
251
+ the spoken sponsor read to accumulate before it commits, not the harness
252
+ withholding frames. The floor is close to identical for a small hosted model
253
+ and a 35B local model, which suggests it is a property of the task — how long
254
+ the read has to be audible before it is unambiguous — rather than of either
255
+ model. A faster orchestrator would buy roughly a second here, not five.
256
+
257
+ ## R12 — "The local model degrades more gracefully as the sampling rate rises"
258
+
259
+ **Claimed:** F30 read the sampling sweep as showing the local model holding up
260
+ better than Haiku under faster sampling, on the basis that it kept precision
261
+ 0.486 at 2 Hz where Haiku fell to 0.142.
262
+
263
+ **Why it fell:** precision as implemented never charges for a duplicate press.
264
+ Reading `gua_eval/windows.py::match_actions`, a press only counts against
265
+ `n_false` if it lands inside no window at all; a press inside a window that was
266
+ already matched is filed as a duplicate and never reaches precision. Duplicates
267
+ are the failure that scales with sampling rate, so the metric was blind to
268
+ exactly the effect being measured. Recomputing precision as
269
+ `n_matched / (n_matched + n_false + n_duplicate)` reverses the comparison.
270
+
271
+ **Evidence:** on the same three videos, 0.5 Hz to 2.0 Hz —
272
+
273
+ model official precision duplicate-charged precision
274
+ Haiku 0.500 -> 0.142 (3.5x) 0.143 -> 0.034 (4.2x)
275
+ local Qwen 0.833 -> 0.486 (1.7x) 0.448 -> 0.083 (5.4x)
276
+
277
+ Under the honest metric the local model's relative collapse (5.4x) is steeper
278
+ than Haiku's (4.2x), not gentler.
279
+
280
+ **Replacement:** the local model remains better in absolute terms at every rate
281
+ (0.083 against 0.034 at 2 Hz), but it does not degrade more gracefully — it
282
+ degrades faster in relative terms while starting from a higher point. The
283
+ graceful-degradation reading is withdrawn; the correct statement is that the
284
+ local model is more accurate at every sampling rate tested and that both models
285
+ lose accuracy quickly as the rate rises.
286
+
287
+ **Credited to:** the review agent acting as the advisor, which found this by
288
+ reading the matching code rather than the summary tables.
289
+
290
+ ## R13 — "The reaction-time floor is flat beyond 1 Hz, so faster polling buys almost nothing"
291
+
292
+ **Claimed:** F36 reported that the local model's evidence time fell 0.90 s from
293
+ 0.5 to 1.0 Hz but only 0.06 s from 1.0 to 2.0 Hz, concluded the floor was flat at
294
+ about 4.3 s, and recommended 1 Hz rather than 2 Hz as the useful end of the range.
295
+
296
+ **Why it fell:** the 0.06 s was a difference of group medians — the median across
297
+ episodes at 2 Hz minus the median across episodes at 1 Hz. But the same 18 videos
298
+ were run at every rate, so this is a paired design, and the correct statistic is
299
+ the median of the per-episode differences. The two are not the same: a few large
300
+ per-video shifts change which episode sits at the median rank, so subtracting
301
+ medians badly understates the typical change. This project already established
302
+ the right method in F19 and F20, where a sign test on paired videos corrected an
303
+ earlier over-reading. It was not applied here.
304
+
305
+ **Evidence:** pairing episode by episode on the existing records, no reruns:
306
+
307
+ transition difference of medians median PAIRED difference sign test
308
+ 0.5 -> 1.0 -0.90 s -1.00 s 11/11, p=0.0010
309
+ 1.0 -> 2.0 -0.06 s -0.50 s 12/12, p=0.0005
310
+ 0.5 -> 2.0 -0.96 s -1.00 s 17/17, p<0.0001
311
+
312
+ On the emitted-reaction column the 1.0 -> 2.0 step is -0.49 s, 16 of 18 episodes
313
+ faster, p=0.0013, bootstrap CI [-0.51, -0.06] excluding zero.
314
+
315
+ **Replacement:** there is no plateau within the range tested. Each doubling of
316
+ the sampling rate buys roughly half of what the previous doubling bought — about
317
+ 1.0 s then about 0.5 s — and every step is significant. The honest statement is
318
+ that returns diminish geometrically, not that they stop. The recommendation of
319
+ 1 Hz over 2 Hz is withdrawn: 2 Hz is genuinely about half a second faster, and
320
+ the reason to prefer a lower rate is the accuracy cost, not an absence of gain.
321
+
322
+ **Credited to:** the review agent acting as the advisor, which ran the paired
323
+ test itself rather than accepting the reported group medians.
324
+
325
+ ## R14 — The list of "proven" War Thunder vehicle identifiers reported in F41
326
+
327
+ **Claimed:** F41 listed the vehicle classes used by missions the game ships
328
+ with, and offered them as identifiers safe to put in a mission — among them
329
+ `germ_tiger`, `bf`, `fw`, `ju`, `la`, `me`, `p`, `he`, `yak` and
330
+ `ussr_zis5_amd`.
331
+
332
+ **Why it fell:** the list was produced with the pattern
333
+ `unit_class:t=.[a-z0-9_]*`, which stops at a hyphen and at any capital letter.
334
+ It truncated most of the identifiers and returned the fragments as though they
335
+ were complete. The pattern did not fail; it succeeded quietly on the wrong
336
+ thing, which is why nothing looked wrong in the output.
337
+
338
+ **Evidence:** re-reading the same files with a pattern that does not stop early:
339
+
340
+ reported actual
341
+ germ_tiger germ_tigerI
342
+ bf bf-109f-4, bf-109k-4
343
+ fw fw-190a-5
344
+ ju ju-88a-4
345
+ la la-5fn
346
+ me me-262a-1a
347
+ p p-39n, p-39q_5, p-40e
348
+ he he-111h-2
349
+ yak yak-1b
350
+ ussr_zis5_amd ussr_zis5_med
351
+
352
+ **Replacement:** the corrected list is in F45. `germ_horch`, `us_lvt_a_1` and
353
+ `sample_m60a1` contain no hyphens or capitals and were reported correctly, so
354
+ v7 was never at risk. Nothing was built on the wrong identifiers, but
355
+ `germ_tiger` had already been offered as a safe choice and would have produced
356
+ an invalid class name — the same defect as F15, arrived at by a careless
357
+ pattern rather than a guess.
358
+
359
+ ## R15 — "Adding memory to the agent is the best-supported next intervention"
360
+
361
+ **Claimed:** F31, F32 and F36 each concluded that repeat presses were the
362
+ largest source of lost precision and that the cause was the agent having no
363
+ memory between snapshots; the recommendation to add memory was carried in the
364
+ report, the brief and the meeting deck as the intervention the evidence most
365
+ supported.
366
+
367
+ **Why it fell:** the support was an inference from where the errors were, not a
368
+ measurement of the fix. When measured, the fix did not work.
369
+
370
+ **Evidence:** eighteen videos, local model, paired, identical in every respect
371
+ except one line telling the agent how many times it had already pressed and how
372
+ long ago. Duplicates per advertisement did not move (4.556 to 4.611, p=0.7539).
373
+ Wrong presses outside the advertisement rose on twelve of the thirteen videos
374
+ that differed (p=0.0063), false alarms per query rose (p=0.0034), and precision
375
+ with duplicates charged fell on nine of ten (p=0.0215).
376
+
377
+ **Replacement:** suppressing repeat presses in the harness — a rule that will
378
+ not emit a second press within some interval — is now the better-supported
379
+ option, because it does not depend on the model choosing to act on information
380
+ it has been given. Whether some other phrasing of in-prompt state would help
381
+ remains open; the phrasing tested was the natural one and it made this agent
382
+ worse.
383
+
384
+ ## R16 — "Repeat presses inside an advertisement are a state-tracking failure and the largest single source of wrong presses"
385
+
386
+ **Claimed:** F31 introduced `duplicates_per_ad` as a separate error axis on the
387
+ grounds that the agent, having no memory between snapshots, presses again
388
+ during a read it has already caught. F32 charged those presses against
389
+ precision and called the older figures two to six times too generous. The
390
+ report carries both a "precision charging duplicates" column and the sentence
391
+ that repeat presses are the largest single source of wrong presses.
392
+
393
+ **Why it fell:** the action is the YouTube `l` key, which advances the playhead
394
+ ten seconds. The reads are longer than that — median 21.5 s, 17 of 18 over
395
+ 10 s, longest 68.9 s — so clearing one takes about three presses. The metric
396
+ credited the first and charged the rest, which meant charging the agent for
397
+ doing the task. This was never a measurement error; the presses were counted
398
+ correctly and scored against the wrong contract.
399
+
400
+ **Evidence:** crediting each press with the ten seconds it buys and charging
401
+ only the excess, between a quarter and a third of the charged duplicates were
402
+ required — 27 of 82 for the local model, 27 of 94 for Haiku, 29 of 82 for
403
+ Opus, 30 of 119 for Sonnet. Precision roughly doubles for every model: 0.184 to
404
+ 0.394 local, 0.141 to 0.332 Haiku, 0.172 to 0.408 Opus, 0.094 to 0.240 Sonnet.
405
+
406
+ **Replacement:** an excess-press count and a precision that credits a press
407
+ inside a read while the read still has time left to skip (F49). Repeat presses
408
+ remain a real failure — the agent presses about 5.6 times where 2.6 are needed
409
+ — but roughly twice, not roughly six times, too often.
410
+
411
+ **What is unaffected:** detection, both latency columns, and all presses
412
+ outside a read, which are wrong whatever the key does. The model ordering does
413
+ not move — Sonnet worse than the other three, no evidence separating those
414
+ three (F40, F42). F47 and R15 stand: the memory intervention was withdrawn on
415
+ the false-alarm result, measured outside the reads, which this does not touch.
416
+ The sampling-rate penalty also stands; it survives the correction at
417
+ p<0.0001 (F49).
418
+
419
+ ## R17 — "The local model decides about three times faster than the hosted API (211 ms vs 693 ms)"
420
+
421
+ **Claimed:** carried in the report as the component latency result and described
422
+ as the claim that survives, the one number left standing after sixteen
423
+ withdrawals: local inference at 211 ms per decision against 693 ms for the
424
+ hosted API.
425
+
426
+ **Why it fell:** the two sides were not measured the same way. The local figure
427
+ came from a five-sample probe on a single cached frame with a 67-character
428
+ prompt. The hosted figure came from 453 real decisions on the trading task with
429
+ its real 764-character prompt. The local sample size was never printed next to
430
+ the hosted one, so the asymmetry was not visible in the table.
431
+
432
+ **Evidence:** the local model re-measured under the trading task's own prompt
433
+ and frames, n=40, gives a median of 690 ms — against the hosted 693 ms. The
434
+ same speed.
435
+
436
+ **Replacement:** local and hosted decision latency are indistinguishable on this
437
+ hardware for this workload. The case for the local model is not speed. It is
438
+ that it runs with no network, no per-call cost, and no account that can run out
439
+ of credit — the last of which is what prevented hosted models being measured at
440
+ all on the night this was found.
441
+
442
+ ## R18
443
+
444
+ **Claim.** Task B reaction times of 6.20 s (local), 7.14 s (Opus), 7.17 s
445
+ (Haiku) and 7.22 s (Sonnet), described in the report as medians.
446
+
447
+ **Why it fell.** The report defines reaction twice as "the median time from an
448
+ event starting to the agent's first correct response". The builder computed
449
+ `sum(reacts)/len(reacts)` — the arithmetic mean of each episode's median. Every
450
+ reaction number the report has published used the wrong statistic for its own
451
+ stated definition.
452
+
453
+ **Evidence.** Recomputed from all 18 records per model in
454
+ `experiments/youtube_nolookahead`: medians are 5.66 s, 6.54 s, 7.02 s and
455
+ 6.90 s.
456
+
457
+ **What replaced it.** The builder computes the median. The values change by up
458
+ to 0.6 s and the ordering among the three closest models changes, which does
459
+ not affect the report's claim that they are effectively tied — the point that
460
+ the fixed 2 s sampling interval dominates all of them stands.
461
+
462
+ ## R19
463
+
464
+ **Claim.** In the Task B paired-precision table, "Opus vs local Qwen +0.048"
465
+ and "Opus vs Haiku +0.077" — as printed, Haiku and the local model ahead of
466
+ Opus.
467
+
468
+ **Why it fell.** Those rows were typed into the report builder by hand rather
469
+ than computed. Recomputing from the records gives −0.048 and −0.077: Opus is
470
+ ahead in both. A third row's count of differing videos was 6 where the records
471
+ give 7.
472
+
473
+ **Evidence.** `metrics_v2.paired_compare` run against
474
+ `experiments/youtube_nolookahead`; the six F1 rows in the neighbouring table
475
+ reproduce exactly, isolating the error to the typed precision rows.
476
+
477
+ **What replaced it.** Both tables are generated from the records on every build
478
+ (FINDINGS F69). The report's prose always described the direction correctly, so
479
+ no conclusion changes.
480
+
481
+ ## R20 — "With picture alone, Sonnet presses rarely but mostly accurately — 0.72 of its presses are correct"
482
+
483
+ **Claimed:** in the channel side-experiment note (from FINDINGS F14, 2026-07-24),
484
+ carried in every report version through v060: on the picture-only ablation
485
+ Sonnet was the cautious model — few presses, and 0.72 of them correct.
486
+
487
+ **Why it fell:** 0.72 is the mean of the stored per-episode precisions over all
488
+ six episodes, where the three episodes in which Sonnet never pressed carry the
489
+ scorer's old zero-presses convention: 0/0 scored as precision 1.0. That is
490
+ exactly the defect F33 identified two days after F14 on the trading task — an
491
+ inactive agent credited with perfect precision — but the ablation prose was
492
+ never re-derived after the convention changed. Under the current convention
493
+ (episodes with no presses excluded), the same records give
494
+ (1.0 + 0.0 + 0.333)/3 = 0.44.
495
+
496
+ **Evidence:** `experiments/youtube_antirefire/episodes/yt_0000–yt_0005/`,
497
+ `record_claude-sonnet-5_vision.json`, stored `meta.score` fields. The pre-F33
498
+ aggregation over all six episodes reproduces 0.7222 exactly; the three-episode
499
+ mean gives 0.444. Reproduced independently by the student who found it and by
500
+ the advisor pass that verified it. The records are unchanged since F14: that
501
+ entry's own per-episode citations match today's files. A smaller slip in the
502
+ same note fell with it: Opus presses 4 to 8 times per video ([7,7,4,7,8,7]),
503
+ not "four to seven" — a write-up slip, since both counting conventions give
504
+ the same numbers.
505
+
506
+ **Replacement:** with picture alone, Sonnet presses sparingly and under half of
507
+ its rare presses are correct. The qualitative contrast in that note — Sonnet
508
+ cautious-but-accurate versus Opus recall-by-spamming — does not survive; what
509
+ survives is that no model is reliable on picture alone while every model is
510
+ reliable with sound. The note's figures are now derived from the ablation
511
+ records at build time (FINDINGS F75), so the prose cannot drift from the
512
+ records again.
aim.py ADDED
@@ -0,0 +1,312 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # /// script
2
+ # requires-python = '>=3.12'
3
+ # dependencies = ['numpy', 'pillow', 'pyserial']
4
+ # ///
5
+ '''Relative aiming for Task A: move the gun, not a cursor.
6
+
7
+ Everything actuated so far has been absolute pointing — park the cursor, then
8
+ jump to a screen pixel. That is right for menus and unusable in a battle: there
9
+ is no cursor, and the mouse steers the gun by relative movement. So aiming is a
10
+ control problem rather than a click, and it needs three things this file
11
+ provides.
12
+
13
+ 1. A way to measure how far the view actually moved, from the captured frames
14
+ alone. Phase correlation gives that without any game-side information.
15
+ 2. A gain: how many pixels the view turns per unit of mouse movement. This is
16
+ a property of the game's sensitivity setting, so it has to be measured on
17
+ the rig rather than assumed, and re-measured whenever that setting changes.
18
+ 3. A closed loop: move, look, correct. One open-loop jump will not land,
19
+ because the gain is only approximate and the turret has inertia.
20
+
21
+ uv run aim.py --self-test # verify the estimator, no hardware
22
+ uv run aim.py --calibrate # measure the gain (needs the game up)
23
+
24
+ The self-test is the part that can be checked without the rig, and it is worth
25
+ running after any change here: an aiming loop built on a shift estimator that
26
+ is silently wrong would look like a model that cannot aim.
27
+ '''
28
+
29
+ from __future__ import annotations
30
+
31
+ import time
32
+ from argparse import ArgumentParser
33
+ from dataclasses import dataclass
34
+ from io import BytesIO
35
+ from typing import Callable
36
+
37
+ import numpy as np
38
+ from PIL import Image
39
+
40
+ Grab = Callable[[], bytes] # returns JPEG bytes of the current frame
41
+
42
+
43
+ def _luma(jpeg: bytes, downscale: int = 2) -> np.ndarray:
44
+ im = Image.open(BytesIO(jpeg)).convert('L')
45
+ if downscale > 1:
46
+ im = im.resize((im.width // downscale, im.height // downscale))
47
+ return np.asarray(im, dtype=np.float32)
48
+
49
+
50
+ def estimate_shift(a: np.ndarray, b: np.ndarray) -> tuple[float, float]:
51
+ '''How far b is displaced from a, in pixels, by phase correlation.
52
+
53
+ Returns (dx, dy): positive dx means the content moved right. A Hann window
54
+ is applied first because the frames are not periodic and the edges would
55
+ otherwise dominate the correlation.
56
+ '''
57
+ if a.shape != b.shape:
58
+ raise ValueError(f'frame size changed: {a.shape} vs {b.shape}')
59
+ h, w = a.shape
60
+ win = np.outer(np.hanning(h), np.hanning(w))
61
+ fa = np.fft.rfft2((a - a.mean()) * win)
62
+ fb = np.fft.rfft2((b - b.mean()) * win)
63
+ # conj(a)*b, not a*conj(b): the reversed order returns the exact
64
+ # negative of the displacement, which an earlier version of this
65
+ # file shipped while its self-test quietly negated the result and
66
+ # reported a pass (FINDINGS F44).
67
+ cross = np.conj(fa) * fb
68
+ mag = np.abs(cross)
69
+ mag[mag == 0] = 1e-12
70
+ corr = np.fft.irfft2(cross / mag, s=a.shape)
71
+ peak = np.unravel_index(int(np.argmax(corr)), corr.shape)
72
+ dy, dx = float(peak[0]), float(peak[1])
73
+ # wrap: a peak past the halfway point is a negative displacement
74
+ if dy > h / 2:
75
+ dy -= h
76
+ if dx > w / 2:
77
+ dx -= w
78
+ return dx, dy
79
+
80
+
81
+ @dataclass(frozen=True)
82
+ class Gain:
83
+ '''Pixels of view movement per unit of mouse movement, WITH sign.
84
+
85
+ The sign records which way the view travels for a positive mouse movement.
86
+ It is not cosmetic: aim_at is a proportional controller, and one fed a
87
+ flipped sign does not converge slowly, it diverges.
88
+ '''
89
+ px_per_count_x: float
90
+ px_per_count_y: float
91
+ downscale: int
92
+ samples: int
93
+ sign_stable: bool = True
94
+
95
+ def counts_for(self, dx_px: float, dy_px: float) -> tuple[int, int]:
96
+ gx = self.px_per_count_x or 1e-9
97
+ gy = self.px_per_count_y or 1e-9
98
+ return int(round(dx_px / gx)), int(round(dy_px / gy))
99
+
100
+
101
+ def calibrate_gain(hid, grab: Grab, counts: int = 200, samples: int = 3,
102
+ settle_s: float = 0.35, downscale: int = 2) -> Gain:
103
+ '''Measure pixels-per-count by moving a known amount and watching the view.
104
+
105
+ Each sample moves out and back so the aim ends where it started, which
106
+ matters because this runs on a live game. The horizontal and vertical gains
107
+ are measured separately: they differ whenever the game applies a different
108
+ sensitivity per axis.
109
+ '''
110
+ xs: list[float] = []
111
+ ys: list[float] = []
112
+ for _ in range(samples):
113
+ before = _luma(grab(), downscale)
114
+ hid.move_rel(counts, 0)
115
+ time.sleep(settle_s)
116
+ after = _luma(grab(), downscale)
117
+ dx, _ = estimate_shift(before, after)
118
+ hid.move_rel(-counts, 0)
119
+ time.sleep(settle_s)
120
+ xs.append(dx * downscale / counts) # signed, deliberately
121
+
122
+ before = _luma(grab(), downscale)
123
+ hid.move_rel(0, counts)
124
+ time.sleep(settle_s)
125
+ after = _luma(grab(), downscale)
126
+ _, dy = estimate_shift(before, after)
127
+ hid.move_rel(0, -counts)
128
+ time.sleep(settle_s)
129
+ ys.append(dy * downscale / counts) # signed, deliberately
130
+
131
+ # If the measured direction flips between samples the gain is not
132
+ # trustworthy at all: something other than our input is moving the view.
133
+ stable = (len({x > 0 for x in xs}) == 1 and len({y > 0 for y in ys}) == 1)
134
+ return Gain(float(np.median(xs)), float(np.median(ys)),
135
+ downscale, samples, stable)
136
+
137
+
138
+ def aim_at(hid, grab: Grab, offset_fn: Callable[[bytes], tuple[float, float] | None],
139
+ gain: Gain, tol_px: float = 12.0, max_steps: int = 6,
140
+ settle_s: float = 0.25, damping: float = 0.8) -> dict:
141
+ '''Bring the gun onto a target by moving, looking and correcting.
142
+
143
+ offset_fn is given the current frame and returns how far the target sits
144
+ from the aiming point in pixels, or None if it cannot find it. Steps are
145
+ damped because overshooting and oscillating is the usual failure of a loop
146
+ like this, and each correction is measured rather than assumed.
147
+ '''
148
+ trace: list[dict] = []
149
+ for step in range(max_steps):
150
+ frame = grab()
151
+ off = offset_fn(frame)
152
+ if off is None:
153
+ trace.append({'step': step, 'status': 'target not found'})
154
+ return {'hit': False, 'reason': 'target not found', 'trace': trace}
155
+ dx_px, dy_px = off
156
+ err = float(np.hypot(dx_px, dy_px))
157
+ trace.append({'step': step, 'dx_px': dx_px, 'dy_px': dy_px, 'err_px': err})
158
+ if err <= tol_px:
159
+ return {'hit': True, 'steps': step, 'err_px': err, 'trace': trace}
160
+ cx, cy = gain.counts_for(dx_px * damping, dy_px * damping)
161
+ if cx == 0 and cy == 0: # below one count of resolution
162
+ return {'hit': False, 'reason': 'below movement resolution',
163
+ 'err_px': err, 'trace': trace}
164
+ hid.move_rel(cx, cy)
165
+ time.sleep(settle_s)
166
+ return {'hit': False, 'reason': 'did not converge', 'trace': trace}
167
+
168
+
169
+ def _self_test() -> int:
170
+ '''Check the estimator against known shifts, with no hardware involved.'''
171
+ rng = np.random.default_rng(0)
172
+ base = rng.random((360, 640)).astype(np.float32)
173
+ # smooth it so it resembles a scene rather than white noise
174
+ for _ in range(3):
175
+ base = (base + np.roll(base, 1, 0) + np.roll(base, 1, 1)) / 3.0
176
+
177
+ worst = 0.0
178
+ print(f'{"true dx":>8s} {"true dy":>8s} {"est dx":>8s} {"est dy":>8s}')
179
+ # The last four exceed half the frame on one or both axes, which is
180
+ # what exercises the wrap-around branch below (half-width 320,
181
+ # half-height 180 on this 360x640 test image).
182
+ for tdx, tdy in ((10, 0), (-14, 0), (0, 9), (0, -21), (17, -13),
183
+ (-30, 25), (200, 0), (-260, 0), (0, 150),
184
+ (240, -140)):
185
+ shifted = np.roll(np.roll(base, tdy, axis=0), tdx, axis=1)
186
+ edx, edy = estimate_shift(base, shifted)
187
+ print(f'{tdx:8d} {tdy:8d} {edx:8.1f} {edy:8.1f}')
188
+ worst = max(worst, abs(edx - tdx), abs(edy - tdy))
189
+ ok = worst <= 1.0
190
+ print(f'\nworst error {worst:.2f} px — {"PASS" if ok else "FAIL"}')
191
+ return 0 if ok else 1
192
+
193
+
194
+
195
+ def _direction_test() -> int:
196
+ """Run the real calibrate_gain against a mock rig with a known direction.
197
+
198
+ The estimator's self-test only exercises estimate_shift. This exercises the
199
+ whole path — device, capture, gain — and checks the one property nothing
200
+ else checks: that a positive mouse movement produces a gain whose SIGN says
201
+ which way the view actually went. Two bugs shipped for want of this test
202
+ (FINDINGS F44): the estimator returned the negative of its contract, and
203
+ the gain discarded the sign with abs() so nothing downstream could notice.
204
+ """
205
+ from io import BytesIO as _B
206
+
207
+ rng = np.random.default_rng(1)
208
+ world = rng.random((720, 1280)).astype(np.float32)
209
+ for _ in range(3):
210
+ world = (world + np.roll(world, 1, 0) + np.roll(world, 1, 1)) / 3.0
211
+
212
+ class MockRig:
213
+ """A device whose movement really does displace the captured view."""
214
+
215
+ def __init__(self, px_per_count_x: float, px_per_count_y: float):
216
+ self.gx, self.gy = px_per_count_x, px_per_count_y
217
+ self.ox = self.oy = 0.0
218
+
219
+ def move_rel(self, dx: int, dy: int) -> None:
220
+ self.ox += dx * self.gx
221
+ self.oy += dy * self.gy
222
+
223
+ def grab(self) -> bytes:
224
+ view = np.roll(np.roll(world, int(round(self.oy)), 0),
225
+ int(round(self.ox)), 1)
226
+ buf = _B()
227
+ Image.fromarray(view.clip(0, 1).__mul__(255).astype('uint8')).save(
228
+ buf, format='JPEG', quality=92)
229
+ return buf.getvalue()
230
+
231
+ ok = True
232
+ print(f'{"true gain x":>12s} {"true gain y":>12s} '
233
+ f'{"measured x":>11s} {"measured y":>11s} verdict')
234
+ for tgx, tgy in ((0.40, 0.35), (-0.40, 0.35), (0.55, -0.48), (-0.30, -0.30)):
235
+ rig = MockRig(tgx, tgy)
236
+ g = calibrate_gain(rig, rig.grab, counts=100, samples=2,
237
+ settle_s=0.0, downscale=2)
238
+ sign_ok = (np.sign(g.px_per_count_x) == np.sign(tgx)
239
+ and np.sign(g.px_per_count_y) == np.sign(tgy))
240
+ mag_ok = (abs(abs(g.px_per_count_x) - abs(tgx)) < 0.05
241
+ and abs(abs(g.px_per_count_y) - abs(tgy)) < 0.05)
242
+ good = sign_ok and mag_ok and g.sign_stable
243
+ ok &= good
244
+ print(f'{tgx:12.2f} {tgy:12.2f} {g.px_per_count_x:11.3f} '
245
+ f'{g.px_per_count_y:11.3f} '
246
+ f'{"ok" if good else ("SIGN WRONG" if not sign_ok else "magnitude off")}')
247
+
248
+ # A controller given a flipped gain must diverge, not merely converge
249
+ # slowly. Confirm that, so the sign check above is known to matter.
250
+ class Turret:
251
+ def __init__(self, dx, gx): self.dx, self.gx = dx, gx
252
+ def move_rel(self, cx, cy): self.dx -= cx * self.gx
253
+ def offset(self, _): return (self.dx, 0.0)
254
+
255
+ right = Turret(300.0, 0.40)
256
+ aim_at(right, lambda: b'', right.offset,
257
+ Gain(0.40, 0.40, 2, 2), tol_px=12, max_steps=6, settle_s=0.0)
258
+ flipped = Turret(300.0, 0.40)
259
+ aim_at(flipped, lambda: b'', flipped.offset,
260
+ Gain(-0.40, -0.40, 2, 2), tol_px=12, max_steps=6, settle_s=0.0)
261
+ diverged = abs(flipped.dx) > 300.0
262
+ print(f'\ncorrect sign converges to {abs(right.dx):8.1f} px')
263
+ print(f'flipped sign ends at {abs(flipped.dx):8.1f} px '
264
+ f'({"diverges as expected" if diverged else "DID NOT DIVERGE"})')
265
+ ok &= diverged
266
+ print(f'\n{"PASS" if ok else "FAIL"}')
267
+ return 0 if ok else 1
268
+
269
+
270
+ def main() -> int:
271
+ ap = ArgumentParser(description='Relative aiming for Task A.')
272
+ ap.add_argument('--self-test', action='store_true')
273
+ ap.add_argument('--direction-test', action='store_true',
274
+ help='run the real gain measurement against a mock rig')
275
+ ap.add_argument('--calibrate', action='store_true')
276
+ ap.add_argument('--counts', type=int, default=200)
277
+ ap.add_argument('--device', default='/dev/video0')
278
+ ap.add_argument('--port',
279
+ default='/dev/serial/by-id/usb-1a86_USB_Serial-if00-port0')
280
+ args = ap.parse_args()
281
+
282
+ if args.self_test:
283
+ return _self_test()
284
+
285
+ if args.direction_test:
286
+ return _direction_test()
287
+
288
+ if args.calibrate:
289
+ from gua_eval.capture import ElgatoSource # noqa: PLC0415
290
+ from hid_kmbox import KMBox # noqa: PLC0415
291
+ cap = ElgatoSource(args.device)
292
+ frames = cap.frames()
293
+
294
+ def grab() -> bytes:
295
+ return next(frames)[0]
296
+
297
+ with KMBox(args.port) as hid:
298
+ hid.open()
299
+ hid.set_relative()
300
+ gain = calibrate_gain(hid, grab, counts=args.counts)
301
+ print(f'horizontal {gain.px_per_count_x:.4f} px/count')
302
+ print(f'vertical {gain.px_per_count_y:.4f} px/count')
303
+ print(f' a 300 px correction needs '
304
+ f'{gain.counts_for(300, 0)[0]} counts horizontally')
305
+ return 0
306
+
307
+ ap.print_help()
308
+ return 0
309
+
310
+
311
+ if __name__ == '__main__':
312
+ raise SystemExit(main())
archives/experiments_trading_episodes_trading_0000_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:7ac763c9554d7f00887306b016e5646feac64cf8037ee3f9702261c7c4af00d6
3
+ size 8785920
archives/experiments_trading_episodes_trading_0001_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:0c565ce375682ba4d351e7a6524c53e5307ce943aa8c707d35c6d41db83d9c9b
3
+ size 8232960
archives/experiments_trading_episodes_trading_0002_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:c8ac4976352bbf17d77e965fbd6efe886c5cba98b3fb8c65723d552b8ab49eef
3
+ size 8325120
archives/experiments_trading_episodes_trading_0003_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:46761efcc82eac9477f171b046b7cf5f88ffad9ae4fa25814fff810be124c292
3
+ size 8171520
archives/experiments_trading_episodes_trading_0004_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:25dc0d8df6882b7e6cd293d7570a7e392e3a1d135bea10fa8cb6f62b3b3c77b5
3
+ size 8376320
archives/experiments_trading_episodes_trading_0005_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:9fe52bb87efaeb8a86dddea7755585f3a293592c431a85159caa5346e4d67ee4
3
+ size 8744960
archives/experiments_trading_local_n20_episodes_trading_0006_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:e9e38a8913178f293361b5f4494295e8b8ddcb384a30280c412992191d8f3451
3
+ size 8427520
archives/experiments_trading_local_n20_episodes_trading_0007_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:2a0b9a37d76df8cf110ec2150fee54d7f232efce56e5a1c1bdb4d41bf67bacee
3
+ size 8499200
archives/experiments_trading_local_n20_episodes_trading_0008_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:8fc64695a197d38b1dfa794094f7f9cbd54505ee79dc2bc4b718239f53a464e7
3
+ size 9021440
archives/experiments_trading_local_n20_episodes_trading_0009_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:ac3b4b61477f74b47e07abdace3ab7abe93a2058207bb346064e5329bd062d10
3
+ size 8448000
archives/experiments_trading_local_n20_episodes_trading_0010_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:397860c7e6d1383adcf1bc86f10921bb9a6425d47747a631af6b30c6dfee29be
3
+ size 8273920
archives/experiments_trading_local_n20_episodes_trading_0011_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:a1c61ef71be745d08cfc954e9f55a2002f150a04f8abd2e9d0d6dcbd2e33aca3
3
+ size 8550400
archives/experiments_trading_local_n20_episodes_trading_0012_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:942e09f82a068119422acafd8fad7df1ec23fa57b62875cc355345f553a8a1e5
3
+ size 8663040
archives/experiments_trading_local_n20_episodes_trading_0013_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:20fd1ca7a6bfaa0e1707f18be6132b44a4e70dbc12dbec5a7f46137c07c1bfce
3
+ size 8396800
archives/experiments_trading_local_n20_episodes_trading_0014_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:5af1a3b3720695a6bb758426ee5c4c29c17a8ceb5ef2d9667d6daebe36562ed6
3
+ size 8509440
archives/experiments_trading_local_n20_episodes_trading_0015_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:3adad7c5ceb55aa3ce66e93df97c0689a7ba9ce2e1600ba8d47e6b5919b39180
3
+ size 8161280
archives/experiments_trading_local_n20_episodes_trading_0016_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:8b728b925c83d994085fabe512661b90586862c3513be3697b34dd4c6556e8e2
3
+ size 8509440
archives/experiments_trading_local_n20_episodes_trading_0017_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:52a71d9d868997b691d616881399ce06b09268e87035c791e1ddb7c3013a5466
3
+ size 8110080
archives/experiments_trading_local_n20_episodes_trading_0018_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:2339e631a1c893256b8f40922d092d516d8be01dad982491975068e3ef3e6930
3
+ size 8611840
archives/experiments_trading_local_n20_episodes_trading_0019_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:85212280fa34fc20a611a5b86a9b8a0e0a39cd0dc062b223ec145c6d7c68b394
3
+ size 8407040
archives/experiments_trading_prompt_v2_episodes_trading_0000_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:dfdeb004e5762c09b665e93dfd55aa94bd7f9d9aa52d79b506107871d409d7bd
3
+ size 8785920
archives/experiments_trading_prompt_v2_episodes_trading_0001_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:1e46394cb8b9789b441f606250f686ac7f289332ec1d90e07d93d7c83f38688c
3
+ size 8232960
archives/experiments_trading_prompt_v2_episodes_trading_0002_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:e55c5644b5a275ca14235988b5e2b1e1bb6df541aa1a727a1182d7fe156f8c2d
3
+ size 8325120
archives/experiments_wt_live__aborted_noaim_no_sight_support_ep_000_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:01c5bd2c365dbd1f978e278a52eac3f0dd6f8442f1077f55bf4e4cadaab2bfea
3
+ size 1587200
archives/experiments_wt_live__aborted_noaim_no_sight_support_ep_001_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:aef738b18059ea03f1a60986141af91b8aa9eacfd19b49567dc3a1438b95aa04
3
+ size 2037760
archives/experiments_wt_live__aborted_noaim_no_sight_support_ep_002_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:16deb72b3f438c583cdcc2cdf087e83d8e5a55cdc811d3ed7284aa397495a317
3
+ size 2836480
archives/experiments_wt_live__aborted_noaim_no_sight_support_ep_003_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:ee1423f8e230e52f2a825b5b23aa37fc510d8a121fa96a20f5f35b1e4371c95d
3
+ size 3123200
archives/experiments_wt_live__aborted_noaim_no_sight_support_ep_004_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:508aa6ff17c266140e1d9c2484902faa6e1144b580946a23cd2b4b04fef3c9d9
3
+ size 1996800
archives/experiments_wt_live__aborted_noaim_no_sight_support_ep_005_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:b615463bfc6cc628d541d7239bd0e97acef349f47a12d07764974c5839201945
3
+ size 1966080
archives/experiments_wt_live__aborted_noaim_no_sight_support_ep_006_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:c8e44681ddf87f08034db6c6a9faea71bba56f028e685e2b486e4174927189b8
3
+ size 768000
archives/experiments_wt_live_fulda_search_ep_000_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:f1a9a474b0029656177f9cbe388d87555f7543c4395a4e9053ef50dc302f8d36
3
+ size 15206400
archives/experiments_wt_live_fulda_search_ep_001_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:6d67b8c811a61c0c75cfe45c17d9340c793e7dcb3d841f11fc1aa435c5fbe628
3
+ size 15482880
archives/experiments_wt_live_fulda_search_ep_002_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:950c8cfc106e2abf94dbfd5615fe474d77f0cf67aff67701dcae282f6f6dd888
3
+ size 12861440
archives/experiments_wt_live_fulda_search_ep_003_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:00c9ceacac56e49b2a93e36b291256ec01f005774f64eb737198672eb698853a
3
+ size 15636480
archives/experiments_wt_live_fulda_search_ep_004_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:8dce302ae7bb8e3b1c1911d9133cc2f7bb92b1fddb0b3d1a8436c0f2ff1497f6
3
+ size 11868160
archives/experiments_wt_live_fulda_search_ep_005_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:82533a88e403cd4db420f511057c7668c3759c272c58ddf352e706538e49e63e
3
+ size 15144960
archives/experiments_wt_live_hosted_claude-opus-4-8_ep_000_frames.tar ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:382f7441f3c3848c99f7fcdf7d3130e541a44415bec4d459284eb27735dc48c2
3
+ size 2037760