# Cognitive-progress ledger Append-only (experiments.md §17.11). One entry per completed work item. This file — not commit count, LOC, or trial count — is the record of progress. --- ## WI-001 — Deterministic Paused/Replay/Live harness and evaluator (Gate 1) — 2026-08-21 ```text work_item_id: WI-001 (card: cards/harness.md) technical_output: src/chronotope/ (9 modules, stdlib only); tests/ (138 tests); specs/revealed_target_live.json; results/WI-001_oracle_sweep.txt contract_status: Built; Contract-verified (§16 items 1–7, 10–18 reject; 8–9 n/a before a GPU exists); Measured (E, O, B, D, A present in every trace; 112 grid points + 3 edge cases match a closed-form prediction written independently of the harness). ``` **what_was_uncertain_before** U1 whether "Replay" has an executable definition and what a pair validator must compare; U2 whether an evaluator built only from E, O, B, D, A reproduces known oracle outcomes and whether the S5.2 labels partition oracle Live failures; U3 whether §16 defects are rejected. **result_observed** All closed-form predictions hold (Paused = Replay = 1; Live = 1 iff A < t_close); every applicable §16 defect is rejected; 0 invalid pairs across the sweep. One evaluator defect was caught by the closed-form test during development (timing labels leaking into Replay) and fixed. **what_the_project_knows_now** 1. *Replay is executable* as: Live's published observation sequence re-released at the same harness offsets, with task time pinned at the depicted time of the first response-triggering frame — "Live's evidence, Paused's validity". The validator needs exactly: matching-key hash (spec minus policy and source pointer), manifest hash, controller-spec hash, action-space / scorer / boundary versions, event list, prefix-equal evidence (source_event_id, source_time, payload_hash), and the Live trace hash pointer. 2. *For a memoryless deterministic direct controller, Replay is a re-scoring of Live.* Its admitted observation at B and its committed action are Live's by construction; only receipt-time validity differs. Consequently the Paused–Replay contrast is vacuous for such controllers. Replay must be a genuine re-run only for controllers with history or stochastic decoding — and then decoding seeds must be paired. 3. *The S5.2 labels partition every oracle Live failure into exactly one of three*, by where the window-close fell: before D with its first evidence at O before D → `outdated_at_commitment`; before D but its first evidence reached O only after D → `missed_evidence:window_closes`; after D but before A → `invalidated_after_commitment`. `late` always co-occurs. The paper's "missed evidence" definition must be read per relevant event (here: the closing event, which ceases to matter at D) for the set to be exhaustive. 4. *Timing labels are defined against an advancing window.* Under Paused/Replay no later state can "require a different outcome", so none of them can apply there. 5. *Limitation found:* an in-process controller on a wall clock would stamp O after D for frames due during B→D. A wall-clock controller needs a concurrent publisher; Gate 1 therefore admits only `timestamp_source: simulated`. **decision_changed_or_unlocked** Gate 2 is admitted on this harness unchanged. Gate 2's first controller must either declare its compute time (simulated) or run under a concurrent publisher (WI-002). Replay is re-scored for deterministic memoryless controllers and re-run otherwise. **what_was_removed_or_deprioritized** `condition` as a separate config field (derived from `task_clock_policy`; §12.1 one source of truth); `delivery_only` trial class (Gate 6); wall-clock timestamp source (needs WI-002); any B→D pre-commit mechanism (not built; §17.8 gate not reached). **one_sentence_generalist_takeaway** With a perfect but slow clicker, the only thing that differs between Replay and Live is whether the target is still there when the click lands — and the trace says whether the closing happened before the click was decided and, if so, whether the controller could have seen it. **evidence_for_that_takeaway** — `results/WI-001_oracle_sweep.txt` (event at 500 ms, window 400 ms, 60 Hz frames, 30 ms publication delay): | compute | delivery | Paused | Replay | Live | S_A | Live labels | |---|---|---|---|---|---|---| | 355 ms | 0 ms | 1 | 1 | 1 | +15.0 ms | — | | 355 ms | 20 ms | 1 | 1 | 0 | −5.0 ms | late, invalidated_after_commitment | | 400 ms | 0 ms | 1 | 1 | 0 | −30.0 ms | late, missed_evidence:window_closes (closing's first frame reached O 8 ns after D) | | 600 ms | 0 ms | 1 | 1 | 0 | −230.0 ms | late, outdated_at_commitment | **what_the_reader_should_not_infer** That any model behaves like the oracle; that a Paused–Replay difference exists (none can for this controller); anything about physical delivery or GPU residency. **remaining_uncertainty** Whether a real controller can do even the Paused task (competence gate §17.7); whether a relevant observation ever arrives during a real B→D (§17.8); physical D→A. **next_admitted_work_item** WI-002 — concurrent observation publisher + first real direct controller under Paused (competence qualification), on this harness unchanged. ### Gate 1 learning note (experiments.md §18) * Unknown before: whether a matched Replay–Live pair differing only in task-clock treatment could be constructed and verified, and whether a trace-only scorer is unambiguous. * Established: both, for one-response episodes and a deterministic controller; plus points 2–5 above. Ruled out: "a Replay–Live gap is a harness/scorer artifact" (for this harness). * Decision changed: Gate 2 admitted; Replay re-run vs re-score decided per controller class. * Generalist understanding: Replay = Live's pictures with the world held still; so Replay vs Live measures only "did the target wait for the click". * Remains unknown: everything about real controllers and the physical path. * Admitted: WI-002. Removed/deferred: see above. ### Deviations from experiments.md (§20 item 12) * §11.1 `condition` is not a config field; it is the task-clock policy (one source of truth). * §11.1 model artifact hash / prompt hash / decoding config are the typed `controller` block; `controller_spec_hash` covers them. The only controller kind is `scripted_oracle`. * §11.1 `trial_class` admits only `agent_decision`; `timestamp_source` only `simulated`. * §16 items 8 and 9 are not applicable before Gate 3; items 15 and 16 are realized as trace-level rejections of a trace that *claims* a restart/buffer as the same decision. --- ## WI-002 — Wall-clock harness mode + first real direct controller — 2026-08-21 (night) ```text work_item_id: WI-002 (card: cards/R1-revealed-target.md) technical_output: clock.MonotonicHarnessClock; runner multi-decision loop (wait decisions, decision_failed, O stamped at due time); controller.VLMDirectController (change-triggered, forced tool call click/wait); png.py; spec per-kind controller schema; studies/wi002_competence_prl.py; 9 new tests (147 total). contract_status: Built; Contract-verified (wall-clock oracle vs closed form within 15 ms jitter; VLM controller against a mock client; spec strictness). NOT Measured for a real model: the agent could not obtain credentials (see below). ``` **what_was_uncertain_before** U4 (is lazy publication faithful under a real clock), U5 (competence), U6 (first real Paused–Replay–Live row). **result_observed** U4: yes — for a deterministic environment, frames that fall due while the controller blocks can be rendered at D and stamped with their due time; the wall-clock oracle reproduces every closed-form interval within sleep jitter (≤ 15 ms), and O ordering before D is preserved. U5/U6: **not run.** An `ANTHROPIC_API_KEY` exists in the old pilot's `.env`, but the session's permission classifier blocked using it (and installing the SDK); the agent did not work around that. Everything else is ready: `studies/wi002_competence_prl.py` runs the entire predeclared protocol from one command once the key is exported. **what_the_project_knows_now** 1. A concurrent observation publisher is NOT required for synthetic environments; it is required only when the environment is not a pure function of task time (physical capture). 2. A real VLM direct controller has exactly one new degree of freedom the oracle lacks: WHEN to invoke. The contract-faithful choice is "on frame change from the first frame" (one fixed-input call per change; `wait` decisions are real decisions that consume time and are traced as such). 3. For a stochastic model Replay must be a re-run (same frame; decoding variance is what a Paused–Replay gap would then measure on this task). **decision_changed_or_unlocked** The concurrent-publisher work item is removed. Gate 2 measurement is one command away, blocked only on credentials. **what_was_removed_or_deprioritized** Concurrent publisher (not needed). SDK retries in the controller (max_retries=0: a retry would silently lengthen B->D; failures are recorded as invalid trials instead). **one_sentence_generalist_takeaway** We can now time a real AI against a disappearing target honestly — the clock only advances because the AI is really thinking — but we have not yet run one, because the agent was not allowed to use your API key on its own. **what_the_reader_should_not_infer** Anything about any model yet. **remaining_uncertainty** U5, U6 (unchanged). **next_admitted_work_item** WI-002-run — superseded by the user's decision to use a LOCAL model (no API keys): see the WI-002 measurement entry below. --- ## WI-003 — Moving target: post-commit delay and the four receipt-state bindings (oracle) — 2026-08-21 (night) ```text work_item_id: WI-003 (card: cards/C0-balloon-drift-oracle.md) technical_output: scenario.MovingTargetManifest (+ manifest factory); oracle `binding` {state_at_B, newest_at_D, predicted_at_A, true_at_A} with a runner-side `correct_at_commit` hook and a `coordinate_correction` trace record; evaluator spatial_error_px and correction-contract checks; studies/wi003_moving_target.py; results/WI-003_moving_target.md; 35 new tests (182 total). contract_status: Built; Contract-verified (closed form on 24 S3.1 cells x 3 conditions; ordering + matched B/D/A; perturbation; negative: unrecorded correction flagged, kind-changing correction rejected, spec strictness); Measured (oracle). ``` **what_was_uncertain_before** U7 (does the evaluator handle post-commit change), U8 (do the four S3.2 bindings order as predicted with matched B, D, A), U9 (can the trace distinguish a coordinate correction from a same-decision update). **result_observed** (results/WI-003_moving_target.md) S3.1: static target valid 5/5 at every D→A delay; at 60 px/s error at A = 7 → 19 px as delay goes 0 → 200 ms, at 120 px/s 15 → 39 px; Live 0/5 throughout while Paused/Replay 5/5. S3.2 at 120 px/s (delivery 60 ms): state_at_B 22 px (0/5), newest_at_D 12 px (0/5), predicted_at_A 1 px (5/5), true_at_A 0 px (5/5); all four tie at 0 px on the static target. Predictor with a ±60 ms wrong delivery estimate: 6–8 px ≈ v·|Δ| (7.2 px), slightly asymmetric because displacement floors to pixels. **what_the_project_knows_now** 1. *Post-commit delay is harmless for a static target and linearly harmful for a moving one* — in the oracle setting, exactly; this is the delay–value relation S4.2 will need for this task. 2. *"Newest at D" is not enough for a moving target*: it removes only the B→D staleness, not the E→O + D→A part. Its residual error is v·(publication delay + delivery delay + ≤1 frame). 3. *Prediction needs the delays*: with the true observation and delivery delays the predictor is within 1 px of the oracle bound; each 20 ms of delivery-estimate error costs v·20 ms. 4. *Operational definitions pinned*: newest_at_D, predicted_at_A, and true_at_A are all "coordinate corrections at commitment" — traced as `coordinate_correction` with the observation used, the proposed and the committed coordinates — and are NOT same-decision updates (the decision is fixed-input; only the coordinates are re-bound). The evaluator flags a committed action that differs from the proposal without such a record. 5. *Scorer semantics for correcting bindings*: "semantic correctness" is undefined for an action aimed at a predicted future state; the evaluator records None rather than a false semantic_error. **decision_changed_or_unlocked** S3.1/S3.2/S5.1-second-intervention can run with real agents on `moving_target` unchanged. The S4.2 combination (physical D→A distribution × this delay–value curve) has its synthetic half. **what_was_removed_or_deprioritized** Nothing added beyond the card; a separate "pre-commit jump" scenario was not built because the continuous moving target already separates state-at-B from newest-at-D. **one_sentence_generalist_takeaway** If the target keeps moving after you decide, clicking where it *was* misses by speed × (how long the click takes to land); clicking where it *will be* only works if you also know how long that is. **what_the_reader_should_not_infer** That any real agent can estimate velocity or the delays; these are oracle instrument checks, not agent results. **remaining_uncertainty** Real-agent behaviour on moving_target; the physical D→A distribution. **next_admitted_work_item** WI-002-run (credentials), then WI-004: real agents on moving_target with the same bindings (state_at_B vs newest_at_D needs no velocity estimate). --- ## WI-002 (measurement) — Qwen3.8-27B, local vLLM, thinking off — 2026-08-22 ```text work_item_id: WI-002 (card: cards/R1-revealed-target.md, amended pre-data: windows {1,2,4,8,16} s) technical_output: controller.LocalOpenAIAdapter (stdlib urllib, decoder-enforced JSON action schema, NO API keys); vLLM 0.27.1 serving Qwen/Qwen3.8-27B bf16 on the GB10 (~/qwen-serve, see README); studies/wi002_competence_prl.py; results/WI-002_qwen38_nothink.md; runs/wi002_qwen38_nothink/ (160 traces). contract_status: Built; Contract-verified (183 tests); Measured (real model, wall clock); Project-learning + Reader-ready below. Claim-supporting for H2 on ONE task, ONE agent: yes, narrowly (see "should not infer"). ``` **what_was_uncertain_before** U5 competence; U6 the first real Paused–Replay–Live row. **result_observed** Competence under Paused on calibration seeds 100–109: **8/10 (0.80) → pass** (threshold 0.80, predeclared). Evaluation seeds 200–209 × windows {1,2,4,8,16} s: | window | Paused | Replay | Live | median Live B→D | Live failure labels | |---|---|---|---|---|---| | 1 s | 5/10 | 5/10 | 0/10 | 5.25 s | late ×10, outdated_at_commitment ×5, semantic_error ×5 | | 2 s | 5/10 | 5/10 | 0/10 | 5.21 s | same | | 4 s | 5/10 | 5/10 | 0/10 | 5.21 s | same | | 8 s | 5/10 | 5/10 | 5/10 | 5.21 s | semantic_error ×5 | | 16 s | 5/10 | 5/10 | 5/10 | 5.21 s | semantic_error ×5 | Zero invalid trials, zero invalid pairs, zero contract violations. Paused = Replay on every seed (temperature 0 ⇒ the re-run reproduces the same click). Live = Paused exactly when the window exceeds the ~5.3 s path (E→O 30 ms + B→D ≈ 5.2 s + D→A 20 ms) and 0 otherwise. Every Live failure on a semantically correct seed carries `late` + `outdated_at_commitment`: the frame showing the window closed reached O before D, and the fixed-input decision committed anyway. The five evaluation seeds the model misses are missed in ALL conditions with the same click (deterministic). Inspection of the Paused traces: four are near misses 3–7 px from a 6-px target and one is a gross miss (y ≈ 2× the true y); in calibration one more gross y-doubling produced `click outside canvas` → `commit_failed` (contract rejection, not a scored click). All five misses are targets within ~10 px of the left or top image border. **what_the_project_knows_now** 1. H2 holds on the minimal task for this agent: Paused ≈ Replay (identical) and Live drops to 0 once the window is shorter than the agent's own path; the transition is exactly where the timestamps say it should be. This is the first real-agent cell of the Paused–Replay–Live table. 2. The Replay control is informative even for a deterministic agent: it shows the Live failures are not sequence-processing failures (there is no sequence — one invocation per change). 3. The agent's competence is not uniform: it fails near image borders and occasionally doubles a coordinate. Calibration 0.80 vs evaluation 0.50 with n=10 each is a reminder that 10 seeds is a coarse competence estimate; the threshold was met but barely. 4. Qwen3.8-27B bf16 on the GB10 decodes at ~4–5 tok/s (memory-bandwidth bound): ~5.2 s per decision thinking-off, ~23–25 s thinking-on (low effort). The FP8 checkpoint would roughly halve B→D; that is a *controller* change and must be a separate agent config. **decision_changed_or_unlocked** Gate 2 passes for (revealed_target, Qwen3.8-27B-nothink). Gate 3 (CUDA-resident control core) is admitted by the contract; but Gate 4's question is already answerable in outline: relevant observations DO arrive during B→D (≈300 frames), and for this task they cannot change the correct action — only whether to act. A same-decision mechanism is therefore NOT warranted by this task (§17.8); it needs the moving target. **what_was_removed_or_deprioritized** The Anthropic/API controller path (deleted; local only). Thinking-on as the primary agent (too slow to sweep; kept as an optional second agent). **one_sentence_generalist_takeaway** A real local vision model takes about five seconds to find and click the square; when the square waits, it gets it right half the time, and when the square leaves in under five seconds it gets it right never — and the trace shows it had already seen the square vanish before it clicked. **evidence_for_that_takeaway** results/WI-002_qwen38_nothink.md; traces runs/wi002_qwen38_nothink/eval_w4000000000_s202_{paused,replay,live}.jsonl (a seed that is right in Paused/Replay and late in Live). **what_the_reader_should_not_infer** That Paused–Replay gaps never occur (this agent is deterministic and memoryless by construction); that 50% is this model's competence (n=10, border effects); anything about the physical D→A path (simulated 20 ms here). **remaining_uncertainty** Whether a faster agent (FP8, smaller image) shifts the Live transition as the timestamps predict; real-agent behaviour on the moving target; the physical delivery path. **next_admitted_work_item** WI-004: the same agent on moving_target (S2 on task C) and the FP8/speed variant as a second agent config to test agent ORDERING across Paused vs Live. --- ## WI-005 (part 1) — Skins are render-only; the agent's coordinate convention was an artifact — 2026-08-22 ```text work_item_id: WI-005 (card: cards/R1-skins.md) technical_output: scenario.skin ∈ {plain, notification, balloon} (RGB frames; render() only; oracle perceives by target colour); prompts v2–v6 (per skin; pixel vs 0–1000 grid); tests: 8 new closed-form cells on the skins (191 total). contract_status: Built; Contract-verified (U10: every closed-form prediction holds unchanged under notification and balloon skins); Measured: in progress (WI-005 part 2). ``` **Finding (pivotal, surfaced before acting).** In a 6-seed smoke test on the notification skin, the pixel-coordinate prompt (v2) produced 1/6 hits, but several "misses" were EXACT in Qwen-VL's native 0–1000 normalized convention (e.g. answered (333, 748) for a target at (214, 360) in a 640×480 image = (334, 750) normalized). With a prompt that asks for the 0–1000 grid (v4) the model was within ±2 grid units on 6/6. Re-reading the WI-002 plain-skin run: the "y-doubling" misses (seed 200: answered (125, 390) for target (80, 190) → normalized (125, 396)) and the `click outside canvas` rejection are the same phenomenon. **Decision.** Coordinate space is part of the agent's declared output grammar (prompt_version → `coordinate_space`, hashed into the controller spec). The skin runs use the 0–1000 prompts (v4 notification, v5 balloon), and the plain skin is re-run with v6 (0–1000) so that its competence figure is not an artifact of the convention. **Alternative rejected:** accepting either convention at parse time — that would be the controller repairing the action (§10), and it would make the agent's grammar ambiguous in the trace. **Consequences.** WI-002's competence numbers (0.80 calibration / 0.50 evaluation) are superseded as a competence estimate; they measured perception AND a convention mismatch. WI-002's timing conclusion stands unchanged (Paused = Replay; Live 0 at windows < 5.3 s, = Paused above): the mismatch affected the same seeds identically in all three conditions, which is exactly what the matched design is for. The "misses cluster near the border" observation is withdrawn until re-measured with v6 (near-border targets have small normalized coordinates, where pixel vs normalized answers happen to be close — the earlier reading was confounded). **one_sentence_generalist_takeaway** The model was often right in its own coordinate system and wrong in ours; asking the question in its system, not guessing afterwards, is the honest fix. --- ## WI-005 (part 2, measurement) — Qwen3.8-27B on the notification skin and the plain skin with the 0–1000 prompt — 2026-08-22 ```text technical_output: runs/wi005_notification_p4 (160 trials), runs/wi005_plain_p6 (160 trials); results/WI-005_qwen38_{notification_p4,plain_p6}.md; figures from real frames (site/figures/qwen_notification_*); site appendix "Qualitative Demonstrations". contract_status: Measured; Project-learning + Reader-ready (below). 0 invalid trials, 0 invalid pairs, 0 contract violations across 320 trials. ``` **result_observed** - plain, prompt v6 (0–1000 grid): competence 10/10; Paused 10/10, Replay 10/10 at every window; Live 0/10 at 1–4 s (late + outdated at commitment ×10) and 10/10 at 8–16 s; median B→D 5.24 s. - notification, prompt v4: competence 10/10; Paused 8/10; Replay 8/10 (1 s), 9/10 (2, 4 s), 10/10 (8, 16 s); Live 0/10 at 1–4 s and 10/10 at 8–16 s; median B→D 5.26 s. Seeds 201 and 206: the model answers `wait` on the single triggering frame → under Paused no further frame ever arrives (no action); under Replay/Live the countdown animation changes the frame, a second invocation is triggered (`wait` is short: ≈1.8 s), and the click commits at ≈7.8 s. **what_the_project_knows_now** 1. The WI-002 competence deficit was entirely the coordinate convention: with the grid stated, the same model is 10/10 on both skins. The Live transition is unchanged (≈5.3 s path). 2. A Paused–Replay gap exists for a deterministic, memoryless agent when the agent can decline to act and the scene animates: Paused gives it ONE frame, Replay gives it the Live stream. Paused is therefore not always the most lenient condition; the paper's "Paused provides the conventional step-by-step reference" should be read with this caveat. 3. B→D depends on the answer: `wait` (5 tokens) ≈1.8 s vs `click` (23 tokens) ≈5.3 s — the agent's own path length is action-dependent, which matters for predicting Live outcomes. 4. A skin is render-only (U10) and can make a result legible without changing it (U11 passed). **decision_changed_or_unlocked** WI-002's competence numbers are superseded (ledger above). The notification skin becomes the default presentation skin; plain remains the control. **one_sentence_generalist_takeaway** With its own coordinate system respected, the model clicks the right spot every time when the world waits — and still never in time when the card expires in under five seconds. **what_the_reader_should_not_infer** That the Paused–Replay gap is a perception effect: it is the agent choosing to wait and then getting (or not getting) another frame. **next_admitted_work_item** WI-004 (pending-action record on a multi-response task) — now with the `wait` behaviour as a known ingredient; FP8 speed variant as a second agent config. ## WI-004 (part 1) — Gate 4 decided from existing traces; late-binding mechanism built; a wall-clock harness artifact found and removed — 2026-08-22 ```text work_item_id: WI-004 (card: cards/C1-balloon-drift.md) technical_output: tracker.py (NCC template tracker: the separately identified binder); VLMLateBindingController with at_commit_policy ∈ {frozen, restart_if_moved, late_bind}; runner: Restart path (decision_restarted record, new decision id), binder cost charged to D in wall-clock mode; evaluator: binding tracked_at_D, frozen counterfactual at the same A (proposed_valid_at_receipt), n_restarts, first_b_to_d_ns, contract checks correction_record_incomplete / restarted-id-commits; stats.py (exact McNemar, template bootstrap, Wilson); tests/test_late_binding.py (10), tests/test_stats.py (3); 212 tests pass. contract_status: Built; Contract-verified; Measured: running (runs/wi004_qwen38_nothink, _think). ``` **Gate 4 decision (§17.8, §12.2), from WI-002/WI-005 traces, before any mechanism was built.** Qwen3.8-27B (thinking off): B→D median 5.2–5.3 s; 150–270 observations published during one B→D; in 60 % of Live decisions the target was visible at B and gone by D. On the STATIC revealed target the newer observations cannot change the correct action — the coordinate never moves, the window merely closes — so there B→D is controller computation time and B is a profiling stamp, nothing more. On the MOVING target the coordinate changes by v × 5.3 s during B→D (21 px at 4 px/s, 42 px at 8 px/s, against a 24-px target), the direct controller cannot consume it, and the proposed mechanism has one typed state (ProvisionalClick + template) and one update operation (track at D). **Admitted narrowly, for changing-coordinate tasks only.** Reader consequence: the paper may keep clock-decoupled control as a claim about tasks whose unresolved field changes during computation; it must not present B as a fifth clock. **Finding (harness artifact, surfaced before any result was read).** The first launch of the study re-stamped D for late_bind as `harness.now()` after binding. In wall-clock mode the harness publishes the frames that fell due during B→D lazily — rendering, hashing and writing ~300 payloads — BEFORE the binder runs, so "now" included ~1 s of harness catch-up that is not controller work. Frozen's D was stamped before that catch-up. The comparison was therefore biased against late_bind by ~1 s of extra drift (8–16 px at the velocities under test). **Decision:** D moves by the binder's own measured cost only (`perf_counter` around `correct_at_commit`, wall mode only — the simulated clock still never reads the wall clock; contract test 04 enforces it). The contaminated run (about 70 % of the no-thinking cells) was discarded and relaunched. **Alternative rejected:** keeping the re-stamp and "explaining" it in the results — the bias is a harness property, not a property of late binding. **Consequences:** none for WI-001–WI-005 (no correcting binding ran in wall-clock mode before this). The late-bind trace now records the tracker's cost explicitly (`track_ns`, median ≈ 60 ms on this machine), which the reader can see. **one_sentence_generalist_takeaway** Before the mechanism was allowed, the traces had to show that something relevant can change while the agent thinks — and they did, for a moving target only. --- ## WI-009 (part 1, oracle) — Pre-commit change: the target jumps before D — 2026-08-22 ```text work_item_id: WI-009 (card: cards/C2-balloon-jump.md) technical_output: scenario jump_target (jump_delay_ns, jump_dx/dy_px; event target_jumps = 4); tests/test_jump_target.py (9; closed-form labels, binding ordering, tie after A, predictor does not help, Replay=Live evidence with a jump, mock late-bind agent re-finds a 96-px jumped balloon); studies/wi009_jump_target.py (--oracle done; --agent queued behind the GPU chain); results/WI-009_jump_target_oracle.md. contract_status: Built; Contract-verified; Measured (oracle); agent cells queued. ``` **Result (oracle, simulated clock, 10 seeds/cell, bindings share B, D, A exactly).** Jump observed before D: state_at_B 0.00 (all 10 labelled `outdated_at_commitment`), newest_at_D 1.00, predicted_at_A 0.00, true_at_A 1.00. Jump in (D, A]: 0.00 for every non-oracle binding (all `invalidated_after_commitment`), true_at_A 1.00. Jump after A: all 1.00, no labels. **What this pins down.** (i) The evaluator separates "outdated at commitment" from "invalidated after commitment" and from "late" by construction; (ii) on a DISCRETE change the velocity extrapolator is worse than useless (it sees one frame of "motion" and overshoots) — prediction is a remedy for predictable change only, as H3.2 states; (iii) the only non-oracle remedy for a pre-commit jump is to read the newer state at D — which is the WI-004 mechanism. **one_sentence_generalist_takeaway** If the button moves before you commit, nothing you do after committing can help — you have to look again just before you commit. --- ## WI-004 (part 2, measurement) — Late binding with Qwen3.8-27B on the moving balloon: Gate 5 passes — 2026-08-22 ```text work_item_id: WI-004 (card: cards/C1-balloon-drift.md) technical_output: runs/wi004_qwen38_nothink (170 Live trials + 10 Paused calibration), analysis studies/analyze_wi004.py → results/WI-004_qwen38_nothink.md; figures site/figures/late_bind_v4_s303.{png,gif}, restart_vs_bind_v4_s303.png. contract_status: Measured (thinking off). Thinking-on subset running (runs/wi004_qwen38_think). ``` **Competence gate.** Paused, balloon skin, prompt 5, seeds 100..109: 10/10 (threshold 0.80). **Result (Live, 10 seeds per cell, window 16 s so lateness is not the failure).** | v (px/s) | frozen | restart_if_moved | late_bind | frozen counterfactual at the SAME A (from late_bind traces) | |---|---|---|---|---| | 0 | 1.00 | 1.00 | 1.00 | 1.00 | | 0 + irrelevant motion | 1.00 | — | 1.00 | 1.00 | | 4 | 0.00 | 0.00 | 1.00 | 0.00 | | 8 | 0.00 | 0.00 | 1.00 | 0.00 | | 16 | 0.00 | 0.00 | 1.00 | 0.00 | Same-deliberation pairs (frozen counterfactual vs late_bind; B, D, A shared exactly): at v = 4, 8, 16 px/s late_bind wins 10/10 pairs, exact McNemar p = 0.002 per velocity; at v = 0 and under irrelevant motion 0 discordant pairs (the binder changes nothing). The counterfactual agrees with an independent frozen run on every seed (40/40). Mean spatial error at A: frozen 22 / 43 / 84 px at 4 / 8 / 16 px/s (= v × 5.3 s, the model's own error is ~1.5 px); late_bind 2.0 / 2.5 / 3.4 px (drift during the 63-ms bind + 20-ms delivery + frame age). B→D: frozen 5.2 s, late_bind 5.3 s (tracker median 63 ms, max 72 ms, 0 no-match in 50 bindings). **Restart-after-update does not converge under continuous change.** With threshold 6 px and B→D 5.3 s the target has always moved > 6 px by D, so restart_if_moved restarts, deliberates again (another 5.3 s), finds it moved again, restarts again, and commits only when the balloon has left the window (first B→D ≈ 18.1 s; all 30 trials at v > 0 invalid and labelled late). The paper's sentence "restart-on-update is reported separately with its additional decision time" has its number: it costs two extra deliberations and still fails — the remedy and the problem run at the same speed. **Gate 5 (experiments.md §18) passes:** a new observation (B < t_O,new < D) changed the final concrete action under the same decision identifier without moving D or A later (D moved by the binder's 63 ms, which the trace records), and only where the unresolved field actually changed (negative controls inert). H7.2 is supported for a real agent on a changing coordinate. **Decision.** P13/P14 of the paper can be written as statements about an implemented controller (paper_additions/wi004_gate4.tex + wi004_result.tex). **Alternative rejected:** claiming the effect "for Chronotope" at large — this is ONE mechanism on ONE field (a coordinate) with a pixel-template binder; text fields and action-kind changes are outside it (S8 classes 3–4 remain). **Consequences.** WI-003's oracle ordering (true_at_A ≥ predicted ≥ newest_at_D ≥ state_at_B) now has its real-agent counterpart for newest-at-D vs state-at-B; prediction with a real agent is still untested (the tracker gives position, not velocity — a two-frame velocity estimate is a natural follow-on and is NOT claimed here). **one_sentence_generalist_takeaway** The model took five seconds to decide "click the balloon"; sliding the click to where the balloon is NOW, sixty milliseconds before committing, turned 0/10 into 10/10 at every speed tested — and re-thinking from scratch instead never caught up. --- ## WI-008 — Benchmark audit (S1.1/S1.2): 18 benchmarks + 1 method — 2026-08-22 ```text work_item_id: WI-008 (card: cards/benchmark-survey.md — written after launch; deviation noted) technical_output: results/WI-008_benchmark_audit.md (90 KB; 19-row summary table; per-benchmark evidence with verbatim quotes and URLs; patterns; unverified list). Produced by a background research agent from official sources only; no harness was run. contract_status: Measured (reading). Not a hypothesis test in the §17 sense; it is the evidence for H1.1/H1.2 that §4.1 promised. ``` **Result.** Of 18 benchmarks: 6 are static/offline (Mind2Web, GUI-World, ScreenSpot, ScreenSpot-Pro, OmniACT, VideoGUI); 8 run a live VM/browser/emulator that is never paused but with a step-synchronous harness and no task event scheduled during inference (OSWorld, WebArena, VisualWebArena, AndroidWorld, Mind2Web-Live, Windows Agent Arena, WebVoyager, AgentStudio) → 14/18 hold task-relevant state effectively fixed during computation. 2/18 are dynamic by design (DynaCU-Bench: JS timers, transient elements, "step boundaries are determined by model inference latency"; LivingScreen: video autoplay, verified in code). 2 unverified (DynamicGUIBench: harness unreleased; Online-Mind2Web: no agent loop). 0/18 stream observations into an in-progress decision. 5/18 record any wall-clock time, 4 of them as logging only; exactly 1 (DynaCU-Bench) measures and reports decision latency; none measures OS receipt or application-level arrival. 1/18 (DynaCU-Bench) lets the same action score differently purely by arriving later. 0/18 combine correctness and latency into one number. AAPT (Dong et al. 2026) is a method whose own testbed is deadline-scored (correct key ∧ before deadline) with a 30-FPS change gate. **Decision.** H1.1 and H1.2 are supported with the named exceptions; the §4.1 compact table and the App. C evidence can be written (paper_additions/wi008_audit.tex). The paper must name DynaCU-Bench and LivingScreen as the dynamic exceptions and AAPT as the deadline-scored testbed, and must not claim "no benchmark measures latency" (DynaCU-Bench does). **Caveats recorded by the agent (keep them in the appendix).** DynaCU sampling-window wording differs between paper and code; two timeout thresholds in its code; some code lines are fetcher paraphrases marked as such; OSWorld per-task getters not individually audited; several sources unreachable (listed in the file). **one_sentence_generalist_takeaway** Almost every GUI-agent leaderboard is scored with the world paused, so a slow right answer and a fast right answer get the same score — exactly the thing the paper says hides the problem. --- ## WI-006 (measurement) — Pending-action record with Qwen3.8-27B on the pending-effect task — 2026-08-22 ```text work_item_id: WI-006 (card: cards/P1-pending-button.md) technical_output: runs/wi006_qwen38_nothink (140 Live trials), studies/analyze_wi006.py → results/WI-006_qwen38_nothink.md; figures site/figures/wi006_live_d8_*.png, wi006_live_d2_*_drop_s400.png. contract_status: Measured (thinking off). 0 contract violations; all trials valid. ``` **Result (Live; effect delay {1,2,4,8} s × memory {none, harness_pending, model_informed}; 10 seeds).** First valid click: accepted in 10/10 everywhere, at E→A = 5.30 s for all three memories (max seed difference 0.04 s) — the record never delays the first action. Duplicates (a click received inside the button after acceptance and before the effect is visible) appear only at effect delay 8 s: memoryless 0.90/trial (9/10 trials), model_informed 0.30 (3/10), harness_pending 0.00 (0/10). Exact success (accepted ∧ no duplicate) at 8 s: none 0.10, model_informed 0.70, harness_pending 1.00; paired exact tests none vs harness_pending p = 0.004 (9/0 discordant), none vs model_informed p = 0.03 (6/0). At 1–4 s no duplicates arise for any memory — with B→D = 5.3 s the second decision cannot commit before the effect is visible — but the memoryless agent then clicks the DONE card (1.00 invalid clicks/trial at every delay; the card remains a "card", the prompt's trigger), which the pending record also removes (0.10) and the informed prompt reduces (0.30–0.40). Invocations per trial are equal across memories at a given delay (2.9 at 1–4 s; 3.8 at 8 s; model_informed 3.6–5.1 because it answers wait more often) — the record suppresses proposals, it does not skip invocations. **Cost of the record (dropped first click; effect delay 2 s; pending_timeout 10 s).** Memoryless retried at the next changed frame and was accepted in 9/10 trials at E→A = 10.7 s. harness_pending was accepted in 0/10: the record expired 10 s after D (≈ 16 s), the retry deliberated for 5.3 s more and committed after the 16-s window had closed. **Finding:** the pending timeout must exceed the effect delay (else the record expires and a duplicate follows — test_pending_effect.py shows it) AND leave window for a retry; 10 s satisfied the first and violated the second in a 16-s window. This is the honest price of suppression: it converts "duplicate on success" into "no retry on loss" unless the timeout is set from the task's effect delay and window — which the controller cannot know without the kind of task model the paper's P11 asks for. **Decision.** H6.1 supported: a memoryless frame-triggered controller repeats an action whose effect is pending (when its deliberation is shorter than the effect delay), the record removes the duplicates without delaying the first action, and telling the model helps only partly (0.70). The timeout trade-off goes into the paper as a limitation, not a footnote. **Alternative rejected:** hiding the dropped-click cell or re-running it with a "tuned" timeout — the predeclared value stays; a timeout sweep would be a new card. **one_sentence_generalist_takeaway** Remembering "I already pressed that" stops a forgetful agent from pressing again when the screen is slow to react — and, set carelessly, also stops it from pressing again when the first press was genuinely lost. --- ## WI-004 (part 3) — Thinking-on subset: evidence age 23–29 s, and what a 32-s window does — 2026-08-22 ```text technical_output: runs/wi004_qwen38_think (40 Live trials; v ∈ {4, 8} × {frozen, late_bind}; window 32 s); results/WI-004_qwen38_think.md. ``` **Result.** With thinking on (reasoning effort low, max 4096 tokens) the deliberation is bimodal: 23–29 s in 24/40 trials and 34–97 s in 16/40. Frozen: 0/10 at both velocities (mean error 98 / 200 px = v × ~25–38 s). late_bind: 7/10 at 4 px/s, 5/10 at 8 px/s; EVERY late_bind trial whose deliberation ended inside the 32-s window was valid (12/12, error 2.6 / 3.8 px) and every failure is labelled `late` (the window had closed before D; the binder then finds no balloon, reports no-match, and the proposal is committed). Paired: 7/0 (p = 0.016) and 5/0 (p = 0.06) in favour of late_bind; counterfactual == independent frozen run on 20/20 seeds. **Reading.** Late binding recovers drift of 25 s × v when the response is still possible; it cannot recover a window that closed during deliberation — that is the lateness failure of WI-002, unchanged by any binding. The first launch of this subset used the 16-s window and was stopped after 5 trials (all late by construction); the 32-s window was chosen from the earlier 24-s measurement, which the longer tail (up to 97 s) of this prompt/image exceeded in 40 % of trials. Both facts are recorded; the cells are not re-run with a longer window (that would be a new card, and the claim does not need it). --- ## WI-009 (part 2, agent) — Jump before D with Qwen3.8-27B; and an evaluator false flag found and fixed — 2026-08-22 ```text technical_output: runs/wi009_qwen38_nothink (50 Live trials), studies/analyze_wi009.py → results/WI-009_qwen38_nothink.md; evaluate.py fix + regression test (222 tests). contract_status: Measured. ``` **Finding (evaluator defect, surfaced before the result was read).** The agent run flagged `uncorrected_action_change` on every restart trial. Cause: the evaluator compared the committed action with the FIRST `action_proposed` of the trial, which belongs to the restarted decision, not to the committing one. **Decision:** compare with the proposal of the committing decision; regression test added (restart whose second proposal differs). **Consequences:** the same false flag was present on the 30 restart trials of WI-004 (thinking off); no number in any ledger entry or table depended on it (violations were not tabulated), and results/WI-004_qwen38_nothink.md is regenerated unchanged. No other trace or test was affected (the contract tests passed because their mock repeated the proposal). **Result (balloon jumps 96 px at 2 s after appearance, i.e. during the 5.3-s deliberation; 16-s window).** frozen 0/10 (9 labelled outdated_at_commitment, 1 model miss that fails at 14 s too; mean error 95 px ≈ the jump), late_bind 9/10 (error 2.8 px; the one failure is the same model-miss seed 502, 15 px), restart_if_moved 10/10 with exactly one restart each (the target does not move again, so the second deliberation lands; first B→D 11.6 s vs 5.3 s). Same-deliberation pairs frozen vs late_bind 9/0, p = 0.004; the counterfactual agrees with the independent frozen run on 20/20 seeds. Control (jump at 14 s, after A): frozen 9/10 = late_bind 9/10, counterfactual 9/10, 0 discordant. **Reading, together with WI-004.** Restart-after-update succeeds on a ONE-TIME change (WI-009) and fails on CONTINUOUS change (WI-004), at the price of one more deliberation either way; late binding succeeds on both at the price of ~63 ms. This is the paper's "which correction addresses which failure" with a real agent: the remedy that recomputes is bounded by the change rate, the remedy that re-binds is bounded only by what the binder can re-find. **one_sentence_generalist_takeaway** When the balloon jumps once while the agent is thinking, thinking again works (late by five seconds) and re-aiming works (late by a blink); when it keeps moving, only re-aiming does. --- ## WI-007 (part 1) — UI-TARS-1.5-7B under the shared JSON grammar fails the competence gate; its native grammar is the declared alternative — 2026-08-22 ```text work_item_id: WI-007 (card: cards/model-qualification.md, U21) technical_output: runs/wi007_ui_tars_1_5_7b_json_prl (Paused calibration, notification, prompt 2 = pixels, 10 seeds: 6/10 → STOP), runs/wi007_ui_tars_1_5_7b_json_wi004 (Paused calibration, balloon, prompt 5 = 0–1000 grid: 0/10 → STOP). prompt_version 7 = UI-TARS native grammar ("Thought/Action", click(point='x y') | wait(), absolute pixels of the Qwen2.5-VL smart-resized image, no structured output) implemented with parser, smart_resize mapping and 4 tests (226 total). studies/pipeline_agents2.sh: Qwen3-VL-8B-Instruct first (grid prompts 4/5 as the 27B), then UI-TARS with prompt 7. contract_status: gate recorded; native-grammar run queued. ``` **What happened.** The first pipeline ran the WI-002 protocol with the wi002 script's default notification prompt (2, pixel coordinates) — not prompt 4 (0–1000 grid) that the 27B run used; a pipeline defect, fixed in v2 by passing the prompt explicitly. Under that pixel prompt UI-TARS-1.5-7B answered correct pixel coordinates when it clicked (e.g. (265, 393) on the 640×480 image for a button centred at (264, 402)) but answered `wait` on 4/10 target frames → 0.60 < 0.80. On the balloon with the 0–1000 prompt it ignored the grid and answered pixels ((179, 264) for a true centre at (178, 264) in the image) → every click scored ~67 px off → 0/10. **This is the mirror image of WI-005's finding:** Qwen-VL models answer on a 0–1000 grid regardless of a pixel prompt; UI-TARS (Qwen2.5-VL-based, trained on absolute coordinates) answers pixels regardless of a grid prompt. The coordinate convention is a property of the model family and must be declared per agent; "matched action grammar" across agents is matched in meaning (click at x,y | wait), not surface syntax — as the card anticipated. **Decision.** Per the card's one declared alternative, UI-TARS is re-run with its native grammar (prompt 7), parsed by the controller and mapped through smart_resize; the JSON-grammar gate failures are reported in the competence table, not hidden. Qwen3-VL-8B-Instruct runs with the same grid prompts as the 27B (same family). **one_sentence_generalist_takeaway** Two model families literally speak different coordinate languages; asking each in its own language is the only fair comparison, and the trace says which language was used. --- ## WI-007 (part 2) — Qwen3-VL-8B-Instruct fails the competence gate under the family's own grid grammar — 2026-08-22 ```text technical_output: runs/wi007_qwen3_vl_8b_instruct_prl (Paused calibration, notification, prompt 4: 1/10 → STOP); runs/wi007_qwen3_vl_8b_instruct_wi004 (Paused calibration, balloon, prompt 5: 1/10 → STOP). contract_status: gate recorded; excluded from timing claims (§17.7); reported in the competence table. ``` **What happened.** With the same 0–1000-grid prompts and decoder settings as Qwen3.8-27B (which scored 10/10 and 10/10 on these calibrations), Qwen3-VL-8B-Instruct answered `wait` on about half of the frames that showed the target and, when it clicked, was 13–25 canvas px off (e.g. (416, 756) on the grid for a button centre at (412, 837): the right column, but the card's text above the button; on the balloon (200, 450) for (278, 550)). The answers are on the grid (no convention mismatch this time); the model is not precise enough on these synthetic renders at 640×480 to pass 0.80. Its B→D was ≈ 1.7 s — the fast small model the ordering hypothesis (H2-ordering) wanted — but a timing comparison on an agent that cannot do the task under Paused is exactly what §17.7 forbids. **Decision.** Reported as a competence-gate failure; no second prompt or image scale is tried for this model (the card allowed one alternative only for the grammar-mismatch case, which this is not). The cross-agent Paused/Live table will therefore have one general VLM that passes (27B) and, pending the native-grammar run, possibly the GUI specialist; the H2-ordering test needs a second competent agent and is recorded as not yet testable with the models on this machine. --- ## WI-007 (part 3) — UI-TARS-1.5-7B with its native grammar: precise when it clicks; passes the balloon gate, fails the notification gate — 2026-08-22 ```text technical_output: runs/wi007_ui_tars_1_5_7b_native64_prl (max_tokens 64: every answer truncated before "Action:" → 0/10; a budget defect, not a model result; kept for the record); runs/wi007_ui_tars_1_5_7b_native_prl (max_tokens 256; Paused calibration, notification, prompt 7: 3/10 → STOP); runs/wi007_ui_tars_1_5_7b_native_wi004 (Paused calibration, balloon, prompt 7: 9/10 → PASS; WI-004 subset running). contract_status: notification: gate failed (reported); balloon: gate passed; subset measuring. ``` **What happened.** With its own "Thought / Action" grammar and enough tokens, UI-TARS-1.5-7B's clicks map back exactly (e.g. `click(start_box='(266,397)')` in the 644×476 smart-resized frame → canvas (132, 200) for a button centred at (132, 201)). On the notification skin it nevertheless answered `wait()` on 7/10 target frames, each time with the same thought — "the page is still loading … wait for the page to finish loading" — i.e. it reads our minimal desktop mock-up as an unfinished page; on the balloon skin it clicked 9/10. Measured Paused B→D ≈ 6.2–7.1 s with 71–83 output tokens (the Thought text is paid for in time). **Decision.** Notification-skin studies (WI-002 protocol, WI-006 subset) for this agent are below the competence gate and are reported as such, not used for timing claims. The balloon-skin WI-004 subset (frozen vs late_bind, v ∈ {0, 8}) is admitted — the late-binding mechanism gets its second agent. The grammar/token finding is recorded with the first (64-token) run kept: a native-grammar agent needs a declared output budget large enough for its own format, and that budget is part of the controller spec. --- ## WI-007 (part 4) — Late binding with a second agent (UI-TARS-1.5-7B, native grammar, balloon) — 2026-08-22 ```text technical_output: runs/wi007_ui_tars_1_5_7b_native_wi004 (40 Live trials + 10 Paused calibration); results/WI-007_uitars_native_wi004.md. contract_status: Measured. 0 contract violations; all trials valid. ``` **Result (Live, 16-s window, balloon; frozen vs late_bind; 10 seeds).** v = 0: frozen 7/10, late_bind 7/10, 0 discordant (the binder changes nothing on a static target; the three misses are the agent's own aim, mean error 6.4 px, up to 15 px). v = 8 px/s: frozen 0/10 (mean error 51 px = 8 × 6.3 s), late_bind 6/10 (mean error 7.1 px); same-deliberation pairs 6/0 in favour of late_bind, exact McNemar p = 0.031; the counterfactual agrees with the independent frozen run on 20/20 seeds. B→D 6.2–6.3 s (Thought text); tracker 62 ms median, 0 no-match in 20 bindings. **Reading.** The mechanism transfers to a second agent and a different model family: it recovers the drift accumulated during deliberation on both, and on the less precise agent the recovered click inherits that agent's own aiming error (6–7 px), so its ceiling is the agent's Paused competence (0.70 here), not 1.00. The late-bound error (7.1 px) equals the agent's static error plus the ~80 ms of post-bind drift, exactly as on the 27B (2.0–3.4 px from 1.5 px). **Cross-agent status (H2-ordering).** Only Qwen3.8-27B passes the notification-skin competence gate (UI-TARS 0.30 native / 0.60 JSON; Qwen3-VL-8B 0.10), so the Paused-vs-Live ORDERING comparison across agents cannot be made on this machine's models; what can be said is that B→D differs by agent (27B 5.3 s, UI-TARS 6.2 s native / 2.0 s JSON, Qwen3-VL-8B 1.7 s) and that the Live transition window of each agent is its own B→D — the ordering claim is recorded as not testable here, not as false. **one_sentence_generalist_takeaway** A different model, a different way of speaking coordinates, the same result: re-aim just before you commit and the drift disappears — but re-aiming cannot make a model aim better than it does when nothing moves. --- ## WI-007 (part 5) — UI-TARS-1.5-7B on the pending-effect task (below the notification gate; recorded, not claimed) — 2026-08-22 ```text technical_output: runs/wi007_ui_tars_1_5_7b_native_wi006 (40 Live trials); results/WI-007_uitars_native_wi006.md. contract_status: Measured but below the competence gate for this skin (0.30 Paused); reported only as consistent. ``` **Result.** First click accepted in 5/10 per cell (the agent's notification competence); where it acted, the same pattern as the 27B: at effect delay 8 s the memoryless controller produced duplicates in 3/10 trials (0.30/trial) and the pending record none (0.00), with the first valid A unchanged (5.90 s); at 2 s no duplicates for either. Exact success at 8 s: none 0.20 vs record 0.50. Not used for a claim. --- ## Review-driven changes — naming, typed update path, controls, binder, 100-seed rule — 2026-08-23 ```text (naming map: NAMES.md — R1 revealed target, C0/C1/C2/C3 balloon drift (oracle)/drift/jump/select, P1 pending button, model qualification & replication, benchmark survey; WI-ids remain as cross-reference) technical_output: action_proposed{coordinate_status=provisional, proposal_time_ns=P}; coordinate_correction{binder_start/end_ns, translation_x/y, coordinate_status=resolved, binder_channels}; policy late_bind_or_restart (no match at D → new decision, never a kind change); contract tests: duplicate frame → translation (0,0); post-D frames never alter the committed click; action-kind change before D (late_bind commits the stale click, labelled late; late_bind_or_restart discards and the new decision answers wait); C3 balloon_select scenario (three balloons, one named by colour; RGB template) + 4 tests; tracker rewritten as FFT correlation + integral-image statistics (grey 5–17 ms, RGB 11–14 ms vs 60 ms / 225 ms before; identical matches; zero-variance windows excluded explicitly); study scripts take --seed-start/--n-seeds (rule: ≥ 100 per cited cell); chain5 runs C1, C2, C3, P1, R1 at 100 seeds. 233 tests pass. ``` **What the review got right about my reporting (recorded so it is not repeated).** (i) "same D plus 60 ms" was ambiguous: D is stamped after binding (D − P = 62–65 ms in every late-bind trace); the native comparison (frozen commits at P) and the matched-D/A comparison (proposed coordinate scored at the late-bind trial's A) are two comparisons and will be reported as two. (ii) The static and irrelevant-motion controls were reported as 10/10 vs 10/10; the trace shows corrected == proposed on all 20 (translation (0,0), NCC 1.00) — report the coordinate identity. (iii) UI-TARS's "≈6 px mean" explanation was wrong: its static errors are bimodal (7/10 within ±2 px; 3/10 at 13–15 px on one axis) and identical seed-for-seed under frozen and late_bind. (iv) "probability of that by chance" → "under the null that either method is equally likely to win a discordant pair, exact two-sided paired p = 0.00195" (UI-TARS: 6/0 with 4 ties, p = 0.03125). (v) Thinking mode: report 12/20 overall and 12/12 conditional with the label breakdown. (vi) The signed-error model holds: frozen −43/−43/−42/−41/−43 px measured vs −42.4/−42.7/−42.4/−40.7/−42.4 predicted; late_bind −1..−2 vs −1.0. **Binder change and its consequence.** C1's 100-seed run (already started) uses the sliding-window binder (~63 ms); C2/C3/P1 use the FFT binder (~13 ms). Both are recorded per trial (track_ns); results are not pooled across the two binder costs. --- ## WI-006 (interpretation) — Trace re-read: the 1–4 s invalid clicks are stale-evidence clicks, not Done-card clicks — 2026-08-23 ```text work_item_id: WI-006 (interpretation pass; no new runs) source: runs/wi006_qwen38_nothink/live_d{1,2,4,8}_{none,harness_pending,model_informed}_s40?.jsonl, src/chronotope/controller.py (PendingMemory.observe), src/chronotope/runner.py (admit_newest) ``` **Finding.** In every memoryless trial at 1–4 s the invalid click lands at ≈11.2 s and comes from decision 2, which BEGAN at ≈6.0 s on a frame that still showed the button (effect visible at 6.8/7.8/9.8 s). The model saw a button and decided on it; the evidence expired during the 5.3-s deliberation. Only s400's third click (and model_informed s401 at 13.3 s) is a genuine click on the Done card. The WI-006 entry's gloss "(the card remains a 'card', the prompt's trigger)" misattributes 9/10 — these are late-binding (stale-evidence) errors, the same failure mode WI-004 measures, inside the pending-effect trace. **Why the record "also removes" them.** PendingMemory.observe() runs only on admitted frames, and the runner admits only between decisions (frames during B→D are observation_superseded). So the record is still pending when decision 2 returns (pending_resolved at 11.3 s, after the 6.8-s effect) and suppresses the stale click because nothing had told it otherwise. With concurrent admission the record would resolve at 6.8 s and the stale click would commit. The remedy for that click is WI-004's at-commit re-check, not the record. Likewise at 8 s the record was cleared by TIMEOUT (pending_expired 16.8 s, 9/10), not by seeing the 13.8-s effect: expiry is checked at the next admit, before the pixel test. The 0-duplicate result stands (decisions 2 and 3 both suppressed while pending); the honest description is "suppressed for ≈ timeout + one deliberation". **The three-hat decision.** Decision 2 is identical in every cell: a duplicate at 8 s, a stale invalid click at 1–4 s, and the life-saving retry when the first delivery was dropped (memoryless accepted at 11.2 s, 9/10). The controller cannot tell them apart; PendingMemory is ack-blind by design (runner logs delivery_failed; the controller never sees it). That is P11 stated operationally. The drop-cell 0/10 is timeout (15.7 s) + one deliberation (5.3 s) = 21 s vs a 16.5-s window — intrinsic delay, window-made failure. **Runner note.** The episode outlives its end condition by one decision (end_h is checked only when ready_to_decide() is false), so a post-effect changed frame triggers one more ≈5-s decision; s400's 22.1-s clicks come from this. Inflates invalid_clicks slightly; does not touch duplicates or first-A. **Decision.** H6.1 and the 8-s result unchanged. Reword the 1–4 s sentence in paper_additions/wi006_result.tex and the WI-006 entry: "clicked the completed card" → "committed a click decided on a pre-effect frame after the effect had appeared (a stale-evidence click), which the record also suppressed — because, like the controller, it only looks between decisions". Present WI-004 + WI-006 as complementary remedies visible in one trace. **Alternatives rejected:** treating blocking-admission resolution as a bug to fix before reporting — it is a true property of this controller; describe it. **Consequences:** no numbers change; one explanatory sentence and its framing do. **one_sentence_generalist_takeaway** The second press is the same press whether it turns out to be a double-click, a click on something that already vanished, or the retry that saves the day — only the world knows which, and the record can't ask it. ## WI-006 (presentation) — Realistic re-skin for reader-facing figures — 2026-08-23 **Decision.** The hero figure and GIF for the pending-effect story now use an illustrative realistic skin (`realistic_frame` in site/make_figures.py: a mail client with an "Update ready / Restart now" notification) — same manifest geometry, same trace timestamps and clicks, redrawn pixels. The figure, its caption, and the GIF header all state that the model saw the schematic skin (kept below as the per-decision strips). **Alternative rejected:** re-running the study on a realistic skin — a new stimulus (WI-005's notification-gate qualification is tied to the schematic pixels), so a new card, not a cosmetic change. Silent replacement rejected for honesty. Files: wi006_story_d8_s400{,_real}.png, wi006_story_d8_s400{,_real}.gif; site rebuilt and pushed to the Space. ## C1 balloon drift — 100-seed principal cells (Qwen3.8-27B, thinking off) — 2026-08-23 ```text technical_output: runs/c1_qwen38_nothink_100 (100 calibration + 1400 Live trials, seeds 1000..1099, calibration 2000..2099); results/C1_qwen38_nothink_100.md. Old 63-ms binder throughout (run started before the FFT rewrite); track_ns recorded per trial. contract_status: Measured. 0 contract violations; all 1500 trials valid. ``` **Result.** Calibration 100/100. Live: v = 0 — frozen 99/100 = late_bind 99/100 = restart 99/100 (the misses are the model's own aim); +irrelevant motion — 97/100 each, 0 discordant seeds. v = 4/8/16 px/s — frozen 0/100 (mean error 20.9/41.7/82.1 px), restart 0/100 (exactly 2 restarts each, first-B→D ≈ 17.6 s, after the window), late_bind 100/100 (2.1/2.7/3.7 px). Same-deliberation pairs: late_bind wins 100/0 at each speed (exact two-sided paired p = 1.6e-30); counterfactual = independent frozen run on 300/300 seeds. Measurement model: mean residual (measured − v·(t_A − t_O,used)) between −0.2 and −1.3 px, max |residual| 4.1 px across all 600 measured trials. Controls: translation (0,0) on 100/100 static trials; 99/100 under irrelevant motion — the exception (seed 1079) is a trial where the MODEL missed the balloon entirely, the background patch around its wrong proposal matched an identical background texture 17 px away (NCC 1.0), and both the proposed and bound clicks miss (no outcome change; no discordance). Binder: 500 bindings, 3 no-match (all on model-miss flat patches), median 61 ms. **Reading.** The pilot's conclusions survive 10× the seeds unchanged, with two honest footnotes the pilot could not see: (i) the agent itself misses ~1–3 % of still balloons (the mechanism's ceiling is the agent, visible only at n = 100); (ii) a template cut around a WRONG proposal on undistinctive background can match a look-alike elsewhere — binding preserves wrongness, sometimes at a different wrong place; it never converted a miss into a hit (0 discordant control seeds). --- ## C2 balloon jump — 100-seed cells (Qwen3.8-27B, thinking off) — 2026-08-23 ```text technical_output: runs/c2_qwen38_nothink_100 (500 Live trials, seeds 1000..1099); results/C2_qwen38_nothink_100.md. contract_status: Measured. 0 contract violations. ``` **Result.** Jump (96 px) at 2 s, during the ~5.1-s deliberation: frozen 0/100 (100× outdated_at_commitment; mean error 97 px ≈ the jump), late_bind 100/100 (2.0 px), restart 99/100 with exactly one restart per trial (first-B→D 11.2 s; the one failure is a model aim/semantic error). Same-deliberation pairs 100/0, exact p = 1.6e-30; counterfactual = independent frozen run 200/200. Control (jump at 14 s, after A): frozen = late_bind = 100/100, 0 discordant. The pilot's reading is unchanged at 10× the seeds: a one-time change is where restart converges (at the price of one extra deliberation); late binding matches it at the price of ~63 ms. --- ## C2 balloon jump — 100-seed cells (Qwen3.8-27B, thinking off) — 2026-08-23 ```text technical_output: runs/c2_qwen38_nothink_100 (500 Live trials, seeds 1000..1099); results/C2_qwen38_nothink_100.md. contract_status: Measured. 0 contract violations. ``` **Result.** Jump (96 px) at 2 s, during the ~5.1-s deliberation: frozen 0/100 (all labelled outdated at commitment; mean error 97 px), late_bind 100/100 (2.0 px), restart 99/100 with exactly one restart per trial (first-B→D 11.2 s; the one failure is a model miss). Paired: late_bind vs frozen-counterfactual 100/0, exact p = 1.6e-30; counterfactual = independent frozen run on 100/100. Control (jump at 14 s, after A): 100/100 for every policy, 0 discordant. Confirms the pilot and the regime statement: a one-time change is where recomputation converges (at the cost of one extra deliberation), and late binding matches it at the cost of 63 ms. --- ## C1 main-paper figure — 2026-08-23 ```text technical_output: figures/c1_main.{pdf,png} via studies/fig_c1_paper.py; paper.tex fig:c1-balloon. contract_status: Rendering of existing measured results; no new trials. ``` **What.** Single-screenshot main figure for C1 (per "few screenshots" readability constraint): (a) screen at A for held-out episode v=16 s1043 — frozen proposal (miss by 84 px) vs late-bound click (hit) from the same decision, same B/D/A; (b) valid-at-A vs speed for frozen / restart / late_bind, recomputed from runs/c1_qwen38_nothink_100 traces (matches results/C1_qwen38_nothink_100.md). Conclusion stated in the caption: with matched boundaries the miss is a clock property, not a perception property, repaired within the same decision. Panel (b) numbers are derived from the run directory at render time, so the figure regenerates if the study reruns. --- ## C1 figures v2: two-figure story — 2026-08-23 ```text technical_output: figures/c1_task.{pdf,png}, c1_results.{pdf,png} via studies/fig_c1_story.py; paper.tex fig:c1-task (protocol) + fig:c1-results (results). contract_status: Rendering of existing measured results; no new trials. ``` **What.** Supersedes c1_main (single dense figure — user: information dense, impossible to understand). Split into (1) task figure: timeline B/D/A over two frames of episode v=16 s1043 — what the model saw vs where its stale click lands (miss by 84 px); (2) findings figure: strategy schematics (frozen / restart / late_bind), hit rate vs speed, and time-to-commit bars (5.1 / 5.1 / 17.6 s, computed from traces pooled over v>0). c1_main.* and studies/fig_c1_paper.py kept on disk but no longer referenced by paper.tex. --- ## C3 balloon select — 100-seed cells (Qwen3.8-27B, thinking off) — 2026-08-23 ```text technical_output: runs/c3_qwen38_nothink_100 (100 Paused calibration + 300 Live trials, seeds 1000..1099, named colour cycling red/blue/yellow; distractors at similar speeds, one opposite); RESULTS.md in the run dir. FFT RGB binder (~13 ms). contract_status: Measured. Gate 100/100 (named balloon picked every time, never a distractor). ``` **Result (Live, target at 8 px/s, crossing distractors).** The model picked the NAMED balloon on the frame at B in 100/100 late_bind trials (and 100/100 frozen). frozen 0/100 — and instructively, 2 of those 100 stale clicks landed on a CROSSING DISTRACTOR that had moved into the old position (staleness converted a correct choice into a wrong-object click); 98 hit empty sky. late_bind 99/100: the RGB template followed the chosen balloon through the crossings (the 1 failure clicked no balloon). restart 0/100 (1.9 restarts, then too late). Frozen counterfactual at the same A: 0/100; wrong picks at B: none occurred at n = 100 (the "wrong pick stays wrong after binding" branch is exercised by the contract tests, not by this model, which never mis-picked). **Reading.** The separation the reviewer asked for holds: semantic choice (which balloon) is entirely the model's — it never erred here — and coordinate currency (where it is now) is entirely the binder's; the binder recovered 99/100 of correct choices and had no wrong choices to launder. The two distractor hits under frozen are a small new failure mode worth a sentence in the paper: an aged coordinate does not just miss — on a busy screen it can hit the WRONG thing. --- ## C3 balloon select — 100-seed cells (Qwen3.8-27B, thinking off) — 2026-08-23 ```text technical_output: runs/c3_qwen38_nothink_100 (100 calibration + 300 Live trials); RESULTS.md in the run dir. contract_status: Measured. Calibration 100/100 with picks {named 100, distractor 0, none 0}. ``` **Result (three balloons, one named by colour, target at 8 px/s, distractors crossing).** The model's semantic choice is perfect at B (picked the named balloon 100/100 in every same-decision trial). frozen 0/100 — and in 2/100 trials the stale click landed on a CROSSING DISTRACTOR: staleness masquerading as a wrong-target error, indistinguishable from a semantic mistake without the four-clock trace. late_bind 99/100 (the 1 failure clicked empty sky; frozen counterfactual 0/100). restart_if_moved 0/100: with the target drifting continuously it restarted ~1.9× and committed only when the balloons were gone (its pick-at-B metric is not meaningful for restarted decisions and is reported only for the same-decision policies). **Separation shown:** the binder recovered 99/100 of RIGHT picks and rescued 0 wrong picks — though this model produced no wrong picks to rescue, so that branch is exercised by the contract test (mock) and, prospectively, by a less accurate agent. The task's calibration also retires the "a tracker alone solves it" objection: choosing WHICH balloon was the model's doing, 100/100. --- ## Gym outcome contract — (Y_g, G_g) on every terminal trace; deadline curve; trial-level D→A — 2026-08-23 ```text work_item_id: gym-outcome-contract (card: cards/gym-outcome-contract.md; from Tom's review) technical_output: evaluate.TrialResult.return_G via manifest hooks return_on_receipt(t_A, action) / return_no_receipt() (Task C family: G = -min(e_click at A, display diagonal), no receipt → -e_max); summarize() adds mean_G and REFUSES a valid trace without G; stats.success_by_deadline() (strict <, matching the evaluator's late rule); delivery spec block is now by-kind with route simulated_seeded_jitter {delivery_delay_min_ns, delivery_delay_max_ns, delivery_seed} (existing kinds byte-identical); tests/test_gym_tasks.py (267 tests total pass). contract_status: Built; Contract-verified; Measured (closed form, inside the A1/B1 studies below). ``` **what_was_uncertain_before** U22 (is G definable from the manifest alone and never undefined on a valid terminal trace), U23 (does the post-hoc deadline curve equal the per-window sweep for a window-insensitive controller), U24 (does a seeded per-trial jitter route reproduce, stay in bounds, and follow the WI-003 delay–value relation). **result_observed** U22 yes — hand cases pass: a LATE click on a static target scores Y = 0 with G = 0.0 (perfect geometry, missed window: the pair separates timeliness from geometry exactly as paper §4.1 specifies); dropped delivery and no-commit terminals get -e_max / task no-receipt values, never None. U23 yes — F(w) from one generous-window oracle run equals the direct window-w run for every tested (w, compute) cell. U24 yes — same delivery_seed reproduces D→A exactly, bounds hold, static target unchanged (negative control), moving-target error = v · I_A within rounding. **what_the_project_knows_now** 1. The outcome pair is computable from existing trace records only — no new boundary, no schema change; the contract is enforced at summarize() time, so a study cannot silently cite SR alone. 2. The deadline-curve caveat is real and stated in code: agents that read the rendered countdown must be swept window by window; the post-hoc curve is exact only for the oracle track. 3. G is NOT a latency penalty: equal-latency trials can differ in G and different-latency trials can tie (static-target jitter control) — Tom's interpretation 2, not interpretation 1. **decision_changed_or_unlocked** Every future gym table cites (SR, mean G). The H4.2 software half is now runnable (see B1 below for the first measurement). **one_sentence_generalist_takeaway** Every episode now answers two questions — did it work when it landed, and what was it worth when it landed — and "nothing ever landed" has a price too. --- ## A1 sponsor skip (oracle) — paper Task A enters the gym — 2026-08-23 ```text work_item_id: A1 (card: cards/A1-sponsor-skip.md) technical_output: scenario.SponsorSkipManifest (skin "player"; sponsor segment = response window; seek_delay_ns; G_A = -(sponsor seconds watched), full window on no valid skip); studies/a1_sponsor_skip.py; results/A1_sponsor_skip_oracle.md (100 seeds/cell, 8 cells, 800 triplets). contract_status: Built; Contract-verified; Measured (oracle). 0 closed-form mismatches, 0 invalid pairs, 0 contract violations. ``` **result_observed** Live G_A tracks the path exactly: -0.55 s at 0.5 s compute → -5.0 s (full sponsor) once the path exceeds the window, with `late` + `outdated_at_commitment` on every too-slow trial; Paused/Replay pin G_A at ≈ -(seek delay) regardless of compute. Two cells worth remembering: (i) compute 4 s + seek 1 s is a VALID skip that still watches the whole sponsor (SR 1.00, G -5.0) — the graded return sees what the binary cannot; (ii) seek ≥ window makes a timely skip worthless — the seek delay is watched time, priced. **what_the_project_knows_now** The timing-isolation track (Tom's "no other reason to fail") has its canonical task: the correct action is known before E, so with the oracle every reward loss in this environment is timing by construction. The success-by-deadline curve F(w) is implemented and equals the sweep here. **what_the_reader_should_not_infer** Anything about models on the player skin (no qualification gate run yet); anything about the multi-skip pending-effect variant (P1's mechanics, not built here). **next_admitted_work_item** Player-skin model qualification (prompt + gate), then A1 agent window sweep = the paper's first-skip study. --- ## B1 live trading (oracle) — paper Task B enters the gym; H4.2's software half measured — 2026-08-23 ```text work_item_id: B1 (card: cards/B1-live-trading.md) technical_output: scenario.LiveTradingManifest (skin "chart"; armed order button = signal validity; event 5 signal_reverses; predeclared u_valid/u_invalid/u_no_order, spec-hashed floats); studies/b1_live_trading.py; results/B1_live_trading_oracle.md (100 seeds/cell, 7 cells). contract_status: Built; Contract-verified; Measured (oracle). 0 closed-form mismatches, 0 invalid pairs, 0 contract violations. ``` **result_observed** The three reversal regimes land exactly on the intended labels at 100/100 each: before D → outdated_at_commitment (u_invalid, window wide open — NOT late); in (D, A] → invalidated_after_commitment; after A → harmless (u_valid). Delivery alone flips the same committed order: 0 ms → +1.00, 60 ms → -1.00 (A crosses the 750 ms reversal). Seeded jitter D→A ~ U[0, 40] ms with the reversal at D + 20 ms: 44/100 valid vs 56/100 invalid with IDENTICAL E, O, D, and action — per-trial consistency with A = D + δ 100/100. **what_the_project_knows_now** 1. The evaluator's timing labels, proven for geometric validity in WI-009, hold for SEMANTIC validity unchanged — no geometry involved, and the same three-way partition falls out. 2. H4.2 both ways in software: under a fixed route A = D + c is exact and A is derived; under a jittered route no fixed offset reproduces the outcomes and A must stay a measured boundary. The physical question is now purely "which kind of route is the real input path?". 3. WI-004's binder is out of scope here by design: the open field IS the decision (order or not), so B1 is the task where "newest state at D" and earlier receipt are the only remedies — the semantic column of the remedy matrix. **what_the_reader_should_not_infer** Any financial claim (the rule is evaluator-defined); that ±1 utilities are the final ones (predeclared per study; only orderings carry claims); model competence on the chart skin. **next_admitted_work_item** Chart-skin model qualification, then B1 agent cells (pre-D reversal is the semantic late-binding boundary: the agent must DECLINE, not re-aim). ## O1 — Oracle remedy matrix: the diagonal holds exactly; and the paper's open tables resolved — 2026-08-23 (evening) ```text work_item_id: O1 (card: cards/O1-remedy-matrix.md, written before the study) technical_output: studies/o1_remedy_matrix.py; runs/o1_remedy_matrix (3 600 oracle trials, seeds 1000..1099); results/O1_remedy_matrix.md; studies/paper_tables.py (derives tab:results-balloon and tab:results-paired rows from run directories); paper.tex: tables results-interventions, results-balloon, results-paired filled; WI-006/WI-007/WI-008 staged blocks inserted with % ADDED markers (WI-006 with the 2026-08-23 stale-evidence rewording); cards/PHY-physical-path.md. contract_status: O1 Built; Contract-verified (baseline labels 100/100 per column; static control 100/100 under every remedy; 0 invalid trials); Measured. ``` **Result (O1).** The predeclared matrix is exact at 100 seeds/cell: each single remedy fixes only its own failure class (100/100 on the diagonal, 0/100 off it), the combined variant (motion + closing window) is fixed only by earlier receipt AND prediction together, and every baseline column carries exactly its predicted S5.2 label. Off-diagonal returns match the card's arithmetic (e.g. newest-at-D on post-D leaves −17 px ≈ v·(PUB+DEL+frame age); prediction on the pre-D jump gives −8.7 px — worse than doing nothing better, the WI-009 overshoot at scale). **Decision (next-decision buffer row).** Filled per the C1 card's predeclared U12: in a one-response episode the buffer coincides with the initial coordinate by construction; the paper row states the identity with a dagger instead of burning 400 GPU trials on a definitional equality. **Alternative rejected:** a small verification run — the card says "stated, not run", and the pre-registration wins. **Decision (tab:results-paired).** Restructured around what is measured: R1 notification per-window PRL rows for the one gate-passing agent (10-seed now; regenerate from runs/r1_qwen38_notification_100 via studies/paper_tables.py when chain5 finishes), competence-gate failures in the caption, Tasks A/B moved to the physical track. Sponsor-skip/trading rows describing unbuilt studies are gone. **Finding (physical track, from the read-only audit of personalgui-accel-setup-old).** The old rig never measured a one-way latency: every one-way number in it is an assumed constant; only same-clock round trips exist (its own docs propose 240-fps phone filming as ground truth — never done). Sound and reusable: the single-clock architecture (agent-machine CLOCK_MONOTONIC + on-screen flash anchor), the V4L2 capture path with kernel timestamps and verified clock identity, the hardened KMBox driver, the camera-loopback calibration technique. Not reusable: every latency benchmark (interval mislabelled as latency; the R17 mismatched-probe pattern), the core scorer (two retracted metrics still live in windows.py, patched only downstream), and the War Thunder environment (mission-authoring debt; verdict read by the model under evaluation). **Decision:** cards/PHY-physical-path.md predeclares the measurement design (instrumented target page: frame counter for E→O, input-echo flip for D→A; a declared minimal relaxation of "unmodified target") and five contract checks including a known-delay recovery test. War Thunder is out of the near-term plan; its transfer row stays not-run. **Consequences:** the physical and transfer tables remain TBD pending the rig — annotated in paper.tex with pointers to the card, not silently. **one_sentence_generalist_takeaway** Four ways a slow click can go wrong, four different fixes — and the oracle matrix shows each fix repairs exactly its own failure and no other, which is the license for the paper's claim that the trace's failure label tells you which remedy to reach for. **next_admitted_work_item** P1/R1 100-seed table regeneration (chain5, in flight); PHY build per its card after the queue drains. --- ## Paper figures and appendix from existing runs — 2026-08-24 ```text work_item_id: PAPER-FIG-1 (no new GPU runs; one deterministic oracle regeneration) technical_output: studies/fig_paper_additions.py; figures/{c1_error_law,o1_remedy_matrix,b1_jitter, b1_regimes,r1_window_curve,wi004_think_strip}.png; paper.tex (main: fig:o1-matrix, fig:c1-error-law, results:jitter + fig:b1-jitter, tab:results-paired at 100 seeds; appendix:extra-results, appendix:audit, appendix:pending) sources: runs/c1_qwen38_nothink_100, runs/c1_qwen38_lb_v12_100 (v=1,2), runs/c1b_qwen38_tau6_100, runs/r1_qwen38_notification_100, runs/wi004_qwen38_think, results/O1_remedy_matrix.md, results/B1_live_trading_oracle.md, results/A1_sponsor_skip_oracle.md, results/WI-006_qwen38_nothink.md, results/WI-008_benchmark_audit.md ``` **What changed in the paper.** Three figures enter the main text, each converting a sentence into a measured relation: (1) miss-vs-travel scatter over 500 paired C1 decisions — initial-coordinate error sits on the identity line (median residual +0.6 px; 95 % within [−0.9, +2.1] px), late-bound error median 2.2 px, max 6.0 px; (2) the O1 remedy matrix as a heatmap, placed directly under tab:gym-diagnostics so the table reads as a result; (3) the B1 seeded-jitter histogram (44/100 vs 56/100 split exactly at the 20-ms reversal) as a new §5.5, which answers the paper's own fourth limitation. tab:results-paired now reports the 100-seed R1 run (0/100 at 1, 2, 4 s; 100/100 at 8, 16 s; B→D 5.11–5.27 s over 500 Live trials) instead of the 10-seed pilot. Appendix "Additional Results" holds the window curve, B1 regimes timeline + table, A1 sponsor table, slow-speed C1 table, thinking-on strip, and the WI-006 pending-action paragraph (with the 2026-08-23 stale-evidence rewording); "Benchmark Audit" holds the WI-008 table. Intro now cites the audit. **Finding (slow speeds, from runs already on disk).** At 1 and 2 px/s the initial coordinate hits 100/100 (travel 5–11 px < 12-px half-width) — late binding is neutral there. Restart-on-update at 2 px/s scores 0/100 where doing nothing scores 100/100: the movement detector fires on harmless motion and every replacement call is outrun. **Decision:** reported as tab:slow-speeds with the reading "a motion-triggered remedy can be worse than none". **Alternatives rejected:** omitting the slow cells (they fence the claim honestly). **Consequences:** none of the existing numbers change. **Not done / caveats.** No LaTeX toolchain on this machine (no pdflatex; iclr2027_conference.sty and math_commands.tex absent), so paper.tex was checked only for balanced environments, resolvable \ref/\label pairs, and existing figure files — not compiled. figures/c1_result_v1.png reference was a pre-existing typo, corrected to c1_results_v1.png. Figure palette kept at the paper's existing amber/green/red/gray for cross-figure consistency (validator unavailable: no node). **one_sentence_generalist_takeaway** The paper's three central claims — the miss is the travel, each timing failure has one cure, and delivery alone can flip a score — are now each one picture drawn from data that was already on disk. --- ## Paper gap-fill from existing runs — every measured cell now cited, tabled, or drawn — 2026-08-24 (afternoon) ```text work_item_id: PAPER-FIG-2 (no new GPU runs) technical_output: results/{P1_qwen38_nothink_100, C3_qwen38_nothink_100, C1_slow_speeds_restart_threshold_100, R1_qwen38_notification_100, WI-010_calendar_pilot, model_qualification}.md; studies/fig_paper_additions2.py; figures/{c3_distractor, wi001_label_phases, p1_delay, o1_return_matrix}.png; paper main.tex (compiled with latexmk: 27 pages, 0 errors); stale figures c1_task/c1_results/c1_main.png removed; site rebuilt and uploaded. sources: runs/p1_qwen38_nothink_100, runs/c3_qwen38_nothink_100, runs/c1b_qwen38_tau{6,12}_100, runs/c1_qwen38_lb_v12_100, runs/r1_qwen38_notification_100, runs/wi010_qwen38_nothink, results/WI-001_oracle_sweep.txt, results/WI-003_moving_target.md, results/O1_remedy_matrix.md, results/A1_sponsor_skip_oracle.md, results/WI-007_*.md, LEDGER WI-007 parts 1–5. ``` **What was missing (audit of main.tex vs results/ and runs/).** (1) P1 pending button was cited at pilot scale (10 seeds) although the 100-seed run had finished; (2) C3 had a paragraph but no table, figure, or results file; (3) four cited cells (R1-100, C1 v=1,2, C1b restart thresholds) had no `results/` provenance file; (4) the C1b restart-threshold regime (τ = 6 vs 12) was measured and unreported; (5) WI-003's four-binding oracle and predictor delay-misestimate sweep, WI-001's label phase diagram, A1's F(w) curve, and O1's return matrix were computed and undrawn; (6) the model-qualification failures (Qwen3-VL-8B, UI-TARS ×4 configs) were the reason the cross-agent comparison is "open" but were nowhere in the paper; (7) UI-TARS's v = 0 control and pending-task run were unmentioned; (8) WI-010's calendar-skin pilot had no results file or ledger entry. **What changed in the paper.** Main text: C3 gains tab:results-c3 and fig:c3-distractor (seed 1010: initial coordinate lands on the crossing red balloon, late-bound click hits yellow); binder diagnostics sentence in C1 (497/500 matches, 61 ms median; zero translation on 100/100 static, 99/100 irrelevant-motion controls); UI-TARS static control (7/10 = 7/10, 0 discordant); O1 return pointer; B1 D→A range; limitations now say WHY the cross-agent comparison is open. Appendix: pending-effect subsection at 100 seeds (d8: 0.95 / 0.32 / 0.00 duplicates; exact success 0.05 / 0.68 / 1.00; none-vs-record 95/0, p < 1e-28; drop-first 95/100 at 10.5 s vs 0/100) + fig:p1-delay + the calendar pilot sentence; tab:slow-speeds gains the τ = 12 column and the restart-threshold reading; three new subsections (receipt-state prediction with fig:bindings + tab:bindings; label phases with fig:label-phases; remedy matrix as return with fig:o1-return); A1 F(w) sentence; new Appendix "Agent Qualification" with tab:qualification (10 configurations). **Finding (C1b, from runs already on disk).** Restart-on-update succeeds exactly where the initial coordinate succeeds and fails exactly where its detector fires (v·T > τ): τ = 12 rescues 2 px/s (0/100 → 100/100) by making restart the same controller as frozen; 4 px/s is 0/100 under both. **Decision:** reported as the extended tab:slow-speeds; the reading "the threshold chooses where the failure begins; it cannot make re-decision outrun the target". **Alternatives rejected:** a separate figure (two numbers per row suffice). **Consequences:** none of the main-text numbers change (main text keeps τ = 6). **Finding (WI-010 pilot, recorded).** Calendar skin: gate 10/10; memoryless duplicate at d8 in 10/10 trials (1.00/trial), first A 5.20 s. Reported as a pilot sentence only; the record arm and 100 seeds are not run. **Not done.** WI-010 harness_pending arm and 100-seed cells (GPU); PHY physical path (not built); cross-agent P/R/L ordering (needs a second agent that passes the notification gate — none of the three on this machine). **one_sentence_generalist_takeaway** Everything the GPU had already measured is now in the paper as a number with a file behind it; what remains open is open because it has not been run, not because it was left in a run directory.