qvm: expose explicit child byte effects

docs/FINDINGS.md

@@ -1406,3 +1406,6 @@ RE-791–800 adds exact Rust source-sort/ranking parity, mixed count/prefix sema
 
 
 **RE-802:** Bounded tracing can now preserve byte/word coherence and execute unaligned byte copies without changing legacy observations. [Evidence](research/QVM_COHERENT_MEMORY.md).
+
+
+**RE-803:** Both bounded resumers now support validated child byte writes, coherent word mirroring and explicit word/byte/return precedence. [Evidence](research/QVM_CHILD_BYTE_EFFECTS.md).

docs/PROVISIONAL_TODO.md

@@ -1413,3 +1413,6 @@ RE-791–800 validation: 1,562 Python and102 Rust tests pass;226 affected produc
 
 
 RE-802: Bounded tracing can now preserve byte/word coherence and execute unaligned byte copies without changing legacy observations. Full runtime completion remains open. [Evidence](research/QVM_COHERENT_MEMORY.md).
+
+
+RE-803: Both bounded resumers now support validated child byte writes, coherent word mirroring and explicit word/byte/return precedence. Full runtime completion remains open. [Evidence](research/QVM_CHILD_BYTE_EFFECTS.md).

docs/RESEARCH_LEDGER.md

@@ -1676,3 +1676,8 @@ After exactly ten task commits from `c6b4a1eb`, the single `cargo xtask test-ful
 ## 2026-10-26 — RE-802 Opt-in coherent byte and unaligned word research memory
 
 Bounded tracing can now preserve byte/word coherence and execute unaligned byte copies without changing legacy observations. Focused `cargo xtask test-group coherent-memory` passes (6 Python tests); selected reports regenerate twice deterministically, with storage, documentation links and whitespace guards. Full suite deferred to task ten. Original assets unchanged; source fixtures do not establish complete native/runtime parity.
+
+
+## 2026-10-26 — RE-803 Explicit child byte effects and read-only shared byte views
+
+Both bounded resumers now support validated child byte writes, coherent word mirroring and explicit word/byte/return precedence. Focused `cargo xtask test-group child-byte-effects` passes (6 Python tests); selected reports regenerate twice deterministically, with storage, documentation links and whitespace guards. Full suite deferred to task ten. Original assets unchanged; source fixtures do not establish complete native/runtime parity.

docs/REVERSE_ENGINEERING_TODO.md

@@ -1456,3 +1456,6 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-802 Opt-in coherent byte and unaligned word research memory ([evidence](research/QVM_COHERENT_MEMORY.md)).
+
+
+- [x] RE-803 Explicit child byte effects and read-only shared byte views ([evidence](research/QVM_CHILD_BYTE_EFFECTS.md)).

docs/research/QVM_CHILD_BYTE_EFFECTS.md

@@ -0,0 +1,7 @@
+# Explicit child byte effects and read-only shared byte views
+
+RE-803. Reproduce with `python3 scripts/analyze_qvm_child_byte_effects.py`; focused validation: `cargo xtask test-group child-byte-effects`. [Machine report](qvm-child-byte-effects.json).
+
+Forty independent byte-lane probes verify child word writes followed by explicit byte overrides across trace and movement resumers. Children receive a read-only byte view and return child_memory_bytes effects; capture of final byte state is opt-in. Movement command tuples retain precedence at the next segment. Unsupported modes reject. Legacy handlers and defaults retain their signatures and behavior.
+
+Original executable/native runtime and complete Linux/macOS Rust/Bevy/Solari acceptance remain unverified.

docs/research/README.md

@@ -996,3 +996,6 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-802: Opt-in coherent byte and unaligned word research memory](QVM_COHERENT_MEMORY.md).
+
+
+[RE-803: Explicit child byte effects and read-only shared byte views](QVM_CHILD_BYTE_EFFECTS.md).

docs/research/qvm-child-byte-effects.json

@@ -0,0 +1,325 @@
+{
+  "limits": "Explicit opt-in read-only child byte view plus validated child_memory_bytes effects. Changed words apply before byte overrides; returned CALL value patch follows both. Movement command tuple remains authoritative at the next segment. No complete native VM/ABI claim.",
+  "probes": [
+    {
+      "byte": 0,
+      "kind": "trace",
+      "lane": 0,
+      "locked": true,
+      "result": 1432778496,
+      "stored": 1432778496
+    },
+    {
+      "byte": 1,
+      "kind": "trace",
+      "lane": 0,
+      "locked": true,
+      "result": 1432778497,
+      "stored": 1432778497
+    },
+    {
+      "byte": 127,
+      "kind": "trace",
+      "lane": 0,
+      "locked": true,
+      "result": 1432778623,
+      "stored": 1432778623
+    },
+    {
+      "byte": 128,
+      "kind": "trace",
+      "lane": 0,
+      "locked": true,
+      "result": 1432778624,
+      "stored": 1432778624
+    },
+    {
+      "byte": 255,
+      "kind": "trace",
+      "lane": 0,
+      "locked": true,
+      "result": 1432778751,
+      "stored": 1432778751
+    },
+    {
+      "byte": 0,
+      "kind": "trace",
+      "lane": 1,
+      "locked": true,
+      "result": 1432748168,
+      "stored": 1432748168
+    },
+    {
+      "byte": 1,
+      "kind": "trace",
+      "lane": 1,
+      "locked": true,
+      "result": 1432748424,
+      "stored": 1432748424
+    },
+    {
+      "byte": 127,
+      "kind": "trace",
+      "lane": 1,
+      "locked": true,
+      "result": 1432780680,
+      "stored": 1432780680
+    },
+    {
+      "byte": 128,
+      "kind": "trace",
+      "lane": 1,
+      "locked": true,
+      "result": 1432780936,
+      "stored": 1432780936
+    },
+    {
+      "byte": 255,
+      "kind": "trace",
+      "lane": 1,
+      "locked": true,
+      "result": 1432813448,
+      "stored": 1432813448
+    },
+    {
+      "byte": 0,
+      "kind": "trace",
+      "lane": 2,
+      "locked": true,
+      "result": 1426093960,
+      "stored": 1426093960
+    },
+    {
+      "byte": 1,
+      "kind": "trace",
+      "lane": 2,
+      "locked": true,
+      "result": 1426159496,
+      "stored": 1426159496
+    },
+    {
+      "byte": 127,
+      "kind": "trace",
+      "lane": 2,
+      "locked": true,
+      "result": 1434417032,
+      "stored": 1434417032
+    },
+    {
+      "byte": 128,
+      "kind": "trace",
+      "lane": 2,
+      "locked": true,
+      "result": 1434482568,
+      "stored": 1434482568
+    },
+    {
+      "byte": 255,
+      "kind": "trace",
+      "lane": 2,
+      "locked": true,
+      "result": 1442805640,
+      "stored": 1442805640
+    },
+    {
+      "byte": 0,
+      "kind": "trace",
+      "lane": 3,
+      "locked": true,
+      "result": 6715272,
+      "stored": 6715272
+    },
+    {
+      "byte": 1,
+      "kind": "trace",
+      "lane": 3,
+      "locked": true,
+      "result": 23492488,
+      "stored": 23492488
+    },
+    {
+      "byte": 127,
+      "kind": "trace",
+      "lane": 3,
+      "locked": true,
+      "result": 2137421704,
+      "stored": 2137421704
+    },
+    {
+      "byte": 128,
+      "kind": "trace",
+      "lane": 3,
+      "locked": true,
+      "result": 2154198920,
+      "stored": 2154198920
+    },
+    {
+      "byte": 255,
+      "kind": "trace",
+      "lane": 3,
+      "locked": true,
+      "result": 4284905352,
+      "stored": 4284905352
+    },
+    {
+      "byte": 0,
+      "kind": "movement",
+      "lane": 0,
+      "locked": true,
+      "result": 1432778496,
+      "stored": 1432778496
+    },
+    {
+      "byte": 1,
+      "kind": "movement",
+      "lane": 0,
+      "locked": true,
+      "result": 1432778497,
+      "stored": 1432778497
+    },
+    {
+      "byte": 127,
+      "kind": "movement",
+      "lane": 0,
+      "locked": true,
+      "result": 1432778623,
+      "stored": 1432778623
+    },
+    {
+      "byte": 128,
+      "kind": "movement",
+      "lane": 0,
+      "locked": true,
+      "result": 1432778624,
+      "stored": 1432778624
+    },
+    {
+      "byte": 255,
+      "kind": "movement",
+      "lane": 0,
+      "locked": true,
+      "result": 1432778751,
+      "stored": 1432778751
+    },
+    {
+      "byte": 0,
+      "kind": "movement",
+      "lane": 1,
+      "locked": true,
+      "result": 1432748168,
+      "stored": 1432748168
+    },
+    {
+      "byte": 1,
+      "kind": "movement",
+      "lane": 1,
+      "locked": true,
+      "result": 1432748424,
+      "stored": 1432748424
+    },
+    {
+      "byte": 127,
+      "kind": "movement",
+      "lane": 1,
+      "locked": true,
+      "result": 1432780680,
+      "stored": 1432780680
+    },
+    {
+      "byte": 128,
+      "kind": "movement",
+      "lane": 1,
+      "locked": true,
+      "result": 1432780936,
+      "stored": 1432780936
+    },
+    {
+      "byte": 255,
+      "kind": "movement",
+      "lane": 1,
+      "locked": true,
+      "result": 1432813448,
+      "stored": 1432813448
+    },
+    {
+      "byte": 0,
+      "kind": "movement",
+      "lane": 2,
+      "locked": true,
+      "result": 1426093960,
+      "stored": 1426093960
+    },
+    {
+      "byte": 1,
+      "kind": "movement",
+      "lane": 2,
+      "locked": true,
+      "result": 1426159496,
+      "stored": 1426159496
+    },
+    {
+      "byte": 127,
+      "kind": "movement",
+      "lane": 2,
+      "locked": true,
+      "result": 1434417032,
+      "stored": 1434417032
+    },
+    {
+      "byte": 128,
+      "kind": "movement",
+      "lane": 2,
+      "locked": true,
+      "result": 1434482568,
+      "stored": 1434482568
+    },
+    {
+      "byte": 255,
+      "kind": "movement",
+      "lane": 2,
+      "locked": true,
+      "result": 1442805640,
+      "stored": 1442805640
+    },
+    {
+      "byte": 0,
+      "kind": "movement",
+      "lane": 3,
+      "locked": true,
+      "result": 6715272,
+      "stored": 6715272
+    },
+    {
+      "byte": 1,
+      "kind": "movement",
+      "lane": 3,
+      "locked": true,
+      "result": 23492488,
+      "stored": 23492488
+    },
+    {
+      "byte": 127,
+      "kind": "movement",
+      "lane": 3,
+      "locked": true,
+      "result": 2137421704,
+      "stored": 2137421704
+    },
+    {
+      "byte": 128,
+      "kind": "movement",
+      "lane": 3,
+      "locked": true,
+      "result": 2154198920,
+      "stored": 2154198920
+    },
+    {
+      "byte": 255,
+      "kind": "movement",
+      "lane": 3,
+      "locked": true,
+      "result": 4284905352,
+      "stored": 4284905352
+    }
+  ]
+}

docs/research/qvm-resumer-audit.json

@@ -674,6 +674,28 @@
       "repeated_calls_opt_in": false,
       "repeated_calls_setting": "default_false"
     },
+    {
+      "backward_conditional_branches": [],
+      "calls": [],
+      "explicit_result_offsets": null,
+      "helper": "qvm_trace_support.resume",
+      "line": 20,
+      "literal_range": null,
+      "path": "scripts/analyze_qvm_child_byte_effects.py",
+      "repeated_calls_opt_in": false,
+      "repeated_calls_setting": "default_false"
+    },
+    {
+      "backward_conditional_branches": [],
+      "calls": [],
+      "explicit_result_offsets": null,
+      "helper": "qvm_research_support.execute",
+      "line": 23,
+      "literal_range": null,
+      "path": "scripts/analyze_qvm_child_byte_effects.py",
+      "repeated_calls_opt_in": false,
+      "repeated_calls_setting": "default_false"
+    },
     {
       "backward_conditional_branches": [
         22261
@@ -9410,10 +9432,10 @@
     }
   },
   "summary": {
-    "call_expressions": 186,
-    "files": 145,
-    "legacy_expressions": 156,
-    "nonliteral_ranges": 22,
+    "call_expressions": 188,
+    "files": 146,
+    "legacy_expressions": 158,
+    "nonliteral_ranges": 24,
     "unresolved_mode_expressions": 3
   }
 }

scripts/analyze_qvm_child_byte_effects.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+from pathlib import Path
+from qvm_trace_support import resume
+from qvm_research_support import execute
+from analyze_qvm_reentry_witness import instructions,BASE
+from analyze_qvm import write_json
+
+def main():
+    rows=[]
+    for kind in ['trace','movement']:
+        for lane in range(4):
+            for value in [0,1,127,128,255]:
+                ins=instructions([('CONST',99),('CALL',None),('POP',None),('CONST',BASE+64),('LOAD4',None),('LEAVE',0)])
+                def child(i,m,a,b):
+                    locked=False
+                    try:b[0]=7
+                    except TypeError:locked=True
+                    m[BASE+64]=0x55667788;return m,0,{'read_only_view':locked,'child_memory_bytes':{BASE+64+lane:value}}
+                opts=dict(repeated_calls=True,sync_child_words=True,coherent_memory=True,byte_handlers=True,capture_byte_memory=True)
+                if kind=='trace':m,e=resume(ins,0,len(ins),{BASE+64:0x11223344},BASE,handlers={99:child},**opts)
+                else:
+                    def move(i,m,a,c,b):m,v,r=child(i,m,a,b);return m,c,v,r
+                    m,c,e=execute(ins,0,len(ins),{BASE+64:0x11223344},[0,0,0],BASE,{99:move},**opts)
+                rows.append({'kind':kind,'lane':lane,'byte':value,'result':e['return']&0xffffffff,'stored':m[BASE+64]&0xffffffff,'locked':e['children'][0]['effect']['read_only_view']})
+    write_json(Path('docs/research/qvm-child-byte-effects.json'),{'probes':rows,'limits':'Explicit opt-in read-only child byte view plus validated child_memory_bytes effects. Changed words apply before byte overrides; returned CALL value patch follows both. Movement command tuple remains authoritative at the next segment. No complete native VM/ABI claim.'})
+if __name__=='__main__':main()

scripts/qvm_research_support.py

@@ -19,8 +19,11 @@ def memory(raw,h,cmd=(100,0,0),plane=1,flags=0):
     m[0x30000+24]=sum((v&255)<<(8*(i+1)) for i,v in enumerate(cmd));return m
 
 
-def execute(ins,start,stop,m,cmd,base,handlers=None,result_offsets=None,boundaries=(),byte_inputs=None,repeated_calls=False,sync_child_words=False):
+def execute(ins,start,stop,m,cmd,base,handlers=None,result_offsets=None,boundaries=(),byte_inputs=None,repeated_calls=False,sync_child_words=False,coherent_memory=False,byte_handlers=False,capture_byte_memory=False):
     """Bounded source calls with actual recovered children at empty-stack boundaries."""
+    from types import MappingProxyType
+    from qvm_byte_memory_support import write_bytes
+    if byte_handlers and not (coherent_memory and repeated_calls and sync_child_words):raise ValueError('byte handlers require coherent corrected synchronized mode')
     from qvm_child_memory_support import sync_words
     if sync_child_words and not repeated_calls:raise ValueError('child synchronization requires corrected reentry')
     import math
@@ -29,10 +32,13 @@ def execute(ins,start,stop,m,cmd,base,handlers=None,result_offsets=None,boundari
     from analyze_bsp_references import trace_fields
     from analyze_qvm_acceleration import FRAME,word,number
     handlers=handlers or {};result_offsets=result_offsets or {};points=[x['index']+2 for x in ins[start:stop] if x['opcode']=='CALL']+list(boundaries);pc=start;trace=[];calls=[];children=[];writes=[];ret=None
-    bytes_map=dict(byte_inputs or {})
+    m=dict(m);bytes_map=dict(byte_inputs or {})
     for _ in range(256):
-        if repeated_calls:bytes_map.update({FRAME+25+i:v&255 for i,v in enumerate(cmd)})
-        t=trace_slice(ins,start,stop,m,{},resume_at=pc,stop_targets=points if repeated_calls else [p for p in points if p!=pc],byte_memory=bytes_map if repeated_calls else {**(byte_inputs or {}),**{FRAME+25+i:v&255 for i,v in enumerate(cmd)}},local_base=base,halt_on_leave=True,capture_stack=True,limit=8192,skip_initial_stop=repeated_calls);m=t['memory'];pc=t.get('stop',stop);trace+=t['trace'];calls+=t['calls'];writes+=t['byte_writes'];cmd=[t['byte_memory'][FRAME+25+i] for i in range(3)]
+        if repeated_calls:
+            command_bytes={FRAME+25+i:v&255 for i,v in enumerate(cmd)}
+            if coherent_memory:write_bytes(m,bytes_map,command_bytes)
+            else:bytes_map.update(command_bytes)
+        t=trace_slice(ins,start,stop,m,{},resume_at=pc,stop_targets=points if repeated_calls else [p for p in points if p!=pc],byte_memory=bytes_map if repeated_calls else {**(byte_inputs or {}),**{FRAME+25+i:v&255 for i,v in enumerate(cmd)}},local_base=base,halt_on_leave=True,capture_stack=True,limit=8192,skip_initial_stop=repeated_calls,coherent_memory=coherent_memory);m=t['memory'];pc=t.get('stop',stop);trace+=t['trace'];calls+=t['calls'];writes+=t['byte_writes'];cmd=[t['byte_memory'][FRAME+25+i] for i in range(3)]
         if repeated_calls:
             bytes_map=t['byte_memory']
             if t['calls'] and t['stack'] and not (t['trace'] and ins[t['trace'][-1]]['opcode']=='LEAVE'):raise ValueError('nonempty bounded CALL return boundary')
@@ -41,8 +47,9 @@ def execute(ins,start,stop,m,cmd,base,handlers=None,result_offsets=None,boundari
             if c['target']==-107:value=word(math.sqrt(number(c['args'][8])));r={'input':c['args'][8]&0xffffffff,'root':value}
             else:
                 if c['target'] not in handlers:raise ValueError('Unrecovered bounded child '+str(c['target']))
-                m,cmd,value,r=handlers[c['target']](ins,m,c['args'],cmd)
+                m,cmd,value,r=handlers[c['target']](ins,m,c['args'],cmd,MappingProxyType(bytes_map)) if byte_handlers else handlers[c['target']](ins,m,c['args'],cmd)
             if sync_child_words:sync_words(child_before,m,bytes_map)
+            if byte_handlers:write_bytes(m,bytes_map,r.get('child_memory_bytes',{}))
             if repeated_calls:patch_result(ins,c,m,bytes_map,base,value,result_offsets)
             elif ins[c['instruction']+1]['opcode']=='STORE4':
                 dest=ins[c['instruction']-2];offset=result_offsets.get(c['instruction'])
@@ -52,6 +59,6 @@ def execute(ins,start,stop,m,cmd,base,handlers=None,result_offsets=None,boundari
         if t['trace'] and ins[t['trace'][-1]]['opcode']=='LEAVE':ret=t['stack'][-1];break
         if pc==stop or pc in boundaries:break
     else:raise ValueError('Bounded child loop exceeded')
-    report={'return':ret,'calls':calls,'children':children,'byte_writes':writes,**trace_fields({'trace':trace},False)}
+    report={**({'byte_memory':bytes_map} if capture_byte_memory else {}),'return':ret,'calls':calls,'children':children,'byte_writes':writes,**trace_fields({'trace':trace},False)}
     if boundaries:report['stop']=pc
     return m,cmd,report

scripts/qvm_trace_support.py

@@ -3,27 +3,31 @@ from analyze_deferred_auth import trace_slice
 from analyze_bsp_references import trace_fields
 from qvm_call_result_support import patch_result
 
-def resume(ins,start,stop,m,base,pc=None,handlers=None,boundaries=(),byte_inputs=None,limit=8192,result_offsets=None,repeated_calls=False,sync_child_words=False,segment_limit=512):
+def resume(ins,start,stop,m,base,pc=None,handlers=None,boundaries=(),byte_inputs=None,limit=8192,result_offsets=None,repeated_calls=False,sync_child_words=False,segment_limit=512,coherent_memory=False,byte_handlers=False,capture_byte_memory=False):
     if type(segment_limit) is not int or not 1<=segment_limit<=8192:raise ValueError('invalid bounded segment budget')
+    from types import MappingProxyType
+    from qvm_byte_memory_support import write_bytes
+    if byte_handlers and not (coherent_memory and repeated_calls and sync_child_words):raise ValueError('byte handlers require coherent corrected synchronized mode')
     from qvm_child_memory_support import sync_words
     if sync_child_words and not repeated_calls:raise ValueError('child synchronization requires corrected reentry')
     handlers=handlers or {};pc=start if pc is None else pc;m=dict(m);trace=[];calls=[];children=[];writes=[];bytes_map=dict(byte_inputs or {});ret=None
     points=[i['index']+2 for i in ins[start:stop] if i['opcode']=='CALL']+list(boundaries)
     for _ in range(segment_limit):
-        t=trace_slice(ins,start,stop,m,{},resume_at=pc,stop_targets=points if repeated_calls else [p for p in points if p!=pc],local_base=base,byte_memory=bytes_map,halt_on_leave=True,capture_stack=True,limit=limit,skip_initial_stop=repeated_calls);m=t['memory'];pc=t.get('stop',stop);trace+=t['trace'];calls+=t['calls'];writes+=t['byte_writes'];bytes_map=t['byte_memory']
+        t=trace_slice(ins,start,stop,m,{},resume_at=pc,stop_targets=points if repeated_calls else [p for p in points if p!=pc],local_base=base,byte_memory=bytes_map,halt_on_leave=True,capture_stack=True,limit=limit,skip_initial_stop=repeated_calls,coherent_memory=coherent_memory);m=t['memory'];pc=t.get('stop',stop);trace+=t['trace'];calls+=t['calls'];writes+=t['byte_writes'];bytes_map=t['byte_memory']
         if repeated_calls and t['calls'] and t['stack'] and not (t['trace'] and ins[t['trace'][-1]]['opcode']=='LEAVE'):
             raise ValueError('nonempty bounded CALL return boundary')
         for c in t['calls']:
             child_before=dict(m) if sync_child_words else None
             if c['target'] not in handlers:raise ValueError('Unrecovered trace child '+str(c['target']))
-            m,value,e=handlers[c['target']](ins,m,c['args'])
+            m,value,e=handlers[c['target']](ins,m,c['args'],MappingProxyType(bytes_map)) if byte_handlers else handlers[c['target']](ins,m,c['args'])
             if sync_child_words:sync_words(child_before,m,bytes_map)
+            if byte_handlers:write_bytes(m,bytes_map,e.get('child_memory_bytes',{}))
             patch_result(ins,c,m,bytes_map,base,value,result_offsets)
             children.append({'call':c,'effect':e})
         if t['trace'] and ins[t['trace'][-1]]['opcode']=='LEAVE':ret=t['stack'][-1];break
         if pc==stop or pc in boundaries:break
     else:raise ValueError('Trace segment budget exceeded')
-    return m,{'stop':pc,'return':ret,'calls':calls,'children':children,'byte_writes':writes,**trace_fields({'trace':trace},False)}
+    return m,{**({'byte_memory':bytes_map} if capture_byte_memory else {}),'stop':pc,'return':ret,'calls':calls,'children':children,'byte_writes':writes,**trace_fields({'trace':trace},False)}
 
 def captured(target,requests):
     def call(ins,m,args):

scripts/test_qvm_child_byte_effects.py

@@ -0,0 +1,18 @@
+import json,unittest
+from pathlib import Path
+from qvm_trace_support import resume
+from qvm_research_support import execute
+from analyze_qvm_reentry_witness import instructions,BASE
+from analyze_qvm_acceleration import FRAME
+class ChildByteEffectsTests(unittest.TestCase):
+    def test_independent_override_precedence_and_mirrored_word(self):
+        ps=json.loads(Path('docs/research/qvm-child-byte-effects.json').read_text())['probes'];self.assertEqual(len(ps),40)
+        for p in ps:
+            b=bytearray.fromhex('88776655');b[p['lane']]=p['byte'];self.assertEqual(p['result'],int.from_bytes(b,'little'));self.assertEqual(p['stored'],p['result']);self.assertTrue(p['locked'])
+    def test_explicit_mode_required(self):
+        with self.assertRaisesRegex(ValueError,'byte handlers require'):resume([],0,0,{},0,byte_handlers=True)
+    def test_movement_tuple_has_command_precedence(self):
+        ins=instructions([('CONST',99),('CALL',None),('POP',None),('CONST',FRAME+25),('LOAD1',None),('LEAVE',0)])
+        def child(i,m,a,c,b):return m,[7,0,0],0,{'child_memory_bytes':{FRAME+25:99}}
+        _,cmd,e=execute(ins,0,len(ins),{},[0,0,0],BASE,{99:child},repeated_calls=True,sync_child_words=True,coherent_memory=True,byte_handlers=True);self.assertEqual((cmd,e['return']),([7,0,0],7))
+if __name__=='__main__':unittest.main()

xtask/checks.tsv

@@ -1894,3 +1894,7 @@ edge	docs/research/qvm-coherent-memory.json	scripts/test_qvm_coherent_memory.py
 group	coherent-memory	scripts/analyze_qvm_coherent_memory.py
 edge	scripts/analyze_qvm_coherent_memory.py	scripts/analyze_qvm_resumer_audit.py
 edge	scripts/qvm_byte_memory_support.py	scripts/analyze_qvm_resumer_audit.py
+report	scripts/analyze_qvm_child_byte_effects.py	docs/research/qvm-child-byte-effects.json
+edge	docs/research/qvm-child-byte-effects.json	scripts/test_qvm_child_byte_effects.py
+group	child-byte-effects	scripts/analyze_qvm_child_byte_effects.py
+edge	scripts/analyze_qvm_child_byte_effects.py	scripts/analyze_qvm_resumer_audit.py