Batch 21 (20261027-A-bos-redo-21) rebuilt 40 of the 53 rejected Bos-qiao environments: hidden assertions that ran inside the candidate's process now run in a trusted parent that reads observations from a low-UID worker; gold bytes are unchanged. 9 were excluded for scope (ROS2, oversize, security core), 3 are blocked because the source requires an exec bit the platform does not freeze, 1 lacks requests/bs4 in trace6. Batch 18 (20261026-C-hwe-codegen-18) adds its last 34 of 134 tasks; the first 100 landed in 2f32624d. Claude reviewed 74/74 USABLE against current digests, canonical families, no ID or source overlap with main, plain public docs. Only the new task directories are taken; the stale pre-batch-20 copies of concur-release-capsule and resource-temp-link on the batch 21 branch and both branches' progress notes stay as main has them. Difficulty is unmeasured. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
293 lines
16 KiB
Python
293 lines
16 KiB
Python
"""Private independent sequence oracle; candidate code runs only in children."""
|
|
import base64
|
|
import copy
|
|
import hashlib
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import random
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
|
|
FILES = ['sequence.hpp', 'engine.cpp', 'protocol.cpp', 'main.cpp']
|
|
DOMAINS = {'reset':[(0,2)], 'append':[(0,2),(-2147483648,2147483647),(0,65535)],
|
|
'order':[(0,2),(0,1)], 'merge':[(0,2),(0,2),(0,2),(0,1)],
|
|
'item':[(0,2),(0,15)], 'range':[(0,2),(0,16),(0,16)],
|
|
'locate':[(0,2),(1,255)]}
|
|
SMOKE = b'append 0 1 10\nappend 0 4 40\nappend 1 2 20\nappend 1 3 30\nappend 1 9 90\nmerge 2 0 1 0\ninspect\n'
|
|
I64_MIN, I64_MAX = -9223372036854775808, 9223372036854775807
|
|
|
|
class Model:
|
|
def __init__(self):
|
|
self.banks = [[], [], []]
|
|
self.next_ticket = 1
|
|
def state(self):
|
|
return [self.next_ticket, copy.deepcopy(self.banks)]
|
|
def invoke(self, verb, a):
|
|
if verb == 'inspect':
|
|
return None
|
|
bank_positions = range(3) if verb == 'merge' else [0]
|
|
if any(not 0 <= a[p] <= 2 for p in bank_positions): return [1, []]
|
|
if any(not low <= value <= high for value,(low,high) in zip(a,DOMAINS[verb])): return [2, []]
|
|
bank = self.banks[a[0]]
|
|
if verb == 'reset':
|
|
count = len(bank)
|
|
bank.clear()
|
|
return [0,[count]]
|
|
if verb == 'append':
|
|
if len(bank) == 16: return [3,[]]
|
|
if self.next_ticket > 255: return [6,[]]
|
|
bank.append([a[1],a[2],self.next_ticket])
|
|
self.next_ticket += 1
|
|
return [0,[len(bank)]]
|
|
if verb == 'order':
|
|
indices = sorted(range(len(bank)),key=lambda n: bank[n][0],reverse=bool(a[1]))
|
|
self.banks[a[0]] = [bank[n] for n in indices]
|
|
return [0,indices]
|
|
if verb == 'merge':
|
|
left,right = self.banks[a[1]],self.banks[a[2]]
|
|
if any((rows[i][0] > rows[i+1][0] if a[3] == 0 else rows[i][0] < rows[i+1][0]) for rows in (left,right) for i in range(len(rows)-1)): return [4,[]]
|
|
if len(left)+len(right)>16: return [3,[]]
|
|
self.banks[a[0]] = copy.deepcopy(sorted(left+right,key=lambda row: row[0],reverse=bool(a[3])))
|
|
return [0,[len(left)+len(right)]]
|
|
if verb == 'item':
|
|
if a[1]>=len(bank): return [5,[]]
|
|
return [0,bank[a[1]][:]]
|
|
if verb == 'range':
|
|
offset,count = a[1:]
|
|
if offset+count>len(bank): return [5,[]]
|
|
rows = bank[offset:offset+count]
|
|
return [0,[count,sum(r[0] for r in rows),min((r[0] for r in rows),default=0),max((r[0] for r in rows),default=0),sum(r[1] for r in rows)]]
|
|
indices = [i for i,row in enumerate(bank) if row[2]==a[1]]
|
|
return [0,indices] if indices else [5,[]]
|
|
|
|
def reply_bytes(reply):
|
|
code,values=reply
|
|
return (' '.join(map(str,[code,len(values),*values]))+'\n').encode()
|
|
|
|
def state_bytes(model):
|
|
fields=['S',str(model.next_ticket)]
|
|
for bank in model.banks:
|
|
fields.append(str(len(bank)))
|
|
fields.extend(str(value) for row in bank for value in row)
|
|
return (' '.join(fields)+'\n').encode()
|
|
|
|
def cli(model, raw, coverage=None):
|
|
output=[]
|
|
lines=raw.split(b'\n')
|
|
if lines[-1:]==[b'']: lines.pop()
|
|
if not raw: lines=[]
|
|
for index,line in enumerate(lines):
|
|
if index==1024:
|
|
output.append(reply_bytes([8,[]]));break
|
|
parts=re.split(rb'[ \t\r]+',line.strip(b' \t\r'))
|
|
good=bool(line) and len(line)<=256 and all(0<byte<128 for byte in line)
|
|
verb=parts[0].decode('ascii',errors='replace')
|
|
arity=0 if verb=='inspect' else len(DOMAINS.get(verb,[]))
|
|
good=good and (verb=='inspect' or verb in DOMAINS) and len(parts)==arity+1
|
|
args=[]
|
|
if good:
|
|
for word in parts[1:]:
|
|
if not re.fullmatch(rb'-?[0-9]+',word):good=False;break
|
|
number=int(word)
|
|
if not I64_MIN<=number<=I64_MAX:good=False;break
|
|
args.append(number)
|
|
if not good:
|
|
output.append(reply_bytes([7,[]]));continue
|
|
before=model.state()
|
|
result=model.invoke(verb,args)
|
|
if result is None: output.append(state_bytes(model))
|
|
else:
|
|
if result[0]: assert model.state()==before
|
|
if coverage is not None: coverage.setdefault(verb,set()).add(result[0])
|
|
output.append(reply_bytes(result))
|
|
return b''.join(output)
|
|
|
|
def build_scenes():
|
|
models=[Model(),Model()]; commands=[]; expected=[]; direct={}; cli_codes={}; endpoints={}; cli_endpoints={}; failures=0; api_calls=0; cli_calls=0
|
|
def new(slot=0):
|
|
models[slot]=Model();commands.append('N '+str(slot));expected.append(state_bytes(models[slot]))
|
|
def api(verb,*args,slot=0):
|
|
nonlocal failures,api_calls
|
|
before=models[slot].state();result=models[slot].invoke(verb,list(args));api_calls+=1
|
|
commands.append('A %d %s%s'%(slot,verb,'' if not args else ' '+' '.join(map(str,args))))
|
|
if result is not None:
|
|
expected.append(reply_bytes(result));direct.setdefault(verb,set()).add(result[0])
|
|
if result[0]: assert before==models[slot].state();failures+=1
|
|
else:
|
|
for p,value in enumerate(args): endpoints[(verb,p,value)]=True
|
|
expected.append(state_bytes(models[slot]));return result
|
|
def entry(raw,slot=0):
|
|
nonlocal cli_calls
|
|
answer=cli(models[slot],raw,cli_codes);cli_calls+=1
|
|
commands.append('C %d %s'%(slot,raw.hex() or '-'))
|
|
expected.append(('C 0 %d %s\n'%(len(answer),answer.hex())).encode());expected.append(state_bytes(models[slot]))
|
|
def call(mode,verb,args):
|
|
if mode=='api':return api(verb,*args)
|
|
before=copy.deepcopy(models[0]);result=before.invoke(verb,list(args))
|
|
entry((' '.join([verb,*map(str,args)])+'\n').encode())
|
|
if result is not None and result[0]==0:
|
|
for p,value in enumerate(args): cli_endpoints[(verb,p,value)]=True
|
|
return result
|
|
def seed(mode,verb,p,value):
|
|
new();args={'reset':[0],'append':[0,1,7],'order':[0,0],'merge':[2,0,1,0],'item':[0,0],'range':[0,0,0],'locate':[0,1]}[verb][:];args[p]=value
|
|
if verb=='merge':
|
|
for bank in range(3):
|
|
for n in range(8):api('append',bank,n-4,20-n)
|
|
for bank in range(3):api('order',bank,args[3])
|
|
elif verb in ('item','range','order'):
|
|
for n in range(16):api('append',args[0],n-8,30-n)
|
|
if verb=='range':
|
|
if p==1:args[2]=0
|
|
if p==2:args[1]=0
|
|
elif verb=='locate':
|
|
ticket=args[1]
|
|
for n in range(1,ticket+1):
|
|
if n>1:api('reset',args[0])
|
|
api('append',args[0],n,256-n)
|
|
else:api('append',args[0],12,55)
|
|
result=call(mode,verb,args);assert result[0]==0,(mode,verb,p,value,result)
|
|
for mode in ('api','cli'):
|
|
for verb,domains in DOMAINS.items():
|
|
for p,(low,high) in enumerate(domains):
|
|
for value in (low,high):seed(mode,verb,p,value)
|
|
for verb,domains in DOMAINS.items():
|
|
for p,(low,high) in enumerate(domains):
|
|
for value in sorted(set([low-1,high+1,I64_MIN,I64_MAX])):
|
|
new();api('append',0,22,8);api('append',2,33,9)
|
|
args={'reset':[0],'append':[0,1,7],'order':[0,0],'merge':[2,0,1,0],'item':[0,0],'range':[0,0,0],'locate':[0,1]}[verb][:];args[p]=value
|
|
assert api(verb,*args)[0]!=0
|
|
entry((' '.join([verb,*map(str,args)])+'\n').encode())
|
|
# Full, unsorted, absent, exhausted and precedence combinations on nonempty backgrounds.
|
|
for mode in ('api','cli'):
|
|
new();api('append',2,88,99)
|
|
for n in range(16):api('append',0,n,16-n)
|
|
call(mode,'append',[0,0,0]);call(mode,'merge',[2,0,0,0]);call(mode,'item',[1,0]);call(mode,'range',[0,16,1]);call(mode,'locate',[0,255])
|
|
api('reset',0);api('append',0,2,3);api('append',0,1,4);call(mode,'merge',[2,0,1,0])
|
|
new();api('append',2,7,8)
|
|
while models[0].next_ticket<=255:
|
|
api('reset',0);api('append',0,7,8)
|
|
call(mode,'append',[0,0,0]);call(mode,'append',[0,I64_MAX,0]);
|
|
# Multi-condition priorities, empty ordering, and monotone capacity projections.
|
|
for mode in ('api','cli'):
|
|
new();call(mode,'order',[0,0]);call(mode,'order',[0,1]);call(mode,'merge',[2,0,1,0])
|
|
api('append',2,8,9)
|
|
for n in range(255):
|
|
api('reset',0)
|
|
if models[0].next_ticket<=255:api('append',0,2,3)
|
|
# Reconstitute a full bank without consuming another ticket.
|
|
if not models[0].banks[0]:api('merge',0,2,2,0)
|
|
while len(models[0].banks[0])<16:api('merge',0,0,0,0)
|
|
assert call(mode,'append',[0,0,0])[0]==3
|
|
assert call(mode,'append',[0,I64_MAX,0])[0]==2
|
|
assert call(mode,'merge',[-1,0,0,2])[0]==1
|
|
assert call(mode,'merge',[2,0,0,2])[0]==2
|
|
new()
|
|
for n in range(16):api('append',0,16-n,n)
|
|
api('append',2,8,9)
|
|
assert call(mode,'merge',[2,0,0,0])[0]==4
|
|
call(mode,'order',[0,1]);call(mode,'order',[0,1])
|
|
# Stable equal keys, both directions, alias, self merge, all record fields and returned-copy independence.
|
|
new();new(1)
|
|
for slot in (0,1):
|
|
for key,payload in [(2,99),(1,12),(2,4),(1,8),(2,0),(1,0)]:api('append',0,key+slot,payload,slot=slot)
|
|
api('order',0,0,slot=slot);api('order',0,1,slot=slot);api('inspect',slot=slot)
|
|
commands.append('V '+str(slot));expected.append(state_bytes(models[slot]))
|
|
api('range',0,0,6,slot=slot);api('range',0,6,0,slot=slot)
|
|
api('order',0,0,slot=slot);api('merge',0,0,0,0,slot=slot);api('locate',0,1,slot=slot)
|
|
for n in range(12):api('item',0,n,slot=slot)
|
|
new();new(1)
|
|
api('append',0,11,44);api('append',0,22,55,slot=1)
|
|
api('inspect');api('inspect',slot=1)
|
|
entry(b'append 0 0 0\ninspect\n',slot=1)
|
|
api('item',0,0);api('item',0,1,slot=1)
|
|
api('reset',0);api('inspect',slot=1);api('inspect')
|
|
# zero payload after a nonzero record, zero-valued keys, and both minimum/maximum sums.
|
|
for key in (-2147483648,2147483647):
|
|
new()
|
|
for n in range(16):api('append',0,key,0 if n else 65535)
|
|
api('range',0,0,16)
|
|
# CLI exact arity, each numeric position malformed/positive-negative overflow and mixed mutations.
|
|
new();api('append',0,5,6);api('append',2,9,10)
|
|
for verb,domains in DOMAINS.items():
|
|
args={'reset':[0],'append':[0,1,7],'order':[0,0],'merge':[2,0,1,0],'item':[0,0],'range':[0,0,0],'locate':[0,1]}[verb]
|
|
base=' '.join([verb,*map(str,args)])
|
|
entry((verb+'\n'+base+' 0\n').encode())
|
|
for p in range(len(args)):
|
|
for bad in ('x','+1','-','--1','1x','1.0','0x1','1\v0','9223372036854775808','-9223372036854775809','9'*80,'-'+'9'*80):
|
|
words=list(map(str,args));words[p]=bad;before=models[0].state();entry((' '.join([verb,*words])+'\n').encode());assert before==models[0].state()
|
|
entry(b'inspect 0\ninspect\n\nunknown\nappend 0 00 -0\nrange\t0\r0 1\nitem 0 0')
|
|
entry(b'\0\n\xff\n'+b'x'*256+b'\n'+b'x'*257+b'\n'+b' '*249+b'inspect\n'+b' '*250+b'inspect\n')
|
|
# 1024th physical line mutates caller-owned Engine; later commands cannot execute.
|
|
prefix=(b'\nunknown\nappend 7 0 0\n')*341
|
|
assert len(prefix.splitlines())==1023
|
|
mixed=prefix+b'append 0 77 55\nreset 0\nappend 0 88 66\n'
|
|
before=len(models[0].banks[0]);entry(mixed);assert len(models[0].banks[0])==before+1
|
|
api('item',0,len(models[0].banks[0])-1);api('inspect');entry(b'');entry(b'reset 2\ninspect\n');entry(b'append 2 0 0\ninspect')
|
|
# Seeded broad compositions retain repeated keys, direction errors and alias transitions.
|
|
rng=random.Random(189)
|
|
for round_number in range(12):
|
|
new(round_number%2);slot=round_number%2
|
|
for n in range(120):
|
|
verb=rng.choice(list(DOMAINS));args=[]
|
|
for p,(low,high) in enumerate(DOMAINS[verb]):
|
|
if verb=='append' and p==1:args.append(rng.randint(-4,4))
|
|
elif verb=='append' and p==2:args.append(rng.randint(0,30))
|
|
else:args.append(rng.choice([low,high,rng.randint(low,high)]))
|
|
api(verb,*args,slot=slot)
|
|
expected_codes={'reset':{0,1},'append':{0,1,2,3,6},'order':{0,1,2},'merge':{0,1,2,3,4},'item':{0,1,2,5},'range':{0,1,2,5},'locate':{0,1,2,5}}
|
|
assert direct==expected_codes,(direct,expected_codes)
|
|
assert cli_codes==expected_codes,(cli_codes,expected_codes)
|
|
for target in (endpoints,cli_endpoints):
|
|
for verb,domains in DOMAINS.items():
|
|
for p,ends in enumerate(domains):
|
|
assert all((verb,p,value) in target for value in ends),(verb,p,ends)
|
|
raw=('\n'.join(commands)+'\n').encode();want=b''.join(expected)
|
|
app_limit=prefix+b'append 0 77 55\nreset 0\nappend 0 88 66\n'
|
|
scenes=[('raw',raw,want),('smoke',SMOKE,cli(Model(),SMOKE)),('empty',b'',b''),('limit',app_limit,cli(Model(),app_limit))]
|
|
coverage={'api_calls':api_calls,'cli_calls':cli_calls,'failure_immutability_guards':failures,'parameters':sum(map(len,DOMAINS.values())),'api_codes':{k:sorted(v) for k,v in direct.items()},'cli_codes':{k:sorted(v) for k,v in cli_codes.items()},'endpoint_guards':sum(2*len(v) for v in DOMAINS.values()),'commands':len(commands)}
|
|
return scenes,coverage
|
|
|
|
def signature(raw):return [len(raw),hashlib.sha256(raw).hexdigest()[:16]]
|
|
|
|
def main(candidate, capture=None):
|
|
candidate=Path(candidate).resolve();grader=Path(__file__).resolve().parent
|
|
scratch=Path(tempfile.mkdtemp(prefix='sequence-',dir=Path.cwd()))
|
|
source={name:(candidate/name).read_bytes() for name in FILES}
|
|
source['observer.cc']=(grader/'observer.cc').read_bytes()
|
|
for name,raw in source.items():(scratch/name).write_bytes(raw)
|
|
scenes,coverage=build_scenes()
|
|
os.environ.setdefault('ORDER_GRADER_HINT',str(grader/'check.py'))
|
|
cwd=str(scratch);records=[];full=[]
|
|
observed=scratch/'observer';app=scratch/'app'
|
|
compilers=[('build_raw',['c++','-std=c++17','-O2','-I.', 'engine.cpp','protocol.cpp','observer.cc','-o',str(observed)]),('build_app',['c++','-std=c++17','-O2','-I.','engine.cpp','protocol.cpp','main.cpp','-o',str(app)])]
|
|
# All trusted filesystem access ends here, before the first compiler.
|
|
def process(name,argv,raw,expected,build=False):
|
|
timed=False;child=subprocess.Popen(argv,cwd=cwd,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
|
|
try:out,err=child.communicate(raw,timeout=15)
|
|
except subprocess.TimeoutExpired:
|
|
timed=True;child.kill();out,err=child.communicate()
|
|
reasons=[]
|
|
if timed:reasons.append('timeout')
|
|
if child.returncode!=0:reasons.append('exit')
|
|
if not build and out!=expected:reasons.append('stdout')
|
|
if err and not build:reasons.append('stderr')
|
|
row=[name,child.pid,argv,cwd,child.returncode,timed,signature(raw),signature(expected),signature(out),signature(err),reasons]
|
|
records.append(row)
|
|
if capture is not None:full.append({'metadata':row,'stdin':base64.b64encode(raw).decode(),'expected':base64.b64encode(expected).decode(),'stdout':base64.b64encode(out).decode(),'stderr':base64.b64encode(err).decode()})
|
|
return not reasons
|
|
okay=True
|
|
for name,argv in compilers:okay=process(name,argv,b'',b'',True) and okay
|
|
if okay:
|
|
for name,raw,expected in scenes:okay=process(name,[str(observed if name=='raw' else app)],raw,expected) and okay
|
|
compact=json.dumps({'v':1,'fields':['scene','pid','argv','cwd','exit','timeout','stdin','expected','stdout','stderr','reasons'],'records':records},separators=(',',':'))
|
|
assert len(compact.encode())<3900,len(compact)
|
|
sys.stderr.write(compact+'\n')
|
|
if capture is not None:capture.update({'records':full,'coverage':coverage,'metadata_payload_bytes':len(compact.encode())})
|
|
print('PASS' if okay else 'FAIL behavior')
|
|
return 0 if okay else 1
|
|
|
|
if __name__=='__main__':sys.exit(main(sys.argv[1]))
|