Files
SkillFactory/tests/test_contact_cycle_skill_v4.py
chenlin c528dd268f feat: checkpoint Go2 FL simulation performance v0.4.2
Include callable skill and live-GUI prerequisites, epoch sensor reads, packed snapshots, sampled bit-exact kinematics, and verified-tick rendering without changing the physical/control schedule.

Record bounded analytic S1 GUI/headless qualification, original failures and CPU evidence (1557 passed, 6 skipped). Preserve accepted_skill=false and sub-real-time limitations. Exclude native authorities, caches, large media and local delivery copies; retain sealed artifact digest.
2026-10-16 15:46:01 +08:00

542 lines
28 KiB
Python

"""CPU-only v4 commands, pair boundaries, atomic mailbox, authority and stop seam."""
import copy
import importlib
import json
from pathlib import Path
import sys
from types import SimpleNamespace
import pytest
import torch
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'scripts'))
import go2_fl_skill as public
import skill_launch_v4 as launch
from SkillFactory.legs.contact_cycle_sim import skill_v4 as skill
from SkillFactory.legs.contact_cycle_sim import skill_mailbox_v4 as mailbox
from SkillFactory.legs.contact_cycle_sim.functional_flow_v2 import load_contract
from SkillFactory.legs.contact_cycle_sim.evaluation_protocol import Protocol
# Reuse the existing local Isaac spies; neither fixture launches Kit or physics.
from test_contact_cycle_sim_evaluation_runtime import runtime, advance
def base():
return load_contract(ROOT / launch.old.CONFIG)
@pytest.mark.parametrize('cycles', range(1, 21))
@pytest.mark.parametrize('controller', ['analytic', 'u256'])
def test_skill_v4_exact_cycles_and_endpoint_clocks(cycles, controller):
session = skill.SkillSession('validated_nominal', cycles, controller)
protocol = skill.SkillProtocol(base(), session)
assert protocol.trial(0).total_ticks == cycles * 4500
for cycle in range(cycles):
if cycle:
session.admit_endpoint(cycle)
end = protocol.evidence_clock(0, (cycle + 1) * 4500)
assert (end.cycle_index, end.local_tick) == (cycle, 4500)
command = protocol.command(0, end, anchor_a_world=(.1, .2, .022),
root_origin_world=(0, 0, .3), weight_N=50.)
assert command.target_world_m == pytest.approx(
(.125, .22, .022) if cycle % 2 == 0 else (.1, .2, .022))
assert protocol.next_command_clock(0, cycles * 4500) is None
@pytest.mark.parametrize('sequence', ['S1', 'S2', 'S3'])
def test_skill_v4_fixed_A_pair_targets_and_no_seam_jump(sequence):
spec = public.make_spec(sequence=sequence)
session = skill.SkillSession(spec['command'], 6, 'analytic', spec['queued'])
protocol = skill.SkillProtocol(base(), session)
args = dict(anchor_a_world=(.1, -.2, .022), root_origin_world=(0, 0, .3), weight_N=50.)
original = object.__new__(Protocol)
object.__setattr__(original, 'document', protocol.document)
for cycle in range(6):
command_id = skill.SEQUENCES[sequence][cycle // 2]
assert session.pair_commands[cycle // 2] == command_id
# Every phase reuses Protocol.command, with only the pair displacement changed.
from dataclasses import replace
object.__setattr__(original, 'trials', (replace(protocol.trial(0),
swing_displacement_m=skill.COMMANDS[command_id]),))
for local in (1, 1499, 1500, 1999, 2299, 2300, 2650, 2999, 3400, 4499, 4500):
clock = protocol.evidence_clock(0, cycle * 4500 + local)
assert protocol.command(0, clock, **args) == original.command(0, clock, **args)
end = protocol.command(0, protocol.evidence_clock(0, (cycle + 1) * 4500), **args)
if cycle < 5:
session.admit_endpoint(cycle + 1)
following = protocol.command(0, protocol.next_command_clock(0, (cycle + 1) * 4500,
seam_admitted=True), **args)
assert end.target_world_m == following.target_world_m
assert end.target_velocity_world_m_s == following.target_velocity_world_m_s
assert skill.SEQUENCES['S3'][0] == 'baseline_direction-24mm'
@pytest.mark.parametrize('command', list(skill.COMMANDS))
def test_skill_v4_queue_never_changes_outbound_or_return_pair(command):
session = skill.SkillSession('validated_nominal', 6, 'analytic')
session.queue(command)
assert session.active == 'validated_nominal'
session.admit_endpoint(1)
assert session.active == 'validated_nominal' and session.pair_commands == {0: 'validated_nominal'}
session.admit_endpoint(2)
assert session.active == command
assert session.pair_commands == {0: 'validated_nominal', 1: command}
@pytest.mark.parametrize('command,cycles,controller', [
('INVALID', 3, 'analytic'), (True, 3, 'analytic'), ([], 3, 'analytic'),
('validated_nominal', True, 'analytic'), ('validated_nominal', 0, 'analytic'),
('validated_nominal', 21, 'analytic'), ('validated_nominal', 3., 'analytic'),
('validated_nominal', float('nan'), 'analytic'), ('validated_nominal', 3, 'random')])
def test_skill_v4_invalid_complete_request_rejected_before_launch(tmp_path, monkeypatch, command, cycles, controller):
monkeypatch.setattr(public.subprocess, 'Popen', lambda *a, **k: pytest.fail('must not launch'))
with pytest.raises(ValueError):
public.start(tmp_path / 'never-created', tmp_path / 'no-registration',
command=command, cycles=cycles, controller=controller)
assert list(tmp_path.iterdir()) == []
def live_mailbox(tmp_path):
directory = tmp_path / 'mailbox'
directory.mkdir()
mailbox.publish(directory / 'status.json', {'state': 'running', 'receipts_count': 0})
return directory
def test_skill_v4_mailbox_invalid_is_zero_filesystem_or_session_mutation(tmp_path):
directory = live_mailbox(tmp_path)
before = {p.name: p.read_bytes() for p in directory.iterdir()}
session = skill.SkillSession('validated_nominal', 6, 'analytic')
original = copy.deepcopy(session.__dict__)
for command in ('invalid', None, 1, True, float('nan'), {'x': .02}):
with pytest.raises(ValueError):
mailbox.send(directory, 'queue', command)
with pytest.raises(ValueError):
session.queue(command)
assert session.__dict__ == original
assert before == {p.name: p.read_bytes() for p in directory.iterdir()}
def test_skill_v4_mailbox_one_outstanding_atomic_receipts_and_stop(tmp_path):
directory = live_mailbox(tmp_path)
session = skill.SkillSession('validated_nominal', 6, 'analytic')
request_id = mailbox.send(directory, 'queue', 'x_bias-16mm')
with pytest.raises(FileExistsError):
mailbox.send(directory, 'stop')
receipt = mailbox.consume(directory, session, 1235)
assert receipt['accepted'] and receipt['received_tick'] == 1235
assert receipt['request']['id'] == request_id
assert session.pending == ['x_bias-16mm'] and session.active == 'validated_nominal'
assert mailbox.consume(directory, session, 1240) is None
mailbox.send(directory, 'stop')
mailbox.consume(directory, session, 1245)
assert session.stop_requested and len(session.receipts) == 2
assert not (directory / 'request.lock').exists()
assert mailbox.read_json(directory / 'receipt.json')['accepted']
@pytest.mark.parametrize('message', [
{'id': 'a' * 32, 'operation': 'queue', 'command': 'INVALID'},
{'id': 'a' * 32, 'operation': 'stop', 'unknown': True},
{'id': 'a' * 32, 'operation': 'queue', 'command': 'x_bias-16mm', 'cycles': 20},
{'id': 'a' * 32, 'operation': 'reset'}, [],
])
def test_skill_v4_runtime_rejects_malformed_mailbox_before_control_mutation(tmp_path, message):
directory = live_mailbox(tmp_path)
session = skill.SkillSession('validated_nominal', 6, 'analytic')
before = copy.deepcopy(session.__dict__)
mailbox.publish(directory / 'request.json', message)
receipt = mailbox.consume(directory, session, 5)
assert receipt['accepted'] is False
assert {k: v for k, v in session.__dict__.items() if k != 'receipts'} == {
k: v for k, v in before.items() if k != 'receipts'}
def test_skill_v4_mailbox_capacity_status_query_detached_and_not_live(tmp_path):
directory = live_mailbox(tmp_path)
handle = public.SkillRun(tmp_path)
snapshot = handle.query()
snapshot['state'] = 'changed'
assert handle.query()['state'] == 'running'
mailbox.publish(directory / 'status.json', {'state': 'running', 'receipts_count': 64})
with pytest.raises(RuntimeError, match='capacity'):
handle.request_stop()
mailbox.publish(directory / 'status.json', {'state': 'stopped'})
with pytest.raises(RuntimeError, match='not live'):
handle.queue('x_bias-24mm')
@pytest.mark.parametrize('endpoint', [1, 2])
def test_skill_v4_boundary_stop_no_extra_physics_or_refresh(runtime, endpoint):
session = skill.SkillSession('x_bias-16mm', 3, 'analytic')
proto = skill.SkillProtocol(base(), session)
events, seams = [], []
hooks = runtime.env.RuntimeHooks(runtime.Sim, [])
with hooks:
def evidence(event, s):
events.append(event)
if event.kind == 'tick' and event.clock.global_tick == 5:
session.request_stop() if endpoint == 1 else None
if event.kind == 'tick' and event.clock.global_tick == 4505 and endpoint == 2:
session.request_stop()
return ()
def seam(event, s):
seams.append(event)
session.admit_endpoint(event.clock.global_tick // 4500)
return runtime.env.SeamDecision(True)
env = runtime.env.EvaluationContactCycleEnv(runtime.config(), protocol=proto, trial_index=0,
runtime_hooks=hooks, evidence_callback=evidence, seam_callback=seam,
boundary_stop_callback=lambda: session.stop_requested)
env._cycle_state.safety_causes = lambda: ()
env.reset()
reset_calls = hooks.reset_calls
result = advance(env, 2700)
assert result.stop.reason == 'requested_stop' and not result.stop.causes
assert result.stop.physics_ticks == hooks.rollout_steps == endpoint * 4500
assert result.stop.completed_clock_cycles == endpoint and result.stop.partial_control_ticks == 0
assert len(seams) == endpoint - 1
assert events[-1].kind == 'tick' and events[-1].clock.local_tick == 4500
assert env._cycle_state.controller.refreshes.item() == endpoint * 900
assert hooks.reset_calls == reset_calls
with pytest.raises(runtime.env.RuntimeViolation):
env.step(torch.zeros(1, 3))
def test_skill_v4_failure_precedes_requested_stop_at_endpoint(runtime):
session = skill.SkillSession('validated_nominal', 3, 'analytic')
with runtime.env.RuntimeHooks(runtime.Sim, []) as hooks:
env = runtime.env.EvaluationContactCycleEnv(runtime.config(), protocol=skill.SkillProtocol(base(), session),
trial_index=0, runtime_hooks=hooks, evidence_callback=lambda e, s: (),
boundary_stop_callback=lambda: True)
env._cycle_state.safety_causes = lambda: ()
env.reset()
env._cycle_state.safety_causes = lambda: ('ground_penetration',)
result = advance(env, 1)
assert result.stop.reason == 'failure' and result.stop.physics_ticks == 1
def registration_file(tmp_path):
path = tmp_path / 'registration.json'
path.write_text(json.dumps({'format': 'skillfactory.sim-functional-v4-task-registration.v1',
'boot_id': launch.b.boot_id(), 'plan_sha256': launch.b.digest(ROOT / launch.PLAN),
'registered_boottime': launch.b.boottime(),
'deadline_boottime': launch.b.boottime() + 3600,
'limits': {'kit_launches': 24, 'physics_calls': 650000, 'owned_bytes': 24 << 30,
'optimizer_steps': 0, 'gpu_serial': True}}))
return path
def test_skill_v4_new_authority_exact_sources_limits_no_reuse_and_serial(tmp_path, monkeypatch):
registration = registration_file(tmp_path)
monkeypatch.setattr(launch, 'capture_gpu', lambda: {'mock': 'CPU only'})
monkeypatch.setattr(launch.old.ownership, 'GPUOwnership', lambda _: None)
spec = public.make_spec(sequence='S1')
root = tmp_path / 'new-run'
with launch.Reservation(registration, root, spec) as reservation:
approval = launch.approval(reservation.path, launch.b.digest(reservation.path), root)
assert approval['sources'] == launch.sources()
assert approval['limits']['max_physics_calls'] == 27250
assert approval['limits']['max_owned_bytes'] == 4 << 30
with pytest.raises(BlockingIOError):
with launch.Reservation(registration, tmp_path / 'parallel', spec):
pytest.fail('concurrent task launch admitted')
with pytest.raises(RuntimeError, match='Consumed root'):
with launch.Reservation(registration, root, spec):
pytest.fail('root reuse')
assert not root.exists() # authority reservation itself never starts Kit/creates run root
@pytest.mark.parametrize('fault', ['launches', 'physics', 'storage'])
def test_skill_v4_whole_task_budget_denies_before_authority(tmp_path, monkeypatch, fault):
registration = registration_file(tmp_path)
spec = public.make_spec(sequence='nominal20')
runs = [{'root': str(tmp_path / ('old' + str(i))), 'authority': str(tmp_path / ('auth' + str(i))),
'reserved_calls': 0} for i in range(12 if fault == 'launches' else 1)]
if fault == 'physics':
runs[0]['reserved_calls'] = 650000
(tmp_path / 'skill-v4-ledger.json').write_text(json.dumps({'runs': runs}))
if fault == 'storage':
monkeypatch.setattr(launch.Reservation, 'check_storage', staticmethod(lambda _: (_ for _ in ()).throw(RuntimeError('storage cap'))))
monkeypatch.setattr(launch, 'capture_gpu', lambda: pytest.fail('must reject before GPU baseline'))
with pytest.raises(RuntimeError):
with launch.Reservation(registration, tmp_path / 'new', spec):
pytest.fail('overbudget')
assert not (tmp_path / 'new-authority').exists()
def test_skill_v4_finite_deadline_and_source_drift_rejection(tmp_path, monkeypatch):
registration = registration_file(tmp_path)
value = json.loads(registration.read_text())
value['boot_id'] = 'old-boot'
registration.write_text(json.dumps(value))
with pytest.raises(PermissionError):
launch.registration(registration)
spec = public.make_spec(cycles=3, stop_at_tick=5)
assert launch.limits(spec)['max_physics_calls'] == 13750
assert launch.limits(spec)['max_physical_seconds'] == 900
assert launch.limits(public.make_spec(sequence='nominal20'))['max_physics_calls'] == 90250
def test_skill_v4_u256_gated_before_mutation(tmp_path):
with pytest.raises(PermissionError, match='analytic evidence'):
public.require_analytics(public.make_spec(controller='u256', sequence='S1'), [])
with pytest.raises(PermissionError, match='analytic evidence'):
public.require_analytics(public.make_spec(controller='u256'), [])
assert list(tmp_path.iterdir()) == []
def test_skill_v4_explicit_fresh_registration_reusable_bounded(tmp_path):
path = tmp_path / 'new-session' / 'registration.json'
value = launch.new_registration(path)
actual, deadline = launch.registration(path)
assert actual == value
assert deadline - value['registered_boottime'] == 43200
assert not (path.parent / 'skill-v4-ledger.json').exists()
with pytest.raises(ValueError):
launch.new_registration(path)
value['deadline_boottime'] += 1
path.write_text(json.dumps(value))
with pytest.raises(PermissionError):
launch.registration(path)
def test_skill_v4_no_frozen_runtime_source_edits():
import hashlib
manifest = json.loads((ROOT / 'logs/contact_cycle/sim_residual_training_v1/prepared01/manifest.json').read_text())
for relative, expected in manifest['sources'].items():
if relative != 'AGENT.md':
assert hashlib.sha256((ROOT / relative).read_bytes()).hexdigest() == expected, relative
@pytest.fixture
def skill_recording(recording, monkeypatch):
name = recording.__package__ + '.skill_recording_v4'
path = ROOT / 'source/SkillFactory/SkillFactory/tasks/manager_based/contact_cycle_sim/skill_recording_v4.py'
import importlib.util
spec = importlib.util.spec_from_file_location(name, path)
module = importlib.util.module_from_spec(spec)
monkeypatch.setitem(sys.modules, name, module)
spec.loader.exec_module(module)
return module
from test_contact_cycle_functional_flow_runtime_v2 import recording
def test_skill_v4_recorder_public_probe_receipts_and_early_stop_continuity(skill_recording, tmp_path, monkeypatch):
from dataclasses import dataclass
directory = live_mailbox(tmp_path)
session = skill.SkillSession('validated_nominal', 3, 'analytic')
recorder = skill_recording.SkillRecorder(base(), skill.SkillProtocol(base(), session), lambda: None,
directory, stop_at_tick=5, reject_at_tick=5)
recorder.capture = SimpleNamespace(frames=[None] * 5, state=object())
monkeypatch.setattr(skill_recording, 'carry_snapshot', lambda s: {'CPU_mock_only': True})
recorder.poll()
assert session.stop_requested
assert session.receipts[0]['source'] == 'public_stop_probe'
assert session.receipts[0]['request']['operation'] == 'stop'
assert session.receipts[1]['source'] == 'public_rejection_probe'
assert session.receipts[1]['accepted'] is False and session.receipts[1]['state_unchanged']
assert session.receipts[1]['carry_before_sha256'] == session.receipts[1]['carry_after_sha256']
assert session.receipts[0]['received_tick'] == session.receipts[1]['received_tick'] == 5
assert not (directory / 'request.json').exists()
recorder.capture.frames = [None] * 4500
recorder.initial_counters = {k: 0 for k in skill_recording.FunctionalFlowRecorder.continuity.__globals__['COUNTERS']}
hooks = SimpleNamespace(**recorder.initial_counters, violations=[])
hooks.rollout_steps = 4500
recorder.cycles = [{'audit': {'sim_functional_passed': True}}]
@dataclass
class Stop:
reason: str = 'requested_stop'
causes: tuple = ()
completed_clock_cycles: int = 1
continuity = recorder.continuity(Stop(), hooks, 3)
assert continuity['runtime_continuity_verified'] and continuity['cycles_completed'] == 1
assert continuity['cycles_requested'] == 3 and continuity['requested_stop']
recorder.pending_seam = {'illegal_extra_refresh': True}
assert not recorder.continuity(Stop(), hooks, 3)['runtime_continuity_verified']
def worker_receipt(spec, *, stopped=False):
completed = 1 if stopped else spec['cycles']
return {'success': True, 'environment_constructed': True, 'preclose_identity_verified': True,
'runtime_continuity_verified': True, 'skill_spec': spec, 'cycles_completed': completed,
'cycles_requested': spec['cycles'], 'controller_kind': skill.CONTROLLERS[spec['controller']],
'runtime_stop': {'reason': 'requested_stop' if stopped else 'protocol_complete', 'causes': [],
'partial_control_ticks': 0, 'clock': {'global_tick': completed * 4500}},
'physics_counts': {'rollout_steps': completed * 4500, 'initialization_steps': 0,
'attempted_steps': completed * 4500, 'completed_steps': completed * 4500},
'hook_violations': [], 'live_receipts': [],
'pair_commands': {str(i): (skill.SEQUENCES.get(spec['sequence']) or (spec['command'],))[
min(i, len(skill.SEQUENCES.get(spec['sequence']) or (spec['command'],)) - 1)]
for i in range((completed + 1) // 2)}}
@pytest.mark.parametrize('fault', ['none', 'count', 'preclose', 'partial', 'fake_complete', 'missing_rejection'])
def test_skill_v4_complete_worker_receipt_requires_physics_and_integrity(fault):
spec = public.make_spec(cycles=3)
receipt = worker_receipt(spec)
assert launch.complete_receipt(receipt, spec)
if fault == 'count':
receipt['physics_counts']['attempted_steps'] += 1
elif fault == 'preclose':
receipt['preclose_identity_verified'] = False
elif fault == 'partial':
receipt['runtime_stop']['partial_control_ticks'] = 1
elif fault == 'fake_complete':
receipt = worker_receipt(spec, stopped=True)
receipt['runtime_stop']['reason'] = 'protocol_complete'
elif fault == 'missing_rejection':
spec['reject_at_tick'] = 5
assert launch.complete_receipt(receipt, spec) == (fault == 'none')
@pytest.mark.parametrize('fault', [None, 'prepare', 'supervisor', 'missing_trace', 'counts'])
def test_skill_v4_reuses_campaign_supervision_first_failure_wait_cleanup(tmp_path, monkeypatch, fault):
import evaluate_cycle_functional_flow as runner
import functional_gpu_watch_v3 as watch
old = launch.old
root = tmp_path / 'mock-run'
spec = public.make_spec(sequence='S1')
approval = {'limits': launch.limits(spec), 'sources': launch.sources(), 'gpu_identity': {},
'spec': spec, 'deadline_boottime': old.b.boottime() + 2000}
monkeypatch.setattr(launch, 'approval', lambda *a: approval)
monkeypatch.setattr(runner.ctypes, 'CDLL', lambda *a, **k: SimpleNamespace(prctl=lambda *a: 0))
monkeypatch.setattr(old, 'native_policy', lambda *a, **k: {})
monkeypatch.setattr(old, 'AsyncMonitor', lambda p: SimpleNamespace(monitor=True, error=None,
check=lambda: None, stop=SimpleNamespace(set=lambda: None), report=lambda: {'error': None}))
class Owned:
known = set()
def attach(self, child): pass
def discover(self): return {}
monkeypatch.setattr(old.owner, 'OwnedProcesses', Owned)
cleaned, waited, commands = [], [], []
monkeypatch.setattr(old.owner, 'cleanup_group', lambda *a, **k: cleaned.append(True) or True)
monkeypatch.setattr(old.owner, 'StdoutCapture', lambda *a: SimpleNamespace(
check=lambda: None, close=lambda: None, pump=lambda: None))
monkeypatch.setattr(old, 'authenticate', lambda *a: None)
monkeypatch.setattr(runner, 'filesystem_verify', lambda _: {'scope': 'CPU mock only'})
class GPU:
def __init__(self, *a): pass
def check(self, *a, **k): return {'clean': True}
monkeypatch.setattr(watch, 'ObservedGPUOwnership', GPU)
class Child:
returncode = 0
stdout = None
def __init__(self, command, **kwargs):
index = len(commands)
commands.append(command)
folder = root / ('prepare' if index == 0 else 'run')
if index == 0:
receipt = {'success': fault != 'prepare', 'environment_constructed': False,
'preclose_identity_verified': True,
'physics_counts': {'attempted_steps': 0, 'completed_steps': 0}}
(folder / 'binding.json').write_text(json.dumps({'format': 'skillfactory.go2-fl-skill-binding.v4',
'contract_sha256': approval['sources'][old.CONFIG]}))
(folder / 'inventory.json').write_text('{}')
else:
receipt = worker_receipt(spec)
if fault == 'counts': receipt['physics_counts']['completed_steps'] += 1
for filename in ('trace.pt', 'initial-state.pt', 'events-and-seams.json'):
if fault == 'missing_trace' and filename == 'trace.pt': continue
(folder / filename).write_text('CPU MOCK, NOT PHYSICS')
receipt['shutdown_handoff_ready'] = True
(folder / 'worker-result.json').write_text(json.dumps(receipt))
self.folder = folder
def poll(self): return 0 if (self.folder / 'shutdown-release.json').exists() else None
def wait(self, **kwargs): waited.append(True); return 0
monkeypatch.setattr(runner.subprocess, 'Popen', Child)
if fault == 'supervisor':
def authenticate(*a):
if len(commands) == 2: raise RuntimeError('mock GPU supervision failure')
monkeypatch.setattr(old, 'authenticate', authenticate)
args = SimpleNamespace(output=root, approval=tmp_path / 'unused', trusted_approval_sha256='mock',
skill_v4=True, followup_v3=False,
skill_reservation=SimpleNamespace(runs=[], check_storage=lambda _: None))
code = runner.campaign(args)
result = json.loads((root / 'campaign-result.json').read_text())
count = 1 if fault == 'prepare' else 2
assert len(commands) == len(cleaned) == len(waited) == count
assert all(str(ROOT / launch.SCRIPT) in ' '.join(c) for c in commands)
assert all('--worker-fd' in c for c in commands)
assert result['success'] == (fault is None) and code == (0 if fault is None else 2)
status = mailbox.read_json(root / 'mailbox/status.json')
assert status['state'] == ('stopped' if fault is None else 'failed')
def test_skill_v4_worker_entry_does_not_preimport_private_cpu_planner(monkeypatch):
import evaluate_cycle_functional_flow as runner
monkeypatch.setattr(launch, 'api', lambda: pytest.fail('planner alias before Kit'))
monkeypatch.setattr(launch, 'worker_payload', lambda fd: {'CPU mock': fd})
monkeypatch.setattr(runner, 'worker', lambda payload: 0 if payload == {'CPU mock': 123} else 1)
assert public.main(['--worker-fd', '123']) == 0
def test_skill_v4_twentieth_cycle_window_uses_integer_local_ticks(recording):
from test_contact_cycle_functional_flow_runtime_v2 import frames
recorder = recording.FunctionalFlowRecorder(base(), None, lambda: None)
local = frames(2999)
recorder.capture = SimpleNamespace(frames=[local[0]] * (19 * 4500) + local)
event = SimpleNamespace(clock=SimpleNamespace(local_tick=2999, cycle_index=19))
assert recorder._window_checks(event) == ()
@pytest.mark.parametrize('overrides', [{'cycles': 21}, {'command': 'INVALID'},
{'queued': ['INVALID']}, {'cycles': 6}])
def test_skill_v4_sequence_never_silently_ignores_invalid_or_conflicting_overrides(overrides):
with pytest.raises(ValueError):
public.make_spec(sequence='S1', **overrides)
def test_skill_v4_api_reports_abnormal_supervisor_exit_without_reusing_live_mailbox(tmp_path):
live_mailbox(tmp_path)
process = SimpleNamespace(returncode=-9, poll=lambda: -9)
handle = public.SkillRun(tmp_path, process)
assert handle.query()['state'] == 'failed'
assert handle.query()['failure'] == ['supervisor_abnormal_exit']
before = {p.name: p.read_bytes() for p in (tmp_path / 'mailbox').iterdir()}
with pytest.raises(RuntimeError, match='already exited'):
handle.request_stop()
with pytest.raises(RuntimeError, match='already exited'):
handle.queue('x_bias-16mm')
assert before == {p.name: p.read_bytes() for p in (tmp_path / 'mailbox').iterdir()}
@pytest.mark.parametrize('sequence', ['nominal20', 'S1', 'S2', 'S3'])
@pytest.mark.parametrize('fault', ['early_stop', 'changed_pair'])
def test_skill_v4_analytic_prerequisite_rejects_partial_or_changed_schedule(sequence, fault):
spec = public.make_spec(sequence=sequence)
receipt = worker_receipt(spec, stopped=fault == 'early_stop')
if fault == 'changed_pair':
receipt['pair_commands']['1'] = ('x_bias-16mm' if receipt['pair_commands']['1'] != 'x_bias-16mm'
else 'y_bias-24mm')
assert launch.complete_receipt(receipt, spec) # safe usable run, not matrix proof
assert not launch.complete_analytic_prerequisite(receipt, spec)
def test_skill_v4_u256_gate_rehashes_successful_current_source_analytics(tmp_path):
roots = []
for sequence in ('nominal20', 'S1', 'S2', 'S3'):
root = tmp_path / sequence
run = root / 'run'
run.mkdir(parents=True)
spec = public.make_spec(sequence=sequence)
receipt_path = run / 'worker-result.json'
receipt_path.write_text(json.dumps(worker_receipt(spec)))
artifacts = {}
for filename in ('trace.pt', 'initial-state.pt', 'events-and-seams.json'):
(run / filename).write_text('CPU MOCK, NOT PHYSICS')
artifacts[filename] = launch.b.digest(run / filename)
(root / 'approval.json').write_text(json.dumps({'format': launch.FORMAT,
'sources': launch.sources(), 'spec': spec}))
(root / 'campaign-result.json').write_text(json.dumps({'success': True, 'rows': [
{'slot': 'prepare', 'success': True}, {'slot': 'run', 'success': True,
'worker_result_sha256': launch.b.digest(receipt_path), 'artifact_sha256': artifacts}]}))
roots.append(root)
spec = public.make_spec(sequence='S1', controller='u256')
public.require_analytics(spec, roots)
(roots[-1] / 'run/trace.pt').write_text('tampered')
with pytest.raises(PermissionError, match='artifact changed'):
public.require_analytics(spec, roots)