amos 9d633e9e67 Batch 15 (20261023-C-hwe-scale-15): 320 HWE-derived repair tasks
One user-space repair task per eligible HWE debug-diag / compile-deploy base
ID: 320 admitted (C 218, C++ 97, build scripts 5), 1 skipped by the content
filter. Each ships a public spec with a check-to-basis table, at least two
defects with single-fix fixtures, a symptom-masking fixture and an alternative
correct implementation. Claude re-checked all 320: structure, the HWE quality
items and trace6 Docker calibration receipts against current digests
(320/320 USABLE). Difficulty is unmeasured. Known follow-up: 212 tasks use 120
ad-hoc family names; the next batch maps them to the canonical list.
The batch's 1,256-line progress log stays in its factory report and the
36-local branch batch15-hwe.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 01:55:56 +08:00

373 lines
23 KiB
Python

"""Independent public-grammar oracle; candidates execute only in supervised children."""
import base64,hashlib,json,math,os,re,secrets,subprocess,sys,tempfile,zlib
from pathlib import Path
SUPERVISOR = "import base64,ctypes,errno,hashlib,json,os,selectors,signal,subprocess,sys,time\nrequest=json.loads(sys.stdin.buffer.read())\nstarted=time.monotonic()\nerrors=[]\ntracked={}\nadopted=[]\nleader=None\nleader_start=None\nleader_rc=None\ntimed_out=False\nstreams={}\noutputs=[bytearray(),bytearray()]\nme=os.getpid()\ndef stat(pid):\n try:\n raw=open('/proc/%d/stat'%pid,'rb').read()\n tail=raw[raw.rfind(b')')+2:].split()\n return (int(tail[1]),int(tail[19]),tail[0].decode('ascii'),int(tail[2]))\n except (FileNotFoundError,ProcessLookupError):\n return None\n except Exception as exc:\n errors.append(['stat',pid,type(exc).__name__,str(exc)])\n return None\ndef table():\n found={}\n try:\n names=os.listdir('/proc')\n except Exception as exc:\n errors.append(['proc',type(exc).__name__,str(exc)])\n return found\n for name in names:\n if name.isascii() and name.isdecimal():\n item=stat(int(name))\n if item is not None:\n found[int(name)]=item\n return found\ndef closure(found):\n roots={me}\n for pid,start in tracked.items():\n item=found.get(pid)\n if item is not None and item[1]==start and item[2] not in ('Z','X'):\n roots.add(pid)\n changed=True\n while changed:\n changed=False\n for pid,item in found.items():\n if pid!=me and item[0] in roots and pid not in roots:\n roots.add(pid)\n changed=True\n for pid in roots-{me}:\n item=found.get(pid)\n if item is not None:\n tracked[pid]=item[1]\n return roots-{me}\ndef signal_one(pid,start,sig):\n item=stat(pid)\n if item is None or item[1]!=start or item[2] in ('Z','X'):\n return\n try:\n os.kill(pid,sig)\n except (ProcessLookupError,FileNotFoundError):\n pass\n except Exception as exc:\n errors.append(['signal',pid,type(exc).__name__,str(exc)])\ndef poll_then_reap():\n global leader_rc\n if leader is not None:\n result=leader.poll()\n if result is not None:\n leader_rc=leader.wait()\n # Do not reap an adopted process until Popen has collected its own leader.\n if leader is not None and leader_rc is None:\n return\n while True:\n try:\n pid,status=os.waitpid(-1,os.WNOHANG)\n if not pid:\n break\n adopted.append([pid,status])\n except ChildProcessError:\n break\n except Exception as exc:\n errors.append(['wait',type(exc).__name__,str(exc)])\n break\ndef reap_all():\n until=time.monotonic()+2.0\n while time.monotonic()<until:\n poll_then_reap()\n found=table()\n pids=closure(found)\n for pid in pids:\n signal_one(pid,tracked[pid],signal.SIGKILL)\n poll_then_reap()\n remaining=[pid for pid,start in tracked.items() if (pid in found and found[pid][1]==start)]\n if not remaining and (leader is None or leader_rc is not None):\n return\n time.sleep(.01)\ntry:\n if ctypes.CDLL(None,use_errno=True).prctl(36,1,0,0,0)!=0:\n raise OSError(ctypes.get_errno(),'subreaper')\n own_stat=stat(me)\n if own_stat is None:\n raise RuntimeError('supervisor stat disappeared')\n leader=subprocess.Popen(request['argv'],cwd=request.get('cwd'),stdin=subprocess.PIPE,\n stdout=subprocess.PIPE,stderr=subprocess.PIPE,start_new_session=True)\n first=stat(leader.pid)\n # Popen child may complete before first proc read; retain a reliable start\n # by using a launch barrier passed through the executable wrapper.\n if first is None:\n raise RuntimeError('leader stat unavailable')\n leader_start=first[1]\n tracked[leader.pid]=leader_start\n sel=selectors.DefaultSelector()\n for index,stream in enumerate((leader.stdout,leader.stderr)):\n os.set_blocking(stream.fileno(),False)\n sel.register(stream,selectors.EVENT_READ,index)\n streams[stream.fileno()]=stream\n data=memoryview(base64.b64decode(request['input']))\n os.set_blocking(leader.stdin.fileno(),False)\n sel.register(leader.stdin,selectors.EVENT_WRITE,2)\n deadline=started+request['deadline']\n while True:\n poll_then_reap()\n closure(table())\n if leader_rc is not None and not streams:\n break\n if time.monotonic()>=deadline:\n timed_out=True\n break\n for key,mask in sel.select(.01):\n if key.data==2:\n try:\n if data:\n written=os.write(key.fd,data[:65536])\n data=data[written:]\n if not data:\n sel.unregister(key.fileobj)\n key.fileobj.close()\n except BrokenPipeError:\n sel.unregister(key.fileobj)\n key.fileobj.close()\n else:\n chunk=os.read(key.fd,65536)\n if chunk:\n outputs[key.data].extend(chunk)\n else:\n sel.unregister(key.fileobj)\n streams.pop(key.fd,None)\n key.fileobj.close()\n reap_all()\n for key in list(sel.get_map().values()):\n if key.data==2:\n key.fileobj.close()\n continue\n while True:\n try:\n chunk=os.read(key.fd,65536)\n except BlockingIOError:\n break\n if not chunk:\n break\n outputs[key.data].extend(chunk)\n key.fileobj.close()\n sel.close()\nexcept BaseException as exc:\n errors.append(['execute',type(exc).__name__,str(exc)])\nfinally:\n reap_all()\n poll_then_reap()\n found=table()\n final=closure(found)\n tokens=[]\n for pid,start in sorted(tracked.items()):\n current=stat(pid)\n present=current is not None and current[1]==start\n tokens.append([pid,start,present])\n identity=[os.getuid(),os.getgid(),os.getgroups()]\n result={'supervisor_pid':me,'supervisor_start':own_stat[1] if 'own_stat' in globals() and own_stat else None,\n 'leader_pid':leader.pid if leader else None,'leader_start':leader_start,\n 'leader_rc':leader_rc,'leader_reaped':leader is not None and leader_rc is not None,\n 'timeout':timed_out,'controlled_rc':124 if timed_out else leader_rc,\n 'identity':identity,'elapsed':time.monotonic()-started,'exceptions':errors,\n 'descendants_absent':not any(row[2] for row in tokens) and not final,\n 'pg_absent':not any(item[3]==(leader.pid if leader else -1) and pid!=me for pid,item in found.items()),\n 'tokens':tokens,'adopted':adopted,'nonce':request['nonce'],'argv':request['argv'],\n 'cwd':request.get('cwd'),'input_sha256':hashlib.sha256(base64.b64decode(request['input'])).hexdigest()}\n for name,raw in zip(('stdout','stderr'),outputs):\n value=bytes(raw)\n result[name]=base64.b64encode(value).decode('ascii')\n result[name+'_length']=len(value)\n result[name+'_sha256']=hashlib.sha256(value).hexdigest()\n sys.stdout.write(json.dumps(result,separators=(',',':'))+'\\n')\n"
COMPILE_DEADLINE=20
RUN_DEADLINE=10
CLEAN_DEADLINE=5
ABSENCE_DEADLINE=5
CLEANUP="import shutil,sys; shutil.rmtree(sys.argv[1])"
ABSENCE="""import os,sys
try:
os.lstat(sys.argv[1])
except FileNotFoundError:
print(0)
else:
print(1)
"""
RECORDS=[]
def digest(raw):
return hashlib.sha256(raw).hexdigest()
def exact_int(value):
return type(value) is int
def validate(meta,request):
required={'supervisor_pid','supervisor_start','leader_pid','leader_start','leader_rc','leader_reaped',
'timeout','controlled_rc','identity','elapsed','exceptions','descendants_absent','pg_absent',
'tokens','adopted','nonce','argv','cwd','input_sha256',
'stdout','stderr','stdout_length','stderr_length','stdout_sha256','stderr_sha256'}
if not isinstance(meta,dict) or not required.issubset(meta):
raise ValueError('missing supervision metadata')
for name in ['supervisor_pid','supervisor_start','leader_pid','leader_start']:
if not exact_int(meta[name]) or meta[name]<=0:
raise ValueError('invalid process identity '+name)
if meta['leader_pid']==meta['supervisor_pid']:
raise ValueError('leader identity collision')
for name in ['leader_rc','controlled_rc']:
if not exact_int(meta[name]):
raise ValueError('invalid return code')
if type(meta['timeout']) is not bool or type(meta['leader_reaped']) is not bool:
raise ValueError('invalid lifecycle flags')
if meta['controlled_rc']!=(124 if meta['timeout'] else meta['leader_rc']):
raise ValueError('controlled return code conflict')
if type(meta['elapsed']) not in (int,float) or not math.isfinite(meta['elapsed']) or not 0<=meta['elapsed']<=request['deadline']+5:
raise ValueError('invalid elapsed')
identity=meta['identity']
if (not isinstance(identity,list) or len(identity)!=3 or not exact_int(identity[0]) or
not exact_int(identity[1]) or not isinstance(identity[2],list) or
not all(exact_int(x) for x in identity[2])):
raise ValueError('identity structure')
expected=[65534,65534,[]] if os.environ.get('ROLLOUT_GRADE_ISOLATION')=='uid65534' else [os.getuid(),os.getgid(),os.getgroups()]
if identity!=expected:
raise ValueError('execution identity mismatch')
if (meta['nonce']!=request['nonce'] or meta['argv']!=request['argv'] or
meta['cwd']!=request['cwd'] or meta['input_sha256']!=digest(base64.b64decode(request['input']))):
raise ValueError('request binding mismatch')
if not isinstance(meta['exceptions'],list) or meta['exceptions']:
raise ValueError('supervisor exceptions')
if meta['descendants_absent'] is not True or meta['pg_absent'] is not True or meta['leader_reaped'] is not True:
raise ValueError('process absence unconfirmed')
if not isinstance(meta['tokens'],list) or not isinstance(meta['adopted'],list):
raise ValueError('process collections')
for token in meta['tokens']:
if not isinstance(token,list) or len(token)!=3 or not all(exact_int(v) and v>0 for v in token[:2]) or token[2] is not False:
raise ValueError('tracked identity not absent')
if [meta['leader_pid'],meta['leader_start'],False] not in meta['tokens']:
raise ValueError('leader absence missing')
for row in meta['adopted']:
if not isinstance(row,list) or len(row)!=2 or not all(exact_int(v) for v in row) or row[0]<=0:
raise ValueError('invalid adopted wait')
result=[]
for name in ['stdout','stderr']:
if not exact_int(meta[name+'_length']) or meta[name+'_length']<0:
raise ValueError('invalid IO length')
if not isinstance(meta[name],str):
raise ValueError('invalid IO encoding')
raw=base64.b64decode(meta[name],validate=True)
if len(raw)!=meta[name+'_length'] or digest(raw)!=meta[name+'_sha256']:
raise ValueError('IO digest conflict')
result.append(raw)
return result
def execute(stage,argv,cwd=None,raw=b'',deadline=RUN_DEADLINE):
request={'argv':argv,'cwd':cwd,'input':base64.b64encode(raw).decode('ascii'),
'deadline':deadline,'nonce':secrets.token_hex(12)}
record={'stage':stage,'request':{k:v for k,v in request.items() if k!='input'},'input_length':len(raw),'input_sha256':digest(raw)}
RECORDS.append(record)
wrapper=subprocess.run([sys.executable,'-I','-c',SUPERVISOR],input=json.dumps(request).encode('ascii'),capture_output=True,timeout=deadline+8)
# Preserve actual wrapper rc and original wire facts before attempting to parse.
wire=wrapper.stdout
record.update(wrapper_rc=wrapper.returncode,wire_length=len(wire),wire_sha256=digest(wire),
wrapper_stderr_length=len(wrapper.stderr),wrapper_stderr_sha256=digest(wrapper.stderr))
if len(wire)<=512:
record['wire_base64']=base64.b64encode(wire).decode('ascii')
if wrapper.returncode!=0:
raise ValueError(stage+' supervisor nonzero')
meta=json.loads(wire)
record['metadata']={k:v for k,v in meta.items() if k not in ('stdout','stderr')}
stdout,stderr=validate(meta,request)
record['stderr_prefix_base64']=base64.b64encode(stderr[:256]).decode('ascii')
if len(stdout)<=65536:
record['stdout_zlib_base64']=base64.b64encode(zlib.compress(stdout,9)).decode('ascii')
if meta['timeout'] or meta['leader_rc']!=0 or meta['controlled_rc']!=0:
raise ValueError(stage+' controlled exit '+str(meta['controlled_rc']))
return stdout
# A separate parser translates public byte grammar to Python regex. This does not
# import candidate code and does not invoke the reference implementation.
def pattern_model(raw):
if len(raw)>128:
return 3,None,0
at=0
pieces=[]
terms=0
if raw.startswith(b'^'):
pieces.append(b'\\A')
at=1
def read_member(position):
if position>=len(raw):
raise ValueError('member missing')
byte=raw[position]
position+=1
if byte==92:
if position>=len(raw):
raise ValueError('quote missing')
byte=raw[position]
position+=1
if not 1<=byte<=127:
raise ValueError('non ASCII')
return byte,position
try:
while at<len(raw):
if raw[at]==36 and at+1==len(raw):
pieces.append(b'\\Z')
at+=1
break
byte=raw[at]
at+=1
if byte==46:
piece=b'[\\x00-\\xff]'
elif byte==91:
negate=at<len(raw) and raw[at]==94
if negate:
at+=1
members=set()
count=0
while at<len(raw) and raw[at]!=93:
first,at=read_member(at)
if at<len(raw) and raw[at]==45:
at+=1
if at>=len(raw) or raw[at]==93:
raise ValueError('range end')
last,at=read_member(at)
if last<first:
raise ValueError('range order')
members.update(range(first,last+1))
else:
members.add(first)
count+=1
if at>=len(raw) or not count:
raise ValueError('class closure')
at+=1
if negate:
members=set(range(256))-members
piece=b'['+b''.join(('\\x%02x'%x).encode('ascii') for x in sorted(members))+b']'
elif byte==92:
if at>=len(raw):
raise ValueError('escape')
byte=raw[at]
at+=1
if not 1<=byte<=127:
raise ValueError('escaped byte')
piece=re.escape(bytes([byte]))
else:
if byte in b'^$*+?]' or not 1<=byte<=127:
raise ValueError('atom')
piece=re.escape(bytes([byte]))
if at<len(raw) and raw[at] in b'*+?':
piece+=raw[at:at+1]
at+=1
pieces.append(piece)
terms+=1
return 0,re.compile(b''.join(pieces)),terms
except ValueError:
return 1,None,0
class Matrix:
def __init__(self):
self.commands=[]
self.expected=[]
self.labels=[]
self.bank=[]
self.generation=0
self.budget=-1
def observation(self,status=0):
return [status,len(self.bank),self.generation,len(self.bank),sum(x[4] for x in self.bank)]
def emit(self,command,expected,label):
self.commands.append(command)
self.expected.append(expected)
self.labels.append(label)
def replace(self,rules,label='C08'):
command='B '+str(len(rules))+''.join(' %d %d %s'%(i,p,raw.hex() or '-') for i,p,raw in rules)
invalid=(len(rules)>32 or any(not 1<=i<=1000000 or not -1000<=p<=1000 or len(raw)>128 for i,p,raw in rules) or
len({i for i,_,_ in rules})!=len(rules))
staged=[]
status=3 if invalid else 0
if not invalid:
for index,(identifier,priority,raw) in enumerate(rules):
status,compiled,terms=pattern_model(raw)
if status:
break
if self.budget==0:
status=2
break
if self.budget>0:
self.budget-=1
staged.append((identifier,priority,index,compiled,terms))
if not status:
self.bank=staged
self.generation+=1
self.emit(command,self.observation(status),label)
def match(self,raw,label='C09'):
if len(raw)>256:
row=[3,999,999,999,999,self.generation,len(self.bank),sum(x[4] for x in self.bank)]
else:
hits=[r for r in self.bank if r[3].search(raw) is not None]
selected=min(hits,key=lambda r:(-r[1],r[2])) if hits else (0,0,-1)
row=[0,len(hits),selected[0],selected[1],selected[2],self.generation,len(self.bank),sum(x[4] for x in self.bank)]
self.emit('M '+(raw.hex() or '-'),row,label)
def budget_set(self,n):
self.budget=n
self.emit('F '+str(n),[n],'C07')
def clear(self):
self.bank=[]
self.generation+=1
self.emit('C',self.observation(),'C02')
def query(self):
self.emit('S',self.observation(),'C02')
def cases():
import random
c=Matrix()
c.query()
c.match(b'')
c.replace([(11,4,b'^err'),(12,2,b'warn'),(13,8,b'fatal')])
for raw in [b'warning: disk full',b'err fatal warn',b'xerr',b'FATAL',b'']:
c.match(raw)
c.clear()
c.clear()
pats=[b'',b'^$',b'.',b'a?',b'a*',b'^ab+$',b'[a-c]+',b'[^x]*$',b'\\^\\$\\*',b'[\\]a]',b'[--0]',b'a|b(c){d}',b'^.+$',b'[a-a]',b'\\[\\]']
for i in range(0,len(pats),5):
c.replace([(100+j,7-j%2,p) for j,p in enumerate(pats[i:i+5])])
for raw in [b'',b'abc',b'xxxx',b'aaa',b'abbb',b'^$*',b']',b'-./0',b'a|b(c){d}',b'\0\n\xff']:
c.match(raw,'C04-C06')
c.replace([(31,1000,b'.*'),(32,1000,b'.+'),(33,-1000,b'')])
for raw in [b'',b'\xff'*256,bytes(range(256)),b'x'*257]:
c.match(raw)
for bad in [b'[',b'[]',b'[^]',b'[z-a]',b'[a-]',b'\\',b'**',b'a++',b'?a',b'x^a',b'x$a',b']',b'\0',b'\xff',b'\\\xff']:
c.replace([(1,0,b'^ok'),(2,1,bad),(3,2,b'fine')],'C05-C08')
c.match(b'ok')
c.replace([(1,0,b'a'),(1,1,b'b')],'C03')
c.replace([(0,0,b'a')],'C03')
c.replace([(1000001,0,b'a')],'C03')
c.replace([(9,1001,b'a')],'C03')
c.replace([(9,-1001,b'a')],'C03')
c.replace([(9,0,b'x'*129)],'C03')
c.replace([(i+1,0,b'a') for i in range(33)],'C03')
c.budget_set(0)
c.replace([(1,0,b'[')],'C07')
c.replace([])
c.replace([(1,0,b'')],'C07')
c.budget_set(2)
c.replace([(1,0,b'a'),(2,0,b'b'),(3,0,b'c')],'C07-C08')
c.query()
c.replace([(1,0,b'a')],'C07')
c.budget_set(2)
c.replace([(1,0,b'a'),(2,0,b'')])
c.replace([(1,0,b'b')],'C07')
c.match(b'a')
c.clear()
c.replace([(1,0,b'a')],'C07')
c.budget_set(-1)
c.replace([(i+1,i%5-2,b'x'*128 if i==0 else b'[^q]*') for i in range(32)])
c.match(b'x'*128)
c.match(b'q')
rng=random.Random(103301)
choices=[b'^a.*b$',b'[a-c]+',b'[^z]?a*',b'b.$',b'^$',b'.*',b'[0-9]+',b'\\+a?',b'warning',b'a?b+c*']
for cycle in range(10):
patterns=rng.sample(choices,rng.randrange(0,7))
c.replace([(700+j,rng.randrange(-5,6),p) for j,p in enumerate(patterns)])
for _ in range(4):
c.match(bytes(rng.choice(b'abcxyz019+\n\0') for _ in range(rng.randrange(15))))
if cycle%3==0:
c.budget_set(1)
c.replace([(91,1,b'a'),(92,2,b'b')])
c.budget_set(-1)
c.clear()
c.generation+=1
c.expected.append(c.observation())
c.labels.append('C02 EOF')
return c
def observations(raw):
if not raw.endswith(b'\n'):
raise ValueError('stdout final LF missing')
lines=raw[:-1].split(b'\n')
result=[]
for line in lines:
tokens=re.split(b'[ \t\r]+',line.strip(b' \t\r'))
row=[]
for value in tokens:
if re.fullmatch(b'[+-]?[0-9]+',value) is None:
raise ValueError('nondecimal stdout token')
negative=value.startswith(b'-')
digits=value.lstrip(b'+-').lstrip(b'0') or b'0'
if len(digits)>12:
raise ValueError('out of public numeric range')
row.append((-1 if negative else 1)*int(digits))
result.append(row)
return result
def main():
failure=[]
scratch=None
behavior_ok=False
cleanup_ok=False
absence_ok=False
try:
c=cases()
scratch=tempfile.mkdtemp(prefix='rule-programs-')
root=Path(scratch)
support=json.loads(Path(__file__).with_name('context.json').read_text())
for name,text in support.items():
(root/name).write_text(text)
(root/'engine.c').write_bytes((Path(sys.argv[1])/'engine.c').read_bytes())
# Every file and input is prepared before the first candidate-identity child.
raw=('\n'.join(c.commands)+'\n').encode('ascii')
stdout=execute('compiler',['gcc','-std=c11','-O2','-Wall','-Wextra','-Werror','driver.c','compiler.c','engine.c','-o','rule-demo'],scratch,deadline=COMPILE_DEADLINE)
stdout=execute('candidate',[str(root/'rule-demo')],scratch,raw,deadline=RUN_DEADLINE)
actual=observations(stdout)
if len(actual)!=len(c.expected):
raise ValueError('row count %d expected %d'%(len(actual),len(c.expected)))
for index,(seen,wanted) in enumerate(zip(actual,c.expected)):
if seen!=wanted:
raise ValueError('raw row %d %s got %s expected %s'%(index,c.labels[index],seen,wanted))
behavior_ok=True
except BaseException as exc:
failure.append(['main',type(exc).__name__,str(exc)])
finally:
if scratch is not None:
try:
execute('cleanup',[sys.executable,'-I','-c',CLEANUP,scratch],deadline=CLEAN_DEADLINE)
cleanup_ok=True
except BaseException as exc:
failure.append(['cleanup',type(exc).__name__,str(exc)])
try:
raw=execute('absence',[sys.executable,'-I','-c',ABSENCE,scratch],deadline=ABSENCE_DEADLINE)
if raw!=b'0\n':
raise ValueError('scratch still present')
absence_ok=True
except BaseException as exc:
failure.append(['absence',type(exc).__name__,str(exc)])
facts={'records':RECORDS,'exceptions':failure,'flags':[behavior_ok,cleanup_ok,absence_ok],'scratch':scratch}
packed=base64.b64encode(zlib.compress(json.dumps(facts,separators=(',',':')).encode(),9)).decode('ascii')
sys.stderr.write('NATIVE '+packed+'\n')
okay=behavior_ok and cleanup_ok and absence_ok and not failure
print('PASS' if okay else 'FAIL '+repr(failure))
return 0 if okay else 1
if __name__=='__main__':
sys.exit(main())