authored/screen_names.json export_archives gains dat/GP_OPTIONS.pak, alone.
Adding all four candidate archives at once would land 139 new screens together
and make any regression unattributable.
Result: 14 screen builds, 30-41 sprites each, ZERO missing sprites, 434 PNGs.
All 30 screens (16 title + 14 options) validate against sylpheed.screen/3, and
export/screens/title is BYTE-IDENTICAL to before -- the addition disturbed
nothing existing.
And they render. build_04 is the real CONTROL SETTINGS screen: 43 elements,
1280x720, title, ten labelled rows and the button legend, every sprite resolving.
Element ids carry a po_ prefix, so these are the options builds and not a
coincidence of the detector.
⚠️ One element, po_pad_slider1, has no sprite in the export and is reported as
NOT DRAWN rather than silently skipped.
⚠️ Screens are unnamed (build_NN by entry index) and OPTIONS is not yet reachable
from the menu -- ptbtn04 still has goto=null. Naming and wiring are the next
units, deliberately separate from making the screens exist.
crates/sylpheed-export read dat/GP_TITLE.pak and nothing else. authored/flow.json
records LOAD GAME, TUTORIAL, OPTIONS and NEW GAME's difficulty chain as MEASURED
destinations that are blocked because 'not a GP_TITLE build, so there is no
screen file to go to'. The blocker was neither the disc nor the reader --
examples/probe_archives.rs finds screen builds in 24 archives using the EXISTING
detector -- it was that constant.
The list now comes from authored/screen_names.json export_archives, whose
'archives' map was ALREADY keyed by archive path. Absent, it defaults to
dat/GP_TITLE.pak, so an old authored tree exports what it always did.
Sprite groups are mapped per archive rather than derived from the filename:
sprites live at sprites/<group>/<screen>/, unnamed builds are named build_NN by
entry index which restarts at 0 in every archive, so two archives sharing a group
would collide. An unmapped archive is rejected rather than given a directory a
typo could invent.
NO BEHAVIOUR CHANGE, and verified as such before anything is added: exported to a
separate tree with the current authored data and diffed -- export/screens and
export-probe/screens are IDENTICAL, manifest screen list identical.
The archive list itself is unchanged in this commit. Adding one is next, and
separately, so any regression is attributable to the archive rather than to the
refactor.
Probed with the EXISTING build detector -- no new decoding. 24 disc archives
contain UI screen builds; the exporter reads one (dat/GP_TITLE.pak, hardcoded).
GP_OPTIONS has 14 builds, GP_SAVE_LOAD 18, GP_DIALOG 105, GP_TUTORIAL 2.
So LOAD GAME, TUTORIAL, OPTIONS and the NEW GAME difficulty chain are not blocked
on the Decoder and need no format work. They are an exporter scope limit, and the
exporter is the port's.
Prioritised by the filter adopted after the plate: 'if this is wrong, what does a
player experience?' Four dead menu entries beat an audio level, which beats
timing minutiae.
Flagged as NOT established: that the screens render (is_build says the record
parses, not that sprites resolve or names are known), which GP_DIALOG entry is
the difficulty dialog, and that more screens are free -- every one joins
check-all's per-screen comparisons and needs a naming decision.
Next unit widens to GP_OPTIONS only. Not all four: 139 new screens at once would
make any regression unattributable.
The pulse has been implemented since 2026-08-30: authored/timing.json
looping_focus_records maps press_start/ptbtn00 -> ptbtn00f at period_units 120,
kind measured. The Decoder's independent figures (120 units, peak 80, ~51 of 60
frames) match the declared record on all three counts.
Verified rather than argued: 502 samples from a filmed boot folded onto the
declared 120-unit period reproduce the declared curve under ONE solved gain --
4.2% rms, with the flat top (phases 36-47, the alpha-80 plateau) and the flat
zero (108-119) both landing where declared. A sine of the same period fits 5.7x
worse, so it is the declared SHAPE and not just the period.
🔴 How I got it wrong: I measured 'does it return to dark'. It never does, BY
DESIGN -- the pulse is an additive glow over a base held at 255. I recorded an
11.6% ripple at a ~120-unit period, which WAS the pulse at exactly its declared
period, and attributed it to background leaking through my glyph mask.
I tested a property the feature was never supposed to have, and the authored
entry said so in its own words before I started. I read the disc's ptbtn00
keyframes, saw 244:0, and never read the port's own configuration for the element
I was measuring.
No code change. The arrival half of the page stands.
check-all's guard printed 'rm -f /tmp/.X11-unix/X<n>' and nothing else. Removing
only the socket leaves /tmp/.X<n>-lock behind; Xvfb then exits 1 immediately and
the next command still reports no display, which reads as the restart having
failed for a deeper reason rather than as an incomplete recipe.
Hit three times across this project, each time following the printed recipe. The
fix was visible in Xvfb's own stderr the whole time and nobody had read it --
the guard was written to save exactly that step, so an incomplete guard is worse
than none here.
I had this in the code as 'bounded, not pinned ... if the game snaps elsewhere in
the window, move this line'. That framed a live loose end. There is none.
The Decoder tightened the window to [160,238) and, more usefully, showed it can
never be narrowed by any capture: every element holds a constant pose across it,
so with the leaves restarting at 0 on the snap, every target in the window
renders the same frame -- and it never becomes observable later either, because
the clock freezes at settle and the 238->250 exit plays when the screen LEAVES
rather than on a timer.
Checked against this export rather than taken on trust: all 24 title elements are
constant across [160,238), and the lower bound is EXACT -- ptcopyright is
mid-ramp at t=159.9 and settled at t=160.0, so the intersection is the window.
Classified undecodable-with-reach. 236 stays, needs no defending, and nobody
should spend a run on it.
A citation added minutes after the other agent pushed the file it names resolved
NOWHERE, because this scans local refs and the local ref was stale. The citation
was right and the check was wrong. It now says so in the failure text and tells
the reader to fetch before editing.
A check that cries wolf is worse than no check -- and this one had just been
teaching me to distrust a correct citation.
🔴 Separately, my own slip: I ran this as '<check>; git commit' instead of
'<check> && git commit', so the commit landed while the check was red. The guard
was in the command and I had disabled it by punctuation.
The Decoder re-ran both flagged findings rather than arguing them. The pulse
ratio -- the leg under rate=0.5 that is independent of the other two -- came back
0.1000 over 16 clean cycles and 0.0993 on a second capture, unchanged by the
full-quad reader. Recorded in the authored why, because a leg that has survived a
challenge to its own instrument is worth more than one merely repeated.
Unit 10's conclusion survives (the parent multiplies in, so F6's gate is
unaffected) but its quoted numbers were a printed subset standing in for the
population -- the second time that exact error has appeared in evidence this port
consumed. Recorded as a pattern rather than a slip: a summary drawn from a subset
does not look like an error, it looks like a result, and neither instance was
reachable by reasoning because the argument was valid and the inputs were wrong.
No code change: both conclusions stand.
Measured by the Decoder with the full-quad reader: at the snap frame both sweeps
enter at their DECLARED OPENING alphas -- pteff03 at 255, pteff03a at 0 rising
1,2,3,4,6,11,17 from x=1721. Those are the leaves' own t=0 poses.
My implementation advanced the shared clock and left the leaf phase untouched, so
the sweeps would have sat mid-travel at the right clock value and the wrong
position. A defect visible only in a film -- no still and no clock reading would
show it, because the clock was correct.
The field already existed (leaf_start_units, from the F6 work); it simply was not
being set at the snap.
VERIFIED, pre-registered, via --probe-leaf on a real boot with a real press:
snap frame -> leaf_t 0.0, pteff03 x=-639, pteff03a x=1721 (declared t=0)
next frame -> leaf_t 0.5, both advanced by 2 px
Their separate note on my snap target: 236.0 survives their challenge -- at the
snap the sweeps are at alpha 255, putting the title clock in [100,238) -- but
their data cannot separate 236 from 200. Recorded as surviving, not confirmed;
the bound in the code comment already says so.
Refuted by the Decoder (f6-unit11): the two strips are batched into a single
additive eight-vertex draw -- two quads -- and their log reader took the first
vertex match per draw line and discarded the rest. Every analysis saw quad A and
never quad B. No new capture was needed; pteff03a was in the same logs that were
read as declaring it absent.
Three of my claims fall with it, including one I put in a report to the human:
'the port draws two, the game's capture has one'. The port draws two and so does
the game. My census stands; it now AGREES with the capture instead of
contradicting it.
✅ Nothing in the port changed. I proposed gating pteff03a and held, because
absence in one capture read by one probe is a lead not a finding, and because the
check I asked for was a human's look rather than another measurement. That hold
is the only reason this cost nothing.
⚠️ The absence claim cited the port drawing pteff03a as evidence the PORT was
wrong -- a defect inferred in my renderer from a gap in a reader.
Recorded generally: an absence is a claim about an instrument, not the world. A
count of zero says only that nothing got through the reader. Every positive
result on the same capture is untouched because those compare like with like on
one quad; only the absence compared a count against zero.
The 1.7x/3.2x title-clock conflict I was carrying as an open doubt against every
unit-valued figure on the title was never a conflict: the Decoder had been
applying the plate's declared ramp to ptcopyright. One mislabelled element
generated the whole discrepancy.
Same shape as the port gating a snap on settle_instant while reading a printed
number that came from settle_time(). Two elements, one label. In both cases what
caught it was measuring a RATIO, which needs no identification, rather than a
value, which does.
rate 0.5 now rests on three declared quantities that agree, the third unrelated
to the first: ptloop01's 30-unit ramp, the leaf's 600-unit loop, and ptbtn00f's
pulse at exactly 1/10 of that loop (60.0 frames over 16 cycles, zero variance).
Also recorded: the plate's pulse is now measured -- ptbtn00f, 120 title units,
peak alpha 80, drawn 51 of 60 frames. NOT implemented: the plate's blink is
neither F5 nor F6, and the human's standing note is that its delay is accepted.
Measured by the Decoder: the plate reaches alpha 255 in a single frame against
~11 frames of ramp with no input, and the sweep enters at 255 with no ramp where
an untouched run obeys its parent's declared t=70..100 gate. A cut, not an
acceleration.
It advances the ONE SHARED CLOCK, so authored/flow.json's clock: 'shared' stands.
🔴 I IMPLEMENTED THE OPPOSITE FIRST AND REVERTED IT. Their initial report had the
artwork animating across the press, which would mean two clocks and an
overlay-only jump; I built that (_plate_offset). It rested on a 5-frame window
that sat entirely inside the 11-12 frame lag between a scripted press and its
effect -- it compared frames where the input had not been acted on yet. A wider
pre-registered test refuted it: three elements mid-fade vanish in one frame.
🔴 AND MY FIRST VERSION NEVER FIRED, SILENTLY. It gated on overlay.settle_instant,
which is -1 for press_start: that screen declares a 22-unit settle window against
SETTLE_WINDOW_MIN=30. The boot has always printed 'settles at t=236' from
settle_time(), a DIFFERENT quantity, and I took the printed number as evidence
for the field I was testing. Caught only by filming and seeing overlay-view stay
flat at 0.0 across the press.
⚠️ The target is BOUNDED, not pinned: the capture puts it inside [100,238] -- past
the sweep's gate at 100, not past 250 or ptloop01's exit ramp would return the
sweep to alpha 0. settle_time()=236 sits inside that and is where the plate
reaches full alpha.
New diagnostic --press-at=S[,S...] presses (A) at wall-clock moments anywhere in
a boot; --skip-at lives inside the movie branch and fires once, so it cannot
reach the title. Marked fragile by construction.
VERIFIED on a filmed boot: shared clock jumps 109.4 -> 236.0 and view_units and
overlay_units move together across the press.
The sweep starts early because ScreenView drew a leaf WITHOUT multiplying its
parent's alpha in. ptloop01/ptloop02 declare 0:0 70:0 100:255 238:255 250:0, so
the sweep is invisible until t=70 and full at t=100. The port has had that ramp
in its export the whole time and was throwing it away at the draw call.
Three changes:
1. Parent alpha multiplies into the leaf's. This file asserted the opposite,
arguing from the sweeps being drawn while their parent had expired -- but that
could not separate 'the leaf wins' from 'the parent is ignored because it
draws nothing', and its own comment said so and named the interval that would
settle it. Measured there: dividing the leaf's declared curve out of the drawn
alpha pins the implied parent at 255.0 (+/-1.5) over hundreds of frames while
the drawn alpha swings 242 -> 132 -> 145.
2. rate 0.5, calibrated against a DECLARED interval (ptloop01's own 30-unit ramp)
rather than captured frames: two runs differing 2x in frames give 0.4795 and
0.4667, 2.7% apart. This number was 0.514, withdrawn, now reinstated at 0.5 --
what failed the first time was quoting a rate in presents, and the ratio was
discarded along with the frames.
3. The 107-unit authored offset is DELETED, with its guard tool. It came from a
ratio measured against an element identified only by screen position; the
declared ramp needs no such identification. Deleting an authored value because
the data already says it is the outcome PORT-MISSION asks for.
Also reverted, same day I made it: removing the transparent-parent skip. I read
'the game submits the sweep ~950 frames past its parent's expiry' as the leaf
outliving the parent. It does not follow -- a draw submitted at alpha 0 is still
a draw, and submitted is not visible. With the multiply, skipping on a
transparent parent IS multiplying by zero.
VERIFIED, pre-registered before running, via --probe-leaf:
u= 60 -> no draw at all (predicted: parent alpha 0.00, gated off)
u=100 -> leaf_t 50.0, x -439 (predicted 50.0, -439)
u=236 -> leaf_t 118.0, x -167 (predicted 118.0, -167)
verify-capture: every row unchanged.
⚠️ BUILD-SENSITIVE: builds 5 and 6 of GP_TITLE declare these records as a single
flat a=255 with no ramp. This export reads the ramped build; if that changes the
gate disappears silently.
Onset: 0.500 of (title first visible element -> plate onset), measured by the
Decoder as 0.489 and 0.507 across two independent captures, 3.7% apart. A RATIO,
which is the point -- it needs no clock, and every unit-valued figure from those
captures has been withdrawn: the rate because frames are presents (1168 vs 600
for the same animation), the '+40 units' because its conversion put
title-start->plate at 75 units where the declared data puts the plate at 238, a
3.2x conflict that is still open and is F4's.
Resolved against THIS export: 0.500 x (214 - 0) = 107.0 units.
tools/port/check-leaf-onset recomputes it and fails if a re-timing moves the
anchors; it has a selftest in both directions and is in check-all.
🔴 AND THE ADOPTION WAS A NO-OP UNTIL THIS COMMIT. leaf_clock() read
'if start < 0.0 OR rate <= 0.0: return screen_units', so when the withdrawn rate
went back to null the adopted OFFSET stopped applying too -- silently, while
authored/rendering.json still stated it. The two fields are independent now.
It was caught only because the offset was re-verified by PROBING THE RENDERER
instead of re-reading the file I had just edited. Both my earlier verifications
of this feature passed while it did nothing: one compared frames that were all
being forced to the same pose, the other ran when both fields happened to be set.
Verified, pre-registered before running, via --probe-leaf:
title u=236 -> leaf_t 129.0, x -123 (predicted 129, -123)
title u=400 -> leaf_t 293.0, x 533 (predicted 293, 533)
Effect: at the plate's arrival the sweep sits at x=-123, just entering the frame,
where before it was at x=305, well across it.
The Decoder withdrew 0.514: captured frames are presents and the present rate
differs per run -- the same animation took 1168 frames in one capture and 600 in
another, 1.947x apart, with that run's own baseline moving 1.953x alongside. So
it measured the capture's pacing, not the game. rate is null again (identity).
📌 The tell was there before the withdrawal and neither of us weighed it. The
human said the animation itself LOOKS correct. A port running 1.0x against a real
0.514x would be twice too fast and they would have said so. Their impression was
evidence against the number and both of us recorded it as a puzzle instead. A
human's impression is weak about magnitudes and strong about gross wrongness.
start_units 40 kept but marked provisional: two captures agree in RATIO form,
which needs no clock and survives the withdrawal, but converting the ratio to
title units needs the title rate, and that is itself in conflict (1.0 units/frame
from ptcopyright's ramp against 0.571 from the plate's, 1.75x apart).
Kept rather than reverted because 0 is not a measurement either -- it is the
unexamined assumption that the leaf shares the screen's clock.
Two changes, both measured, neither invented.
1. LEAF CLOCK. authored/rendering.json leaf_clock.title = {start_units 40,
rate 0.514}, from the Decoder's f6-unit8, both numbers off ONE capture. The
title's own rate is measured rather than assumed there (ptcopyright ramps
0->255 over 22 declared units across 22 frames = 1.000 units/frame), which was
the assumption their unit 4 had flagged. Supersedes their earlier 0.463, which
divided by the end of MOTION -- the declared track is stationary from t=540 to
600, so that denominator was short; 0.514 anchors on the loop wrap.
Corroborated independently: the human reported the port looks FASTER than the
game, offered as an impression. 1.0x against 0.514x is exactly twice too fast.
2. A LEAF OUTLIVES ITS PARENT. _draw skipped any element whose PARENT posed
transparent, before _draw_leaf was reached, so ptloop01 expiring at t=250 took
the sweep with it -- while this file's own decode says the leaf runs on its own
timeline and the parent's alpha is not multiplied in. The two were inconsistent
and the silent gate won. The capture settles it: the game submits the sweep
across frames 746..1913 while the parent expires at 956, so it keeps drawing
~950 frames after the parent is gone.
VERIFIED by probing the running renderer at two PRE-REGISTERED instants:
title u=400 -> leaf t=185.0, pteff03 centre 301 (predicted 301),
pteff03a centre 1169 (predicted 1168)
title u=800 -> leaf t=390.6, pteff03 centre 1124 (predicted 1124),
pteff03a centre 333 (predicted 332)
All within 1 px.
Effect at the plate's arrival (title t=236): the sweep's centre moves from 505 --
halfway across the screen -- to -36, just entering at the left edge. The human's
report is that the game's glow begins when the plate appears.
F6 is a clock question, not an effect question: the human confirms the light
animation itself looks like the game's and only starts earlier, and separately
that the port may be running it faster (flagged by them as an impression).
The port passed time_units straight to the leaf, which is an assumption -- offset
0, rate 1 -- that nobody measured and that the Decoder's capture contradicts:
the game's leaf t=0 is its first drawn frame, 40 frames after the title's first
element, at a rate measuring well below the title's.
ScreenView.leaf_clock(screen_units) applies an origin and a rate; both default to
-1.0 meaning unmeasured, in which case it is the identity and behaviour is
unchanged. Fed from authored/rendering.json leaf_clock per screen, currently null
with the provenance recorded.
No placeholder values, per F1: an invented constant here is indistinguishable
from a measured one later.
Verified inert: title rendered at t=2/3/4 s, 0 differing pixels against captures
taken before the change.
Also corrected in the process: my earlier 'the sweep enters the viewport at t=61'
used the UNROTATED sprite width. The leaf carries a 30 deg rest rotation, so its
AABB is 886 px against a 399 px sprite -- matching the Decoder's measured ~890 to
within 4 px. Port and game both put the quad on screen at leaf t~0, so the whole
discrepancy is the leaf clock's origin and rate.
The human reports the real game shows multiple, possibly more than two, running
along blue PCB-like traces, and cannot tell whether it is one light per line or
one glow spanning several.
Census of declared travel over every title element: only pteff03 (2160 px) and
pteff03a (2560 px) move as lights. The logo pair travels 300 px but is the logo
sliding in. Everything else -- pteff00/01/02/04, ptlogo_back2eff and eff1..5,
ptlogoall_eff/eff2, ptcopyright, ptbase2 -- declares no travel at all.
So the port renders two full-height streaks crossing the screen where the human
describes a population of smaller lights. Both agents had been asking WHEN the
sweep starts; the port may have the wrong effect altogether, and 'starts too
early' is what a wrong effect looks like to someone not reading keyframes.
Limit flagged on the Decoder's scan: it covered quads taller than 1.2 NDC, so it
cannot count small per-trace lights. pteff03a's absence stands (3.62 NDC); 'only
one travelling quad exists' does not generalise below the filter.
Limit flagged on this census: it reads DECLARED positional keyframes, so it
cannot see UV-scroll or shader-driven motion -- now a live possibility.
The Decoder's candidate 2 -- 'a focus/variant link means only one of the pair is
active' -- is answerable from the export and the answer is no.
It looked strong: ptloop01 carries opt_link=ptloop02.rat, it is the only linked
element on the title, the field comes straight from el.focus_link, and the port
never reads it.
But surveying opt_link across the whole export splits it in two: *f.rat targets
are variant-only, everything else is a top-level element drawn in its own right.
And the second population chains across kinds -- on main_menu, ptloop01 ->
ptloop02 -> ptbtn01 -> ptbtn01f. A light sweep points at a BUTTON, which a
variant selector cannot do.
So opt_link is a chain pointer that lands on the focus variant when the element
happens to be a button, which is why it was exported as focus_link. Candidate
eliminated; the port ignoring it is not what draws the extra sweep.
Surviving smaller finding: focus_link carries two different things and is named
after one. Nothing depends on it today.
CORRECTION FIRST: I refuted the Decoder's by-size identification on the ground
that both sweep sprites are 399x180. Wrong -- I compared source PNGs and never
read the leaf scales, which are [100,600] and [100,800], so the DRAWN quads
differ by a third. That is exactly the 3.15 vs 3.62 NDC they were separating by.
Size distinguishes them fine. The hold was right, the check found a real defect,
but my stated reason did not survive.
Which sharpens the real lead: because size DOES separate them, 'pteff03a does not
appear in this capture at all' is well-evidenced. The port draws it -- confirmed
at t=120/180/240 -- on screen from t~108 to t~521, right-to-left at 800% scale,
inside the window the capture covers.
A second glow arriving at t~108 is a good candidate for 'the glow starts too
early'. One capture, one probe, identified by size: a lead, not a finding.
Also recorded a failed approach: isolating the sweeps by differencing --time
frames does not work, because during a build-in everything else is moving too.
Answering the human's 'what is holding you up': two agents spent three exchanges
on ALPHA while the answer sat in a POSITION series neither of us compared to
anything.
The arithmetic that should have been step one: the Decoder's quoted sweep centre
-1.690 read as NDC is -441.6 px, and the declared position at leaf t=0 is -439.5
px. A 2 px agreement on a 2160 px travel -- so the game's sweep begins
travelling at leaf t~0, the same as the port.
That CONTRADICTS my own earlier framing on this page, which blamed ~135 units on
the leaf clock. If the game's leaf clock also starts at 0 then F6 is a
visibility question, not a clock question. Flagged rather than rewritten: it
rests on two numbers relayed in a message, which is what should be read from the
repo instead.
The tool: solves x(frame) ~= declared(t0 + rate*frame) for both parameters and
reports the RESIDUAL, which says whether the model was right at all. Selftest
runs both directions -- recovers a known clock to 0.09 px and rejects a
wrong-shape series at 81.9 px against a 20 px bar. In check-all.
Travel direction settled it: both rows travel LEFT->RIGHT, so both are pteff03
split across two keys by per-frame rounding. pteff03a is not in the capture.
So my 'the finding may still be correct via the OTHER row' does not apply --
there is no other row. I was right that size could not carry the assignment and
wrong about what the assignment was.
The larger half was not visible from here: the quoted low alphas were the nine
lowest DISTINCT values, not a series -- 14 sub-floor samples out of 1754. The
bound survives in shape and collapses in weight.
Status 🟡. Renderer still unchanged.
The Decoder's bound refutes screen_view.gd's 'parent alpha NOT multiplied in'.
Premise verified here: pteff03's leaf floors at 128, so a drawn alpha below that
cannot come from the leaf alone.
But the identification is 'by size', and pteff03 and pteff03a are BOTH 399x180 --
consistent with the two reported rows measuring 1.38x3.15 and 1.39x3.15. Size
separates the sweeps from the screen, not from each other.
That flips the cited row: pteff03a's leaf floors at 0 and ramps 0->128 over
t=0..150, so 8/24/33/50 is exactly that leaf alone. The conclusion may still hold
via the OTHER row (16 with a 128-131 cluster is pteff03's signature) -- the
finding may be right and the cited row wrong.
Free discriminator already in their capture: the leaves travel in OPPOSITE
directions, ~1000 px apart. Renderer unchanged until the row is identified.
Answers the Decoder's direct question: the port positions the leaf from the
LEAF's own clock, it does not draw the parent's pose and ignore the translation.
Computed from the leaf translation: pteff03 enters the frame at t=61 and is
mid-screen (x=305) when the plate reaches full alpha at t=236 -- visible and
travelling for ~175 units before the plate.
And screen_view.gd's own flagged limit -- 'a capture during t=100..238 would
separate' leaf-wins from parent-ignored-because-it-draws-nothing -- is the SAME
interval F6 is about. Applying the parent would hide the sweep until t=70 and
dim it to t=100, which accounts for ~40 units of the earliness but not the other
~175. One capture in that window settles both questions.
No behaviour change. The start mechanism is one expression, screen_view.gd:684:
var t := leaf_time_units if leaf_time_units >= 0.0 else time_units
leaf_time_units is set only by the --leaf-time diagnostic and is -1.0 on every
real boot, so the sweep rides the title's own clock from 0 with no offset.
Refuted the obvious reading, which was mine before checking: ptloop01/02 declare
0:0 70:0 100:255, so the parents LOOK like the gate. They are not -- the leaf is
what reaches the screen and the parent's alpha is decoded as not multiplied in.
pteff03's leaf declares 0:255 and is travelling from t=0; the plate arrives at
t=214-236, so the port starts the sweep ~150 units (~2.5 s) early, which is the
size and direction the human reported.
A start time is an OFFSET and leaf_time_units is an ABSOLUTE override; the
one-line edit is a subtraction at 684 fed by one authored value.
Two new findings from the human, both about WHEN a title animation starts, and
both handed over rather than guessed:
F5 Does (A) SNAP the title to finished, or ACCELERATE it? The human says they
cannot tell and is right that they cannot -- a three-frame acceleration and a
one-frame cut look identical to an eye. Two routes that should agree: a
per-frame capture (acceleration shows intermediate alphas, a cut shows none)
and the code (assigning a target time and raising a rate multiplier are
different instructions). Their "looks more like a snap on multiple attempts"
is recorded as a PRIOR, not a result.
F6 The title's sweeping white glow -- ptloop01/ptloop02, the blue PCB-like lines
-- starts only when the plate appears in the real game, and starts earlier in
the port. A lead from the exported declaration, mine and unverified: those
elements are keyed at t = 0, 70, 100, 238, 250 while the plate reaches full
alpha at 236, with pteff02 keyed at exactly 236 and ptlogo_back2eff and
ptcopyright at 238. 236-238 is a synchronisation point in the declared data
and a human just reported a behaviour change there. Flagged AGAINST itself
too: 238...250 looks equally like an exit ramp -- ptcopyright uses that shape
and starts nothing -- and the sweep lives in a nested .rat leaf with its own
timeline.
F6 bears on clock: "shared" and on F4: if a title element does not move until
the plate arrives, either the declared data says so and our keyframe reading is
wrong, or something at the plate's arrival STARTS it, which is a mechanism
nobody has proposed.
And the process change, which is the human's and outlives this item:
"attacking the 'whole' mission was too big for them to handle. Split the given
missions and tasks into even smaller tasks which they can tackle and give to
a human for feedback."
PROTOCOL.md gains "Work in units a human can check in a minute". A milestone is
not a unit of work, it is a bag of them. A unit is right-sized when it ends in
something a person can judge in under a minute WITHOUT READING ANYTHING, and
each one states its question, what the human looks at, and what it does NOT
cover. Do one, hand it over, stop -- an unverified fix under a second change
makes a regression two-variable.
The evidence for the rule is this week: the splash sat through a whole milestone
and took one day once scoped to "does it animate?". The bar is a HUMAN check,
not a green tool -- three instruments passed a frozen screen.
Every other assertion in check-all has a control; audio was the one that did
not, which is how it went weeks unable to fail. Control measured just now: with
move absent from the baseline the diagonal reads +0.000, the check reports 'at
least one cue is not sounding' and exits 1.
I wrote "whether the game snaps both clocks forward" into yesterday's F4 and the
human asked which clocks. There are none: authored/flow.json sets
`clock: "shared"`, so the title's two composited builds -- build 4 the artwork
(finishes t~=118) and build 2/3 the plate (full alpha t=236) -- run on ONE clock
started together. Left standing, that phrasing sends an agent hunting for a
second clock this corpus says does not exist.
Corrected in both briefs and in the playtest page, marked as a correction rather
than silently edited.
And the question is better than I first framed it. `clock: "shared"` is
AUTHORED, and the port's own plate-arrival-halves.md calls it "not falsified...
not confirmed to better than ~20 % either", with an unresolved anchor
disagreement inside one binary: the reconciliation picked t=118 while
settle_time() returns 160 and the boot prints "settles at t=160".
So F4 is a TEST OF THAT PREMISE, and the discriminator is observable -- press (A)
early, while the wordmark is still building in, and watch the ARTWORK rather
than the plate:
advances the shared clock -> the artwork SNAPS to finished
only forces the plate -> the artwork KEEPS ANIMATING its build-in
Both briefs now say to answer F4 before building on `shared`, and tell the port
not to choose what "jump" means.
F1: the human watched the real game and it repeats on a held direction, on the
stick AND (confirmed separately) the d-pad. gamepad.gd had predicted this exact
refutation in its own words, so one-step-per-deflection stops being the
conservative reading and becomes a known defect.
Mechanism: Gamepad.held_direction() polls the DEVICES -- not
Input.is_action_pressed, because ui_up/ui_down sit on the stick at Godot's 0.50
deadzone while the port steps at the game's measured 0.61, so polling the action
would repeat through the exact band ENTER exists to exclude.
Boot._menu_repeat() re-applies the same guards a real press gets, rather than
sharing them, because a second input path is where this port's defects hide.
The RATE is NOT shipped, on instruction: an invented interval is
indistinguishable from a measured one later. An earlier draft of this change had
0.40/0.20 with a why attached; that was the named failure mode and the numbers
are removed, not commented out. repeat_due() returns 0 until both are set.
Flagged at the adoption site: verify-input's 'a held stick is ONE step, not six'
asserts the ABSENCE of this feature and will go red when a rate lands -- for the
right reason, and looking exactly like the jitter bug returning.
main's P6 row reads 'Looping is blocked on HANDOFF Q10' while main's OWN
HANDOFF.md line 39 marks Q10 answered -- the row was stale, not a decision, so
the resolution keeps the answered status rather than silently un-resolving it.
P5 takes main's line verbatim: that is the human's gate call and not mine.
P6 explicitly does NOT claim the gate -- the same play-test found the SFX mix
wrong, and 'sound on the P5 gate' means the RIGHT sound.
"Menu walk and navigation is fine. Video skips too. Extras open. New Game
shows new game intro video." -- 2026-09-02
P5 is done. Its gate was "a human clicks through it", the retro said it had been
waiting on that and not on code for the whole milestone, and it has happened.
PORT-MISSION.md updated. The NEW GAME gap is accepted as-is.
Four findings, three of them the Decoder's:
F1 THE MENU REPEATS ON A HELD DIRECTION AND OURS DOES NOT. One step per
deflection was authored as the conservative choice because nobody knew; a
human has now watched the real game and it repeats, "at a medium pace... slow
enough to see which item is selected". That settles the existence half of H1
against us. The RATE is still unmeasured and must not be guessed -- the
description bounds it and supplies no number. Decoder measures initial delay
and repeat interval as frame counts; the port implements the mechanism and
waits for the numbers.
F2 THE SFX ARE TOO LOUD BECAUSE THERE IS NO MIX AT ALL. Measured: confirm
-17.7 dB mean / -0.0 dB peak, 3 dB hotter in mean than the music and 6.4 dB
above move. No volume or gain value exists anywhere in export/ or authored/,
so every clip plays at unity on one bus. Decoder: is per-cue or per-bus gain
on the disc -- the cue table is the obvious place and cue 1103 is already
decoded. Port: gains at PLAYBACK as data, and explicitly NOT normalisation in
the exporter, which destroys the relationship between clips and cannot be
undone by a modder.
F3 SOMETHING IS MISSING ON THE TITLE SCREEN. The export carries one music file
and the port plays nothing on the title. Which cue does the title play, and
is there a sting on the plate or on accept? A negative needs a positive
control: find the menu's cue by the same method first.
F4 (A) SKIPS FORWARD THROUGH THE BOOT AND WE IMPLEMENT TWO OF THREE PRESSES.
In the game: skip video, reveal plate immediately, accept plate. The middle
one is missing here. Whether the game snaps both clocks forward or only
reveals the plate is a question, not a detail -- and it is a cheap second
route to the plate-arrival question, since a press that skips to the plate
says where the game thinks the plate belongs.
H3, the plate delay, is ACCEPTED -- "feels the same... sufficient". Left
unattributed rather than closed green.
It computed ok, printed a red line when a cue was silent, and the python had no
exit path at all, so it returned 0 every time while check-all registered it
must-pass. A cue could stop sounding and the suite would print the failure and
stay green.
This project's recurring defect one level up: not an instrument sitting below
the thing under test, but one that SEES the failure and does not report it.
The diagonal now exits. The no-op-silence and cue-order lines stay REPORTED --
both carry documented cross-run instability (whole-buffer recording shifts; a
0.15 margin this file's own comments show reaching 0.109 on a sounding cue), and
making either binding would produce red on correct audio.
--control feeds it a walk in which move never sounded, built from the tool's own
suppression machinery, and requires it to fail.
PLAYTEST-2026-09-02 asks for this re-ask by name, and the previous plate numbers
were taken through the pose_at bug -- the same accident that manufactured H2's
false green.
Filmed a real boot and isolated the plate with its own sprite's transparent
holes: same rect, same rows, interleaved at pixel scale, so the moving title
sweep cancels. Two earlier isolations failed first and are recorded -- a rect
that overlapped the developer splash, and a control band 55px away that could
not cancel a sweep that MOVES.
Onset: flat through ou=213.9, risen by 222.1, declared t=214 inside the bracket;
88% of lit by t=238 against declared full at 236. NOT late.
But over 8.1 declared cycles (ou 6..1974) it never returns within 88% of dark,
where the disc declares 0 from t=244. rest.t=236 is the PULSE PEAK and holding
parks it there -- the exact family plate-arrival-halves.md named for transients
and nobody had checked on the plate itself.
Proposed, not changed: whether the guest pulses the plate is the Decoder's.
The publisher shape check covered one element on one screen, which I flagged: a
port applying one screen-wide ramp to everything would have passed it.
developer_logos declares gamearts/seta flat across 15..30 and anima decaying 17%
over the same interval. Same screen, same frames, same clock -- the two flat
elements are the control for the third, and any phase or rate error hits all
three alike.
Pre-registered, then filmed. Flat ones flat to five decimals (+0.00000), anima
decays. Fitted scale-free against declared curves: each element matches its own
at 0.49/0.50/2.18% max error and the OTHER shape at 8.1-8.8% -- 4-17x, both
directions.
Establishes the ramp is per-element, not just correctly shaped.
"Looks good! Cannot notice any obvious difference from the actual game.
Mark logos as done." -- 2026-09-02
Not "the check passes": a person compared the port against the real game and
could not tell them apart. That is the oracle, and it is the strongest result
this port has produced. The sole-focus order is lifted; both agents return to
their milestones.
The fix was one word -- pose_at ASSIGNED the settle instant instead of clamping
to it, so every query returned the settled pose whatever the clock said. The
same line manufactured the false green: the capture harness shoots after two
frames, so it was photographing t~=2 units, which looked settled only because
everything looked settled. The 0.01 % agreement that closed H2 was measured
through the accident. One bug produced the defect AND the evidence of its
absence.
Verified here before it went to the human, by film rather than by claim:
motion 16.4 % -> 27.7 %, distinct luma states 26 -> 43, the publisher ramp 6
steps -> 13 in one continuous run, and the developer splash's interrupting
0.50 s freeze gone. The publisher trajectory rises to a peak and settles back --
the crossfade signature.
The port then closed a gap motion-census names in its own header ("a wrong ramp
that moves every frame passes here") with a shape check pre-registered from the
disc, measured off a film, on a non-overlapped strip, in ratios so the texture
divides out: rise:last declared 1.20, measured 1.20 exact.
Kept as the standing lesson, because it is the fourth instance: an instrument
that sits below the thing under test cannot see it fail. Ask of any new check
what it would still report if the feature were entirely absent.
Explicitly NOT claimed: P5's gate is "a human clicks through it" and nobody has
said the milestone is met. The briefs say so, and say not to record it on the
human's behalf.
The decoder's end-to-end pipeline work returns to normal priority rather than
being dropped -- it is what decides whether the port's 60 units/s matches the
game. The ramp is now right in SHAPE and unverified in DURATION.
The Decoder read Canary's cvars (present_letterbox true, safe area 100) and drew
the consequence that "everything either of us measures off a PNG carries the
resample -- every RMSE against a capture, every glyph count, every surface mean,
and the motion-census numbers on both sides."
That is a caveat on a very large amount of shared evidence, so it was worth one
measurement before anyone started qualifying results with it.
Pre-registered: if the captures carry a scale, SCALING this port's 1280x720
render to 1279x675 should beat CROPPING it. If they are crops, the reverse.
render cropped to 1279x675 RMSE 558.1 (0.85 %)
render scaled to 1279x675 RMSE 10118.8 (15.4 %)
Cropping is 18x better. A 0.9375 vertical scale would put every feature on the
wrong row, and the residual under scaling is exactly what that looks like.
REFUTED: the consequence. Pixel comparisons against the committed captures are
like-for-like.
NOT REFUTED: the cvar reading. Canary may letterbox by default; this says
nothing about that. It says the capture path used for the corpus did not go
through it -- presenter bypassed, window 1:1, or the tool cropped the letterbox
before saving. Which, nobody has established.
📌 And a second line already agreed, one page away, unconnected:
ui-render-tone-curve.md records every committed capture aligning against our
render at exactly dy=0 dx=0, correlation 0.9466. A 0.9375 vertical scale cannot
produce a zero-offset alignment. The evidence for "crop" was already in the
corpus, next to the surface-size puzzle it explains.
Unchanged and worth keeping: their gamma negative (VdGetCurrentDisplayGamma is
kStub, the splash shader is four ALU ops with no pow/ramp/lookup), the
vertex-stream path being the better instrument where a question can be asked of
it, and motion-census never having been at risk -- a resample preserves change.
Reach: one capture, one screen. Enough to refute a universal; not enough to
establish that no capture anywhere carries a resample.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018AHUQvXGyNcKonSEWsgWcX
motion-census says in its own header that it cannot do this: "a wrong ramp that
moves every frame passes here." So having restored the motion, this checks the
shape.
Pre-registered from the disc. palogo_sqex_eff declares 0:0 -> 15:255 -> 30:212
-> 45:0, so three straight runs with breakpoints at 15 and 30, the middle slope
~1/5 the magnitude of the last, and the rise ~1.2x the last.
Measured from a FILM of a real boot, on the companion's top strip
(686x11+299+319) which no other element overlaps, so it is that element's own
alpha rather than a composite:
units 5.6-13.0 +0.00509 /unit rise
units 16-28 -0.00090 /unit gentle fall
units 31-43 -0.00423 /unit steep fall
unit 46.4 0.00000 gone
Breakpoints land where declared: the rise stops between 13.0 and 16.1, the
gentle fall steepens between 28.4 and 31.4.
ratio middle:last declared 0.203 measured 0.213 (within 5 %)
ratio rise:last declared 1.20 measured 1.20 (exact)
So the port interpolates piecewise-linearly across the declared segments, which
is what the Decoder independently measured the game doing -- 28 distinct alphas
over 28 consecutive presents, modal steps -3 and -14 against predicted -2.87 and
-14.13.
⚠️ RATIOS, NOT ABSOLUTES, and deliberately. The strip mean is an alpha scaled by
the sprite's own pixels; its absolute value carries the texture. A ratio between
segments divides that out, which is the only reason the shape is checkable from
a composite at all.
What this does NOT establish, stated rather than implied: that it LOOKS right --
three instruments have now agreed with a picture a human called wrong, and a
fourth agreeing does not change the standing of the fifth. Nor anything about
the developer splash's three pairs. Nor the absolute alpha.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018AHUQvXGyNcKonSEWsgWcX
Closes the two items the play-test left after the fix landed.
1. tools/port/verify-motion, wired into check-all with its control.
It films a REAL boot -- no --time, no pinning -- and hands it to
tools/motion-census. The window is the DECLARED build-in (publisher t=0..45,
0.75 s at 60 units/s), so it asks about the interval the disc says is animating
and nothing else.
🔴 BOTH SIDES MEASURED, not one measured and one assumed. I reverted the single
operator in pose_at, ran this check against the defect, and restored it:
broken (ASSIGNS the settle instant) 40 % and it FAILED
fixed (clamps to it) 86 % and it passed
The bar of 60 sits mid-gap: 20 points above the defect, 26 below the fix.
🔴 AND MY FIRST VERSION OF THAT BAR WAS JUSTIFIED BY A NUMBER I HAD NOT
MEASURED. It claimed "~40 points of clearance on both sides"; with a 1.0 s
window the real clearance was 5 points, because that window includes 0.25 s of
legitimate hold and dilutes the signal. A bar defended by an unmeasured number
is this whole check's own defect, one level up. Corrected with the measurements
and the sequence stated.
The control runs FIRST and is not optional: motion-census --selftest drives a
fade, a switch and a frozen film through the same loader and floor. If it cannot
separate those three, every number the check reports is decoration. Then the
--control mode builds a frozen film from the port's own pixels -- one real boot
frame repeated -- and requires it to FAIL. It scores 0 %.
One defect in the check itself, caught by running it: `ls | head` under
`set -o pipefail` exits 141 before asserting anything, and a check that dies
before checking looks a lot like a check that passed.
2. BLOCKED.md H2 corrected from ✅ to 🟡, against myself.
The MECHANISM half stands -- no post-process pass, the blur is a baked companion
texture. The BEHAVIOUR half was false and the row asserted it: I wrote "the port
draws all seven quads -- verified by a frozen sweep". True, and it did not mean
what I used it for. A frozen sweep drives the clock BY HAND. It proves the
renderer can draw pose N and says nothing about the poses being drawn in
sequence while running.
All three of my instruments passed the defect -- frozen sweep, a 0.01 % settled
comparison (a frozen screen matches a settled reference PERFECTLY), and an
achieved-fps counter (identical pixels 25x/s score like animating). Every one
measured throughput or a pose; none measured CHANGE. Same shape as
InputEventAction bypassing the input map.
Not settled: the ~1.0-1.2 menu residual; findings 3 and 4's remaining halves.
Both were explicitly deferred by the human until this was fixed, and it now is.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018AHUQvXGyNcKonSEWsgWcX
The 2026-09-02 play-test: "the logos just switch, I cannot discern any animation
at all." Reproduced, diagnosed, fixed, and gated by a film.
REPRODUCED FIRST, as instructed. tools/motion-census needed Pillow, which this
container has no pip for, so it got an ImageMagick fallback that shims only the
four Pillow calls it uses -- the census arithmetic, the MOVED floor and the GRID
are untouched. Its --selftest passes on that backend with the human's own
numbers: fade 97.4 %, switch 2.6 %, frozen 0.0 %. A shim that distorted pixels
would fail its own control.
publisher 0.30 s moving then 3.30 s FROZEN (human: 0.30 then 3.20)
developer 0.40 + 0.25 split then 2.45 FROZEN (human: 0.35 + 0.25 then 2.40)
Matched to within a frame.
THE CLOCK WAS NEVER THE PROBLEM. view_units advances 2.8-3.0 per frame, smooth,
~60 units/s, no stalls -- the play-test's candidate list can drop "the group
clock not integrating" and "advancing by keyframe index".
THE POSE WAS. Measuring the sharp logo's own rect frame by frame: 0.40549 flat
from unit 7.9 through 28.2 -- the same value it holds at 45 and beyond. It was
already FULL before its declared ramp (15 -> 30) began.
Cause, in ScreenView.pose_at:
t = settle_instant if settle_instant >= 0.0 else minf(t, settle_units(element))
The comment above it says "stop at the hold". The else-branch clamps. This half
ASSIGNS, so from a screen's first frame every element was posed at the settled
instant and no build-in was ever drawn. The asymmetry is the whole defect, and
`--time` sets `frozen`, which skips the clamp -- which is exactly why my frozen
sweep "proved" the companions were drawn and proved nothing about running.
Fix: `minf(t, settle_instant)`. One operator.
⚠️ AND THE HOLD IS NOT THE BUG. The Decoder measured the game holding one picture
for 3.34 s on this screen -- LONGER than the port's 3.30 -- because palogo_sqex
declares 205 of its 255 units as a flat plateau. The play-test's "a fade does not
hold one picture for 3.20 s" would have sent me to delete the one correct part.
Clamping keeps the plateau exactly.
GATED BY A FILM, not a still:
before after game (Decoder)
publisher build-in 0.30 s 0.60 s
developer build-in 0.40+0.25 0.95 s continuous
splash moving 12.0 % 24.8 % 21.2 % / 27.8 %
distinct luma states 120 152
longest frozen 3.30 s 3.30 s 3.34 s
🔴 AND IT LOOKED LIKE A 10x REGRESSION AGAINST THE ORACLE, WHICH IT WAS NOT.
verify-capture went publisher 2.17 -> 22.58, title 14.11 -> 67.07. Cause: it
shoots two frames after load and got the settled pose ONLY because pose_at
assigned it. Its own comment says so -- "the 0.01 % agreements on both splashes
were measured through that accident."
So the `--screen --capture` path now advances the clock to the settle instant
explicitly before shooting, which is what the tool was always asking for. Guarded
on `not _frozen`: `--time` means the caller wants THAT instant, and overriding it
would reintroduce the silent-ignore this replaces.
Every oracle row is back to its pre-fix value to the digit: publisher 2.17
(0.01 %), developer 3.05 (0.01 %), title 14.11, main_menu 13.02, extras 13.10,
title_plate 13.04. The port animates AND still matches the settled captures.
Not settled: motion-census is not yet wired into check-all -- next, and
deliberately not rushed at the end of a long iteration.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018AHUQvXGyNcKonSEWsgWcX
A human on a GPU at ~140 fps: "the logos just switch, there is no animation at
all." Measured from a real boot with --film at 0.05 s, then per-frame change:
splash moves 1.30 s of 7.95 s = 16.4 %
publisher splash 0.30 s of motion, then 3.20 s FROZEN
developer splash 0.35 s + 0.25 s, then 2.40 s FROZEN
distinct luma states in 7.95 s 26
A 45-unit build-in cannot be drawn in 26 states, and a fade does not hold one
picture for 3.20 s. The frame counter says 24.8 fps achieved; both are true --
the port is DRAWING 25 times a second and CHANGING almost never.
🔴 Why every check passed, which matters more than the bug:
frozen sweep drives the clock BY HAND -- proves the renderer can draw
pose N, never that the poses are drawn in sequence
settled compare 0.01 % against the capture -- a screen frozen 84 % of the
time matches a settled reference PERFECTLY, that is what
frozen means
achieved fps counts frames DRAWN -- the same pixels 25x/s scores
identically to animating
Every one measured throughput or a pose. None measured CHANGE. Same shape as
InputEventAction bypassing the input map: the instrument sat below the thing
that was broken, so the break could not appear in it.
tools/motion-census closes the class. It measures change and nothing else, and
its --selftest asserts it separates a fade (97.4 % moving) from a switch (2.6 %)
from a frozen film (0.0 %) -- a detector that cannot tell those apart would
report the same green line on all three.
Both briefs: this is the SOLE focus. The port reproduces before changing
anything and gates every fix on a film rather than a still. The decoder maps the
whole pipeline end to end -- disc bytes, the game's per-frame update (does it
interpolate between keyframes or hold?), what is submitted per frame, and what
Canary does to it before a capture records it -- delivered as a SERIES, not a
settled value.
The port should also record the refutation against itself: H2 reads ANSWERED on
the strength of the frozen sweep. The mechanism half stands, the blur is a baked
companion texture. The behaviour half does not.
Two corrections to my own file, one from the Decoder and one from a GPU.
1. "60 NOW STANDS ON A THIRD INDEPENDENT ROUTE" IS WITHDRAWN. I recorded it last
iteration and challenged it in the same breath -- three routes to one number are
weaker than they look if they share an upstream assumption -- but I wrote the
claim down first and the caveat second. The Decoder audited it and agreed: route
B needs "the guest presents 60x/s", from the vblank histogram UNDER Xenia's 60 Hz
limiter; route C needs "the vblank is 60 Hz", that limiter's cvar; route D is a
wall-clock duration that lands on 60 only because the vblank is 60 Hz. One
witness in three coats.
✅ What survives is conditional and better, established by MANIPULATION rather
than agreement -- forcing 30 Hz gave 30.2 units/s, 60 Hz gives 59.8/61.3:
units per second = THE DISPLAY REFRESH RATE.
It becomes "60" only through a fact this corpus has never measured: an Xbox 360
outputs 60 Hz. A hardware specification -- solid, and belonging CITED as a spec
rather than folded in as a third measurement.
📌 The conditional form justifies this port's construction rather than excusing
it. "units/s = refresh rate" says what to do on hardware that is NOT 60 Hz, which
is exactly why a time-based clock at a fixed 60 units/s is right where a
frame-based one would drift. `kind` stays `authored`, and the reason is now
sharper: the measurement is of a RELATIONSHIP, and the constant that closes it
comes from a datasheet.
2. THE +1.2 / +1.6 UNIT DWELL RESIDUAL WAS FRAME GRANULARITY -- measured now,
not inferred. I attributed it to the exit check's granularity without testing it.
The GPU makes it testable: same boot, same declared groups, 65-66 fps instead of
17-25.
Pre-registered: shrink roughly with the frame rate, so <=0.5 units at 65 fps.
publisher 4.27 / 4.26 / 4.27 mean 4.253 s residual +0.20 units
developer 3.50 / 3.52 / 3.50 mean 3.500 s residual +0.00 units
From +1.2 and +1.6 to +0.20 and +0.00. The prediction held. ⚠️ It also means the
4.270 / 3.527 quoted elsewhere carry a rendering-rate term; 4.250 / 3.500 is what
the port hits when the renderer keeps up.
Housekeeping: Xvfb did not survive the restart again -- the exact failure the
check-all display guard was written for, now with a second occurrence. Restored;
the port runs on the GPU at 65-66 fps.
Not settled: findings 3 and 4, both still without a surviving named cause; the
clock origin, where their FRAMES=9000 capture reached 96 % of the movie and
FRAMES=11000 should clear it; the ~1.0-1.2 menu residual.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018AHUQvXGyNcKonSEWsgWcX
The Decoder reconciled three of their own pages that held incompatible positions
-- 2 units per guest frame, time-integrated at 56.8, and 1 unit per present --
with one mechanism: the clock advances ONE UNIT PER VBLANK, and presents may be
dropped without the clock caring. It explains steps that are always multiples of
17, and the same animation spanning 21 labels in one capture and 33 in another,
which a strict per-present clock cannot produce.
Their rate result is a manipulation, not an observation: 255 declared units take
4.263/4.162 s at a 60 Hz vblank and 8.450 s at --framerate_limit=30. The vblank
rate sets the unit rate; a console vblanks at 60.
So the justification for 60 has now been "2 units per rendered frame" (retired),
"the game presents at 60 Hz" (superseded), and now "one unit per 60 Hz vblank".
THE NUMBER HAS NEVER MOVED. Worth noticing rather than celebrating: a value whose
reason changes three times while it survives is either robust or
under-constrained, and the honest label is still `authored`.
📌 THIS PORT INSTANTIATES THEIR NULL MODEL, which is the one thing this side can
contribute to that argument. Their reasoning turns on "a time-integrated clock
predicts 4.25 s in BOTH conditions". This port IS a working time-integrated clock
at 60 units/s, and its splash dwell across a 4.0x change in its own rendering
rate is 4.28/4.26/4.27/4.26 s -- flat to 0.5 %. Their counterfactual is
demonstrated rather than assumed.
⚠️ Labelled: that is evidence about the NULL, not about the game. It says what a
time-integrated clock does, not what the game's clock is.
🟡 And per-vblank vs per-present stays open, with the discriminating experiment
named on their side. IT IS IMMATERIAL TO THIS PORT AND THEY SHOULD NOT RUN IT ON
THE PORT'S ACCOUNT: the two models differ only when the console DROPS a present
-- per-vblank keeps real-time pace through a drop, per-present slows. This port
is time-based, so it matches per-vblank exactly and would run marginally ahead of
per-present during drops only. On a console presenting every vblank they
coincide, and these screens are a handful of quads.
Nothing in the port changes.
Not settled: findings 3 and 4, both still with no surviving named cause; the
clock origin, which the Decoder reports blocked because no capture reaches the
title; the ~1.0-1.2 menu residual; the allowance's grep trigger.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018AHUQvXGyNcKonSEWsgWcX
From the Decoder's audit of their own /canary checkout, not from anything visible
on this side. They applied their own lesson rather than stating it, and the
exposure was four logger commits deep, not one.
The sharpest bears directly on what this port shipped. `0f920e645` adds `blend=`
per draw, and without it a draw log records NO BLEND STATE AT ALL -- so
ui-blend-mode-decoded.md's 35-element oracle, the evidence on which this port
DELETED its authored additive map, could not be re-derived by anyone who cloned
this repository. Not approximately. Not at all.
It is reproducible now: four container-only commits exported as patches on their
branch with a rebuild recipe. Named in prose without a resolvable path, since
that directory is not in this checkout and citing it as one would be the exact
defect check-citations exists to catch.
What it changes: nothing is retracted. The measurement was real when made and is
now portable, and the trade was still right -- a screen-name map cannot answer for
a screen nobody drove to, so the decoded field is better regardless. What it
changes is what "decoded" was resting on: for the window between adoption and
export, this port had deleted an authored entry in favour of a field whose
supporting oracle nobody else could regenerate.
📌 Theirs, and the durable line: a finding is only as portable as the tool that
produced it, and a reproduce recipe that READS as complete is the dangerous kind.
Theirs named shas, which is why four commits sat unexported while one was noticed.
⚠️ And this port cannot check the class from here. check-citations scans repo
paths; an instrument living in another container is not a path at all. The only
defence available on this side is asking what produced a number before adopting
it -- which is a habit, not a check, and does not run.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018AHUQvXGyNcKonSEWsgWcX
From the Decoder's catch at shutdown, not my own. They found their Canary logger
change -- the texture content hash -- living UNCOMMITTED in /canary, a checkout
pushed nowhere. Two committed findings could not be reproduced without it: it is
the field separating "the buffer rotated" from "a frame was decoded", and its
absence is what cost two withdrawn positions on units/second in one day. They
committed it and exported it into the repo as a patch.
Their generalisation applies here too, so I audited this side at the same moment.
One real instance: DECISIONS.md cited
`/reborn/docs/re/captures/main-menu-oracle.png` as the evidence for a decision.
The capture IS in the repository, at docs/re/captures/main-menu-oracle.png --
only the path was stale, left by the monorepo move. Fixed. The other /reborn
mentions are deliberate: one warns the mount is empty, one is a table row listing
the pattern as an example of what not to do.
⚠️ tools/port/check-citations does NOT catch this class, and the gap is named
rather than quietly left: it scans for REPO paths that fail to resolve, and an
absolute path is not a repo path, so it slips through. Extending it to flag
off-repo absolutes -- especially ones whose basename does resolve in-repo, the
recoverable case -- is the obvious next increment and is deliberately NOT done
here. It was found minutes before a shutdown, and a hasty checker is worse than a
named gap.
Index regenerated.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018AHUQvXGyNcKonSEWsgWcX
Last iteration I inferred the returned plate's fade from code-path identity
because the harness could not watch it: `--script` quits the moment the last step
settles, and the plate arrives on its declared ramp ~3.6 s later. A film of
`--script=cancel` stopped at 168 units and never reached 214.
`--linger=SECONDS` holds the run open past the walk. `_script_settled` still waits
for a hold before shooting -- a shot taken mid-fade is a photograph of a fade --
this only changes what happens after the shot, which was "exit".
Pre-registered: the returned plate sits at its floor until 214 units, then rises
to full by 236, the same ramp the boot shows. Measured:
units=208.75 0.145404 floor
units=216.58 0.158596
units=224.41 0.179036
units=232.25 0.203050
units=240.08 0.215005 full -- boot path gives 0.2142 at t=236
So the return fades, identically to the boot, and it is now OBSERVED rather than
argued from the branch it takes.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018AHUQvXGyNcKonSEWsgWcX
The Decoder warned that my port "presumably models one title". Checking that found
a real behavioural split, and the code was right where I expected it wrong and
wrong where I did not.
My prediction FAILED first: I expected the port to be inventing a plate on a
(B)-reached title, because flow.json's scope_why says that is deliberately not
claimed. It is not inventing -- the call site cites a measurement from 2026-08-30,
the plate IS re-drawn after (B). scope_why was the stale thing, and is corrected.
🔴 BUT THE TWO PATHS DIFFER, AND A `why` CLAIMED THEY DO NOT. That call site says
"the plate re-appears by the SAME path, with the same shared clock, as it does on
boot. Whatever the boot does, the return does." Filmed:
before: el=1.39 view_u=0.00 overlay_u= 0.00 plate absent
el=1.53 view_u=8.67 overlay_u=244.67 plate present
The overlay clock jumped 0 -> 244.67 in ONE frame. The plate POPPED, where the
boot fades it across its declared 214->236.
Cause: `_overlay_process` detected "static diagnostic mode" as
`_sequence.is_empty()`, and `_sequence` is populated only by `--boot`. So `--menu`
matched it too and the menu's return took the `--screen --overlay` diagnostic
branch, which poses the overlay at settle_time() by design. A proxy for one mode
that silently caught another.
Fixed by gating on the flag itself -- `_static_overlay`, set only by `--overlay=`
without `--boot`. Verified both directions:
diagnostic still poses: --screen=title --overlay=press_start --time=4
-> "overlay press_start at t = 240.00 units, drew 2"
return now shares the clock: overlay_u == view_u on every filmed frame, plate
at its 0.1377 floor through 168 units
boot path unchanged: plate reaches full alpha at t=236, boot completes 10.46 s
⚠️ WHAT I DID NOT OBSERVE, stated rather than glossed: the plate actually RISING
on the return path. `--script` quits when the walk settles, so the film stops at
~168 units and never reaches 214. The rise is established on the BOOT path
(measured earlier: 0.1457 at 210 u, 0.2142 at 236 u) and the return now provably
takes that same branch with an identical clock -- but the final rise on this path
is inferred from path identity, not filmed.
⚠️ And whether the GAME fades the returned plate is still unmeasured. The 7.3 s
between (B) and the pulse returning is consistent with a transition plus the
declared fade, but that is consistency, not a measurement of the ramp on this
path. Recorded in scope_why.
Not settled: finding 3, no surviving cause; the clock origin, which the Decoder
reports blocked -- no capture contains the title, because it sits on the far side
of a 137.7 s movie and the runs were too short; the ~1.0-1.2 menu residual.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018AHUQvXGyNcKonSEWsgWcX
The --framerate_limit=30 run refuted the time-based reading on every
discriminating row, against its author's own expectation: modal alpha step stayed
17 where time-based predicts 34, units/second halved to 30.2, the publisher dwell
doubled to 8.450 s. Both controls passed FIRST -- the limiter demonstrably took
effect, and all 8 splash quad rects were identical, so nothing but the frame rate
differed. 255 x 1 / 15 = 17 at 28.4, 51.4 and 54.8 presents/s alike.
THE GAME ADVANCES 1 UNIT PER PRESENTED FRAME. This port advances
`time_units += delta * units_per_second`. Two different mechanisms that agree at
exactly one frame rate -- 60 Hz, the only rate the console ever asked the game to
be right at.
🔴 DO NOT MAKE THE PORT FRAME-BASED TO MATCH THE GAME, and the reason is now in
authored/timing.json so nobody "fixes" it. A time-based port reproduces a 60 Hz
console on hardware that is not 60 Hz; a frame-based one drifts on every machine
that is not -- and this port has measured ITSELF between 9.7 and 69.4 fps
depending on the renderer. Matching the game's mechanism would import a fragility
the game never had to survive, because the game only ever ran on one box.
⚠️ BUT IT SHARPENS WHAT 60 CLAIMS. If units/second IS the present rate, then
`keyframe_units_per_second = 60` is no longer "the unit is 1/60 s". It is "the
game presented these screens at 60 Hz on the console" -- a harder statement, and
checkable.
✅ And supported for the first time. Canary unlimited presents at 51-55 Hz with a
splash dwell of 4.30/4.60/4.37 s. A natively 30 Hz game would present at ~30 in
Canary too -- the framerate_limit run proves it, since forcing 30 made that same
splash take 8.45 s. It does not take 8.45 s unforced. So the game asks for ~60.
Kept as `authored`, not promoted: this is inference over three measurements
rather than a measurement of units per second. It becomes `measured` when someone
reads the console's present rate for these screens directly.
🔴 AND IT CLOSES THE CONSTANT AS A CAUSE OF FINDING 3, in the direction that
matters. Under the frame-based model the only alternative is a 30 Hz console,
which puts the plate at 236/30 = 7.87 s -- LATER than the 3.93 s shipping, not
earlier. There is NO console present rate that makes the plate arrive sooner than
this port already shows it. The human reported it late; no value of this constant
can produce that.
The method note is theirs and it is the durable part: four positions on this
number were inference over a measured quantity; this one changed an input and
watched what moved. The opportunistic comparison -- two captures that happened to
differ -- pointed exactly the wrong way, because nothing controlled what else
differed between them. One designed capture settled it against its author's
expectation.
Not settled: finding 3, still with no surviving cause; the clock origin, which
they are taking next and which every ratio and count in this account survives;
the ~1.0-1.2 menu residual; the allowance's grep trigger.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018AHUQvXGyNcKonSEWsgWcX
