chickenbstrips/TheTree_mock
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

P08-03: 配置の通常操作受入

Browse Source
This commit is contained in:
Agent Control Runner
2026-10-14 10:05:42 +09:00
parent 7dde98ccb7
commit 647196f4ca
4 changed files with 1818 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tools/check_p08_normal_placement_evidence.py
+134 -29
View File
@@ -147,26 +147,79 @@ def input_map(root):
R09_COMMIT = '31aa7706d28a92e313c432d5a62e35d19503dcc3'
R09_DOCS = 'docs/plans/original-completion-2026-10-02/execution/p08-03'
def jpeg_dimensions(data):
"""Parse baseline/progressive frame headers, including multi-scan markers.
VALIDATORS = {'tools/check_p08_normal_placement_evidence.py',
'tools/test_p08_normal_placement_evidence.py'}
This is a structural/dimension check, not a pixel decoder.
"""
def r09_allowed(name):
return name in VALIDATORS or name.startswith(R09_DOCS+'/')
def pinned_document(pin):
path = Path(pin['path'])
require(path.stat().st_size == pin['bytes'] and sha(path) == pin['sha256'], 'collection pin SHA')
return load(path)
def r09_runner_binding(evidence, index, pins):
run = load(evidence/'runner-input.json')
original = pinned_document(pins['runner_input'])
require(run['engine'] == original['engine'] and run['engine_sha256'] == original['engine_sha256'],
'R09 engine hash/version drift')
require(run == original, 'R09 settings/config/environment drift')
original_index = pinned_document(pins['index'])
for role in ('writer', 'reader'):
receipt = load(evidence/('os-runs/'+role+'/ended.json'))
pinned = pinned_document(pins['OS'][role]['receipt'])
require(receipt == pinned, 'R09 settings/config/environment drift')
name = 'os-pair/'+role+'-profile.json'
require(index['artifacts'][name] == original_index['artifacts'][name]
and sha(evidence/name) == original_index['artifacts'][name]['sha256'],
'R09 engine hash/version drift')
require(run['commit'] == index['commit'] == R09_COMMIT, 'R09 reuse candidate')
def r09_applicability(root, index):
head = subprocess.check_output(['git', '-C', str(root), 'rev-parse', 'HEAD'], text=True).strip()
require(index['commit'] == R09_COMMIT, 'R09 reuse candidate')
result = subprocess.run(['git', '-C', str(root), 'merge-base', '--is-ancestor', R09_COMMIT, head],
capture_output=True)
require(result.returncode == 0, 'R09_COMMIT not an ancestor')
diff = subprocess.check_output(['git', '-C', str(root), 'diff', '--name-status',
'--no-renames', '-z', R09_COMMIT, head]).decode().split('\0')
require(all(r09_allowed(name) for name in diff[1::2] if name), 'non-whitelisted committed change')
status = subprocess.check_output(['git', '-C', str(root), 'status', '--porcelain', '-z']).decode().split('\0')
require(all(len(row) >= 4 and r09_allowed(row[3:]) and 'R' not in row[:2]
and 'C' not in row[:2] for row in status if row), 'dirty working tree outside whitelist')
require(input_map(root) == index['inputs'], 'stale reuse input')
actual = {n:v['sha256'] for n,v in runner.source_refs(root).items()}
require({n:v for n,v in actual.items() if not r09_allowed(n)} ==
{n:v for n,v in index['source_map'].items() if not r09_allowed(n)}, 'stale reuse source')
for name in VALIDATORS:
baseline = subprocess.check_output(['git', '-C', str(root), 'show', R09_COMMIT+':'+name])
require(index['source_map'][name] == hashlib.sha256(baseline).hexdigest(), 'reuse source pin')
pins = load(root/R09_DOCS/'ROOT_NATIVE_R09_COLLECTION_PINS.json')
original = Path(pins['original_root'])
pinned = pinned_document(pins['runner_input'])
current = load(original/'runner-input.json')
require(current == pinned, 'R09 runner input drift')
require(pinned['commit'] == index['commit'] and pinned['inputs'] == index['inputs'],
'R09 runner binding drift')
require(sha(pinned['engine']) == pinned['engine_sha256'], 'R09 engine hash drift')
for role in ('writer', 'reader'):
receipt = pinned_document(pins['OS'][role]['receipt'])
require(receipt['engine_sha256'] == pinned['engine_sha256'], 'R09 engine hash/version drift')
require(receipt['environment_sha256'] == hashlib.sha256(
json.dumps(receipt['environment'], sort_keys=True).encode()).hexdigest(),
'R09 settings/environment drift')
return {name:sha(root/name) for name in sorted(VALIDATORS)}
def jpeg_dimensions(data):
"""Structural validation only; positive validity requires original capture hashes."""
require(data[:2] == b'\xff\xd8' and data[-2:] == b'\xff\xd9', 'invalid JPEG SOI/EOI')
pos, dimensions, scans = 2, None, 0
entropy = False
components, quant, huffman = {}, set(), set()
while pos < len(data):
if entropy:
pos = data.find(b'\xff', pos)
require(pos >= 0, 'truncated JPEG scan')
require(data[pos] == 255, 'invalid JPEG marker')
while pos < len(data) and data[pos] == 255:
pos += 1
while pos < len(data) and data[pos] == 255: pos += 1
require(pos < len(data), 'truncated JPEG marker')
marker = data[pos]; pos += 1
if entropy and (marker == 0 or 0xd0 <= marker <= 0xd7):
continue
entropy = False
if marker == 0xd9:
require(pos == len(data) and dimensions is not None and scans > 0, 'invalid JPEG end')
return dimensions
@@ -176,21 +229,59 @@ def jpeg_dimensions(data):
length = int.from_bytes(data[pos:pos+2], 'big')
require(length >= 2 and pos+length <= len(data)-2, 'truncated JPEG segment')
body = data[pos+2:pos+length]; pos += length
if marker in (0xc0, 0xc2):
if marker == 0xdb:
offset = 0
while offset < len(body):
info = body[offset]; offset += 1
require(info >> 4 in (0, 1) and info & 15 <= 3, 'invalid JPEG DQT')
size = 64 * (1 + (info >> 4))
require(offset+size <= len(body), 'invalid JPEG DQT')
quant.add(info & 15); offset += size
elif marker == 0xc4:
offset = 0
while offset < len(body):
require(offset+17 <= len(body), 'invalid JPEG DHT')
info = body[offset]; count = sum(body[offset+1:offset+17])
require(info >> 4 in (0, 1) and info & 15 <= 3 and count > 0
and offset+17+count <= len(body), 'invalid JPEG DHT')
huffman.add((info >> 4, info & 15)); offset += 17+count
elif marker in (0xc0, 0xc2):
require(dimensions is None and len(body) >= 6 and body[0] == 8
and body[5] > 0 and len(body) == 6+3*body[5], 'invalid JPEG SOF')
height, width = struct.unpack('>HH', body[1:5])
require(width > 0 and height > 0, 'invalid JPEG dimensions')
components = {body[i]:body[i+2] for i in range(6, len(body), 3)}
require(len(components) == body[5], 'invalid JPEG SOF components')
dimensions = (width, height)
elif 0xc0 <= marker <= 0xcf and marker not in (0xc4, 0xc8, 0xcc):
raise ValueError('unsupported JPEG SOF')
elif marker == 0xda:
require(dimensions is not None and body and body[0] > 0
and len(body) == 4+2*body[0], 'invalid JPEG SOS')
scans += 1; entropy = True
ids = [body[i] for i in range(1, 1+2*body[0], 2)]
require(len(ids) == len(components) and set(ids) == set(components),
'JPEG SOF/SOS component mismatch')
require(set(components.values()) <= quant, 'missing JPEG DQT')
require(bool(huffman), 'missing JPEG DHT')
for i in range(2, 1+2*body[0], 2):
table = body[i]
require((0, table >> 4) in huffman and (1, table & 15) in huffman,
'JPEG SOS undefined table')
start, nonempty = pos, False
while pos < len(data):
if data[pos] != 255:
nonempty = True; pos += 1; continue
require(pos+1 < len(data), 'truncated JPEG scan')
if data[pos+1] == 0:
nonempty = True; pos += 2; continue
if 0xd0 <= data[pos+1] <= 0xd7:
pos += 2; continue
break
require(nonempty and pos > start, 'empty JPEG entropy stream')
scans += 1
raise ValueError('missing JPEG EOI')
def r09_images(evidence, index, measurement):
def r09_images(evidence, index, measurement, pins=None):
require(measurement['original_index_sha256'] == sha(evidence/'index.json'), 'stale image index pin')
expected = {f'os-pair/{role}-request-{i:04d}/screen-{side}.png'
for role, count in (('reader', 5), ('writer', 64))
@@ -199,11 +290,34 @@ def r09_images(evidence, index, measurement):
indexed = {n for n in index['artifacts'] if n.startswith('os-pair/') and n.endswith('.png')
and n not in ('os-pair/formal/thumbnail.png', 'os-pair/formal.bak/thumbnail.png')}
require(set(rows) == indexed == expected, 'missing/extra image entry')
original_index = None
if pins is not None:
original_index = pinned_document(pins['index'])
for role in ('writer', 'reader'):
pinned_document(pins['OS'][role]['receipt'])
sizes = {}
for name in sorted(expected):
data = (evidence/name).read_bytes()
sizes[name] = jpeg_dimensions(data)
row, pin = rows[name], index['artifacts'][name]
if original_index is not None:
capture = original_index['artifacts'][name]
original_bytes = (Path(pins['original_root'])/name).read_bytes()
require(hashlib.sha256(original_bytes).hexdigest() == capture['sha256']
and len(original_bytes) == capture['bytes']
and pin == capture and hashlib.sha256(data).hexdigest() == capture['sha256']
and len(data) == capture['bytes'], 'original capture hash mismatch')
require(row['source_sha256'] == capture['sha256'], 'measurement capture hash altered')
role = name.split('/')[1].split('-')[0]
ack_name = name.rsplit('/', 1)[0]+'/ack.json'
ack_path = Path(pins['original_root'])/ack_name
require(sha(ack_path) == original_index['artifacts'][ack_name]['sha256'],
'original capture receipt hash mismatch')
ack = load(ack_path)
receipt = pinned_document(pins['OS'][role]['receipt'])
side = 'screen_before' if name.endswith('screen-before.png') else 'screen_after'
require(ack[side] == name and ack['target_pid'] == receipt['actual_pid'],
'original capture receipt mismatch')
require(hashlib.sha256(data).hexdigest() == row['source_sha256'] == pin['sha256']
and len(data) == pin['bytes'], 'image source_sha256 mismatch')
require(row['format_by_magic'] == 'JPEG' and type(row['width']) is int
@@ -466,22 +580,13 @@ def check(project_root, evidence_dir):
original = evidence
pins_path = root/R09_DOCS/'ROOT_NATIVE_R09_COLLECTION_PINS.json'
if pins_path.exists():
r09_applicability(root, index)
r09_runner_binding(evidence, index, load(pins_path))
original = r09_collection(evidence, index, load(pins_path))
r09_images(evidence, index, load(root/R09_DOCS/'ROOT_R09_READONLY_IMAGE_DIMENSIONS.json'))
# Only these Python validator/test files may differ from same31aa.
changed = {'tools/check_p08_normal_placement_evidence.py',
'tools/test_p08_normal_placement_evidence.py'}
added = {'tests/fixtures/p08-03/repair13_images.py'}
for name in changed:
baseline = subprocess.check_output(['git', '-C', str(root), 'show', R09_COMMIT+':'+name])
require(index['source_map'][name] == hashlib.sha256(baseline).hexdigest(), 'reuse source pin')
require({n:v for n,v in actual.items() if n not in changed|added} ==
{n:v for n,v in index['source_map'].items() if n not in changed}, 'stale reuse source')
require({n:v for n,v in input_map(root).items() if n not in added} == index['inputs'], 'stale reuse input')
r09_images(evidence, index, load(root/R09_DOCS/'ROOT_R09_READONLY_IMAGE_DIMENSIONS.json'), load(pins_path))
actual = index['source_map']
require(index['source_map'] == actual, 'stale source')
require(index['inputs'] == {n:v for n,v in input_map(root).items()
if not pins_path.exists() or n != 'tests/fixtures/p08-03/repair13_images.py'}, 'stale input')
require(index['inputs'] == input_map(root), 'stale input')
require(index['spec_sha256'] == SPEC_SHA == hashlib.sha256((root/SPEC).read_text().strip().encode()).hexdigest(), 'immutable spec')
require(index['marker_contract_sha256'] == sha(root/CONTRACT), 'stale marker')
require(re.fullmatch('[0-9a-f]{40}', index['commit']) is not None, 'commit')
tools/test_p08_normal_placement_evidence.py
+143 -4
View File
@@ -16,6 +16,7 @@ import io
import os
import gzip
import hashlib
import struct
sys.dont_write_bytecode = True
ROOT = Path(__file__).resolve().parents[1]
@@ -163,6 +164,10 @@ class EvidenceTests(unittest.TestCase):
self.edit('index.json', lambda d: d.update(commit='0'*40))
self.reject('stale commit')
def test_non_reuse_head_mismatch(self):
self.edit('index.json', lambda d:d.update(commit='0'*40))
self.reject('stale commit')
def test_stale_input(self):
(self.root/'docs/traceability/original/BASELINE.txt').write_text('changed')
self.reject('stale input')
@@ -524,11 +529,54 @@ class EvidenceTests(unittest.TestCase):
def test_mock_native_timeout_restores_project_and_cleans_owned_child(self):
self.collector_mock(fail_wait=True)
def image_put(path, value):
path.write_text(json.dumps(value, sort_keys=True)+'\n')
def negative_jpeg(width=1280, height=752, progressive=False):
def segment(marker, body):
return bytes((255, marker))+struct.pack('>H', len(body)+2)+body
frame = segment(0xc2 if progressive else 0xc0,
b'\x08'+struct.pack('>HH', height, width)+b'\x01\x01\x11\x00')
scan = segment(0xda, b'\x01\x01\x00\x00\x3f\x00')+b'\x12\xff\x00\x34\xff\xd0\x56'
tables = segment(0xdb, b'\x00'+bytes([1])*64)+segment(0xc4, b'\x00'+b'\x01'+bytes(15)+b'\x00'+b'\x10'+b'\x01'+bytes(15)+b'\x00')
return b'\xff\xd8'+tables+segment(0xe0, b'SYNTHETIC')+frame+scan+(scan if progressive else b'')+b'\xff\xd9'
def negative_images(base, candidate):
out, original = base/'canonical', base/'original'
out.mkdir(parents=True); index = {'commit':candidate, 'artifacts':{}}
measurement = {'scope':'synthetic post-collection measurement', 'images':[]}
for role, count in (('reader',5), ('writer',64)):
for i in range(1,count+1):
for side in ('before','after'):
name = f'os-pair/{role}-request-{i:04d}/screen-{side}.png'
path = out/name; path.parent.mkdir(parents=True, exist_ok=True)
path.write_bytes(negative_jpeg(progressive=i%2 == 0))
measurement['images'].append({'file':name, 'source_sha256':hashlib.sha256(path.read_bytes()).hexdigest(),
'width':1280,'height':752,'format_by_magic':'JPEG'})
for name in ('runner-input.json','runner-ended.json','os-runs/writer/ended.json','os-runs/reader/ended.json'):
path = out/name; path.parent.mkdir(parents=True,exist_ok=True); image_put(path, {'synthetic':True})
refresh_images(out, index, measurement)
shutil.copytree(out, original)
def pin(name):
p=original/name
return {'path':str(p),'bytes':p.stat().st_size,'sha256':hashlib.sha256(p.read_bytes()).hexdigest()}
pins = {'original_root':str(original),'native_candidate':candidate,'index':pin('index.json'),
'runner_input':pin('runner-input.json'),'runner_ended':pin('runner-ended.json'),
'OS':{role:{'receipt':pin('os-runs/'+role+'/ended.json')} for role in ('writer','reader')}}
return out, original, index, measurement, pins
def refresh_images(out, index, measurement):
index['artifacts'] = {p.relative_to(out).as_posix():{'bytes':p.stat().st_size,
'sha256':hashlib.sha256(p.read_bytes()).hexdigest()} for p in out.rglob('*') if p.is_file() and p.name != 'index.json'}
image_put(out/'index.json',index)
measurement['original_index_sha256'] = hashlib.sha256((out/'index.json').read_bytes()).hexdigest()
class R09ImageTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory(dir=ROOT/'tests/fixtures/p08-03/.scratch')
self.addCleanup(self.temp.cleanup)
self.fixture = module('repair13_image_fixture', ROOT/'tests/fixtures/p08-03/repair13_images.py')
self.fixture = SimpleNamespace(make=negative_images, jpeg=negative_jpeg, refresh=refresh_images)
self.out, self.original, self.index, self.measurement, self.pins = self.fixture.make(Path(self.temp.name), C.R09_COMMIT)
def images(self):
@@ -541,9 +589,29 @@ class R09ImageTests(unittest.TestCase):
self.fixture.refresh(self.out, self.index, self.measurement)
def test_baseline_progressive_and_collection_positive(self):
self.images()
self.assertEqual(self.original, C.r09_collection(self.out,self.index,self.pins))
self.assertEqual((1280,752),C.jpeg_dimensions(self.fixture.jpeg(progressive=True)))
pins = C.load(ROOT/C.R09_DOCS/'ROOT_NATIVE_R09_COLLECTION_PINS.json')
original = Path(pins['original_root'])
if not (original/'index.json').exists():
self.skipTest('Root-executed original R09 capture hash re-check required')
C.r09_images(original, C.load(original/'index.json'),
C.load(ROOT/C.R09_DOCS/'ROOT_R09_READONLY_IMAGE_DIMENSIONS.json'), pins)
def test_jpeg_missing_tables_and_scan(self):
data = negative_jpeg()
def remove(marker):
start = data.index(bytes((255, marker)))
size = int.from_bytes(data[start+2:start+4], 'big')
return data[:start]+data[start+2+size:]
for stream, error in ((remove(0xdb), 'missing JPEG DQT'),
(remove(0xc4), 'missing JPEG DHT'),
(data[:data.index(b'\xff\xda')+10]+b'\xff\xd9', 'empty JPEG entropy stream')):
with self.subTest(error=error), self.assertRaisesRegex(ValueError, error):
C.jpeg_dimensions(stream)
start = data.index(b'\xff\xda')
for offset, value, error in ((5, 2, 'JPEG SOF/SOS component mismatch'),
(6, 0x11, 'JPEG SOS undefined table')):
stream = bytearray(data); stream[start+offset] = value
with self.assertRaisesRegex(ValueError, error): C.jpeg_dimensions(stream)
def test_truncated_or_non_jpeg(self):
good = self.fixture.jpeg()
@@ -585,6 +653,22 @@ class R09ImageTests(unittest.TestCase):
self.measurement['images'][0]['source_sha256'] = '0'*64
with self.assertRaisesRegex(ValueError,'source_sha256 mismatch'): self.images()
def test_original_capture_hash_and_measurement_drift(self):
for alter_bytes in (True, False):
with self.subTest(alter_bytes=alter_bytes):
out, original, index, measurement, pins = negative_images(
Path(self.temp.name)/('case-'+str(alter_bytes)), C.R09_COMMIT)
row = sorted(measurement['images'], key=lambda r:r['file'])[0]
if alter_bytes:
(out/row['file']).write_bytes(negative_jpeg(height=720))
refresh_images(out, index, measurement)
error = 'original capture hash mismatch'
else:
row['source_sha256'] = '0'*64
error = 'measurement capture hash altered'
with self.assertRaisesRegex(ValueError, error):
C.r09_images(out, index, measurement, pins)
def test_stale_index_pin(self):
self.measurement['original_index_sha256'] = '0'*64
with self.assertRaisesRegex(ValueError,'stale image index pin'): self.images()
@@ -600,6 +684,61 @@ class R09ImageTests(unittest.TestCase):
C.r09_collection(self.out,self.index,self.pins)
class R09ApplicabilityTests(unittest.TestCase):
def test_commit_and_ancestor(self):
with patch.object(C.subprocess, 'check_output', return_value=C.R09_COMMIT+'\n'):
with self.assertRaisesRegex(ValueError, 'R09 reuse candidate'):
C.r09_applicability(ROOT, {'commit':'0'*40})
with patch.object(C.subprocess, 'run', return_value=SimpleNamespace(returncode=1)):
with self.assertRaisesRegex(ValueError, 'R09_COMMIT not an ancestor'):
C.r09_applicability(ROOT, {'commit':C.R09_COMMIT})
def test_non_whitelisted_committed_and_dirty_changes(self):
names = ['scenes/main/main.gd', 'tests/ui/test_p08_normal_placement_ops.gd',
'tests/fixtures/p08-03/added.py', 'tests/fixtures/p08-03/placement.gd',
'tools/run_p08_normal_placement.py', 'tools/regression/suite-policy.json']
for name in names:
for status in ('A', 'D', 'M'):
with self.subTest(name=name, status=status):
with patch.object(C.subprocess, 'run', return_value=SimpleNamespace(returncode=0)), patch.object(
C.subprocess, 'check_output', side_effect=[
C.R09_COMMIT+'\n', (status+'\0'+name+'\0').encode()]):
with self.assertRaisesRegex(ValueError, 'non-whitelisted committed change'):
C.r09_applicability(ROOT, {'commit':C.R09_COMMIT})
with patch.object(C.subprocess, 'run', return_value=SimpleNamespace(returncode=0)), patch.object(
C.subprocess, 'check_output', side_effect=[C.R09_COMMIT+'\n', b'', b' M scenes/main/main.gd\0']):
with self.assertRaisesRegex(ValueError, 'dirty working tree outside whitelist'):
C.r09_applicability(ROOT, {'commit':C.R09_COMMIT})
def test_engine_settings_environment_drift(self):
pins = {'runner_input':{'tag':'run'}, 'index':{'tag':'index'},
'OS':{'writer':{'receipt':{'tag':'receipt'}}}}
baseline = {'engine':'pinned-engine', 'engine_sha256':'1'*64}
for field, message in (('engine_sha256', 'R09 engine hash/version drift'),
('settings', 'R09 settings/config/environment drift'),
('environment', 'R09 settings/config/environment drift')):
altered = dict(baseline); altered[field] = 'drift'
with self.subTest(field=field), patch.object(C, 'load', return_value=altered), patch.object(
C, 'pinned_document', return_value=baseline):
with self.assertRaisesRegex(ValueError, message):
C.r09_runner_binding(ROOT, {}, pins)
# Version is in the SHA-pinned profile, not a worker engine invocation.
run = dict(baseline, commit=C.R09_COMMIT)
documents = [run, {}]
originals = [run, {'artifacts':{'os-pair/writer-profile.json':{'sha256':'1'*64}}}, {}]
with patch.object(C, 'load', side_effect=documents), patch.object(
C, 'pinned_document', side_effect=originals):
with self.assertRaisesRegex(ValueError, 'R09 engine hash/version drift'):
C.r09_runner_binding(ROOT, {'artifacts':{'os-pair/writer-profile.json':{'sha256':'2'*64}}}, pins)
def test_input_drift(self):
with patch.object(C.subprocess, 'run', return_value=SimpleNamespace(returncode=0)), patch.object(
C.subprocess, 'check_output', side_effect=[C.R09_COMMIT+'\n', b'', b'']), patch.object(
C, 'input_map', return_value={'fixture':'changed'}):
with self.assertRaisesRegex(ValueError, 'stale reuse input'):
C.r09_applicability(ROOT, {'commit':C.R09_COMMIT, 'inputs':{'fixture':'original'}})
class RealR05InfrastructureTests(unittest.TestCase):
"""Actual native snapshot, never a fabricated acceptance specimen."""
def setUp(self):