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

172 lines
19 KiB
Python

"""Independent command-port oracle and bounded candidate-identity execution."""
import base64,hashlib,json,math,os,random,subprocess,sys,tempfile,uuid,zlib
from pathlib import Path
SUPERVISOR = "import base64,ctypes,hashlib,json,os,selectors,signal,subprocess,sys,time\n\ndef descendants(table, root, tracked):\n roots={root}\n for pid,start in tracked:\n value=table.get(pid)\n if value and value[3]==start and value[2] not in ('Z','X'):\n roots.add(pid)\n found=set()\n changed=True\n while changed:\n changed=False\n for pid,value in table.items():\n if pid != root and value[0] in roots and pid not in roots:\n roots.add(pid);found.add((pid,value[3]));changed=True\n for pid,start in tracked:\n value=table.get(pid)\n if value and value[3]==start:\n found.add((pid,start))\n return found\n\ndef proc_table():\n table={}\n for name in os.listdir('/proc'):\n if not name.isdigit():continue\n try:\n raw=open('/proc/'+name+'/stat','rb').read()\n parts=raw[raw.rfind(b')')+2:].split()\n table[int(name)]=(int(parts[1]),int(parts[2]),parts[0].decode('ascii'),int(parts[19]))\n except (FileNotFoundError,ProcessLookupError):pass\n return table\n\ndef run(spec):\n start=time.monotonic();root=os.getpid();tracked=set();adopted=[];errors=[]\n proc=None;leader_start=None;leader_rc=None;timed_out=False\n stdout=bytearray();stderr=bytearray();input_data=base64.b64decode(spec['stdin'])\n selector=selectors.DefaultSelector();offset=0;deadline=spec['deadline'];stop_at=None\n def discover():\n table=proc_table()\n tracked.update(descendants(table,root,tracked))\n return table\n def kill_owned(table):\n for pid,token in list(tracked):\n info=table.get(pid)\n if info and info[3]==token and info[2] not in ('Z','X'):\n try:\n raw=open('/proc/'+str(pid)+'/stat','rb').read()\n parts=raw[raw.rfind(b')')+2:].split()\n current_state=parts[0].decode('ascii')\n current_start=int(parts[19])\n if current_start!=token or current_state in ('Z','X'):\n continue\n os.kill(pid,signal.SIGKILL)\n except (FileNotFoundError,ProcessLookupError):pass\n except Exception as exc:errors.append('kill:'+type(exc).__name__+':'+str(exc))\n def reap(table):\n nonlocal leader_rc\n if proc is not None:\n leader_rc=proc.poll()\n for pid,token in list(tracked):\n if proc is not None and pid==proc.pid:continue\n info=table.get(pid)\n if info and info[3]==token and info[0]==root:\n try:\n got,status=os.waitpid(pid,os.WNOHANG)\n if got:adopted.append([got,token,status])\n except ChildProcessError:pass\n except Exception as exc:errors.append('reap:'+type(exc).__name__+':'+str(exc))\n def drain(wait):\n nonlocal offset\n for key,mask in selector.select(wait):\n stream,kind=key.fileobj,key.data\n try:\n if kind=='stdin':\n if offset < len(input_data):offset+=os.write(stream.fileno(),input_data[offset:offset+65536])\n if offset==len(input_data):selector.unregister(stream);stream.close()\n else:\n raw=os.read(stream.fileno(),65536)\n if raw:(stdout if kind=='stdout' else stderr).extend(raw)\n else:selector.unregister(stream);stream.close()\n except (BrokenPipeError,ConnectionResetError):\n selector.unregister(stream);stream.close()\n except BlockingIOError:pass\n try:\n libc=ctypes.CDLL(None,use_errno=True)\n if libc.prctl(36,1,0,0,0)!=0:raise OSError(ctypes.get_errno(),'subreaper')\n proc=subprocess.Popen(spec['argv'],cwd=spec['cwd'],stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,start_new_session=True)\n table=proc_table();leader_start=table[proc.pid][3];tracked.add((proc.pid,leader_start))\n for stream,kind in [(proc.stdin,'stdin'),(proc.stdout,'stdout'),(proc.stderr,'stderr')]:\n os.set_blocking(stream.fileno(),False);selector.register(stream,selectors.EVENT_WRITE if kind=='stdin' else selectors.EVENT_READ,kind)\n while True:\n table=discover();reap(table);now=time.monotonic()\n pipes_open=any(key.data in ('stdout','stderr') for key in selector.get_map().values())\n if stop_at is None and now-start>=deadline and (leader_rc is None or pipes_open):\n timed_out=True;stop_at=now+3\n if leader_rc is not None and not pipes_open and stop_at is None:stop_at=now+3\n if stop_at is not None:\n kill_owned(table)\n drain(0.01)\n table=discover();reap(table)\n remaining=[(pid,token) for pid,token in tracked if pid in table and table[pid][3]==token]\n if leader_rc is not None and not selector.get_map() and not remaining:break\n if stop_at is not None and time.monotonic()>=stop_at:\n if remaining:errors.append('descendants remain at recovery deadline')\n if selector.get_map():errors.append('pipes remain at recovery deadline')\n break\n except Exception as exc:\n errors.append('execute:'+type(exc).__name__+':'+str(exc))\n finally:\n recovery=time.monotonic()+3\n try:\n while proc is not None and time.monotonic()<recovery:\n table=discover();kill_owned(table);reap(table);drain(0.01)\n table=discover();reap(table)\n if leader_rc is not None and not any(pid in table and table[pid][3]==token for pid,token in tracked):break\n except Exception as exc:errors.append('finally:'+type(exc).__name__+':'+str(exc))\n for key in list(selector.get_map().values()):\n try:selector.unregister(key.fileobj);key.fileobj.close()\n except Exception as exc:errors.append('pipeclose:'+type(exc).__name__+':'+str(exc))\n selector.close()\n try:\n table=discover();reap(table);table=discover()\n remaining=sorted([pid,token] for pid,token in tracked if pid in table and table[pid][3]==token)\n group_remaining=sorted([pid,token] for pid,token in tracked if pid in table and table[pid][3]==token and proc is not None and table[pid][1]==proc.pid)\n supervisor_start=table[root][3]\n except Exception as exc:\n errors.append('finalfacts:'+type(exc).__name__+':'+str(exc));remaining=[[-1,-1]];group_remaining=[[-1,-1]];supervisor_start=0\n controlled=125 if errors else 124 if timed_out else leader_rc\n meta={'nonce':spec['nonce'],'phase':spec['phase'],'deadline':deadline,'argv':spec['argv'],\n 'uid':os.getuid(),'gid':os.getgid(),'groups':os.getgroups(),'supervisor_pid':root,'supervisor_start':supervisor_start,\n 'leader_pid':None if proc is None else proc.pid,'leader_start':leader_start,'leader_rc':leader_rc,\n 'leader_reaped':proc is not None and proc.returncode is not None,'controlled_rc':controlled,\n 'timeout':timed_out,'elapsed':time.monotonic()-start,'remaining':remaining,'pg_remaining':group_remaining,\n 'descendants_absent':not remaining,'pg_absent':not group_remaining,'adopted':adopted,'tracked':sorted([list(t) for t in tracked]),\n 'errors':errors,'stdin_offered_len':len(input_data),'stdin_written_len':offset,\n 'stdout_len':len(stdout),'stdout_sha256':hashlib.sha256(stdout).hexdigest(),\n 'stderr_len':len(stderr),'stderr_sha256':hashlib.sha256(stderr).hexdigest()}\n return {'meta':meta,'stdout':base64.b64encode(stdout).decode('ascii'),'stderr':base64.b64encode(stderr).decode('ascii')}\nif __name__=='__main__':\n result=run(json.loads(sys.stdin.buffer.read()))\n sys.stdout.write(json.dumps(result,separators=(',',':')))\n"
COMPILER_DEADLINE = 20
CANDIDATE_DEADLINE = 12
CLEANUP_DEADLINE = 5
ABSENCE_DEADLINE = 5
CLEANUP_CODE = 'import shutil,sys;shutil.rmtree(sys.argv[1])'
ABSENCE_CODE = "import os,sys\ntry: os.lstat(sys.argv[1])\nexcept FileNotFoundError: sys.exit(0)\nsys.exit(1)"
class Matrix:
def __init__(self):
self.commands=[];self.expected=[];self.labels=[]
self.reset(1,1)
def emit(self,command,value,label):
self.commands.append(command);self.expected.append(value);self.labels.append(label)
def reset(self,streams,children):
self.streams=streams;self.children=children
self.opens=self.closes=self.waits=self.failures=0
self.stream_peak=self.child_peak=0
self.emit('N %d %d'%(streams,children),[0],'C10')
def plan(self,payload=b'',chunk=16,fault=-1,ri=0,wi=0,exit=0,signal=0,fail=0):
self.payload=payload;self.fault=fault;self.exit=exit;self.signal=signal;self.fail=fail
self.emit('P %s %d %d %d %d %d %d %d %d'%(payload.hex() or '-',chunk,fault,ri,wi,exit,signal,fail,len(payload)),[0],'C09')
def run(self,limit=2048,tag=0):
seen=b'';status=0;exit=signal=0
if limit>2048:status=4
elif self.fail or not self.streams or not self.children:
status=1;self.failures+=1
else:
self.opens+=1;self.closes+=1;self.waits+=1
self.stream_peak=self.child_peak=1
seen=self.payload if self.fault<0 else self.payload[:self.fault]
exit=self.exit;signal=self.signal
status=2 if self.fault>=0 else 3 if exit or signal else 0
h=2166136261
for byte in seen:h=((h^byte)*16777619)&0xffffffff
stored=seen[:limit]
row=[status,status,len(seen),len(stored),h,exit,signal,int(len(seen)>len(stored)),stored.hex(),0,0,self.opens,self.closes,self.waits,self.failures,0,self.stream_peak,self.child_peak,0]
self.emit('R %d %d'%(limit,tag),row,'C01-C10')
def cases():
m=Matrix();r=random.Random(810024)
m.plan(b'hello\n',3);m.run(6,42);m.run(6,43)
for payload in [b'',b'\0',b'\xff',bytes(range(256)),b'x'*2048]:
for chunk in [1,2,97,128]:
m.reset(1,1);m.plan(payload,chunk,ri=2,wi=3)
for limit in [0,1,7,len(payload),2048,2049,4096]:m.run(limit,r.randrange(65536))
for payload in [b'',b'abcdef',bytes(range(256)),b'\0'*2048]:
for fault in sorted({0,len(payload)//2,len(payload)}):
m.reset(1,1);m.plan(payload,2,fault,2,2,exit=7)
m.run(4,90);m.plan(b'\0\xff',1);m.run(2,91)
for streams,children in [(0,0),(0,1),(1,0),(16,16)]:
m.reset(streams,children);m.plan(b'capacity');m.run(3,199)
for exit,signal in [(0,0),(1,0),(255,0),(0,1),(0,64)]:
m.reset(1,1);m.plan(b'child',128,wi=16,exit=exit,signal=signal);m.run(4,253)
m.reset(1,1);m.plan(b'fail',fail=1);m.run(2048,99);m.plan(b'recovery');m.run(2048,100)
for trial in range(90):
payload=bytes(r.randrange(256) for _ in range(r.randrange(2050)//2))
fault=r.choice([-1,-1,0,len(payload),r.randrange(len(payload)+1)])
exit=r.choice([0,0,17]);signal=0 if exit else r.choice([0,0,9])
m.reset(r.choice([1,16]),r.choice([1,16]))
m.plan(payload,r.randrange(1,129),fault,r.randrange(17),r.randrange(17),exit,signal)
m.run(r.choice([0,1,32,2048,2049]),r.randrange(65536));m.run(2048,r.randrange(65536))
m.reset(1,1);m.plan(bytes(range(256)),128,ri=16,wi=16)
for index in range(60):m.run(index%257,index)
return m
def exact(left,right):
if type(left) is not type(right):return False
if isinstance(left,list):return len(left)==len(right) and all(exact(a,b) for a,b in zip(left,right))
return left==right
def validate_meta(meta,spec):
required={'nonce','phase','deadline','argv','uid','gid','groups','supervisor_pid','supervisor_start','leader_pid','leader_start','leader_rc','leader_reaped','controlled_rc','timeout','elapsed','remaining','pg_remaining','descendants_absent','pg_absent','adopted','tracked','errors','stdin_offered_len','stdin_written_len','stdout_len','stdout_sha256','stderr_len','stderr_sha256'}
if type(meta) is not dict or set(meta)!=required:raise ValueError('metadata fields')
for name in ['nonce','phase','deadline','argv']:
if not exact(meta[name],spec[name]):raise ValueError('metadata binding '+name)
expected_uid=65534 if os.environ.get('ROLLOUT_GRADE_ISOLATION')=='uid65534' else os.getuid()
expected_gid=65534 if os.environ.get('ROLLOUT_GRADE_ISOLATION')=='uid65534' else os.getgid()
expected_groups=[] if os.environ.get('ROLLOUT_GRADE_ISOLATION')=='uid65534' else os.getgroups()
if not exact(meta['uid'],expected_uid) or not exact(meta['gid'],expected_gid) or not exact(meta['groups'],expected_groups):raise ValueError('identity')
for name in ['supervisor_pid','supervisor_start','leader_pid','leader_start']:
if type(meta[name]) is not int or meta[name]<=0:raise ValueError('positive integer '+name)
if meta['supervisor_pid']==meta['leader_pid']:raise ValueError('leader equals supervisor')
for name in ['leader_rc','controlled_rc']:
if type(meta[name]) is not int:raise ValueError('return code type')
if type(meta['timeout']) is not bool:raise ValueError('timeout type')
elapsed=meta['elapsed']
if type(elapsed) not in (int,float) or not math.isfinite(elapsed) or not 0<=elapsed<=spec['deadline']+7:raise ValueError('elapsed')
for name in ['leader_reaped','descendants_absent','pg_absent']:
if type(meta[name]) is not bool or not meta[name]:raise ValueError(name)
for name in ['remaining','pg_remaining','errors']:
if type(meta[name]) is not list or meta[name]:raise ValueError(name)
for name in ['stdout_len','stderr_len','stdin_offered_len','stdin_written_len']:
if type(meta[name]) is not int or meta[name]<0:raise ValueError('IO length')
if meta['stdin_offered_len']!=len(base64.b64decode(spec['stdin'])) or meta['stdin_written_len']>meta['stdin_offered_len']:raise ValueError('stdin lengths')
for name in ['stdout_sha256','stderr_sha256']:
value=meta[name]
if type(value) is not str or len(value)!=64 or any(c not in '0123456789abcdef' for c in value):raise ValueError('IO digest')
for name in ['tracked','adopted']:
if type(meta[name]) is not list:raise ValueError(name)
for token in meta[name]:
if type(token) is not list or len(token)!=(2 if name=='tracked' else 3) or any(type(x) is not int for x in token) or token[0]<=0 or token[1]<=0:raise ValueError(name+' token')
if [meta['leader_pid'],meta['leader_start']] not in meta['tracked']:raise ValueError('untracked leader')
expected_control=124 if meta['timeout'] else meta['leader_rc']
if meta['controlled_rc']!=expected_control:raise ValueError('return code consistency')
if meta['controlled_rc']!=0 or meta['leader_rc']!=0 or meta['timeout']:raise ValueError('execution rejected')
def execute(phase,argv,cwd,stdin,deadline,records):
spec={'phase':phase,'argv':argv,'cwd':str(cwd),'stdin':base64.b64encode(stdin).decode('ascii'),'deadline':deadline,'nonce':uuid.uuid4().hex}
item={'phase':phase,'wrapper_rc':None,'wire_len':None,'wire_sha256':None,'meta':None,'errors':[]}
records.append(item)
completed=subprocess.run([sys.executable,'-I','-c',SUPERVISOR],input=json.dumps(spec).encode(),capture_output=True)
# These facts precede parsing and remain available for malformed or absent wire.
item['wrapper_rc']=completed.returncode;item['wire_len']=len(completed.stdout);item['wire_sha256']=hashlib.sha256(completed.stdout).hexdigest()
item['wrapper_stderr_len']=len(completed.stderr);item['wrapper_stderr_sha256']=hashlib.sha256(completed.stderr).hexdigest()
if completed.returncode!=0:raise ValueError('supervisor nonzero '+phase)
wire=json.loads(completed.stdout)
if type(wire) is not dict or set(wire)!={'meta','stdout','stderr'}:raise ValueError('wire fields '+phase)
item['meta']=wire['meta']
stdout=base64.b64decode(wire['stdout'],validate=True);stderr=base64.b64decode(wire['stderr'],validate=True)
meta=wire['meta'];validate_meta(meta,spec)
for name,raw in [('stdout',stdout),('stderr',stderr)]:
if meta[name+'_len']!=len(raw) or meta[name+'_sha256']!=hashlib.sha256(raw).hexdigest():raise ValueError('IO binding '+phase)
return stdout,stderr
def main():
records=[];errors=[];success=False;cleaned=False;absent=False;scratch=None;rows=0
try:
matrix=cases();rows=len(matrix.expected)
context=json.loads((Path(__file__).resolve().parent/'context.json').read_text())
candidate=(Path(sys.argv[1])/'runner.c').read_bytes()
scratch=Path(tempfile.mkdtemp(prefix='resource-command-stream-'))
work=scratch/'work';work.mkdir();work.chmod(0o777)
for name,content in context.items():
target=work/name;target.parent.mkdir(parents=True,exist_ok=True);target.write_text(content)
for directory in work.rglob('*'):
if directory.is_dir():directory.chmod(0o777)
(work/'runner.c').write_bytes(candidate)
stdin=('\n'.join(matrix.commands)+'\n').encode('ascii')
# All candidate-tree reads/writes above finish before the first child.
os.environ['ROLLOUT_PRIVATE_CHECK']=str(Path(__file__).resolve())
execute('compiler',['gcc','-std=c11','-O2','-Wall','-Wextra','-pedantic','runner.c','command_port.c','wire.c','observe.c','-o','command-observe'],work,b'',COMPILER_DEADLINE,records)
stdout,stderr=execute('candidate',[str(work/'command-observe')],work,stdin,CANDIDATE_DEADLINE,records)
# stdout is a defined ASCII JSON protocol; stderr is arbitrary bytes.
observed=[json.loads(line) for line in stdout.decode('ascii').splitlines()]
if not exact(observed,matrix.expected):
mismatch=next((i for i,(a,b) in enumerate(zip(observed,matrix.expected)) if not exact(a,b)),min(len(observed),len(matrix.expected)))
raise ValueError('raw observation mismatch row '+str(mismatch)+' '+(matrix.labels[mismatch] if mismatch<len(matrix.labels) else 'extra'))
success=True
except Exception as exc:errors.append('main:'+type(exc).__name__+':'+str(exc))
finally:
if scratch is not None:
try:
execute('cleanup',[sys.executable,'-I','-c',CLEANUP_CODE,str(scratch)],'/tmp',b'',CLEANUP_DEADLINE,records)
cleaned=True
except Exception as exc:errors.append('cleanup:'+type(exc).__name__+':'+str(exc))
try:
execute('absence',[sys.executable,'-I','-c',ABSENCE_CODE,str(scratch)],'/tmp',b'',ABSENCE_DEADLINE,records)
absent=True
except Exception as exc:errors.append('absence:'+type(exc).__name__+':'+str(exc))
facts={'version':1,'scratch':None if scratch is None else str(scratch),'rows':rows,'success':success,'cleaned':cleaned,'absent':absent,'errors':errors,'phases':records}
terminal=base64.b85encode(zlib.compress(json.dumps(facts,separators=(',',':')).encode(),9)).decode('ascii')
sys.stderr.write('RCSTREAM_Z:'+terminal+'\n')
if success and cleaned and absent and not errors and len(records)==4 and all(not p['errors'] for p in records):
print('PASS');return 0
print('FAILED_CHECKS '+json.dumps(errors,separators=(',',':')));return 1
if __name__=='__main__':sys.exit(main())