Recover transparent geometry submit (+1,285 meaningful code, zero exact losses); reconcile COMMON ownership and Q10 85+EXT1 credit, actions/main data, and separately disclosed denominator corrections. Preserve canonical-only repairs and all held research. C09 is ordinary disclosed cleanup, not a claim of proven scaffolding intent. Clean rebuild, 1,663 tests, parks, audits, provider links and independent EXT1 check pass. Local reconciliation only.
Independently gate storage + K, OQ-4 P-a/P-b1, four static-local packets and comment-only disclosures. Preserve all 7641 exact owner rows, 71 valid parks and 1161 passing tests; code/data credit unchanged. G and game_engine admission remain held because current canonical loses populate_statistic_buffer. Existing collision static-local repair is not duplicated. No donor tree, held candidate, scorer or private asset imported.
Structural lane batch 1: +8,512 padded / +8,459 meaningful bytes strict
exact (8 functions), zero stable-verdict regressions.
- aim_assist.c: _player_aim_projectile (Lane B body). The debug build
calls set_real_point3d with the three x+i sums; the pin_normal_to_cone3d
prototype now comes from the focused real_math_cones.h. The object stops
emitting _add_vectors3d and _distance3d and emits only the coalescing
_set_real_point3d, byte-identical to January's copy.
- path_obstacle_avoidance.c: _path_avoid_obstacles single-exit body
(Lane B). Its only blocker, the _debug_path/_debug_obstacles static
relabel, landed canonically in 4f4c8502.
- actor_perception.c: _actor_perception_friend_prop_is_attacking
(single exit, /Od 0x472cb0) and _actor_situation_update (/Od statement
order at 0x478d33).
- ui_widget.c: _display_error (/Od 0x65f2e0 shape) and
_widget_instance_text_box_is_focused (/Od 0x66c190 list arm).
- hud_weapon.c: _render_grenade_hud (parent index in its own local,
/Od 0x639128).
- hud_messaging.c: _hud_messaging_update from /Od 0x62cb90 (wchar_t[256]
buffer gives the 0x2a0 frame), plus two relocs.json retargets of a
one-before alias to _button_mappings-18.
- parked.json: unpark the three newly exact parked functions.
- docs: machine-readable manifest and the owner-decision packet.
Gate: ninja PASS, parks 121/0/0, admission 0 contradicted/0 revoked,
selected-provider link PASS on every touched unit, punning casts and
fake-scan leads unchanged, pytest 1152 passed / 5 skipped / 26 subtests.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Owner ruling 2026-09-20: admit the macro reuse, and update its evidence comment
to disclose that the hand-written parenthesised form also matches here.
The function closes strictly exact from plain source plus one reuse of the
already-admitted TU-private actor_perception_distance_squared macro, at the
friend-target distance square.
The plain-source parts, each shown load-bearing by reverting it alone:
- actor_emotion_assess_unopposable_danger spells its priority as
if (facing <= 1) priority = 3; else priority = 2; rather than (facing<=1)+2.
Both constants then thread through the inlined helper before if-conversion,
which removes the join test that had exiled the visibility arm out of line.
The helper itself stays byte-identical and EXACT at 112. This answers what
suppresses a hoist: remove the reason for the join test, not the placement.
- a redundant if (target_count > 0) guard around the priority-adjust loop is
deleted; that IL-changing, code-preserving guard had tipped a whole-function
allocator state to the wrong side.
- block-scope iterator, one function-scope target_index, and named
upper_bound / lower_bound reals at both random-range sites (the action_guard.c
idiom).
The macro comment now carries the honest ladder, re-derived independently
before the ruling: d*d and (d*d) fail at size 1280, while (d)*(d) and the
macro's ((d)*(d)) both match. Unlike the first site, the single-parenthesis
hand spelling also matches here, so this site alone does not prove a macro
stood there; the comment says so, and that the macro is used here by ruling.
Verified: full ninja green; code 1,460,468 -> 1,461,731 (7,301 -> 7,302
functions); 11,060 function rows and 1,706 section rows diffed board-wide with
0 worse, the only movement being the target and actor_perception .text;
actor_perception 39/5 -> 40/4; parks 181 active / 0 stale / 0 invalid; forbid
guard exit 0; fake_match_scan 0 findings.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Owner ruling 2026-09-20: admit as a target-proven BUG with a precise source
comment, a layout assertion, and independent verification.
January scans the threat array from NUMBER_OF_ACTOR_THREAT_TYPES rather than
from NUMBER_OF_ACTOR_THREAT_TYPES-1, so its first iteration reads
specific_threats[9] - one element past the end. Proven from raw bytes: mov eax,9
at +0xf5, a six-byte alignment nop touching neither EAX nor memory, the loop head
at +0x100, the load at +0x103, and dec eax only at +0x10d, after the load.
The same read was refused earlier because it was being landed on a function that
would stay fuzzy. That premise no longer holds - the function is now STRICT
EXACT, so January's own bytes prove the access rather than a reconstruction
guessing at it.
Per the ruling the layout is now ASSERTED rather than assumed. Two compile-time
assertions in this file's existing assertion block state that specific_threats
holds exactly NUMBER_OF_ACTOR_THREAT_TYPES elements and that cumulative_threats
begins immediately after it, so the stray index is
cumulative_threats[_actor_threat_none] and nothing else. If either stops
holding, the file stops compiling.
Independent verification, done before the landing rather than taken on trust:
every use of cumulative_threats in the whole tree is index 1 through 8 or the
literal 5; index 0 is never written anywhere; and the single variable-index use
is a read-only csprintf argument in the actor_debug_print_threat debug macro.
The stray byte is therefore always zero, the early-out never fires on it, and
observable behaviour is unchanged. The comment now records all of that.
The byte ledger closes exactly at 19 differing bytes and was verified additively
- closing either half alone leaves the function residual at 13 or 18 bytes, so
the crouch restructure could not have been landed alone. The second half is a
semantics-preserving if/else-if restructure; all four input combinations traced.
Verified: full ninja green, halobetacache 1,460,468 / 1,770,166 (7,301 / 7,574),
actor_perception 38/6 to 39/5 with no sibling lost, relocations 38/38 and zero
differing rows, parks 181 active / 0 stale / 0 invalid, forbid-guard exit 0,
fake_match_scan 0 findings.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
None of these four close a function, so none of them bank a byte and the record
says so plainly. The board metric is unchanged at 1,458,814 / 7,300.
_actor_perception_aiming_vector_test_blockage - the only one that moves a HIGHER
ranked key. The 16-byte size gap is closed: both builds are 400 padded bytes and
the gate row goes [size 384!=400, sha] to [sha], with REAL regions 9 to 7.
January does not use a result/blockage PAIR but ONE short carrier whose live
range VC7 splits three ways. That was forced by running the return-width law
BACKWARDS: in a short function a literal return 1; emits mov ax,1, but January
emits mov eax,1, so January's constants are assignments to a short local whose
register home is eax. The decode independently corroborates the cascade I read
from January's bytes earlier in this session.
_actor_emotion_unopposable_retreat 47 -> 44 REAL regions.
_actor_destination_update 24 -> 20 REAL regions.
_actor_move_update ties every ranked key; one instruction moves
from differing to matching. Its one-line change is spelling
vehicle->vehicle.airborne_ticks as > 0. I verified the load-bearing claim myself
and it is stronger than stated: the field is byte at vehicle_datum.h:26, so the
two forms are provably identical on an unsigned type; vehicles.c:2309 spells
this exact expression on this exact field; and EVERY other use of the field in
the tree is an explicit comparison, so the bare truth test was the anomaly.
The blockage landing stales a second parked entry, whose evidence explicitly
said the size gap was 'not attributed to a proved compiler mechanism'. It now
is, so the measurements are refreshed and the evidence records the decode.
objdiff falls 56.21528 to 54.791668 there, which is diagnostic only and never
credit - every authoritative key improved or held. Both functions stay parked
because neither is exact. parked.json was edited by line surgery.
Verified: full ninja green, parks 181 active / 0 stale / 0 invalid, all 11 lane
units gated per row with no row lost, forbid-guards exit 0, fake_match_scan 0
findings on both touched files.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
I committed in 4410f35e that part (c) of this package was PROVEN IMPOSSIBLE,
on a lab showing that a short-returning function always emits 'mov ax,3' for a
returned constant. That conclusion was wrong because the lab only ever tested
'return <constant>;'.
A board-wide scan settles it: 122 narrow-returning functions in our own build
emit 'mov eax,imm' immediately before ret, including _actor_visibility_at_point
in this very object, which is EXACT. The corrected law, stated as the verifier
required rather than as the decoding agent first wrote it:
In a narrow-returning function, 'return <constant>;' materialises the constant
at RETURN-SLOT width (mov ax,K), while a constant assigned to a single-exit
accumulator materialises it at REGISTER width (mov eax,K). The accumulator's
own width is INERT - short and long accumulators both reach 38/6. It is the
declared RETURN TYPE that flips callers to cleanup-first; the body rewrite
alone buys nothing.
So January's 'mov eax,3' never meant a wide return type. It meant the single-exit
idiom this campaign already knows January uses, and which this file uses nine
times over.
actor_get_perception_knowledge becomes short in both definition and declaration,
with its body rewritten to the file's own goto done idiom. All three functions
are now EXACT: the callee holds at 240, _actor_perception_update banks 4,720 and
_prop_status_refresh banks 3,680.
The third file is why this is not the two-file change that was proposed. The
landing also improves a PARKED function's bytes - ai_communication's
_ai_communication_actor_talk_weight goes 99.31293 to 99.993195 percent - which
stales its recorded evidence and fails ninja's PROGRESS gate outright. Its
measurements are refreshed and the two sentences this landing falsifies are
rewritten: the entry asserted that the long return type was definition-correct
and that a narrow declaration contradicted the owner definition, and both are
now untrue. The function is still not exact, so it stays parked, and its
residual is down to a single real region. parked.json was edited by line
surgery, never re-serialized.
Verified: full ninja green, halobetacache 1,458,814 / 1,770,166 (7,300 / 7,574),
all 11 lane units gated per row, exactly two rows gained and none lost.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
All three functions remain residual, so this banks ZERO strict bytes. A
residual's padded size is its potential, not a realized gain, and the record
says so throughout.
ai_communication _ai_communication_event
restores a re-fetched actor_get(subject_actor_index) January has in the
_comm_look_direction_danger case. size 7856 -> 7888 (target 8064),
relocations 328 -> 330 (target 336). The identifier is not invented:
January's assert macro baked `subject_actor->danger_zone.object_index
!= NONE` into the object, so any other name swaps a string COMDAT.
actor_perception _prop_status_refresh
three boolean stores put in props.h declaration order (noncombat,
in_combat, fighting - we had fighting first), plus the owner-approved
macro at its squared-distance site. REAL regions 52 -> 4.
actor_perception _actor_perception_update
the owner-approved macro at its two remaining sites.
REAL regions 14 -> 2.
The _prop_status_refresh decode is the best mechanism work of the wave. A
register-blind structural diff (normalise every register name, then re-diff)
showed the instruction multiset identical in every cluster but one: January
`xor edx,edx; mov dx,[eax+0x182]` against our `movsx eax,[eax+0x182]`. That
single site was the whole deficit, and the renaming FORCES it - ours landed the
destination on EAX which also held the definition pointer, making
`xor eax,eax; mov ax,[eax+...]` impossible. Control: the sibling site in
_actor_perception_refresh_danger_zone compiles to `xor ecx,ecx; mov cx,[eax+0x182]`
in BOTH builds from identical source, proving it is not a type or cast issue.
Verified: ninja exit 0, halobetacache 1,448,422 / 1,770,166 (7,295 / 7,574)
unchanged as expected; stable_verdicts REGRESSIONS 0; parked 183 active / 0
stale / 0 invalid; the mandatory
`gate.py source/ai/actor_perception --forbid-emitted-symbol _point_from_line3d`
guard still exits 0; git diff --check clean.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
OWNER RULING: "Land _actor_perception_refresh (+2,416) with a TU-private,
descriptively named inferred macro and documented evidence. Do not land
_ai_test_line_of_sight uninitialized read."
Both parts honoured. _ai_test_line_of_sight stays held and unlanded; its diff
and evidence remain in scratch only.
The macro is translation-unit private - a #define in the .c, no header touched -
named actor_perception_distance_squared to match its sibling
actor_perception_distance_squared2d already in the same macro block, and it
carries a comment that says plainly it is INFERRED FROM JANUARY'S BYTES and not
attested in any surviving source. The comment reproduces the measurement that
justifies it, with the rest of the function held constant:
prop->distance * prop->distance residual
(prop->distance) * (prop->distance) residual
(prop->distance * prop->distance) residual
bind a local first, (distance * distance) residual
((prop->distance) * (prop->distance)) EXACT
Only the canonical macro expansion reaches January. A hand-written expression
does not produce the doubly-parenthesised form; a correctly written macro
produces it inevitably, which is why the byte evidence is itself the argument
that a macro stood here. The second hunk - an explicit if/else giving that
else-if arm its own cross-jump resolution - carries its own comment recording
that the two are required jointly; I measured each alone and both are residual.
Verified: EXACT 2416, relocdiff `sha equal` with 0 differing rows, 86/86
relocations, unit census 35/9 -> 36/8, fake_match_scan 0 findings, no sibling
lost, comments did not shift any match_assert line literal.
Wave B totals after this landing:
halobetacache 1,448,422 / 1,770,166 (7,295 / 7,574)
overall 1,469,654 (7,562)
stable_verdicts gained 3, 4,240 padded bytes, REGRESSIONS 0
parked 183 active / 0 stale / 0 invalid
Net for the wave: +4,229 meaningful bytes, +3 functions, 0 regressions, one
whole object closed and one park retired.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Ten residuals decoded in parallel, each on its own scratch copy, every proposed
landing re-measured by an adversarial verifier and a third time by the
orchestrator against the pristine tree. Targets were picked by the board
censuses added earlier this session.
EXACT, +1,817 meaningful bytes / +2 functions / 0 regressions:
source/ai/actor_firing_position _pre_evaluator_attack 1120 B
26/27 -> 27/27, THE WHOLE OBJECT CLOSES
source/ai/ai_debug _code_0003a910 704 B
57/60 -> 58/60
_pre_evaluator_attack was the +12 frame class, and the census called it: the
function homed twelve bytes more than January with [ebp-0x40] never referenced
at all - the elided-aggregate-member signature. The cause was a hand-expanded
library idiom, scale_vector3d + add_vectors3d + a real_vector3d temporary,
where January writes point_from_line3d in place. That spelling, casts included,
is verbatim real_math.c:2536 inside point_to_line_distance_squared3d, and the
change is a net deletion. Frames now agree at sub esp,0x34; relocdiff 39/39,
0 differing rows. The verifier confirmed the patched function's RAW bytes are
identical to January's, not merely equal under the normalized hash.
_code_0003a910 is target-proven: January emits ONE fdivr against 1.0f and THREE
fmul, so `scale = 1.0f/vertex_count` then three `*= scale` is its source, not a
rounding liberty; three `/=` divides would emit three fdivs. vehicle_stuck in
units/vehicles.c writes the same centroid the same way.
Landed at explicitly ZERO credit, because both functions remain residual and
both verifiers were emphatic that a residual's potential is not a realized
gain:
ai_debug _ai_debug_render_actor a real off-by-one CORRECTED
actor_perception _actor_perception_update an invented macro replaced by
real_math.h's genuine helper
The render_actor fix is a defect, not byte-steering: `switch (target_type-1)`
with case labels that are the enumerators and _actor_target_none == 0 dispatches
every type onto the previous colour and sends _actor_target_damaging_enemy into
the asserting default arm. January proves the compiler subtracts 1 itself
(`dec eax` where we emitted `add eax,-2`).
A park retired. _pre_evaluator_attack was parked `unclassified`; the frame
census contradicted that class and was right. parked.json 184 -> 183 entries,
no other entry touched, never re-serialized. First park retired by the census;
it says 35 more carry the same kind of evidence.
HELD, not landed, and both are deliberate:
_ai_test_line_of_sight drops an initialiser January lacks, which is
byte-proven, but lands an uninitialised read on a function that stays
residual - the same class as the owner's standing hold on
_actor_emotion_update's out-of-bounds read, and worth zero credit.
_actor_perception_refresh gates strictly EXACT at 2,416 bytes, the biggest
win this wave found, but needs a macro we would be inventing. A five-way
strip test shows ONLY the full canonical macro expansion ((a) * (a))
reaches January - four simpler spellings all stay residual - and neither
of its two hunks works alone. That cuts both ways and the ruling is the
owner's, not a lane orchestrator's. Full evidence in the wave report.
Negatives worth more than some landings: _encounter_create, 23 shapes, no
landing - its -4 frame is not a missing local but which pointer wins EBX, and
the previous wave's "spill slot" reading is refuted by `count` at [ebp-8].
_prop_get_active_by_unit_index, 60 gated builds mapping the entire reachable
image of a 144-byte function to three hashes, January's not among them - a
whole-function ECX/EDX two-colouring. Both agents also caught metric traps
where a shape matches January's instruction count by coincidence while
diverging earlier.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Integrate six accepted exact functions, two whole-object admissions, evidence-backed zero-credit source corrections, owner-header cleanup, and curated campaign records. Preserve zero regressions and exclude generated scratch archives from canonical history.
Wave n2 of the next-150K lane.
- actor_perception _actor_perception_refresh_test_object (+1744).
- ai_debug _code_00041220 (+2336): closed by spelling January's counting loop as
a while loop with the initialiser before it instead of a for with an empty
body. It also carries a names-only rename packet: config/symbols.json line 654
and the three C identifiers become _ai_debug_render_encounter, which is house
rule 7 (no code_<address> names). The name is authenticated by the January map
atlas (scratch/atlas/ai_debug.obj.txt line 44, "00041220 fuzzy ai_debug.obj
_ai_debug_render_encounter"), whose offsets for this object cross-validate
against symbols.json (_ai_debug_dispose_from_old_map 226736, _ai_debug_drawstack
235808, _ai_debug_render 269120), and corroborated by caller topology
(_ai_debug_render passes ai_debug.selected_squad_index), the encounter_* callee
set and the firing-position assert literal. No PDB public exists at 266784,
consistent with the static. The rename carries no additional byte credit.
Rejected and not landed: devices _device_frontfacing (exact, but a live standing
hold) and the decals _debug_decals relabel (symbols.json line 22482 has no object
at 4414816; the worker's own proposal is to delete that entry, which is a config
question, not a landing).
Full ninja, parks 274 active / 0 stale / 0 invalid, stable diff vs
scratch/opus5-next150-before.json: gained 7 / 6,832 padded, regressions 0; fake
scan 0 leads.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Retain 18 strict exact-function gains across Actions, Actor Combat, Decals, Game Engine, Object Lights, and Bipeds after removing donor bodies that regressed exact objects, emitted unowned code, or violated source-credibility rules. Name authenticated private symbols, move declarations to owner headers, record honest residual parks, and preserve units.obj at 189/189.
Jonas Volman