qvm: complete bounded walking

docs/ASSET_PIPELINE_TODO.md

@@ -367,3 +367,6 @@ Research progress: RE-556 [report](research/QVM_WALK_WISH.md); remaining native/
 
 
 Research progress: RE-557 [report](research/QVM_WALK_POLICY.md); remaining native/content/runtime/platform scope stays open.
+
+
+Research progress: RE-558 [report](research/QVM_WALKING_MODE.md); remaining native/content/runtime/platform scope stays open.

docs/FINDINGS.md

@@ -725,3 +725,6 @@ Bounded qagame paths recover bomb-plant/inactivity correction requests, direct f
 
 
 **RE-557 — Recover walking speed policy acceleration projection and resource:** Walking applies flag/state/resource/water caps then a timed state128 override, selects acceleration from surface/flags/speed, performs two normalized plane projections and passes saved pre-projection speed into39595. [Evidence](research/QVM_WALK_POLICY.md).
+
+
+**RE-558 — Complete bounded walking wrapper and combined main handoffs:** Complete43626 routes actual entry to air/water or normal policy, clears32 and runs60091(0) only when horizontal velocity is nonzero; actual main posture/contents/ground/timer/action/query and post-ground share the resulting state. [Evidence](research/QVM_WALKING_MODE.md).

docs/PROVISIONAL_TODO.md

@@ -679,3 +679,6 @@ Research progress: RE-556 [report](research/QVM_WALK_WISH.md); remaining native/
 
 
 Research progress: RE-557 [report](research/QVM_WALK_POLICY.md); remaining native/content/runtime/platform scope stays open.
+
+
+Research progress: RE-558 [report](research/QVM_WALKING_MODE.md); remaining native/content/runtime/platform scope stays open.

docs/RESEARCH_LEDGER.md

@@ -487,3 +487,12 @@ Walking friction and copied-command scaling precede actual40679, flattening and
 ## 2026-10-19 — RE-557 Recover walking speed policy acceleration projection and resource (separate task commit)
 
 Walking applies flag/state/resource/water caps then a timed state128 override, selects acceleration from surface/flags/speed, performs two normalized plane projections and passes saved pre-projection speed into39595. 30 command/policy profiles and four independent tests reproduce exact speed/cap/coefficient rounding, acceleration, both projections, timed250 boundary and resource outputs. Full suite: 755 tests pass. Report regenerates byte-identically (416388 bytes). Storage/filter, links and whitespace checks pass. No assets/Rust runtime/shared VM evaluator changed; native/reference/legal/full platform scope remains open.
+
+
+## 2026-10-19 — RE-558 Complete bounded walking wrapper and combined main handoffs (separate task commit)
+
+Complete43626 routes actual entry to air/water or normal policy, clears32 and runs60091(0) only when horizontal velocity is nonzero; actual main posture/contents/ground/timer/action/query and post-ground share the resulting state. 26 standalone/8 combined-main fixtures and four independent tests compose all prior child oracles, native-supplied wrapper/step paths, zero-horizontal controls, entry events/resource and higher-priority mode suppression. All ten direct test entrypoints are executable. Full suite: 759 tests pass. Report regenerates byte-identically (1716605 bytes). Storage/filter, links and whitespace checks pass. No assets/Rust runtime/shared VM evaluator changed; native/reference/legal/full platform scope remains open.
+
+### Ten-task batch final regression audit
+
+RE-549–558 each has its own code/tests/report/documentation commit. All759 tests pass; all ten direct test commands execute four tests each. Ten new reports and six prior contact/main/active/flagged/walk-entry/air reports regenerate byte-identically after final integration. New reports remain below the2MiB normal-Git cap. Completed coverage and explicit native-supplied limits are indexed in `research/QVM_MOVEMENT_BATCH.md`; RE-559 preserves remaining original-reference/native/runtime/rendering/content/platform work. No asset payloads or Rust runtime were added.

docs/REVERSE_ENGINEERING_TODO.md

@@ -716,3 +716,9 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-557 Recover walking speed policy acceleration projection and resource ([report](research/QVM_WALK_POLICY.md)).
+
+
+- [ ] RE-559 Validate these movement paths against original execution and collision-consistent native traces; complete remaining main prefix/suffix/scheduler/event-resource-animation consumers, full cross-module rules/network/audio/rendering/assets coverage and Rust/Bevy/Solari macOS/Linux platform prototype and runtime. See the [ten-task batch](research/QVM_MOVEMENT_BATCH.md) for bounded completed coverage.
+
+
+- [x] RE-558 Complete bounded walking wrapper and combined main handoffs ([report](research/QVM_WALKING_MODE.md)).

docs/research/QVM_MOVEMENT_BATCH.md

@@ -4,15 +4,18 @@ Each task has its own tested code/report/documentation commit. Completed rows li
 
 | Task | Completion scope |
 | --- | --- |
-| RE-549 | Complete40679 direction classifier and idle transitions. |
-| RE-550 | File-backed162-direction encode/decode services and tie/index rules. |
-| RE-551 | Wall-contact42838 guards, trace geometry, hull restoration and failure state. |
-| RE-552 | Wall success40966/event86/animation and ordinary-air continuation. |
-| RE-553 | Complete41486 water-entry query and launch state. |
-| RE-554 | Actual41848 water-entry guard and41768 fallback routing. |
-| RE-555 | Remaining41848 swim wish/acceleration/clip/slide body. |
-| RE-556 | Walking43626 ordinary direction/basis/wish producer. |
-| RE-557 | Walking acceleration, slope velocity and resource suffix. |
-| RE-558 | Complete bounded walking wrapper and actual main/environment handoffs. |
+| [RE-549](QVM_MOVE_DIRECTION.md) ✓ | Complete40679 direction classifier and idle transitions. |
+| [RE-550](QVM_DIRECTION_CODEC.md) ✓ | File-backed162-direction encode/decode services and tie/index rules. |
+| [RE-551](QVM_WALL_PROBE.md) ✓ | Wall-contact42838 guards, trace geometry, hull restoration and failure state. |
+| [RE-552](QVM_WALL_ACTION.md) ✓ | Wall success40966/event86/animation and ordinary-air continuation. |
+| [RE-553](QVM_WATER_ENTRY.md) ✓ | Complete41486 water-entry query and launch state. |
+| [RE-554](QVM_WATER_ROUTE.md) ✓ | Actual41848 water-entry guard and41768 fallback routing. |
+| [RE-555](QVM_SWIM_MODE.md) ✓ | Remaining41848 swim wish/acceleration/clip/slide body. |
+| [RE-556](QVM_WALK_WISH.md) ✓ | Walking43626 ordinary direction/basis/wish producer. |
+| [RE-557](QVM_WALK_POLICY.md) ✓ | Walking acceleration, slope velocity and resource suffix. |
+| [RE-558](QVM_WALKING_MODE.md) ✓ | Complete bounded walking wrapper and actual main/environment handoffs. |
 
 Native roots, trace/content records and initial finite state remain supplied until actual native behavior is established. These tasks add research fixtures, not a Rust/Bevy/Solari runtime or platform proof. The wall/swim/walk scopes may expose additional required callees; those dependencies are recovered or explicitly recorded within the corresponding task before it is marked complete.
+
+
+All ten tasks are complete as separately tested commits. Each report labels finite/native-supplied inputs and remaining runtime limits. The final batch verifies all direct test entrypoints, full-suite checks and byte-identical regeneration of existing reports. RE-559 tracks follow-up reference/native/renderer/runtime and remaining scheduler/consumer work.

docs/research/QVM_WALKING_MODE.md

@@ -0,0 +1,7 @@
+# Complete bounded walking wrapper and combined main handoffs
+
+RE-558. Reproduce with `python3 scripts/analyze_qvm_walking_mode.py`; check with `python3 scripts/test_qvm_walking_mode.py`. The [machine report](qvm-walking-mode.json) retains source identity and bounded fixtures.
+
+Normal walking now continues after the resource update into source horizontal-zero routing and the real gravity-off60091 wrapper, including conditional step/second-slide/fallback. A vertical-only control confirms the skip checks X/Y, not full speed. Successful40966 delegation uses actual ordinary air or41848 water body/fallback; normal walking uses the recovered speed/resource policy. Eight main fixtures combine actual posture, contents, ground, timer, action, query, selected movement and post-environment. Flat-ground source processing can clear128 before dispatch; retained128 controls use supplied steep-ground responses and select41768, suppressing walking effects. Native trace/content/root inputs remain supplied and legal consistency is unverified. The task also validates batch test CLI entrypoints and preserves earlier default report formats. Whole-game runtime, reference execution, native collision correctness, main prefix/suffix consumers, networking/rendering/assets and macOS/Linux Rust/Bevy/Solari implementation remain open.
+
+No original executable/full QVM/native collision/physics/rendering executes. Native responses and legal input domains are supplied or unverified where stated; full runtime/macOS/Linux Rust/Bevy/Solari gameplay remains open.

docs/research/README.md

@@ -280,3 +280,6 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-557: Recover walking speed policy acceleration projection and resource](QVM_WALK_POLICY.md). Reproduce with `python3 scripts/analyze_qvm_walk_policy.py`; check with `python3 scripts/test_qvm_walk_policy.py`.
+
+
+[RE-558: Complete bounded walking wrapper and combined main handoffs](QVM_WALKING_MODE.md). Reproduce with `python3 scripts/analyze_qvm_walking_mode.py`; check with `python3 scripts/test_qvm_walking_mode.py`.

scripts/analyze_qvm_walk_entry.py

@@ -18,7 +18,7 @@ from analyze_vm_extensions import verified
 LOCAL=0x62000000
 
 
-def route(ins,m,cmd,air_effect=None):
+def route(ins,m,cmd,air_effect=None,water_effect=None):
     initial=snapshot(m);level=m[FRAME+212];basis=[m[35023892+4*i]&0xffffffff for i in range(3)];normal=[m[35023968+4*i]&0xffffffff for i in range(3)];pc=43627;trace=[];calls=[];launch=None;air=None
     while True:
         t=trace_slice(ins,43627,45199,m,{},resume_at=pc,stop_targets=[s for s in [43662,43683] if s!=pc],local_base=LOCAL,call_results={43660:0},limit=1024);m=t['memory'];trace+=t['trace'];calls+=t['calls'];pc=t['stop']
@@ -26,7 +26,12 @@ def route(ins,m,cmd,air_effect=None):
         else:break
     delegated=[c['target'] for c in calls if c['target'] in [41848,42838]];target=delegated[0] if delegated else None
     if target==42838 and air_effect:m,air=air_effect(ins,m,cmd)
-    return m,{'initial':initial,'level':level,'basis':basis,'normal':normal,'commands':list(cmd),'entry':launch,'delegated_target':target,'stop_instruction':pc,'air':air,'final':snapshot(m),'calls':calls,**trace_fields({'trace':trace},False)}
+    water=None
+    if target==41848 and water_effect:m,water=water_effect(ins,m,cmd)
+    report={'initial':initial,'level':level,'basis':basis,'normal':normal,'commands':list(cmd),'entry':launch,'delegated_target':target,'stop_instruction':pc,'air':air,'final':snapshot(m),'calls':calls,**trace_fields({'trace':trace},False)}
+
+    if water_effect:report['water']=water
+    return m,report
 
 
 def main_case(ins,constants,up,flags,air_effect=None,meter=4000):

scripts/analyze_qvm_walking_mode.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""Full finite43626 routing/ordinary policy/wrapper and actual combined main."""
+import itertools
+from pathlib import Path
+from qvm_research_support import source,memory,constants,execute
+from analyze_qvm_walk_policy import policy,CONFIG
+from analyze_qvm_walk_wish import LOCAL
+from analyze_qvm_walk_entry import route
+from analyze_qvm_air_mode import air
+from analyze_qvm_swim_mode import swim
+from analyze_qvm_contact_callers import wrapper
+from analyze_qvm_acceleration import PS,FRAME,word
+from analyze_qvm_jump_entry import snapshot
+from analyze_qvm_main_contact import probe
+from analyze_qvm_main_environment import contents
+from analyze_qvm_combined_ground import ground_all
+from analyze_qvm_main_posture import posture
+from analyze_qvm_action_probe import action,PATTERNS
+from analyze_qvm_main_query import coupled
+from analyze_qvm import write_json
+
+
+def walking(ins,m,cmd,pattern='clear'):
+    def airborne(i,m,c):return air(i,m,c,pattern)
+    def water(i,m,c):return swim(i,m,c,(1,0) if c[2]>=10 else (0,0),pattern)
+    m,p=route(ins,m,cmd,airborne,water);normal=None;w=None;tail=None
+    if p['stop_instruction']==43683:
+        cmd=p['commands'];m,normal=policy(ins,m,cmd)
+        def move(i,m,a,c):
+            nonlocal w
+            m,w=wrapper(i,m,pattern,'clear','clear',a[8]);return m,c,w['return_word'],{}
+        m,cmd,tail=execute(ins,45143,45199,m,cmd,LOCAL,{60091:move})
+    return m,{'route':p,'policy':normal,'wrapper':w,'tail':tail,'final':snapshot(m)}
+
+
+def main():
+    q,raw,h,ins=source();cfg=constants(raw,h,CONFIG+[21196]);rows=[]
+    for cmd,level,pattern in itertools.product([(0,0,0),(100,0,0),(-128,127,0),(100,0,10)],[0,2,3],['clear','contacts']):
+        m=memory(raw,h,cmd);m.update(cfg);m[PS+220]=0;m[FRAME+212]=level;rows.append(walking(ins,m,cmd,pattern)[1])
+    for z in [0,1]:
+        m=memory(raw,h,(0,0,0),flags=32);m.update(cfg);m[PS+220]=0
+        for j,v in enumerate([0,0,z]):m[PS+32+4*j]=word(v)
+        for j,v in enumerate([0,0,1]):m[35023968+4*j]=word(v)
+        rows.append(walking(ins,m,(0,0,0))[1])
+    chains=[]
+    for up,flags,pattern in itertools.product([0,10],[32,160],['clear','contacts']):
+        cmd=(100,0,up);m=memory(raw,h,cmd,flags=flags);m.update(cfg);m.update({PS+220:0,PS+184:8000,PS+376:17})
+        def env(i,m,target,phase):
+            m,r=contents(i,m,[0,0,0]) if target==47217 else ground_all(i,m,'flat' if flags==32 else 'steep');r['phase']=phase;return m,r
+        def post(i,m):return posture(i,m,up,0)
+        def act(i,m):return action(i,m,0,PATTERNS['none'])
+        def query(i,m):return coupled(i,m,{'forward':100,'fractions':(1,1)})
+        def mode(i,m):return walking(i,m,cmd,pattern)
+        p=probe(ins,1016,0,flags,'clear',initial_memory=m,environment_effect=env,posture_effect=post,action_effect=act,query_effect=query,walking_mode_effect=mode);p.update({'commands':list(cmd),'input_flags':flags});chains.append(p)
+    write_json(Path('docs/research/qvm-walking-mode.json'),{'source':q['source'],'sha256':q['sha256'],'constants':{str(a):v for a,v in cfg.items()},'probes':rows,'main_chains':chains,'limits':'Full bounded43626 entry/ordinary/water-air delegation with recovered children; actual main posture/content/ground/timer/action/query/walking and post-environment share memory. Native roots/contents/stand/ground/slide/step traces supplied, not collision-derived. No original executable/full QVM/native physics/rendering executes. Remaining wall-specific main integration, other main prefix/suffix/consumers/native legal domains/reference execution/full Rust/Bevy/Solari platforms remain open.'})
+
+
+if __name__=='__main__':main()

scripts/test_qvm_direction_codec.py

@@ -27,3 +27,6 @@ class DirectionCodecTests(unittest.TestCase):
         q=json.loads(Path('docs/research/qvm/qagame.json').read_text());raw=Path(q['source']['member']['output']).read_bytes();h,_=decode(raw);self.assertEqual(self.r['sha256'],hashlib.sha256(raw).hexdigest())
         for i,v in enumerate(self.r['table']):
             for j,w in enumerate(v):self.assertEqual(int.from_bytes(raw[h['data_offset']+21732+12*i+4*j:h['data_offset']+21736+12*i+4*j],'little'),w)
+
+
+if __name__=='__main__':unittest.main()

scripts/test_qvm_move_direction.py

@@ -20,3 +20,6 @@ class MoveDirectionTests(unittest.TestCase):
         for p in self.r['probes']:self.assertEqual(p['calls'],[]);self.assertEqual(p['canary'],123)
     def test_source_partition_identity(self):
         q=json.loads(Path('docs/research/qvm/qagame.json').read_text());self.assertEqual(self.r['sha256'],hashlib.sha256(Path(q['source']['member']['output']).read_bytes()).hexdigest());self.assertEqual(self.r['instructions'][0]['index'],40679);self.assertEqual(self.r['instructions'][-1]['index'],40965)
+
+
+if __name__=='__main__':unittest.main()

scripts/test_qvm_swim_mode.py

@@ -40,3 +40,6 @@ class SwimTests(unittest.TestCase):
         self.assertEqual(sum(m['water_mode']['body'] is None for m in self.r['main_chains']),2)
         for m in self.r['main_chains']:
             p=m['water_mode'];self.assertEqual(p['body'] is None,p['prefix']['fallback'] is not None)
+
+
+if __name__=='__main__':unittest.main()

scripts/test_qvm_walk_policy.py

@@ -46,3 +46,6 @@ class WalkPolicyTests(unittest.TestCase):
     def test_surface_or_flag_selects_gravity_and_low_accel(self):
         rows=[p for p in self.r['probes'] if p['inputs']['surface']&2 or p['inputs']['flags']&64];self.assertEqual(len(rows),6)
         for p in rows:self.assertEqual(p['acceleration']['acceleration_float_word'],speed(p,self.c)[1])
+
+
+if __name__=='__main__':unittest.main()

scripts/test_qvm_walk_wish.py

@@ -31,3 +31,6 @@ class WalkWishTests(unittest.TestCase):
             flat=n(p['normal'][2])==1;self.assertEqual(all(n(v[2])==0 for v in p['basis_after']),flat)
     def test_idle_old2_and6_feed_real_direction_child(self):
         idle=[p for p in self.r['probes'] if p['scale']['movement_bytes']==[0,0,0]];self.assertEqual({p['direction']['after'] for p in idle},{1,7})
+
+
+if __name__=='__main__':unittest.main()

scripts/test_qvm_walking_mode.py

@@ -0,0 +1,57 @@
+import copy,json,unittest
+from pathlib import Path
+from test_qvm_ground import f,n,word
+from test_qvm_walk_policy import check as check_policy
+from test_qvm_air_mode import check as check_air
+from test_qvm_swim_mode import check as check_swim
+from test_qvm_water_route import check_wrapper
+from test_qvm_jump_entry import check as check_entry
+
+
+def check(test,p,c):
+    route=p['route']
+    if route['entry']:check_entry(test,route['entry'])
+    if p['policy']:
+        check_policy(test,p['policy'],c);s=copy.deepcopy(p['policy']['final']);s['flags']&=~32
+        if p['wrapper']:
+            w=p['wrapper'];check_wrapper(test,w,p['policy']['wish']['normal']);test.assertEqual(w['before']['velocity'],s['velocity']);test.assertEqual(w['before']['flags'],s['flags']);test.assertEqual(w['first_slide']['gravity'],0);s.update(w['final'])
+        else:test.assertEqual([n(x) for x in s['velocity'][:2]],[0,0]);test.assertEqual(p['tail']['calls'],[])
+        test.assertEqual(p['final'],s)
+    else:
+        test.assertEqual(p['final'],route['final'])
+        if route['air']:check_air(test,route['air'],c)
+        if route['water']:
+            w=route['water'];check_swim(test,w,c)
+            if w['prefix']['fallback']:
+                mode=w['prefix']['fallback'];check_wrapper(test,mode['wrapper'],w['prefix']['normal']);s=copy.deepcopy(mode['wrapper']['final']);z=f(n(s['velocity'][2])-f(800*n(w['prefix']['dt'])));s['velocity'][2]=word(z)
+                if z<0:s['flags']&=~192;s['timer']=0
+                test.assertEqual(mode['mode_final'],s)
+
+
+class WalkingModeTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):cls.r=json.loads(Path('docs/research/qvm-walking-mode.json').read_text());cls.c={21160:100,21212:1,21220:5,21224:3000,**{int(a):n(v) for a,v in cls.r['constants'].items()}}
+    def test_all26_walking_or_delegated_states(self):
+        self.assertEqual(len(self.r['probes']),26)
+        for p in self.r['probes']:check(self,p,self.c)
+    def test_horizontal_zero_skips_wrapper_even_vertical_nonzero(self):
+        a,b=self.r['probes'][-2:]
+        for p in [a,b]:self.assertIsNone(p['wrapper']);self.assertFalse(p['final']['flags']&32)
+        self.assertEqual(n(a['final']['velocity'][2]),0);self.assertEqual(n(b['final']['velocity'][2]),1)
+    def test_main_actual_selected_walking_and_mode_handoff(self):
+        self.assertEqual(len(self.r['main_chains']),8);count=0
+        for m in self.r['main_chains']:
+            p=m['walking_mode'];self.assertEqual(p is not None,m['selected_mode']==43626);self.assertIsNotNone(m['posture']);self.assertEqual(len(m['environment']),4)
+            if p:
+                count+=1;check(self,p,self.c);self.assertEqual(p['route']['initial']['velocity'],m['at_mode']['velocity']);self.assertEqual(p['final']['velocity'],m['after_dispatch']['velocity']);self.assertEqual(p['final']['origin'],m['after_dispatch']['origin'])
+            else:self.assertEqual(m['selected_mode'],41768)
+        self.assertEqual(count,4)
+    def test_resource_and_entry_queue_survive_wrapper_and_main(self):
+        for m in self.r['main_chains']:
+            p=m['walking_mode']
+            if p:
+                self.assertEqual(m['walking_final']['184'],p['final']['meter']);self.assertEqual(m['walking_final']['108'],p['final']['queue']['sequence'])
+                if m['commands'][2]==10:self.assertEqual(p['final']['queue']['events'][0],99);self.assertIsNotNone(p['route']['air'])
+
+
+if __name__=='__main__':unittest.main()

scripts/test_qvm_wall_action.py

@@ -31,3 +31,6 @@ class WallActionTests(unittest.TestCase):
         for p in self.r['probes']:
             if p['air']:
                 check_air(self,p['air'],self.c);self.assertEqual(p['air']['initial']['velocity'],p['before_air']['velocity']);self.assertEqual(p['final']['velocity'],p['air']['final']['velocity']);self.assertEqual(p['final']['queue'],p['before_air']['queue'])
+
+
+if __name__=='__main__':unittest.main()

scripts/test_qvm_wall_probe.py

@@ -23,3 +23,6 @@ class WallProbeTests(unittest.TestCase):
         for p in self.r['probes']:
             self.assertEqual(len(p['calls']),int(p['request'] is not None))
             if p['old_count']==5:self.assertIsNone(p['request'])
+
+
+if __name__=='__main__':unittest.main()

scripts/test_qvm_water_entry.py

@@ -22,3 +22,6 @@ class WaterEntryTests(unittest.TestCase):
             for j,q in enumerate(p['queries']):self.assertEqual(q['point'],base[:2]+[word(f(n(base[2])+4+16*j))]);self.assertEqual(q['entity'],7)
     def test_no_event_or_inventory_cost_side_effect(self):
         for p in self.r['probes']:self.assertEqual(p['final']['queue'],p['initial']['queue']);self.assertEqual(p['final']['meter'],p['initial']['meter']);self.assertEqual(p['final']['inventory'],p['initial']['inventory'])
+
+
+if __name__=='__main__':unittest.main()

scripts/test_qvm_water_route.py

@@ -36,3 +36,6 @@ class WaterRouteTests(unittest.TestCase):
                 for k,v in s.items():self.assertEqual(p['final'][k],v)
     def test_call_order_no_prepared_fallback_on_failure(self):
         for p in self.r['probes']:self.assertEqual([c['target'] for c in p['execution']['calls']],[41486,41768] if p['fallback'] else [41486])
+
+
+if __name__=='__main__':unittest.main()