StarPilot/roadscore/tools/judging_run.py

"""Private single-attempt native judging orchestration. No musical selection or uploads."""
import argparse
import hashlib
import json
import os
import math
import re
from pathlib import Path
import subprocess
import time

ROOT = Path(__file__).resolve().parents[1]
PYTHON = '/usr/local/venv/bin/python'


def save(path, value):
    temp = path.with_suffix('.tmp')
    temp.write_text(json.dumps(value, indent=2))
    os.chmod(temp, 0o600)
    temp.replace(path)



def validate_frozen_configuration(root, frozen=None):
    """Refuse official work unless a nonempty local freeze verifies completely."""
    frozen = frozen or root / 'generated/judging_configuration.private.json'
    try:
        entries = json.loads(frozen.read_text())
    except (OSError, ValueError) as error:
        raise SystemExit('Valid frozen judging configuration is required') from error
    if not isinstance(entries, dict) or not entries:
        raise SystemExit('Frozen judging configuration must be a nonempty file/hash mapping')
    for name, digest in entries.items():
        if (not isinstance(name, str) or not name or Path(name).is_absolute()
                or '..' in Path(name).parts or not isinstance(digest, str)
                or len(digest) != 64 or any(c not in '0123456789abcdef' for c in digest)):
            raise SystemExit('Invalid frozen judging configuration entry')
        path = root / name
        if not path.resolve().is_relative_to(root.resolve()):
            raise SystemExit('Frozen judging configuration path escapes project')
        try:
            actual = hashlib.sha256(path.read_bytes()).hexdigest()
        except OSError as error:
            raise SystemExit('Frozen judging configuration file unavailable: ' + name) from error
        if actual != digest:
            raise SystemExit('Frozen judging configuration changed: ' + name)


def validate_handoff_readiness(manifest, row):
    """Preparation exports are inert until explicitly authorized and complete."""
    if manifest.get('schema') == 'roadscore-judging-handoff-v1':
        if manifest.get('generation_authorized') is not True:
            raise SystemExit('Judging handoff has not been authorized for generation')
        if row.get('preparation_ready') is not True or row.get('preparation_blockers') != []:
            raise SystemExit('Judging handoff preparation is incomplete or blocked')


def attempt_configuration(manifest, manifest_path, root):
    """Keep future policy evidence separate from historical attempts and freezes."""
    config = manifest['configuration']
    if manifest.get('schema') != 'roadscore-judging-handoff-v1':
        raise SystemExit('Export a versioned judging handoff; historical attempts are preserved')
    version = config.get('policy_version', '')
    if not isinstance(version, str) or not re.fullmatch(r'[A-Za-z0-9][A-Za-z0-9_-]{0,79}', version):
        raise SystemExit('A safe, explicit judging policy_version is required')
    mode, cap = config.get('hardware_mode'), config.get('power_limit_watts')
    env = os.environ.copy()
    env.pop('AM_POWER_LIMIT', None)
    if mode == 'full-speed' and cap is None:
        pass
    elif mode == 'capped' and isinstance(cap, (int, float)) and not isinstance(cap, bool) and math.isfinite(cap) and cap > 0:
        env['AM_POWER_LIMIT'] = str(cap)
    else:
        raise SystemExit('Declare full-speed with no cap, or an explicit capped policy')
    return (root / 'results/community_judging' / version,
            manifest_path.with_name('configuration.freeze.private.json'), env)


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('manifest', type=Path)
    parser.add_argument('--label', required=True, choices=list('ABCDEFGHIJK'))
    parser.add_argument('--resume-preparation', action='store_true')
    args = parser.parse_args()
    manifest = json.loads(args.manifest.read_text())
    row = next(r for r in manifest['submissions'] if r['label'] == args.label)
    ranges = args.manifest.with_name('judging_ranges.private.json')
    if ranges.exists():
        row.update(json.loads(ranges.read_text()).get(args.label, {}))
    if row.get('range_resolution') == 'pending metadata':
        raise SystemExit('Resolve submitted range before launching this entry')
    validate_handoff_readiness(manifest, row)
    out, frozen, env = attempt_configuration(manifest, args.manifest, ROOT)
    validate_frozen_configuration(ROOT, frozen)
    out.mkdir(parents=True, exist_ok=True, mode=0o700)
    ledger = out / f'official_{args.label}.json'
    if ledger.exists():
        record = json.loads(ledger.read_text())
        if not args.resume_preparation or record['phase'] != 'preparing' or record['seed'] != row['seed']:
            raise SystemExit('Existing attempt preserved; refusing an automatic rerun')
    else:
        record = {'label': args.label, 'seed': row['seed'], 'attempt': 1, 'phase': 'preparing',
                  'started_wall': time.time(), 'configuration': manifest['configuration'], 'manual_reruns': 0}
        with ledger.open('x') as stream:
            json.dump(record, stream, indent=2)
        os.chmod(ledger, 0o600)
    env['ROADSCORE_GENERATION_SEED'] = str(row['seed'])
    env['ROADSCORE_SEED_ORIGIN'] = 'judging-route'
    service = ROOT / 'prototype/worker_service.py'
    try:
        if not args.resume_preparation:
            subprocess.run([PYTHON, str(service), 'stop', '--composer', 'ace'], check=True)
            subprocess.run([PYTHON, str(service), 'start', '--composer', 'ace', '--profile', 'prism'], env=env, check=True)
        deadline = time.monotonic() + 1560
        while True:
            state = json.loads((ROOT / 'generated/ace_worker_state.json').read_text())
            if state.get('generation_seed') == row['seed'] and state.get('phase') == 'READY':
                break
            if (state.get('generation_seed') == row['seed'] and state.get('phase') == 'Stopped') or time.monotonic() > deadline:
                raise RuntimeError('Preparation stopped or timed out; original attempt retained')
            time.sleep(5)
        initial = json.loads((ROOT / 'generated/ace_initial.json').read_text())
        if initial.get('generation_seed') != row['seed']:
            raise RuntimeError('Prepared seed mismatch')
        save(out / f'preparation_{args.label}.json', initial)
        # Require the ordinary complete cache, without inspecting musical/road events.
        import sys
        sys.path.insert(0, str(ROOT / 'prototype'))
        from route_library import cache_complete
        deadline = time.monotonic() + 3600
        while not cache_complete(ROOT / 'routes' / row['route']):
            if time.monotonic() > deadline:
                raise RuntimeError('Cache not ready within one hour; no replay launched')
            time.sleep(10)
        before = set((ROOT / 'results').glob('normal_*'))
        record.update(phase='replaying', replay_started_wall=time.time())
        save(ledger, record)
        command = [str(ROOT.parent / 'onroad'), '--routeid', row['route'], '--roadscore',
                   '--composer', 'ace', '--profile', 'prism', '--muted',
                   '--roadscore-seed', str(row['seed']),
                   '--start', str(row.get('start_seconds', 0)), '--duration', str(row.get('duration_seconds', 86400))]
        with (out / f'console_{args.label}.log').open('wb') as log:
            result = subprocess.run(command, env=env, cwd=ROOT.parent, stdout=log, stderr=subprocess.STDOUT)
        runs = sorted(set((ROOT / 'results').glob('normal_*')) - before)
        record.update(phase='finished' if result.returncode == 0 else 'failed', exit_code=result.returncode,
                      run_paths=[str(r) for r in runs], ended_wall=time.time())
        for run in runs:
            audit_args = [PYTHON, str(ROOT / 'tools/event_replay_audit.py'), str(run)]
            if row.get('duration_seconds', 86400) < 86400:
                audit_args += ['--expected-duration', str(row['duration_seconds'])]
            subprocess.run(audit_args, stdout=subprocess.DEVNULL, check=True)
    except Exception as error:
        record.update(phase='failed', error_type=type(error).__name__, error=str(error), ended_wall=time.time())
        raise
    finally:
        save(ledger, record)
    print(args.label, record['phase'], flush=True)


if __name__ == '__main__':
    main()