amos 913d3c367f Add the usable task catalog and admit batch 6 tasks
All 161 task packages, including the 21 batch 6 C++17 tasks that passed
gates 1/2, are now in Git. rollout.catalog builds docs/task-catalog.{json,md}
from the task packages, a fresh trace5 calibration (128/128 PASS), every
verified controller receipt on the current task digest, documented holds
and digest-bound difficulty reviews. 123 tasks are usable (6 HARD),
5 are on hold and 33 still need a subprocess-only grader.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-18 17:43:15 +08:00

472 lines
21 KiB
Python

"""Private specification oracle. Candidate code runs only in the observation child."""
import copy
import json
from pathlib import Path
import random
import re
import subprocess
import sys
import tempfile
WS = ' \t\r\v\f'
CANDIDATES = ['conf_lex.cpp', 'conf_compile.cpp', 'module_session.cpp', 'module_batch.cpp']
def canonical(raw):
if not re.fullmatch(r'[A-Za-z0-9_-]{1,64}', raw, flags=re.ASCII):
raise ValueError('module')
return raw.replace('-', '_')
def lex(text):
if len(text) > 65536 or any(ord(c) > 127 for c in text):
raise ValueError('text')
rows = []
assembled = ''
waiting = False
for physical in text.split('\n'):
if physical.endswith('\\'):
assembled += physical[:-1] + ' '
waiting = True
else:
logical = (assembled + physical).strip(WS)
assembled = ''
waiting = False
if logical and not logical.startswith('#'):
rows.append(re.split(r'[ \t\r\v\f]+', logical))
if waiting:
raise ValueError('continuation')
return rows
def compile_config(directories, available):
if len(directories) > 5 or len(available) > 256:
raise ValueError('capacity')
available = [canonical(name) for name in available]
if len(set(available)) != len(available):
raise ValueError('duplicate module')
all_files = sum(len(directory) for directory in directories)
all_bytes = sum(len(text) for directory in directories for _, text in directory)
if all_files > 128 or all_bytes > 262144:
raise ValueError('aggregate')
selected = {}
for directory in directories:
if len(directory) > 64 or len({name for name, _ in directory}) != len(directory):
raise ValueError('directory')
for name, text in directory:
if not 1 <= len(name) <= 128 or not re.fullmatch(r'[A-Za-z0-9_.-]*\.conf', name):
raise ValueError('filename')
if len(text) > 65536 or any(ord(c) > 127 for c in text):
raise ValueError('text domain')
if name not in selected:
selected[name] = text
black = set()
options = {}
dependencies = {}
for filename in sorted(selected):
for row in lex(selected[filename]):
if len(row) < 2:
raise ValueError('directive')
command, module, *tail = row
module = canonical(module)
if command == 'blacklist':
if tail:
raise ValueError('blacklist syntax')
black.add(module)
elif command == 'options':
if not tail or any(not re.fullmatch(r'[A-Za-z0-9_.,=:+/-]+', item) for item in tail):
raise ValueError('option syntax')
options.setdefault(module, []).extend(tail)
elif command == 'softdep':
if module in dependencies or not tail:
raise ValueError('duplicate softdep')
parts = {}
side = None
for token in tail:
if token in ('pre:', 'post:'):
if token in parts or (token == 'pre:' and 'post:' in parts):
raise ValueError('section order')
side = token
parts[side] = []
else:
if side is None:
raise ValueError('section missing')
parts[side].append(canonical(token))
if not parts:
raise ValueError('sections')
dependencies[module] = (parts.get('pre:', []), parts.get('post:', []))
else:
raise ValueError('unsupported')
return [sorted(available), sorted(selected), sorted(black),
[[name, values] for name, values in sorted(options.items())],
[[name, pre, post] for name, (pre, post) in sorted(dependencies.items())]]
EMPTY_CONFIG = [[], [], [], [], []]
class Session:
"""Build an event script recursively; apply publication separately on each tick."""
def __init__(self, config):
self.config = copy.deepcopy(config)
self.reset()
def reset(self):
self.committed = []
self.skipped = []
self.missing = set()
self.accepted = self.suppressed = self.failed = self.cancelled = 0
self.discard()
def discard(self):
self.events = []
self.staged = []
self.pending = set()
self.busy = False
def snapshot(self):
return copy.deepcopy([self.busy, self.committed, self.staged, self.skipped,
sorted(self.missing), sorted(self.pending), self.accepted,
self.suppressed, self.failed, self.cancelled])
def begin(self, raw, alias):
if self.busy:
return 3
try:
name = canonical(raw)
if name not in self.config[0]:
raise ValueError('requested missing')
except ValueError:
return 1
self.discard()
self.busy = True
if alias and name in self.config[2]:
self.events = [(6, name)]
return 0
available = set(self.config[0])
loaded = {item[0] for item in self.committed}
active = set()
dependencies = {n: (pre, post) for n, pre, post in self.config[4]}
class Cycle(Exception):
pass
def visit(module):
if module not in available:
self.events.append((4, module))
return
if module in active:
self.events.append((7, module))
raise Cycle()
if module in loaded:
self.events.append((5, module))
return
active.add(module)
self.events.append((1, module))
pre, post = dependencies.get(module, ([], []))
for dependency in pre:
visit(dependency)
self.events.append((2, module))
loaded.add(module)
for dependency in post:
visit(dependency)
self.events.append((3, module))
active.remove(module)
try:
visit(name)
except Cycle:
pass
return 0
def tick(self):
if not self.busy:
return 4, 0, ''
kind, name = self.events.pop(0)
if kind == 6:
self.skipped.append(name)
self.suppressed += 1
self.discard()
elif kind == 7:
self.failed += 1
self.discard()
return 2, kind, name
elif kind == 4:
self.pending.add(name)
elif kind == 2:
options = dict(self.config[3])
self.staged.append([name, options.get(name, [])[:]])
if self.busy and not self.events:
self.committed.extend(self.staged)
self.missing.update(self.pending)
self.accepted += 1
self.discard()
return 0, kind, name
def cancel(self):
if self.busy:
self.cancelled += 1
self.discard()
def batch(directories, available, requests):
error = 1
try:
if len(requests) > 256:
raise ValueError('request count')
names = {canonical(name) for name in available}
if any(canonical(raw) not in names for raw, _ in requests):
raise ValueError('requested unavailable')
config = compile_config(directories, available)
session = Session(config)
for raw, alias in requests:
if session.begin(raw, alias):
raise ValueError('begin')
while session.busy:
error, _, _ = session.tick()
if error:
return [error, [], [], [], []]
return [0, session.committed, session.skipped, sorted(session.missing), config[1]]
except ValueError:
return [1, [], [], [], []]
class Cases:
def __init__(self):
self.commands = []
self.expected = []
self.labels = []
self.banks = [dict(dirs=[], available=[], session=Session(EMPTY_CONFIG), held=Session(EMPTY_CONFIG).snapshot()) for _ in range(3)]
self.selected = 0
@staticmethod
def hex(text):
return text.encode('latin1').hex() or '-'
def emit(self, command, result, label):
self.commands.append(command)
self.expected.append(result)
self.labels.append(label)
def config(self, directories, available, label='C07'):
bank = self.banks[self.selected]
bank['dirs'] = copy.deepcopy(directories)
bank['available'] = available[:]
rows = ['C %d %d' % (len(directories), len(available))]
for directory in directories:
rows.append('D %d' % len(directory))
rows.extend('F %s %s' % (self.hex(name), self.hex(text)) for name, text in directory)
rows.extend('A ' + self.hex(name) for name in available)
try:
config = compile_config(directories, available)
error = 0
bank['session'] = Session(config)
except ValueError:
config, error = copy.deepcopy(EMPTY_CONFIG), 1
self.emit('\n'.join(rows), ['C', error, config, True], label)
def command(self, op, *args, label='C30'):
bank = self.banks[self.selected]
session = bank['session']
if op == 'G':
self.selected = args[0]
result = ['G', self.banks[self.selected]['session'].snapshot()]
wire = 'G %d' % args[0]
elif op == 'N':
try:
name, valid = canonical(args[0]), True
except ValueError:
name, valid = '', False
result, wire = ['N', valid, name, True], 'N ' + self.hex(args[0])
elif op == 'L':
try:
tokens, error = lex(args[0]), 0
except ValueError:
tokens, error = [], 1
result, wire = ['L', error, tokens, True], 'L ' + self.hex(args[0])
elif op == 'B':
error = session.begin(*args)
result = ['B', error, session.snapshot(), True]
wire = 'B %s %d' % (self.hex(args[0]), args[1])
elif op == 'T':
error, kind, name = session.tick()
result, wire = ['T', error, kind, name, session.snapshot()], 'T'
elif op == 'P':
requests = args[0]
result = ['P', *batch(bank['dirs'], bank['available'], requests), True]
wire = 'P %d\n%s' % (len(requests), '\n'.join('Q %s %d' % (self.hex(raw), flag) for raw, flag in requests))
else:
if op == 'R':
session.reset()
elif op == 'X':
session.cancel()
elif op == 'H':
bank['held'] = session.snapshot()
result, wire = [op, copy.deepcopy(bank['held']) if op == 'J' else session.snapshot()], op
self.emit(wire, result, label)
def drain(self, label='C27'):
while self.banks[self.selected]['session'].busy:
self.command('T', label=label)
self.command('T', label='C19')
def cases():
c = Cases()
rng = random.Random(20261017016)
# Public cancellation sequence, then independently selected hidden variants.
c.config([[('00-boot.conf', 'softdep core post: logger\n')]], ['core', 'logger'])
c.command('B', 'core', False, label='C18')
c.command('T', label='C24'); c.command('T', label='C25')
c.command('S', label='C27'); c.command('X', label='C28'); c.command('S', label='C28')
c.command('B', 'logger', False); c.drain()
for raw in ['', 'a', 'x-y_Z9', 'A' * 64, 'A' * 65, 'bad.name', '\x00', '\xff', 'x y', 'pre:']:
c.command('N', raw, label='C01')
for text in ['', '\n', ' #ignored\x00\n', 'a\\', 'a\\\n', 'a\\\nb', 'a\\ \n b',
'\t\v\f\ra\t b\r\n# x\\\noptions a wrong', 'x\x00y', 'a # literal',
'x\\\n\\\ny', 'x\xff', 'a' * 65536, 'a' * 65537]:
c.command('L', text, label='C08' if '\xff' in text or len(text) > 65536 else 'C09')
c.config([[('z.conf', 'options m z=3 z=3\n'), ('a.conf', 'options m k=1 k=2 same same\n')],
[('a.conf', 'unsupported ignored syntax\n'), ('b.conf', 'options m b=4\n')]], ['m'], label='C07')
c.command('P', [('m', False)], label='C14')
c.config([[('x.conf', 'options x-y a=1\noptions x_y a=2 a=2\nblacklist x-y\nblacklist x_y\nsoftdep x-y pre: post:\n')]], ['x-y'], label='C16')
c.command('P', [('x_y', True), ('x-y', True), ('x-y', False), ('x_y', False)], label='C13')
c.command('B', 'x-y', True, label='C20'); c.command('H'); c.command('X', label='C28'); c.command('J', label='C02')
c.command('B', 'x_y', True, label='C20'); c.drain('C20')
c.command('B', 'x-y', False, label='C13'); c.drain('C13')
c.command('B', 'x_y', False, label='C23'); c.drain('C23')
c.command('B', 'missing', False, label='C05'); c.command('B', 'bad.name', True, label='C05')
invalid_text = ['options m', 'blacklist m extra', 'BlackList m', 'unknown m', 'softdep m',
'softdep m x pre:', 'softdep m pre: pre:', 'softdep m post: pre:',
'softdep m post: post:', 'softdep m pre: bad.name', 'options m x#y',
'options m "x"', 'options m a\\', 'options m x\x00y', 'blacklist m\x00',
'softdep m pre:\nsoftdep m post:', 'softdep x-y pre:\nsoftdep x_y post:']
for text in invalid_text:
c.config([[('bad.conf', text)]], ['m'], label='C12' if not text.startswith('softdep') else 'C16')
c.command('P', [], label='C11')
for name in ['', 'a', '.conf', 'x/../a.conf', 'A' * 123 + '.conf', 'A' * 124 + '.conf', 'x\x00.conf', '\xff.conf']:
c.config([[(name, '#empty')]], ['m'], label='C04')
c.config([[('x.conf', '# top')], [('x.conf', '\xff')]], ['m'], label='C04')
c.config([[('x.conf', '# a'), ('x.conf', '# b')]], ['m'], label='C03')
c.config([[]] * 5, ['m'], label='C03'); c.config([[]] * 6, ['m'], label='C03')
c.config([], ['m'] * 2, label='C05'); c.config([], ['x-y', 'x_y'], label='C05')
c.config([], ['m%d' % i for i in range(256)], label='C05')
c.command('P', [('m0', False)] * 256, label='C31')
c.command('P', [('m0', False)] * 257, label='C31')
c.config([], ['m%d' % i for i in range(257)], label='C05')
for size in [64, 65]:
c.config([[('%03d.conf' % i, '# comment') for i in range(size)]], [], label='C03')
c.config([[('%03d.conf' % i, '#') for i in range(64)], [('%03d.conf' % i, '#') for i in range(64, 128)]], [], label='C03')
c.config([[('%03d.conf' % i, '#') for i in range(64)], [('%03d.conf' % i, '#') for i in range(64, 128)], [('129.conf', '#')]], [], label='C03')
c.config([[('x.conf', '#' + 'a' * 65535)]], [], label='C04')
c.config([[('x.conf', '#' + 'a' * 65536)]], [], label='C04')
for excess in [0, 1]:
c.config([[('%d.conf' % i, '#' + 'a' * 65535) for i in range(4)], [('last.conf', '#' if excess else '')]], [], label='C04')
# Active post-backedge occurs after a parent emit; all staged output must roll back.
text = 'options a z=1 z=2\nsoftdep a pre: missing post: b\nsoftdep b pre: c post: a\nsoftdep missing pre: a\nblacklist b\n'
c.config([[('graph.conf', text)]], ['a', 'b', 'c', 'stable'], label='C15')
c.command('B', 'stable', False); c.drain()
c.command('B', 'a', False); c.command('H')
c.drain('C22'); c.command('J', label='C02'); c.command('S', label='C29')
c.command('B', 'c', False); c.drain('C29')
c.command('P', [('stable', False), ('a', False)], label='C32')
c.command('P', [('stable', False)], label='C22')
# Missing dependencies do not recurse and dependency blacklist never suppresses.
c.config([[('graph.conf', 'blacklist b\nsoftdep a pre: gone b gone post: b tail\nsoftdep gone pre: a\n')]], ['a', 'b'], label='C21')
c.command('B', 'a', False); c.command('B', 'bad.name', True, label='C18'); c.drain('C26')
c.command('P', [('a', False), ('b', True), ('a', False)], label='C13')
# Every cancellation position, including before first action and after pending missing.
configs = [('softdep r pre: absent child post: end\noptions r x=1 x=1\n', ['r', 'child', 'end']),
('softdep r pre: child post: child\nsoftdep child pre: post:\n', ['r', 'child'])]
for text, available in configs:
baseline = Session(compile_config([[('x.conf', text)]], available))
baseline.begin('r', False)
length = len(baseline.events)
for cut in range(length + 1):
c.config([[('x.conf', text)]], available)
c.command('B', 'r', False)
for _ in range(cut): c.command('T', label='C25')
c.command('H', label='C30'); c.command('X', label='C28'); c.command('J', label='C02')
c.command('B', 'r', False); c.drain('C27'); c.command('R', label='C17')
# Distinct configurations and interleaved transactions cannot share state.
for bank in range(3):
c.command('G', bank, label='C02')
c.config([[('bank.conf', 'options shared bank=%d\n' % bank)]], ['shared'], label='C02')
c.command('B', 'shared', False); c.command('T'); c.command('H')
for bank in [1, 0, 2]:
c.command('G', bank, label='C02'); c.drain('C02'); c.command('J', label='C02')
c.command('G', 0)
for trial in range(60):
names = ['t%d_m%d' % (trial, i) for i in range(rng.randrange(1, 13))]
lines = []
for name in names:
tokens = ['k=%d' % rng.randrange(4) for _ in range(rng.randrange(1, 5))]
lines.append('options %s %s' % (name, ' '.join(tokens)))
if rng.randrange(3) == 0: lines.append('blacklist ' + name)
pre = [rng.choice(names + ['missing_a', 'missing_b']) for _ in range(rng.randrange(4))]
post = [rng.choice(names + ['missing_a', 'missing_b']) for _ in range(rng.randrange(3))]
lines.append('softdep %s pre: %s post: %s' % (name, ' '.join(pre), ' '.join(post)))
c.config([[('zz.conf', '\n'.join(lines)), ('aa.conf', '# ignored\n')]], names, label='C15')
requests = [(rng.choice(names), bool(rng.randrange(2))) for _ in range(10)]
c.command('P', requests, label='C32')
for name, alias in requests[:4]:
c.command('B', name, alias)
if rng.randrange(3) == 0:
for _ in range(rng.randrange(3)): c.command('T', label='C25')
c.command('X', label='C28')
c.drain('C29')
# A full 256-node pre-chain verifies deterministic depth without timing assumptions.
names = ['node_%03d' % i for i in range(256)]
text = '\n'.join('softdep %s pre: %s post:' % (names[i], names[i + 1]) for i in range(255))
c.config([[('chain.conf', text)]], names, label='C33')
c.command('P', [(names[0], False)], label='C33')
c.command('B', names[0], False); c.drain('C33')
return c
def main():
matrix = cases()
context = json.loads((Path(__file__).resolve().parent / 'context.json').read_text())
scratch = Path(tempfile.mkdtemp(prefix='embedded-hard-module-', dir='/tmp'))
for name, text in context.items():
destination = scratch / name
destination.parent.mkdir(parents=True, exist_ok=True)
destination.write_text(text)
for name in CANDIDATES:
(scratch / name).write_bytes((Path(sys.argv[1]) / name).read_bytes())
result = subprocess.run(['g++', '-std=c++17', '-O2', '-Wall', '-Wextra', '-pedantic',
'observe.cpp', *CANDIDATES, '-o', 'observe'],
cwd=scratch, text=True, capture_output=True, timeout=30)
if result.returncode:
print('FAILED_CHECKS ["C34"] build failed: ' + result.stderr[-1000:].replace('\n', ' '))
return 1
wire = '\n'.join(matrix.commands) + '\n'
# shortcut: candidate-owned scratch is retained until container destruction or a
# separate trusted-local owner cleanup; never inspect shared scratch after execution.
result = subprocess.run([str(scratch / 'observe')], input=wire, cwd=scratch,
text=True, encoding='utf-8', errors='replace', capture_output=True, timeout=15)
if result.returncode:
print('FAILED_CHECKS ["C35"] candidate execution returned %s' % result.returncode)
return 1
actual = result.stdout.splitlines()
failed = set()
details = []
for index in range(max(len(actual), len(matrix.expected))):
label = matrix.labels[index] if index < len(matrix.labels) else 'C35'
wanted = matrix.expected[index] if index < len(matrix.expected) else '<end>'
try:
got = json.loads(actual[index]) if index < len(actual) else '<missing>'
except (ValueError, IndexError):
got = actual[index] if index < len(actual) else '<missing>'
if index >= len(actual) or index >= len(matrix.expected) or got != wanted:
failed.add(label)
if len(details) < 8:
details.append('%s observation=%d got=%r expected=%r' % (label, index, repr(got)[:300], repr(wanted)[:300]))
if failed:
print('FAILED_CHECKS ' + json.dumps(sorted(failed)))
for detail in details: print(detail)
return 1
print('PASS')
return 0
if __name__ == '__main__':
raise SystemExit(main())