qvm: nested ground action

docs/ASSET_PIPELINE_TODO.md

@@ -318,3 +318,6 @@ Research progress: [QVM combined posture/ground callees](research/QVM_COMBINED_G
 
 
 Research progress: [QVM54981 forward traces/rebase/main routing](research/QVM_ACTION_PROBE.md) completes bounded RE-525–527: contact-bit geometry/retrace, recursive origin/landing and actual post-timer main producer across42 standalone/16 main cases. RE-524/528 retain nested ground-loss action/query/other modes/native/consumers/full runtime/platform work and broad game/rendering milestones.
+
+
+Research progress: [QVM nested ground-loss action](research/QVM_LOST_ACTION.md) completes bounded RE-529–531: actual54981(1) before sentinel/flags, rebased deep-query priority and distinct later main54981(0) across48 standalone/12 main cases. RE-528/532 retain query/other modes/native/consumers/full runtime/platform work and broad game/rendering milestones.

docs/FINDINGS.md

@@ -660,3 +660,10 @@ Bounded qagame paths recover bomb-plant/inactivity correction requests, direct f
 **F-254 — Recursive origin policy:**argument1 can rebase to supplied trace end Z+24, recursively evaluate argument0 and invoke actual landing with the parent entity if flags12 remain. Clear child suppresses landing while preserving the rebase. [ACTIONPROBE-002](research/QVM_ACTION_PROBE.md).
 
 **F-255 — Actual main54981 routing:**16 post-timer action chains select eight evaluated41768, six omitted55465 and two omitted43626 requests from actual produced flags. Ground-loss's nested54981 request, query/other modes/native/full runtime remain open. [ACTIONPROBE-003](research/QVM_ACTION_PROBE.md).
+
+
+**F-256 — Actual nested action priority:**46527 runs54981(1) before checking old-ground1023 then updated flags12. New flags can suppress the deep trace and preserve an existing plane; the sentinel path clears it first. Initial flags&12 still skip the prepared action. [LOSTACTION-001](research/QVM_LOST_ACTION.md).
+
+**F-257 — Deep trace consumes rebase:**clear recursive action can leave origin[101,202,304] for the later64-unit query; flag-producing recursion skips that query/ground-loss animation. Outer46773 still clears plane/walk after helper return. [LOSTACTION-002](research/QVM_LOST_ACTION.md).
+
+**F-258 — Two actual action call sites:**nested54981(1) runs before main timer, then main54981(0) clears/rebuilds flags and query gating. Twelve reached41768 chains retain actual post-ground landing/timer/event/resource state; native/full main/runtime remain open. [LOSTACTION-003](research/QVM_LOST_ACTION.md).

docs/PROVISIONAL_TODO.md

@@ -630,3 +630,6 @@ Research progress: [QVM combined posture/ground callees](research/QVM_COMBINED_G
 
 
 Research progress: [QVM54981 forward traces/rebase/main routing](research/QVM_ACTION_PROBE.md) completes bounded RE-525–527: contact-bit geometry/retrace, recursive origin/landing and actual post-timer main producer across42 standalone/16 main cases. RE-524/528 retain nested ground-loss action/query/other modes/native/consumers/full runtime/platform work and broad game/rendering milestones.
+
+
+Research progress: [QVM nested ground-loss action](research/QVM_LOST_ACTION.md) completes bounded RE-529–531: actual54981(1) before sentinel/flags, rebased deep-query priority and distinct later main54981(0) across48 standalone/12 main cases. RE-528/532 retain query/other modes/native/consumers/full runtime/platform work and broad game/rendering milestones.

docs/RESEARCH_LEDGER.md

@@ -411,3 +411,7 @@ Completed bounded RE-521–523 with `analyze_qvm_combined_ground.py`:18 shared-s
 ## 2026-10-19 — Game-QVM54981 forward probes, recursive rebase and actual main producer
 
 Completed bounded RE-525–527 with `analyze_qvm_action_probe.py`:42 standalone54981 probes and16 actual main post-timer chains. ACTIONPROBE-001–003/F-253–255 recover existing12/32 entry and16 exit gates, clearing12, planar supplied-basis normalization/root/zero path, viewheight first trace and conditional entity-exclusion retry with mask65537, feet probe mask33619969 and trace-surface8-driven PS8/4 stores. Argument1 uses Z−24/ten-unit geometry, qualifying supplied endpoint rebase Z+24, actual disjoint-frame argument0 recursion and conditional45912 with parent entity/current snapshot state. Explicit rebase fixtures preserve[101,202,304] whether landing is suppressed or reached; native endpoint validity remains unverified. Actual main54981(0) consumes live aged posture/ground state before query/routing, producing eight evaluated41768, six omitted55465 and two omitted43626 requests. Main bridge adds optional action effect with byte-identical defaults. Ground-loss nested54981(1), query/alternative modes/other suffix effects remain omitted in reused chains. Native roots/records/positions/basis/state remain supplied; no original executable/full QVM/native collision/physics/rendering executes. Eight independent tests verify all guard/normalization/geometry/retry/flag/recursion/landing outputs and entry handoffs, parent entity/rebase persistence, source pointer/mask/root arguments/zero basis,16 posture-ground-timer-action snapshots, query/mode counts and reached slide/mode/post-ground states, provenance and scope. All663 tests pass. Prior main-contact and combined-ground reports regenerate byte-identically; new action report reproduces twice byte-identically (924731 bytes). Storage/filter setup, documentation links and whitespace checks pass. No assets or shared instruction evaluator changed. RE-524 remains open for broader scope; RE-528 tracks nested ground-loss action/query/other modes/native/legal/consumers/real producers and complete main/scheduler/macOS/Linux Rust/Bevy/Solari gameplay. Broad game/assets/rendering/protocol milestones remain open.
+
+## 2026-10-19 — Game-QVM nested ground-loss action and main re-probe ordering
+
+Completed bounded RE-529–531 with `analyze_qvm_lost_action.py`:48 standalone46527/nested54981 cases and12 actual posture-ground-timer-main-action/movement/post-environment chains. LOSTACTION-001–003/F-256–258 recover actual54981(1) before old-ground sentinel and updated flags rereads, initial flags&12 prepared-child suppression, sentinel-first plane clearing versus new-contact-bit early exit/plane retention, rebased64-unit deep geometry after a clear recursive child and deep-query/animation suppression after flag-producing recursion. Main then executes distinct54981(0), clearing/rebuilding flags/query gating while128 selects41768 in all12 controls; actual first-clear slide/wrapper/gravity/post-ground landing/touch/event/resource states remain shared. Later outer ground landing can store250 after main aging, unlike nested landing's own effects. Optional action callback in lost and optional lost callback in combined ground preserve original defaults/reports. Roots/native records/endpoints/basis/input/state remain supplied; logging/query/alternative modes/other suffix/native consumers/full53418/scheduler/legal collision/platform gameplay remain omitted or unverified. No original executable/full QVM/native collision/physics/rendering executes. Eight independent tests verify all helper/child/caller states, sentinel/flags/rebase/query priority and twelve skipped actions, main entry/two call-site identity/query gates, reached mode/post-ground parent timer states, final queue/resource/animation persistence, source identity and scope. All671 tests pass. Prior ground-callee, combined-ground and action-probe reports regenerate byte-identically; new report reproduces twice byte-identically (1295119 bytes). Storage/filter setup, documentation links and whitespace checks pass. No assets or shared instruction evaluator changed. RE-528 remains open for broader scope; RE-532 tracks actual query/alternative modes/consumers/real producers/native/legal and complete main/scheduler/macOS/Linux Rust/Bevy/Solari gameplay. Broad game/assets/rendering/protocol milestones remain open.

docs/REVERSE_ENGINEERING_TODO.md

@@ -654,3 +654,9 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 - [x] RE-526 Evaluate argument1 origin rebase/argument0 recursion and conditional actual landing with parent entity and live snapshot state ([ACTIONPROBE-002](research/QVM_ACTION_PROBE.md)).
 - [x] RE-527 Evaluate actual main54981(0) after timer aging and derive query/mode routing plus selected movement/post-ground outputs ([ACTIONPROBE-003](research/QVM_ACTION_PROBE.md)).
 - [ ] RE-528 Compose54981 inside ground loss, actual56639/query and alternative55465/41848/other modes, remaining suffix/event/PS216 consumers/real basis-input-environment/native collision ABI/legal domains; complete main/scheduler/macOS/Linux Rust/Bevy/Solari gameplay and broader game/assets/rendering/protocol work.
+
+
+- [x] RE-529 Evaluate54981(1) at46527's actual request before ground-sentinel/flags rereads, preserving initial early skips ([LOSTACTION-001](research/QVM_LOST_ACTION.md)).
+- [x] RE-530 Recover action-produced flag suppression/plane priority and rebased deep-query/animation state with actual caller clearing ([LOSTACTION-002](research/QVM_LOST_ACTION.md)).
+- [x] RE-531 Compose nested ground action before main timer and distinct main54981(0), reached mode/post-ground/landing/queue/resource state ([LOSTACTION-003](research/QVM_LOST_ACTION.md)).
+- [ ] RE-532 Recover actual56639/query and alternative55465/41848/other modes, event/PS216/suffix consumers, real basis/input/environment/native collision ABI/legal domains and complete main/scheduler/macOS/Linux Rust/Bevy/Solari gameplay; continue broader game/assets/rendering/protocol work.

docs/research/QVM_ACTION_PROBE.md

@@ -35,3 +35,6 @@ The main bridge exposes an optional reached action effect while preserving old d
 Eight tests independently verify all42 standalone guards/normalization/geometries/retry/flag/recursion/landing outcomes, zero basis, source masks/pointers, recursive origin persistence and parent argument,16 actual main entry snapshots and reached posture/ground state, action-derived mode/query counts, selected slide/mode/post-ground outputs, source hash/partition and supplied/omitted-effect scope. Reproducibility/full-suite/storage/link/whitespace results are recorded in the ledger.
 
 RE-524 remains open for its broader query/mode/native/consumer/runtime scope. RE-528 tracks actual54981 effects inside ground-loss callers,56639/query and alternative55465/41848/other movement bodies, remaining suffix/event/PS216 consumers, real basis/input/environment/native collision/legal domains and complete main/scheduler/macOS/Linux Rust/Bevy/Solari gameplay. Other game/assets/rendering/protocol milestones remain open.
+
+
+Follow-up: [ground-loss nested action composition](QVM_LOST_ACTION.md) completes bounded RE-529–531, attaching the recovered argument1 body inside46527 and distinguishing the later main argument0 re-probe. This earlier report retains its original omitted-nested scope.

docs/research/QVM_GROUND_CALLEES.md

@@ -41,3 +41,6 @@ Follow-up: [complete bounded landing body](QVM_LANDING.md) completes RE-513–51
 
 
 Follow-up: [helper54981 body](QVM_ACTION_PROBE.md) completes bounded RE-525–527 for standalone argument1 and actual main argument0. This report retains its omitted54981 effects inside46527; attaching the recovered child there remains explicit follow-up work.
+
+
+Follow-up: [actual54981 inside ground loss](QVM_LOST_ACTION.md) completes bounded RE-529–531 and checks sentinel/flag/deep-query decisions against updated child state. Original no-callback reports remain unchanged; native/query/mode/runtime limits stay explicit.

docs/research/QVM_LOST_ACTION.md

@@ -0,0 +1,35 @@
+# QVM ground-loss nested action and main re-probe ordering
+
+This batch completes bounded RE-529–531 / F-256–258 by evaluating54981(1) inside46527, then carrying its real effects through the remaining ground-loss decisions and main54981(0). It extends [ground loss](QVM_GROUND_CALLEES.md), [helper54981](QVM_ACTION_PROBE.md) and [combined main ground state](QVM_COMBINED_GROUND.md). Native responses and remaining main effects stay supplied or omitted.
+
+Reproduce with `python3 scripts/analyze_qvm_lost_action.py`; validate with `python3 scripts/test_qvm_lost_action.py`. The [machine report](qvm-lost-action.json) retains source identity,48 standalone nested-action probes and12 actual main chains with child/caller snapshots. No original executable, full QVM, native collision, physics or rendering executes.
+
+## LOSTACTION-001 — Actual child before sentinel and flag rereads (RE-529)
+
+The standalone grid varies initial flags0/4/16/4096, old ground7/1023, three supplied action patterns and deep fraction0.5/1. Initial flags&12 still take46527's early ground/plane/walk reset and skip54981 entirely. Twelve fixtures take that early branch; their prepared child effects are not attached.
+
+Otherwise46527 sets32, requests54981(1), then reads actual updated state. The child can normalize/probe, rebase origin, recursively evaluate54981(0) and invoke landing/event writers as recovered earlier. The old-ground1023 check follows the action and precedes the flags&12 reread. Sentinel1023 clears the plane indicator and skips deep probing. With existing ground and newly produced flags12, the helper exits immediately without its later plane-clear store. Standalone plane1 can therefore survive that branch, while sentinel controls clear it.
+
+The optional reached-action callback is applied after the source CALL/POP boundary and before these rereads. Original no-callback reports remain byte-identical. Logging, native collision legality, callback side effects and unmodeled action semantics remain open.
+
+## LOSTACTION-002 — Rebased deep geometry and animation priority (RE-530)
+
+A clear recursive action child can preserve its origin rebase while leaving flags12 clear. Ground loss then builds its64-unit deep query from that updated origin. Explicit fixtures trace from[101,202,304] to[101,202,240], rather than the pre-action origin. A flag-producing recursive child suppresses that deep query and its associated ground-loss animation. The action's own bit16 early exit can instead leave the original origin for a later deep query; the model checks actual reached branches rather than prepared pattern names.
+
+When deep probing is reached, supplied fraction1 retains the prior recovered4096/direction/animation/ground reset policy; fraction0.5 retains old ground/walk within the helper and clears plane. Actual animation/landing/queue effects from the nested action remain live. The outer46773 caller still clears plane/walk after returning from ground loss, so helper retention and actual caller output remain distinct.
+
+Roots, basis, native endpoints/fractions and finite state are supplied. Rebased endpoints demonstrate source arithmetic/control flow, not a collision-consistent geometry or real escape/contact domain.
+
+## LOSTACTION-003 — Nested argument1 before main argument0 (RE-531)
+
+Twelve main chains combine entered/standing posture, no-hit/clear-recursive/flag-recursive nested patterns and no-hit/feet-hit main patterns. The first ground fraction1 path evaluates the nested54981(1) before main timer aging. Main then invokes a separate54981(0) at its actual post-timer boundary. Source request identity and shared state are checked independently for these two call sites.
+
+The main argument0 re-probe can clear the nested flags12 or set feet bit4 again. That changes whether query56639 is requested, while existing128 still selects41768 in all12 controls. Reached first-clear slide/wrapper/gravity state feeds the later combined ground/landing/touch children. Ground's later landing call can store movement timer250 after the earlier main aging; other paths finish with0. The nested landing call inside54981 does not itself receive the outer ground caller's250 store.
+
+Final contents preserves actual resource, animation, numeric event queue and extended ground state. Native content/stand/ground/deep/slide/down/overlap/root responses remain supplied. Query/alternative-mode/other suffix/native consumers, clock-to-main gap/full53418/scheduler and macOS/Linux Rust/Bevy/Solari gameplay remain open.
+
+## Validation and next tasks
+
+Eight tests independently verify all48 nested/helper outcomes, sentinel-versus-new-flag priority and plane retention, rebased deep geometry, twelve skipped prepared actions, actual posture/ground/timer entry handoffs, distinct nested/main argument calls and query gating,12 reached slide/mode/post-ground states and conditional caller250 stores, final event/resource/animation persistence, source identity and supplied-effect limits. Reproducibility/full-suite/storage/link/whitespace results are recorded in the ledger.
+
+RE-528 remains open for broader query/mode/native/consumer/runtime scope; ground-loss54981 integration is covered by RE-529–531. RE-532 tracks actual56639/query and alternative55465/41848/other movement bodies, remaining event/PS216/suffix consumers, real basis/input/environment/native collision ABI/legal domains and complete main/scheduler/macOS/Linux Rust/Bevy/Solari gameplay. Other game/assets/rendering/protocol milestones remain open.

docs/research/README.md

@@ -231,3 +231,6 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [QVM54981 forward probes and main producer](QVM_ACTION_PROBE.md) adds RE-525–527. Reproduce with `python3 scripts/analyze_qvm_action_probe.py`; check with `python3 scripts/test_qvm_action_probe.py`. Actual main argument0 effects and standalone recursive argument1 evaluate; nested ground-loss integration/query/other modes/native/full runtime remain open.
+
+
+[QVM ground-loss nested action and main re-probe](QVM_LOST_ACTION.md) adds RE-529–531. Reproduce with `python3 scripts/analyze_qvm_lost_action.py`; check with `python3 scripts/test_qvm_lost_action.py`. Actual nested/main action ordering composes with ground/movement; query/other modes/native/full runtime remain open.

scripts/analyze_qvm_combined_ground.py

@@ -25,7 +25,7 @@ def state(m):
     r=env_state(m);r.update({'bounds':vec(m,FRAME+184)+vec(m,FRAME+196),'legs':m[PS+76]&0xffffffff,'leg_timer':m[PS+72],'meter':m[PS+184],'entity_flags':m[PS+104]&0xffffffff,'queue':queue(m),'field216':m[PS+216],'field8':m[PS+8],'state220':m[PS+220]&0xffffffff,'field440':m[PS+440]});return r
 
 
-def ground_all(ins,m,kind,escape=None,followup='flat'):
+def ground_all(ins,m,kind,escape=None,followup='flat',lost_effect=None):
     before=state(m);pc=46774;calls=[];trace=[];children=[];native=None
     stops=[46847,46860,46873,46983,47022,47190,47215]
     while True:
@@ -37,7 +37,7 @@ def ground_all(ins,m,kind,escape=None,followup='flat'):
         elif pc==46860:
             c=t['calls'][-1];old=state(m);m,r=recovery(ins,m,c['args'][8],escape,followup);m[GROUND+112]=r['return_word'];children.append({'target':46296,'before':old,'report':r,'after':state(m)})
         elif pc==46873 and t['calls'] and t['calls'][-1]['target']==46527:
-            old=state(m);m,r=lost(ins,m,1,1);children.append({'target':46527,'before':old,'report':r,'after':state(m)})
+            old=state(m);m,r=lost_effect(ins,m) if lost_effect else lost(ins,m,1,1);children.append({'target':46527,'before':old,'report':r,'after':state(m)})
         elif pc==47190:
             c=t['calls'][-1];old=state(m);m,r=landing(ins,m,c['args'][8]);children.append({'target':45912,'before':old,'report':r,'after':state(m)})
         elif pc in [46983,47022,47215] and t['calls'] and t['calls'][-1]['target'] in [39525,39253]:

scripts/analyze_qvm_ground_callees.py

@@ -23,18 +23,21 @@ def memory(flags=0,oldground=7,legs=25):
     m=seed(flags=flags,velocity=(10,20,0));m.update({PS+4:0,PS+68:oldground,PS+72:17,PS+76:legs,PS+220:0x12345000,PS+440:99,FRAME+32:0,35023936:1,35024012:word(300),35024024:word(-100)});return m
 
 
-def lost(ins,m,fraction=1,forward=1):
-    initial=state(m);pc=46528;trace=[];calls=[];request=None;children=[]
+def lost(ins,m,fraction=1,forward=1,action_effect=None):
+    initial=state(m);pc=46528;trace=[];calls=[];request=None;children=[];action=None
     while True:
-        t=trace_slice(ins,46528,46771,m,{},resume_at=pc,stop_targets=[s for s in [46668,46719,46758] if s!=pc],local_base=LOST,byte_memory={FRAME+25:forward&255},limit=1024);m=t['memory'];pc=t['stop'];trace+=t['trace'];calls+=t['calls']
-        if pc==46668:
+        t=trace_slice(ins,46528,46771,m,{},resume_at=pc,stop_targets=[s for s in ([46668,46719,46758]+([46573] if action_effect else [])) if s!=pc],local_base=LOST,byte_memory={FRAME+25:forward&255},limit=1024);m=t['memory'];pc=t['stop'];trace+=t['trace'];calls+=t['calls']
+        if action_effect and pc==46573:m,action=action_effect(ins,m)
+        elif pc==46668:
             c=t['calls'][-1];a=c['args'];request={'call':c,'start':vec(m,a[12]),'end':vec(m,a[24]),'bounds':vec(m,a[16])+vec(m,a[20]),'supplied_fraction':word(fraction)};m[a[8]+8]=word(fraction)
         elif pc in [46719,46758]:
             if not t['calls']:continue
             c=t['calls'][-1];before=state(m);child=evaluate(ins,39525,c['args'][8],m);m=child['memory'];children.append({'request':c['args'][8],'before':before,'after':state(m),'calls':child['calls'],**trace_fields(child,False)})
         elif pc==46771:break
         else:raise AssertionError('Unexpected lost boundary')
-    return m,{'initial':initial,'forward':forward,'fraction':word(fraction),'request':request,'animation_children':children,'final':state(m),'calls':calls,**trace_fields({'trace':trace},False)}
+    report={'initial':initial,'forward':forward,'fraction':word(fraction),'request':request,'animation_children':children,'final':state(m),'calls':calls,**trace_fields({'trace':trace},False)}
+    if action_effect:report['action']=action
+    return m,report
 
 
 def landing_prefix(ins,previous,delta,flags,legs):

scripts/analyze_qvm_lost_action.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+"""Actual54981(1) inside46527 with deep-query and main54981(0) ordering."""
+import itertools,json
+from pathlib import Path
+from analyze_qvm import decode,write_json
+from analyze_qvm_acceleration import PS,FRAME,word
+from analyze_qvm_ground_callees import lost
+from analyze_qvm_action_probe import action,memory,PATTERNS
+from analyze_qvm_combined_ground import ground_all,state
+from analyze_qvm_main_posture import posture
+from analyze_qvm_main_environment import contents
+from analyze_qvm_main_contact import probe
+from analyze_vm_extensions import verified
+
+
+def coupled(ins,m,pattern,fraction=1):
+    def effect(ins,m):return action(ins,m,1,PATTERNS[pattern])
+    return lost(ins,m,fraction,1,action_effect=effect)
+
+
+def standalone(ins,flags,oldground,pattern,fraction):
+    m=memory(flags);m.update({PS+68:oldground,35023940:1,35023936:1});_,p=coupled(ins,m,pattern,fraction);p['pattern']=pattern;return p
+
+
+def main_case(ins,variant,pattern,main_pattern):
+    flags=160 if variant=='enter' else 161;up=-1 if variant=='enter' else 0
+    def lost_child(ins,m):return coupled(ins,m,pattern)
+    def environment(ins,m,target,phase):
+        if target==47217:m,r=contents(ins,m,[0,0,0]);r['combined_after']=state(m)
+        else:m,r=ground_all(ins,m,'air' if phase=='before' else 'flat',lost_effect=lost_child)
+        r['phase']=phase;return m,r
+    def post(ins,m):return posture(ins,m,up,0)
+    def main_action(ins,m):return action(ins,m,0,PATTERNS[main_pattern])
+    m=memory(flags);m[PS+40]=word(-300)
+    p=probe(ins,1016,0,flags,'clear',initial_memory=m,environment_effect=environment,posture_effect=post,action_effect=main_action);p.update({'variant':variant,'nested_pattern':pattern,'main_pattern':main_pattern});return p
+
+
+def main():
+    q=json.loads(Path('docs/research/qvm/qagame.json').read_text());_,ins=decode(verified(Path(q['source']['member']['output']).read_bytes(),q['sha256']))
+    out={'source':q['source'],'sha256':q['sha256'],'probes':[standalone(ins,*v) for v in itertools.product([0,4,16,4096],[7,1023],['none','recurse_clear','recurse_flags'],[.5,1])],'main_chains':[main_case(ins,*v) for v in itertools.product(['enter','stand_clear'],['none','recurse_clear','recurse_flags'],['none','feet'])],'limitations':'Bounded finite shipped-QVM nested ground-loss action composition; no original executable/full QVM/native collision/physics/rendering executes. Actual46527 calls54981(1), reached recursive54981(0)/landing/events, then reads updated ground/flags before deep-query/animation decisions. Actual main pre-ground includes nested action before timer and main54981(0); reached posture/ground/mode/slide/post-environment children share state. Native trace/contents/root records/endpoints and initial state/basis remain supplied, not collision-derived; prepared unreachable effects are not attached. Logging/query/alternative-mode/other suffix/native consumers, full53418/scheduler/legal collision domains/macOS/Linux/Rust/Bevy/Solari gameplay remain omitted or unverified.'};write_json(Path('docs/research/qvm-lost-action.json'),out);print('Composed ground-loss nested action and actual main re-probe ordering')
+
+
+if __name__=='__main__':main()

scripts/test_qvm_lost_action.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""Independent nested-action caller priority and shared main state checks."""
+import hashlib,json
+from pathlib import Path
+import unittest
+from test_qvm_ground import f,n,word
+from test_qvm_action_probe import check_action
+from test_qvm_main_posture import expected_posture
+from test_qvm_combined_ground import ground_expected
+from test_qvm_slide_repeated import oracle as slide_oracle
+
+
+def check_lost(test,p):
+    s=dict(p['initial']);a=p['action'];request=None
+    if s['flags']&12:
+        test.assertIsNone(a);s.update({'ground':1023,'plane':0,'walk':0})
+    else:
+        test.assertIsNotNone(a);s['flags']|=32
+        for k,v in s.items():test.assertEqual(a['initial'][k],v)
+        full=check_action(test,a)
+        for k in s:s[k]=full[k]
+        if s['ground']==1023:s['plane']=0
+        elif s['flags']&12:pass
+        else:
+            request=full['origin'];test.assertIsNotNone(p['request']);test.assertEqual(p['request']['start'],request);test.assertEqual(p['request']['end'],request[:2]+[word(f(n(request[2])-64))])
+            if n(p['fraction'])==1:
+                old=bool(s['flags']&4096);s['flags']^=4096;r=26 if old else 28
+                if s['legs']!=r:s['legs']=(((s['legs']&128)^128)|r)&0xffffffff;s['leg_timer']=0
+                s.update({'ground':1023,'walk':0})
+            s['plane']=0
+    test.assertEqual(p['request'] is not None,request is not None);test.assertEqual(p['final'],s);test.assertEqual(sum(c['target']==54981 for c in p['calls']),int(not bool(p['initial']['flags']&12)));return s
+
+
+def first_ground_expected(test,g):
+    s=dict(g['before']);r=g['native']['record'];s.update({'normal':r[6:9],'surface':r[11]});child=next(c for c in g['children'] if c['target']==46527);test.assertEqual(child['before'],s);small=check_lost(test,child['report'])
+    if child['report']['action']:s=check_action(test,child['report']['action'])
+    for k,v in small.items():s[k]=v
+    s.update({'plane':0,'walk':0});return s
+
+
+class QvmLostActionTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):cls.r=json.loads(Path('docs/research/qvm-lost-action.json').read_text())
+
+    def test_all_nested_action_and_lost_results_against_independent_model(self):
+        self.assertEqual(len(self.r['probes']),48)
+        for p in self.r['probes']:check_lost(self,p)
+
+    def test_sentinel_precedes_new_flag_exit_and_preserves_plane_only_when_reached(self):
+        preserved=cleared=False
+        for p in self.r['probes']:
+            a=p['action']
+            if not a or not a['final']['flags']&12:continue
+            self.assertIsNone(p['request'])
+            if p['initial']['ground']==1023:self.assertEqual(p['final']['plane'],0);cleared=True
+            else:self.assertEqual(p['final']['plane'],1);preserved=True
+        self.assertTrue(preserved and cleared)
+
+    def test_rebased_deep_trace_and_initial_guard_suppress_unreached_effects(self):
+        rebased=False;skipped=0
+        for p in self.r['probes']:
+            if p['initial']['flags']&12:self.assertIsNone(p['action']);self.assertEqual(p['animation_children'],[]);skipped+=1
+            if p['request'] and p['pattern']=='recurse_clear' and p['action']['recursive']:self.assertEqual(p['request']['start'],list(map(word,[101,202,304])));self.assertEqual(p['request']['end'],list(map(word,[101,202,240])));rebased=True
+        self.assertTrue(rebased);self.assertEqual(skipped,12)
+
+    def test_actual_main_posture_to_nested_action_to_timer_entry(self):
+        self.assertEqual(len(self.r['main_chains']),12)
+        for p in self.r['main_chains']:
+            self.assertEqual(p['posture']['final'],expected_posture(p)[0]);g=p['environment'][1];self.assertEqual(g['after'],first_ground_expected(self,g));self.assertEqual(p['timer']['before']['flags'],g['after']['flags']);self.assertEqual(p['timer']['before']['leg'],g['after']['leg_timer']);self.assertEqual(p['timer']['before']['movement'],0);self.assertEqual(p['action']['initial']['leg_timer'],p['timer']['after']['leg']);check_action(self,p['action'])
+
+    def test_distinct_nested_and_main_action_calls_and_query_routing(self):
+        for p in self.r['main_chains']:
+            lost=next(c for c in p['environment'][1]['children'] if c['target']==46527)['report'];self.assertEqual(lost['action']['argument'],1);self.assertEqual(p['action']['argument'],0);self.assertEqual(sum(c['target']==54981 for c in p['calls']),1);self.assertEqual(sum(c['target']==54981 for c in lost['calls']),1);self.assertEqual(p['selected_mode'],41768);self.assertEqual(any(c['target']==56639 for c in p['calls']),p['main_pattern']=='none')
+            if p['main_pattern']=='none':self.assertEqual(p['action']['final']['flags']&12,0)
+            else:self.assertTrue(p['action']['final']['flags']&4)
+
+    def test_reached_motion_and_post_ground_parent_landing_timer(self):
+        landed=not_landed=False
+        for p in self.r['main_chains']:
+            mode=p['mode'];w=mode['wrapper'];a=p['action']['final'];self.assertEqual(mode['initial']['origin'],a['origin']);self.assertEqual(mode['initial']['flags'],a['flags']);entry=dict(w['before']);entry['ground_normal']=a['normal'];slide_oracle(self,w['first_slide'],entry);self.assertIsNone(w['step']);expected=dict(w['final']);vz=f(n(expected['velocity'][2])-f(f(800)*n(p['clock']['float_dt'])));expected['velocity']=expected['velocity'][:2]+[word(vz)]
+            if vz<0:expected['flags']&=~192;expected['timer']=0
+            self.assertEqual(mode['mode_final'],expected);g=p['environment'][2];self.assertEqual(g['after'],ground_expected(g,p['clock']['velocity_snapshot'][2]))
+            if any(c['target']==45912 for c in g['children']):self.assertEqual(g['after']['timer'],250);landed=True
+            else:self.assertEqual(g['after']['timer'],0);not_landed=True
+        self.assertTrue(landed and not_landed)
+
+    def test_shared_event_resource_and_animation_state_survives_final_contents(self):
+        for p in self.r['main_chains']:
+            g=p['environment'][2];c=p['environment'][3];expected=dict(g['after']);expected.update({'contents':c['after']['contents'],'level':c['after']['level']});self.assertEqual(c['combined_after'],expected)
+            for k in ['origin','velocity','flags','timer','touches']:self.assertEqual(p['final'][k],expected[k])
+            self.assertEqual(expected['meter'],p['posture']['final']['meter'])
+
+    def test_verified_source_and_omitted_native_full_runtime_scope(self):
+        q=json.loads(Path('docs/research/qvm/qagame.json').read_text());self.assertEqual(self.r['source'],q['source']);self.assertEqual(self.r['sha256'],hashlib.sha256(Path(q['source']['member']['output']).read_bytes()).hexdigest())
+        for text in ['no original executable/full QVM/native collision/physics/rendering executes','reads updated ground/flags','not collision-derived','Logging/query/alternative-mode/other suffix/native consumers']:self.assertIn(text,self.r['limitations'])
+
+
+if __name__=='__main__':unittest.main()