#!/usr/bin/env python3 """CPU-only JSONL evidence re-audit; no policy, physics, registration or optimizer.""" import argparse import importlib.util import json import lzma import sys import time import types import zlib from pathlib import Path ROOT = Path(__file__).resolve().parents[1] def cpu_modules(): # Private offline namespace, NOT SkillFactory and never used for frozen identity verification. directory = ROOT / 'source/SkillFactory/SkillFactory/legs/contact_cycle_sim' name = '_contact_cycle_offline_cpu' package = types.ModuleType(name) package.__path__ = [str(directory)] sys.modules[name] = package modules = [] for leaf in ('evaluation_protocol', 'evaluation_audit'): spec = importlib.util.spec_from_file_location(name + '.' + leaf, directory / (leaf + '.py')) module = importlib.util.module_from_spec(spec) sys.modules[spec.name] = module spec.loader.exec_module(module) modules.append(module) return modules def trace_lines(path, *, compressed, max_bytes, max_record_bytes, deadline, max_decoded_bytes=None): """Incremental legacy gzip / v2 XZ / raw JSONL, never whole-stream decompression. XZ decoder memory is capped, including dictionaries advertised in headers. Input, output, individual records and per-member output are independently bounded; deadlines are checked even while draining buffered decoder output. """ _, limits = cpu_modules() chunk_bytes = 64 * 1024 max_member_bytes = limits.MAX_CHUNK_RAW_BYTES max_decoded_bytes = max_bytes * 64 if max_decoded_bytes is None else max_decoded_bytes xz = compressed and path.name.endswith('.xz') read_bytes = decoded_bytes = member_bytes = member_records = 0 line = bytearray() def check(): if time.monotonic() > deadline or path.stat().st_size > max_bytes or read_bytes > max_bytes: raise ValueError('budget_audit_resource_or_record_limit') decoder = None with path.open('rb') as source: while True: check() data = source.read(min(chunk_bytes, max_bytes - read_bytes + 1)) read_bytes += len(data) check() # Includes EOF and time spent reading compressed headers/tails. if not data: if decoder is not None: raise EOFError('truncated compressed member') if line: raise ValueError('budget_audit_resource_or_record_limit') return # XZ may retain input internally. Drain it with bounded output before # reading more source, including when the source is already at EOF. while data or (xz and decoder is not None and not decoder.needs_input): check() member_done = False if compressed: if decoder is None: decoder = (lzma.LZMADecompressor(format=lzma.FORMAT_XZ, memlimit=limits.XZ_DECODER_MEMORY_BYTES) if xz else zlib.decompressobj(wbits=31)) member_bytes = member_records = 0 decoded = decoder.decompress(data, chunk_bytes) member_done = decoder.eof if xz: remaining = decoder.unused_data if member_done else b'' else: remaining = decoder.unused_data if member_done else decoder.unconsumed_tail if not decoded and len(remaining) == len(data): raise ValueError('gzip decoder made no progress') data = remaining else: decoded, data = data, b'' check() decoded_bytes += len(decoded) member_bytes += len(decoded) if decoded_bytes > max_decoded_bytes or compressed and member_bytes > max_member_bytes: raise ValueError('budget_audit_decoded_limit') # At most one bounded record plus a 64KiB decoded block is held. for part in decoded.splitlines(keepends=True): line.extend(part) if len(line) > max_record_bytes: raise ValueError('budget_audit_resource_or_record_limit') if line.endswith(b'\n'): member_records += 1 if xz and member_records > limits.MAX_CHUNK_RECORDS: raise ValueError('budget_audit_chunk_record_limit') check() yield bytes(line) line.clear() if member_done: if xz and line: raise ValueError('incomplete record at compressed member boundary') decoder = None def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument('--protocol', type=Path, required=True) parser.add_argument('--trial-index', type=int, required=True) parser.add_argument('--trace', type=Path, required=True) parser.add_argument('--output', type=Path, required=True) parser.add_argument('--max-trace-bytes', type=int, required=True) parser.add_argument('--wall-seconds', type=float, required=True) args = parser.parse_args() protocol_module, audit_module = cpu_modules() protocol = protocol_module.load_protocol(args.protocol) if not 0 < args.max_trace_bytes <= protocol.document['resources']['max_artifact_bytes']: parser.error('Require bounded positive trace budget within protocol cap') if not 0 < args.wall_seconds <= 3600: parser.error('Require bounded positive CPU audit wall budget') audit = audit_module.TrialAudit(protocol, args.trial_index) deadline = time.monotonic() + args.wall_seconds count = 0 try: if args.trace.stat().st_size > args.max_trace_bytes: raise ValueError('budget_audit_compressed_bytes') for line in trace_lines(args.trace, compressed=args.trace.name.endswith(('.jsonl.gz', '.jsonl.xz')), max_bytes=args.max_trace_bytes, max_record_bytes=audit_module.MAX_RECORD_BYTES, deadline=deadline): count += 1 if count > 2 * audit.trial.total_ticks + 16: raise ValueError('budget_audit_resource_or_record_limit') audit.consume(json.loads(line)) if audit.terminal is None: audit.fail(('recording_missing_terminal',), kind='terminal') except (OSError, EOFError, zlib.error, lzma.LZMAError, ValueError, KeyError, TypeError) as exc: audit.fail((f'recording_offline:{exc}',), kind='offline') report = audit.report() report.update(terminal=audit.terminal, source_trace=str(args.trace), new_simulation_steps=0, new_optimizer_steps=0) with args.output.open('x') as output: json.dump(report, output, indent=2, allow_nan=False) output.write('\n') print(json.dumps({'functional_passed': report['functional_passed'], 'first_failure': report['first_failure']})) return 0 if report['functional_passed'] else 1 if __name__ == '__main__': raise SystemExit(main())